plugins/org.eclipse.bpel.ui.noEmbeddedEditors/src/org/eclipse/bpel/ui/BPELGraphicalKeyHandler.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2012 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.bpel.ui;

 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Vector;

 import org.eclipse.bpel.ui.editparts.CollapsableEditPart;
 import org.eclipse.bpel.ui.editparts.ProcessEditPart;
 import org.eclipse.draw2d.FigureCanvas;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.draw2d.PositionConstants;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.gef.ConnectionEditPart;
 import org.eclipse.gef.EditPart;
 import org.eclipse.gef.GraphicalEditPart;
 import org.eclipse.gef.GraphicalViewer;
 import org.eclipse.gef.KeyHandler;
 import org.eclipse.gef.requests.DirectEditRequest;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.events.KeyEvent;

 public class BPELGraphicalKeyHandler extends KeyHandler {
 	int counter;

 	/**
 	 * When navigating through connections, a "Node" EditPart is used as a
 	 * reference.
 	 */
 	private WeakReference<GraphicalEditPart> cachedNode;
 	private GraphicalViewer viewer;

 	public BPELGraphicalKeyHandler(GraphicalViewer viewer) {
 		this.viewer = viewer;
 	}

 	private boolean acceptConnection(KeyEvent event) {
 		return event.character == '/'
 			|| event.character == '?'
 			|| event.character == '\\'
 			|| event.character == '\u001c'
 			|| event.character == '|';
 	}

 	private boolean acceptIntoContainer(KeyEvent event) {
 		return ((event.stateMask & SWT.ALT) != 0)
 			&& (event.keyCode == SWT.ARROW_DOWN);
 	}

 	private boolean acceptLeaveConnection(KeyEvent event) {
 		int key = event.keyCode;
 		if (getFocus() instanceof ConnectionEditPart)
 			if ((key == SWT.ARROW_UP)
 				|| (key == SWT.ARROW_RIGHT)
 				|| (key == SWT.ARROW_DOWN)
 				|| (key == SWT.ARROW_LEFT))
 				return true;
 		return false;
 	}

 	private boolean acceptLeaveContents(KeyEvent event) {
 		int key = event.keyCode;
 		return getFocus() == getViewer().getContents()
 			&& ((key == SWT.ARROW_UP)
 				|| (key == SWT.ARROW_RIGHT)
 				|| (key == SWT.ARROW_DOWN)
 				|| (key == SWT.ARROW_LEFT));
 	}

 	private boolean acceptOutOf(KeyEvent event) {
 		return ((event.stateMask & SWT.ALT) != 0)
 			&& (event.keyCode == SWT.ARROW_UP);
 	}

 	private ConnectionEditPart findConnection(
 		GraphicalEditPart node,
 		ConnectionEditPart current,
 		boolean forward) {
 		List<ConnectionEditPart> connections = new ArrayList<ConnectionEditPart>(node.getSourceConnections());
 		connections.addAll(node.getTargetConnections());
 		if (connections.isEmpty())
 			return null;
 		if (forward)
 			counter++;
 		else
 			counter--;
 		while (counter < 0)
 			counter += connections.size();
 		counter %= connections.size();
 		return connections.get(
 			counter % connections.size());
 	}

 	/*
 	 * pStart is a point in absolute coordinates.
 	 */
 	private GraphicalEditPart findSibling(
 		List<GraphicalEditPart> siblings,
 		Point pStart,
 		int direction,
 		EditPart exclude) {
 		GraphicalEditPart epCurrent;
 		GraphicalEditPart epFinal = null;
 		IFigure figure;
 		Point pCurrent;
 		int distance = Integer.MAX_VALUE;

 		Iterator<GraphicalEditPart> iter = siblings.iterator();
 		while (iter.hasNext()) {
 			epCurrent = iter.next();
 			if (epCurrent == exclude || !epCurrent.isSelectable())
 				continue;
 			figure = epCurrent.getFigure();
 			pCurrent = getInterestingPoint(figure);
 			figure.translateToAbsolute(pCurrent);
 			if (pStart.getPosition(pCurrent) != direction)
 				continue;

 			int d = pCurrent.getDistanceOrthogonal(pStart);
 			if (d < distance) {
 				distance = d;
 				epFinal = epCurrent;
 			}
 		}
 		return epFinal;
 	}

 	Point getInterestingPoint(IFigure figure) {
 		return figure.getBounds().getCenter();
 	}

 	/**
 	 * Returns the cached node. It is possible that the node is not longer in
 	 * the viewer but has not been garbage collected yet.
 	 */
 	private GraphicalEditPart getCachedNode() {
 		if (cachedNode == null)
 			return null;
 		if (cachedNode.isEnqueued())
 			return null;
 		return cachedNode.get();
 	}

 	protected GraphicalEditPart getFocus() {
 		return (GraphicalEditPart) getViewer().getFocusEditPart();
 	}

 	/**
 	 * Returns the viewer on which this key handler was created.
 	 *
 	 * @return the viewer
 	 */
 	protected GraphicalViewer getViewer() {
 		return viewer;
 	}

 	/**
 	 * Extended to process key events described above.
 	 *
 	 * @see org.eclipse.gef.KeyHandler#keyPressed(org.eclipse.swt.events.KeyEvent)
 	 */
 	@Override
 	public boolean keyPressed(KeyEvent event) {
 		if (event.character == ' ') {
 			processSelect(event);
 			return true;
 		} else if (acceptIntoContainer(event)) {
 			navigateIntoContainer(event);
 			return true;
 		} else if (acceptOutOf(event)) {
 			navigateOut(event);
 			return true;
 		} else if (acceptConnection(event)) {
 			navigateConnections(event);
 			return true;
 		} else if (acceptScroll(event)) {
 			scrollViewer(event);
 			return true;
 		} else if (acceptLeaveConnection(event)) {
 			navigateOutOfConnection(event);
 			return true;
 		} else if (acceptLeaveContents(event)) {
 			navigateIntoContainer(event);
 			return true;
 		} else if (event.character == '[') {
 			int found = -1;
 			List<GraphicalEditPart> list = getProcessNavigationList();
 			for (int i = 0; i < list.size(); i++) {
 				if (getFocus() == list.get(i)) {
 					found = i;
 					break;
 				}
 			}
 			if (found >= 0) {
 				found--;
 			}
 			if (found >=0) {
 				EditPart navigateTo = list.get(found);
 				navigateTo(navigateTo, event);
 			}
 		} else if (event.character == ']') {
 			int found = -1;
 			List<GraphicalEditPart> list = getProcessNavigationList();
 			for (int i = 0; i < list.size(); i++) {
 				if (getFocus() == list.get(i)) {
 					found = i;
 					break;
 				}
 			}
 			if (found >= 0) {
 				found++;
 			}
 			if (found < list.size()) {
 				EditPart navigateTo = list.get(found);
 				navigateTo(navigateTo, event);
 			}
 		} else if (event.character == '+' || event.character == '=') {
 			expand(event);
 		} else if (event.character == '-') {
 			collapse(event);
 		}


 		switch (event.keyCode) {
 			case SWT.ARROW_LEFT :
 				if (navigateNextSibling(event, PositionConstants.WEST))
 					return true;
 				break;
 			case SWT.ARROW_RIGHT :
 				if (navigateNextSibling(event, PositionConstants.EAST))
 						return true;
 				break;
 			case SWT.ARROW_UP :
 				if (navigateNextSibling(event, PositionConstants.NORTH))
 					return true;
 				break;
 			case SWT.ARROW_DOWN :
 				if (navigateNextSibling(event, PositionConstants.SOUTH))
 					return true;
 				break;

 			case SWT.HOME :
 				if (navigateJumpSibling(event, PositionConstants.WEST))
 					return true;
 				break;
 			case SWT.END :
 				if (navigateJumpSibling(event, PositionConstants.EAST))
 					return true;
 				break;
 			case SWT.PAGE_DOWN :
 				if (navigateJumpSibling(event, PositionConstants.SOUTH))
 					return true;
 				break;
 			case SWT.PAGE_UP :
 				if (navigateJumpSibling(event, PositionConstants.NORTH))
 					return true;
 				break;
 			case SWT.TAB :
 				return true;
 			case SWT.F2:
 				activateDirectEdit(event);
 				break;
 		}
 		return super.keyPressed(event);
 	}

 	private void navigateConnections(KeyEvent event) {
 		GraphicalEditPart focus = getFocus();
 		ConnectionEditPart current = null;
 		GraphicalEditPart node = getCachedNode();
 		if (focus instanceof ConnectionEditPart) {
 			current = (ConnectionEditPart) focus;
 			if (node == null
 				|| (node != current.getSource() && node != current.getTarget())) {
 				node = (GraphicalEditPart) current.getSource();
 				counter = 0;
 			}
 		} else {
 			node = focus;
 		}

 		setCachedNode(node);
 		boolean forward = event.character == '/' || event.character == '?';
 		ConnectionEditPart next = findConnection(node, current, forward);
 		navigateTo(next, event);
 	}

 	private void navigateIntoContainer(KeyEvent event) {
 		GraphicalEditPart focus = getFocus();
 		List<GraphicalEditPart> childList = getNavigationChildren(focus);
 		Point tl = focus.getContentPane().getBounds().getTopLeft();

 		int minimum = Integer.MAX_VALUE;
 		int current;
 		GraphicalEditPart closestPart = null;

 		for (int i = 0; i < childList.size(); i++) {
 			GraphicalEditPart ged = childList.get(i);
 			if (!ged.isSelectable())
 				continue;
 			Rectangle childBounds = ged.getFigure().getBounds();

 			current = (childBounds.x - tl.x) + (childBounds.y - tl.y);
 			if (current < minimum) {
 				minimum = current;
 				closestPart = ged;
 			}
 		}
 		if (closestPart != null)
 			navigateTo(closestPart, event);
 	}

 	private boolean navigateJumpSibling(KeyEvent event, int direction) {
 		// TODO: Implement navigateJumpSibling() (for PGUP, PGDN, HOME and END
 		// key events)
 		return false;
 	}

 	private boolean navigateNextSibling(KeyEvent event, int direction) {
 		return navigateNextSibling(event, direction, getNavigationSiblings());
 	}

 	boolean navigateNextSibling(KeyEvent event, int direction, List<GraphicalEditPart> list) {
 		GraphicalEditPart epStart = getFocus();
 		IFigure figure = epStart.getFigure();
 		Point pStart = getInterestingPoint(figure);
 		figure.translateToAbsolute(pStart);
 		EditPart next = findSibling(list, pStart, direction, epStart);
 		if (next == null)
 			return false;
 		navigateTo(next, event);
 		return true;
 	}

 	private void navigateOut(KeyEvent event) {
 		EditPart parent = getNavigationParent(getFocus());
 		if (getFocus() == null || getFocus() == getViewer().getContents() || getFocus().getParent() == getViewer().getContents())
 			return;
 		navigateTo(parent, event);
 	}

 	private void navigateOutOfConnection(KeyEvent event) {
 		GraphicalEditPart cached = getCachedNode();
 		ConnectionEditPart conn = (ConnectionEditPart) getFocus();
 		if (cached != null && (cached == conn.getSource() || cached == conn.getTarget()))
 			navigateTo(cached, event);
 		else
 			navigateTo(conn.getSource(), event);
 	}

 	void navigateTo(EditPart part, KeyEvent event) {
 		if (part == null)
 			return;
 		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);
 	}

 	private void processSelect(KeyEvent event) {
 		EditPart part = getViewer().getFocusEditPart();
 		if ((event.stateMask & SWT.CONTROL) != 0
 			&& part.getSelected() != EditPart.SELECTED_NONE)
 			getViewer().deselect(part);
 		else
 			getViewer().appendSelection(part);

 		getViewer().setFocus(part);
 	}

 	private void expand(KeyEvent event) {
 		EditPart part = getViewer().getFocusEditPart();
 		if (part instanceof CollapsableEditPart) {
 			((CollapsableEditPart)part).setCollapsed(false);
 		}
 	}

 	private void collapse(KeyEvent event) {
 		EditPart part = getViewer().getFocusEditPart();
 		if (part instanceof CollapsableEditPart) {
 			((CollapsableEditPart)part).setCollapsed(true);
 		}
 	}

 	private void setCachedNode(GraphicalEditPart node) {
 		if (node == null)
 			cachedNode = null;
 		else
 			cachedNode = new WeakReference<GraphicalEditPart>(node);
 	}

 	/**
 	 * handles StartNodeEditPart specific behavior
 	 */
 	protected List<GraphicalEditPart> getNavigationChildren(EditPart part) {
 //		if (part instanceof StartNodeEditPart) {
 //			// return the process's children
 //			ProcessEditPart proc = (ProcessEditPart) part.getParent();
 //			List list = proc.getChildren();
 //			list.remove(part);
 //			return list;
 //		}
 //		else
 		return part.getChildren();
 	}

 	protected List<GraphicalEditPart> getNavigationSiblings() {
 		EditPart focus = getFocus().getParent();
 		return focus.getChildren();
 	}

 	protected EditPart getNavigationParent(EditPart part) {
 		EditPart parent = part.getParent();
 		if (parent instanceof ProcessEditPart) {
 			return null;
 		}
 		return parent;
 	}

 	protected void addChildren(EditPart part, List<GraphicalEditPart> list) {
 		List<GraphicalEditPart> children = part.getChildren();
 		for (int i = 0; i < children.size(); i++) {
 			list.add(children.get(i));
 			addChildren((children.get(i)), list);
 		}
 		return;
 	}
 	/*
 	 * as a usability enhancement, we want to navigate to the next activity using the SHIFT left and right arrow, this
 	 * allows the user to navigate to every element on the canvas easily
 	 */
 	protected List<GraphicalEditPart> getProcessNavigationList() {
 		ProcessEditPart process = (ProcessEditPart)viewer.getContents();
 		Vector<GraphicalEditPart> all = new Vector<GraphicalEditPart>();
 		addChildren(process,all);
 		return all;
 	}

 	protected boolean activateDirectEdit(KeyEvent event) {
 		GraphicalEditPart currentPart = (GraphicalEditPart)viewer.getFocusEditPart();
 		currentPart.performRequest(new DirectEditRequest());
 		return true;
 	}

 	boolean acceptScroll(KeyEvent event) {
 		return ((event.stateMask & SWT.CTRL) != 0 && (event.stateMask & SWT.SHIFT) != 0
 				&& (event.keyCode == SWT.ARROW_DOWN || event.keyCode == SWT.ARROW_LEFT
 				|| event.keyCode == SWT.ARROW_RIGHT || event.keyCode == SWT.ARROW_UP));
 	}

 	void scrollViewer(KeyEvent event) {
 		if (!(getViewer().getControl() instanceof FigureCanvas))
 			return;
 		FigureCanvas figCanvas = (FigureCanvas)getViewer().getControl();
 		Point loc = figCanvas.getViewport().getViewLocation();
 		Rectangle area = figCanvas.getViewport().getClientArea(Rectangle.SINGLETON).scale(.1);
 		switch (event.keyCode) {
 			case SWT.ARROW_DOWN:
 				figCanvas.scrollToY(loc.y + area.height);
 				break;
 			case SWT.ARROW_UP:
 				figCanvas.scrollToY(loc.y - area.height);
 				break;
 			case SWT.ARROW_LEFT:
 				figCanvas.scrollToX(loc.x - area.width);
 				break;
 			case SWT.ARROW_RIGHT:
 				figCanvas.scrollToX(loc.x + area.width);
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2012 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.bpel.ui;

	import java.lang.ref.WeakReference;
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Vector;

	import org.eclipse.bpel.ui.editparts.CollapsableEditPart;
	import org.eclipse.bpel.ui.editparts.ProcessEditPart;
	import org.eclipse.draw2d.FigureCanvas;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.draw2d.PositionConstants;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.Rectangle;
	import org.eclipse.gef.ConnectionEditPart;
	import org.eclipse.gef.EditPart;
	import org.eclipse.gef.GraphicalEditPart;
	import org.eclipse.gef.GraphicalViewer;
	import org.eclipse.gef.KeyHandler;
	import org.eclipse.gef.requests.DirectEditRequest;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.events.KeyEvent;

	public class BPELGraphicalKeyHandler extends KeyHandler {
	int counter;

	/**
	* When navigating through connections, a "Node" EditPart is used as a
	* reference.
	*/
	private WeakReference<GraphicalEditPart> cachedNode;
	private GraphicalViewer viewer;

	public BPELGraphicalKeyHandler(GraphicalViewer viewer) {
	this.viewer = viewer;
	}

	private boolean acceptConnection(KeyEvent event) {
	return event.character == '/'
	\|\| event.character == '?'
	\|\| event.character == '\\'
	\|\| event.character == '\u001c'
	\|\| event.character == '\|';
	}

	private boolean acceptIntoContainer(KeyEvent event) {
	return ((event.stateMask & SWT.ALT) != 0)
	&& (event.keyCode == SWT.ARROW_DOWN);
	}

	private boolean acceptLeaveConnection(KeyEvent event) {
	int key = event.keyCode;
	if (getFocus() instanceof ConnectionEditPart)
	if ((key == SWT.ARROW_UP)
	\|\| (key == SWT.ARROW_RIGHT)
	\|\| (key == SWT.ARROW_DOWN)
	\|\| (key == SWT.ARROW_LEFT))
	return true;
	return false;
	}

	private boolean acceptLeaveContents(KeyEvent event) {
	int key = event.keyCode;
	return getFocus() == getViewer().getContents()
	&& ((key == SWT.ARROW_UP)
	\|\| (key == SWT.ARROW_RIGHT)
	\|\| (key == SWT.ARROW_DOWN)
	\|\| (key == SWT.ARROW_LEFT));
	}

	private boolean acceptOutOf(KeyEvent event) {
	return ((event.stateMask & SWT.ALT) != 0)
	&& (event.keyCode == SWT.ARROW_UP);
	}

	private ConnectionEditPart findConnection(
	GraphicalEditPart node,
	ConnectionEditPart current,
	boolean forward) {
	List<ConnectionEditPart> connections = new ArrayList<ConnectionEditPart>(node.getSourceConnections());
	connections.addAll(node.getTargetConnections());
	if (connections.isEmpty())
	return null;
	if (forward)
	counter++;
	else
	counter--;
	while (counter < 0)
	counter += connections.size();
	counter %= connections.size();
	return connections.get(
	counter % connections.size());
	}

	/*
	* pStart is a point in absolute coordinates.
	*/
	private GraphicalEditPart findSibling(
	List<GraphicalEditPart> siblings,
	Point pStart,
	int direction,
	EditPart exclude) {
	GraphicalEditPart epCurrent;
	GraphicalEditPart epFinal = null;
	IFigure figure;
	Point pCurrent;
	int distance = Integer.MAX_VALUE;

	Iterator<GraphicalEditPart> iter = siblings.iterator();
	while (iter.hasNext()) {
	epCurrent = iter.next();
	if (epCurrent == exclude \|\| !epCurrent.isSelectable())
	continue;
	figure = epCurrent.getFigure();
	pCurrent = getInterestingPoint(figure);
	figure.translateToAbsolute(pCurrent);
	if (pStart.getPosition(pCurrent) != direction)
	continue;

	int d = pCurrent.getDistanceOrthogonal(pStart);
	if (d < distance) {
	distance = d;
	epFinal = epCurrent;
	}
	}
	return epFinal;
	}

	Point getInterestingPoint(IFigure figure) {
	return figure.getBounds().getCenter();
	}

	/**
	* Returns the cached node. It is possible that the node is not longer in
	* the viewer but has not been garbage collected yet.
	*/
	private GraphicalEditPart getCachedNode() {
	if (cachedNode == null)
	return null;
	if (cachedNode.isEnqueued())
	return null;
	return cachedNode.get();
	}

	protected GraphicalEditPart getFocus() {
	return (GraphicalEditPart) getViewer().getFocusEditPart();
	}

	/**
	* Returns the viewer on which this key handler was created.
	*
	* @return the viewer
	*/
	protected GraphicalViewer getViewer() {
	return viewer;
	}

	/**
	* Extended to process key events described above.
	*
	* @see org.eclipse.gef.KeyHandler#keyPressed(org.eclipse.swt.events.KeyEvent)
	*/
	@Override
	public boolean keyPressed(KeyEvent event) {
	if (event.character == ' ') {
	processSelect(event);
	return true;
	} else if (acceptIntoContainer(event)) {
	navigateIntoContainer(event);
	return true;
	} else if (acceptOutOf(event)) {
	navigateOut(event);
	return true;
	} else if (acceptConnection(event)) {
	navigateConnections(event);
	return true;
	} else if (acceptScroll(event)) {
	scrollViewer(event);
	return true;
	} else if (acceptLeaveConnection(event)) {
	navigateOutOfConnection(event);
	return true;
	} else if (acceptLeaveContents(event)) {
	navigateIntoContainer(event);
	return true;
	} else if (event.character == '[') {
	int found = -1;
	List<GraphicalEditPart> list = getProcessNavigationList();
	for (int i = 0; i < list.size(); i++) {
	if (getFocus() == list.get(i)) {
	found = i;
	break;
	}
	}
	if (found >= 0) {
	found--;
	}
	if (found >=0) {
	EditPart navigateTo = list.get(found);
	navigateTo(navigateTo, event);
	}
	} else if (event.character == ']') {
	int found = -1;
	List<GraphicalEditPart> list = getProcessNavigationList();
	for (int i = 0; i < list.size(); i++) {
	if (getFocus() == list.get(i)) {
	found = i;
	break;
	}
	}
	if (found >= 0) {
	found++;
	}
	if (found < list.size()) {
	EditPart navigateTo = list.get(found);
	navigateTo(navigateTo, event);
	}
	} else if (event.character == '+' \|\| event.character == '=') {
	expand(event);
	} else if (event.character == '-') {
	collapse(event);
	}



	switch (event.keyCode) {
	case SWT.ARROW_LEFT :
	if (navigateNextSibling(event, PositionConstants.WEST))
	return true;
	break;
	case SWT.ARROW_RIGHT :
	if (navigateNextSibling(event, PositionConstants.EAST))
	return true;
	break;
	case SWT.ARROW_UP :
	if (navigateNextSibling(event, PositionConstants.NORTH))
	return true;
	break;
	case SWT.ARROW_DOWN :
	if (navigateNextSibling(event, PositionConstants.SOUTH))
	return true;
	break;

	case SWT.HOME :
	if (navigateJumpSibling(event, PositionConstants.WEST))
	return true;
	break;
	case SWT.END :
	if (navigateJumpSibling(event, PositionConstants.EAST))
	return true;
	break;
	case SWT.PAGE_DOWN :
	if (navigateJumpSibling(event, PositionConstants.SOUTH))
	return true;
	break;
	case SWT.PAGE_UP :
	if (navigateJumpSibling(event, PositionConstants.NORTH))
	return true;
	break;
	case SWT.TAB :
	return true;
	case SWT.F2:
	activateDirectEdit(event);
	break;
	}
	return super.keyPressed(event);
	}

	private void navigateConnections(KeyEvent event) {
	GraphicalEditPart focus = getFocus();
	ConnectionEditPart current = null;
	GraphicalEditPart node = getCachedNode();
	if (focus instanceof ConnectionEditPart) {
	current = (ConnectionEditPart) focus;
	if (node == null
	\|\| (node != current.getSource() && node != current.getTarget())) {
	node = (GraphicalEditPart) current.getSource();
	counter = 0;
	}
	} else {
	node = focus;
	}

	setCachedNode(node);
	boolean forward = event.character == '/' \|\| event.character == '?';
	ConnectionEditPart next = findConnection(node, current, forward);
	navigateTo(next, event);
	}

	private void navigateIntoContainer(KeyEvent event) {
	GraphicalEditPart focus = getFocus();
	List<GraphicalEditPart> childList = getNavigationChildren(focus);
	Point tl = focus.getContentPane().getBounds().getTopLeft();

	int minimum = Integer.MAX_VALUE;
	int current;
	GraphicalEditPart closestPart = null;

	for (int i = 0; i < childList.size(); i++) {
	GraphicalEditPart ged = childList.get(i);
	if (!ged.isSelectable())
	continue;
	Rectangle childBounds = ged.getFigure().getBounds();

	current = (childBounds.x - tl.x) + (childBounds.y - tl.y);
	if (current < minimum) {
	minimum = current;
	closestPart = ged;
	}
	}
	if (closestPart != null)
	navigateTo(closestPart, event);
	}

	private boolean navigateJumpSibling(KeyEvent event, int direction) {
	// TODO: Implement navigateJumpSibling() (for PGUP, PGDN, HOME and END
	// key events)
	return false;
	}

	private boolean navigateNextSibling(KeyEvent event, int direction) {
	return navigateNextSibling(event, direction, getNavigationSiblings());
	}

	boolean navigateNextSibling(KeyEvent event, int direction, List<GraphicalEditPart> list) {
	GraphicalEditPart epStart = getFocus();
	IFigure figure = epStart.getFigure();
	Point pStart = getInterestingPoint(figure);
	figure.translateToAbsolute(pStart);
	EditPart next = findSibling(list, pStart, direction, epStart);
	if (next == null)
	return false;
	navigateTo(next, event);
	return true;
	}

	private void navigateOut(KeyEvent event) {
	EditPart parent = getNavigationParent(getFocus());
	if (getFocus() == null \|\| getFocus() == getViewer().getContents() \|\| getFocus().getParent() == getViewer().getContents())
	return;
	navigateTo(parent, event);
	}

	private void navigateOutOfConnection(KeyEvent event) {
	GraphicalEditPart cached = getCachedNode();
	ConnectionEditPart conn = (ConnectionEditPart) getFocus();
	if (cached != null && (cached == conn.getSource() \|\| cached == conn.getTarget()))
	navigateTo(cached, event);
	else
	navigateTo(conn.getSource(), event);
	}

	void navigateTo(EditPart part, KeyEvent event) {
	if (part == null)
	return;
	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);
	}

	private void processSelect(KeyEvent event) {
	EditPart part = getViewer().getFocusEditPart();
	if ((event.stateMask & SWT.CONTROL) != 0
	&& part.getSelected() != EditPart.SELECTED_NONE)
	getViewer().deselect(part);
	else
	getViewer().appendSelection(part);

	getViewer().setFocus(part);
	}

	private void expand(KeyEvent event) {
	EditPart part = getViewer().getFocusEditPart();
	if (part instanceof CollapsableEditPart) {
	((CollapsableEditPart)part).setCollapsed(false);
	}
	}

	private void collapse(KeyEvent event) {
	EditPart part = getViewer().getFocusEditPart();
	if (part instanceof CollapsableEditPart) {
	((CollapsableEditPart)part).setCollapsed(true);
	}
	}

	private void setCachedNode(GraphicalEditPart node) {
	if (node == null)
	cachedNode = null;
	else
	cachedNode = new WeakReference<GraphicalEditPart>(node);
	}

	/**
	* handles StartNodeEditPart specific behavior
	*/
	protected List<GraphicalEditPart> getNavigationChildren(EditPart part) {
	// if (part instanceof StartNodeEditPart) {
	// // return the process's children
	// ProcessEditPart proc = (ProcessEditPart) part.getParent();
	// List list = proc.getChildren();
	// list.remove(part);
	// return list;
	// }
	// else
	return part.getChildren();
	}

	protected List<GraphicalEditPart> getNavigationSiblings() {
	EditPart focus = getFocus().getParent();
	return focus.getChildren();
	}

	protected EditPart getNavigationParent(EditPart part) {
	EditPart parent = part.getParent();
	if (parent instanceof ProcessEditPart) {
	return null;
	}
	return parent;
	}

	protected void addChildren(EditPart part, List<GraphicalEditPart> list) {
	List<GraphicalEditPart> children = part.getChildren();
	for (int i = 0; i < children.size(); i++) {
	list.add(children.get(i));
	addChildren((children.get(i)), list);
	}
	return;
	}
	/*
	* as a usability enhancement, we want to navigate to the next activity using the SHIFT left and right arrow, this
	* allows the user to navigate to every element on the canvas easily
	*/
	protected List<GraphicalEditPart> getProcessNavigationList() {
	ProcessEditPart process = (ProcessEditPart)viewer.getContents();
	Vector<GraphicalEditPart> all = new Vector<GraphicalEditPart>();
	addChildren(process,all);
	return all;
	}

	protected boolean activateDirectEdit(KeyEvent event) {
	GraphicalEditPart currentPart = (GraphicalEditPart)viewer.getFocusEditPart();
	currentPart.performRequest(new DirectEditRequest());
	return true;
	}

	boolean acceptScroll(KeyEvent event) {
	return ((event.stateMask & SWT.CTRL) != 0 && (event.stateMask & SWT.SHIFT) != 0
	&& (event.keyCode == SWT.ARROW_DOWN \|\| event.keyCode == SWT.ARROW_LEFT
	\|\| event.keyCode == SWT.ARROW_RIGHT \|\| event.keyCode == SWT.ARROW_UP));
	}

	void scrollViewer(KeyEvent event) {
	if (!(getViewer().getControl() instanceof FigureCanvas))
	return;
	FigureCanvas figCanvas = (FigureCanvas)getViewer().getControl();
	Point loc = figCanvas.getViewport().getViewLocation();
	Rectangle area = figCanvas.getViewport().getClientArea(Rectangle.SINGLETON).scale(.1);
	switch (event.keyCode) {
	case SWT.ARROW_DOWN:
	figCanvas.scrollToY(loc.y + area.height);
	break;
	case SWT.ARROW_UP:
	figCanvas.scrollToY(loc.y - area.height);
	break;
	case SWT.ARROW_LEFT:
	figCanvas.scrollToX(loc.x - area.width);
	break;
	case SWT.ARROW_RIGHT:
	figCanvas.scrollToX(loc.x + area.width);
	}
	}
	}