/**
 * Handles extra things that should happen when we are launching in debug mode.
 */
private static void handleDebugMode() {
	Display.getDefault().asyncExec(() -> {

		// Switch to debug perspective
		if (PlatformUI.getWorkbench() != null) {
			IPerspectiveDescriptor descriptor =
				PlatformUI.getWorkbench().getPerspectiveRegistry().findPerspectiveWithId(
					IDebugUIConstants.ID_DEBUG_PERSPECTIVE);
			EclipseMessageUtils.getWorkbenchPage().setPerspective(descriptor);
		}

		// Start PyDev debugger
		if (PyDevUtils.isSupportedPyDevInstalled()) {
			try {
				PyDevUtils.startPyDevRemoteDebugger();
			}
			catch (OperationNotSupportedException e) {
				EclipseMessageUtils.error(
					"Failed to start the PyDev remote debugger.  PyDev version is not supported.");
			}
		}
	});
}
 

public AbapGitStagingView initializeView() throws PartInitException{
	AbapGitStagingView view;
	IWorkbenchPage activePage = PlatformUI.getWorkbench()
			.getActiveWorkbenchWindow().getActivePage();
	IPerspectiveDescriptor abapPerspective = PlatformUI.getWorkbench()
			.getPerspectiveRegistry()
			.findPerspectiveWithId("com.sap.adt.ui.AbapPerspective"); //$NON-NLS-1$
	activePage.setPerspective(abapPerspective);
	view = ((AbapGitStagingView) PlatformUI.getWorkbench().getActiveWorkbenchWindow()
			.getActivePage().showView(AbapGitStagingView.VIEW_ID));
	view.init(view.getViewSite());
	Shell shell = new Shell(Display.getDefault().getActiveShell());
	Composite parent = new Composite(shell, SWT.NONE);
	view.createPartControl(parent);				
	return view;
}
 

public AbapGitView initializeView() throws PartInitException {
	AbapGitView view;
	IWorkbenchPage activePage = PlatformUI.getWorkbench()
			.getActiveWorkbenchWindow().getActivePage();
	IPerspectiveDescriptor abapPerspective = PlatformUI.getWorkbench()
			.getPerspectiveRegistry()
			.findPerspectiveWithId("com.sap.adt.ui.AbapPerspective"); //$NON-NLS-1$
	activePage.setPerspective(abapPerspective);
	view = ((AbapGitView) PlatformUI.getWorkbench().getActiveWorkbenchWindow()
			.getActivePage().showView(AbapGitView.ID));
	view.init(view.getViewSite());
	Shell shell = new Shell(Display.getDefault().getActiveShell());
	Composite parent = new Composite(shell, SWT.NONE);
	view.createPartControl(parent);				
	return view;
}
 

/**
 * 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);
}
 

@Override
public Object execute(final ExecutionEvent event) throws ExecutionException {
	final IWorkbenchWindow activeWorkbenchWindow = HandlerUtil.getActiveWorkbenchWindow(event);
	if (activeWorkbenchWindow != null) {
		final WorkbenchPage page = (WorkbenchPage) activeWorkbenchWindow.getActivePage();
		if (page != null) {
			final IPerspectiveDescriptor descriptor = page.getPerspective();
			if (descriptor != null) {
				final String message =
						"Resetting the perspective will reload the current experiment. Do you want to proceed ?";
				final boolean result = MessageDialog.open(MessageDialog.QUESTION, activeWorkbenchWindow.getShell(),
						"Reset experiment perspective", message, SWT.SHEET);
				if (!result) { return null; }
				page.resetPerspective();
				GAMA.reloadFrontmostExperiment();
			}

		}
	}

	return null;

}
 

public static void cleanPerspectives() {
	final EModelService e = PlatformUI.getWorkbench().getService(EModelService.class);
	final MApplication a = PlatformUI.getWorkbench().getService(MApplication.class);

	final List<PerspectiveImpl> perspectives = e.findElements(a, PerspectiveImpl.class, EModelService.ANYWHERE,
		element -> matches(element.getElementId()));
	for ( final PerspectiveImpl p : perspectives ) {
		// DEBUG.OUT("Dirty perspective implementation found and removed: " + p.getElementId());
		p.getParent().getChildren().remove(p);
	}

	final IPerspectiveRegistry reg = PlatformUI.getWorkbench().getPerspectiveRegistry();
	for ( final IPerspectiveDescriptor desc : reg.getPerspectives() ) {
		if ( matches(desc.getId()) ) {
			// DEBUG.OUT("Dirty perspective descriptor found and removed: " + desc.getId());
			reg.deletePerspective(desc);
		}
	}

	// DEBUG.OUT("Current perspectives: " + listCurrentPerspectives());
}
 

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);
		}
	}
}
 

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();
    }
}
 

/**
 * Switch to the perspective with id given as parameter
 * 
 * @param perspectiveID
 */
public static synchronized void switchToPerspective(final String perspectiveID) {
    final IWorkbench workbench = PlatformUI.getWorkbench();
    final IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
    if (window != null) {
        final IWorkbenchPage activePage = window.getActivePage();
        if (activePage != null) {
            final IPerspectiveDescriptor activePerspective = activePage.getPerspective();
            if (activePerspective == null || !activePerspective.getId().equals(perspectiveID)) {
                final IPerspectiveRegistry registry = workbench.getPerspectiveRegistry();
                final IWorkbenchPage page = window.getActivePage();
                final IPerspectiveDescriptor desc = registry.findPerspectiveWithId(perspectiveID);
                page.setPerspective(desc);
            }
        }
    }
}
 

/**
 * 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)
			+ StringTool.space + 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 earlyStartup() {
        /*
         * The registration of the listener should have been done in the UI thread
         * since  PlatformUI.getWorkbench().getActiveWorkbenchWindow() returns null
         * if it is called outside of the UI thread.
         * */
         Display.getDefault().asyncExec(new Runnable() {
           /* (non-Javadoc)
           * @see java.lang.Runnable#run()
           */
           public void run() {
               SdkUtils.autoLoadSdksOnEarlyStart();
        	   UpdateManager.activateXdsUpdateContext();
        	   
        	   automaticUpdateScheduler = new AutomaticUpdateScheduler();
        	   automaticUpdateScheduler.earlyStartup();
        		
               final IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
               if (workbenchWindow != null) {
                 removeActionSets(workbenchWindow, workbenchWindow.getActivePage().getPerspective());
                 workbenchWindow.addPerspectiveListener(new PerspectiveAdapter() {
                   /* (non-Javadoc)
                   * @see org.eclipse.ui.PerspectiveAdapter#perspectiveActivated(org.eclipse.ui.IWorkbenchPage, org.eclipse.ui.IPerspectiveDescriptor)
                   */
                   @Override
                   public void perspectiveActivated(IWorkbenchPage page, IPerspectiveDescriptor perspectiveDescriptor) {
                     super.perspectiveActivated(page, perspectiveDescriptor);
//                     removeActionSets(workbenchWindow, perspectiveDescriptor);
                   }
                 });
               }
           }
         });
    }
 

private void removeActionSets(final IWorkbenchWindow workbenchWindow,
            IPerspectiveDescriptor perspectiveDescriptor) {
    	// TODO : FIXME not working in e4
//        if (perspectiveDescriptor.getId().indexOf(
//                XdsPerspectiveFactory.DEVELOPMENT_PERSPECTIVE_ID) > -1) {
//            if (workbenchWindow.getActivePage() instanceof WorkbenchPage) {
//                WorkbenchPage worbenchPage = (WorkbenchPage) workbenchWindow
//                        .getActivePage();
//                // Get the perspective
//                Perspective perspective = worbenchPage.findPerspective(perspectiveDescriptor);
//                
//                // hide some item at Project menu
//                perspective.getHiddenMenuItems().addAll(Arrays.asList(
//                		"org.eclipse.ui.internal.ide.actions.BuildSetMenu", //$NON-NLS-1$
//                		"org.eclipse.ui.project.buildProject",  //$NON-NLS-1$
//                		"org.eclipse.ui.project.buildAll",  //$NON-NLS-1$
//                		"org.eclipse.ui.project.closeProject",  //$NON-NLS-1$
//                		"org.eclipse.ui.project.openProject",  //$NON-NLS-1$
//                		"org.eclipse.ui.project.cleanAction")); //$NON-NLS-1$
//                
//                ArrayList toRemove = new ArrayList();
//                if (perspective != null) {
//                    
//                    for (IActionSetDescriptor actionSetDescriptor : perspective.getAlwaysOnActionSets()) {
//                        if (actionSetsToRemove.contains(actionSetDescriptor.getId())) {
//                            toRemove.add(actionSetDescriptor);
//                        }
//                    }
//                    perspective.turnOffActionSets((IActionSetDescriptor[]) toRemove.toArray(new IActionSetDescriptor[toRemove.size()]));
//                }
//            }
//        }
    }
 

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);
}
 

/**
 * Returns whether or not the user wishes to switch to the specified
 * perspective when a launch occurs.
 *
 * @param perspectiveName
 *            the name of the perspective that will be presented to the user
 *            for confirmation if they've asked to be prompted about
 *            perspective switching
 * @param message
 *            a message to be presented to the user. This message is
 *            expected to contain a slot for the perspective name to be
 *            inserted ("{0}").
 * @param preferenceKey
 *            the preference key of the perspective switching preference
 * @return whether or not the user wishes to switch to the specified
 *         perspective automatically
 */
private boolean shouldSwitchPerspective(IWorkbenchWindow window, String perspectiveId, String preferenceKey) {
    if (isCurrentPerspective(window, perspectiveId)) {
        return false;
    }
    IPerspectiveDescriptor perspective = PlatformUI.getWorkbench().getPerspectiveRegistry().findPerspectiveWithId(perspectiveId);
    String perspectiveName = (perspective == null) ? null : perspective.getLabel();
    if (perspectiveName == null) {
        return false;
    }
    String switchPerspective = Activator.getDefault().getPreferenceStore().getString(preferenceKey);
    if (MessageDialogWithToggle.ALWAYS.equals(switchPerspective)) {
        return true;
    } else if (MessageDialogWithToggle.NEVER.equals(switchPerspective)) {
        return false;
    }

    Shell shell= window.getShell();
    if (shell == null || fPrompting) {
        return false;
    }
    fPrompting = true;
    MessageDialogWithToggle dialog = MessageDialogWithToggle.openYesNoQuestion(
            shell,
            Messages.TmfPerspectiveManager_SwitchPerspectiveDialogTitle,
            MessageFormat.format(Messages.TmfPerspectiveManager_SwitchPerspectiveDialogMessage, perspectiveName),
            null,
            false,
            Activator.getDefault().getPreferenceStore(),
            preferenceKey);
    boolean answer = (dialog.getReturnCode() == IDialogConstants.YES_ID);
    synchronized (this) {
        fPrompting= false;
        notifyAll();
    }
    if (isCurrentPerspective(window, perspectiveId)) {
        answer = false;
    }
    return answer;
}
 

/**
 * Returns whether the given perspective identifier matches the identifier
 * of the current perspective.
 *
 * @param window
 *            the workbench window
 *
 * @param perspectiveId
 *            the identifier
 * @return whether the given perspective identifier matches the identifier
 *         of the current perspective
 */
private static boolean isCurrentPerspective(IWorkbenchWindow window, String perspectiveId) {
    boolean isCurrent= false;
    if (window != null) {
        IWorkbenchPage page = window.getActivePage();
        if (page != null) {
            IPerspectiveDescriptor perspectiveDescriptor = page.getPerspective();
            if (perspectiveDescriptor != null) {
                isCurrent= perspectiveId.equals(perspectiveDescriptor.getId());
            }
        }
    }
    return isCurrent;
}
 

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 static void deletePerspectiveFromApplication(final IPerspectiveDescriptor d) {
	final MApplication a = PlatformUI.getWorkbench().getService(MApplication.class);
	final EModelService e = PlatformUI.getWorkbench().getService(EModelService.class);
	final List<PerspectiveImpl> perspectives = e.findElements(a, PerspectiveImpl.class, EModelService.ANYWHERE,
		element -> element.getElementId().contains(d.getId()));
	for ( final PerspectiveImpl p : perspectives ) {
		// DEBUG.OUT("Dirty perspective implementation found and removed: " + p.getElementId());
		p.getParent().getChildren().remove(p);
	}
}
 

private static IPerspectiveDescriptor findOrBuildPerspectiveWithId(final String id) {
	if ( currentSimulationPerspective != null && currentSimulationPerspective.getId().equals(id) ) {
		return currentSimulationPerspective;
	}
	final PerspectiveRegistry pr = (PerspectiveRegistry) getPerspectiveRegistry();
	IPerspectiveDescriptor tempDescriptor = pr.findPerspectiveWithId(id);
	if ( tempDescriptor == null ) {
		getPerspectiveRegistry()
			.revertPerspective(getPerspectiveRegistry().findPerspectiveWithId(PERSPECTIVE_SIMULATION_ID));
		tempDescriptor = new SimulationPerspectiveDescriptor(id);
	}
	return tempDescriptor;
}
 

public final static Boolean keepTabs() {
	final IPerspectiveDescriptor d = getActivePerspective();
	if ( d instanceof SimulationPerspectiveDescriptor ) {
		return ((SimulationPerspectiveDescriptor) d).keepTabs;
	} else {
		return true;
	}
}
 

public final static Boolean keepToolbars() {
	final IPerspectiveDescriptor d = getActivePerspective();
	if ( d instanceof SimulationPerspectiveDescriptor ) {
		return ((SimulationPerspectiveDescriptor) d).keepToolbars();
	} else {
		return null;
	}
}
 

public final static Boolean keepControls() {
	final IPerspectiveDescriptor d = getActivePerspective();
	if ( d instanceof SimulationPerspectiveDescriptor ) {
		return ((SimulationPerspectiveDescriptor) d).keepControls();
	} else {
		return true;
	}
}
 

public final static Boolean keepTray() {
	final IPerspectiveDescriptor d = getActivePerspective();
	if ( d instanceof SimulationPerspectiveDescriptor ) {
		return ((SimulationPerspectiveDescriptor) d).keepTray();
	} else {
		return true;
	}
}