Updates the disabled status of all registered containers.
771565
protected void updateStatus() {
        if (!plugins.isEmpty()) {
            boolean disabled = isDisabled();
            
            for (ElementPlugin container : plugins) {
                container.setDisabled(disabled);
            }
        }
    }
169600
def update(self, status=values.unset):
        
        return self._proxy.update(status=status, )
765042
def _UpdateForemanProcessStatus(self):
    """"""
    used_memory = self._process_information.GetUsedMemory() or 0

    display_name = getattr(self._merge_task, 'identifier', '')

    self._processing_status.UpdateForemanStatus(
        self._name, self._status, self._pid, used_memory, display_name,
        self._number_of_consumed_sources, self._number_of_produced_sources,
        self._number_of_consumed_events, self._number_of_produced_events,
        self._number_of_consumed_event_tags,
        self._number_of_produced_event_tags,
        self._number_of_consumed_warnings, self._number_of_produced_warnings,
        self._number_of_consumed_reports, self._number_of_produced_reports)

    self._processing_status.UpdateEventsStatus(self._events_status)
732974
public void onReload(final Container _container)
    {
        final Set<Class<?>> classesToRemove = new HashSet<>();
        final Set<Class<?>> classesToAdd = new HashSet<>();

        for (final Class<?> c : getClasses()) {
            if (!this.cachedClasses.contains(c)) {
                classesToAdd.add(c);
            }
        }

        for (final Class<?> c : this.cachedClasses) {
            if (!getClasses().contains(c)) {
                classesToRemove.add(c);
            }
        }

        getClasses().clear();

        init();

        getClasses().addAll(classesToAdd);
        getClasses().removeAll(classesToRemove);
    }
827891
def get_disabled():
    '''
    
    '''
    (enabled_services, disabled_services) = _get_service_list(include_enabled=False,
                                                              include_disabled=True)
    return sorted(disabled_services)
788128
function updateControls() {
		var query = $.trim($("input[name=query]").val());

		$("#btnPin").attr("disabled", !taxonTree.getActiveNode());
		$("#btnUnpin")
			.attr("disabled", !taxonTree.isFilterActive())
			.toggleClass("btn-success", taxonTree.isFilterActive());
		$("#btnResetSearch").attr("disabled", query.length === 0);
		$("#btnSearch").attr("disabled", query.length < 2);
	}
760009
def reset_status(self):
        """"""
        for item in self.items:
            item.isProcessing = False
            item.currentProgress = 0
242111
def disabled(name):
    '''
    
    '''
    ret = {'name': name,
           'result': True,
           'changes': {},
           'comment': ''}

    stat = __salt__['rdp.status']()

    if stat:
        if __opts__['test']:
            ret['result'] = None
            ret['comment'] = 'RDP will be disabled'
            return ret

        ret['result'] = __salt__['rdp.disable']()
        ret['changes'] = {'RDP was disabled': True}
        return ret

    ret['comment'] = 'RDP is disabled'
    return ret
529787
final static void enable() {
		if (lifeCycle.getStatus().equals(RunStatus.READY) || lifeCycle.getStatus().equals(RunStatus.STOPPED)) {
			init();
		} else if (lifeCycle.getStatus().equals(RunStatus.DISABLED)) {
			lifeCycle.setStatus(RunStatus.RUNNING);
		}
	}
627902
@GuardedBy("lock")
  private void updateStats() {
    mInternalStatFs = updateStatsHelper(mInternalStatFs, mInternalPath);
    mExternalStatFs = updateStatsHelper(mExternalStatFs, mExternalPath);
    mLastRestatTime = SystemClock.uptimeMillis();
  }
1003390
private void resetAvailabilityFlags() {
		epAvailable = false;
		overlayAvailable = false;
		for (DataDirectoryKey key : specials) {
			specialsAvailability.put(key, false);
		}
	}
1362958
public function enable()
    {
        $updatedCheck = $this->ohDear->enableCheck($this->id);

        $this->enabled = $updatedCheck->enabled;
    }
191977
private void setConditionEnabled(boolean enabled)
	{
		fConditionEditor.setEnabled(enabled);
		fSuspendWhenLabel.setEnabled(enabled);
		fConditionIsTrue.setEnabled(enabled);
		fConditionHasChanged.setEnabled(enabled);
	}
338751
def refresh_file_dependent_actions(self):
        """"""
        if self.dockwidget and self.dockwidget.isVisible():
            enable = self.get_current_editor() is not None
            for action in self.file_dependent_actions:
                action.setEnabled(enable)
1303
def update_active(self):
        """"""
        if self.active is not None:
            self.update_state(self.active, "normal")
        if self.current_iid == self.active:
            self._active = None
            return
        self._active = self.current_iid
        if self.active is not None:
            self.update_state(self.active, "active")
107148
function update( container, src, dest ) {
  for ( var key in src ) {
    // @TODO Better handle safe defaults.
    dest[ key ] = _deTokenize( container, src[key] );
  }
}
766067
private void updateContainerLevelInfo() {

        Map<String, CmsContainerPageContainer> containers = new HashMap<String, CmsContainerPageContainer>();
        List<CmsContainerPageContainer> temp = new ArrayList<CmsContainerPageContainer>(m_targetContainers.values());
        m_maxContainerLevel = 0;
        boolean progress = true;
        while (!temp.isEmpty() && progress) {
            int size = containers.size();
            Iterator<CmsContainerPageContainer> it = temp.iterator();
            while (it.hasNext()) {
                CmsContainerPageContainer container = it.next();
                int level = -1;
                if (CmsStringUtil.isEmptyOrWhitespaceOnly(container.getParentContainerId())) {
                    level = 0;
                } else if (containers.containsKey(container.getParentContainerId())) {
                    level = containers.get(container.getParentContainerId()).getContainerLevel() + 1;
                }
                if (level > -1) {
                    container.setContainerLevel(level);
                    containers.put(container.getContainerId(), container);
                    it.remove();
                    if (level > m_maxContainerLevel) {
                        m_maxContainerLevel = level;
                    }
                }
            }
            progress = containers.size() > size;
        }
    }