| /****************************************************************************** |
| * Copyright (c) 2000, 2009 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.gmf.runtime.diagram.ui.internal.parts; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.draw2d.IFigure; |
| import org.eclipse.draw2d.PositionConstants; |
| import org.eclipse.draw2d.Viewport; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.draw2d.geometry.Rectangle; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gef.GraphicalEditPart; |
| import org.eclipse.gef.GraphicalViewer; |
| import org.eclipse.gef.RootEditPart; |
| import org.eclipse.gef.ui.parts.GraphicalViewerKeyHandler; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.KeyEvent; |
| |
| /** |
| * @author melaasar |
| * <p> |
| * Code taken from Eclipse reference bugzilla #98820 |
| * |
| */ |
| public class DiagramGraphicalViewerKeyHandler |
| extends GraphicalViewerKeyHandler { |
| |
| /** |
| * @param viewer |
| */ |
| public DiagramGraphicalViewerKeyHandler(GraphicalViewer viewer) { |
| super(viewer); |
| } |
| |
| /** |
| * @see org.eclipse.gef.KeyHandler#keyPressed(org.eclipse.swt.events.KeyEvent) |
| */ |
| public boolean keyPressed(KeyEvent event) { |
| switch (event.keyCode) { |
| case SWT.HOME : |
| if ((event.stateMask & SWT.ALT) != 0) { |
| if (navigateEndSibling(event, PositionConstants.WEST)) |
| return true; |
| } else { |
| if (navigateEndSibling(event, PositionConstants.NORTH)) |
| return true; |
| } |
| break; |
| case SWT.END : |
| if ((event.stateMask & SWT.ALT) != 0) { |
| if (navigateEndSibling(event, PositionConstants.EAST)) |
| return true; |
| } else { |
| if (navigateEndSibling(event, PositionConstants.SOUTH)) |
| return true; |
| } |
| break; |
| case SWT.PAGE_UP : |
| if ((event.stateMask & SWT.ALT) != 0) { |
| if (navigatePageSibling(event, PositionConstants.WEST)) |
| return true; |
| } else { |
| if (navigatePageSibling(event, PositionConstants.NORTH)) |
| return true; |
| } |
| break; |
| case SWT.PAGE_DOWN : |
| if ((event.stateMask & SWT.ALT) != 0) { |
| if (navigatePageSibling(event, PositionConstants.EAST)) |
| return true; |
| } else { |
| if (navigatePageSibling(event, PositionConstants.SOUTH)) |
| return true; |
| } |
| break; |
| case SWT.TAB: |
| if ((event.stateMask & SWT.SHIFT) != 0) { |
| if (navigateNextHorizontalSibling(isViewerMirrored() ? PositionConstants.EAST |
| : PositionConstants.WEST)) { |
| return true; |
| } |
| } else { |
| if (navigateNextHorizontalSibling(isViewerMirrored() ? PositionConstants.WEST |
| : PositionConstants.EAST)) { |
| return true; |
| } |
| } |
| break; |
| } |
| return super.keyPressed(event); |
| } |
| |
| /** |
| * @return |
| */ |
| protected GraphicalEditPart getFocusPart() { |
| return (GraphicalEditPart) getViewer().getFocusEditPart(); |
| } |
| |
| /** |
| * @param part |
| * @param event |
| */ |
| protected void navigateToPart(EditPart part, KeyEvent event) { |
| if (part == null) |
| return; |
| if (!part.isSelectable()) { |
| getViewer().deselectAll(); |
| getViewer().setFocus(part); |
| } else if ((event.stateMask & SWT.SHIFT) != 0) { |
| getViewer().appendSelection(part); |
| getViewer().setFocus(part); |
| } else if ((event.stateMask & SWT.CONTROL) != 0) |
| getViewer().setFocus(part); |
| else |
| getViewer().select(part); |
| getViewer().reveal(part); |
| } |
| |
| /** |
| * @return |
| */ |
| protected List getPartNavigationSiblings() { |
| EditPart epParent = findParent(getFocusPart()); |
| if (epParent != null) |
| return epParent.getChildren(); |
| else |
| return null; |
| } |
| |
| /** |
| * @param figure |
| * @return |
| */ |
| protected Point getFigureInterestingPoint(IFigure figure) { |
| return figure.getBounds().getCenter(); |
| } |
| |
| protected Viewport findViewport(GraphicalEditPart part) { |
| if (part == null) |
| return null; |
| |
| IFigure figure = null; |
| Viewport port = null; |
| do { |
| if (figure == null) |
| figure = part.getContentPane(); |
| else |
| figure = figure.getParent(); |
| if (figure instanceof Viewport) { |
| port = (Viewport) figure; |
| break; |
| } |
| } while (figure != null); |
| return port; |
| } |
| |
| /** |
| * @param event |
| * @param direction |
| * @param page |
| * @param list |
| * @return |
| */ |
| protected boolean navigatePageSibling(KeyEvent event, int direction) { |
| GraphicalEditPart epStart = getFocusPart(); |
| IFigure figure = epStart.getFigure(); |
| Point pStart = getFigureInterestingPoint(figure); |
| figure.translateToAbsolute(pStart); |
| |
| GraphicalEditPart epParent = (GraphicalEditPart) findParent(epStart); |
| Viewport viewport = findViewport(epParent); |
| Rectangle bounds = |
| (viewport != null) |
| ? new Rectangle(viewport.getBounds()) |
| : epParent.getFigure().getClientArea(); |
| int pageDistance = 0; |
| switch (direction) { |
| case PositionConstants.NORTH : |
| case PositionConstants.SOUTH : |
| pageDistance = bounds.height; |
| break; |
| case PositionConstants.EAST : |
| case PositionConstants.WEST : |
| pageDistance = bounds.width; |
| break; |
| } |
| |
| if (epStart instanceof DiagramEditPart) { |
| Point location = viewport.getViewLocation().getCopy(); |
| switch (direction) { |
| case PositionConstants.NORTH : |
| location.translate(0, -pageDistance); |
| break; |
| case PositionConstants.SOUTH : |
| location.translate(0, pageDistance); |
| break; |
| case PositionConstants.EAST : |
| location.translate(pageDistance, 0); |
| break; |
| case PositionConstants.WEST : |
| location.translate(-pageDistance, 0); |
| break; |
| } |
| viewport.setViewLocation(location); |
| } |
| |
| List<GraphicalEditPart> editParts = |
| findPageSibling( |
| getPartNavigationSiblings(), |
| pStart, |
| pageDistance, |
| direction, |
| epStart); |
| if (editParts.isEmpty()) |
| return false; |
| if ((event.stateMask & SWT.SHIFT) != 0) { |
| Iterator<GraphicalEditPart> parts = editParts.iterator(); |
| while (parts.hasNext()) |
| navigateToPart(parts.next(), event); |
| } else { |
| EditPart part = editParts.get(editParts.size() - 1); |
| navigateToPart(part, event); |
| } |
| return true; |
| } |
| |
| /** |
| * @param event |
| * @param direction |
| * @param list |
| * @return |
| */ |
| protected boolean navigateEndSibling(KeyEvent event, int direction) { |
| GraphicalEditPart epStart = getFocusPart(); |
| |
| // go to top-left or bottom-right corner if nothing is selected |
| if (epStart instanceof DiagramEditPart) { |
| Viewport viewport = findViewport(epStart); |
| switch (direction) { |
| case PositionConstants.NORTH: |
| case PositionConstants.WEST: |
| viewport.setViewLocation(viewport.getHorizontalRangeModel() |
| .getMinimum(), viewport.getVerticalRangeModel() |
| .getMinimum()); |
| break; |
| case PositionConstants.SOUTH: |
| case PositionConstants.EAST: |
| viewport.setViewLocation(viewport.getHorizontalRangeModel() |
| .getMaximum(), viewport.getVerticalRangeModel() |
| .getMaximum()); |
| break; |
| } |
| } |
| |
| IFigure figure = epStart.getFigure(); |
| Point pStart = getFigureInterestingPoint(figure); |
| figure.translateToAbsolute(pStart); |
| List<GraphicalEditPart> editParts = |
| findEndSibling( |
| getPartNavigationSiblings(), |
| pStart, |
| direction, |
| epStart); |
| if (editParts.isEmpty()) |
| return false; |
| if ((event.stateMask & SWT.SHIFT) != 0) { |
| Iterator<GraphicalEditPart> parts = editParts.iterator(); |
| while (parts.hasNext()) |
| navigateToPart(parts.next(), event); |
| } else { |
| EditPart part = editParts.get(editParts.size() - 1); |
| navigateToPart(part, event); |
| } |
| return true; |
| } |
| |
| /** |
| * @param siblings |
| * @param pStart |
| * @param minDistance |
| * @param direction |
| * @param exclude |
| * @return |
| */ |
| private List<GraphicalEditPart> findPageSibling( |
| List siblings, |
| Point pStart, |
| int pageDistance, |
| int direction, |
| EditPart exclude) { |
| |
| GraphicalEditPart epCurrent; |
| GraphicalEditPart epFinal = null; |
| GraphicalEditPart epFurthest = null; // in case there is not a full pageDistance left to scroll |
| List<GraphicalEditPart> selection = new ArrayList<GraphicalEditPart>(); |
| IFigure figure; |
| Point pCurrent; |
| int distance = Integer.MAX_VALUE; |
| int furthestDistance = 0; |
| |
| Iterator iter = siblings.iterator(); |
| while (iter.hasNext()) { |
| epCurrent = (GraphicalEditPart) iter.next(); |
| if (epCurrent == exclude |
| || !epCurrent.getFigure().isVisible() |
| || epCurrent.getFigure().getBounds().isEmpty()) |
| continue; |
| figure = epCurrent.getFigure(); |
| pCurrent = getFigureInterestingPoint(figure); |
| figure.translateToAbsolute(pCurrent); |
| if (!isInDirection(direction, pStart, pCurrent)) |
| continue; |
| |
| int d = pCurrent.getDistanceOrthogonal(pStart); |
| if (d >= pageDistance) { |
| selection.add(epCurrent); |
| if (d < distance) { |
| distance = d; |
| epFinal = epCurrent; |
| } |
| } |
| if (d > furthestDistance) { |
| epFurthest = epCurrent; |
| } |
| if (epFinal != null) { |
| selection.remove(epFinal); |
| selection.add(epFinal); |
| } |
| } |
| if (selection.isEmpty() && epFurthest != null) { |
| return Collections.singletonList(epFurthest); |
| } |
| return selection; |
| } |
| |
| /** |
| * @param siblings |
| * @param pStart |
| * @param direction |
| * @param exclude |
| * @return |
| */ |
| private List<GraphicalEditPart> findEndSibling( |
| List siblings, |
| Point pStart, |
| int direction, |
| EditPart exclude) { |
| GraphicalEditPart epCurrent; |
| GraphicalEditPart epFinal = null; |
| List<GraphicalEditPart> selection = new ArrayList<GraphicalEditPart>(); |
| IFigure figure; |
| Point pCurrent; |
| int distance = 0; |
| |
| Iterator iter = siblings.iterator(); |
| while (iter.hasNext()) { |
| epCurrent = (GraphicalEditPart) iter.next(); |
| if (epCurrent == exclude |
| || !epCurrent.getFigure().isVisible() |
| || epCurrent.getFigure().getBounds().isEmpty()) |
| continue; |
| figure = epCurrent.getFigure(); |
| pCurrent = getFigureInterestingPoint(figure); |
| figure.translateToAbsolute(pCurrent); |
| if (!isInDirection(direction, pStart, pCurrent)) |
| continue; |
| |
| selection.add(epCurrent); |
| int d = pCurrent.getDistanceOrthogonal(pStart); |
| if (d > distance) { |
| distance = d; |
| epFinal = epCurrent; |
| } |
| } |
| if (epFinal != null) { |
| selection.remove(epFinal); |
| selection.add(epFinal); |
| } |
| return selection; |
| } |
| |
| |
| /** |
| * @param child |
| * @return EditPart |
| */ |
| private EditPart findParent(EditPart child) { |
| //check to see if we are not looking for a parent on RootEditPart, |
| //as it does not have a parent. |
| if (child instanceof RootEditPart) |
| return child; |
| else |
| return child.getParent(); //any other EditPart |
| } |
| |
| /** |
| * Traverses to the closest EditPart in the given list that is also in the |
| * given direction (EAST or WEST). The x-location alone is used to determine |
| * the closest sibling. If the direction is EAST and there are no EditParts |
| * to the EAST then the farthest WEST EditPart is returned (and vice versa). |
| * This allows the user to cycle through all the EditParts using the TAB |
| * key. |
| * |
| * @param direction |
| * the direction in which to navigate (either |
| * PositionConstants.WEST or PositionConstants.EAST) |
| * @return true if a sibling was found to navigate to; false otherwise. |
| */ |
| private boolean navigateNextHorizontalSibling(int direction) { |
| GraphicalEditPart epStart = getFocusEditPart(); |
| EditPart next = null; |
| if (epStart instanceof DiagramEditPart) { |
| next = findClosestHorizontalSibling(epStart.getChildren(), |
| new Point(0, 0), PositionConstants.EAST, null); |
| } else { |
| IFigure figure = epStart.getFigure(); |
| Point pStart = figure.getBounds().getCenter(); |
| figure.translateToAbsolute(pStart); |
| next = findClosestHorizontalSibling(getNavigationSiblings(), |
| pStart, direction, epStart); |
| } |
| if (next == null) |
| return false; |
| |
| getViewer().select(next); |
| getViewer().reveal(next); |
| return true; |
| } |
| |
| /** |
| * Given an absolute point (pStart) and a list of EditParts, this method |
| * finds the closest EditPart (except for the one to be excluded) in the |
| * given direction (EAST or WEST). The x-location is used to determine the |
| * closest sibling. Also, if going EAST and there is vertically aligned |
| * figure underneath pStart, then that figure is the result. If going WEST |
| * and there is a figure above pStartm then that figure is the result.If the |
| * direction is EAST and there are no EditParts to the EAST and SOUTH then |
| * the farthest WEST EditPart is returned (and vice versa). This allows the |
| * user to cycle through all the EditParts using the TAB key. |
| * |
| * @param siblings |
| * List of sibling EditParts |
| * @param pStart |
| * The starting point (must be in absolute coordinates) from |
| * which the next sibling is to be found. |
| * @param direction |
| * PositionConstants.EAST or PositionConstants.WEST |
| * @param exclude |
| * The EditPart to be excluded from the search |
| */ |
| private GraphicalEditPart findClosestHorizontalSibling(List siblings, |
| Point pStart, int direction, EditPart exclude) { |
| GraphicalEditPart epCurrent; |
| GraphicalEditPart epFinal = null; |
| GraphicalEditPart epCycle = null; // in case there are no more shapes in this direction |
| GraphicalEditPart epCycleVertical = null; // in case there are no more shapes in EAST or WEST direction |
| |
| IFigure figure; |
| Point pCurrent; |
| int distanceX = Integer.MAX_VALUE; |
| int distanceY = Integer.MAX_VALUE; |
| int finalY = 0; |
| boolean goVertical = false; |
| int xCycle = direction == PositionConstants.EAST ? Integer.MAX_VALUE : 0; |
| int yCycle = xCycle; |
| int yCycleVertical = xCycle; |
| |
| Iterator iter = siblings.iterator(); |
| while (iter.hasNext()) { |
| epCurrent = (GraphicalEditPart) iter.next(); |
| if (epCurrent == exclude || !epCurrent.isSelectable()) |
| continue; |
| figure = epCurrent.getFigure(); |
| pCurrent = figure.getBounds().getCenter(); |
| figure.translateToAbsolute(pCurrent); |
| |
| int dx = pCurrent.x - pStart.x; |
| |
| if (!goVertical && |
| ((direction == PositionConstants.EAST && dx > 0) |
| || (direction == PositionConstants.WEST && dx < 0))) { |
| int abs_dx = Math.abs(dx); |
| if (abs_dx < distanceX) { |
| distanceX = abs_dx; |
| finalY = pCurrent.y; |
| epFinal = epCurrent; |
| } else if (abs_dx == distanceX) { |
| // There are vertically aligned figures that could be horizontally closest to the current figure. |
| // If we go east, choose the top one, if we go west, choose the bottom one. |
| // finalY is always assigned in this case |
| if ((direction == PositionConstants.EAST && pCurrent.y < finalY) || |
| (direction == PositionConstants.WEST && pCurrent.y > finalY)) { |
| finalY = pCurrent.y; |
| epFinal = epCurrent; |
| } |
| } |
| } |
| if (dx == 0) { |
| // Once we find a figure that is vertically aligned with the current, we have to go vertically |
| // (to this or closest figure vertically aligned) since there will be no other chance to traverse it. |
| // The exception: we reached the far east end while going east, or far west end while going west. |
| int dy = pCurrent.y - pStart.y; |
| if ((direction == PositionConstants.EAST && dy > 0) |
| || (direction == PositionConstants.WEST && dy < 0)) { |
| goVertical = true; |
| int abs_dy = Math.abs(dy); |
| if (abs_dy < distanceY) { |
| distanceY = abs_dy; |
| epFinal = epCurrent; |
| } |
| } |
| } |
| // Consider the case when we need to go east (south) or west (north) and the current figure is on the |
| // far east (south) or west (north) end, respectively. |
| if (epFinal == null) { |
| if (dx == 0) { |
| // Case when the figure is at the end and there is one or more vertically aligned figure. |
| // This will be the result only if there are no figures to the left or right. |
| if (direction == PositionConstants.EAST && pCurrent.y < yCycleVertical) { |
| yCycleVertical = pCurrent.y; |
| epCycleVertical = epCurrent; |
| } else if (direction == PositionConstants.WEST && pCurrent.y > yCycleVertical) { |
| yCycleVertical = pCurrent.y; |
| epCycleVertical = epCurrent; |
| } |
| } else { |
| boolean assign = false; |
| if (direction == PositionConstants.EAST) { |
| if (pCurrent.x < xCycle) { |
| assign = true; |
| } else if (pCurrent.x == xCycle) { |
| // Current figure is vertically aligned with the possible result figure. |
| // Choose the top figure. |
| if (pCurrent.y < yCycle) { |
| assign = true; |
| } |
| } |
| } else if (direction == PositionConstants.WEST) { |
| if (pCurrent.x > xCycle) { |
| assign = true; |
| } else if (pCurrent.x == xCycle) { |
| // Current figure is vertically aligned with the possible result figure. |
| // Choose the top figure. |
| if (pCurrent.y > yCycle) { |
| assign = true; |
| } |
| } |
| } |
| if (assign) { |
| xCycle = pCurrent.x; |
| yCycle = pCurrent.y; |
| epCycle = epCurrent; |
| } |
| } |
| } |
| } |
| if (epFinal == null) { |
| if (epCycle == null) { |
| return epCycleVertical; |
| } else { |
| return epCycle; |
| } |
| } |
| return epFinal; |
| } |
| |
| /** |
| * Returns true if the point in question is in the given direction from the |
| * starting point. |
| * |
| * @param direction |
| * the direction |
| * @param start |
| * the starting point |
| * @param point |
| * the point in question |
| * @return true if the point in question is in the given direction from the |
| * starting point; false otherwise |
| */ |
| private boolean isInDirection(int direction, Point start, Point point) { |
| switch (direction) { |
| case PositionConstants.WEST: |
| return start.x > point.x; |
| case PositionConstants.EAST: |
| return start.x < point.x; |
| case PositionConstants.NORTH: |
| return start.y > point.y; |
| case PositionConstants.SOUTH: |
| return start.y < point.y; |
| } |
| return false; |
| } |
| |
| } |
