| /******************************************************************************* |
| * Copyright (c) 2003, 2008 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.ui.internal; |
| |
| import org.eclipse.jface.action.IContributionItem; |
| import org.eclipse.jface.action.ToolBarManager; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.CoolBar; |
| import org.eclipse.swt.widgets.CoolItem; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.MenuItem; |
| import org.eclipse.swt.widgets.ToolBar; |
| import org.eclipse.swt.widgets.ToolItem; |
| import org.eclipse.ui.IWorkbenchPreferenceConstants; |
| import org.eclipse.ui.internal.layout.LayoutUtil; |
| import org.eclipse.ui.internal.util.PrefUtil; |
| |
| public class PerspectiveBarManager extends ToolBarManager { |
| |
| public PerspectiveBarManager(int style) { |
| super(style); |
| } |
| |
| public ToolBar createControl(Composite parent) { |
| ToolBar control = super.createControl(parent); |
| |
| return control; |
| } |
| |
| // TODO begin refactor this out? it is not good that we know we are inside a |
| // CoolBar |
| private CoolBar coolBar; |
| private Menu chevronMenu = null; |
| |
| public void handleChevron(SelectionEvent event) { |
| CoolItem item = (CoolItem) event.widget; |
| //ToolBar toolbar = (ToolBar)getControl(); |
| Control control = getControl(); |
| if (!(control instanceof ToolBar)) { |
| return; // currently we only deal with toolbar items |
| } |
| /* Retrieve the current bounding rectangle for the selected cool item. */ |
| Rectangle itemBounds = item.getBounds(); |
| /* Convert to display coordinates (i.e. was relative to CoolBar). */ |
| Point pt = coolBar.toDisplay(new Point(itemBounds.x, itemBounds.y)); |
| itemBounds.x = pt.x; |
| itemBounds.y = pt.y; |
| /* Retrieve the total number of buttons in the toolbar. */ |
| ToolBar toolBar = (ToolBar) control; |
| ToolItem[] tools = toolBar.getItems(); |
| int toolCount = tools.length; |
| int i = 0; |
| while (i < toolCount) { |
| /* |
| * Starting from the leftmost tool, retrieve the tool's bounding |
| * rectangle. |
| */ |
| Rectangle toolBounds = tools[i].getBounds(); |
| /* Convert to display coordinates (i.e. was relative to ToolBar). */ |
| pt = toolBar.toDisplay(new Point(toolBounds.x, toolBounds.y)); |
| toolBounds.x = pt.x; |
| toolBounds.y = pt.y; |
| /* |
| * Figure out the visible portion of the tool by looking at the |
| * intersection of the tool bounds with the cool item bounds. |
| */ |
| Rectangle intersection = itemBounds.intersection(toolBounds); |
| /* |
| * If the tool is not completely within the cool item bounds, then |
| * the tool is at least partially hidden, and all remaining tools |
| * are completely hidden. |
| */ |
| if (!intersection.equals(toolBounds)) { |
| break; |
| } |
| i++; |
| } |
| |
| /* Create a pop-up menu with items for each of the hidden buttons. */ |
| // Out with the old... |
| if (chevronMenu != null && !chevronMenu.isDisposed()) |
| chevronMenu.dispose(); |
| |
| // ...In with the new |
| chevronMenu = new Menu(coolBar); |
| |
| for (int j = i; j < toolCount; j++) { |
| ToolItem tool = tools[j]; |
| MenuItem menuItem = new MenuItem(chevronMenu, SWT.NONE); |
| if (tool.getSelection()) { |
| menuItem.setEnabled(false); |
| } |
| |
| // Show the full text of the perspective name in the chevron menu. |
| if (tool.getData() instanceof PerspectiveBarContributionItem) { |
| menuItem.setText(((PerspectiveBarContributionItem) tool |
| .getData()).getPerspective().getLabel()); |
| } else { |
| menuItem.setText(tool.getText()); |
| } |
| menuItem.setImage(tool.getImage()); |
| |
| menuItem.setData("IContributionItem", tool.getData()); //$NON-NLS-1$ |
| |
| menuItem.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| //rotate the selected item in and the other items right |
| // don't touch the "Open" item |
| MenuItem menuItem = (MenuItem) e.widget; |
| Object item = menuItem.getData("IContributionItem"); //$NON-NLS-1$ |
| if (item instanceof PerspectiveBarContributionItem) { |
| PerspectiveBarContributionItem contribItem = (PerspectiveBarContributionItem) item; |
| update(false); |
| contribItem.select(); |
| } |
| } |
| }); |
| } |
| /* |
| * Display the pop-up menu immediately below the chevron, with the left |
| * edges aligned. Need to convert the given point to display |
| * coordinates in order to pass them to Menu.setLocation (i.e. was |
| * relative to CoolBar). |
| */ |
| pt = coolBar.toDisplay(new Point(event.x, event.y)); |
| chevronMenu.setLocation(pt.x, pt.y); |
| chevronMenu.setVisible(true); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jface.action.ToolBarManager#relayout(org.eclipse.swt.widgets.ToolBar, int, int) |
| */ |
| protected void relayout(ToolBar toolBar, int oldCount, int newCount) { |
| super.relayout(toolBar, oldCount, newCount); |
| |
| if (getControl() != null) { |
| LayoutUtil.resize(getControl()); |
| } |
| } |
| |
| void setParent(CoolBar cool) { |
| this.coolBar = cool; |
| } |
| |
| /** |
| * Method to select a PerspectiveBarContributionItem and ensure |
| * that it is visible. It updates the MRU list. |
| * @param contribItem the PerspectiveBarContributionItem to select |
| */ |
| void select(PerspectiveBarContributionItem contribItem) { |
| if (contribItem.getToolItem() == null) { |
| return; |
| } |
| // check if not visible and ensure visible |
| if (getControl().isVisible() |
| && !isItemVisible(contribItem.getToolItem())) { |
| ensureVisible(contribItem); |
| } |
| } |
| |
| /** |
| * Method that adds a PerspectiveBarContributionItem and |
| * ensures it is visible |
| * @param item the PerspectiveBarContributionItem to be added |
| */ |
| public void addItem(PerspectiveBarContributionItem item) { |
| // Put it after the 'open' button (if any) |
| IPreferenceStore apiPreferenceStore = PrefUtil.getAPIPreferenceStore(); |
| if (apiPreferenceStore.getBoolean(IWorkbenchPreferenceConstants.SHOW_OPEN_ON_PERSPECTIVE_BAR)) |
| insert(1, item); |
| else |
| insert(0, item); |
| |
| update(false); |
| } |
| |
| /** |
| * Method to remove a PerspectiveBarContributionItem from the toolbar |
| * and from the MRU and sequence lists when necessary |
| * @param item the PerspectiveBarContributionItem to be removed |
| */ |
| public void removeItem(PerspectiveBarContributionItem item) { |
| remove(item); |
| } |
| |
| /** |
| * Re-insert the item at the beginning of the perspective bar, |
| * ensuring that it is visible to the user. |
| * |
| * @param contribItem |
| */ |
| private void ensureVisible(PerspectiveBarContributionItem contribItem) { |
| relocate(contribItem, 1); |
| } |
| |
| void relocate(PerspectiveBarContributionItem contribItem, int index) { |
| PerspectiveBarContributionItem newItem = new PerspectiveBarContributionItem( |
| contribItem.getPerspective(), contribItem.getPage()); |
| |
| removeItem(contribItem); |
| contribItem.dispose(); |
| contribItem = null; |
| |
| insert(index, newItem); |
| update(false); |
| } |
| |
| /** |
| * @return true if the toolItem is visible on the screen, false otherwise. |
| */ |
| private boolean isItemVisible(ToolItem toolItem) { |
| Rectangle barBounds = getControl().getBounds(); |
| Rectangle itemBounds = toolItem.getBounds(); |
| return (barBounds.intersection(itemBounds).equals(itemBounds)); |
| } |
| |
| /** |
| * This method ensures that the selected item in the toolbar is visible. |
| */ |
| public void arrangeToolbar() { |
| // check if the tool bar is visible |
| if (!getControl().isVisible()) { |
| return; |
| } |
| |
| // the tool bar should contain at least the new perspective button |
| // and 2 other buttons |
| if (getControl().getItemCount() < 3) { |
| return; |
| } |
| |
| // Find the selected item and make sure it is visible. |
| IContributionItem[] items = getItems(); |
| for (int i = 2; i < items.length; i++) { |
| PerspectiveBarContributionItem contribItem = (PerspectiveBarContributionItem) items[i]; |
| if (contribItem.getToolItem().getSelection()) { |
| if (!isItemVisible(contribItem.getToolItem())) { |
| ensureVisible(contribItem); |
| break; |
| } |
| } |
| } |
| } |
| } |
