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

/**
 * Determines if given perspective is shown
 * 
 * @param id
 * @return true if the perspective with current id is shown, false otherwise
 */
public static boolean isPerspectiveShown(String perspectiveId) {
    if (perspectiveId == null || perspectiveId.equals("")) {
        return false;
    }
    IWorkbenchWindow[] workbenchWindows = PlatformUI.getWorkbench().getWorkbenchWindows();
    for (int i = 0; i < workbenchWindows.length; i++) {
        IPerspectiveDescriptor[] openPerspectives = workbenchWindows[i].getActivePage().getOpenPerspectives();
        for (int j = 0; j < openPerspectives.length; j++) {
            if (perspectiveId.equals(openPerspectives[j].getId())) {
                return true;
            }
        }
    }
    return false;
}

/**
 * Adds the new wizards to the current perspective displayed in <code>activeWorkbenchWindow</code>, if they've not
 * been added already. Adds listeners on the window so that the same is done whenever the user switches perspectives
 * in the window.
 *
 * Note: This method can only be called once the workbench has been started.
 */
private void maybeAddNewWizardActionsToWindow(IWorkbenchWindow activeWorkbenchWindow) {
  if (activeWorkbenchWindow == null) {
    return;
  }

  activeWorkbenchWindow.addPerspectiveListener(perspectiveListener);

  WorkbenchPage activePage = (WorkbenchPage) activeWorkbenchWindow.getActivePage();
  if (activePage == null) {
    return;
  }

  IPerspectiveDescriptor perspectiveDesc = activePage.getPerspective();
  maybeAddNewWizardActionsToPerspective(activePage, perspectiveDesc);
}

public void perspectiveChanged(IWorkbenchPage page, IPerspectiveDescriptor perspective, String changeId)
{
    if (changeId.equals(IWorkbenchPage.CHANGE_VIEW_HIDE))
    {
        if (findView(page, OUTLINE_VIEW_ID) == null)
        {
            setCommandState(false);
        }
    }
    else if (changeId.equals(IWorkbenchPage.CHANGE_VIEW_SHOW))
    {
        if (findView(page, OUTLINE_VIEW_ID) != null)
        {
            setCommandState(true);
        }
    }
}

private static void replaceCurrentPerspective(IPerspectiveDescriptor persp) {

        // Get the active page.
        IWorkbenchWindow window = PlatformUI.getWorkbench()
                .getActiveWorkbenchWindow();
        if (window == null) {
            return;
        }
        IWorkbenchPage page = window.getActivePage();
        if (page == null) {
            return;
        }

        // Set the perspective.
        page.setPerspective(persp);
    }

/**
 * Adds to the list all perspective IDs in the Workbench who's original ID
 * matches the given ID.
 * 
 * @param perspectiveIds
 *            the list of perspective IDs to supplement.
 * @param id
 *            the id to query.
 * @since 3.0
 */
@SuppressWarnings({ "unchecked" })
private static void addPerspectiveAndDescendants(List perspectiveIds,
        String id) {
    IPerspectiveRegistry registry = PlatformUI.getWorkbench()
            .getPerspectiveRegistry();
    IPerspectiveDescriptor[] perspectives = registry.getPerspectives();
    for (int i = 0; i < perspectives.length; i++) {
        // @issue illegal ref to workbench internal class;
        // consider adding getOriginalId() as API on IPerspectiveDescriptor
        PerspectiveDescriptor descriptor = ((PerspectiveDescriptor) perspectives[i]);
        if (descriptor.getOriginalId().equals(id)) {
            perspectiveIds.add(descriptor.getId());
        }
    }
}

public void run(IIntroSite site, Properties params) {
    PlatformUI.getWorkbench().getIntroManager().closeIntro(PlatformUI.getWorkbench().getIntroManager().getIntro());

    IPerspectiveDescriptor currentPerspective = site.getPage().getPerspective();
    if (!PERSPECTIVE_ID.equals(currentPerspective.getId())) {
        // show required perspective
        IWorkbenchWindow workbenchWindow = site.getWorkbenchWindow();
        try {
            workbenchWindow.getWorkbench().showPerspective(PERSPECTIVE_ID, workbenchWindow);
        } catch (WorkbenchException e) {
            ExceptionHandler.process(e);
            return;
        }
    }

    // find repository node
    repositoryNode = (RepositoryNode) RepositorySeekerManager.getInstance().searchRepoViewNode(params.getProperty("nodeId"),
            false);
    if (null != repositoryNode) {
        // expand/select node item
        RepositoryManagerHelper.getRepositoryView().getViewer().setSelection(new StructuredSelection(repositoryNode));
        init(repositoryNode);
        doRun();
    }
}

private void addPerspectiveListener(IWorkbenchWindow window) {
    IPerspectiveListener perspectiveListener = new PerspectiveListener();
    window.addPerspectiveListener(perspectiveListener);

    // triggers the event for the currently open perspective, if there is
    // any
    IWorkbenchPage activePage = window.getActivePage();
    if (activePage != null) {
        IPerspectiveDescriptor currentPerspective = window.getActivePage()
                .getPerspective();
        if (currentPerspective != null) {
            perspectiveListener.perspectiveActivated(activePage,
                    currentPerspective);
        }

    }
}

/**
 * Create a new action for opening a perspective
 * 
 * @param perspectiveDescriptor
 *            the perspective to be opened
 */
OpenPerspectiveAction(IPerspectiveDescriptor perspectiveDescriptor, String name, String icon){
    super(perspectiveDescriptor.getLabel());

    setId(perspectiveDescriptor.getId());
    if (!StringTool.isNothing(icon)) {
        setImageDescriptor(perspectiveDescriptor.getImageDescriptor());
    } else {

        setImageDescriptor(perspectiveDescriptor.getImageDescriptor());
    }

    setToolTipText((StringTool.isNothing(name) ? perspectiveDescriptor.getLabel() : name)
        + Messages.ApplicationActionBarAdvisor_10);

    this.perspectiveDescriptor = perspectiveDescriptor;
}

@SuppressWarnings("restriction")
private IPerspectiveDescriptor savePerspectiveToRegistryLegacy(MPerspective perspective){
    IPerspectiveRegistry perspectiveRegistry =
        (PerspectiveRegistry) PlatformUI.getWorkbench().getPerspectiveRegistry();
    IPerspectiveDescriptor pd =
        perspectiveRegistry.findPerspectiveWithId(perspective.getElementId());
    if (pd == null) {
        ((PerspectiveRegistry) perspectiveRegistry).addPerspective(perspective);
        pd = perspectiveRegistry.findPerspectiveWithId(perspective.getElementId());
    } else {
        LoggerFactory.getLogger(PerspektiveImportHandler.class)
            .error("perspective descriptor already exists for perspective id: "
            + perspective.getElementId());
    }

    return pd;
}

@Override
public int deletePerspective(String perspectiveId){
    IPerspectiveRegistry iPerspectiveRegistry =
        PlatformUI.getWorkbench().getPerspectiveRegistry();
    MApplication mApplication = getService(MApplication.class);
    IPerspectiveDescriptor existingPerspectiveDescriptor =
        iPerspectiveRegistry.findPerspectiveWithId(perspectiveId);

    int idx = -1;

    if (existingPerspectiveDescriptor != null) {

        idx = closePerspective(existingPerspectiveDescriptor);
        //NOT WORKING IF PERSPECTIVE IS PREDEFINED - workaround with generics
        iPerspectiveRegistry.deletePerspective(existingPerspectiveDescriptor);
        PerspectiveImportService.genericInvokMethod(iPerspectiveRegistry, "removeSnippet",
            MSnippetContainer.class, String.class, mApplication,
            existingPerspectiveDescriptor.getId());

    }
    return idx;
}

private int isPerspectiveInsideStack(IPerspectiveDescriptor pd){
    int idx = -1;
    if (pd != null) {
        List<MPerspective> perspectivesInStack;
        MPerspectiveStack mPerspectiveStack = getPerspectiveStack();
        perspectivesInStack = mPerspectiveStack.getChildren();

        for (MPerspective perspectiveInStack : perspectivesInStack) {
            if (pd.getId().equals(perspectiveInStack.getElementId())) {
                idx++;
                break;
            }
        }
    }
    return idx;
}

@Override
public void fill(ToolBar parent, int index) {
    IPerspectiveRegistry pr = PlatformUI.getWorkbench().
        getPerspectiveRegistry();

    String cfg = CoreHub.localCfg.get(Preferences.CFG_PERSPEKTIVEN, "");
    String[] ids = cfg.split(",");
    if (cfg == "") return;

    for (String id: ids) {
        IPerspectiveDescriptor pd = pr.findPerspectiveWithId(id);
        if (pd == null) continue;

        ToolItem ti = new ToolItem(parent, SWT.PUSH);
        ImageDescriptor idesc = pd.getImageDescriptor();
        Image im = (idesc != null ? idesc.createImage() : null);
        if (im != null)
            ti.setImage(im);
        else
            ti.setText(pd.getLabel());
        ti.setToolTipText(pd.getLabel());
        ti.addSelectionListener(new TISelListener(pd.getId()));
    }

    parent.update();
}

public void perspectiveActivated(IWorkbenchPage page, IPerspectiveDescriptor perspective) {

        ConvertigoPlugin.logDebug3("IWorkbenchPage perspectiveActivated : " + page.getLabel() + "("
                + page.toString() + ")");
        if (!perspective.getId().equalsIgnoreCase(ConvertigoPlugin.PLUGIN_PERSPECTIVE_ID)) {
        } else {
        }
    }

public void perspectiveChanged(IWorkbenchPage page, IPerspectiveDescriptor perspective, String changeId) {
    ConvertigoPlugin.logDebug3("IWorkbenchPage perspectiveChanged : " + page.getLabel() + "("
            + perspective.getLabel() + " - " + changeId + ")");

    IViewReference introView = page.findViewReference("org.eclipse.ui.internal.introview");
    // Maximize the intro view if present
    if (introView != null) {
        page.setPartState(introView, IWorkbenchPage.STATE_MAXIMIZED);
    }
}

/**
 * Removes the unwanted perspectives from your RCP application
 */
public void removeUnWantedPerspectives() {
    IPerspectiveRegistry perspectiveRegistry = PlatformUI.getWorkbench().getPerspectiveRegistry();
    IPerspectiveDescriptor[] perspectiveDescriptors = getAllRegisteredPerspectiveDescriptors();
    ArrayList<IPerspectiveDescriptor> ignorePerspectiveList = getIgnorePerspectiveList(perspectiveDescriptors);
    removePerspetives(perspectiveRegistry, ignorePerspectiveList);
}

private void removePerspetives(IPerspectiveRegistry perspectiveRegistry, List<IPerspectiveDescriptor> removePerspectiveDesc) {
    // If the list is non-empty then remove all such perspectives from the IExtensionChangeHandler
    if(perspectiveRegistry instanceof IExtensionChangeHandler && !removePerspectiveDesc.isEmpty()) {
        IExtensionChangeHandler extChgHandler = (IExtensionChangeHandler) perspectiveRegistry;
        extChgHandler.removeExtension(null, removePerspectiveDesc.toArray());
    }
}

private ArrayList<IPerspectiveDescriptor> getIgnorePerspectiveList(IPerspectiveDescriptor[] registeredPerspetives){        
    ArrayList<IPerspectiveDescriptor> ignorePerspectiveList = new ArrayList<>();
    for (IPerspectiveDescriptor perspectiveDescriptor : registeredPerspetives) {
        if(!ELTPerspectives.contains(perspectiveDescriptor.getId())) {
            ignorePerspectiveList.add(perspectiveDescriptor);
        }
    }
    return ignorePerspectiveList;
}

private static void openInNewWindow(IPerspectiveDescriptor desc) {

        // Open the page.
        try {
            PlatformUI.getWorkbench().openWorkbenchWindow(desc.getId(), ResourcesPlugin.getWorkspace().getRoot());
        } catch (WorkbenchException e) {
            IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
            if (window != null) {
                ErrorDialog.openError(window.getShell(), WINDOW_PROBLEMS_TITLE, e.getMessage(), e.getStatus());
            }
        }
    }

private static void replaceCurrentPerspective(IPerspectiveDescriptor persp) {

        // Get the active page.
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        if (window == null) {
            return;
        }
        IWorkbenchPage page = window.getActivePage();
        if (page == null) {
            return;
        }

        // Set the perspective.
        page.setPerspective(persp);
    }

/**
 * Adds to the list all perspective IDs in the Workbench who's original ID
 * matches the given ID.
 *
 * @param perspectiveIds
 *            the list of perspective IDs to supplement.
 * @param id
 *            the id to query.
 * @since 3.0
 */
private static void addPerspectiveAndDescendants(List perspectiveIds, String id) {
    IPerspectiveRegistry registry = PlatformUI.getWorkbench().getPerspectiveRegistry();
    IPerspectiveDescriptor[] perspectives = registry.getPerspectives();
    for (int i = 0; i < perspectives.length; i++) {
        // @issue illegal ref to workbench internal class;
        // consider adding getOriginalId() as API on IPerspectiveDescriptor
        PerspectiveDescriptor descriptor = ((PerspectiveDescriptor) perspectives[i]);
        if (descriptor.getOriginalId().equals(id)) {
            perspectiveIds.add(descriptor.getId());
        }
    }
}

/**
 * Prompts the user for whether to switch perspectives.
 *
 * @param window
 *            The workbench window in which to switch perspectives; must not
 *            be <code>null</code>
 * @param finalPersp
 *            The perspective to switch to; must not be <code>null</code>.
 *
 * @return <code>true</code> if it's OK to switch, <code>false</code>
 *         otherwise
 */
private static boolean confirmPerspectiveSwitch(IWorkbenchWindow window, IPerspectiveDescriptor finalPersp) {
    IPreferenceStore store = IDEWorkbenchPlugin.getDefault().getPreferenceStore();
    String pspm = store.getString(IDEInternalPreferences.PROJECT_SWITCH_PERSP_MODE);
    if (!IDEInternalPreferences.PSPM_PROMPT.equals(pspm)) {
        // Return whether or not we should always switch
        return IDEInternalPreferences.PSPM_ALWAYS.equals(pspm);
    }
    String desc = finalPersp.getDescription();
    String message;
    if (desc == null || desc.length() == 0)
        message = NLS.bind(ResourceMessages.NewProject_perspSwitchMessage, finalPersp.getLabel());
    else
        message = NLS.bind(ResourceMessages.NewProject_perspSwitchMessageWithDesc,
                new String[] { finalPersp.getLabel(), desc });

    MessageDialogWithToggle dialog = MessageDialogWithToggle.openYesNoQuestion(window.getShell(),
            ResourceMessages.NewProject_perspSwitchTitle, message,
            null /* use the default message for the toggle */,
            false /* toggle is initially unchecked */, store, IDEInternalPreferences.PROJECT_SWITCH_PERSP_MODE);
    int result = dialog.getReturnCode();

    // If we are not going to prompt anymore propogate the choice.
    if (dialog.getToggleState()) {
        String preferenceValue;
        if (result == IDialogConstants.YES_ID) {
            // Doesn't matter if it is replace or new window
            // as we are going to use the open perspective setting
            preferenceValue = IWorkbenchPreferenceConstants.OPEN_PERSPECTIVE_REPLACE;
        } else {
            preferenceValue = IWorkbenchPreferenceConstants.NO_NEW_PERSPECTIVE;
        }

        // update PROJECT_OPEN_NEW_PERSPECTIVE to correspond
        PrefUtil.getAPIPreferenceStore().setValue(IDE.Preferences.PROJECT_OPEN_NEW_PERSPECTIVE, preferenceValue);
    }
    return result == IDialogConstants.YES_ID;
}

private void hookListeners(IWorkbenchPage page) {
    IPerspectiveDescriptor perspective = page.getPerspective();
    if (perspective != null) {
        perspectiveActivated(page, perspective);
    }
    page.addPartListener(this);
}

@Override
public void perspectiveActivated(IWorkbenchPage page, IPerspectiveDescriptor perspective) {
    super.perspectiveActivated(page, perspective);
    if (UICoreConstant.PROJECT_CONSTANTS__UmlPerspectiveID.equals(perspective.getId())) {
        if (UMLLoginController.getInstance().getLoginState() != UMLNexcoreLoginEvent.LOG_IN) {
            MessageDialog.openWarning(getShell(),
                UMLMessage.LABEL_NEXCORE_UML_MODELER,
                UMLMessage.MESSAGE_LOGIN_ERROR);
        }
    }

    flag = true;
}

public static void switchToModelingPerspective(IWorkbenchWindow window) {
    IPreferenceStore prefs = UIPluginActivator.getDefault()
            .getPreferenceStore();
    boolean hide = prefs.getBoolean(AUTO_SWITCH_PERSPECTIVE);
    IWorkbenchPage page = window.getActivePage();
    if (!hide) {
        IWorkbench workbench = window.getWorkbench();
        IPerspectiveRegistry registry = workbench.getPerspectiveRegistry();
        IPerspectiveDescriptor descriptor = registry
                .findPerspectiveWithId(IYakinduSctPerspectives.ID_PERSPECTIVE_SCT_MODELING);
        if ((page != null) && (page.getPerspective() != descriptor)) {
            MessageDialogWithToggle dialog = MessageDialogWithToggle
                    .openYesNoQuestion(
                            window.getShell(),
                            "Confirm Perspective Switch",
                            "This kind of editor is associated with the YAKINDU Modeling perspective. Do you want to switch to this perspective now?",
                            "Do not offer to switch perspective in the future",
                            hide, prefs, AUTO_SWITCH_PERSPECTIVE);
            if (dialog.getReturnCode() == 2)
                page.setPerspective(descriptor);
            hide = dialog.getToggleState();
            prefs.setValue(AUTO_SWITCH_PERSPECTIVE, hide);
            try {
                InstanceScope.INSTANCE.getNode(UIPluginActivator.PLUGIN_ID)
                        .flush();
            } catch (BackingStoreException e) {
                e.printStackTrace();
            }
        }
    }
}

public void run() {
    if(server != null) {
        ServerPrefUtil.storeDefaultServer(server.getIp()+":"+server.getPort());
        ServerManager.getInstance().setDefaultServer(server);
        IWorkbenchPage page = win.getActivePage();
        IPerspectiveDescriptor perspective = page.getPerspective();
        if (Activator.getDefault().isPrePerspective(perspective.getId())) {
            if (MessageDialog.openConfirm(win.getShell(), "Reset Perspectives", "Default server is changed. Would you reset current perspective?")) {
                RCPUtil.resetPerspective();
            }
        } else {
            MessageDialog.openInformation(win.getShell(), "Custom perspective", "Default server is changed. But custom perspective is not applied");
        }
    }
}

public static void preLoadingPerspective(String[] ids){
    IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
    if (page != null) {
        IPerspectiveRegistry registry = PlatformUI.getWorkbench().getPerspectiveRegistry();
        IPerspectiveDescriptor active = page.getPerspective();
        for (int idx = ids.length - 1; idx >= 0; idx--) {
            if (active == null || !active.getId().equals(ids[idx])) {
                IPerspectiveDescriptor perspective = registry.findPerspectiveWithId(ids[idx]);
                page.setPerspective(perspective);
            }
        }
        page.setPerspective(active);
    }
}

public static void hidePerspectives(String[] ids) {
    IPerspectiveRegistry registry = PlatformUI.getWorkbench().getPerspectiveRegistry();
    IPerspectiveDescriptor[] descriptors = registry.getPerspectives();
    List ignoredPerspectives = Arrays.asList(ids);
    List removePerspectiveDesc = new ArrayList();
    for (IPerspectiveDescriptor desc : descriptors) {
        if (ignoredPerspectives.contains(desc.getId())) {
            removePerspectiveDesc.add(desc);
        }
    }
    if (registry instanceof IExtensionChangeHandler && !removePerspectiveDesc.isEmpty()) {
        IExtensionChangeHandler extChgHandler = (IExtensionChangeHandler) registry;
        extChgHandler.removeExtension(null, removePerspectiveDesc.toArray());
    }
}

public static void printPerspectives(){
    System.out.println("=== Perspectives ===");
    IPerspectiveRegistry registry = PlatformUI.getWorkbench().getPerspectiveRegistry();
    IPerspectiveDescriptor[] descriptors = registry.getPerspectives();
    for (int idx = 0; idx < descriptors.length; idx++) {
        System.out.println(descriptors[idx].getId());
    }
}

private static IPerspectiveDescriptor findOrBuildPerspectiveWithId(final String id) {
    IPerspectiveDescriptor tempDescriptor = getPerspectiveRegistry().findPerspectiveWithId(id);
    if ( tempDescriptor == null ) {
        tempDescriptor = new SimulationPerspectiveDescriptor(id);
    }
    return tempDescriptor;
}

@Override
public void perspectiveActivated(final IWorkbenchPage page, final IPerspectiveDescriptor perspective) {
    final WorkbenchWindow w = (WorkbenchWindow) page.getWorkbenchWindow();
    WorkbenchHelper.asyncRun(() -> {
        // RearrangeMenus.run();
        final IContributionItem[] items = w.getCoolBarManager2().getItems();
        // System.out.println(Arrays.toString(items));
        // We remove all contributions to the toolbar that do not
        // relate
        // to gama
        for (final IContributionItem item : items) {

            for (final String s1 : TOOLBAR_ACTION_SETS_TO_REMOVE) {
                if (item.getId().contains(s1)) {
                    try {
                        if (w.getCoolBarManager2().find(item.getId()) != null)
                            w.getCoolBarManager2().remove(item);
                    } catch (final Exception e) {}
                }
            }
        }

        // exploreMenus(w.getMenuBarManager(), "");
        for (final String s2 : MENUS_TO_REMOVE) {
            w.getMenuBarManager().remove(s2);
            w.getMenuManager().remove(s2);
        }
        // Update the tool and menu bars
        w.getCoolBarManager2().update(true);
        w.getMenuManager().update(true);
        w.getMenuBarManager().update(true);
    });
}

public static void setPerspective(final String perspectiveID) {
  runInDisplayThread(new Runnable() {
    public void run() {
      IPerspectiveDescriptor wantedPerspective = PlatformUI.getWorkbench().getPerspectiveRegistry()
          .findPerspectiveWithId(perspectiveID);

      PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().setPerspective(wantedPerspective);
    }
  });
}

/**
 * Returns the active perspective id if there is one
 * 
 * @return the active perspective id; <code>null</code> in case it could not be resolved.
 */
public static String getActivePerspectiveId()
{
    IPerspectiveDescriptor perspective = getActivePerspectiveDescriptor();
    if (perspective != null)
    {
        return perspective.getId();
    }
    return null;
}

/**
 * Returns the active perspective descriptor if there is one.
 * 
 * @return the active perspective descriptor; <code>null</code> in case it could not be resolved.
 */
public static IPerspectiveDescriptor getActivePerspectiveDescriptor()
{
    IWorkbenchPage activePage = getActivePage();
    if (activePage != null)
    {
        return activePage.getPerspective();
    }
    return null;
}

/**
 * Updates the window title. Format will be:
 * <p>
 * [pageInput -] [currentPerspective -] [editorInput -] [workspaceLocation -] productName
 */
private void updateTitle() {

    final IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
    final IWorkbenchWindow window = configurer.getWindow();

    IWorkbenchPart activePart = null;
    final IWorkbenchPage currentPage = window.getActivePage();

    IPerspectiveDescriptor persp = null;

    if (currentPage != null) {
        persp = currentPage.getPerspective();

        activePart = currentPage.getActivePart();
    }

    // Nothing to do if the part hasn't changed
    if ((activePart == _lastActivePart) && (currentPage == _lastActivePage) && (persp == _lastPerspective)) {
        return;
    }

    if (_lastActivePart != null) {
        _lastActivePart.removePropertyListener(_partPropertyListener);
    }

    _lastActivePart = activePart;
    _lastActivePage = currentPage;
    _lastPerspective = persp;

    if (activePart != null) {
        activePart.addPropertyListener(_partPropertyListener);
    }

    recomputeTitle();
}

public void showEmptyPerspective() {
    final IPerspectiveRegistry perspectiveRegistry = PlatformUI.getWorkbench().getPerspectiveRegistry();
    final IPerspectiveDescriptor perspectiveDescriptor = perspectiveRegistry.findPerspectiveWithId(DynamicPerspective.ID);
    final IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
    activePage.setPerspective(perspectiveDescriptor);
    perspectiveRegistry.setDefaultPerspective(DynamicPerspective.ID);
}

public void showPerspective(
    final ComponentNodeContext componentTreeNodeContext,
    final ComponentContext componentContext,
    final ILayout perspective) {
    if (perspective == null) {
        showEmptyPerspective();
        return;
    }

    final String perspectiveId = getPerspectiveId(perspective, componentTreeNodeContext);
    final IPerspectiveRegistry perspectiveRegistry = PlatformUI.getWorkbench().getPerspectiveRegistry();
    IPerspectiveDescriptor newPerspective = perspectiveRegistry.findPerspectiveWithId(perspectiveId);
    if (newPerspective == null) {
        final IPerspectiveDescriptor perspectiveDescriptor = perspectiveRegistry.findPerspectiveWithId(DynamicPerspective.ID);
        newPerspective = perspectiveRegistry.clonePerspective(
                perspectiveId,
                String.valueOf(perspective.getLabel()),
                perspectiveDescriptor);
        final IViewContainerContext context = registerViews(perspectiveId, perspective.getLayoutContainer(), componentContext);
        viewContainerContextMap.put(perspectiveId, context);
    }
    final IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
    activePage.setPerspective(newPerspective);

    // initialize views to update view titles from view model
    initializeViews();
}

public void resetPerspective(
    final ComponentNodeContext componentTreeNodeContext,
    final ComponentContext componentContext,
    final ILayout layout) {
    final IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
    final IPerspectiveDescriptor currentPerspective = activePage.getPerspective();
    showPerspective(componentTreeNodeContext, componentContext, layout);
    activePage.resetPerspective();
    activePage.setPerspective(currentPerspective);
    // initialize views to update view titles from view model
    initializeViews();
}

private static void openInNewWindow(IPerspectiveDescriptor desc, String windowProblemsTitle) {

        // Open the page.
        try {
            PlatformUI.getWorkbench().openWorkbenchWindow(desc.getId(),
                    ResourcesPlugin.getWorkspace().getRoot());
        } catch (WorkbenchException e) {
            IWorkbenchWindow window = PlatformUI.getWorkbench()
                    .getActiveWorkbenchWindow();
            if (window != null) {
                ErrorDialog.openError(window.getShell(), windowProblemsTitle,
                        e.getMessage(), e.getStatus());
            }
        }
    }

/**
    *  Implements IPerspectiveFactory.  Automatically adds all registered perspectives to the shortcut bar.  This ensures
    *  that all perspectives will be easily accessible regardless of the perspective that is currently selected. 
    */
   @Override
public void createInitialLayout(IPageLayout layout) {
    for (IPerspectiveDescriptor per : PlatformUI.getWorkbench().getPerspectiveRegistry().getPerspectives()) {
        layout.addPerspectiveShortcut(per.getId());
    }
   }

protected void cleanupPerspectives() {
    PerspectiveRegistry pRegistry = (PerspectiveRegistry) PlatformUI.getWorkbench().getPerspectiveRegistry();
    Collection<String> undesirables = getUndesirablePerspectives();
    List<IPerspectiveDescriptor> pToRemove = new ArrayList<IPerspectiveDescriptor>();
    for (IPerspectiveDescriptor pDesc : pRegistry.getPerspectives()) {
        if (undesirables.contains(pDesc.getId())) {
            pToRemove.add(pDesc);
        }
    }
    pRegistry.removeExtension(null, pToRemove.toArray(new Object[pToRemove.size()]));
    System.out.println();
}