| /******************************************************************************* |
| * Copyright (c) 2000, 2003 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ui.internal.dialogs; |
| |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Hashtable; |
| import java.util.Iterator; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.jface.action.ContributionManager; |
| import org.eclipse.jface.action.CoolBarManager; |
| import org.eclipse.jface.action.IAction; |
| import org.eclipse.jface.action.IContributionItem; |
| import org.eclipse.jface.action.ICoolBarManager; |
| import org.eclipse.jface.action.IMenuManager; |
| import org.eclipse.jface.action.IStatusLineManager; |
| import org.eclipse.jface.action.IToolBarManager; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.ToolBarContributionItem; |
| import org.eclipse.jface.dialogs.Dialog; |
| import org.eclipse.jface.resource.ImageDescriptor; |
| import org.eclipse.jface.viewers.CheckStateChangedEvent; |
| import org.eclipse.jface.viewers.CheckboxTableViewer; |
| import org.eclipse.jface.viewers.CheckboxTreeViewer; |
| import org.eclipse.jface.viewers.ICheckStateListener; |
| import org.eclipse.jface.viewers.ISelectionChangedListener; |
| import org.eclipse.jface.viewers.IStructuredContentProvider; |
| import org.eclipse.jface.viewers.IStructuredSelection; |
| import org.eclipse.jface.viewers.ITableLabelProvider; |
| import org.eclipse.jface.viewers.ITreeContentProvider; |
| import org.eclipse.jface.viewers.LabelProvider; |
| import org.eclipse.jface.viewers.SelectionChangedEvent; |
| import org.eclipse.jface.viewers.StructuredSelection; |
| import org.eclipse.jface.viewers.Viewer; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.custom.SashForm; |
| import org.eclipse.swt.custom.StyledText; |
| import org.eclipse.swt.events.FocusEvent; |
| import org.eclipse.swt.events.FocusListener; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.events.KeyListener; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.events.ShellEvent; |
| import org.eclipse.swt.events.ShellListener; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Shell; |
| import org.eclipse.swt.widgets.TabFolder; |
| import org.eclipse.swt.widgets.TabItem; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.swt.widgets.TableColumn; |
| import org.eclipse.ui.IActionBars2; |
| import org.eclipse.ui.IPerspectiveDescriptor; |
| import org.eclipse.ui.IPerspectiveRegistry; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.activities.WorkbenchActivityHelper; |
| import org.eclipse.ui.application.WorkbenchAdvisor; |
| import org.eclipse.ui.help.WorkbenchHelp; |
| import org.eclipse.ui.internal.AbstractActionBarConfigurer; |
| import org.eclipse.ui.internal.ActionSetActionBars; |
| import org.eclipse.ui.internal.ActionSetContributionItem; |
| import org.eclipse.ui.internal.ActionSetMenuManager; |
| import org.eclipse.ui.internal.IHelpContextIds; |
| import org.eclipse.ui.internal.Perspective; |
| import org.eclipse.ui.internal.PluginActionContributionItem; |
| import org.eclipse.ui.internal.PluginActionCoolBarContributionItem; |
| import org.eclipse.ui.internal.PluginActionSet; |
| import org.eclipse.ui.internal.PluginActionSetBuilder; |
| import org.eclipse.ui.internal.WorkbenchMessages; |
| import org.eclipse.ui.internal.WorkbenchPlugin; |
| import org.eclipse.ui.internal.WorkbenchWindow; |
| import org.eclipse.ui.internal.dialogs.IndentedTableViewer.IIndentedTableLabelProvider; |
| import org.eclipse.ui.internal.intro.IIntroConstants; |
| import org.eclipse.ui.internal.registry.ActionSetDescriptor; |
| import org.eclipse.ui.internal.registry.ActionSetRegistry; |
| import org.eclipse.ui.internal.registry.Category; |
| import org.eclipse.ui.internal.registry.IActionSetDescriptor; |
| import org.eclipse.ui.internal.registry.IViewDescriptor; |
| import org.eclipse.ui.internal.registry.IViewRegistry; |
| import org.eclipse.ui.internal.registry.NewWizardsRegistryReader; |
| import org.eclipse.ui.internal.util.BundleUtility; |
| import org.eclipse.ui.model.WorkbenchLabelProvider; |
| import org.eclipse.ui.model.WorkbenchViewerSorter; |
| |
| /******************************************************************************* |
| * Copyright (c) 2000, 2003 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| // @issue add class doc |
| // @issue need to break this not to show menu specific page |
| public class CustomizePerspectiveDialog extends Dialog { |
| private Perspective perspective; |
| WorkbenchWindow window; |
| private TabFolder tabFolder; |
| private CheckboxTableViewer actionSetsViewer; |
| private IndentedTableViewer actionSetMenuViewer; |
| private IndentedTableViewer actionSetToolbarViewer; |
| private Combo menusCombo; |
| private CheckboxTreeViewer menuCategoriesViewer; |
| private CheckboxTableViewer menuItemsViewer; |
| private CustomizeActionBars customizeWorkbenchActionBars; |
| |
| private static int lastSelectedTab = -1; |
| private static int lastSelectedMenuIndex = 0; |
| private static String lastSelectedActionSetId = null; |
| private static int cursorSize = 15; |
| |
| private final static int TABLES_WIDTH = 600; |
| private final static int TABLE_HEIGHT = 300; |
| |
| private final String shortcutMenuColumnHeaders[] = { |
| WorkbenchMessages.getString("ActionSetSelection.menuColumnHeader"),//$NON-NLS-1$ |
| WorkbenchMessages.getString("ActionSetSelection.descriptionColumnHeader")};//$NON-NLS-1$ |
| |
| private int[] shortcutMenuColumnWidths = {125, 300}; |
| |
| private ActionSetDescriptor selectedActionSet = null; |
| private ShortcutMenu selectedMenuCategory = null; |
| |
| ImageDescriptor menuImageDescriptor = null; |
| ImageDescriptor submenuImageDescriptor = null; |
| ImageDescriptor toolbarImageDescriptor = null; |
| |
| ShortcutMenu rootMenu; |
| private ArrayList actionSets = new ArrayList(); |
| private Hashtable actionSetStructures = new Hashtable(); |
| |
| class ActionSetDisplayItem extends Object { |
| /** |
| * Tree representation for action set menu and toolbar items. |
| */ |
| ArrayList children = new ArrayList(); |
| ActionSetDisplayItem parent = null; |
| private String id = null; |
| private String text = ""; //$NON-NLS-1$ |
| String description = ""; //$NON-NLS-1$ |
| ImageDescriptor imageDescriptor; |
| int type = MENUITEM; |
| private final static int MENUITEM = 0; |
| private final static int TOOLITEM = 1; |
| |
| private ActionSetDisplayItem() { |
| } |
| ActionSetDisplayItem(String id) { |
| this(null, id, "", MENUITEM); //$NON-NLS-1$ |
| } |
| private ActionSetDisplayItem(ActionSetDisplayItem parent, String id, String text, int type) { |
| if (parent != null) { |
| parent.children.add(this); |
| this.parent = parent; |
| } |
| this.id = id; |
| this.type = type; |
| this.text = removeShortcut(text); |
| this.text = DialogUtil.removeAccel(this.text); |
| } |
| private ActionSetDisplayItem find(String itemId) { |
| for (int i=0; i<children.size(); i++) { |
| ActionSetDisplayItem child = (ActionSetDisplayItem)children.get(i); |
| if (itemId.equals(child.id)) return child; |
| } |
| return null; |
| } |
| |
| public void fillMenusFor(String actionSetId, IContributionItem item) { |
| if (item instanceof ContributionManager) { |
| ContributionManager mgr = (ContributionManager)item; |
| IContributionItem[] items = mgr.getItems(); |
| for (int i=0; i<items.length; i++) { |
| IContributionItem mgrItem = items[i]; |
| if (mgrItem instanceof ActionSetContributionItem) { |
| ActionSetContributionItem actionSetItem = (ActionSetContributionItem)mgrItem; |
| if (actionSetItem.getActionSetId().equals(actionSetId)) { |
| IContributionItem innerItem = actionSetItem.getInnerItem(); |
| if (innerItem instanceof MenuManager) { |
| MenuManager inner =(MenuManager)actionSetItem.getInnerItem(); |
| ActionSetDisplayItem node = new ActionSetDisplayItem(this, inner.getId(), inner.getMenuText(), MENUITEM); |
| node.fillMenusFor(actionSetId, inner); |
| } else if (innerItem instanceof ActionSetMenuManager) { |
| ActionSetMenuManager inner =(ActionSetMenuManager)actionSetItem.getInnerItem(); |
| MenuManager parentMgr = (MenuManager)inner.getParent(); |
| ActionSetDisplayItem node = new ActionSetDisplayItem(this, inner.getId(), parentMgr.getMenuText(), MENUITEM); |
| node.fillMenusFor(actionSetId, parentMgr); |
| } else if (innerItem instanceof PluginActionContributionItem) { |
| PluginActionContributionItem inner =(PluginActionContributionItem)actionSetItem.getInnerItem(); |
| ActionSetDisplayItem node = new ActionSetDisplayItem(this, inner.getId(), inner.getAction().getText(), MENUITEM); |
| IAction action = inner.getAction(); |
| if (action != null) { |
| node.imageDescriptor = action.getImageDescriptor(); |
| node.description = action.getDescription(); |
| } |
| } |
| } |
| } else if (mgrItem instanceof MenuManager) { |
| MenuManager menuMgr = (MenuManager)mgrItem; |
| boolean found = containsActionSet(menuMgr, actionSetId); |
| if (found) { |
| ActionSetDisplayItem node = new ActionSetDisplayItem(this, menuMgr.getId(), menuMgr.getMenuText(), MENUITEM); |
| node.fillMenusFor(actionSetId, menuMgr); |
| } |
| } |
| } |
| } |
| } |
| public void fillToolsFor(String actionSetId, CoolBarManager mgr) { |
| IContributionItem[] items = mgr.getItems(); |
| for (int i=0; i<items.length; i++) { |
| if (items[i] instanceof ToolBarContributionItem) { |
| ToolBarContributionItem cbItem = (ToolBarContributionItem)items[i]; |
| IContributionItem[] subItems = cbItem.getToolBarManager().getItems(); |
| for (int j=0; j<subItems.length; j++) { |
| IContributionItem subItem = subItems[j]; |
| if (subItem instanceof PluginActionCoolBarContributionItem) { |
| PluginActionCoolBarContributionItem actionItem = (PluginActionCoolBarContributionItem)subItem; |
| if (actionItem.getActionSetId().equals(actionSetId)) { |
| String toolbarId = cbItem.getId(); |
| ActionSetDisplayItem toolbar = find(toolbarId); |
| if (toolbar == null) { |
| String toolbarText = window.getToolbarLabel(toolbarId); |
| toolbar = new ActionSetDisplayItem(this, toolbarId, toolbarText, TOOLITEM); |
| } |
| IAction action = actionItem.getAction(); |
| String toolItemText = action.getToolTipText(); |
| if (toolItemText == null) toolItemText = action.getText(); |
| ActionSetDisplayItem toolItem = new ActionSetDisplayItem(toolbar, action.getId(), toolItemText, TOOLITEM); |
| toolItem.imageDescriptor = action.getImageDescriptor(); |
| toolItem.description = action.getDescription(); |
| } |
| } |
| } |
| } |
| } |
| } |
| int getDepth() { |
| if (parent == null) return 0; |
| else return parent.getDepth() + 1; |
| } |
| String getDisplayText() { |
| if (type == MENUITEM) { |
| if (children.size() > 0) { |
| if (parent.id.equals("Root")) { //$NON-NLS-1$ |
| return WorkbenchMessages.format("ActionSetSelection.menubarLocation", new Object[] {text}); //$NON-NLS-1$ |
| } |
| } |
| return text; |
| } else { |
| if (children.size() > 0) return WorkbenchMessages.format("ActionSetSelection.toolbarLocation", new Object[] {text}); //$NON-NLS-1$ |
| else return text; |
| } |
| } |
| ArrayList getElements() { |
| ArrayList elements = new ArrayList(); |
| for (int i=0; i<children.size(); i++) { |
| ActionSetDisplayItem child = (ActionSetDisplayItem)children.get(i); |
| elements.add(child); |
| elements.addAll(child.getElements()); |
| } |
| return elements; |
| } |
| protected boolean isTopLevelMenu() { |
| if (parent == null) return false; |
| return parent.parent == null; |
| } |
| } |
| |
| public class CustomizeActionBars extends AbstractActionBarConfigurer implements IActionBars2 { |
| /** |
| * Fake action bars to use to build the menus and toolbar contributions for the |
| * workbench. We cannot use the actual workbench action bars, since doing so would |
| * make the action set items visible. |
| */ |
| MenuManager menuManager; |
| CoolBarManager coolBarManager; |
| |
| public CustomizeActionBars() { |
| } |
| |
| public CustomizeActionBars(MenuManager menuManager, CoolBarManager coolBarManager) { |
| this.menuManager = menuManager; |
| this.coolBarManager = coolBarManager; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.ui.application.IActionBarConfigurer#getMenuManager() |
| */ |
| public IMenuManager getMenuManager() { |
| return menuManager; |
| } |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.ui.application.IActionBarConfigurer#getStatusLineManager() |
| */ |
| public IStatusLineManager getStatusLineManager() { |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.AbstractActionBarConfigurer#getCoolBarManager() |
| */ |
| public ICoolBarManager getCoolBarManager() { |
| return coolBarManager; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IActionBars#getToolBarManager() |
| */ |
| public IToolBarManager getToolBarManager() { |
| return null; |
| } |
| |
| public void setGlobalActionHandler(String actionID, IAction handler) { |
| } |
| public void updateActionBars() { |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IActionBars#clearGlobalActionHandlers() |
| */ |
| public void clearGlobalActionHandlers() { |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IActionBars#getGlobalActionHandler(java.lang.String) |
| */ |
| public IAction getGlobalActionHandler(String actionId) { |
| return null; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.application.IActionBarConfigurer#registerGlobalAction(org.eclipse.jface.action.IAction) |
| */ |
| public void registerGlobalAction(IAction action) { |
| } |
| |
| } |
| |
| class ShortcutMenuItemContentProvider implements IStructuredContentProvider { |
| |
| ShortcutMenuItemContentProvider() { |
| } |
| public Object[] getElements(Object input) { |
| if (input instanceof ShortcutMenu) { |
| return ((ShortcutMenu)input).getItems().toArray(); |
| } |
| return new Object[0]; |
| } |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| } |
| public void dispose() { |
| } |
| } |
| class ShortcutMenuItemLabelProvider extends LabelProvider implements ITableLabelProvider { |
| private Map imageTable = new Hashtable(); |
| private final static int COLUMN_ID = 0; |
| private final static int COLUMN_DESCRIPTION = 1; |
| |
| ShortcutMenuItemLabelProvider() { |
| } |
| public final void dispose() { |
| for (Iterator i = imageTable.values().iterator(); i.hasNext();) { |
| ((Image) i.next()).dispose(); |
| } |
| imageTable = null; |
| } |
| public Image getColumnImage(Object element, int index) { |
| if (index != COLUMN_ID) return null; |
| ImageDescriptor descriptor = null; |
| if (element instanceof IPerspectiveDescriptor) { |
| descriptor = ((IPerspectiveDescriptor)element).getImageDescriptor(); |
| } else if (element instanceof IViewDescriptor) { |
| descriptor = ((IViewDescriptor)element).getImageDescriptor(); |
| } else if (element instanceof WorkbenchWizardElement) { |
| descriptor = ((WorkbenchWizardElement)element).getImageDescriptor(); |
| } |
| if (descriptor == null) |
| return null; |
| //obtain the cached image corresponding to the descriptor |
| if (imageTable == null) { |
| imageTable = new Hashtable(40); |
| } |
| Image image = (Image) imageTable.get(descriptor); |
| if (image == null) { |
| image = descriptor.createImage(); |
| imageTable.put(descriptor, image); |
| } |
| return image; |
| } |
| public String getColumnText(Object element, int columnIndex) { |
| String text = null; |
| switch (columnIndex) { |
| case COLUMN_ID : |
| text = getText(element); |
| break; |
| case COLUMN_DESCRIPTION : |
| if (element instanceof IPerspectiveDescriptor) { |
| text = ((IPerspectiveDescriptor)element).getDescription(); |
| } else if (element instanceof IViewDescriptor) { |
| text = ((IViewDescriptor)element).getDescription(); |
| } else if (element instanceof WorkbenchWizardElement) { |
| text = ((WorkbenchWizardElement)element).getDescription(); |
| } |
| break; |
| } |
| if (text == null) text = ""; //$NON-NLS-1$ |
| return text; |
| } |
| public String getText(Object element) { |
| String text = null; |
| if (element instanceof IPerspectiveDescriptor) { |
| text = ((IPerspectiveDescriptor)element).getLabel(); |
| } else if (element instanceof IViewDescriptor) { |
| text = ((IViewDescriptor)element).getLabel(); |
| } else if (element instanceof WorkbenchWizardElement) { |
| text = ((WorkbenchWizardElement)element).getLabel(element); |
| } |
| if (text == null) text = ""; //$NON-NLS-1$ |
| return text; |
| } |
| } |
| |
| class ShortcutMenu extends Object { |
| /** |
| * Tree representation for the shortcut items. |
| */ |
| private final static String ID_VIEW = "org.eclipse.ui.views"; //$NON-NLS-1$ |
| private final static String ID_WIZARD = "org.eclipse.ui.wizards"; //$NON-NLS-1$ |
| private final static String ID_PERSP = "org.eclipse.ui.perspectives"; //$NON-NLS-1$ |
| String id; |
| String label; |
| private ArrayList items = new ArrayList(); |
| private ArrayList checkedItems = new ArrayList(); |
| ArrayList children = new ArrayList(); |
| ShortcutMenu parent = null; |
| |
| ShortcutMenu(ShortcutMenu parent, String id, String label) { |
| super(); |
| this.id = id; |
| this.parent = parent; |
| this.label = removeShortcut(label); |
| this.label = DialogUtil.removeAccel(this.label); |
| if (parent != null) parent.children.add(this); |
| } |
| void addItem(Object item) { |
| items.add(item); |
| } |
| void addCheckedItem(Object item) { |
| checkedItems.add(item); |
| } |
| public String toString() { |
| return label; |
| } |
| ArrayList getCheckedItems() { |
| return checkedItems; |
| } |
| ArrayList getCheckedItemIds() { |
| ArrayList ids = new ArrayList(); |
| if (getMenuId() == ID_PERSP) { |
| for (int i=0; i < checkedItems.size(); i++) { |
| IPerspectiveDescriptor item = (IPerspectiveDescriptor)checkedItems.get(i); |
| ids.add(item.getId()); |
| } |
| } else if (getMenuId() == ID_VIEW) { |
| for (int i=0; i < checkedItems.size(); i++) { |
| IViewDescriptor item = (IViewDescriptor)checkedItems.get(i); |
| ids.add(item.getId()); |
| } |
| } else if (getMenuId() == ID_WIZARD) { |
| for (int i=0; i < checkedItems.size(); i++) { |
| WorkbenchWizardElement item = (WorkbenchWizardElement)checkedItems.get(i); |
| ids.add(item.getID()); |
| } |
| } |
| for (int i=0; i < children.size(); i++) { |
| ShortcutMenu menu = (ShortcutMenu)children.get(i); |
| ids.addAll(menu.getCheckedItemIds()); |
| } |
| return ids; |
| } |
| ArrayList getChildren() { |
| return children; |
| } |
| ArrayList getItems() { |
| return items; |
| } |
| private String getMenuId() { |
| if (parent == rootMenu) return id; |
| else return parent.getMenuId(); |
| } |
| ArrayList getSubtreeItems() { |
| ArrayList subtreeItems = new ArrayList(); |
| subtreeItems.add(this); |
| for (int i=0; i<children.size(); i++) { |
| ShortcutMenu child = (ShortcutMenu)children.get(i); |
| subtreeItems.addAll(child.getSubtreeItems()); |
| } |
| return subtreeItems; |
| } |
| Object getItem(String menuItemId) { |
| for (int i=0; i<items.size(); i++) { |
| Object item = items.get(i); |
| String itemId = null; |
| if (id == ID_PERSP) { |
| itemId = ((IPerspectiveDescriptor)item).getId(); |
| } else if (id == ID_VIEW) { |
| itemId = ((IViewDescriptor)item).getId(); |
| } else if (id == ID_WIZARD) { |
| itemId = ((WorkbenchWizardElement)item).getID(); |
| } |
| if (menuItemId.equals(itemId)) return item; |
| } |
| return null; |
| } |
| boolean isFullyChecked() { |
| if (getItems().size() != getCheckedItems().size()) return false; |
| for (int i=0; i<children.size(); i++) { |
| ShortcutMenu child = (ShortcutMenu)children.get(i); |
| if (!child.isFullyChecked()) return false; |
| } |
| return true; |
| } |
| boolean isFullyUnchecked() { |
| if (getCheckedItems().size() != 0) return false; |
| for (int i=0; i<children.size(); i++) { |
| ShortcutMenu child = (ShortcutMenu)children.get(i); |
| if (!child.isFullyUnchecked()) return false; |
| } |
| return true; |
| } |
| void removeCheckedItem(Object item) { |
| checkedItems.remove(item); |
| } |
| void checked(boolean checked) { |
| checkedItems = new ArrayList(); |
| if (checked) { |
| checkedItems.addAll(items); |
| } |
| for (int i=0; i<children.size(); i++) { |
| ShortcutMenu child = (ShortcutMenu)children.get(i); |
| child.checked(checked); |
| } |
| } |
| } |
| class TreeContentProvider implements ITreeContentProvider { |
| public void dispose() { |
| } |
| public Object[] getChildren(Object element) { |
| if (element instanceof ActionSetDisplayItem) { |
| ActionSetDisplayItem node = (ActionSetDisplayItem)element; |
| return node.children.toArray(); |
| } else if (element instanceof ShortcutMenu) { |
| ShortcutMenu node = (ShortcutMenu)element; |
| return node.children.toArray(); |
| } |
| return null; |
| } |
| public Object[] getElements(Object element) { |
| return getChildren(element); |
| } |
| public Object getParent(Object element) { |
| if (element instanceof ActionSetDisplayItem) { |
| ActionSetDisplayItem node = (ActionSetDisplayItem)element; |
| return node.parent; |
| } else if (element instanceof ShortcutMenu) { |
| ShortcutMenu node = (ShortcutMenu)element; |
| return node.parent; |
| } |
| return null; |
| } |
| public boolean hasChildren(Object element) { |
| if (element instanceof ActionSetDisplayItem) { |
| ActionSetDisplayItem node = (ActionSetDisplayItem)element; |
| return node.children.size() > 0; |
| } else if (element instanceof ShortcutMenu) { |
| ShortcutMenu node = (ShortcutMenu)element; |
| return node.children.size() > 0; |
| } |
| return false; |
| } |
| public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { |
| } |
| } |
| class IndentedTableLabelProvider extends LabelProvider implements IIndentedTableLabelProvider { |
| private Map imageTable = new Hashtable(); |
| public void dispose() { |
| for (Iterator i = imageTable.values().iterator(); i.hasNext();) { |
| ((Image) i.next()).dispose(); |
| } |
| imageTable = null; |
| } |
| public Image getColumnImage(Object element, int column) { |
| ActionSetDisplayItem item = (ActionSetDisplayItem)element; |
| ImageDescriptor descriptor = item.imageDescriptor; |
| if (descriptor == null) { |
| if (item.type == ActionSetDisplayItem.MENUITEM) { |
| if (item.children.size() > 0) { |
| if (item.isTopLevelMenu()) descriptor = menuImageDescriptor; |
| else descriptor = submenuImageDescriptor; |
| } |
| else return null; |
| } else if (item.type == ActionSetDisplayItem.TOOLITEM) { |
| if (item.children.size() > 0) descriptor = toolbarImageDescriptor; |
| else return null; |
| } else { |
| return null; |
| } |
| } |
| //obtain the cached image corresponding to the descriptor |
| if (imageTable == null) { |
| imageTable = new Hashtable(40); |
| } |
| Image image = (Image) imageTable.get(descriptor); |
| if (image == null) { |
| image = descriptor.createImage(); |
| imageTable.put(descriptor, image); |
| } |
| return image; |
| } |
| public String getColumnText(Object element, int column) { |
| if (element instanceof ActionSetDisplayItem) { |
| ActionSetDisplayItem item = (ActionSetDisplayItem)element; |
| String text = item.getDisplayText(); |
| if ((item.type == ActionSetDisplayItem.MENUITEM) |
| && (item.children.size() > 0)) |
| text = text + " >"; //$NON-NLS-1$ |
| return text; |
| } |
| return ""; //$NON-NLS-1$ |
| } |
| public int getIndent(Object element) { |
| if (element instanceof ActionSetDisplayItem) { |
| int depth = ((ActionSetDisplayItem)element).getDepth(); |
| depth = depth - 1; |
| return depth; |
| } |
| return 0; |
| } |
| } |
| |
| public CustomizePerspectiveDialog(Shell parentShell, Perspective persp) { |
| super(parentShell); |
| perspective = persp; |
| // @issue should pass in the parent window, not use getActiveWorkbenchWindow() |
| window = (WorkbenchWindow)PlatformUI.getWorkbench().getActiveWorkbenchWindow(); |
| |
| // build a structure for the menuitems and toolitems that the workbench contributes |
| customizeWorkbenchActionBars = new CustomizeActionBars(new MenuManager(), new CoolBarManager()); |
| |
| // Fill current actionBars in the "fake" workbench actionbars |
| window.fillActionBars(customizeWorkbenchActionBars, |
| WorkbenchAdvisor.FILL_PROXY | WorkbenchAdvisor.FILL_MENU_BAR | WorkbenchAdvisor.FILL_COOL_BAR ); |
| |
| initializeActionSetInput(); |
| initializeShortcutMenuInput(); |
| } |
| |
| /** |
| * Adds listeners for the Commands tab. |
| * |
| * @since 3.0 |
| */ |
| private void addActionSetsListeners() { |
| tabFolder.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent event) { |
| handleTabSelected(event); |
| } |
| }); |
| actionSetsViewer.addSelectionChangedListener(new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| handleActionSetSelected(event); |
| } |
| }); |
| actionSetsViewer.getControl().addKeyListener(new KeyListener() { |
| public void keyPressed(KeyEvent e) { |
| handleActionSetViewerKeyPressed(e); |
| } |
| public void keyReleased(KeyEvent e) {} |
| }); |
| actionSetMenuViewer.getControl().addKeyListener(new KeyListener() { |
| public void keyPressed(KeyEvent e) { |
| handleActionSetMenuViewerKeyPressed(e); |
| } |
| public void keyReleased(KeyEvent e) {} |
| }); |
| actionSetToolbarViewer.getControl().addKeyListener(new KeyListener() { |
| public void keyPressed(KeyEvent e) { |
| handleActionSetToolbarViewerKeyPressed(e); |
| } |
| public void keyReleased(KeyEvent e) {} |
| }); |
| } |
| |
| /** |
| * Adds listeners for the Shortcuts tab. |
| * |
| * @since 3.0 |
| */ |
| private void addShortcutListeners() { |
| menusCombo.addSelectionListener(new SelectionListener() { |
| public void widgetDefaultSelected(SelectionEvent e) { |
| // do nothing |
| } |
| public void widgetSelected(SelectionEvent e) { |
| handleMenuSelected(e); |
| } |
| }); |
| menusCombo.addModifyListener(new ModifyListener() { |
| public void modifyText(ModifyEvent e) { |
| handleMenuModified(e); |
| } |
| }); |
| menuCategoriesViewer.addSelectionChangedListener(new ISelectionChangedListener() { |
| public void selectionChanged(SelectionChangedEvent event) { |
| handleMenuCategorySelected(event); |
| } |
| }); |
| menuCategoriesViewer.addCheckStateListener(new ICheckStateListener() { |
| public void checkStateChanged(CheckStateChangedEvent event) { |
| handleMenuCategoryChecked(event); |
| } |
| }); |
| menuItemsViewer.addCheckStateListener(new ICheckStateListener() { |
| public void checkStateChanged(CheckStateChangedEvent event) { |
| handleMenuItemChecked(event); |
| } |
| }); |
| } |
| |
| private void buildMenusAndToolbarsFor (ActionSetDescriptor actionSetDesc) { |
| String id = actionSetDesc.getId(); |
| ActionSetActionBars bars = new ActionSetActionBars(customizeWorkbenchActionBars, id); |
| PluginActionSetBuilder builder = new PluginActionSetBuilder(); |
| PluginActionSet actionSet = null; |
| try { |
| actionSet = (PluginActionSet)actionSetDesc.createActionSet(); |
| actionSet.init(null, bars); |
| } catch (CoreException ex) { |
| WorkbenchPlugin.log("Unable to create action set " + actionSetDesc.getId()); //$NON-NLS-1$ |
| return; |
| } |
| builder.buildMenuAndToolBarStructure(actionSet, window); |
| } |
| private void checkInitialActionSetSelections() { |
| // Check off the action sets that are active for the perspective. |
| IActionSetDescriptor [] actionSetDescriptors = perspective.getActionSets(); |
| if (actionSets != null) { |
| for (int i = 0; i < actionSetDescriptors.length; i++) |
| actionSetsViewer.setChecked(actionSetDescriptors[i],true); |
| } |
| } |
| private void checkInitialMenuCategorySelections(ShortcutMenu menu) { |
| // Check off the shortcut categories that are active for the perspective. |
| if (menu.children.size() == 0) updateMenuCategoryCheckedState(menu); |
| else { |
| for (int i=0; i<menu.children.size(); i++) { |
| ShortcutMenu child = (ShortcutMenu)menu.children.get(i); |
| checkInitialMenuCategorySelections(child); |
| } |
| } |
| } |
| public boolean close() { |
| if (showShortcutTab()) { |
| lastSelectedMenuIndex = menusCombo.getSelectionIndex(); |
| } |
| lastSelectedTab = tabFolder.getSelectionIndex(); |
| StructuredSelection selection = (StructuredSelection)actionSetsViewer.getSelection(); |
| if (selection.isEmpty()) lastSelectedActionSetId = null; |
| else lastSelectedActionSetId = ((ActionSetDescriptor)selection.getFirstElement()).getId(); |
| customizeWorkbenchActionBars.coolBarManager.dispose(); |
| customizeWorkbenchActionBars.menuManager.dispose(); |
| return super.close(); |
| } |
| protected void configureShell(Shell shell) { |
| super.configureShell(shell); |
| shell.setText(WorkbenchMessages.getString("ActionSetSelection.customize")); //$NON-NLS-1$ |
| WorkbenchHelp.setHelp(shell, IHelpContextIds.ACTION_SET_SELECTION_DIALOG); |
| } |
| boolean containsActionSet(MenuManager mgr, String actionSetId) { |
| // Return whether or not the given menuManager contains items for the |
| // given actionSetId. |
| IContributionItem[] menuItems = mgr.getItems(); |
| for (int j=0; j<menuItems.length; j++) { |
| IContributionItem menuItem = menuItems[j]; |
| if (menuItem instanceof ActionSetContributionItem) { |
| ActionSetContributionItem actionSetItem = (ActionSetContributionItem)menuItem; |
| if (actionSetItem.getActionSetId().equals(actionSetId)) { |
| return true; |
| } |
| } else if (menuItem instanceof MenuManager) { |
| MenuManager childMgr = (MenuManager)menuItem; |
| boolean found = containsActionSet(childMgr, actionSetId); |
| if (found) return true; |
| } |
| } |
| return false; |
| } |
| private Composite createActionSetsPage(Composite parent) { |
| GridData data; |
| Font font = parent.getFont(); |
| |
| Composite actionSetsComposite= new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| actionSetsComposite.setLayout(layout); |
| data = new GridData(GridData.FILL_BOTH); |
| actionSetsComposite.setLayoutData(data); |
| |
| // Select... label |
| Label label = new Label(actionSetsComposite, SWT.WRAP); |
| label.setText(WorkbenchMessages.format("ActionSetSelection.selectActionSetsLabel", new Object[] {perspective.getDesc().getLabel()})); //$NON-NLS-1$ |
| data = new GridData(GridData.FILL_BOTH); |
| data.widthHint = TABLES_WIDTH; |
| label.setLayoutData(data); |
| |
| Label sep = new Label(actionSetsComposite, SWT.HORIZONTAL | SWT.SEPARATOR); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| sep.setLayoutData(data); |
| |
| SashForm sashComposite= new SashForm(actionSetsComposite, SWT.HORIZONTAL); |
| data = new GridData(GridData.FILL_BOTH); |
| data.heightHint = TABLE_HEIGHT; |
| data.widthHint = TABLES_WIDTH; |
| sashComposite.setLayoutData(data); |
| |
| // Action Set List Composite |
| Composite actionSetGroup = new Composite(sashComposite, SWT.NONE); |
| layout = new GridLayout(); |
| layout.marginHeight = 0; |
| layout.marginWidth = 0; |
| actionSetGroup.setLayout(layout); |
| data = new GridData(GridData.FILL_BOTH); |
| actionSetGroup.setLayoutData(data); |
| |
| label = new Label(actionSetGroup,SWT.NONE); |
| label.setText(WorkbenchMessages.getString("ActionSetSelection.availableActionSets")); //$NON-NLS-1$ |
| |
| actionSetsViewer = CheckboxTableViewer.newCheckList(actionSetGroup, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL); |
| data = new GridData(GridData.FILL_BOTH); |
| actionSetsViewer.getTable().setLayoutData(data); |
| actionSetsViewer.getTable().setFont(font); |
| actionSetsViewer.setLabelProvider(new WorkbenchLabelProvider()); |
| actionSetsViewer.setContentProvider(new ListContentProvider()); |
| actionSetsViewer.setSorter(new ActionSetSorter()); |
| |
| // Action list Group |
| Composite actionItemGroup = new Composite(sashComposite, SWT.NONE); |
| layout = new GridLayout(); |
| layout.marginHeight = 0; |
| layout.marginWidth = 0; |
| layout.horizontalSpacing = 5; |
| actionItemGroup.setLayout(layout); |
| data = new GridData(GridData.FILL_BOTH); |
| actionItemGroup.setLayoutData(data); |
| |
| Composite actionGroup = new Composite(actionItemGroup, SWT.NULL); |
| layout = new GridLayout(); |
| layout.numColumns = 2; |
| layout.makeColumnsEqualWidth = true; |
| layout.marginHeight = 0; |
| layout.marginWidth = 0; |
| layout.horizontalSpacing = 0; |
| actionGroup.setLayout(layout); |
| data = new GridData(GridData.FILL_BOTH); |
| actionGroup.setLayoutData(data); |
| |
| label = new Label(actionGroup, SWT.NONE); |
| label.setText(WorkbenchMessages.getString("ActionSetSelection.menubarActions")); //$NON-NLS-1$ |
| label.setFont(font); |
| |
| label = new Label(actionGroup, SWT.NONE); |
| label.setText(WorkbenchMessages.getString("ActionSetSelection.toolbarActions")); //$NON-NLS-1$ |
| label.setFont(font); |
| |
| actionSetMenuViewer = new IndentedTableViewer(actionGroup); |
| data = new GridData(GridData.FILL_BOTH); |
| actionSetMenuViewer.getControl().setLayoutData(data); |
| actionSetMenuViewer.setLabelProvider(new IndentedTableLabelProvider()); |
| actionSetMenuViewer.setContentProvider(new ListContentProvider()); |
| |
| actionSetToolbarViewer = new IndentedTableViewer(actionGroup); |
| data = new GridData(GridData.FILL_BOTH); |
| actionSetToolbarViewer.getControl().setLayoutData(data); |
| actionSetToolbarViewer.setLabelProvider(new IndentedTableLabelProvider()); |
| actionSetToolbarViewer.setContentProvider(new ListContentProvider()); |
| |
| sashComposite.setWeights(new int[]{30, 70}); |
| |
| // Use F2... label |
| label = new Label(actionSetsComposite, SWT.WRAP); |
| label.setText(WorkbenchMessages.getString("ActionSetSelection.selectActionSetsHelp")); //$NON-NLS-1$ |
| label.setFont(font); |
| data = new GridData(); |
| data.widthHint = TABLES_WIDTH; |
| label.setLayoutData(data); |
| |
| return actionSetsComposite; |
| } |
| /** |
| * Returns whether the shortcut tab should be shown. |
| * |
| * @return <code>true</code> if the shortcut tab should be shown, |
| * and <code>false</code> otherwise |
| * @since 3.0 |
| */ |
| private boolean showShortcutTab() { |
| return window.containsSubmenu(WorkbenchWindow.NEW_WIZARD_SUBMENU) |
| || window.containsSubmenu(WorkbenchWindow.OPEN_PERSPECTIVE_SUBMENU) |
| || window.containsSubmenu(WorkbenchWindow.SHOW_VIEW_SUBMENU); |
| } |
| |
| |
| protected Control createDialogArea(Composite parent) { |
| Composite composite = (Composite)super.createDialogArea(parent); |
| |
| // tab folder |
| tabFolder = new TabFolder(composite, SWT.NONE); |
| GridData gd = new GridData(GridData.FILL_BOTH); |
| tabFolder.setLayoutData(gd); |
| |
| // Shortcuts tab |
| if (showShortcutTab()) { |
| TabItem item1 = new TabItem(tabFolder, SWT.NONE); |
| item1.setText(WorkbenchMessages.getString("ActionSetSelection.menuTab")); //$NON-NLS-1$ |
| item1.setControl(createMenusPage(tabFolder)); |
| addShortcutListeners(); |
| ArrayList children = rootMenu.getChildren(); |
| String[] itemNames = new String[children.size()]; |
| for (int i=0; i<children.size(); i++) { |
| itemNames[i]=((ShortcutMenu)children.get(i)).label; |
| } |
| menusCombo.setItems(itemNames); |
| } |
| |
| // Commands tab |
| TabItem item = new TabItem(tabFolder, SWT.NONE); |
| item.setText(WorkbenchMessages.getString("ActionSetSelection.actionSetsTab")); //$NON-NLS-1$ |
| item.setControl(createActionSetsPage(tabFolder)); |
| addActionSetsListeners(); |
| actionSetsViewer.setInput(actionSets); |
| checkInitialActionSetSelections(); |
| |
| // now that both tabs are set up, initialize selections |
| setInitialSelections(); |
| |
| return composite; |
| } |
| private Composite createMenusPage(Composite parent) { |
| GridData data; |
| Font font = parent.getFont(); |
| |
| Composite menusComposite= new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| menusComposite.setLayout(layout); |
| data = new GridData(GridData.FILL_BOTH); |
| menusComposite.setLayoutData(data); |
| |
| // Select... label |
| Label label = new Label(menusComposite, SWT.WRAP); |
| label.setText(WorkbenchMessages.format("ActionSetSelection.selectMenusLabel", new Object[] {perspective.getDesc().getLabel()})); //$NON-NLS-1$ |
| label.setFont(font); |
| data = new GridData(); |
| data.widthHint = TABLES_WIDTH; |
| label.setLayoutData(data); |
| |
| Label sep = new Label(menusComposite, SWT.HORIZONTAL | SWT.SEPARATOR); |
| data = new GridData(GridData.FILL_HORIZONTAL); |
| sep.setLayoutData(data); |
| |
| SashForm sashComposite= new SashForm(menusComposite, SWT.HORIZONTAL); |
| data = new GridData(GridData.FILL_BOTH); |
| data.heightHint = TABLE_HEIGHT; |
| data.widthHint = TABLES_WIDTH; |
| sashComposite.setLayoutData(data); |
| |
| // Menus List |
| Composite menusGroup = new Composite(sashComposite, SWT.NONE); |
| layout = new GridLayout(); |
| layout.marginHeight = 0; |
| layout.marginWidth = 0; |
| menusGroup.setLayout(layout); |
| data = new GridData(GridData.FILL_BOTH); |
| menusGroup.setLayoutData(data); |
| menusGroup.setFont(font); |
| |
| label = new Label(menusGroup,SWT.NONE); |
| label.setText(WorkbenchMessages.getString("ActionSetSelection.availableMenus")); //$NON-NLS-1$ |
| label.setFont(font); |
| |
| menusCombo = new Combo(menusGroup, SWT.READ_ONLY); |
| menusCombo.setFont(font); |
| GridData gridData = new GridData(GridData.FILL_HORIZONTAL); |
| menusCombo.setLayoutData(gridData); |
| |
| // Categories Tree |
| label = new Label(menusGroup,SWT.NONE); |
| label.setText(WorkbenchMessages.getString("ActionSetSelection.availableCategories")); //$NON-NLS-1$ |
| label.setFont(font); |
| |
| menuCategoriesViewer = new CheckboxTreeViewer(menusGroup); |
| data = new GridData(GridData.FILL_BOTH); |
| menuCategoriesViewer.getControl().setLayoutData(data); |
| menuCategoriesViewer.setLabelProvider(new LabelProvider()); |
| menuCategoriesViewer.setContentProvider(new TreeContentProvider()); |
| menuCategoriesViewer.setSorter(new WorkbenchViewerSorter()); |
| |
| // Menu items list |
| Composite menuItemsGroup = new Composite(sashComposite, SWT.NONE); |
| layout = new GridLayout(); |
| layout.marginHeight = 0; |
| layout.marginWidth = 0; |
| menuItemsGroup.setLayout(layout); |
| data = new GridData(GridData.FILL_BOTH); |
| menuItemsGroup.setLayoutData(data); |
| menuItemsGroup.setFont(font); |
| |
| label = new Label(menuItemsGroup, SWT.NONE); |
| label.setText(WorkbenchMessages.getString("ActionSetSelection.menuItems")); //$NON-NLS-1$ |
| label.setFont(font); |
| |
| menuItemsViewer = CheckboxTableViewer.newCheckList(menuItemsGroup, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL); |
| data = new GridData(GridData.FILL_BOTH); |
| Table menuTable = menuItemsViewer.getTable(); |
| menuTable.setLayoutData(data); |
| menuTable.setFont(font); |
| menuItemsViewer.setLabelProvider(new ShortcutMenuItemLabelProvider()); |
| menuItemsViewer.setContentProvider(new ShortcutMenuItemContentProvider()); |
| menuItemsViewer.setSorter(new WorkbenchViewerSorter()); |
| |
| menuTable.setHeaderVisible(true); |
| int[] columnWidths = new int[shortcutMenuColumnWidths.length]; |
| for (int i = 0; i < shortcutMenuColumnWidths.length; i++) { |
| columnWidths[i] = convertHorizontalDLUsToPixels(shortcutMenuColumnWidths[i]); |
| } |
| for (int i = 0; i < shortcutMenuColumnHeaders.length; i++) { |
| TableColumn tc = new TableColumn(menuTable, SWT.NONE,i); |
| tc.setResizable(true); |
| tc.setText(shortcutMenuColumnHeaders[i]); |
| tc.setWidth(columnWidths[i]); |
| } |
| sashComposite.setWeights(new int[]{30, 70}); |
| return menusComposite; |
| } |
| void handleActionSetMenuViewerKeyPressed(KeyEvent event) { |
| // popup the description for the selected action set menu item |
| if (event.keyCode == SWT.F2 && event.stateMask == 0) { |
| IStructuredSelection sel = (IStructuredSelection)actionSetMenuViewer.getSelection(); |
| ActionSetDisplayItem element = (ActionSetDisplayItem)sel.getFirstElement(); |
| if (element != null) { |
| String desc = element.description; |
| if (desc == null || desc.equals("")) { //$NON-NLS-1$ |
| desc = WorkbenchMessages.getString("ActionSetSelection.noDesc"); //$NON-NLS-1$ |
| } |
| popUp(desc); |
| } |
| } |
| } |
| void handleActionSetSelected(SelectionChangedEvent event) { |
| IStructuredSelection sel = (IStructuredSelection)event.getSelection(); |
| ActionSetDescriptor element = (ActionSetDescriptor)sel.getFirstElement(); |
| if (element == selectedActionSet) return; |
| String actionSetId = element.getId(); |
| // Hash table is used to cache previous selections |
| ArrayList structures = (ArrayList)actionSetStructures.get(actionSetId); |
| ActionSetDisplayItem menubarStructure = null; |
| ActionSetDisplayItem toolbarStructure = null; |
| // If the actionset has never been selected then we need to populate the structures |
| if (structures == null) { |
| structures = new ArrayList(2); |
| menubarStructure = new ActionSetDisplayItem("Menubar"); //$NON-NLS-1$ |
| toolbarStructure = new ActionSetDisplayItem("Toolbar"); //$NON-NLS-1$ |
| MenuManager windowMenuMgr = window.getMenuManager(); |
| CoolBarManager windowCoolBarManager = window.getCoolBarManager(); |
| // Update internal structure |
| windowCoolBarManager.refresh(); |
| if (containsActionSet(windowMenuMgr, actionSetId)) { |
| // if the action set is active, we can use the workbench menu and coolbar managers |
| // to figure out the action set structure. |
| menubarStructure.fillMenusFor(actionSetId, windowMenuMgr); |
| toolbarStructure.fillToolsFor(actionSetId, windowCoolBarManager); |
| } else { |
| // The action set is not active, so build the menus and toolbars for it using |
| // our fake action bars. |
| buildMenusAndToolbarsFor(element); |
| menubarStructure.fillMenusFor(actionSetId, customizeWorkbenchActionBars.menuManager); |
| toolbarStructure.fillToolsFor(actionSetId, customizeWorkbenchActionBars.coolBarManager); |
| |
| } |
| // Add menubarStructure and toolbarStructure to arrayList |
| structures.add(menubarStructure); |
| structures.add(toolbarStructure); |
| // Add the structure to the hash table with key actionSetId |
| actionSetStructures.put(actionSetId, structures); |
| } |
| // retrieve the actionsets from the arraylist |
| if (menubarStructure == null) menubarStructure = (ActionSetDisplayItem)structures.get(0); |
| if (toolbarStructure == null) toolbarStructure = (ActionSetDisplayItem)structures.get(1); |
| |
| // fill the menu structure table |
| if (element != actionSetMenuViewer.getInput()) { |
| try { |
| actionSetMenuViewer.getControl().setRedraw(false); |
| actionSetMenuViewer.setInput(menubarStructure.getElements()); |
| if (menubarStructure.children.size() > 0) { |
| actionSetMenuViewer.reveal(menubarStructure.children.get(0)); |
| } |
| } finally { |
| actionSetMenuViewer.getControl().setRedraw(true); |
| } |
| } |
| // fill the toolbar structure table |
| if (element != actionSetToolbarViewer.getInput()) { |
| try { |
| actionSetToolbarViewer.getControl().setRedraw(false); |
| actionSetToolbarViewer.setInput(toolbarStructure.getElements()); |
| if (toolbarStructure.children.size() > 0) { |
| actionSetToolbarViewer.reveal(toolbarStructure.children.get(0)); |
| } |
| } finally { |
| actionSetToolbarViewer.getControl().setRedraw(true); |
| } |
| } |
| selectedActionSet = element; |
| } |
| void handleActionSetToolbarViewerKeyPressed(KeyEvent event) { |
| // popup the description for the selected action set toolbar item |
| if (event.keyCode == SWT.F2 && event.stateMask == 0) { |
| IStructuredSelection sel = (IStructuredSelection)actionSetToolbarViewer.getSelection(); |
| ActionSetDisplayItem element = (ActionSetDisplayItem)sel.getFirstElement(); |
| if (element != null) { |
| String desc = element.description; |
| if (desc == null || desc.equals("")) { //$NON-NLS-1$ |
| desc = WorkbenchMessages.getString("ActionSetSelection.noDesc"); //$NON-NLS-1$ |
| } |
| popUp(desc); |
| } |
| } |
| } |
| void handleActionSetViewerKeyPressed(KeyEvent event) { |
| // popup the description for the selected action set |
| if (event.keyCode == SWT.F2 && event.stateMask == 0) { |
| IStructuredSelection sel = (IStructuredSelection)actionSetsViewer.getSelection(); |
| ActionSetDescriptor element = (ActionSetDescriptor)sel.getFirstElement(); |
| if (element != null) { |
| String desc = element.getDescription(); |
| if (desc == null || desc.equals("")) { //$NON-NLS-1$ |
| desc = WorkbenchMessages.getString("ActionSetSelection.noDesc"); //$NON-NLS-1$ |
| } |
| popUp(desc); |
| } |
| } |
| } |
| void handleMenuCategoryChecked(CheckStateChangedEvent event) { |
| ShortcutMenu checkedCategory = (ShortcutMenu)event.getElement(); |
| boolean checked = event.getChecked(); |
| checkedCategory.checked(checked); |
| // check/uncheck the element's category subtree |
| menuCategoriesViewer.setSubtreeChecked(checkedCategory, checked); |
| // set gray state of the element's category subtree, all items should |
| // not be grayed |
| ArrayList subtree = checkedCategory.getSubtreeItems(); |
| ShortcutMenu menuItemInput = (ShortcutMenu)menuItemsViewer.getInput(); |
| for (int i=0; i<subtree.size(); i++) { |
| Object child = subtree.get(i); |
| menuCategoriesViewer.setGrayed(child, false); |
| if (child == menuItemInput) menuItemsViewer.setAllChecked(checked); |
| } |
| menuCategoriesViewer.setGrayed(checkedCategory, false); |
| updateMenuCategoryCheckedState(checkedCategory.parent); |
| } |
| void handleMenuCategorySelected(SelectionChangedEvent event) { |
| IStructuredSelection sel = (IStructuredSelection)event.getSelection(); |
| ShortcutMenu element = (ShortcutMenu)sel.getFirstElement(); |
| if (element == selectedMenuCategory) return; |
| if (element != menuItemsViewer.getInput()) { |
| menuItemsViewer.setInput(element); |
| } |
| if (element != null) { |
| menuItemsViewer.setCheckedElements(element.getCheckedItems().toArray()); |
| } |
| } |
| void handleMenuItemChecked(CheckStateChangedEvent event) { |
| ShortcutMenu selectedMenu = (ShortcutMenu)menuItemsViewer.getInput(); |
| boolean itemChecked = event.getChecked(); |
| Object item = event.getElement(); |
| if (itemChecked) { |
| selectedMenu.addCheckedItem(item); |
| } else { |
| selectedMenu.removeCheckedItem(item); |
| } |
| updateMenuCategoryCheckedState(selectedMenu); |
| } |
| void handleMenuModified(ModifyEvent event) { |
| String text = menusCombo.getText(); |
| String[] items = menusCombo.getItems(); |
| int itemIndex = -1; |
| for (int i=0; i<items.length; i++) { |
| if (items[i].equals(text)) { |
| itemIndex = i; |
| break; |
| } |
| } |
| if (itemIndex == -1) return; |
| ShortcutMenu element = (ShortcutMenu)rootMenu.children.get(itemIndex); |
| handleMenuSelected(element); |
| } |
| void handleMenuSelected(SelectionEvent event) { |
| int i = menusCombo.getSelectionIndex(); |
| ShortcutMenu element = (ShortcutMenu)rootMenu.children.get(i); |
| handleMenuSelected(element); |
| } |
| void handleMenuSelected(ShortcutMenu element) { |
| if (element != menuCategoriesViewer.getInput()) { |
| menuCategoriesViewer.setInput(element); |
| menuCategoriesViewer.expandAll(); |
| if (element != null) { |
| if (element.getChildren().size() > 0) { |
| StructuredSelection sel = new StructuredSelection(element.getChildren().get(0)); |
| menuCategoriesViewer.setSelection(sel, true); |
| } else { |
| menuItemsViewer.setInput(element); |
| menuItemsViewer.setCheckedElements(element.getCheckedItems().toArray()); |
| } |
| } else { |
| menuCategoriesViewer.setInput(element); |
| menuItemsViewer.setInput(element); |
| } |
| checkInitialMenuCategorySelections(rootMenu); |
| } |
| } |
| void handleTabSelected(SelectionEvent event) { |
| TabItem item = (TabItem)event.item; |
| Control control = item.getControl(); |
| if (control != null) control.setFocus(); |
| } |
| private void initializeActionSetInput() { |
| // Just get the action sets at this point. Do not load the action set until it |
| // is actually selected in the dialog. |
| ActionSetRegistry reg = WorkbenchPlugin.getDefault().getActionSetRegistry(); |
| IActionSetDescriptor [] sets = reg.getActionSets(); |
| for (int i = 0; i < sets.length; i ++) { |
| ActionSetDescriptor actionSetDesc = (ActionSetDescriptor)sets[i]; |
| if (WorkbenchActivityHelper.filterItem(actionSetDesc)) |
| continue; |
| actionSets.add(actionSetDesc); |
| } |
| String iconPath = "icons/full/obj16/menu.gif";//$NON-NLS-1$ |
| URL url = BundleUtility.find(PlatformUI.PLUGIN_ID, iconPath); |
| menuImageDescriptor = ImageDescriptor.createFromURL(url); |
| |
| iconPath = "icons/full/obj16/submenu.gif";//$NON-NLS-1$ |
| url = BundleUtility.find(PlatformUI.PLUGIN_ID, iconPath); |
| submenuImageDescriptor = ImageDescriptor.createFromURL(url); |
| |
| iconPath = "icons/full/obj16/toolbar.gif";//$NON-NLS-1$ |
| url = BundleUtility.find(PlatformUI.PLUGIN_ID, iconPath); |
| toolbarImageDescriptor = ImageDescriptor.createFromURL(url); |
| } |
| |
| private void initializeShortCutMenu(ShortcutMenu menu, WizardCollectionElement element, ArrayList activeIds) { |
| ShortcutMenu category = new ShortcutMenu(menu, element.getId(), element.getLabel(element)); |
| Object[] wizards = element.getWizards(); |
| for (int i = 0; i < wizards.length; i++) { |
| WorkbenchWizardElement wizard = (WorkbenchWizardElement)wizards[i]; |
| category.addItem(wizard); |
| if (activeIds.contains(wizard.getID())) category.addCheckedItem(wizard); |
| } |
| // @issue should not pass in null |
| Object[] children = element.getChildren(null); |
| for (int i = 0; i < children.length; i++) { |
| initializeShortCutMenu(category, (WizardCollectionElement)children[i], activeIds); |
| } |
| } |
| private void initializeShortcutMenuInput() { |
| rootMenu = new ShortcutMenu(null, "Root", ""); //$NON-NLS-1$ //$NON-NLS-2$ |
| ArrayList activeIds; |
| |
| if (window.containsSubmenu(WorkbenchWindow.NEW_WIZARD_SUBMENU)) { |
| ShortcutMenu wizardMenu = new ShortcutMenu(rootMenu, ShortcutMenu.ID_WIZARD, WorkbenchMessages.getString("ActionSetDialogInput.wizardCategory")); //$NON-NLS-1$ |
| NewWizardsRegistryReader rdr = new NewWizardsRegistryReader(); |
| WizardCollectionElement wizardCollection = rdr.getWizardElements(); |
| |
| // @issue should not pass in null |
| Object [] wizardCategories = wizardCollection.getChildren(null); |
| activeIds = perspective.getNewWizardActionIds(); |
| for (int i = 0; i < wizardCategories.length; i ++) { |
| WizardCollectionElement element = (WizardCollectionElement)wizardCategories[i]; |
| if (WorkbenchActivityHelper.filterItem(element)) |
| continue; |
| initializeShortCutMenu(wizardMenu, element, activeIds); |
| } |
| } |
| |
| if (window.containsSubmenu(WorkbenchWindow.OPEN_PERSPECTIVE_SUBMENU)) { |
| ShortcutMenu perspMenu = new ShortcutMenu(rootMenu, ShortcutMenu.ID_PERSP, WorkbenchMessages.getString("ActionSetDialogInput.perspectiveCategory")); //$NON-NLS-1$ |
| IPerspectiveRegistry perspReg = WorkbenchPlugin.getDefault().getPerspectiveRegistry(); |
| IPerspectiveDescriptor [] persps = perspReg.getPerspectives(); |
| for (int i = 0; i < persps.length; i ++) { |
| if (WorkbenchActivityHelper.filterItem(persps[i])) |
| continue; |
| perspMenu.addItem(persps[i]); |
| } |
| activeIds = perspective.getPerspectiveActionIds(); |
| for (int i = 0; i < activeIds.size(); i++) { |
| String id = (String)activeIds.get(i); |
| Object item = perspMenu.getItem(id); |
| if (item != null) perspMenu.addCheckedItem(item); |
| } |
| } |
| |
| if (window.containsSubmenu(WorkbenchWindow.SHOW_VIEW_SUBMENU)) { |
| ShortcutMenu viewMenu = new ShortcutMenu(rootMenu, ShortcutMenu.ID_VIEW, WorkbenchMessages.getString("ActionSetDialogInput.viewCategory")); //$NON-NLS-1$ |
| IViewRegistry viewReg = WorkbenchPlugin.getDefault().getViewRegistry(); |
| Category[] categories = viewReg.getCategories(); |
| activeIds = perspective.getShowViewActionIds(); |
| for (int i=0; i<categories.length; i++) { |
| Category category = categories[i]; |
| if (WorkbenchActivityHelper.filterItem(category)) |
| continue; |
| ShortcutMenu viewCategory = new ShortcutMenu(viewMenu, category.getId(), category.getLabel()); |
| ArrayList views = category.getElements(); |
| if (views != null) { |
| for (int j=0; j<views.size(); j++) { |
| IViewDescriptor view = (IViewDescriptor)views.get(j); |
| if (view.getID().equals(IIntroConstants.INTRO_VIEW_ID)) |
| continue; |
| if (WorkbenchActivityHelper.filterItem(view)) |
| continue; |
| viewCategory.addItem(view); |
| if (activeIds.contains(view.getId())) viewCategory.addCheckedItem(view); |
| } |
| } |
| } |
| } |
| } |
| protected void okPressed() { |
| if (showShortcutTab()) { |
| ArrayList menus = rootMenu.children; |
| for (int i=0; i < menus.size(); i++) { |
| ShortcutMenu menu = (ShortcutMenu)menus.get(i); |
| if (ShortcutMenu.ID_VIEW.equals(menu.id)) { |
| perspective.setShowViewActionIds(menu.getCheckedItemIds()); |
| } else if (ShortcutMenu.ID_PERSP.equals(menu.id)) { |
| perspective.setPerspectiveActionIds(menu.getCheckedItemIds()); |
| } else if (ShortcutMenu.ID_WIZARD.equals(menu.id)) { |
| perspective.setNewWizardActionIds(menu.getCheckedItemIds()); |
| } |
| } |
| } |
| |
| ArrayList actionSetList = new ArrayList(); |
| Object[] selected = actionSetsViewer.getCheckedElements(); |
| for (int i = 0; i < selected.length; i ++) { |
| Object obj = selected[i]; |
| actionSetList.add(obj); |
| } |
| IActionSetDescriptor [] actionSetArray = new IActionSetDescriptor[actionSetList.size()]; |
| actionSetArray = (IActionSetDescriptor [])actionSetList.toArray(actionSetArray); |
| perspective.setActionSets(actionSetArray); |
| |
| super.okPressed(); |
| } |
| private void popUp(String description) { |
| Display display = getShell().getDisplay(); |
| final Shell descShell = new Shell(getShell(), SWT.ON_TOP | SWT.NO_TRIM); |
| GridLayout layout = new GridLayout(); |
| layout.marginHeight = 1; |
| layout.marginWidth = 1; |
| descShell.setLayout(layout); |
| descShell.setBackground(display.getSystemColor(SWT.COLOR_BLACK)); |
| |
| Composite insetComposite = new Composite(descShell, SWT.NULL); |
| insetComposite.setBackground(display.getSystemColor(SWT.COLOR_INFO_BACKGROUND)); |
| layout = new GridLayout(); |
| layout.marginHeight = 2; |
| layout.marginWidth = 2; |
| insetComposite.setLayout(layout); |
| GridData data = new GridData(GridData.FILL_BOTH); |
| insetComposite.setLayoutData(data); |
| insetComposite.addFocusListener(new FocusListener() { |
| public void focusLost(FocusEvent e) { |
| descShell.dispose(); |
| } |
| public void focusGained(FocusEvent e) { |
| } |
| }); |
| insetComposite.addKeyListener(new KeyListener() { |
| public void keyPressed(KeyEvent e) { |
| descShell.dispose(); |
| } |
| public void keyReleased(KeyEvent e) { |
| } |
| }); |
| |
| StyledText descText = new StyledText(insetComposite, SWT.MULTI | SWT.READ_ONLY | SWT.WRAP); |
| descText.setForeground(display.getSystemColor(SWT.COLOR_INFO_FOREGROUND)); |
| descText.setBackground(display.getSystemColor(SWT.COLOR_INFO_BACKGROUND)); |
| data = new GridData(GridData.FILL_BOTH); |
| data.widthHint = 200; |
| descText.setLayoutData(data); |
| descText.setText(description); |
| descText.setEnabled(false); |
| |
| descShell.pack(); |
| Rectangle displayBounds= display.getClientArea(); |
| Rectangle bounds = descShell.getBounds(); |
| Point point = display.getCursorLocation(); |
| Point location = new Point(point.x + cursorSize, point.y + cursorSize); |
| if (location.x + bounds.width > displayBounds.x + displayBounds.width) { |
| location.x = displayBounds.x + displayBounds.width - bounds.width; |
| } |
| if (location.y + bounds.height > displayBounds.x + displayBounds.height) { |
| location.y = displayBounds.y + displayBounds.height - bounds.height; |
| } |
| descShell.setLocation(location); |
| descShell.open(); |
| descShell.addShellListener(new ShellListener() { |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.events.ShellListener#shellActivated(org.eclipse.swt.events.ShellEvent) |
| */ |
| public void shellActivated(ShellEvent e) { |
| // Do nothing |
| |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.events.ShellListener#shellClosed(org.eclipse.swt.events.ShellEvent) |
| */ |
| public void shellClosed(ShellEvent e) { |
| // Do nothing. |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.events.ShellListener#shellDeactivated(org.eclipse.swt.events.ShellEvent) |
| */ |
| public void shellDeactivated(ShellEvent e) { |
| descShell.dispose(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.events.ShellListener#shellDeiconified(org.eclipse.swt.events.ShellEvent) |
| */ |
| public void shellDeiconified(ShellEvent e) { |
| // Do nothing |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.swt.events.ShellListener#shellIconified(org.eclipse.swt.events.ShellEvent) |
| */ |
| public void shellIconified(ShellEvent e) { |
| descShell.dispose(); |
| } |
| }); |
| } |
| String removeShortcut(String label) { |
| if (label == null) return label; |
| int end = label.lastIndexOf('@'); |
| if (end >= 0) label = label.substring(0, end); |
| return label; |
| } |
| private void setInitialSelections() { |
| Object item = actionSetsViewer.getElementAt(0); |
| if (lastSelectedActionSetId != null) { |
| for (int i=0; i<actionSets.size(); i++) { |
| ActionSetDescriptor actionSet = (ActionSetDescriptor)actionSets.get(i); |
| if (actionSet.getId().equals(lastSelectedActionSetId)) { |
| item = actionSet; |
| break; |
| } |
| } |
| } |
| StructuredSelection sel = new StructuredSelection(item); |
| actionSetsViewer.setSelection(sel, true); |
| |
| if (showShortcutTab()) { |
| menusCombo.select(lastSelectedMenuIndex); |
| } |
| |
| if (lastSelectedTab != -1) { |
| tabFolder.setSelection(lastSelectedTab); |
| } |
| |
| if ((tabFolder.getSelectionIndex() == 0) && showShortcutTab()) { |
| menusCombo.setFocus(); |
| } else { |
| actionSetsViewer.getControl().setFocus(); |
| } |
| } |
| |
| private void updateMenuCategoryCheckedState(ShortcutMenu menu) { |
| if (menu == rootMenu) return; |
| if (menu.isFullyChecked()) { |
| menuCategoriesViewer.setParentsGrayed(menu, false); |
| menuCategoriesViewer.setChecked(menu, true); |
| } else if (menu.isFullyUnchecked()) { |
| menuCategoriesViewer.setParentsGrayed(menu, false); |
| menuCategoriesViewer.setChecked(menu, false); |
| } else { |
| menuCategoriesViewer.setParentsGrayed(menu, true); |
| menuCategoriesViewer.setChecked(menu, true); |
| } |
| updateMenuCategoryCheckedState(menu.parent); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.dialogs.Dialog#applyDialogFont() |
| */ |
| protected boolean applyDialogFont() { |
| return false; |
| } |
| |
| } |
