| /******************************************************************************* |
| * Copyright (c) 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 |
| ******************************************************************************/ |
| |
| package org.eclipse.ui.internal; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.jface.action.ToolBarManager; |
| import org.eclipse.jface.util.Geometry; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.DisposeEvent; |
| import org.eclipse.swt.events.DisposeListener; |
| import org.eclipse.swt.graphics.Cursor; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.ToolBar; |
| import org.eclipse.swt.widgets.ToolItem; |
| import org.eclipse.ui.IViewReference; |
| 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.presentations.PresentationUtil; |
| |
| /** |
| * @since 3.3 |
| * |
| */ |
| public class FastViewDnDHandler implements IDragOverListener { |
| private String id; |
| private ToolBarManager tbm; |
| private WorkbenchWindow wbw; |
| private ViewDropTarget dropTarget = null; |
| |
| private Listener dragListener = new Listener() { |
| public void handleEvent(Event event) { |
| Point position = DragUtil.getEventLoc(event); |
| |
| ToolBar toolbar = tbm.getControl(); |
| Point local = toolbar.toControl(position); |
| ToolItem item = toolbar.getItem(local); |
| IViewReference ref = (IViewReference) item |
| .getData(ShowFastViewContribution.FAST_VIEW); |
| |
| if (ref != null) { |
| startDraggingFastView(ref, position, false); |
| } |
| } |
| }; |
| |
| class ViewDropTarget extends AbstractDropTarget { |
| List panes; |
| ToolItem curItem; |
| |
| /** |
| * @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.curItem = position; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.dnd.IDropTarget#drop() |
| */ |
| public void drop() { |
| Perspective persp = wbw.getActiveWorkbenchPage().getActivePerspective(); |
| FastViewManager fvm = persp.getFastViewManager(); |
| |
| int insertIndex = tbm.getControl().indexOf(curItem); |
| Iterator iter = panes.iterator(); |
| while (iter.hasNext()) { |
| ViewPane pane = (ViewPane) iter.next(); |
| IViewReference ref = pane.getViewReference(); |
| adoptRef(ref); |
| fvm.addViewReference(id, insertIndex++, ref, !iter.hasNext()); |
| } |
| } |
| |
| private void adoptRef(IViewReference ref) { |
| Perspective persp = wbw.getActiveWorkbenchPage() |
| .getActivePerspective(); |
| PerspectiveHelper helper = persp.getPresentation(); |
| ContainerPlaceholder ourContainerPlaceholder = (ContainerPlaceholder) helper |
| .findPart(id, null); |
| LayoutPart refPart = helper.findPart(ref.getId(), ref |
| .getSecondaryId()); |
| ILayoutContainer refContainer = refPart.container; |
| if (refContainer != ourContainerPlaceholder) { |
| // remove the old part... if it's represented by a |
| // placeholder then just remove it... |
| if (refPart instanceof PartPlaceholder) { |
| if (refContainer instanceof ContainerPlaceholder) { |
| // just remove the placeholder |
| ViewStack realContainer = (ViewStack) ((ContainerPlaceholder) refContainer) |
| .getRealContainer(); |
| realContainer.remove(refPart); |
| } |
| else if (refContainer instanceof ViewStack) { |
| refContainer.remove(refPart); |
| } |
| } |
| else { |
| // If its a real view ref then defref it... |
| helper.derefPart(refPart); |
| } |
| PartPlaceholder newPlaceholder = new PartPlaceholder(ref |
| .getId()); |
| ourContainerPlaceholder.add(newPlaceholder); |
| } |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.ui.internal.dnd.IDropTarget#getCursor() |
| */ |
| public Cursor getCursor() { |
| return DragCursors.getCursor(DragCursors.FASTVIEW); |
| } |
| |
| public Rectangle getSnapRectangle() { |
| if (curItem == 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 (tbm.getControl().getItemCount() > 0) { |
| return getLocationOfNextIcon(); |
| } |
| // If the toolbar is empty, highlight the entire toolbar |
| return DragUtil.getDisplayBounds(tbm.getControl()); |
| } |
| |
| return Geometry.toDisplay(tbm.getControl(), curItem.getBounds()); |
| } |
| } |
| |
| /** |
| * |
| */ |
| public FastViewDnDHandler(String id, final ToolBarManager tbm, WorkbenchWindow wbw) { |
| this.id = id; |
| this.tbm = tbm; |
| this.wbw = wbw; |
| |
| // Hook the 'drop' listener to the control |
| DragUtil.addDragTarget(tbm.getControl(), this); |
| PresentationUtil.addDragListener(tbm.getControl(), dragListener); |
| |
| // Clean up on dispose |
| tbm.getControl().addDisposeListener(new DisposeListener() { |
| public void widgetDisposed(DisposeEvent e) { |
| DragUtil.removeDragTarget((Control)(e.widget), FastViewDnDHandler.this); |
| PresentationUtil.removeDragListener(tbm.getControl(), dragListener); |
| } |
| }); |
| } |
| |
| /** |
| * Returns the toolbar item at the given position, in display coordinates |
| * @param position |
| */ |
| private ToolItem getToolItem(Point position) { |
| ToolBar toolbar = tbm.getControl(); |
| Point local = toolbar.toControl(position); |
| return toolbar.getItem(local); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.dnd.IDragOverListener#drag(org.eclipse.swt.widgets.Control, java.lang.Object, org.eclipse.swt.graphics.Point, org.eclipse.swt.graphics.Rectangle) |
| */ |
| public IDropTarget drag(Control currentControl, Object draggedObject, |
| Point position, Rectangle dragRectangle) { |
| // If we're trying to drop onto a 'standalone' stack, don't... |
| if (isStandaloneStack()) |
| return null; |
| |
| ToolItem targetItem = getToolItem(position); |
| if (draggedObject instanceof ViewPane) { |
| ViewPane pane = (ViewPane) draggedObject; |
| |
| // Can't drag views between windows |
| if (pane.getWorkbenchWindow() != wbw) { |
| 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() != wbw) { |
| 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; |
| } |
| /** |
| * Tests the view references associated with the stack and |
| * returns <code>true</code> if any view is a stand-alone view |
| * |
| * @return <code>true</code> is any view is stand-alone |
| */ |
| private boolean isStandaloneStack() { |
| Perspective persp = wbw.getActiveWorkbenchPage().getActivePerspective(); |
| List fvs = persp.getFastViewManager().getFastViews(id); |
| for (Iterator iterator = fvs.iterator(); iterator.hasNext();) { |
| IViewReference ref = (IViewReference) iterator.next(); |
| if (persp.isStandaloneView(ref)) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| private IDropTarget createDropTarget(List viewList, ToolItem targetItem) { |
| if (dropTarget == null) { |
| dropTarget = new ViewDropTarget(viewList, targetItem); |
| } else { |
| dropTarget.setTarget(viewList, targetItem); |
| } |
| return dropTarget; |
| } |
| |
| /** |
| * Returns the approximate location where the next fastview icon |
| * will be drawn (display coordinates) |
| */ |
| public Rectangle getLocationOfNextIcon() { |
| ToolBar control = tbm.getControl(); |
| |
| Rectangle result = control.getBounds(); |
| Point size = control.computeSize(SWT.DEFAULT, SWT.DEFAULT, false); |
| result.height = size.y; |
| result.width = size.x; |
| |
| boolean horizontal = (control.getStyle() & SWT.VERTICAL) == 0; |
| 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); |
| } |
| |
| /** |
| * Returns the index of the ToolItem fronting the view ref |
| * @param toFind the view reference to find the index of |
| * @return the index or -1 if not found |
| */ |
| private int getIndex(IViewReference toFind) { |
| ToolItem[] items = tbm.getControl().getItems(); |
| for (int i = 0; i < items.length; i++) { |
| if (items[i].getData(ShowFastViewContribution.FAST_VIEW) == toFind) { |
| return i; |
| } |
| } |
| |
| return -1; |
| } |
| |
| /** |
| * Begins dragging a particular fast view |
| * |
| * @param ref |
| * @param position |
| */ |
| protected void startDraggingFastView(IViewReference ref, Point position, |
| boolean usingKeyboard) { |
| int index = getIndex(ref); |
| if (index == -1) |
| return; |
| |
| ToolItem item = tbm.getControl().getItem(index); |
| Rectangle dragRect = Geometry.toDisplay(tbm.getControl(), item.getBounds()); |
| startDrag(((WorkbenchPartReference) ref).getPane(), dragRect, position, |
| usingKeyboard); |
| } |
| |
| private void startDrag(Object toDrag, Rectangle dragRect, Point position, |
| boolean usingKeyboard) { |
| WorkbenchPage page = wbw.getActiveWorkbenchPage(); |
| Perspective persp = page.getActivePerspective(); |
| |
| // Prevent dragging non-movable refs out of a minimized stack |
| if (toDrag instanceof ViewPane) { |
| ViewPane pane = (ViewPane) toDrag; |
| if (!persp.isMoveable(pane.getViewReference())) |
| return; |
| } |
| |
| IViewReference oldFastView = null; |
| if (persp != null) { |
| oldFastView = persp.getActiveFastView(); |
| |
| if (page != null) { |
| page.hideFastView(); |
| } |
| } |
| |
| if (page.isPageZoomed()) { |
| 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); |
| } |
| } |
| } |
