Registers Konekt Menu Component
351026
private function registerMenuComponent()
    {
        $this->app->register(\Konekt\Menu\MenuServiceProvider::class);
        $this->concord->registerAlias('Menu', \Konekt\Menu\Facades\Menu::class);
    }
133798
function registerComponents(elemNames) {
    if (!elemNames) { return; }

    var elemNameDashCase, elemNameCamelCase;
    for (var i = 0; i < elemNames.length; i++) {
        elemNameDashCase = elemNames[i];
        elemNameCamelCase = utils.dashToCamelCase(elemNameDashCase);
        elems[elemNameCamelCase] = makeElem(elemNameDashCase);
    }
}
671040
function() {
		/**
		 * Class replacing the non-configurable native context menu with configurable CKEditor's equivalent.
		 *
		 * @class
		 * @extends CKEDITOR.menu
		 */
		CKEDITOR.plugins.contextMenu = CKEDITOR.tools.createClass( {
			base: CKEDITOR.menu,

			/**
			 * Creates the CKEDITOR.plugins.contextMenu class instance.
			 *
			 * @constructor
			 * @param {CKEDITOR.editor} editor
			 */
			$: function( editor ) {
				this.base.call( this, editor, {
					panel: {
						className: 'cke_menu_panel',
						attributes: {
							'aria-label': editor.lang.contextmenu.options
						}
					}
				} );
			},

			proto: {
				/**
				 * Starts watching on native context menu triggers (option key, right click) on given element.
				 *
				 * @param {CKEDITOR.dom.element} element
				 * @param {Boolean} [nativeContextMenuOnCtrl] Whether to open native context menu if
				 * *Ctrl* key is hold on opening the context menu. See {@link CKEDITOR.config#browserContextMenuOnCtrl}.
				 */
				addTarget: function( element, nativeContextMenuOnCtrl ) {
					element.on( 'contextmenu', function( event ) {
						var domEvent = event.data,
							isCtrlKeyDown =
								// Safari on Windows always show 'ctrlKey' as true in 'contextmenu' event,
								// which make this property unreliable. (#4826)
								( CKEDITOR.env.webkit ? holdCtrlKey : ( CKEDITOR.env.mac ? domEvent.$.metaKey : domEvent.$.ctrlKey ) );

						if ( nativeContextMenuOnCtrl && isCtrlKeyDown )
							return;

						// Cancel the browser context menu.
						domEvent.preventDefault();

						// Fix selection when non-editable element in Webkit/Blink (Mac) (#11306).
						if ( CKEDITOR.env.mac && CKEDITOR.env.webkit ) {
							var editor = this.editor,
								contentEditableParent = new CKEDITOR.dom.elementPath( domEvent.getTarget(), editor.editable() ).contains( function( el ) {
									// Return when non-editable or nested editable element is found.
									return el.hasAttribute( 'contenteditable' );
								}, true ); // Exclude editor's editable.

							// Fake selection for non-editables only (to exclude nested editables).
							if ( contentEditableParent && contentEditableParent.getAttribute( 'contenteditable' ) == 'false' )
								editor.getSelection().fake( contentEditableParent );
						}

						var doc = domEvent.getTarget().getDocument(),
							offsetParent = domEvent.getTarget().getDocument().getDocumentElement(),
							fromFrame = !doc.equals( CKEDITOR.document ),
							scroll = doc.getWindow().getScrollPosition(),
							offsetX = fromFrame ? domEvent.$.clientX : domEvent.$.pageX || scroll.x + domEvent.$.clientX,
							offsetY = fromFrame ? domEvent.$.clientY : domEvent.$.pageY || scroll.y + domEvent.$.clientY;

						CKEDITOR.tools.setTimeout( function() {
							this.open( offsetParent, null, offsetX, offsetY );

							// IE needs a short while to allow selection change before opening menu. (#7908)
						}, CKEDITOR.env.ie ? 200 : 0, this );
					}, this );

					if ( CKEDITOR.env.webkit ) {
						var holdCtrlKey,
							onKeyDown = function( event ) {
								holdCtrlKey = CKEDITOR.env.mac ? event.data.$.metaKey : event.data.$.ctrlKey;
							},
							resetOnKeyUp = function() {
								holdCtrlKey = 0;
							};

						element.on( 'keydown', onKeyDown );
						element.on( 'keyup', resetOnKeyUp );
						element.on( 'contextmenu', resetOnKeyUp );
					}
				},

				/**
				 * Opens context menu in given location. See the {@link CKEDITOR.menu#show} method.
				 *
				 * @param {CKEDITOR.dom.element} offsetParent
				 * @param {Number} [corner]
				 * @param {Number} [offsetX]
				 * @param {Number} [offsetY]
				 */
				open: function( offsetParent, corner, offsetX, offsetY ) {
					this.editor.focus();
					offsetParent = offsetParent || CKEDITOR.document.getDocumentElement();

					// #9362: Force selection check to update commands' states in the new context.
					this.editor.selectionChange( 1 );

					this.show( offsetParent, corner, offsetX, offsetY );
				}
			}
		} );
	}
832210
public static function registerColumnDisplayer()
    {
        $map = [
            'editable'    => Displayers\Editable::class,
            'switch'      => Displayers\SwitchDisplay::class,
            'switchGroup' => Displayers\SwitchGroup::class,
            'select'      => Displayers\Select::class,
            'image'       => Displayers\Image::class,
            'label'       => Displayers\Label::class,
            'button'      => Displayers\Button::class,
            'link'        => Displayers\Link::class,
            'badge'       => Displayers\Badge::class,
            'progressBar' => Displayers\ProgressBar::class,
            'radio'       => Displayers\Radio::class,
            'checkbox'    => Displayers\Checkbox::class,
            'orderable'   => Displayers\Orderable::class,
            'table'       => Displayers\Table::class,
            'expand'      => Displayers\Expand::class,
            'modal'       => Displayers\Modal::class,
        ];

        foreach ($map as $abstract => $class) {
            Column::extend($abstract, $class);
        }
    }
811761
protected function registerThirdPartyProviders()
    {
        if (
            'testing' == $this->app->environment()
            ||
            version_compare(Application::VERSION, '5.5.0', '<')
        ) {
            $this->registerMenuComponent();
            $this->registerFormComponent();
            $this->registerFlashComponent();
            $this->registerBreadcrumbsComponent();
            $this->registerSluggableComponent();
        }

        $this->mergeBreadCrumbsConfig();
    }
940893
function initMenu() {
    let menuCfg = defaults.menu;

    // no configuration given and neither the menu created earlier
    // no need to proceed
    if (!menuCfg && !Menu.created) {
        return;
    }

    // set options to create menu
    if (menuCfg) {
        Menu.setOptions(menuCfg);
    }

    menuDoc = Menu.get();
    Page.prepareDom(menuDoc);
}
358067
public function register()
    {
        $this->app->singleton('menu', function ($app) {
            return new Repository();
        });

        $this->app->singleton('konekt.menu.renderer.menu.ul', UlMenuRenderer::class);
        $this->app->singleton('konekt.menu.renderer.menu.ol', OlMenuRenderer::class);
        $this->app->singleton('konekt.menu.renderer.menu.div', DivMenuRenderer::class);
        $this->app->singleton('konekt.menu.renderer.item.li', LiItemRenderer::class);
        $this->app->singleton('konekt.menu.renderer.item.div', DivItemRenderer::class);
    }
485389
protected function registerComponents()
    {
        ComponentManager::instance()->registerComponents(function ($manager) {
            $manager->registerComponent(\Cms\Components\ViewBag::class, 'viewBag');
            $manager->registerComponent(\Cms\Components\Resources::class, 'resources');
        });
    }
102192
public function registerViewComposerData()
    {
        View::composer('avored-ecommerce::layouts.left-nav', AdminNavComposer::class);
        View::composer('avored-ecommerce::site-currency._fields', SiteCurrencyFieldsComposer::class);
        View::composer(['avored-ecommerce::category._fields'], CategoryFieldsComposer::class);
        View::composer(['avored-ecommerce::admin-user._fields'], AdminUserFieldsComposer::class);
        View::composer(['avored-ecommerce::product.create',
                        'avored-ecommerce::product.edit',
                        ], ProductFieldsComposer::class);
    }
572597
public void contributeToViewMenu(IMenuManager menu) {
		if (!fInViewMenu)
			return;
		final String filters= "filters"; //$NON-NLS-1$
		if (menu.find(filters) != null) {
			for (int i= 0; i < fFilterActions.length; i++) {
				menu.prependToGroup(filters, fFilterActions[i]);
			}
		} else {
			for (int i= 0; i < fFilterActions.length; i++) {
				menu.add(fFilterActions[i]);
			}
		}
	}
1290640
public function registerWorkerNamespace()
    {
        foreach ($this->customComponents as $ns => $componentDir) {
            if (is_int($ns)) {
                $ns = $componentDir;
                $componentDir = ComposerHelper::getDirByNamespace($ns);
                $ns = rtrim($ns, "\\");
                $componentDir = rtrim($componentDir, "/");
            }

            $this->componentNamespaces[] = $ns;
            $componentDir = alias($componentDir);

            if (!is_dir($componentDir)) {
                continue;
            }

            $scanDirs = scandir($componentDir, null);

            foreach ($scanDirs as $dir) {
                if ($dir == '.' || $dir == '..') {
                    continue;
                }
                if (\in_array($dir, $this->serverScan, true)) {
                    continue;
                }

                $scanDir = $componentDir . DS . $dir;

                if (!is_dir($scanDir)) {
                    $this->scanFiles[$ns][] = $scanDir;
                    continue;
                }
                $scanNs = $ns . '\\' . $dir;

                $this->scanNamespaces[$scanNs] = $scanDir;
            }
        }
    }
903585
private function registerMenuManagerService()
    {
        $this->singleton('arcanedev.menus.manager', function () {
            return new MenusManager;
        });

        $this->app->bind(
            \Arcanedev\Menus\Contracts\MenusManager::class,
            \Arcanedev\Menus\MenusManager::class
        );
    }
119828
public void setupSubMenus(String strMenu)
    {
        Record recMenu = this.getMainRecord();
        try   {
            String strCommandNoCommas = Utility.replace(strMenu, ",", null);    // Get any commas out
            boolean bIsNumeric = Utility.isNumeric(strCommandNoCommas);
            if (bIsNumeric)
            {
                recMenu.setKeyArea(Menus.ID_KEY);
                recMenu.getField(Menus.ID).setString(strCommandNoCommas);
                bIsNumeric = recMenu.seek("=");
            }
            if (!bIsNumeric)
            {
                recMenu.setKeyArea(Menus.CODE_KEY);
                recMenu.getField(Menus.CODE).setString(strMenu);
                if (!recMenu.seek("="))
                {   // Not found, try the default main menu
                    recMenu.getField(Menus.CODE).setString(HtmlConstants.MAIN_MENU_KEY);
                    recMenu.seek("=");
                }
            }
        } catch (DBException ex)    {
            ex.printStackTrace(); // Never
        }
        String strParentID = recMenu.getField(Menus.ID).toString();
        BaseListener listener = recMenu.getListener(StringSubFileFilter.class.getName());
        if (listener != null)
        { // Should just change the string
            recMenu.removeListener(listener, true);
        }
        recMenu.setKeyArea(Menus.PARENT_FOLDER_ID_KEY);
        recMenu.addListener(new StringSubFileFilter(strParentID, recMenu.getField(Menus.PARENT_FOLDER_ID), null, null, null, null));
    }
836488
public void setAsContextMenuOf(AbstractClientConnector component) {

        if (component instanceof Table) {
            setAsTableContextMenu((Table)component);
        } else if (component instanceof Tree) {
            setAsTreeContextMenu((Tree)component);
        } else {
            super.extend(component);
        }
    }
538367
protected function registerCoreComponents()
    {
        $this->app->singleton(Component::CORE, $this->getCoreConfig('bindings.' . Component::CORE));
        $this->app->singleton(Component::AUTH, $this->getCoreConfig('bindings.' . Component::AUTH));
        $this->app->singleton(Component::MODULES, $this->getCoreConfig('bindings.' . Component::MODULES));
        $this->app->singleton(Component::CACHE, $this->getCoreConfig('bindings.' . Component::CACHE));
        $this->app->singleton(Component::API, $this->getCoreConfig('bindings.' . Component::API));
        $this->app->singleton(Component::MENU, $this->getCoreConfig('bindings.' . Component::MENU));
        $this->app->singleton(Component::ACL, $this->getCoreConfig('bindings.' . Component::ACL));
        $this->app->singleton(Component::NOTIFIER, $this->getCoreConfig('bindings.' . Component::NOTIFIER));
        $this->app->singleton(Component::ASSETS, $this->getCoreConfig('bindings.' . Component::ASSETS, AssetManager::class));

        $this->app->bind(CoreInterface::class, Component::CORE);
        $this->app->bind(AuthenticatorInterface::class, Component::AUTH);
        $this->app->bind(ModuleManagerInterface::class, Component::MODULES);
        $this->app->bind(CacheInterface::class, Component::CACHE);
        $this->app->bind(ApiCoreInterface::class, Component::API);
        $this->app->bind(MenuRepositoryInterface::class, Component::MENU);
        $this->app->bind(AclRepositoryInterface::class, Component::ACL);
        $this->app->bind(NotifierInterface::class, Component::NOTIFIER);
        $this->app->bind(AssetManagerInterface::class, Component::ASSETS);

        return $this;
    }
450908
function registerComponents(Vue, components) {
        for (var component in components) {
            registerComponent(Vue, component, components[component]);
        }
    }
1355029
def register_plugin(self):
        """"""
        self.main.add_dockwidget(self)

        self.focus_changed.connect(self.main.plugin_focus_changed)
        self.edit_goto.connect(self.main.editor.load)
        self.edit_goto[str, int, str, bool].connect(
                         lambda fname, lineno, word, processevents:
                         self.main.editor.load(fname, lineno, word,
                                               processevents=processevents))
        self.main.editor.breakpoints_saved.connect(self.set_spyder_breakpoints)
        self.main.editor.run_in_current_ipyclient.connect(self.run_script)
        self.main.editor.run_cell_in_ipyclient.connect(self.run_cell)
        self.main.workingdirectory.set_current_console_wd.connect(
                                     self.set_current_client_working_directory)

        self.tabwidget.currentChanged.connect(self.update_working_directory)

        self._remove_old_stderr_files()