Examples with StatusReporter org.eclipse.e4.core.services.statusreporter.StatusReporter used on opensource projects

Example 1 with StatusReporter

use of org.eclipse.e4.core.services.statusreporter.StatusReporter 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 2 with StatusReporter

use of org.eclipse.e4.core.services.statusreporter.StatusReporter in project eclipse.platform.ui by eclipse-platform.

the class PartRenderingEngineTests method addRuntimeExceptionHandler.

/**
 * Sets a temporary RuntimeException handler, that doesn't show an error dialog
 * when an exception occurs. The handler is reset by calling
 * resetRuntimeExceptionHandler() in the finally block of handler code.
 */
private void addRuntimeExceptionHandler() {
    Display display = Display.getDefault();
    runtimeExceptionHandler = display.getRuntimeExceptionHandler();
    display.setRuntimeExceptionHandler(e -> handle(e, 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.report(statusReporter.newStatus(StatusReporter.ERROR, "Internal Error", exception), StatusReporter.LOG, exception);
            }
        }
    }));
}

Example 3 with StatusReporter

use of org.eclipse.e4.core.services.statusreporter.StatusReporter in project eclipse.platform.ui by eclipse-platform.

the class ShowInSystemExplorerHandler method execute.

@Override
public Object execute(final ExecutionEvent event) {
    final IResource item = getResource(event);
    if (item == null) {
        return null;
    }
    final StatusReporter statusReporter = HandlerUtil.getActiveWorkbenchWindow(event).getService(StatusReporter.class);
    Job job = Job.create(IDEWorkbenchMessages.ShowInSystemExplorerHandler_jobTitle, monitor -> {
        String logMsgPrefix;
        try {
            // $NON-NLS-1$
            logMsgPrefix = event.getCommand().getName() + ": ";
        } catch (NotDefinedException e1) {
            // will used id instead...
            // $NON-NLS-1$
            logMsgPrefix = event.getCommand().getId() + ": ";
        }
        try {
            File canonicalPath = getSystemExplorerPath(item);
            if (canonicalPath == null) {
                return statusReporter.newStatus(IStatus.ERROR, logMsgPrefix + IDEWorkbenchMessages.ShowInSystemExplorerHandler_notDetermineLocation, null);
            }
            String launchCmd = formShowInSytemExplorerCommand(canonicalPath);
            if ("".equals(launchCmd)) {
                // $NON-NLS-1$
                return statusReporter.newStatus(IStatus.ERROR, logMsgPrefix + IDEWorkbenchMessages.ShowInSystemExplorerHandler_commandUnavailable, null);
            }
            File dir = item.getWorkspace().getRoot().getLocation().toFile();
            Process p;
            if (Util.isLinux() || Util.isMac()) {
                // $NON-NLS-1$ //$NON-NLS-2$
                p = Runtime.getRuntime().exec(new String[] { "/bin/sh", "-c", launchCmd }, null, dir);
            } else {
                p = Runtime.getRuntime().exec(launchCmd, null, dir);
            }
            int retCode = p.waitFor();
            if (retCode != 0 && !Util.isWindows()) {
                return statusReporter.newStatus(IStatus.ERROR, // $NON-NLS-1$
                "Execution of '" + launchCmd + "' failed with return code: " + retCode, // $NON-NLS-1$
                null);
            }
        } catch (IOException | InterruptedException e2) {
            // $NON-NLS-1$
            return statusReporter.newStatus(IStatus.ERROR, logMsgPrefix + "Unhandled failure.", e2);
        }
        return Status.OK_STATUS;
    });
    job.schedule();
    return null;
}