| /*=============================================================================# |
| # Copyright (c) 2005, 2019 Stephan Wahlbrink and others. |
| # |
| # This program and the accompanying materials are made available under the |
| # terms of the Eclipse Public License 2.0 which is available at |
| # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 |
| # which is available at https://www.apache.org/licenses/LICENSE-2.0. |
| # |
| # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 |
| # |
| # Contributors: |
| # Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation |
| #=============================================================================*/ |
| |
| package org.eclipse.statet.internal.nico.ui; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.concurrent.atomic.AtomicReference; |
| |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.runtime.jobs.ISchedulingRule; |
| import org.eclipse.core.runtime.jobs.Job; |
| import org.eclipse.debug.core.DebugEvent; |
| import org.eclipse.debug.core.DebugPlugin; |
| import org.eclipse.debug.core.IDebugEventSetListener; |
| import org.eclipse.debug.core.ILaunch; |
| import org.eclipse.debug.core.model.IProcess; |
| import org.eclipse.debug.ui.DebugUITools; |
| import org.eclipse.debug.ui.contexts.DebugContextEvent; |
| import org.eclipse.debug.ui.contexts.IDebugContextListener; |
| import org.eclipse.jface.viewers.ISelection; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.ui.IViewPart; |
| import org.eclipse.ui.IViewReference; |
| import org.eclipse.ui.IWorkbenchPage; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.PartInitException; |
| import org.eclipse.ui.console.IConsole; |
| import org.eclipse.ui.console.IConsoleConstants; |
| import org.eclipse.ui.console.IConsoleView; |
| import org.eclipse.ui.progress.WorkbenchJob; |
| import org.eclipse.ui.statushandlers.StatusManager; |
| |
| import org.eclipse.statet.ecommons.collections.FastList; |
| import org.eclipse.statet.ecommons.ts.ui.workbench.WorkbenchToolRegistryListener; |
| import org.eclipse.statet.ecommons.ts.ui.workbench.WorkbenchToolSessionData; |
| import org.eclipse.statet.ecommons.ui.util.UIAccess; |
| |
| import org.eclipse.statet.nico.core.runtime.ToolProcess; |
| import org.eclipse.statet.nico.ui.NicoUI; |
| import org.eclipse.statet.nico.ui.NicoUITools; |
| import org.eclipse.statet.nico.ui.console.NIConsole; |
| |
| |
| /** |
| * part of tool registry per workbench page |
| */ |
| class PageRegistry implements IDebugEventSetListener, IDebugContextListener { |
| |
| |
| static final String SHOW_CONSOLE_JOB_NAME = "Show NIConsole"; //$NON-NLS-1$ |
| |
| |
| private class ShowConsoleViewJob extends WorkbenchJob { |
| |
| private final int fDelay; |
| |
| private volatile NIConsole fConsoleToShow; |
| private volatile boolean fActivate; |
| |
| |
| public ShowConsoleViewJob(final int delay) { |
| super(SHOW_CONSOLE_JOB_NAME); |
| setSystem(true); |
| setPriority(Job.SHORT); |
| fDelay = delay; |
| } |
| |
| |
| public void schedule(final NIConsole console, final boolean activate) { |
| cancel(); |
| fConsoleToShow = console; |
| fActivate = activate; |
| schedule(fDelay); |
| } |
| |
| @Override |
| public IStatus runInUIThread(final IProgressMonitor monitor) { |
| final NIConsole console = fConsoleToShow; |
| if (fClosed || console == null) { |
| return Status.CANCEL_STATUS; |
| } |
| try { |
| final IWorkbenchPart activePart = fPage.getActivePart(); |
| if (activePart instanceof IConsoleView) { |
| if (console == ((IConsoleView) activePart).getConsole()) { |
| ((IConsoleView) activePart).setFocus(); |
| return Status.OK_STATUS; |
| } |
| } |
| final IConsoleView view = searchView(console); |
| return showInView(view, monitor); |
| } |
| catch (final PartInitException e) { |
| NicoUIPlugin.logError(NicoUIPlugin.INTERNAL_ERROR, "Error of unexpected type occured, when showing a console view.", e); //$NON-NLS-1$ |
| return Status.OK_STATUS; |
| } |
| finally { |
| fConsoleToShow = null; |
| } |
| } |
| |
| private IStatus showInView(IConsoleView view, final IProgressMonitor monitor) throws PartInitException { |
| final NIConsole console = fConsoleToShow; |
| final boolean activate = fActivate; |
| if (fClosed || monitor.isCanceled()) { |
| return Status.CANCEL_STATUS; |
| } |
| |
| if (view == null) { |
| final String secId = console.getType() + System.currentTimeMillis(); // force creation |
| view = (IConsoleView) fPage.showView(IConsoleConstants.ID_CONSOLE_VIEW, secId, IWorkbenchPage.VIEW_CREATE); |
| } |
| view.display(console); |
| if (activate) { |
| fPage.activate(view); |
| } |
| else { |
| fPage.bringToTop(view); |
| } |
| finish(view); |
| return Status.OK_STATUS; |
| } |
| |
| protected void finish(final IConsoleView view) { |
| } |
| |
| } |
| |
| private class OnConsoleChangedJob extends Job implements ISchedulingRule { |
| |
| private volatile NIConsole fConsole; |
| private volatile IViewPart fSource; |
| private volatile List<ToolProcess> fExclude; |
| |
| public OnConsoleChangedJob() { |
| super("NicoUI Registry - On Console Changed"); |
| setSystem(true); |
| setPriority(Job.SHORT); |
| } |
| |
| @Override |
| public boolean belongsTo(final Object family) { |
| return (family == PageRegistry.this); |
| } |
| |
| @Override |
| public boolean contains(final ISchedulingRule rule) { |
| return false; |
| } |
| |
| @Override |
| public boolean isConflicting(final ISchedulingRule rule) { |
| if (rule instanceof Job) { |
| return ((Job) rule).belongsTo(PageRegistry.this); |
| } |
| return false; |
| } |
| |
| |
| public void scheduleActivated(final NIConsole console, final IViewPart source) { |
| synchronized (PageRegistry.this) { |
| if (fExclude != null && console != null && fExclude.contains(console.getProcess())) { |
| return; |
| } |
| cancel(); // ensure delay |
| fConsole = console; |
| fSource = source; |
| schedule(50); |
| } |
| } |
| |
| public void scheduleRemoved(final List<ToolProcess> exclude) { |
| synchronized (PageRegistry.this) { |
| if (fConsole != null && exclude.contains(fConsole.getProcess())) { |
| fConsole = null; |
| } |
| else if (fActiveProcess == null && !exclude.contains(fActiveProcess)) { |
| return; |
| } |
| cancel(); // ensure delay |
| fExclude = exclude; |
| schedule(200); |
| } |
| } |
| |
| @Override |
| protected IStatus run(final IProgressMonitor monitor) { |
| if (fClosed) { |
| return Status.OK_STATUS; |
| } |
| NIConsole console = fConsole; |
| final List<ToolProcess> exclude = fExclude; |
| |
| if (console == null) { |
| final AtomicReference<NIConsole> ref= new AtomicReference<>(); |
| UIAccess.getDisplay(fPage.getWorkbenchWindow().getShell()).syncExec(new Runnable() { |
| @Override |
| public void run() { |
| ref.set(searchConsole((exclude != null) ? |
| exclude : Collections.<ToolProcess>emptyList() )); |
| } |
| }); |
| console = ref.get(); |
| } |
| |
| synchronized(PageRegistry.this) { |
| if (monitor.isCanceled()) { |
| return Status.CANCEL_STATUS; |
| } |
| if (fConsole == console) { |
| fConsole = null; |
| fExclude = null; |
| } |
| |
| if ((console == fActiveConsole) || (console == null && fActiveConsole == null)) { |
| return Status.OK_STATUS; |
| } |
| fActiveProcess = (console != null) ? console.getProcess() : null; |
| fActiveConsole = console; |
| } |
| |
| // don't cancel after process is changed |
| notifyActiveToolSessionChanged(fSource); |
| |
| return Status.OK_STATUS; |
| } |
| |
| } |
| |
| private class OnToolTerminatedJob extends Job implements ISchedulingRule { |
| |
| private volatile ToolProcess fTool; |
| |
| public OnToolTerminatedJob() { |
| super("NicoUI Registry - On Tool Terminated"); //$NON-NLS-1$ |
| setSystem(true); |
| setPriority(Job.SHORT); |
| } |
| |
| @Override |
| public boolean belongsTo(final Object family) { |
| return (family == PageRegistry.this); |
| } |
| |
| @Override |
| public boolean contains(final ISchedulingRule rule) { |
| return false; |
| } |
| |
| @Override |
| public boolean isConflicting(final ISchedulingRule rule) { |
| if (rule instanceof Job) { |
| return ((Job) rule).belongsTo(PageRegistry.this); |
| } |
| return false; |
| } |
| |
| |
| public void scheduleTerminated(final ToolProcess tool) { |
| fTool = tool; |
| schedule(0); |
| } |
| |
| @Override |
| public synchronized IStatus run(final IProgressMonitor monitor) { |
| final ToolProcess tool = fTool; |
| fTool = null; |
| |
| if (getActiveProcess() == tool) { |
| notifyToolTerminated(); |
| } |
| return Status.OK_STATUS; |
| } |
| |
| } |
| |
| |
| private final IWorkbenchPage fPage; |
| private boolean fClosed; |
| private IDebugContextListener fDebugContextListener; |
| |
| private ToolProcess fActiveProcess; |
| private NIConsole fActiveConsole; |
| |
| final FastList<WorkbenchToolRegistryListener> fListeners; |
| |
| private final ShowConsoleViewJob fShowConsoleViewJob = new ShowConsoleViewJob(100); |
| private final OnConsoleChangedJob fConsoleUpdateJob = new OnConsoleChangedJob(); |
| private final OnToolTerminatedJob fTerminatedJob = new OnToolTerminatedJob(); |
| |
| |
| PageRegistry(final IWorkbenchPage page, final WorkbenchToolRegistryListener[] initial) { |
| fPage = page; |
| fListeners= new FastList<>(WorkbenchToolRegistryListener.class, FastList.IDENTITY, initial); |
| |
| DebugUITools.getDebugContextManager().getContextService(fPage.getWorkbenchWindow()).addDebugContextListener(this); |
| DebugPlugin.getDefault().addDebugEventListener(this); |
| } |
| |
| |
| public synchronized void dispose() { |
| fClosed = true; |
| DebugPlugin.getDefault().removeDebugEventListener(this); |
| DebugUITools.getDebugContextManager().getContextService(fPage.getWorkbenchWindow()).removeDebugContextListener(this); |
| fShowConsoleViewJob.cancel(); |
| fConsoleUpdateJob.cancel(); |
| fTerminatedJob.cancel(); |
| |
| fListeners.clear(); |
| fActiveProcess = null; |
| fActiveConsole = null; |
| } |
| |
| |
| @Override |
| public void debugContextChanged(final DebugContextEvent event) { |
| final ISelection selection = event.getContext(); |
| if (selection instanceof IStructuredSelection) { |
| final IStructuredSelection sel = (IStructuredSelection) selection; |
| if (sel.size() == 1) { |
| final Object element = sel.getFirstElement(); |
| ToolProcess tool = null; |
| if (element instanceof IAdaptable) { |
| final IProcess process = ((IAdaptable) element).getAdapter(IProcess.class); |
| if (process instanceof ToolProcess) { |
| tool = (ToolProcess) process; |
| } |
| } |
| if (tool == null && element instanceof ILaunch) { |
| final IProcess[] processes = ((ILaunch) element).getProcesses(); |
| for (int i = 0; i < processes.length; i++) { |
| if (processes[i] instanceof ToolProcess) { |
| tool = (ToolProcess) processes[i]; |
| break; |
| } |
| } |
| } |
| if (tool != null) { |
| showConsole(NicoUITools.getConsole(tool), false); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void handleDebugEvents(final DebugEvent[] events) { |
| final ToolProcess tool = fActiveProcess; |
| if (tool == null) { |
| return; |
| } |
| for (final DebugEvent event : events) { |
| if (event.getSource() == tool && event.getKind() == DebugEvent.TERMINATE) { |
| fTerminatedJob.scheduleTerminated(tool); |
| } |
| } |
| } |
| |
| public IWorkbenchPage getPage() { |
| return fPage; |
| } |
| |
| public synchronized ToolProcess getActiveProcess() { |
| return fActiveProcess; |
| } |
| |
| public synchronized WorkbenchToolSessionData createSessionInfo(final IViewPart source) { |
| return new WorkbenchToolSessionData(fActiveProcess, fActiveConsole, fPage, null); |
| } |
| |
| public IConsoleView getConsoleView(final NIConsole console) { |
| if (fClosed) { |
| return null; |
| } |
| return searchView(console); |
| } |
| |
| void handleConsolesRemoved(final List<ToolProcess> tools) { |
| fConsoleUpdateJob.scheduleRemoved(tools); |
| } |
| |
| void handleActiveConsoleChanged(final NIConsole console, final IViewPart source) { |
| fConsoleUpdateJob.scheduleActivated(console, source); |
| } |
| |
| void showConsole(final NIConsole console, final boolean activate) { |
| fShowConsoleViewJob.schedule(console, activate); |
| } |
| |
| void showConsoleExplicitly(final NIConsole console, final boolean pin) { |
| fShowConsoleViewJob.cancel(); |
| new ShowConsoleViewJob(0) { |
| @Override |
| protected void finish(final IConsoleView view) { |
| if (pin) { |
| view.setPinned(true); |
| } |
| } |
| }.schedule(console, true); |
| } |
| |
| |
| private void notifyActiveToolSessionChanged(final IViewPart source) { |
| final WorkbenchToolSessionData sessionData = new WorkbenchToolSessionData(fActiveProcess, fActiveConsole, |
| fPage, source); |
| if (ToolRegistry.DEBUG) { |
| System.out.println("[tool registry] tool session activated: " + sessionData.toString()); |
| } |
| |
| final Object[] listeners = fListeners.toArray(); |
| for (final Object obj : listeners) { |
| try { |
| ((WorkbenchToolRegistryListener) obj).toolSessionActivated(sessionData); |
| } |
| catch (final Exception e) { |
| StatusManager.getManager().handle(new Status(IStatus.ERROR, NicoUI.BUNDLE_ID, -1, |
| "An error occurred when handling tool activation.", e )); |
| } |
| } |
| } |
| |
| private void notifyToolTerminated() { |
| final WorkbenchToolSessionData sessionData = new WorkbenchToolSessionData(fActiveProcess, fActiveConsole, |
| fPage, null); |
| if (ToolRegistry.DEBUG) { |
| System.out.println("[tool registry] activate tool terminated: " + sessionData.toString()); |
| } |
| |
| final Object[] listeners = fListeners.toArray(); |
| for (final Object obj : listeners) { |
| try { |
| ((WorkbenchToolRegistryListener) obj).toolTerminated(sessionData); |
| } |
| catch (final Exception e) { |
| StatusManager.getManager().handle(new Status(IStatus.ERROR, NicoUI.BUNDLE_ID, -1, |
| "An error occurred when handling tool termination.", e )); |
| } |
| } |
| } |
| |
| private List<IConsoleView> getConsoleViews() { |
| final List<IConsoleView> consoleViews= new ArrayList<>(); |
| |
| final IViewReference[] allReferences = fPage.getViewReferences(); |
| for (final IViewReference reference : allReferences) { |
| if (reference.getId().equals(IConsoleConstants.ID_CONSOLE_VIEW)) { |
| final IViewPart view = reference.getView(true); |
| if (view != null) { |
| final IConsoleView consoleView = (IConsoleView) view; |
| if (!consoleView.isPinned()) { |
| consoleViews.add(consoleView); |
| } |
| else if (consoleView.getConsole() instanceof NIConsole) { |
| consoleViews.add(0, consoleView); |
| } |
| } |
| } |
| } |
| return consoleViews; |
| } |
| |
| /** |
| * Searches best next console (tool) |
| * |
| * Must be called only in UI thread |
| */ |
| private NIConsole searchConsole(final List<ToolProcess> exclude) { |
| // Search NIConsole in |
| // 1. active part |
| // 2. visible part |
| // 3. all |
| NIConsole nico = null; |
| final IWorkbenchPart part = fPage.getActivePart(); |
| if (part instanceof IConsoleView) { |
| final IConsole console = ((IConsoleView) part).getConsole(); |
| if (console instanceof NIConsole && !exclude.contains((nico = (NIConsole) console).getProcess())) { |
| return nico; |
| } |
| } |
| |
| final List<IConsoleView> consoleViews = getConsoleViews(); |
| NIConsole secondChoice = null; |
| for (final IConsoleView view : consoleViews) { |
| final IConsole console = view.getConsole(); |
| if (console instanceof NIConsole && !exclude.contains((nico = (NIConsole) console).getProcess())) { |
| if (fPage.isPartVisible(view)) { |
| return nico; |
| } |
| else if (secondChoice == null) { |
| secondChoice = nico; |
| } |
| } |
| } |
| return secondChoice; |
| } |
| |
| /** |
| * Searches the best console view for the specified console (tool) |
| * |
| * @param console |
| * @return |
| */ |
| private IConsoleView searchView(final NIConsole console) { |
| // Search the console view |
| final List<IConsoleView> views = getConsoleViews(); |
| |
| final IConsoleView[] preferedView = new IConsoleView[10]; |
| for (final IConsoleView view : views) { |
| final IConsole consoleInView = view.getConsole(); |
| if (consoleInView == console) { |
| if (fPage.isPartVisible(view)) { // already visible |
| preferedView[view.isPinned() ? 0 : 1] = view; |
| continue; |
| } |
| else { // already selected |
| preferedView[view.isPinned() ? 2 : 3] = view; |
| continue; |
| } |
| } |
| if (consoleInView == null) { |
| if (fPage.isPartVisible(view)) { |
| preferedView[4] = view; |
| continue; |
| } |
| else { |
| preferedView[5] = view; |
| continue; |
| } |
| } |
| if (!view.isPinned()) { // for same type created view |
| final String secId = view.getViewSite().getSecondaryId(); |
| if (secId != null && secId.startsWith(console.getType())) { |
| preferedView[6] = view; |
| continue; |
| } |
| if (fPage.isPartVisible(view)) { // visible views |
| preferedView[7] = view; |
| continue; |
| } |
| else { // other views |
| preferedView[8] = view; |
| continue; |
| } |
| } |
| } |
| for (int i = 0; i < preferedView.length; i++) { |
| if (preferedView[i] != null) { |
| return preferedView[i]; |
| } |
| } |
| return null; |
| } |
| |
| } |
