Java IPerspectiveDescriptor类代码示例

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
/**
 * 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);
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
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);
		}
	}
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
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);
	}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
/**
 * 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());
		}
	}
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
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();
    }
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
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);
		}

	}
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
/**
 * 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;
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
@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;
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
@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;
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
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;
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
@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();
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
public void perspectiveActivated(IWorkbenchPage page, IPerspectiveDescriptor perspective) {

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

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
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);
	}
}
 

import org.eclipse.ui.IPerspectiveDescriptor; //导入依赖的package包/类
/**
 * 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);
}