| /******************************************************************************* |
| * 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 |
| *******************************************************************************/ |
| package org.eclipse.ui.internal; |
| |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.jface.util.Geometry; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Cursor; |
| 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.ui.internal.dnd.DragBorder; |
| 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.dnd.IDropTarget2; |
| import org.eclipse.ui.internal.layout.IWindowTrim; |
| import org.eclipse.ui.internal.layout.LayoutUtil; |
| import org.eclipse.ui.internal.layout.TrimDescriptor; |
| import org.eclipse.ui.internal.layout.TrimLayout; |
| import org.eclipse.ui.internal.layout.TrimToolBarBase; |
| |
| /** |
| */ |
| /*package*/class TrimDropTarget implements IDragOverListener { |
| |
| private final class ActualTrimDropTarget implements IDropTarget2 { |
| public IWindowTrim draggedTrim; |
| |
| // tracking parameters |
| private DragBorder border = null; |
| private int dockedArea; |
| |
| // Holder for the position of trim that is 'floating' with the cursor |
| private int cursorAreaId; |
| private int initialAreaId; |
| private IWindowTrim initialInsertBefore; |
| private Rectangle initialLocation; |
| |
| /** |
| * Constructor |
| */ |
| private ActualTrimDropTarget() { |
| super(); |
| |
| draggedTrim = null; |
| dockedArea = SWT.NONE; |
| |
| initialAreaId = SWT.NONE; |
| initialInsertBefore = null; |
| } |
| |
| /** |
| * This method is used to delineate separate trims dragging events. The -first- drag |
| * event will set this and then it will remain constant until the drag gesture is done; |
| * either by dropping or escaping. Once the gesture is finished the trim value is set |
| * back to 'null'. |
| * |
| * @param trim The trim item currently being dragged. |
| */ |
| public void startDrag(IWindowTrim trim) { |
| // Are we starting a new drag? |
| if (draggedTrim != trim) { |
| // remember the dragged trim |
| draggedTrim = trim; |
| |
| // Remember the location that we were in initially so we |
| // can go back there on an cancel... |
| initialAreaId = layout.getTrimAreaId(draggedTrim.getControl()); |
| |
| // Determine who we were placed 'before' in the trim |
| initialInsertBefore = getInsertBefore(initialAreaId, draggedTrim); |
| |
| // Remember the location that the control used to be at for animation purposes |
| initialLocation = DragUtil.getDisplayBounds(draggedTrim.getControl()); |
| |
| // The dragged trim is always initially docked |
| dockedArea = initialAreaId; |
| } |
| } |
| |
| /** |
| * Determine the trim area from the point. To avoid clashing at the 'corners' due to extending the trim area's |
| * rectangles we first ensure that the point is not actually -within- a trim area before we check the extended |
| * rectangles. |
| * |
| * @param pos The current cursor pos |
| * @return the Trim area that the cursor is in or SWT.NONE if the point is not in an area |
| */ |
| private int getTrimArea(Point pos) { |
| // First, check if we're actually -within- a trim area (i.e. no boundary extensions) |
| int areaId = getTrimArea(pos, 0); |
| |
| // If we are not inside a trim area...are we 'close' to one? |
| if (areaId == SWT.NONE) { |
| areaId = getTrimArea(pos, TrimDragPreferences.getThreshold()); |
| } |
| |
| // not inside any trim area |
| return areaId; |
| } |
| |
| /** |
| * Checks the trims areas against the given position. Each trim area is 'extended' into |
| * the workbench page by the value of <code>extendedBoundaryWidth</code> before the checking |
| * takes place. |
| * |
| * @param pos The point to check against |
| * @param extendedBoundaryWidth The amount to extend the trim area's 'inner' edge by |
| * |
| * @return The trim area or SWT.NONE if the point is not within any extended trim area's rect. |
| */ |
| private int getTrimArea(Point pos, int extendedBoundaryWidth) { |
| int[] areaIds = layout.getAreaIds(); |
| for (int i = 0; i < areaIds.length; i++) { |
| Rectangle trimRect = layout.getTrimRect(windowComposite, areaIds[i]); |
| trimRect = Geometry.toControl(windowComposite, trimRect); |
| |
| // Only check 'valid' sides |
| if ( (areaIds[i] & getValidSides()) != SWT.NONE) { |
| // TODO: more confusion binding 'areaIds' to SWT 'sides' |
| switch (areaIds[i]) { |
| case SWT.LEFT: |
| trimRect.width += extendedBoundaryWidth; |
| |
| if (pos.y >= trimRect.y && |
| pos.y <= (trimRect.y+trimRect.height) && |
| pos.x <= (trimRect.x+trimRect.width)) { |
| return areaIds[i]; |
| } |
| break; |
| case SWT.RIGHT: |
| trimRect.x -= extendedBoundaryWidth; |
| trimRect.width += extendedBoundaryWidth; |
| |
| if (pos.y >= trimRect.y && |
| pos.y <= (trimRect.y+trimRect.height) && |
| pos.x >= trimRect.x) { |
| return areaIds[i]; |
| } |
| break; |
| case SWT.TOP: |
| trimRect.height += extendedBoundaryWidth; |
| |
| if (pos.x >= trimRect.x && |
| pos.x <= (trimRect.x+trimRect.width) && |
| pos.y <= (trimRect.y+trimRect.height)) { |
| return areaIds[i]; |
| } |
| break; |
| case SWT.BOTTOM: |
| trimRect.y -= extendedBoundaryWidth; |
| trimRect.height += extendedBoundaryWidth; |
| |
| if (pos.x >= trimRect.x && |
| pos.x <= (trimRect.x+trimRect.width) && |
| pos.y >= trimRect.y) { |
| return areaIds[i]; |
| } |
| break; |
| } |
| } |
| } |
| |
| // not inside any trim area |
| return SWT.NONE; |
| } |
| |
| /** |
| * Determine the window trim that the currently dragged trim should be inserted |
| * before. |
| * @param areaId The area id that is being checked |
| * @param pos The position used to determine the correct insertion trim |
| * @return The trim to 'dock' the draggedTrim before |
| */ |
| private IWindowTrim getInsertBefore(int areaId, Point pos) { |
| boolean isHorizontal = (areaId == SWT.TOP) || (areaId == SWT.BOTTOM); |
| |
| // Walk the trim area and return the first one that the positon |
| // is 'after'. |
| List tDescs = layout.getTrimArea(areaId).getDescriptors(); |
| for (Iterator iter = tDescs.iterator(); iter.hasNext();) { |
| TrimDescriptor desc = (TrimDescriptor) iter.next(); |
| |
| // Skip ourselves |
| if (desc.getTrim() == draggedTrim) { |
| continue; |
| } |
| |
| // Now, check |
| Rectangle bb = desc.getCache().getControl().getBounds(); |
| Point center = Geometry.centerPoint(bb); |
| if (isHorizontal) { |
| if (pos.x < center.x) { |
| return desc.getTrim(); |
| } |
| } |
| else { |
| if (pos.y < center.y) { |
| return desc.getTrim(); |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Returns the trim that is 'before' the given trim in the given area |
| * |
| * @param areaId The areaId of the trim |
| * @param trim The trim to find the element after |
| * |
| * @return The trim that the given trim is 'before' |
| */ |
| private IWindowTrim getInsertBefore(int areaId, IWindowTrim trim) { |
| List tDescs = layout.getTrimArea(areaId).getDescriptors(); |
| for (Iterator iter = tDescs.iterator(); iter.hasNext();) { |
| TrimDescriptor desc = (TrimDescriptor) iter.next(); |
| if (desc.getTrim() == trim) { |
| if (iter.hasNext()) { |
| desc = (TrimDescriptor) iter.next(); |
| return desc.getTrim(); |
| } |
| return null; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Recalculates the drop information based on the current cursor pos. |
| * |
| * @param pos The cursor position |
| */ |
| public void track(Point pos) { |
| // Convert the mouse positon into 'local' coords |
| Rectangle r = new Rectangle(pos.x, pos.y, 1,1); |
| r = Geometry.toControl(windowComposite, r); |
| pos.x = r.x; |
| pos.y = r.y; |
| |
| // Are we 'inside' a trim area ? |
| cursorAreaId = getTrimArea(pos); |
| |
| // Provide tracking for the appropriate 'mode' |
| if (cursorAreaId != SWT.NONE) { |
| trackInsideTrimArea(pos); |
| } else { |
| trackOutsideTrimArea(pos); |
| } |
| } |
| |
| /** |
| * Perform the feedback used when the cursor is 'inside' a particular trim area. |
| * The current implementation will place the dragged trim into the trim area at |
| * the location determined by the supplied point. |
| * |
| * @param pos The point to use to determine where in the trim area the dragged trim |
| * should be located. |
| */ |
| private void trackInsideTrimArea(Point pos) { |
| // Where should we be? |
| int newArea = getTrimArea(pos); |
| IWindowTrim newInsertBefore = getInsertBefore(newArea, pos); |
| |
| // if we're currently undocked then we should dock |
| boolean shouldDock = dockedArea == SWT.NONE; |
| |
| // If we're already docked then only update if there's a change in area or position |
| if (dockedArea != SWT.NONE) { |
| // Where are we now? |
| IWindowTrim curInsertBefore = getInsertBefore(dockedArea, draggedTrim); |
| |
| // If we're already docked we should only update if there's a change |
| shouldDock = dockedArea != newArea || curInsertBefore != newInsertBefore; |
| } |
| |
| // Do we have to do anything? |
| if (shouldDock) { |
| // (Re)dock the trim in the new location |
| dock(newArea, newInsertBefore); |
| } |
| } |
| |
| /** |
| * Provide the dragging feedback when the cursor is -not- explicitly inside |
| * a particular trim area. |
| * |
| */ |
| private void trackOutsideTrimArea(Point pos) { |
| // If we -were- docked then undock |
| if (dockedArea != SWT.NONE) { |
| undock(); |
| } |
| |
| border.setLocation(pos, SWT.BOTTOM); |
| } |
| |
| /** |
| * Return the set of valid sides that a piece of trim can be docked on. We |
| * arbitrarily extend this to include any areas that won't cause a change in orientation |
| * |
| * @return The extended drop 'side' set |
| */ |
| private int getValidSides() { |
| int result = draggedTrim.getValidSides(); |
| if (result == SWT.NONE) { |
| return result; |
| } |
| |
| // For now, if we can dock...we can dock -anywhere- |
| return SWT.TOP | SWT.BOTTOM | SWT.LEFT | SWT.RIGHT; |
| } |
| |
| /** |
| * The user either cancelled the drag or tried to drop the trim in an invalid |
| * area...put the trim back in the last location it was in |
| */ |
| private void redock() { |
| // Since the control might move 'far' we'll provide an animation |
| Rectangle startRect = DragUtil.getDisplayBounds(draggedTrim.getControl()); |
| RectangleAnimation animation = new RectangleAnimation( |
| windowComposite.getShell(), startRect, initialLocation, 300); |
| animation.schedule(); |
| |
| dock(initialAreaId, initialInsertBefore); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.dnd.IDropTarget#drop() |
| */ |
| public void drop() { |
| // If we aren't docked then restore the initial location |
| if (dockedArea == SWT.NONE) { |
| redock(); |
| } |
| } |
| |
| /** |
| * Remove the trim frmo its current 'docked' location and attach it |
| * to the cursor... |
| */ |
| private void undock() { |
| // Remove the trim from the layout |
| layout.removeTrim(draggedTrim); |
| LayoutUtil.resize(draggedTrim.getControl()); |
| |
| // Re-orient the widget to its -original- side and size |
| draggedTrim.dock(initialAreaId); |
| draggedTrim.getControl().setSize(initialLocation.width, initialLocation.height); |
| |
| // Create a new dragging border onto the dragged trim |
| // Special check for TrimPart...should be generalized |
| boolean wantsFrame = !(draggedTrim instanceof TrimToolBarBase); |
| border = new DragBorder(windowComposite, draggedTrim.getControl(), wantsFrame); |
| |
| dockedArea = SWT.NONE; |
| } |
| |
| /** |
| * Return the 'undocked' trim to its previous location in the layout |
| */ |
| private void dock(int areaId, IWindowTrim insertBefore) { |
| // remove the drag 'border' |
| if (border != null) { |
| border.dispose(); |
| border = null; |
| } |
| |
| // Update the trim's orientation if necessary |
| draggedTrim.dock(areaId); |
| |
| // Add the trim into the layout |
| layout.addTrim(areaId, draggedTrim, insertBefore); |
| LayoutUtil.resize(draggedTrim.getControl()); |
| |
| // Remember the area that we're currently docked in |
| dockedArea = areaId; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.dnd.IDropTarget#getCursor() |
| */ |
| public Cursor getCursor() { |
| // If the trim isn't docked then show the 'no smoking' sign |
| if (cursorAreaId == SWT.NONE) { |
| return windowComposite.getDisplay().getSystemCursor(SWT.CURSOR_NO); |
| } |
| |
| // It's docked; show the four-way arrow cursor |
| return windowComposite.getDisplay().getSystemCursor(SWT.CURSOR_SIZEALL); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.dnd.IDropTarget#getSnapRectangle() |
| */ |
| public Rectangle getSnapRectangle() { |
| // TODO: KLUDGE!! We don't want to show -any- snap rect |
| // but Tracker won't allow that so place it where it won't be visible |
| return new Rectangle(100000, 0,0,0); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.ui.internal.dnd.IDropTarget2#dragFinished(boolean) |
| */ |
| public void dragFinished(boolean dropPerformed) { |
| // If we didn't perform a drop then restore the original position |
| if (!dropPerformed && dockedArea == SWT.NONE) { |
| // Force the dragged trim back into its original position... |
| redock(); |
| } |
| |
| // Set the draggedTrim to null. This indicates that we're no longer |
| // dragging the trim. The first call to the TrimDropTarget's 'drag' method |
| // will reset this the next time a drag starts. |
| draggedTrim = null; |
| } |
| } |
| |
| private ActualTrimDropTarget dropTarget; |
| |
| private TrimLayout layout; |
| private Composite windowComposite; |
| |
| /** |
| * Create a new drop target capable of accepting IWindowTrim items |
| * |
| * @param someComposite The control owning the TrimLayout |
| * @param theWindow the workbenchWindow |
| */ |
| public TrimDropTarget(Composite someComposite, WorkbenchWindow theWindow) { |
| layout = (TrimLayout) someComposite.getLayout(); |
| windowComposite = someComposite; |
| |
| // Create an instance of a drop target to use |
| dropTarget = new ActualTrimDropTarget(); |
| } |
| |
| /* (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, final Rectangle dragRectangle) { |
| |
| // Have to be dragging trim |
| if (!(draggedObject instanceof IWindowTrim)) { |
| return null; |
| } |
| |
| // OK, we're dragging trim. is it from -this- shell? |
| IWindowTrim trim = (IWindowTrim) draggedObject; |
| if (trim.getControl().getShell() != windowComposite.getShell()) { |
| return null; |
| } |
| |
| // If this is the -first- drag then inform the drop target |
| if (dropTarget.draggedTrim == null) { |
| dropTarget.startDrag(trim); |
| } |
| |
| // Forward on to the 'actual' drop target for feedback |
| dropTarget.track(position); |
| |
| // Spin the paint loop after every track |
| windowComposite.getDisplay().update(); |
| |
| return dropTarget; |
| } |
| } |
