* Copyright (c) 2000, 2007 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

*******************************************************************************/

* Dialog to allow users the ability to customize the perspective. This includes

* customizing menus and toolbars by adding, removing, or re-arranging commands

* or groups of commands.

*

*/

  private DefaultToolTip actionSetMenuViewerTooltip;

 

  private DefaultToolTip actionSetToolbarViewerTooltip;

 

  private DefaultToolTip actionSetsViewerTooltip;

 

    private Perspective perspective;

    WorkbenchWindow window;

    private TabFolder tabFolder;

    private CheckboxTableViewer actionSetsViewer;

    private TreeViewer actionSetMenuViewer;

    private TreeViewer actionSetToolbarViewer;

    private Combo menusCombo;

    private CheckboxTreeViewer menuCategoriesViewer;

    private CheckboxTableViewer menuItemsViewer;

    private static int lastSelectedTab = -1;

    private static int lastSelectedMenuIndex = 0;

    private static String lastSelectedActionSetId = null;

    private final static int TAB_WIDTH_IN_DLUS = 490;

    private final static int TAB_HEIGHT_IN_DLUS = 230;

    private final String shortcutMenuColumnHeaders[] = {

            WorkbenchMessages.ActionSetSelection_menuColumnHeader,

            WorkbenchMessages.ActionSetSelection_descriptionColumnHeader };

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

  private IWorkbenchWindowConfigurer configurer;

    private List initiallyActive = new ArrayList();

        /**

         * 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;

        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;

        }

        /**

         * @param actionSetId the action to fill

         * @param item the item to fill

         */

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

                        }

                    }

                }

            }

        }

        /**

         * @param actionSetId the action set to fill

         * @param mgr the manager to fill into

         */

        public void fillToolsFor(String actionSetId, CoolBarManager mgr) {

            IContributionItem[] items = mgr.getItems();

            for (int i = 0; i < items.length; i++) {

                if (items[i] instanceof IToolBarContributionItem) {

                  IToolBarContributionItem cbItem = (IToolBarContributionItem) 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;

      }

            return parent.getDepth() + 1;

        }

        String getDisplayText() {

            if (type == MENUITEM) {

                if (children.size() > 0) {

                    if (parent.id.equals("Root")) { //$NON-NLS-1$

                        return NLS.bind(WorkbenchMessages.ActionSetSelection_menubarLocation, text );

                    }

                }

                return text;

            }

            if (children.size() > 0) {

        return NLS.bind(WorkbenchMessages.ActionSetSelection_toolbarLocation, text );

      }

           

            return text;

        }

        protected boolean isTopLevelMenu() {

            if (parent == null) {

        return false;

      }

            return parent.parent == null;

        }

       

        public String toString() {

          StringBuffer sb = new StringBuffer();

          for (int i = getDepth(); --i >= 0;) {

            sb.append("  "); //$NON-NLS-1$

          }

        sb.append("id: "); //$NON-NLS-1$

        sb.append(id);

        sb.append("  text: "); //$NON-NLS-1$

        sb.append(text);

          sb.append('\n');

          for (int i = 0; i < children.size(); ++i) {

            sb.append(children.get(i));

          }

          return sb.toString();

           

        }

    }

    /**

     * The proxy IActionBarConfigurer that gets passed to the application's

     * ActionBarAdvisor.  This is used to construct a representation of the

     * window's hardwired menus and toolbars in order to display their

     * structure properly in the preview panes.

     */

    public class CustomizeActionBars implements IActionBarConfigurer2,

      IActionBars2 {

       

        IWorkbenchWindowConfigurer configurer;

       

        /**

         * 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 = new MenuManager();

        CoolBarManager coolBarManager = new CoolBarManager();

        StatusLineManager statusLineManager = new StatusLineManager();

       

        /**

         * Create a new instance of this class.

         *

         * @param configurer the configurer

         */

        public CustomizeActionBars(IWorkbenchWindowConfigurer configurer) {

            this.configurer = configurer;

        }

       

        /* (non-Javadoc)

         * @see org.eclipse.ui.application.IActionBarConfigurer#getWindowConfigurer()

         */

        public IWorkbenchWindowConfigurer getWindowConfigurer() {

            return configurer;

        }

       

        /*

         *  (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 statusLineManager;

        }

        /* (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) {

        }

        /**

         * Clean up the action bars.

         */

    public void dispose() {

      coolBarManager.dispose();

          menuManager.dispose(); 

          statusLineManager.dispose();

      }

    public final IServiceLocator getServiceLocator() {

      return configurer.getWindow();

    }

    /* (non-Javadoc)

     * @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarContributionItem(org.eclipse.jface.action.IToolBarManager, java.lang.String)

     */

    public IToolBarContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {

      return new ToolBarContributionItem2(toolBarManager, id);

    }

    /* (non-Javadoc)

     * @see org.eclipse.ui.application.IActionBarConfigurer#createToolBarManager(int)

     */

    public IToolBarManager createToolBarManager() {

      return new ToolBarManager();

    }

    }

    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;

      }

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

            } else if (element instanceof ArrayList) {

              return ((ArrayList) element).toArray();

            }

            return new Object[0];

        }

        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 ActionSetLabelProvider extends LabelProvider {

        private Map imageTable = new Hashtable();

        public void dispose() {

            for (Iterator i = imageTable.values().iterator(); i.hasNext();) {

                ((Image) i.next()).dispose();

            }

            imageTable = null;

        }

        public Image getImage(Object element) {

            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 getText(Object element) {

            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$

        }

    }

    /**

     * Create an instance of this Dialog.

     *

     * @param configurer the configurer

     * @param persp the perspective

     */

    public CustomizePerspectiveDialog(IWorkbenchWindowConfigurer configurer, Perspective persp) {

        super(configurer.getWindow().getShell());

        setShellStyle(SWT.MAX | SWT.RESIZE | getShellStyle());

       

        this.configurer = configurer;

        perspective = persp;

        window = (WorkbenchWindow) configurer.getWindow();

       

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

            }

        });

        menusCombo.addModifyListener(new ModifyListener() {

            public void modifyText(ModifyEvent e) {

                handleMenuModified();

            }

        });

        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(CustomizeActionBars customizeActionBars, ActionSetDescriptor actionSetDesc) {

        String id = actionSetDesc.getId();

        ActionSetActionBars bars = new ActionSetActionBars(

            customizeActionBars, window, customizeActionBars, 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(), ex); //$NON-NLS-1$

            return;

        }

        builder.buildMenuAndToolBarStructure(actionSet, window);

    }

    private void checkInitialActionSetSelections() {

        // Check off the action sets that are active for the perspective.

        IActionSetDescriptor[] actionSetDescriptors = ((WorkbenchPage)window.getActivePage()).getActionSets();

        initiallyActive  = Arrays.asList(actionSetDescriptors);

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

        IStructuredSelection selection = (IStructuredSelection) actionSetsViewer

                .getSelection();

        if (selection.isEmpty()) {

      lastSelectedActionSetId = null;

    } else {

      lastSelectedActionSetId = ((ActionSetDescriptor) selection

                    .getFirstElement()).getId();

    }

        return super.close();

    }

    protected void configureShell(Shell shell) {

        super.configureShell(shell);

        String title=perspective.getDesc().getLabel();

       

        title = NLS.bind(WorkbenchMessages.ActionSetSelection_customize,title);

        shell.setText(title);

        window.getWorkbench().getHelpSystem().setHelp(shell,

        IWorkbenchHelpContextIds.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;

     

        Composite actionSetsComposite = new Composite(parent, SWT.NONE);

        GridLayout layout = new GridLayout();

        actionSetsComposite.setLayout(layout);

        // Select... label

        Label label = new Label(actionSetsComposite, SWT.WRAP);

        label

                .setText(NLS.bind(WorkbenchMessages.ActionSetSelection_selectActionSetsLabel,perspective.getDesc().getLabel() ));

        data = new GridData(SWT.FILL, SWT.CENTER, true, false);

        label.setLayoutData(data);

        Label sep = new Label(actionSetsComposite, SWT.HORIZONTAL

                | SWT.SEPARATOR);

        sep.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

        SashForm sashComposite = new SashForm(actionSetsComposite,

                SWT.HORIZONTAL);

        data = new GridData(SWT.FILL, SWT.FILL, true, true);

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

        actionSetGroup.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

        label = new Label(actionSetGroup, SWT.WRAP);

        label.setText(WorkbenchMessages.ActionSetSelection_availableActionSets);

        label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

       

        actionSetsViewer = CheckboxTableViewer.newCheckList(actionSetGroup,

                SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);

        actionSetsViewer.getTable().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

        actionSetsViewer.setLabelProvider(new WorkbenchLabelProvider());

        actionSetsViewer.setContentProvider(new ArrayContentProvider());

        actionSetsViewer.setComparator(new ActionSetComparator());

        actionSetsViewerTooltip = new DefaultToolTip(actionSetsViewer.getControl(),ToolTip.RECREATE,true){

      public Point getLocation(Point tipSize, Event event) {

        return getShell().getDisplay().getCursorLocation();

      }

         

        };

        // Menu and toolbar composite

        Composite actionGroup = new Composite(sashComposite, SWT.NONE);

        layout = new GridLayout();

        layout.numColumns = 2;

        layout.makeColumnsEqualWidth = true;

        layout.marginHeight = 0;

        layout.marginWidth = 0;

        layout.horizontalSpacing = 0;

        actionGroup.setLayout(layout);

        actionGroup.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

        Composite menubarGroup = new Composite(actionGroup, SWT.NONE);

        layout = new GridLayout();

        layout.marginHeight = 0;

        layout.marginWidth = 0;

        menubarGroup.setLayout(layout);

        menubarGroup.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

       

        label = new Label(menubarGroup, SWT.WRAP);

        label.setText(WorkbenchMessages.ActionSetSelection_menubarActions);

        label.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

        actionSetMenuViewer = new TreeViewer(menubarGroup);

        actionSetMenuViewer.setAutoExpandLevel(AbstractTreeViewer.ALL_LEVELS);

        actionSetMenuViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

        actionSetMenuViewer.setLabelProvider(new ActionSetLabelProvider());

        actionSetMenuViewer.setContentProvider(new TreeContentProvider());

        actionSetMenuViewerTooltip = new DefaultToolTip(actionSetMenuViewer.getControl(),ToolTip.RECREATE, true) {

      public Point getLocation(Point tipSize, Event event) {

        return getShell().getDisplay().getCursorLocation();

      }

         

        };

        Composite toolbarGroup = new Composite(actionGroup, SWT.NONE);

        layout = new GridLayout();

        layout.marginHeight = 0;

        layout.marginWidth = 0;

        toolbarGroup.setLayout(layout);

        toolbarGroup.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));