Provides an opportunity for a descendant class implemenentation to take action when the main taxonomy is loaded
505462
public function afterMainTaxonomy()
	{
		// Run the pruning process over the roles taxonomy
		$map = array(
			XBRL_US_GAAP_2015::$us_GAAP_2013_NS => XBRL_US_GAAP_2015::$us_GAAP_2013_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2013_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2013_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2013_ENTRY_POINT_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2013_ROLES_NS,

			XBRL_US_GAAP_2015::$us_GAAP_2014_NS => XBRL_US_GAAP_2015::$us_GAAP_2014_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2014_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2014_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2014_ENTRY_POINT_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2014_ROLES_NS,

			XBRL_US_GAAP_2015::$us_GAAP_2015_NS => XBRL_US_GAAP_2015::$us_GAAP_2015_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2015_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2015_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2015_ENTRY_POINT_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2015_ROLES_NS,

			XBRL_US_GAAP_2015::$us_GAAP_2016_NS => XBRL_US_GAAP_2015::$us_GAAP_2016_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2016_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2016_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2016_ENTRY_POINT_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2016_ROLES_NS,

			XBRL_US_GAAP_2015::$us_GAAP_2017_NS => XBRL_US_GAAP_2015::$us_GAAP_2017_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2017_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2017_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2017_ENTRY_POINT_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2017_ROLES_NS,

			XBRL_US_GAAP_2015::$us_GAAP_2018_NS => XBRL_US_GAAP_2015::$us_GAAP_2018_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2018_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2018_ROLES_NS,
			XBRL_US_GAAP_2015::$us_GAAP_2018_ENTRY_POINT_ALL_NS => XBRL_US_GAAP_2015::$us_GAAP_2018_ROLES_NS,
		);

		/**
		 * @var XBRL $taxonomy
		 */
		$taxonomy = false;
		if ( isset( $map[ $this->getNamespace() ] ) )
		{
			$taxonomy = $this->getTaxonomyForNamespace( $map[ $this->getNamespace() ] );
		}

		if ( ! $taxonomy )
		{
			foreach ( array_unique( array_values( $map ) ) as $namespace => $roleNamespace )
			{
				if ( ! ( $taxonomy = $this->getTaxonomyForNamespace( $roleNamespace ) ) ) continue;
				break;
			}

			if ( ! $taxonomy )
			{
				$this->log()->err( "The Roles schema cannot be located for taxonomy with namespace '{$this->getNamespace()}'" );
				exit;
			}
		}

		// /**
		//  * @var XBRL $taxonomy
		//  */
		// $taxonomy = $this->getTaxonomyForNamespace( XBRL_US_GAAP_2015::$us_GAAP_2015_ROLES_NS );
		// if ( ! $taxonomy )
		// {
		// 	$taxonomy = $this->getTaxonomyForNamespace( XBRL_US_GAAP_2015::$us_GAAP_2014_ROLES_NS );
		// 	if ( ! $taxonomy )
		// 	{
		// 		$this->log()->err( "The Roles schema cannot be located for 2014 or 2015" );
		// 		exit;
		// 	}
		// }

		if ( $this->context->isExtensionTaxonomy() )
		{
			// This is needed because the definitions and presentations are loaded into
			// the roles schema which is loaded early so an additional fixup is required.
			$taxonomy->fixupPresentationHypercubes();
			$taxonomy->fixupDefinitionRoles(); // Mainly adds a 'paths' index to the 'hierarchy' element of each role.
		}

		$this->context->locale = 'en_US';
		$taxonomy->context->locale = 'en_US';
	}
1198702
function(options){
    // Prevent re-starting a module that is already started
    if (this._isInitialized){ return; }

    // start the sub-modules (depth-first hierarchy)
    _.each(this.submodules, function(mod){
      // check to see if we should start the sub-module with this parent
      if (mod.startWithParent){
        mod.start(options);
      }
    });

    // run the callbacks to "start" the current module
    this.triggerMethod("before:start", options);

    this._initializerCallbacks.run(options, this);
    this._isInitialized = true;

    this.triggerMethod("start", options);
  }
299018
protected void actionNext() {

        if (m_dialogIndex >= (m_resources.size() - 1)) {
            return;
        }

        m_dialogIndex++;
        m_uploadPropertyPanel.getPropertyEditor().getForm().validateAndSubmit();
        m_nextAction = new Runnable() {

            public void run() {

                loadDialogBean(m_resources.get(m_dialogIndex));
            }
        };
    }
123073
public void onCategoriesTabSelection() {

        if (!m_galleryDialog.getCategoriesTab().isInitOpen()) {
            m_galleryDialog.getCategoriesTab().onContentChange();
            return;
        }
        m_galleryDialog.getCategoriesTab().openFirstLevel();
        m_galleryDialog.getCategoriesTab().setInitOpen(false);
    }
192914
public function loadConfiguration(): void
	{
		$builder = $this->getContainerBuilder();
		$config = $this->validateConfig($this->defaults);

		if ($config['lazy'] === true) {
			$builder->addDefinition($this->prefix('dispatcher'))
				->setType(LazyEventDispatcher::class);
		} else {
			$builder->addDefinition($this->prefix('dispatcher'))
				->setType(EventDispatcher::class);
		}
	}
1102186
protected void fireTreeStructureChanged(Object source, Object[] path, int[] childIndices, Object[] children) {
        // Guaranteed to return a non-null array
        Object[] listeners = listenerList.getListenerList();
        TreeModelEvent e = null;
        // Process the listeners last to first, notifying
        // those that are interested in this event
        for (int i = listeners.length - 2; i >= 0; i -= 2) {
            if (listeners[i] == TreeModelListener.class) {
                // Lazily create the event:
                if (e == null) {
                    e = new TreeModelEvent(source, path, childIndices, children);
                }
                ((TreeModelListener) listeners[i + 1]).treeStructureChanged(e);
            }
        }
    }
1059317
private void addChildrenForOUNode(CmsOrganizationalUnit item) {

        List<Object> itemsToRemove = new ArrayList<Object>();

        Collection<?> childCol = m_treeContainer.getChildren(item);
        if (childCol != null) {
            itemsToRemove.addAll(childCol);
        }

        try {
            if (m_app.isOUManagable(item.getName())) {

                List<I_CmsOuTreeType> types = m_app.getTreeTypeProvider().getTreeTypes();
                for (I_CmsOuTreeType type : types) {
                    if (!type.isValidForOu(m_cms, item.getName())) {
                        continue;
                    }
                    if (type.isOrgUnit()) {
                        continue;
                    }
                    String itemId = type.getId() + item.getName();
                    Item newItem = m_treeContainer.addItem(itemId);
                    itemsToRemove.remove(itemId);
                    if (newItem != null) {
                        newItem.getItemProperty(PROP_NAME).setValue(getIconCaptionHTML(itemId, type));
                        newItem.getItemProperty(PROP_TYPE).setValue(type);
                        m_treeContainer.setParent(itemId, item);
                        setChildrenAllowed(itemId, type.isExpandable());
                    }
                }
            }
            List<CmsOrganizationalUnit> ous = OpenCms.getOrgUnitManager().getOrganizationalUnits(
                m_cms,
                item.getName(),
                false);
            List<CmsOrganizationalUnit> webOus = new ArrayList<CmsOrganizationalUnit>();
            for (CmsOrganizationalUnit ou : ous) {
                if (m_app.isParentOfManagableOU(ou.getName())) {
                    itemsToRemove.remove(ou);
                    if (ou.hasFlagWebuser()) {
                        webOus.add(ou);
                    } else {
                        addOuToTree(ou, item);
                    }
                }
            }
            for (CmsOrganizationalUnit ou : webOus) {
                if (m_app.isParentOfManagableOU(ou.getName())) {
                    itemsToRemove.remove(ou);
                    addOuToTree(ou, item);
                }
            }
        } catch (CmsException e) {
            LOG.error("Can't read ou", e);
        }
        for (Object it : itemsToRemove) {
            m_treeContainer.removeItemRecursively(it);
        }
    }
610755
void onBuildChildNode(Object childObject, EntityMetadata childMetadata, PersistenceDelegator delegator,
            PersistenceCache pc, Node node, Relation relation)
    {
        Node childNode = generate(childObject, delegator, pc, null);
        if (childNode != null)
        {
            assignNodeLinkProperty(node, relation, childNode);
        }
    }
328818
@Override
    public void fireAddAppenderEvent(Category logger, Appender appender) {
        if (listeners != null) {
            HierarchyEventListener listener;
            for (Iterator<HierarchyEventListener> it = listeners.iterator(); it
                    .hasNext();) {
                listener = it.next();
                listener.addAppenderEvent(logger, appender);
            }
        }
    }
1190838
protected void attachParentListener() {

        final AutoRelease ar = ClassUtility.getLastClassAnnotation(this.getClass(), AutoRelease.class);

        // Only manage automatic release when the annotation exists with true value
        if (ar != null && ar.value() && node() != null) { // TODO check rootnode null when using NullView

            // Allow to release the model if the root business object doesn't exist anymore
            node().parentProperty().addListener(new ChangeListener<Node>() {

                @Override
                public void changed(final ObservableValue<? extends Node> observable, final Node oldValue, final Node newValue) {
                    if (newValue != null) {
                        AbstractBaseModel.this.hasBeenAttached = true;
                    }
                    if (newValue == null && AbstractBaseModel.this.hasBeenAttached) {
                        AbstractBaseModel.this.hasBeenAttached = false;
                        release();
                        node().parentProperty().removeListener(this);
                    }
                }

            });
        }
    }
865479
@Override
	public void execute() {
		if (target instanceof WComponentGroup<?>) {
			for (WComponent component : ((WComponentGroup<WComponent>) target).getComponents()) {
				if (component instanceof SubordinateTarget) {
					applyAction((SubordinateTarget) component, value);
				}
			}
		} else {
			// Leaf.
			applyAction(target, value);
		}

	}
767377
def load_parent_implems(self, parent_implems):
        
        for trname, attr, implem in parent_implems.get_custom_implementations():
            self.implementations[trname] = implem.copy()
            self.transitions_at[trname] = attr
            self.custom_implems.add(trname)
614750
private void loadAndExpand(Object itemId, I_CmsOuTreeType type) {

        if (type.isOrgUnit()) {
            addChildrenForOUNode((CmsOrganizationalUnit)itemId);
        }
        if (type.isGroup()) {
            addChildrenForGroupsNode(type, (String)itemId);
        }
        if (type.isRole()) {
            addChildrenForRolesNode((String)itemId);
        }
        expandItem(itemId);
    }
1258162
def add_action(self, name, parent, action):
        
        if iskeyword(name):
            name = '_' + name
        self._actions[name] = parent.new_action(**action)
        setattr(self, name, self._actions[name].execute)
1335956
protected void onResize() {

        Widget parent = getParent();
        while (parent != null) {
            if (parent instanceof I_CmsDescendantResizeHandler) {
                ((I_CmsDescendantResizeHandler)parent).onResizeDescendant();
                break;
            }
            parent = parent.getParent();
        }
    }
81115
def do_setup
        if (self.taxonomy_node == nil)
          self.taxonomy_node = self.respond_to?(:create_taxonomy_node) ? self.create_taxonomy_node : Taxonomite::Node.new
          self.taxonomy_node.owner = self
        end
      end
387132
private void initNestedContainers() {

        for (CmsContainer container : m_controller.getContainers().values()) {
            if (container.isSubContainer()) {
                CmsContainerPageContainer containerWidget = m_controller.m_targetContainers.get(container.getName());
                // check if the sub container is a valid drop targets
                if (m_dragInfos.keySet().contains(containerWidget)) {
                    CmsContainer parentContainer = m_controller.getContainers().get(container.getParentContainerName());
                    // add the container to all it's ancestors as a dnd child
                    while (parentContainer != null) {
                        if (m_dragInfos.keySet().contains(
                            m_controller.m_targetContainers.get(parentContainer.getName()))) {
                            m_controller.m_targetContainers.get(parentContainer.getName()).addDndChild(containerWidget);
                        }
                        if (parentContainer.isSubContainer()) {
                            parentContainer = m_controller.getContainers().get(
                                parentContainer.getParentContainerName());
                        } else {
                            parentContainer = null;
                        }
                    }
                }
            }

        }
    }