Java 类org.eclipse.ui.IPartListener2 实例源码

private void addPartListenerToAllExistingPages(IPartListener2 eclipseListener) {
    for (IWorkbenchWindow window : eclipseAdapter.getWorkbench().getWorkbenchWindows()) {
        for (IWorkbenchPage page : window.getPages()) {
            page.addPartListener(eclipseListener);
        }
    }
}

private void removePartListenerFromAllExistingPages(IPartListener2 eclipseListener) {
    for (IWorkbenchWindow window : eclipseAdapter.getWorkbench().getWorkbenchWindows()) {
        for (IWorkbenchPage page : window.getPages()) {
            page.removePartListener(eclipseListener);
        }
    }
}

/**
 * Removes an {@link IEditorManagementListener} from the set of listeners getting notified of
 * opened and closed {@link IEditorPart}s.
 * 
 * @param listener
 *            The listener to be removed.
 */
public void removeEditorManagementListener(final IEditorManagementListener listener) {
    if (!listeners.containsKey(listener)) {
        throw new NoSuchElementException(listener.toString());
    } else {
        final IPartListener2 eclipseListener = listeners.get(listener);
        eclipseAdapter.executeSynchronous(new Runnable() {
            @Override
            public void run() {
                removePartListenerFromAllExistingPages(eclipseListener);
            }
        });
        listeners.remove(listener);
    }
}

@Test
public void executionListenerIsFiredOnEditorOpen() {
    IPartListener2 createEditorListener = createStrictMock(IPartListener2.class);
    reset(createEditorListener);
    createEditorListener.partOpened(isA(IWorkbenchPartReference.class));
    expectLastCall().andAnswer(IS_ARG_IEDITORPART_ANSWER).times(1);
    replay(createEditorListener);

    eclipse.getActiveWorkbenchPage().addPartListener(createEditorListener);
    eclipseMockCtrl.openNewNonEMFEditorPart();

    verify(createEditorListener);
}

@Test
public void executionListenerIsFiredOnEMFTreeEditorOpen() {
    IPartListener2 createEditorListener = createStrictMock(IPartListener2.class);
    reset(createEditorListener);
    createEditorListener.partOpened(isA(IWorkbenchPartReference.class));
    expectLastCall().andAnswer(IS_ARG_IEDITORPART_ANSWER).times(1);
    replay(createEditorListener);

    eclipse.getActiveWorkbenchPage().addPartListener(createEditorListener);
    eclipseMockCtrl.openNewEMFTreeEditorPart(Files.DATATYPE_ECORE);

    verify(createEditorListener);
}

@Test
public void executionListenerIsFiredOnGMFEditorOpen() {
    IPartListener2 createEditorListener = createStrictMock(IPartListener2.class);
    reset(createEditorListener);
    createEditorListener.partOpened(isA(IWorkbenchPartReference.class));
    expectLastCall().andAnswer(IS_ARG_IEDITORPART_ANSWER).times(1);
    replay(createEditorListener);

    eclipse.getActiveWorkbenchPage().addPartListener(createEditorListener);
    eclipseMockCtrl.openNewEMFDiagramEditorPart(Files.EXAMPLEMODEL_ECORE, Files.EXAMPLEMODEL_ECOREDIAG);

    verify(createEditorListener);
}

@Test
public void executionListenerIsFiredOnMultipleEditorOpen() {
    IPartListener2 createEditorListener = createStrictMock(IPartListener2.class);
    reset(createEditorListener);
    createEditorListener.partOpened(isA(IWorkbenchPartReference.class));
    expectLastCall().andAnswer(IS_ARG_IEDITORPART_ANSWER).times(3);
    replay(createEditorListener);

    eclipse.getActiveWorkbenchPage().addPartListener(createEditorListener);
    eclipseMockCtrl.openNewNonEMFEditorPart();
    eclipseMockCtrl.openNewEMFTreeEditorPart(Files.EMPTY_ECORE);
    eclipseMockCtrl.openNewEMFTreeEditorPart(Files.EMPTY_ECORE);
    verify(createEditorListener);
}

@Test
public void executionListenerIsFiredOnEditorClose() {
    IPartListener2 createEditorListener = createStrictMock(IPartListener2.class);
    reset(createEditorListener);
    createEditorListener.partClosed(isA(IWorkbenchPartReference.class));
    expectLastCall().times(1);
    replay(createEditorListener);

    IEditorPart editor = eclipseMockCtrl.openNewNonEMFEditorPart();
    eclipse.getActiveWorkbenchPage().addPartListener(createEditorListener);
    eclipseMockCtrl.closeEditorPart(editor);

    verify(createEditorListener);
}

public Collection<IPartListener2> getPartListeners() {
    List<IPartListener2> result = new ArrayList<>();
    for (IWorkbenchPage page : this.partListeners.keySet()) {
        result.addAll(partListeners.get(page));
    }
    return result;
}

/***************************************************************************
 * Called just after the workbench window is open.
 **************************************************************************/
public void postWindowOpen()
{
    // Show the master console as default. Showing this view must be
    // done this way in order to activate properly the log view.
    final IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
    try
    {
        window.getActivePage().showView(MasterView.ID);
    }
    catch (PartInitException e)
    {
        e.printStackTrace();
    }

    // Register the view manager for monitoring view operations
    IViewManager viewMgr = (IViewManager) ServiceManager.get(IViewManager.class);
    PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().addPartListener( (IPartListener2) viewMgr);

    // Show connection dialog in case of having procedures already loaded in the context
    final IContextProxy cproxy = (IContextProxy) ServiceManager.get(IContextProxy.class);
    if (cproxy.isConnected())
    {
        if (!cproxy.getAvailableExecutors().isEmpty())
        {
            final String ctx = cproxy.getCurrentContext();
            Display.getDefault().syncExec( new Runnable()
            {
                public void run()
                {
                    MessageDialog.openInformation(window.getShell(), "Open procedures", 
                            "There are procedures open on the current context " + ctx + ".\n\n" +
                            "Be aware of that there is a limit for the number of open procedures in the GCS system.\n\n" +
                            "It should be recommended to check the Master View for details.");

                }
            });
        }
    }
}

private void assignBoxPartListener() {
    final IPartService partService = getSite().getWorkbenchWindow().getPartService();
    if (partService == null) { return; }
    if (partListeners == null) {
        partListeners = new HashMap<IPartService, IPartListener2>();
    }
    final IPartListener2 oldListener = partListeners.get(partService);
    if (oldListener == null) {
        final IPartListener2 listener = new BoxDecoratorPartListener();
        partService.addPartListener(listener);
        partListeners.put(partService, listener);
    }
}

@Override
protected Optional<IPartListener2> createDisposeListener(IEditorPart editorPart) {
    if (editorPart instanceof CoreMultiDiagramEditor) {
        ((CoreMultiDiagramEditor) editorPart).onClose(() -> this.editorClosed(editorPart.getSite().getPage()));
    }
    return Optional.empty();
}

public void removeListener(IPartListener2 listener) {
    IWorkbenchPage page = EmacsPlusUtils.getWorkbenchPage(); 
    if (page != null && location != null) {
        page.removePartListener(listener);
    }
    location.clearListener();
    location = null;
}

private void registerEclipseListener(IEditorManagementListener listener, IPartListener2 eclipseListener) {
    listeners.put(listener, eclipseListener);
}

private IPartListener2 getEclipseListener(IEditorManagementListener listener) {
    return listeners.get(listener);
}

public Collection<IPartListener2> getPartListeners(IWorkbenchPage page) {
    return Collections.unmodifiableCollection(this.partListeners.get(page));
}

protected Optional<IPartListener2> createDisposeListener(IEditorPart editorPart) {
    return Optional.of(new DisposedListener(editorPart, this::editorClosed));
}

public void addListener(IPartListener2 listener) {
    IWorkbenchPage page = EmacsPlusUtils.getWorkbenchPage(); 
    if (page != null) {
        page.addPartListener(listener);
    }
}