| /******************************************************************************* |
| * Copyright (c) 2015, 2016 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| ******************************************************************************/ |
| |
| package org.eclipse.ui.internal.e4.migration; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import javax.annotation.PostConstruct; |
| import javax.inject.Inject; |
| import org.eclipse.core.runtime.IConfigurationElement; |
| import org.eclipse.core.runtime.IExtension; |
| import org.eclipse.core.runtime.IExtensionPoint; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.e4.ui.model.application.ui.MElementContainer; |
| import org.eclipse.e4.ui.model.application.ui.MUIElement; |
| import org.eclipse.e4.ui.model.application.ui.SideValue; |
| import org.eclipse.e4.ui.model.application.ui.advanced.MPerspective; |
| import org.eclipse.e4.ui.model.application.ui.advanced.MPlaceholder; |
| import org.eclipse.e4.ui.model.application.ui.basic.MPartSashContainer; |
| import org.eclipse.e4.ui.model.application.ui.basic.MPartSashContainerElement; |
| import org.eclipse.e4.ui.model.application.ui.basic.MPartStack; |
| import org.eclipse.e4.ui.model.application.ui.basic.MStackElement; |
| import org.eclipse.e4.ui.model.application.ui.basic.MTrimmedWindow; |
| import org.eclipse.e4.ui.workbench.IPresentationEngine; |
| import org.eclipse.e4.ui.workbench.modeling.EModelService; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.ui.IPageLayout; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.internal.IWorkbenchConstants; |
| import org.eclipse.ui.internal.PerspectiveTagger; |
| import org.eclipse.ui.internal.e4.compatibility.ModeledPageLayout; |
| import org.eclipse.ui.internal.e4.compatibility.ModeledPageLayoutUtils; |
| import org.eclipse.ui.internal.e4.migration.InfoReader.PageReader; |
| import org.eclipse.ui.internal.e4.migration.InfoReader.PartState; |
| import org.eclipse.ui.internal.e4.migration.PerspectiveReader.DetachedWindowReader; |
| import org.eclipse.ui.internal.e4.migration.PerspectiveReader.ViewLayoutReader; |
| import org.eclipse.ui.internal.registry.IWorkbenchRegistryConstants; |
| import org.eclipse.ui.internal.registry.RegistryReader; |
| import org.eclipse.ui.internal.registry.StickyViewDescriptor; |
| |
| public class PerspectiveBuilder { |
| |
| static final String ORIGINAL_ID = "originalId"; //$NON-NLS-1$ |
| |
| static final String BASE_PERSPECTIVE_ID = "basePerspectiveId"; //$NON-NLS-1$ |
| |
| private static final String DEFAULT_FASTVIEW_STACK = "defaultFastViewStack"; //$NON-NLS-1$ |
| |
| private static final String ID_EDITOR_AREA = IPageLayout.ID_EDITOR_AREA; |
| |
| @Inject |
| private PerspectiveReader perspReader; |
| |
| @Inject |
| private EModelService modelService; |
| |
| private MPerspective perspective; |
| |
| private List<String> tags; |
| |
| private List<String> renderedViews; |
| |
| private List<String> defaultFastViews; |
| |
| private Map<String, MPlaceholder> viewPlaceholders = new HashMap<>(); |
| |
| private Map<String, ViewLayoutReader> viewLayouts; |
| |
| private MPlaceholder editorAreaPlaceholder; |
| |
| private ModeledPageLayoutUtils layoutUtils; |
| |
| private Integer defaultFastViewSide; |
| |
| @PostConstruct |
| private void postConstruct() { |
| layoutUtils = new ModeledPageLayoutUtils(modelService); |
| } |
| |
| public MPerspective createPerspective() { |
| create(); |
| tags = perspective.getTags(); |
| populate(); |
| return perspective; |
| } |
| |
| public MPerspective createPerspective(Integer defaultFastViewSide) { |
| this.defaultFastViewSide = defaultFastViewSide; |
| return createPerspective(); |
| } |
| |
| private void create() { |
| perspective = modelService.createModelElement(MPerspective.class); |
| perspective.setElementId(perspReader.getId()); |
| String label = perspReader.getLabel(); |
| perspective.setLabel(label); |
| perspective.setTooltip(label); |
| if (perspReader.isCustom()) { |
| perspective.getTransientData().put(BASE_PERSPECTIVE_ID, perspReader.getBasicPerspectiveId()); |
| perspective.getTransientData().put(ORIGINAL_ID, perspReader.getOriginalId()); |
| } |
| } |
| |
| private void populate() { |
| addActionSetTags(); |
| addPerspectiveShortcutTags(); |
| addNewWizardTags(); |
| addShowViewTags(); |
| addHiddenItems(); |
| addShowInTags(); |
| |
| for (InfoReader info : perspReader.getInfos()) { |
| if (info.isEditorArea()) { |
| addEditorArea(info); |
| } else if (info.isFolder()) { |
| MPartStack stack = addPartStack(info); |
| populatePartStack(stack, info); |
| } |
| } |
| |
| addDefaultFastViewStack(); |
| setZoomState(); |
| addDetachedWindows(); |
| hideEmptyStacks(); |
| hideUrenderableSashes(); |
| hideInvisibleSashes(); |
| processStandaloneViews(); |
| correctSelectedElements(); |
| addTrimBars(); |
| PerspectiveTagger.tagPerspective(perspective, modelService); |
| } |
| |
| private void processStandaloneViews() { |
| Map<String, ViewLayoutReader> viewLayouts = perspReader.getViewLayouts(); |
| for (Entry<String, ViewLayoutReader> entry : viewLayouts.entrySet()) { |
| String viewId = entry.getKey(); |
| MPlaceholder placeholder = viewPlaceholders.get(viewId); |
| if (placeholder == null) { |
| continue; |
| } |
| if (entry.getValue().isStandalone()) { |
| MElementContainer<MUIElement> parent = placeholder.getParent(); |
| placeholder.setContainerData(parent.getContainerData()); |
| parent.getChildren().remove(placeholder); |
| MElementContainer<MUIElement> grandParent = parent.getParent(); |
| int location = grandParent.getChildren().indexOf(parent); |
| grandParent.getChildren().add(location, placeholder); |
| grandParent.getChildren().remove(parent); |
| } |
| } |
| } |
| |
| private void addDetachedWindows() { |
| for (DetachedWindowReader detachedWindowReader : perspReader.getDetachedWindows()) { |
| MTrimmedWindow detachedWindow = modelService.createModelElement(MTrimmedWindow.class); |
| Rectangle bounds = detachedWindowReader.getBounds(); |
| detachedWindow.setX(bounds.x); |
| detachedWindow.setY(bounds.y); |
| detachedWindow.setWidth(bounds.width); |
| detachedWindow.setHeight(bounds.height); |
| MPartStack stack = modelService.createModelElement(MPartStack.class); |
| populatePartStack(stack, detachedWindowReader); |
| detachedWindow.getChildren().add(stack); |
| perspective.getWindows().add(detachedWindow); |
| } |
| } |
| |
| private void addTrimBars() { |
| Map<String, Integer> fastViewBars = perspReader.getFastViewBars(); |
| if (fastViewBars.size() == 0 && defaultFastViews.size() == 0) { |
| return; |
| } |
| |
| int topCounter = 0; |
| int bottomCounter = 0; |
| int rightCounter = 0; |
| int leftCounter = 0; |
| StringBuilder sb = new StringBuilder(); |
| |
| if (defaultFastViews.size() > 0) { |
| sb.append(DEFAULT_FASTVIEW_STACK).append(' '); |
| if (defaultFastViewSide != null) { |
| switch (defaultFastViewSide) { |
| case SWT.TOP: |
| sb.append(SideValue.TOP_VALUE).append(' ').append(topCounter++); |
| break; |
| case SWT.BOTTOM: |
| sb.append(SideValue.BOTTOM_VALUE).append(' ').append(bottomCounter++); |
| break; |
| case SWT.RIGHT: |
| sb.append(SideValue.RIGHT_VALUE).append(' ').append(rightCounter++); |
| break; |
| default: |
| sb.append(SideValue.LEFT_VALUE).append(' ').append(leftCounter++); |
| break; |
| } |
| } else { |
| sb.append(SideValue.BOTTOM_VALUE).append(' ').append(bottomCounter++); |
| } |
| sb.append('#'); |
| } |
| |
| if (fastViewBars.size() > 0) { |
| for (InfoReader folder : perspReader.getInfos()) { |
| String folderId = folder.getId(); |
| if (!fastViewBars.containsKey(folderId)) { |
| continue; |
| } |
| |
| sb.append(folderId).append(' '); |
| |
| Integer side = fastViewBars.get(folderId); |
| if (side == null) { |
| side = SWT.LEFT; |
| } |
| |
| switch (side) { |
| case SWT.TOP: |
| sb.append(SideValue.TOP_VALUE).append(' ').append(topCounter++); |
| break; |
| case SWT.BOTTOM: |
| sb.append(SideValue.BOTTOM_VALUE).append(' ').append(bottomCounter++); |
| break; |
| case SWT.RIGHT: |
| sb.append(SideValue.RIGHT_VALUE).append(' ').append(rightCounter++); |
| break; |
| default: |
| sb.append(SideValue.LEFT_VALUE).append(' ').append(leftCounter++); |
| break; |
| } |
| |
| sb.append('#'); |
| } |
| } |
| perspective.getPersistedState().put("trims", sb.toString()); //$NON-NLS-1$ |
| } |
| |
| private void hideEmptyStacks() { |
| for (MPartStack stack : modelService.findElements(perspective, null, MPartStack.class, null)) { |
| if (ID_EDITOR_AREA.equals(stack.getElementId()) || ID_EDITOR_AREA.equals(stack.getParent().getElementId())) { |
| continue; |
| } |
| if (!hasRenderableContent(stack)) { |
| stack.setToBeRendered(false); |
| } |
| } |
| } |
| |
| private void setZoomState() { |
| List<MPartStack> stacks = modelService.findElements(perspective, null, MPartStack.class, null); |
| boolean isAnythingMaximized = isMaximized(editorAreaPlaceholder) || isAnyMaximized(stacks); |
| if (isAnythingMaximized) { |
| markMinimizedByZoom(editorAreaPlaceholder); |
| for (MPartStack stack : stacks) { |
| markMinimizedByZoom(stack); |
| } |
| } |
| } |
| |
| private void markMinimizedByZoom(MUIElement element) { |
| List<String> tags = element.getTags(); |
| if (tags.contains(IPresentationEngine.MINIMIZED)) { |
| tags.add(IPresentationEngine.MINIMIZED_BY_ZOOM); |
| } |
| } |
| |
| private boolean isAnyMaximized(List<MPartStack> stacks) { |
| for (MPartStack stack : stacks) { |
| if (isMaximized(stack)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private boolean isMaximized(MUIElement element) { |
| return element.getTags().contains(IPresentationEngine.MAXIMIZED); |
| } |
| |
| private void hideUrenderableSashes() { |
| for (MPartSashContainer sash : modelService.findElements(perspective, null, MPartSashContainer.class, null)) { |
| hideUnrenderableSash(sash); |
| } |
| } |
| |
| private void hideInvisibleSashes() { |
| for (MPartSashContainer sash : modelService.findElements(perspective, null, MPartSashContainer.class, null)) { |
| hideInvisibleSash(sash); |
| } |
| } |
| |
| private void hideInvisibleSash(MElementContainer<?> container) { |
| if ((container instanceof MPartSashContainer) && container != perspective) { |
| if (!hasVisibleContent((MPartSashContainer) container)) { |
| container.setVisible(false); |
| hideInvisibleSash(container.getParent()); |
| } |
| } |
| } |
| |
| private boolean hasVisibleContent(MPartSashContainer sash) { |
| for (MPartSashContainerElement child : sash.getChildren()) { |
| if (child.isVisible()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private void hideUnrenderableSash(MElementContainer<?> container) { |
| if ((container instanceof MPartSashContainer) && container != perspective) { |
| if (modelService.countRenderableChildren(container) == 0) { |
| container.setToBeRendered(false); |
| hideUnrenderableSash(container.getParent()); |
| } |
| } |
| } |
| |
| private boolean hasRenderableContent(MPartStack stack) { |
| for (MStackElement child : stack.getChildren()) { |
| if (child.isVisible() && child.isToBeRendered()) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private void correctSelectedElements() { |
| List<MPartSashContainerElement> perspChildren = perspective.getChildren(); |
| if (perspective.getSelectedElement() == null && !perspChildren.isEmpty()) { |
| for (MPartSashContainerElement child : perspChildren) { |
| if (child.isToBeRendered()) { |
| perspective.setSelectedElement(child); |
| break; |
| } |
| } |
| } |
| |
| for (MPartSashContainerElement child : perspChildren) { |
| correctSelectedElements(child); |
| } |
| } |
| |
| private void correctSelectedElements(MUIElement element) { |
| if (!(element instanceof MPartSashContainer || element instanceof MPartStack)) { |
| return; |
| } |
| @SuppressWarnings("unchecked") |
| MElementContainer<MUIElement> container = (MElementContainer<MUIElement>) element; |
| List<MUIElement> children = container.getChildren(); |
| if (container.getSelectedElement() == null && !children.isEmpty()) { |
| MUIElement firstRenderableElement = getFirstRenderableElement(children); |
| if (firstRenderableElement != null) { |
| container.setSelectedElement(firstRenderableElement); |
| } |
| } |
| for (MUIElement child : children) { |
| correctSelectedElements(child); |
| } |
| } |
| |
| private MUIElement getFirstRenderableElement(List<MUIElement> elements) { |
| for (MUIElement element : elements) { |
| if (element.isToBeRendered()) { |
| return element; |
| } |
| } |
| return null; |
| } |
| |
| private void addToPerspective(MPartSashContainerElement element, InfoReader info) { |
| if (info.isRelativelyPositioned()) { |
| insert(element, info); |
| } else { |
| perspective.getChildren().add(element); |
| } |
| } |
| |
| private void addEditorArea(InfoReader info) { |
| editorAreaPlaceholder = modelService.createModelElement(MPlaceholder.class); |
| editorAreaPlaceholder.setElementId(ID_EDITOR_AREA); |
| editorAreaPlaceholder.setToBeRendered(perspReader.isEditorAreaVisible()); |
| setPartState(editorAreaPlaceholder, perspReader.getEditorAreaState()); |
| addToPerspective(editorAreaPlaceholder, info); |
| } |
| |
| private MPartStack addPartStack(InfoReader info) { |
| MPartStack stack = createPartStack(info); |
| if (info.isRelativelyPositioned()) { |
| String refElementId = info.getRelative(); |
| MUIElement refElement = modelService.find(refElementId, perspective); |
| MElementContainer<?> parent = refElement.getParent(); |
| // don't put a stack in another stack |
| if (parent instanceof MPartStack) { |
| refElement = parent; |
| } |
| |
| insert(stack, refElement, info); |
| } else { |
| perspective.getChildren().add(stack); |
| } |
| setPartState(stack, info.getState()); |
| return stack; |
| } |
| |
| private MPartStack addDefaultFastViewStack() { |
| MPartStack stack = null; |
| List<String> views = perspReader.getDefaultFastViewBarViewIds(); |
| if (views.size() > 0) { |
| stack = layoutUtils.createStack(DEFAULT_FASTVIEW_STACK, true); |
| MPartSashContainer psc = modelService.createModelElement(MPartSashContainer.class); |
| psc.setHorizontal(true); |
| psc.setContainerData(Integer.toString(5000)); |
| stack.setContainerData(Integer.toString(2500)); |
| psc.getChildren().add(stack); |
| List<MPartSashContainer> list = modelService.findElements(perspective, null, MPartSashContainer.class, |
| null); |
| if (list == null || list.size() == 0) { |
| perspective.getChildren().add(psc); |
| } else { |
| int size = list.size(); |
| MPartSashContainer container = list.get(size - 1); |
| container.getChildren().add(psc); |
| } |
| setPartState(stack, org.eclipse.ui.internal.e4.migration.InfoReader.PartState.MINIMIZED); |
| |
| for (String view : views) { |
| addPlaceholderToDefaultFastViewStack(stack, view, null); |
| } |
| } |
| return stack; |
| } |
| |
| private void setPartState(MUIElement element, PartState state) { |
| List<String> tags = element.getTags(); |
| switch (state) { |
| case MINIMIZED: |
| tags.add(IPresentationEngine.MINIMIZED); |
| element.setVisible(false); |
| break; |
| case MAXIMIZED: |
| tags.add(IPresentationEngine.MAXIMIZED); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| private void insert(MUIElement element, MUIElement refElement, InfoReader info) { |
| layoutUtils.insert(element, refElement, layoutUtils.plRelToSwt(info.getRelationship()), info.getRatio()); |
| } |
| |
| private void insert(MUIElement element, InfoReader info) { |
| insert(element, modelService.find(info.getRelative(), perspective), info); |
| } |
| |
| private MPartStack createPartStack(InfoReader info) { |
| String stackId = info.getId(); |
| if (stackId != null) { |
| if (stackId.equals(StickyViewDescriptor.STICKY_FOLDER_RIGHT)) { |
| stackId = "legacyStickyFolderRight"; //$NON-NLS-1$ |
| } |
| } |
| return layoutUtils.createStack(stackId, true); |
| } |
| |
| private void populatePartStack(MPartStack stack, InfoReader info) { |
| for (PageReader page : info.getPages()) { |
| addPlaceholderToStack(stack, page.getId(), page.getLabel()); |
| } |
| MStackElement selectedElement = (MStackElement) modelService.find(info.getActivePageId(), stack); |
| if (selectedElement != null) { |
| selectedElement.setToBeRendered(true); |
| selectedElement.setVisible(true); |
| } |
| stack.setSelectedElement(selectedElement); |
| |
| // restore order of views in the stacks |
| List<MStackElement> renderedViews = getRenderedViews(stack); |
| if (renderedViews.size() < 2) { |
| return; |
| } |
| |
| int[] partOrder = info.getPartOrder(); |
| List<MStackElement> stackChildren = stack.getChildren(); |
| // unexpected situation - don't order |
| if (partOrder == null || partOrder.length != renderedViews.size()) { |
| return; |
| } |
| List<MStackElement> originalOrder = new ArrayList<>(renderedViews); |
| stackChildren.clear(); |
| for (int element : partOrder) { |
| stackChildren.add(originalOrder.get(element)); |
| } |
| originalOrder.removeAll(stackChildren); |
| stackChildren.addAll(originalOrder); |
| } |
| |
| private List<MStackElement> getRenderedViews(MPartStack stack) { |
| List<MStackElement> renderedViews = new ArrayList<>(); |
| for (MStackElement element : stack.getChildren()) { |
| if (element.isToBeRendered()) { |
| renderedViews.add(element); |
| } |
| } |
| return renderedViews; |
| } |
| |
| private void populatePartStack(MPartStack stack, DetachedWindowReader info) { |
| for (PageReader page : info.getPages()) { |
| addPlaceholderToStack(stack, page.getId(), page.getLabel()); |
| } |
| stack.setSelectedElement((MStackElement) modelService.find(info.getActivePageId(), stack)); |
| } |
| |
| private void addPlaceholderToStack(MPartStack stack, String partId, String label) { |
| if (partId == null || isDefaultFastView(partId)) { |
| return; |
| } |
| MPlaceholder placeholder = createPlaceHolder(partId, label); |
| if (!isToBeRendered(placeholder)) { |
| placeholder.setToBeRendered(false); |
| } |
| addLayoutTagsToPlaceholder(placeholder, partId); |
| stack.getChildren().add(placeholder); |
| viewPlaceholders.put(partId, placeholder); |
| } |
| |
| private void addPlaceholderToDefaultFastViewStack(MPartStack stack, String partId, String label) { |
| MPlaceholder placeholder = createPlaceHolder(partId, label); |
| if (!isDefaultFastView(placeholder)) { |
| placeholder.setToBeRendered(false); |
| } |
| addLayoutTagsToPlaceholder(placeholder, partId); |
| stack.getChildren().add(placeholder); |
| viewPlaceholders.put(partId, placeholder); |
| } |
| |
| private void addLayoutTagsToPlaceholder(MPlaceholder placeholder, String partId) { |
| ViewLayoutReader viewLayout = getViewLayout(partId); |
| if (viewLayout == null) { |
| return; |
| } |
| List<String> tags = placeholder.getTags(); |
| if (!viewLayout.isCloseable()) { |
| tags.add(IPresentationEngine.NO_CLOSE); |
| } |
| if (viewLayout.isStandalone()) { |
| tags.add(IPresentationEngine.STANDALONE); |
| } |
| } |
| |
| private boolean isToBeRendered(MPlaceholder placeholder) { |
| if (renderedViews == null) { |
| renderedViews = perspReader.getRenderedViewIds(); |
| } |
| return renderedViews.contains(placeholder.getElementId()); |
| } |
| |
| private boolean isDefaultFastView(MPlaceholder placeholder) { |
| if (defaultFastViews == null) { |
| defaultFastViews = perspReader.getDefaultFastViewBarViewIds(); |
| } |
| return defaultFastViews.contains(placeholder.getElementId()); |
| } |
| |
| private boolean isDefaultFastView(String placeholderId) { |
| if (defaultFastViews == null) { |
| defaultFastViews = perspReader.getDefaultFastViewBarViewIds(); |
| } |
| return defaultFastViews.contains(placeholderId); |
| } |
| |
| private void addPerspectiveShortcutTags() { |
| for (String shortcutId : perspReader.getPerspectiveShortcutIds()) { |
| tags.add(ModeledPageLayout.PERSP_SHORTCUT_TAG + shortcutId); |
| } |
| } |
| |
| private void addActionSetTags() { |
| for (String actionSetId : perspReader.getActionSetIds()) { |
| tags.add(ModeledPageLayout.ACTION_SET_TAG + actionSetId); |
| } |
| } |
| |
| private void addShowInTags() { |
| String origId = null; |
| if (perspReader.isCustom()) { |
| origId = perspReader.getBasicPerspectiveId(); |
| } else { |
| origId = perspReader.getId(); |
| } |
| ArrayList<String> list = getShowInPartFromRegistry(origId); |
| if (list != null) { |
| for (String showIn : list) { |
| tags.add(ModeledPageLayout.SHOW_IN_PART_TAG + showIn); |
| } |
| } |
| return; |
| } |
| |
| public static ArrayList<String> getShowInPartFromRegistry(String targetId) { |
| ArrayList<String> list = new ArrayList<>(); |
| IExtension[] extensions = getPerspectiveExtensions(); |
| if (extensions != null) { |
| for (IExtension extension : extensions) { |
| list.addAll(getExtensionShowInPartFromRegistry(extension, targetId)); |
| } |
| } |
| return list; |
| } |
| |
| private static IExtension[] getPerspectiveExtensions() { |
| IExtensionPoint point = Platform.getExtensionRegistry().getExtensionPoint(PlatformUI.PLUGIN_ID, |
| IWorkbenchRegistryConstants.PL_PERSPECTIVE_EXTENSIONS); |
| if (point == null) { |
| return null; |
| } |
| IExtension[] extensions = point.getExtensions(); |
| extensions = RegistryReader.orderExtensions(extensions); |
| return extensions; |
| } |
| |
| private static ArrayList<String> getExtensionShowInPartFromRegistry(IExtension extension, String targetId) { |
| ArrayList<String> list = new ArrayList<>(); |
| IConfigurationElement[] configElements = extension.getConfigurationElements(); |
| for (IConfigurationElement configElement : configElements) { |
| String type = configElement.getName(); |
| if (type.equals(IWorkbenchRegistryConstants.TAG_PERSPECTIVE_EXTENSION)) { |
| String id = configElement.getAttribute(IWorkbenchRegistryConstants.ATT_TARGET_ID); |
| if (targetId.equals(id) || "*".equals(id)) { //$NON-NLS-1$ |
| list.addAll(getConfigElementShowInPartsFromRegistry(configElement)); |
| } |
| } |
| } |
| return list; |
| } |
| |
| private static ArrayList<String> getConfigElementShowInPartsFromRegistry(IConfigurationElement configElement) { |
| ArrayList<String> list = new ArrayList<>(); |
| String tag = IWorkbenchRegistryConstants.TAG_SHOW_IN_PART; |
| IConfigurationElement[] children = configElement.getChildren(); |
| for (IConfigurationElement child : children) { |
| String ctype = child.getName(); |
| if (tag.equals(ctype)) { |
| String tid = child.getAttribute(IWorkbenchRegistryConstants.ATT_ID); |
| if (tid != null) { |
| list.add(tid); |
| } |
| } |
| } |
| return list; |
| } |
| |
| private void addNewWizardTags() { |
| for (String actionId : perspReader.getNewWizardActionIds()) { |
| tags.add(ModeledPageLayout.NEW_WIZARD_TAG + actionId); |
| } |
| } |
| |
| private void addShowViewTags() { |
| for (String actionId : perspReader.getShowViewActionIds()) { |
| tags.add(ModeledPageLayout.SHOW_VIEW_TAG + actionId); |
| } |
| } |
| |
| private void addHiddenItems() { |
| String comma = ","; //$NON-NLS-1$ |
| StringBuilder persistedValue = new StringBuilder(); |
| for (String elementId : perspReader.getHiddenMenuItemIds()) { |
| persistedValue.append(ModeledPageLayout.HIDDEN_MENU_PREFIX); |
| persistedValue.append(elementId).append(comma); |
| } |
| for (String elementId : perspReader.getHiddenToolbarItemIds()) { |
| persistedValue.append(ModeledPageLayout.HIDDEN_TOOLBAR_PREFIX); |
| persistedValue.append(elementId).append(comma); |
| } |
| perspective.getPersistedState().put(ModeledPageLayout.HIDDEN_ITEMS_KEY, persistedValue.toString()); |
| } |
| |
| private ViewLayoutReader getViewLayout(String viewId) { |
| if (viewLayouts == null) { |
| viewLayouts = perspReader.getViewLayouts(); |
| } |
| return viewLayouts.get(viewId); |
| } |
| |
| Collection<MPlaceholder> getPlaceholders() { |
| return viewPlaceholders.values(); |
| } |
| |
| MPlaceholder getEditorAreaPlaceholder() { |
| return editorAreaPlaceholder; |
| } |
| |
| MPlaceholder createPlaceHolder(String str, String label) { |
| MPlaceholder placeholder = null; |
| placeholder = modelService.createModelElement(MPlaceholder.class); |
| placeholder.setElementId(str); |
| if (modelService.getPartDescriptor(str) == null) { |
| placeholder.getTransientData().put(IWorkbenchConstants.TAG_LABEL, label); |
| } |
| return placeholder; |
| } |
| |
| } |