org.eclipse.ui.internal.FastViewDnDHandler Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of workbench Show documentation
Show all versions of workbench Show documentation
This plug-in contains the bulk of the Workbench implementation, and depends on JFace, SWT, and Core Runtime. It cannot be used independently from org.eclipse.ui. Workbench client plug-ins should not depend directly on this plug-in.
The newest version!
/*******************************************************************************
* 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 true
if any view is a stand-alone view
*
* @return true
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);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy