| /******************************************************************************* |
| * Copyright (c) 2004, 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 |
| * Kiryl Kazakevich, Intel - bug 88359 |
| *******************************************************************************/ |
| package org.eclipse.ui.internal; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.action.IContributionItem; |
| import org.eclipse.jface.action.MenuManager; |
| import org.eclipse.jface.action.ToolBarManager; |
| import org.eclipse.jface.util.Geometry; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.accessibility.AccessibleAdapter; |
| import org.eclipse.swt.accessibility.AccessibleEvent; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.events.SelectionListener; |
| import org.eclipse.swt.graphics.Cursor; |
| import org.eclipse.swt.graphics.Image; |
| 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.Event; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.ToolBar; |
| import org.eclipse.swt.widgets.ToolItem; |
| import org.eclipse.ui.IMemento; |
| import org.eclipse.ui.IViewReference; |
| import org.eclipse.ui.IWorkbenchPart; |
| import org.eclipse.ui.IWorkbenchPreferenceConstants; |
| import org.eclipse.ui.PlatformUI; |
| import org.eclipse.ui.internal.dnd.AbstractDropTarget; |
| import org.eclipse.ui.internal.dnd.DragUtil; |
| import org.eclipse.ui.internal.dnd.IDragOverListener; |
| import org.eclipse.ui.internal.dnd.IDropTarget; |
| import org.eclipse.ui.internal.layout.CellData; |
| import org.eclipse.ui.internal.layout.CellLayout; |
| import org.eclipse.ui.internal.layout.IWindowTrim; |
| import org.eclipse.ui.internal.layout.LayoutUtil; |
| import org.eclipse.ui.internal.layout.Row; |
| import org.eclipse.ui.internal.util.PrefUtil; |
| import org.eclipse.ui.presentations.PresentationUtil; |
| import org.osgi.framework.Bundle; |
| |
| /** |
| * Represents the fast view bar. |
| * |
| * <p>The set of fastviews are obtained from the WorkbenchWindow that |
| * is passed into the constructor. The set of fastviews may be refreshed to |
| * match the state of the perspective by calling the update(...) method.</p> |
| * |
| * @see org.eclipse.ui.internal.FastViewPane |
| */ |
| public class FastViewBar implements IWindowTrim { |
| public static String FASTVIEWBAR_ID = "org.eclise.ui.internal.FastViewBar"; //$NON-NLS-1$ |
| |
| private ToolBarManager fastViewBar; |
| private MenuManager fastViewBarMenuManager; |
| private MenuManager showViewMenuMgr; |
| private FastViewBarContextMenuContribution contextContributionItem; |
| |
| private WorkbenchWindow window; |
| private IViewReference selection; |
| |
| // "New Fast View" 'Button' fields |
| private MenuManager newFastViewMenuMgr; |
| private Composite fvbComposite; |
| private ToolBar menuTB; |
| private ToolItem menuItem; |
| private CellData toolBarData; |
| |
| private static final int HIDDEN_WIDTH = 5; |
| |
| |
| private int oldLength = 0; |
| |
| private ViewDropTarget dropTarget; |
| |
| private Listener dragListener = new Listener() { |
| public void handleEvent(Event event) { |
| Point position = DragUtil.getEventLoc(event); |
| |
| IViewReference ref = getViewAt(position); |
| |
| if (ref == null) { |
| startDraggingFastViewBar(position, false); |
| } else { |
| startDraggingFastView(ref, position, false); |
| } |
| } |
| }; |
| |
| // Map of string view IDs onto Booleans (true iff horizontally aligned) |
| private Map viewOrientation = new HashMap(); |
| |
| private Listener addMenuListener = new Listener() { |
| public void handleEvent(Event event) { |
| Point loc = new Point(event.x, event.y); |
| if (event.type == SWT.MenuDetect) { |
| showAddFastViewPopup(loc); |
| } |
| } |
| }; |
| |
| private Listener menuListener = new Listener() { |
| public void handleEvent(Event event) { |
| Point loc = new Point(event.x, event.y); |
| if (event.type == SWT.MenuDetect) { |
| showFastViewBarPopup(loc); |
| } |
| } |
| }; |
| private int fCurrentSide = SWT.DEFAULT; |
| |
| private boolean hasNewFastViewDisabled = false; |
| |
| class ViewDropTarget extends AbstractDropTarget { |
| List panes; |
| |
| ToolItem position; |
| |
| /** |
| * @param panesToDrop the list of ViewPanes to drop at the given position |
| */ |
| public ViewDropTarget(List panesToDrop, ToolItem position) { |
| setTarget(panesToDrop, position); |
| } |
| |
| public void setTarget(List panesToDrop, ToolItem position) { |
| panes = panesToDrop; |
| this.position = position; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.dnd.IDropTarget#drop() |
| */ |
| public void drop() { |
| IViewReference view = getViewFor(position); |
| |
| Iterator iter = panes.iterator(); |
| while (iter.hasNext()) { |
| ViewPane pane = (ViewPane) iter.next(); |
| IViewReference ref = pane.getViewReference(); |
| getPerspective().getFastViewManager().addViewReference(FASTVIEWBAR_ID, getIndex(view), ref, true); |
| // getPage().addFastView(pane.getViewReference()); |
| // getPage().getActivePerspective().moveFastView( |
| // pane.getViewReference(), view); |
| } |
| update(true); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.dnd.IDropTarget#getCursor() |
| */ |
| public Cursor getCursor() { |
| return DragCursors.getCursor(DragCursors.FASTVIEW); |
| } |
| |
| public Rectangle getSnapRectangle() { |
| if (position == null) { |
| // As long as the toolbar is not empty, highlight the place |
| // where this view will appear (we |
| // may have compressed it to save space when empty, so the actual |
| // icon location may not be over the toolbar when it is empty) |
| if (getToolBar().getItemCount() > 0) { |
| return getLocationOfNextIcon(); |
| } |
| // If the toolbar is empty, highlight the entire toolbar |
| return DragUtil.getDisplayBounds(getControl()); |
| } |
| |
| return Geometry.toDisplay(getToolBar(), position.getBounds()); |
| } |
| } |
| |
| /** |
| * Constructs a new fast view bar for the given workbench window. |
| * |
| * @param theWindow |
| */ |
| public FastViewBar(WorkbenchWindow theWindow) { |
| window = theWindow; |
| |
| hasNewFastViewDisabled = PrefUtil.getAPIPreferenceStore().getBoolean( |
| IWorkbenchPreferenceConstants.DISABLE_NEW_FAST_VIEW); |
| |
| // Construct the context menu for the fast view bar area |
| fastViewBarMenuManager = new MenuManager(); |
| contextContributionItem = new FastViewBarContextMenuContribution(this); |
| fastViewBarMenuManager.add(contextContributionItem); |
| |
| if (!hasNewFastViewDisabled) { |
| // Add "New Fast View" submenu |
| showViewMenuMgr = new MenuManager(WorkbenchMessages.FastViewBar_show_view, "showView"); //$NON-NLS-1$ |
| IContributionItem showViewMenu = new ShowViewMenu(window, ShowViewMenu.class.getName(), true); |
| showViewMenuMgr.add(showViewMenu); |
| fastViewBarMenuManager.add(showViewMenuMgr); |
| |
| // Construct the context menu for the "New Fast View" 'button' |
| newFastViewMenuMgr = new MenuManager(WorkbenchMessages.FastViewBar_show_view, "showView"); //$NON-NLS-1$ |
| showViewMenu = new ShowViewMenu(window, ShowViewMenu.class.getName(), true); |
| newFastViewMenuMgr.add(showViewMenu); |
| } |
| } |
| |
| /** |
| * Returns the platform's idea of where the fast view bar should be docked in a fresh |
| * workspace. This value is meaningless after a workspace has been setup, since the |
| * fast view bar state is then persisted in the workbench. This preference is just |
| * used for applications that want the initial docking location to be somewhere other |
| * than bottom. |
| * @return the initial side to dock on |
| */ |
| public static int getInitialSide() { |
| String loc = PrefUtil.getAPIPreferenceStore().getString( |
| IWorkbenchPreferenceConstants.INITIAL_FAST_VIEW_BAR_LOCATION); |
| |
| if (IWorkbenchPreferenceConstants.BOTTOM.equals(loc)) { |
| return SWT.BOTTOM; |
| } |
| if (IWorkbenchPreferenceConstants.LEFT.equals(loc)) { |
| return SWT.LEFT; |
| } |
| if (IWorkbenchPreferenceConstants.RIGHT.equals(loc)) { |
| return SWT.RIGHT; |
| } |
| |
| Bundle bundle = Platform.getBundle(PlatformUI.PLUGIN_ID); |
| if (bundle != null) { |
| IStatus status = new Status( |
| IStatus.WARNING, |
| PlatformUI.PLUGIN_ID, |
| IStatus.WARNING, |
| "Invalid value for " //$NON-NLS-1$ |
| + PlatformUI.PLUGIN_ID |
| + "/" //$NON-NLS-1$ |
| + IWorkbenchPreferenceConstants.INITIAL_FAST_VIEW_BAR_LOCATION |
| + " preference. Value \"" + loc //$NON-NLS-1$ |
| + "\" should be one of \"" //$NON-NLS-1$ |
| + IWorkbenchPreferenceConstants.LEFT + "\", \"" //$NON-NLS-1$ |
| + IWorkbenchPreferenceConstants.BOTTOM |
| + "\", or \"" //$NON-NLS-1$ |
| + IWorkbenchPreferenceConstants.RIGHT + "\".", null); //$NON-NLS-1$ |
| Platform.getLog(bundle).log(status); |
| } |
| |
| // use bottom as the default-default |
| return SWT.BOTTOM; |
| } |
| |
| public void setOrientation(IViewReference refToSet, int newState) { |
| if (newState == getOrientation(refToSet)) { |
| return; |
| } |
| |
| viewOrientation.put(refToSet.getId(), new Integer(newState)); |
| Perspective persp = getPerspective(); |
| |
| if (persp != null) { |
| IViewReference ref = persp.getActiveFastView(); |
| if (ref != null) { |
| persp.setActiveFastView(null); |
| } |
| persp.setActiveFastView(refToSet); |
| } |
| } |
| |
| /** |
| * Returns the active workbench page or null if none |
| */ |
| private WorkbenchPage getPage() { |
| if (window == null) { |
| return null; |
| } |
| |
| return window.getActiveWorkbenchPage(); |
| } |
| |
| /** |
| * Returns the current perspective or null if none |
| */ |
| private Perspective getPerspective() { |
| |
| WorkbenchPage page = getPage(); |
| |
| if (page == null) { |
| return null; |
| } |
| |
| return page.getActivePerspective(); |
| } |
| |
| /** |
| * Creates the underlying SWT fvbComposite for the fast view bar. Will add exactly |
| * one new fvbComposite to the given composite. Makes no assumptions about the layout |
| * being used in the parent composite. |
| * |
| * @param parent enclosing SWT composite |
| */ |
| public void createControl(Composite parent) { |
| fvbComposite = new Composite(parent, SWT.NONE) { |
| public Point computeSize(int wHint, int hHint, boolean changed) { |
| Point size = super.computeSize(wHint, hHint, changed); |
| if (Geometry.isHorizontal(getSide())) { |
| if (size.y < TrimUtil.TRIM_DEFAULT_HEIGHT) { |
| size.y = TrimUtil.TRIM_DEFAULT_HEIGHT; |
| } |
| } else { |
| if (size.x < TrimUtil.TRIM_DEFAULT_HEIGHT) { |
| size.x = TrimUtil.TRIM_DEFAULT_HEIGHT; |
| } |
| } |
| return size; |
| }}; |
| String tip = WorkbenchMessages.FastViewBar_0; |
| fvbComposite.setToolTipText(tip); |
| |
| fvbComposite.addListener(SWT.MenuDetect, menuListener); |
| PresentationUtil.addDragListener(fvbComposite, dragListener); |
| |
| createChildControls(); |
| } |
| |
| /** |
| * Create the contents of the fast view bar. The top-level fvbComposite (created by createControl) is a |
| * composite that is created once over the lifetime of the fast view bar. This method creates the |
| * rest of the widgetry inside that composite. The controls created by this method will be |
| * destroyed and recreated if the fast view bar is docked to a different side of the window. |
| */ |
| protected void createChildControls() { |
| int newSide = getSide(); |
| int orientation = Geometry.isHorizontal(newSide) ? SWT.HORIZONTAL |
| : SWT.VERTICAL; |
| |
| // Create a ControlLayout apropriate for the new orientation |
| CellLayout controlLayout; |
| if (Geometry.isHorizontal(newSide)) { |
| controlLayout = new CellLayout(0) |
| .setMargins(0, 0) |
| .setDefaultRow(Row.growing()) |
| .setDefaultColumn(Row.fixed()) |
| .setColumn(1, Row.growing()); |
| } else { |
| controlLayout = new CellLayout(1) |
| .setMargins(0, 3) |
| .setDefaultColumn(Row.growing()) |
| .setDefaultRow(Row.fixed()) |
| .setRow(1, Row.growing()); |
| } |
| |
| // Set up the composite for the new orientation |
| fvbComposite.setLayout(controlLayout); |
| |
| if (!hasNewFastViewDisabled) { |
| // Create a toolbar to show an 'Add FastView' menu 'button' |
| menuTB = new ToolBar(fvbComposite, SWT.FLAT | orientation); |
| |
| // Construct an item to act as a 'menu button' (a la the PerspectiveSwitcher) |
| menuItem = new ToolItem(menuTB, SWT.PUSH, 0); |
| |
| Image tbImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_ETOOL_NEW_FASTVIEW); |
| menuItem.setImage(tbImage); |
| |
| final String menuTip = WorkbenchMessages.FastViewBar_0; |
| menuItem.setToolTipText(menuTip); |
| //new ToolItem(menuTB, SWT.SEPARATOR, 1); |
| |
| menuTB.getAccessible().addAccessibleListener(new AccessibleAdapter() { |
| public void getName(AccessibleEvent e) { |
| e.result = menuTip; |
| } |
| }); |
| |
| // Now that the ToolBar is populated calculate its size... |
| Point size = menuTB.computeSize(SWT.DEFAULT, SWT.DEFAULT, true); |
| menuTB.setBounds(0, 0, size.x, size.y); |
| |
| // Bring up the 'Add Fast View' menu on a left -or- right button click |
| // Right click (context menu) |
| menuItem.addListener(SWT.MenuDetect, addMenuListener); |
| menuTB.addListener(SWT.MenuDetect, addMenuListener); |
| |
| // Left Click... |
| menuItem.addSelectionListener(new SelectionListener() { |
| public void widgetSelected(SelectionEvent e) { |
| Rectangle bb = DragUtil.getDisplayBounds(menuTB); |
| showAddFastViewPopup(new Point(bb.x,bb.y+bb.height)); |
| } |
| |
| public void widgetDefaultSelected(SelectionEvent e) { |
| } |
| |
| }); |
| |
| // try to get the layout correct... |
| toolBarData = new CellData(); |
| toolBarData.align(SWT.FILL, SWT.FILL); |
| menuTB.setLayoutData(toolBarData); |
| } |
| |
| // Construct the ToolBar containing the 'Fast' views |
| fastViewBar = new ToolBarManager(SWT.FLAT | SWT.WRAP | orientation); |
| fastViewBar.add(new ShowFastViewContribution(window)); |
| |
| fastViewBar.createControl(fvbComposite); |
| |
| getToolBar().addListener(SWT.MenuDetect, menuListener); |
| |
| IDragOverListener fastViewDragTarget = new IDragOverListener() { |
| |
| public IDropTarget drag(Control currentControl, |
| Object draggedObject, Point position, |
| Rectangle dragRectangle) { |
| ToolItem targetItem = getToolItem(position); |
| if (draggedObject instanceof ViewPane) { |
| ViewPane pane = (ViewPane) draggedObject; |
| |
| // Can't drag views between windows |
| if (pane.getWorkbenchWindow() != window) { |
| return null; |
| } |
| |
| List newList = new ArrayList(1); |
| newList.add(draggedObject); |
| |
| return createDropTarget(newList, targetItem); |
| } |
| if (draggedObject instanceof ViewStack) { |
| ViewStack folder = (ViewStack) draggedObject; |
| |
| if (folder.getWorkbenchWindow() != window) { |
| return null; |
| } |
| |
| List viewList = new ArrayList(folder.getItemCount()); |
| LayoutPart[] children = folder.getChildren(); |
| |
| for (int idx = 0; idx < children.length; idx++) { |
| if (!(children[idx] instanceof PartPlaceholder)) { |
| viewList.add(children[idx]); |
| } |
| } |
| |
| return createDropTarget(viewList, targetItem); |
| } |
| |
| return null; |
| } |
| |
| }; |
| |
| toolBarData = new CellData(); |
| toolBarData.align(SWT.FILL, SWT.FILL); |
| |
| getToolBar().setLayoutData(toolBarData); |
| PresentationUtil.addDragListener(getToolBar(), dragListener); |
| DragUtil.addDragTarget(getControl(), fastViewDragTarget); |
| |
| update(true); |
| } |
| |
| /** |
| * Creates and returns a drop target with the given properties. To save object allocation, |
| * the same instance is saved and reused wherever possible. |
| * |
| * @param targetItem |
| * @param viewList |
| * @since 3.1 |
| */ |
| private IDropTarget createDropTarget(List viewList, ToolItem targetItem) { |
| if (dropTarget == null) { |
| dropTarget = new ViewDropTarget(viewList, targetItem); |
| } else { |
| dropTarget.setTarget(viewList, targetItem); |
| } |
| return dropTarget; |
| } |
| |
| /** |
| * Begins dragging a particular fast view |
| * |
| * @param ref |
| * @param position |
| */ |
| protected void startDraggingFastView(IViewReference ref, Point position, |
| boolean usingKeyboard) { |
| ViewPane pane = (ViewPane) ((WorkbenchPartReference) ref).getPane(); |
| |
| ToolItem item = itemFor(pane.getViewReference()); |
| |
| Rectangle dragRect = Geometry.toDisplay(getToolBar(), item.getBounds()); |
| |
| startDrag(((WorkbenchPartReference) ref).getPane(), dragRect, position, |
| usingKeyboard); |
| } |
| |
| private void startDrag(Object toDrag, Rectangle dragRect, Point position, |
| boolean usingKeyboard) { |
| |
| Perspective persp = getPerspective(); |
| |
| WorkbenchPage page = getPage(); |
| |
| IViewReference oldFastView = null; |
| if (persp != null) { |
| oldFastView = persp.getActiveFastView(); |
| |
| if (page != null) { |
| page.hideFastView(); |
| } |
| } |
| |
| if (page.isZoomed()) { |
| page.zoomOut(); |
| } |
| |
| boolean success = DragUtil.performDrag(toDrag, dragRect, position, |
| !usingKeyboard); |
| |
| // If the drag was cancelled, reopen the old fast view |
| if (!success && oldFastView != null && page != null) { |
| page.toggleFastView(oldFastView); |
| } |
| } |
| |
| /** |
| * Begins dragging the fast view bar |
| * |
| * @param position initial mouse position |
| * @param usingKeyboard true iff the bar is being dragged using the keyboard |
| */ |
| protected void startDraggingFastViewBar(Point position, |
| boolean usingKeyboard) { |
| Rectangle dragRect = DragUtil.getDisplayBounds(fvbComposite); |
| |
| startDrag(this, dragRect, position, usingKeyboard); |
| } |
| |
| /** |
| * Returns the toolbar for the fastview bar. |
| */ |
| private ToolBar getToolBar() { |
| return fastViewBar.getControl(); |
| } |
| |
| private IViewReference getViewFor(ToolItem item) { |
| if (item == null) { |
| return null; |
| } |
| |
| return (IViewReference) item |
| .getData(ShowFastViewContribution.FAST_VIEW); |
| } |
| |
| /** |
| * Returns the view at the given position, or null if none |
| * |
| * @param position to test, in display coordinates |
| * @return the view at the given position or null if none |
| */ |
| private IViewReference getViewAt(Point position) { |
| return getViewFor(getToolItem(position)); |
| } |
| |
| /** |
| * Returns the toolbar item at the given position, in display coordinates |
| * @param position |
| */ |
| private ToolItem getToolItem(Point position) { |
| ToolBar toolbar = getToolBar(); |
| Point local = toolbar.toControl(position); |
| return toolbar.getItem(local); |
| } |
| |
| /** |
| * Shows the popup menu for an item in the fast view bar. |
| */ |
| private void showFastViewBarPopup(Point pt) { |
| // Get the tool item under the mouse. |
| |
| ToolBar toolBar = getToolBar(); |
| |
| Menu menu = fastViewBarMenuManager.createContextMenu(toolBar); |
| |
| IViewReference selectedView = getViewAt(pt); |
| contextContributionItem.setTarget(selectedView); |
| |
| menu.setLocation(pt.x, pt.y); |
| menu.setVisible(true); |
| } |
| |
| /** |
| * Shows the popup menu for an item in the fast view bar. |
| */ |
| private void showAddFastViewPopup(Point pt) { |
| Menu menu = newFastViewMenuMgr.createContextMenu(menuTB); |
| menu.setLocation(pt.x, pt.y); |
| menu.setVisible(true); |
| } |
| |
| public int getOrientation(IViewReference ref) { |
| return isHorizontal(ref) ? SWT.HORIZONTAL : SWT.VERTICAL; |
| } |
| |
| /** |
| * Returns the underlying SWT fvbComposite for the fast view bar, or null if |
| * createControl has not yet been invoked. The caller must not make any |
| * assumptions about the type of Control that is returned. |
| * |
| * @return the underlying SWT fvbComposite for the fast view bar |
| */ |
| public Control getControl() { |
| return fvbComposite; |
| } |
| |
| public void dispose() { |
| fastViewBarMenuManager.dispose(); |
| |
| disposeChildControls(); |
| } |
| |
| protected void disposeChildControls() { |
| fastViewBar.dispose(); |
| fastViewBar = null; |
| |
| if (menuItem != null) { |
| menuItem.dispose(); |
| menuTB.dispose(); |
| } |
| |
| oldLength = 0; |
| } |
| |
| |
| /** |
| * Refreshes the contents to match the fast views in the window's |
| * current perspective. |
| * |
| * @param force |
| */ |
| public void update(boolean force) { |
| fastViewBar.update(force); |
| ToolItem[] items = fastViewBar.getControl().getItems(); |
| |
| updateLayoutData(); |
| |
| for (int idx = 0; idx < items.length; idx++) { |
| IViewReference view = getViewFor(items[idx]); |
| |
| viewOrientation.put(view.getId(), new Integer( |
| isHorizontal(view) ? SWT.HORIZONTAL : SWT.VERTICAL)); |
| } |
| |
| // Resize the FVB to its new size |
| fvbComposite.setSize(fvbComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT)); |
| } |
| |
| private void updateLayoutData() { |
| ToolItem[] items = fastViewBar.getControl().getItems(); |
| boolean isHorizontal = Geometry.isHorizontal(getSide()); |
| boolean shouldExpand = items.length > 0; |
| |
| Point hint = new Point(32, shouldExpand ? SWT.DEFAULT : HIDDEN_WIDTH); |
| |
| if (!isHorizontal) { |
| Geometry.flipXY(hint); |
| } |
| |
| if (shouldExpand) { |
| toolBarData.setHint(CellData.MINIMUM, hint); |
| } else { |
| toolBarData.setHint(CellData.OVERRIDE, hint); |
| } |
| |
| if (items.length != oldLength) { |
| LayoutUtil.resize(fvbComposite); |
| oldLength = items.length; |
| } |
| } |
| |
| /** |
| * Returns the currently selected fastview |
| * |
| * @return the currently selected fastview or null if none |
| */ |
| public IViewReference getSelection() { |
| return selection; |
| } |
| |
| /** |
| * Sets the currently selected fastview. |
| * |
| * @param selected the currently selected fastview, or null if none |
| */ |
| public void setSelection(IViewReference selected) { |
| |
| ToolItem[] items = fastViewBar.getControl().getItems(); |
| for (int i = 0; i < items.length; i++) { |
| ToolItem item = items[i]; |
| item.setSelection(getView(item) == selected); |
| } |
| |
| selection = selected; |
| } |
| |
| /** |
| * Returns the view associated with the given toolbar item |
| * |
| * @param item |
| */ |
| private IViewReference getView(ToolItem item) { |
| return (IViewReference) item |
| .getData(ShowFastViewContribution.FAST_VIEW); |
| } |
| |
| private int getIndex(IViewReference toFind) { |
| ToolItem[] items = fastViewBar.getControl().getItems(); |
| for (int i = 0; i < items.length; i++) { |
| if (items[i].getData(ShowFastViewContribution.FAST_VIEW) == toFind) { |
| return i; |
| } |
| } |
| |
| return items.length; |
| } |
| |
| private ToolItem getItem(int idx) { |
| ToolItem[] items = fastViewBar.getControl().getItems(); |
| if (idx >= items.length) { |
| return null; |
| } |
| |
| return items[idx]; |
| } |
| |
| /** |
| * Returns the toolbar item associated with the given view |
| * |
| * @param toFind |
| */ |
| private ToolItem itemFor(IViewReference toFind) { |
| return getItem(getIndex(toFind)); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.IWindowTrim#getValidSides() |
| */ |
| public int getValidSides() { |
| return SWT.TOP | SWT.LEFT | SWT.RIGHT | SWT.BOTTOM; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.IWindowTrim#docked(int) |
| */ |
| public void dock(int side) { |
| fCurrentSide = side; |
| disposeChildControls(); |
| createChildControls(); |
| } |
| |
| /** |
| * Get the current side. |
| * @return SWT.BOTTOM or SWT.RIGHT or SWT.LEFT |
| */ |
| public int getSide() { |
| if (fCurrentSide==SWT.DEFAULT) { |
| fCurrentSide = getInitialSide(); |
| } |
| return fCurrentSide; |
| } |
| |
| |
| private boolean isHorizontal(IViewReference ref) { |
| Integer orientation = (Integer) viewOrientation.get(ref.getId()); |
| boolean horizontalBar = Geometry.isHorizontal(getSide()); |
| boolean horizontal = horizontalBar; |
| if (orientation != null) { |
| horizontal = orientation.intValue() == SWT.HORIZONTAL; |
| } else { |
| horizontal = false; |
| } |
| |
| return horizontal; |
| } |
| |
| /** |
| * @param ref |
| */ |
| public int getViewSide(IViewReference ref) { |
| boolean horizontal = isHorizontal(ref); |
| |
| if (horizontal) { |
| return (getSide() == SWT.BOTTOM) ? SWT.BOTTOM : SWT.TOP; |
| } |
| |
| return (getSide() == SWT.RIGHT) ? SWT.RIGHT : SWT.LEFT; |
| } |
| |
| public void saveState(IMemento memento) { |
| memento.putInteger(IWorkbenchConstants.TAG_FAST_VIEW_SIDE, getSide()); |
| |
| Iterator iter = viewOrientation.keySet().iterator(); |
| while (iter.hasNext()) { |
| String next = (String) iter.next(); |
| IMemento orientation = memento |
| .createChild(IWorkbenchConstants.TAG_FAST_VIEW_ORIENTATION); |
| |
| orientation.putString(IWorkbenchConstants.TAG_VIEW, next); |
| orientation.putInteger(IWorkbenchConstants.TAG_POSITION, |
| ((Integer) viewOrientation.get(next)).intValue()); |
| } |
| |
| } |
| |
| /** |
| * Returns the approximate location where the next fastview icon |
| * will be drawn (display coordinates) |
| */ |
| public Rectangle getLocationOfNextIcon() { |
| ToolBar control = getToolBar(); |
| |
| Rectangle result = control.getBounds(); |
| Point size = control.computeSize(SWT.DEFAULT, SWT.DEFAULT, false); |
| result.height = size.y; |
| result.width = size.x; |
| |
| boolean horizontal = Geometry.isHorizontal(getSide()); |
| if (control.getItemCount() == 0) { |
| Geometry.setDimension(result, horizontal, 0); |
| } |
| |
| int hoverSide = horizontal ? SWT.RIGHT : SWT.BOTTOM; |
| |
| result = Geometry.getExtrudedEdge(result, -Geometry.getDimension( |
| result, !horizontal), hoverSide); |
| |
| return Geometry.toDisplay(control.getParent(), result); |
| } |
| |
| public void restoreState(IMemento memento) { |
| Integer bigInt; |
| bigInt = memento.getInteger(IWorkbenchConstants.TAG_FAST_VIEW_SIDE); |
| if (bigInt != null) { |
| dock(bigInt.intValue()); |
| } |
| |
| IMemento[] orientations = memento |
| .getChildren(IWorkbenchConstants.TAG_FAST_VIEW_ORIENTATION); |
| for (int i = 0; i < orientations.length; i++) { |
| IMemento next = orientations[i]; |
| |
| viewOrientation.put(next.getString(IWorkbenchConstants.TAG_VIEW), |
| next.getInteger(IWorkbenchConstants.TAG_POSITION)); |
| } |
| } |
| |
| public WorkbenchWindow getWindow() { |
| return window; |
| } |
| |
| public void restoreView(IViewReference selectedView) { |
| if (selectedView != null) { |
| WorkbenchPage page = window.getActiveWorkbenchPage(); |
| if (page != null) { |
| int idx = getIndex(selectedView); |
| ToolItem item = getItem(idx); |
| Rectangle bounds = item.getBounds(); |
| Rectangle startBounds = Geometry.toDisplay(item |
| .getParent(), bounds); |
| |
| Perspective persp = getPerspective(); |
| if (persp != null) { |
| persp.getFastViewManager().removeViewReference(selectedView, true, true); |
| } |
| |
| IWorkbenchPart toActivate = selectedView |
| .getPart(true); |
| if (toActivate != null) { |
| page.activate(toActivate); |
| } |
| |
| ViewPane pane = (ViewPane) ((WorkbenchPartReference) selectedView) |
| .getPane(); |
| |
| RectangleAnimation animation = new RectangleAnimation( |
| window.getShell(), startBounds, pane |
| .getParentBounds()); |
| |
| animation.schedule(); |
| } |
| } |
| } |
| |
| /** |
| * @return The list of all view references in the stack |
| */ |
| public List getViewRefs() { |
| List refs = new ArrayList(fastViewBar.getControl().getItemCount()); |
| ToolItem[] items = fastViewBar.getControl().getItems(); |
| for (int i = 0; i < items.length; i++) { |
| Object data = items[i].getData(ShowFastViewContribution.FAST_VIEW); |
| if (data != null) |
| refs.add(data); |
| } |
| |
| return refs; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.IWindowTrim#isCloseable() |
| */ |
| public boolean isCloseable() { |
| return false; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.IWindowTrim#handleClose() |
| */ |
| public void handleClose() { |
| // nothing to do... |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.IWindowTrim#getId() |
| */ |
| public String getId() { |
| return "org.eclise.ui.internal.FastViewBar"; //$NON-NLS-1$ |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.IWindowTrim#getDisplayName() |
| */ |
| public String getDisplayName() { |
| return WorkbenchMessages.TrimCommon_FastView_TrimName; |
| } |
| |
| /** |
| * Returns the context menu contribution item. This is for |
| * internal UI testing only. |
| * |
| * @return the context menu contribution item |
| * @since 3.1.1 |
| */ |
| public FastViewBarContextMenuContribution testContextMenu() { |
| return contextContributionItem; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IWindowTrim#getWidthHint() |
| */ |
| public int getWidthHint() { |
| return SWT.DEFAULT; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IWindowTrim#getHeightHint() |
| */ |
| public int getHeightHint() { |
| return SWT.DEFAULT; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.IWindowTrim#isResizeable() |
| */ |
| public boolean isResizeable() { |
| return false; |
| } |
| } |
