Examples with Logger org.eclipse.e4.core.services.log.Logger used on opensource projects

Example 6 with Logger

use of org.eclipse.e4.core.services.log.Logger in project eclipse.platform.ui by eclipse-platform.

the class AbstractContributionItem method getMenu.

protected Menu getMenu(final MMenu mmenu, ToolItem toolItem) {
    Object obj = mmenu.getWidget();
    if (obj instanceof Menu && !((Menu) obj).isDisposed()) {
        return (Menu) obj;
    }
    // this is a temporary passthrough of the IMenuCreator
    if (RenderedElementUtil.isRenderedMenu(mmenu)) {
        obj = RenderedElementUtil.getContributionManager(mmenu);
        if (obj instanceof IContextFunction) {
            final IEclipseContext lclContext = getContext(mmenu);
            obj = ((IContextFunction) obj).compute(lclContext, null);
            RenderedElementUtil.setContributionManager(mmenu, obj);
        }
        if (obj instanceof IMenuCreator) {
            final IMenuCreator creator = (IMenuCreator) obj;
            final Menu menu = creator.getMenu(toolItem.getParent().getShell());
            if (menu != null) {
                toolItem.addDisposeListener(e -> {
                    if (menu != null && !menu.isDisposed()) {
                        creator.dispose();
                        mmenu.setWidget(null);
                    }
                });
                menu.setData(AbstractPartRenderer.OWNING_ME, menu);
                return menu;
            }
        }
    } else {
        final IEclipseContext lclContext = getContext(getModel());
        IPresentationEngine engine = lclContext.get(IPresentationEngine.class);
        obj = engine.createGui(mmenu, toolItem.getParent(), lclContext);
        if (obj instanceof Menu) {
            return (Menu) obj;
        }
        if (logger != null) {
            // $NON-NLS-1$
            logger.debug("Rendering returned " + obj);
        }
    }
    return null;
}

Example 7 with Logger

use of org.eclipse.e4.core.services.log.Logger in project eclipse.platform.ui by eclipse-platform.

the class DirectContributionItem method executeItem.

@Override
protected void executeItem(Event trigger) {
    final IEclipseContext lclContext = getContext(getModel());
    if (!checkContribution(lclContext)) {
        return;
    }
    MContribution contrib = (MContribution) getModel();
    IEclipseContext staticContext = getStaticContext(trigger);
    Object result = ContextInjectionFactory.invoke(contrib.getObject(), Execute.class, getExecutionContext(lclContext), staticContext, missingExecute);
    if (result == missingExecute && logger != null) {
        // $NON-NLS-1$
        logger.error("Contribution is missing @Execute: " + contrib.getContributionURI());
    }
}

Example 8 with Logger

use of org.eclipse.e4.core.services.log.Logger in project eclipse.platform.ui by eclipse-platform.

the class MenuManagerShowProcessor method processDynamicElements.

/**
 * Process dynamic menu contributions provided by
 * {@link MDynamicMenuContribution} application model elements
 *
 * @param menuModel
 * @param menuManager
 */
private void processDynamicElements(MMenu menuModel, MenuManager menuManager) {
    MMenuElement[] menuElements = menuModel.getChildren().toArray(new MMenuElement[menuModel.getChildren().size()]);
    for (MMenuElement currentMenuElement : menuElements) {
        if (currentMenuElement instanceof MDynamicMenuContribution) {
            MDynamicMenuContribution dmc = (MDynamicMenuContribution) currentMenuElement;
            Object contribution = dmc.getObject();
            if (contribution == null) {
                IEclipseContext context = modelService.getContainingContext(menuModel);
                contribution = contributionFactory.create(dmc.getContributionURI(), context);
                dmc.setObject(contribution);
            }
            IEclipseContext dynamicMenuContext = EclipseContextFactory.create();
            ArrayList<MMenuElement> mel = new ArrayList<>();
            dynamicMenuContext.set(List.class, mel);
            dynamicMenuContext.set(MDynamicMenuContribution.class, dmc);
            IEclipseContext parentContext = modelService.getContainingContext(currentMenuElement);
            Object rc = ContextInjectionFactory.invoke(contribution, AboutToShow.class, parentContext, dynamicMenuContext, this);
            dynamicMenuContext.dispose();
            if (rc == this) {
                if (logger != null) {
                    // $NON-NLS-1$
                    logger.error("Missing @AboutToShow method in " + contribution);
                }
                continue;
            }
            if (mel.size() > 0) {
                int position = 0;
                while (position < menuModel.getChildren().size()) {
                    if (currentMenuElement == menuModel.getChildren().get(position)) {
                        position++;
                        break;
                    }
                    position++;
                }
                // and set the parent of the entries
                for (int j = 0; j < mel.size(); j++) {
                    MMenuElement menuElement = mel.get(j);
                    if (menuElement.getElementId() == null || menuElement.getElementId().length() < 1) {
                        menuElement.setElementId(currentMenuElement.getElementId() + "." + // $NON-NLS-1$
                        j);
                    }
                    menuModel.getChildren().add(position++, menuElement);
                    renderer.modelProcessSwitch(menuManager, menuElement);
                }
                currentMenuElement.getTransientData().put(DYNAMIC_ELEMENT_STORAGE_KEY, mel);
            }
        }
    }
}

Example 9 with Logger

use of org.eclipse.e4.core.services.log.Logger in project eclipse.platform.ui by eclipse-platform.

the class PartRenderingEngine method run.

@Override
@Inject
@Optional
public Object run(final MApplicationElement uiRoot, final IEclipseContext runContext) {
    final Display display;
    if (runContext.get(Display.class) != null) {
        display = runContext.get(Display.class);
    } else {
        display = Display.getDefault();
        runContext.set(Display.class, display);
    }
    Realm.runWithDefault(DisplayRealm.getRealm(display), new Runnable() {

        @Override
        public void run() {
            initializeStyling(display, runContext);
            // Register an SWT resource handler
            runContext.set(IResourceUtilities.class, new ResourceUtility());
            // set up the keybinding manager
            KeyBindingDispatcher dispatcher = ContextInjectionFactory.make(KeyBindingDispatcher.class, runContext);
            runContext.set(KeyBindingDispatcher.class, dispatcher);
            keyListener = dispatcher.getKeyDownFilter();
            display.addFilter(SWT.KeyDown, keyListener);
            display.addFilter(SWT.Traverse, keyListener);
            // Show the initial UI
            // Create a 'limbo' shell (used to host controls that shouldn't
            // be in the current layout)
            Shell limbo = getLimboShell();
            runContext.set("limbo", limbo);
            // HACK!! we should loop until the display gets disposed...
            // ...then we listen for the last 'main' window to get disposed
            // and dispose the Display
            testShell = null;
            theApp = null;
            boolean spinOnce = true;
            if (uiRoot instanceof MApplication) {
                ShellActivationListener shellDialogListener = new ShellActivationListener((MApplication) uiRoot);
                display.addFilter(SWT.Activate, shellDialogListener);
                display.addFilter(SWT.Deactivate, shellDialogListener);
                // loop until the app closes
                spinOnce = false;
                theApp = (MApplication) uiRoot;
                // long startTime = System.currentTimeMillis();
                for (MWindow window : theApp.getChildren()) {
                    createGui(window);
                }
                // long endTime = System.currentTimeMillis();
                // System.out.println("Render: " + (endTime - startTime));
                // tell the app context we are starting so the splash is
                // torn down
                IApplicationContext ac = appContext.get(IApplicationContext.class);
                if (ac != null) {
                    ac.applicationRunning();
                    if (eventBroker != null) {
                        eventBroker.post(UIEvents.UILifeCycle.APP_STARTUP_COMPLETE, theApp);
                    }
                }
            } else if (uiRoot instanceof MUIElement) {
                if (uiRoot instanceof MWindow) {
                    testShell = (Shell) createGui((MUIElement) uiRoot);
                } else {
                    // Special handling for partial models (for testing...)
                    testShell = new Shell(display, SWT.SHELL_TRIM);
                    createGui((MUIElement) uiRoot, testShell, null);
                }
            }
            // allow any early startup extensions to run
            Runnable earlyStartup = (Runnable) runContext.get(EARLY_STARTUP_HOOK);
            if (earlyStartup != null) {
                earlyStartup.run();
            }
            TestableObject testableObject = runContext.get(TestableObject.class);
            if (testableObject instanceof E4Testable) {
                ((E4Testable) testableObject).init(display, runContext.get(IWorkbench.class));
            }
            IEventLoopAdvisor advisor = runContext.getActiveLeaf().get(IEventLoopAdvisor.class);
            if (advisor == null) {
                advisor = new IEventLoopAdvisor() {

                    @Override
                    public void eventLoopIdle(Display display) {
                        display.sleep();
                    }

                    @Override
                    public void eventLoopException(Throwable exception) {
                        StatusReporter statusReporter = appContext.get(StatusReporter.class);
                        if (statusReporter != null) {
                            statusReporter.show(StatusReporter.ERROR, "Internal Error", exception);
                        } else if (logger != null) {
                            logger.error(exception);
                        }
                    }
                };
            }
            final IEventLoopAdvisor finalAdvisor = advisor;
            display.setErrorHandler(e -> {
                // recoverable, hand it to the event loop advisor
                if (e instanceof LinkageError || e instanceof AssertionError) {
                    handle(e, finalAdvisor);
                } else {
                    // Otherwise, rethrow it
                    throw e;
                }
            });
            display.setRuntimeExceptionHandler(e -> handle(e, finalAdvisor));
            // Spin the event loop until someone disposes the display
            while (((testShell != null && !testShell.isDisposed()) || (theApp != null && someAreVisible(theApp.getChildren()))) && !display.isDisposed()) {
                try {
                    if (!display.readAndDispatch()) {
                        runContext.processWaiting();
                        if (spinOnce) {
                            return;
                        }
                        advisor.eventLoopIdle(display);
                    }
                } catch (ThreadDeath th) {
                    throw th;
                } catch (Exception | Error err) {
                    handle(err, advisor);
                }
            }
            if (!spinOnce) {
                cleanUp();
            }
        }

        private void handle(Throwable ex, IEventLoopAdvisor advisor) {
            try {
                advisor.eventLoopException(ex);
            } catch (Throwable t) {
                if (t instanceof ThreadDeath) {
                    throw (ThreadDeath) t;
                }
                // couldn't handle the exception, print to console
                t.printStackTrace();
            }
        }
    });
    return IApplication.EXIT_OK;
}

Example 10 with Logger

use of org.eclipse.e4.core.services.log.Logger in project eclipse.platform.ui by eclipse-platform.

the class PartRenderingEngine method safeRemoveGui.

private void safeRemoveGui(MUIElement element) {
    if (removeRoot == null)
        removeRoot = element;
    // We call 'hideChild' *before* checking if the actual element
    // has been rendered in order to pick up cases of 'lazy loading'
    MUIElement parent = element.getParent();
    AbstractPartRenderer parentRenderer = parent != null ? getRendererFor(parent) : null;
    if (parentRenderer != null) {
        parentRenderer.hideChild(element.getParent(), element);
    }
    AbstractPartRenderer renderer = getRendererFor(element);
    // If the element hasn't been rendered then this is a NO-OP
    if (renderer != null) {
        if (element instanceof MElementContainer<?>) {
            @SuppressWarnings("unchecked") MElementContainer<MUIElement> container = (MElementContainer<MUIElement>) element;
            MUIElement selectedElement = container.getSelectedElement();
            List<MUIElement> children = container.getChildren();
            // Bug 458460: Operate on a copy in case child nulls out parent
            for (MUIElement child : new ArrayList<>(children)) {
                // remove stuff in the "back" first
                if (child != selectedElement) {
                    removeGui(child);
                }
            }
            if (selectedElement != null && children.contains(selectedElement)) {
                // now remove the selected element
                removeGui(selectedElement);
            }
        }
        if (element instanceof MPerspective) {
            MPerspective perspective = (MPerspective) element;
            for (MWindow subWindow : perspective.getWindows()) {
                removeGui(subWindow);
            }
        } else if (element instanceof MWindow) {
            MWindow window = (MWindow) element;
            for (MWindow subWindow : window.getWindows()) {
                removeGui(subWindow);
            }
            if (window instanceof MTrimmedWindow) {
                MTrimmedWindow trimmedWindow = (MTrimmedWindow) window;
                for (MUIElement trimBar : trimmedWindow.getTrimBars()) {
                    removeGui(trimBar);
                }
            }
        }
        if (element instanceof MContribution) {
            MContribution contribution = (MContribution) element;
            Object client = contribution.getObject();
            IEclipseContext parentContext = renderer.getContext(element);
            if (parentContext != null && client != null) {
                try {
                    ContextInjectionFactory.invoke(client, PersistState.class, parentContext, null);
                } catch (Exception e) {
                    if (logger != null) {
                        logger.error(e);
                    }
                }
            }
        }
        renderer.disposeWidget(element);
        // unset the client object
        if (element instanceof MContribution) {
            MContribution contribution = (MContribution) element;
            Object client = contribution.getObject();
            IEclipseContext parentContext = renderer.getContext(element);
            if (parentContext != null && client != null) {
                try {
                    ContextInjectionFactory.uninject(client, parentContext);
                } catch (Exception e) {
                    if (logger != null) {
                        logger.error(e);
                    }
                }
            }
            contribution.setObject(null);
        }
        // dispose the context
        if (element instanceof MContext) {
            clearContext((MContext) element);
        }
    }
    if (element instanceof MPlaceholder) {
        MPlaceholder ph = (MPlaceholder) element;
        if (ph.getRef() != null && ph.getRef().getCurSharedRef() == ph) {
            ph.getRef().setCurSharedRef(null);
        }
    }
    if (removeRoot == element)
        removeRoot = null;
}