Enables/Disables registered components.
519101
protected void _notifyActionComponentsNow()
  {
    for( Iterator iter = _mapItems.keySet().iterator(); iter.hasNext(); )
    {
      JComponent item = (JComponent)iter.next();
//      if( !item.isShowing() )
//      {
//        continue;
//      }

      Action action = (Action)item.getClientProperty( GenericAction.ACTION_PROPERTY );
      if( action == null )
      {
        if( item instanceof AbstractButton )
        {
          action = ((AbstractButton)item).getAction();
        }

        if( action == null )
        {
          continue;
        }
      }

      boolean bEnabled = action.isEnabled();

//      long lTime = System.currentTime();
//      boolean bEnabled = action.isEnabled();
//      long diff = System.currentTime() - lTime;
//      if( diff > 50 )
//      {
//        //!! Uncomment following line and set a break point there to debug poor performing isEnabled() impl.
//        //action.isEnabled();
//
//        ConditionalActionHandler cah = null;
//        if( action instanceof GenericAction )
//        {
//          cah = ((GenericAction)action).getConditionalActionHandler();
//        }
//        System.out.println( "!!!!!!!!!!!!!!!!!!!!!!!\n" +
//                            "An action.isEnabled() impl needs to be optimized.\nIt took " + diff + "ms to complete.\n" +
//                            (cah == null ? "" : "ConditionalActionHandler: " + cah.getClass().getName() + "\n") +
//                            "Debug UpdateNotifier.notifyActionComponentsNow() to find the naughty code." +
//                            "\n!!!!!!!!!!!!!!!!!!!!!!!" );
//      }

      if( item.isEnabled() != bEnabled )
      {
        item.setEnabled( bEnabled );
      }


      // Also handle "selected" state for togglable :) items

      if( action instanceof GenericAction )
      {
        boolean bSelected = ((GenericAction)action).isSelected();
        if( item instanceof JToggleButton )
        {
          JToggleButton tb = (JToggleButton)item;
          if( tb.isSelected() != bSelected )
          {
            tb.setSelected( bSelected );
          }
        }
        else if( item instanceof JCheckBoxMenuItem )
        {
          JCheckBoxMenuItem tb = (JCheckBoxMenuItem)item;
          if( tb.getState() != bSelected )
          {
            tb.setState( bSelected );
          }
        }
      }
    }
  }
687423
public static void disableAction(BaseComponent component, String eventName, boolean disable) {
        ActionListener listener = getListener(component, eventName);
        
        if (listener != null) {
            listener.setDisabled(disable);
        }
    }
1285771
public function deactivate_component( $component ) {

		if ( $this->is_component_active( $component ) ) {
			if ( isset( $this->components[ $component ] ) ) {
				$this->settings['components'][ $component ] = 0;

				$this->update_settings( $this->settings );
			}
		}

	}
1373724
public static void setEnabled(Component component, boolean bEnabled)
    {
        if (component instanceof JPanel)
        {
            for (int i = 0; i < ((JPanel)component).getComponentCount(); i++)
            {
                JComponent componentSub = (JComponent)((JPanel)component).getComponent(i);
                ScreenUtil.setEnabled(componentSub, bEnabled);
            }
        }
        else if (component instanceof JScrollPane)
        {
            JComponent componentSub = (JComponent)((JScrollPane)component).getViewport().getView();
            ScreenUtil.setEnabled(componentSub, bEnabled);
        }
        else
            component.setEnabled(bEnabled);
    }
1024815
public static synchronized void disable() {
        if (!enabled) {
            return;
        }
        RxJavaPlugins.setOnObservableAssembly(oldOnObservableAssembly);
        oldOnObservableAssembly = null;
        RxJavaPlugins.setOnConnectableObservableAssembly(oldOnConnectableObservableAssembly);
        oldOnConnectableObservableAssembly = null;
        RxJavaPlugins.setOnCompletableAssembly(oldOnCompletableAssembly);
        oldOnCompletableAssembly = null;
        RxJavaPlugins.setOnSingleAssembly(oldOnSingleAssembly);
        oldOnSingleAssembly = null;
        RxJavaPlugins.setOnMaybeAssembly(oldOnMaybeAssembly);
        oldOnMaybeAssembly = null;
        RxJavaPlugins.setOnFlowableAssembly(oldOnFlowableAssembly);
        oldOnFlowableAssembly = null;
        RxJavaPlugins.setOnConnectableFlowableAssembly(oldOnConnectableFlowableAssembly);
        oldOnConnectableFlowableAssembly = null;
        RxJavaPlugins.setOnParallelAssembly(oldOnParallelAssembly);
        oldOnParallelAssembly = null;
        enabled = false;
    }
450908
function registerComponents(Vue, components) {
        for (var component in components) {
            registerComponent(Vue, component, components[component]);
        }
    }
318566
function(oComponent) {
				var sComponentName = oComponent.getMetadata().getComponentName(),
				    sKey = sComponentName + "::" + oComponent.getId();
				if (mComponentConfigs[sKey]) {
					Log.info("CustomizingConfiguration: deactivateForComponent('" + sKey + "')");
					delete mComponentConfigs[sKey];
				}
			}
209543
private void applyEnableAction(final WComponent target, final boolean enabled) {
		// Found Disableable component
		if (target instanceof Disableable) {
			target.setValidate(enabled);
			((Disableable) target).setDisabled(!enabled);
		} else if (target instanceof Container) {  // Apply to any Disableable children
			Container cont = (Container) target;
			final int size = cont.getChildCount();

			for (int i = 0; i < size; i++) {
				WComponent child = cont.getChildAt(i);
				applyEnableAction(child, enabled);
			}
		}
	}
755726
public void enableDefaultButtons(boolean enabled) {

        if (enabled) {
            m_itemsRight.addComponent(m_contextMenu, 0);
            m_itemsRight.addComponent(m_favButton, 1);
            m_itemsRight.addComponent(m_quickLaunchDropDown, 2);
        } else {
            m_itemsRight.removeComponent(m_contextMenu);
            m_itemsRight.removeComponent(m_favButton);
            m_itemsRight.removeComponent(m_quickLaunchDropDown);
        }
        updateFoldingThreshhold();
    }
1255812
private void registerComponents() throws RepositoryConfigurationException, RepositoryException
   {
      SecurityHelper.doPrivilegedAction(new PrivilegedAction<Void>()
      {
         public Void run()
         {
            registerComponentInstance(config);
            registerComponentImplementation(FileCleanerHolder.class);
            registerComponentImplementation(LockRemoverHolder.class);
            return null;
         }
      });
      registerWorkspacesComponents();
      registerRepositoryComponents();
   }
408679
public void setDisabled(boolean disabled) {

        m_disabled = disabled;
        if (m_disabled) {
            getListItemWidget().addStyleName(I_CmsSitemapLayoutBundle.INSTANCE.sitemapItemCss().hiddenNavEntry());
        } else {
            getListItemWidget().removeStyleName(I_CmsSitemapLayoutBundle.INSTANCE.sitemapItemCss().hiddenNavEntry());
        }
    }
874117
def deactivate_components_ui(self):
        

        selected_components = self.get_selected_components()

        self.__engine.start_processing("Deactivating Components ...", len(selected_components))
        deactivation_failed_components = []
        for component in selected_components:
            if component.interface.activated:
                if component.interface.deactivatable:
                    success = self.deactivate_component(component.name) or False
                    if not success:
                        deactivation_failed_components.append(component)
                else:
                    self.__engine.notifications_manager.warnify(
                        "{0} | '{1}' Component cannot be deactivated!".format(self.__class__.__name__, component.name))
            else:
                self.__engine.notifications_manager.warnify(
                    "{0} | '{1}' Component is already deactivated!".format(self.__class__.__name__, component.name))
            self.__engine.step_processing()
        self.__engine.stop_processing()

        self.__store_deactivated_components()

        if not deactivation_failed_components:
            return True
        else:
            raise manager.exceptions.ComponentDeactivationError(
                "{0} | Exception(s) raised while deactivating '{1}' Component(s)!".format(self.__class__.__name__,
                                                                                          ", ".join((
                                                                                          deactivation_failed_component.name
                                                                                          for
                                                                                          deactivation_failed_component
                                                                                          in
                                                                                          deactivation_failed_components))))
725529
@Deactivate
    protected void deactivate(ComponentContext context) {
        lock.writeLock().lock();
        try {
            componentContext = null;
            properties = null;
            threadContextConfigurations = null;
        } finally {
            lock.writeLock().unlock();
        }
    }
401349
function() {
			var self = this;
			self.$input.prop('disabled', false);
			self.$control_input.prop('disabled', false).prop('tabindex', self.tabIndex);
			self.isDisabled = false;
			self.unlock();
		}
1260574
def enable_disable(self):
        
        if self.enabled:
            self.data['enabled'] = False
        else:
            self.data['enabled'] = True
        self.update()
491868
private function is_disabled( $component )
    {
        return 
            $component instanceof DisableableComponentInterface &&
            (
                true === $component->disabled ||
                true === $component->readonly
            );
    }
224733
protected void deactivate(ComponentContext componentContext) {
        isShutdown.set(true);

        contextSvcRef.deactivate(componentContext);

        threadGroupTracker.threadFactoryDestroyed(name, threadGroup);
    }