xref: /dports/net-im/convey/convey-src-0.3/src/org/convey/GraphicPanel.java

package org.convey;

import java.util.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import javax.swing.event.*;
import javax.swing.*;
import javax.swing.border.*;
import org.jdom.output.*;
import org.jdom.*;

/**
 * GraphicPanel is a JPanel implementation that manages the Graphic objects.
 * This class provides the link between the Graphic objects and Java Swing's
 * painting and input mechanisms.
 * <p>
 * The GraphicPanel has a state field indicating which mode of interaction the
 * GraphicPanel is in. For example, if the state is SELECT, the user may select
 * existing graphic objects in the panel. One or more graphic objects may be
 * selected simultaneously by clicking them directly or dragging a rectangular
 * selection box.
 * <p>
 * Additionally, in the SELECT state, the user may move the set of selected
 * graphics.
 * <p>
 * In the RECTANGLE state, the user may create rectangles with the mouse by
 * dragging a rectangular regon in the graphic panel. This is known as a
 * graphic creation state.
 * <p>
 * All states except SELECT and VERTEX are considered graphic creation states
 * because these states allow the user to create new graphic objects. When the
 * graphic panel is in a creation state and the user is creating a new graphic,
 * the newGraphic field stores a reference to the new graphic. When the user has
 * completed the graphic creation, the new graphic is added to the Vector of
 * graphic objects and newGraphic is set to null.
 * <p>
 * There are four Vectors of graphic objects: graphics, selectedGraphics, and
 * clipboardGraphics.
 * <p>
 * The graphics Vector consists of all graphic objects that have NOT been sent
 * across the Jabber network. These graphic objects are painted in the graphic
 * panel without a selection border nor selection handles.
 * <p>
 * The selectedGraphic Vector consists of all graphic objects in the SELECTED
 * state and have NOT been sent across the Jabber network. These graphic objects
 * are painted in the graphic panel with a selection border or selection
 * handles. Graphic objects in this Vector are also stored in the graphics
 * Vector.
 * <p>
 * The clipboardGraphics Vector consists of org.jdom.Element references that
 * describe the set of graphic objects that have been cut or copied into the
 * clipboard. This Vector does not actually store Graphic references.
 * <p>
 *
 * @author Andy Ames, Ed Braunhut
 */
public class GraphicPanel extends JPanel
		implements MouseInputListener, KeyListener {

	public static final int SELECT = 0;
	public static final int SCALE = 1;
	public static final int TEXT = 2;
	public static final int RECTANGLE = 3;
	public static final int ELLIPSE = 4;
	public static final int POLYLINE = 5;
	public static final int POLYGON = 6;
	public static final int QUADCURVE = 7;
	public static final int CUBICCURVE = 8;
	public static final int FITTEDCURVE = 9;
	public static final int FREEHANDCURVE = 10;

	private static final int MAX_STATE = 10;

	private transient boolean incoming;

	private transient boolean hasPen;

	protected transient CanvasPanel canvasPanel = null;

	protected transient Graphic newGraphic = null;

	protected Hashtable nameGraphicTable = new Hashtable();

	/**
	 * Vector of all Graphic objects contained in the GraphicPanel. The Graphic
	 * objects are ordered from back to front.
	 */
	protected Vector graphics = new Vector();

	protected transient Vector selectedGraphics = new Vector();

	protected Vector graphicEvents = new Vector();

	protected int lastGraphicEventIndex = -1;

	protected Vector graphicEventStack = new Vector();

	/**
	 * Stores GraphicEvents when auto send is off. They are then sent when auto
	 * send is turned back on, or when the pen is yielded.
	 */
	protected Vector graphicEventQueue = new Vector();

	/**
	 * State of the graphic panel. One of SELECT, VERTEX, TEXT, RECTANGLE, ELLIPSE,
	 * POLYLINE, POLYGON, QUADCURVE, CUBICCURVE, and FITTEDCURVE.
	 */
	protected transient int state;

	/**
	 * Flag indicating if the user is in the process of dragging a rectangular
	 * selection box. This flag is always false when the graphic panel is not in
	 * the SELECT nor the VERTEX state.
	 *
	 * @todo Get rid of this flag. Its redundant.
	 */
	protected transient boolean rectSelecting = false;

	/**
	 * Current rectangular selection area. This Rectangle is null when
	 * rectSelecting is false.
	 */
	protected transient Rectangle selectRect = null;

	/**
	 * Point indicating the last point captured from a mouseDragged event.
	 */
	protected transient Point lastDragPoint;

	/**
	 * Point indicating the last point captured from a mousePressed event.
	 */
	protected transient Point pressPoint;

	protected transient Graphic vertexSelected = null;

	protected boolean autoSend;

	/**
	 * Set white for the background color. Set up mouse and key listeners.
	 */
	public GraphicPanel(CanvasPanel canvasPanel) {
		super.setBorder(new SoftBevelBorder(SoftBevelBorder.LOWERED));
		this.incoming = false;

		super.setBackground(Color.white);

		this.canvasPanel = canvasPanel;

		super.addMouseListener(this);
		super.addMouseMotionListener(this);
		super.addKeyListener(this);

		this.hasPen = true;
	}

	public void setHasPen(boolean value) {
		CanvasPanel canvasPanel = this.getCanvasPanel();
		if(canvasPanel instanceof JabberCanvasPanel) {
			JabberCanvasPanel jabberCanvasPanel = (JabberCanvasPanel)canvasPanel;
			jabberCanvasPanel.getConveyFrame().changePenIcon(jabberCanvasPanel, value);
		}
		this.hasPen = value;
	}

	public boolean hasPen() {
		return this.hasPen;
	}

	public boolean isIncoming() {
		return this.incoming;
	}

	public void setIncoming(boolean incoming) {
		this.incoming = incoming;
	}

	/**
	 * Paints the GraphicPanel component by painting all Graphic objects.
	 * <p>
	 * First, the lockedGraphics Vector graphic objects are painted. Second, the
	 * graphics Vector graphic objects are painted.
	 * <p>
	 * Third, if newGraphic is valid, it is painted. Otherwise, the
	 * selectedGraphics Vector graphic objects have their selection painted.
	 * <p>
	 * Finally, if rectSelecting is true, the selectRect rectangle is painted.
	 */
	public void paintComponent(Graphics g) {
		super.paintComponent(g);

		Graphics2D g2d = (Graphics2D)g;

		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

		Iterator iter = this.graphics.iterator();
		while (iter.hasNext()) {
			Graphic graphic = (Graphic) iter.next();
			graphic.paint(g2d);
			if (graphic.getState() == Graphic.SELECTED)
				graphic.paintSelection(g2d);
		}

		if(this.newGraphic != null) {
			this.newGraphic.paint(g2d);
			if(this.newGraphic instanceof TextGraphic)
				this.newGraphic.paintSelection(g2d);
		}

		if(rectSelecting) {
			g2d.setStroke(new BasicStroke(1));
			g2d.setColor(Color.gray);
			g2d.draw(selectRect);
		}

		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
	}

	public Iterator graphicIterator() {
		return this.graphics.iterator();
	}

	/**
	 * Sets the state of the graphicPanel. Possible states are SELECT, VERTEX,
	 * TEXT, RECTANGLE, ELLIPSE, POLYLINE, POLYGON, QUADCURVE, CUBICCURVE,
	 * FITTEDCURVE and FREEHANDCURVE.
	 * <p>
	 * Currently, we are repainting the entire graphic panel when this happens.
	 *
	 * @todo Identify what needs to be repainted when. Only repaint in those
	 *       cases.
	 */
	void setState(int state) {
		if(state <= MAX_STATE && state >= 0 && state != this.state) {
			this.state = state;
			super.repaint();
		}
	}

	/**
	 * Gets the state of the graphicPanel. Possible states are SELECT, VERTEX,
	 * TEXT, RECTANGLE, ELLIPSE, POLYLINE, POLYGON, QUADCURVE, CUBICCURVE,
	 * FITTEDCURVE and FREEHANDCURVE.
	 */
	int getState() {
		return this.state;
	}

	public void deselectAll() {
		Vector oldSelectedGraphics = this.selectedGraphics;
		this.selectedGraphics = new Vector();

		Iterator iter = oldSelectedGraphics.iterator();
		while(iter.hasNext()) {
			Graphic graphic = (Graphic)iter.next();
			graphic.setState(Graphic.DORMANT);
		}

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	/**
	 * Invoked when a mouse button has been pressed on the graphic panel.
	 * <p>
	 * Depending on the state of the graphic panel, this event may or may not
	 * be forwarded to one or more graphic objects.
	 * <p>
	 * For example, if the state is a graphic creation state and the newGraphic
	 * field is non-null, then the newGraphic receives this event.
	 * <p>
	 * If the newGraphic field is null, some graphic creation states will have
	 * a new graphic created in response to this method. Other graphic creation
	 * states have a new graphic created in response to mouseClicked.
	 * <p>
	 * Currently, the following graphic creation states require a mousePressed to
	 * begin the creation process: RECTANGLE, ELLIPSE, FITTEDCURVE and FREEHANDCURVE.
	 */
	public void mousePressed(MouseEvent e) {
		Iterator iter;

		super.requestFocus();

		if(this.hasPen && this.newGraphic != null && this.newGraphic instanceof TextGraphic) {
			if(!this.newGraphic.hitPath(e.getPoint())) {
				((TextGraphic)this.newGraphic).setCursor(-1);
				this.newGraphic.setState(Graphic.DORMANT);
				this.addGraphic(this.newGraphic);
				this.addGraphicEvent(new NewGraphicEvent(this.newGraphic));
				this.newGraphic = null;
			}
		}

		if(this.hasPen && this.newGraphic != null) {
			this.newGraphic.mousePressed(e);

			if(newGraphic.getState() != Graphic.CREATING) {

				// if newGraphic is no longer in CREATING state after processing event,
				// add the newGraphic to the graphics Vector
				this.addGraphic(this.newGraphic);
				this.newGraphic.setState(Graphic.SELECTED);
				this.addGraphicEvent(new NewGraphicEvent(this.newGraphic));
				this.newGraphic = null;
			}
		} else {

			Point p = e.getPoint();

			// if newGraphic is null...

			if(this.hasPen && this.state != SELECT && this.state != SCALE) {

				// Check if we hit a vertex of a selected graphic. If so, pop ourselves
				// into SELECT state and carry on.

				Graphic graphic = this.hitGraphic(p);
				if(graphic != null && graphic.getState() == Graphic.SELECTED && graphic.hitVertex(p)) {
					this.vertexSelected = graphic;
					graphic.setOrig();
					graphic.mousePressed(e);
					return;
				}

				// If we're not in SELECT or VERTEX states (we are in a graphic creation
				// state) we're about to create a new Graphic, deselect everyone.
				deselectAll();
			}

			switch(this.state) {
				case SELECT:
					Graphic selected = null;
					this.vertexSelected = null;

					if(!e.isControlDown() && !e.isAltDown() &&
						 !e.isShiftDown() && !e.isMetaDown()) {

						// If we are single-selecting...

						// What graphic got hit?
						selected = hitGraphic(p);

						if(selected != null) {
							// if a graphic was hit...

							if(selected.getState() == Graphic.DORMANT) {

								// If the hit graphic was previously DORMANT, deselect all
								deselectAll();

								// select hit graphic
								selected.setState(Graphic.SELECTED);
							} else if(selected.hitVertex(p))
								this.vertexSelected = selected;
						} else {

							// If a graphic was not hit, deselect all
							deselectAll();

							// Enter rectangular select mode
							rectSelecting = true;
							selectRect = new Rectangle(p);
							lastDragPoint = pressPoint = p;
						}
					} else {

						// If we are multi-selecting...

						// What graphic got hit?
						selected = hitGraphic(p);

						if(selected != null) {

							// If a graphic got hit...

							if(selected.getState() == Graphic.DORMANT) {

								// If the hit graphic was previously DORMANT, add it to the
								// selectedGraphics Vector.
								selected.setState(Graphic.SELECTED);
							} else {

								// If the hit graphic was previously SELECTED, remove it from
								// the selectedGraphics Vector.
								selected.setState(Graphic.DORMANT);
							}
						} else {

							// If a graphic was NOT hit, enter rectangular select mode
							rectSelecting = true;
							selectRect = new Rectangle(p);
							lastDragPoint = pressPoint = p;
						}
					}

					// Finally, we give all selected Graphic objects the mousePressed
					// event only if vertexOnly is false...
					if(this.hasPen && this.vertexSelected == null) {
						iter = this.selectedGraphics.iterator();
						while(iter.hasNext()) {
							Graphic graphic = (Graphic)iter.next();
							graphic.setOrig();
							graphic.mousePressed(e);
						}
					} else if(this.hasPen) {
						vertexSelected.setOrig();
						vertexSelected.mousePressed(e);
					}

					break;
				case SCALE:
					selected = hitGraphic(p);

					deselectAll();

					if(selected != null) {
						selected.setState(Graphic.SELECTED);
						if(this.hasPen) {
							selected.setOrig();
							selected.mousePressed(e);
						}
					}
					break;
				case RECTANGLE:
					if(this.hasPen) {
						QuadGraphic quadGraphic = new QuadGraphic(this, e.getPoint());
						this.newGraphic = quadGraphic;
					}
					break;
				case ELLIPSE:
					if(this.hasPen) {
						EllipseGraphic ellipseGraphic = new EllipseGraphic(this, e.getPoint());
						this.newGraphic = ellipseGraphic;
					}
					break;
				case FITTEDCURVE:
					if(this.hasPen) {
						FittedCurveGraphic curveGraphic = new FittedCurveGraphic(this, e.getPoint());
						this.newGraphic = curveGraphic;
					}
					break;
				case FREEHANDCURVE:
					if(this.hasPen) {
						FreehandGraphic freeGraphic = new FreehandGraphic(this, e.getPoint());
						this.newGraphic = freeGraphic;
					}
					break;
			}
		}

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	/**
	 * Invoked when a mouse button has been released.
	 */
	public void mouseReleased(MouseEvent e) {
		if(rectSelecting) {

			// If we were selecting a rectangular region...

			Iterator iter = graphics.iterator();
			while(iter.hasNext()) {
				Graphic graphic = (Graphic) iter.next();
				if(graphic.hitPath(selectRect) && graphic.getState() != Graphic.SELECTED)
					graphic.setState(Graphic.SELECTED);
			}
			rectSelecting = false;
			selectRect.grow(5, 5);
			super.repaint(selectRect);
		} else if(this.hasPen && newGraphic != null) {
			newGraphic.mouseReleased(e);
			if(newGraphic.getState() == Graphic.DELETE) {
				Graphic graphic = this.newGraphic;
				this.newGraphic = null;
				graphic.forceRepaint();
			} else if(newGraphic.getState() != Graphic.CREATING) {
				this.addGraphic(this.newGraphic);
				this.newGraphic.setState(Graphic.SELECTED);
				this.addGraphicEvent(new NewGraphicEvent(this.newGraphic));
				this.newGraphic = null;
			}
		} else if(this.hasPen && this.vertexSelected == null) {
			Iterator iter = this.selectedGraphics.iterator();
			while(iter.hasNext()) {
				Graphic graphic = (Graphic)iter.next();
				graphic.mouseReleased(e);
			}
		} else if(this.hasPen) {
			this.vertexSelected.mouseReleased(e);
			this.vertexSelected = null;
		}

		GraphicEvent event = this.popAllGraphicEvents();
		if(event != null)
			this.addGraphicEvent(event);

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	/**
	 * Invoked when the mouse has been clicked on a component.
	 */
	public void mouseClicked(MouseEvent e) {
		if(!this.hasPen && !this.isIncoming())
			return;

		if(newGraphic != null) {
			newGraphic.mouseClicked(e);
			if(newGraphic.getState() != Graphic.CREATING) {
				this.addGraphic(this.newGraphic);
				this.newGraphic.setState(Graphic.SELECTED);
				this.addGraphicEvent(new NewGraphicEvent(this.newGraphic));
				this.newGraphic = null;
			}
		} else {
			switch(this.state) {
				case SELECT:
				case SCALE:
					Iterator iter = this.selectedGraphics.iterator();
					while(iter.hasNext()) {
						Graphic graphic = (Graphic)iter.next();
						graphic.mouseClicked(e);
					}
					if(e.getClickCount() == 2) {
						Graphic hitGraphic = this.hitGraphic(e.getPoint());
						if(hitGraphic instanceof TextGraphic) {
							TextGraphic textGraphic = (TextGraphic)hitGraphic;

							this.deselectAll();

							this.addSelectedGraphic(textGraphic);

							textGraphic.edit(e.getPoint());
						}
					}
					break;
				case TEXT:
					TextGraphic textGraphic = new TextGraphic(this, new Point(e.getX(), e.getY()));
					this.newGraphic = textGraphic;
					break;
				case POLYGON:
					PolygonGraphic polygonGraphic = new PolygonGraphic(this, e.getPoint());
					this.newGraphic = polygonGraphic;
					break;
				case POLYLINE:
					PolylineGraphic polylineGraphic = new PolylineGraphic(this, e.getPoint());
					this.newGraphic = polylineGraphic;
					break;
				case QUADCURVE:
					QuadCurveGraphic quadCurveGraphic = new QuadCurveGraphic(this, e.getPoint());
					this.newGraphic = quadCurveGraphic;
					break;
				case CUBICCURVE:
					CubicCurveGraphic cubicCurveGraphic = new CubicCurveGraphic(this, e.getPoint());
					this.newGraphic = cubicCurveGraphic;
					break;
			}
		}

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	/**
	* Invoked when a mouse button is pressed on a component and then
	* dragged.  Mouse drag events will continue to be delivered to
	* the component where the first originated until the mouse button is
	* released (regardless of whether the mouse position is within the
	* bounds of the component).
	*/
	public void mouseDragged(MouseEvent e) {
		if(rectSelecting) {
			Point p = e.getPoint();
			Rectangle newRectangle = new Rectangle(Math.min(pressPoint.x, p.x),
													 Math.min(pressPoint.y, p.y),
													 Math.abs(pressPoint.x - p.x),
													 Math.abs(pressPoint.y - p.y));
			Rectangle dirty = newRectangle.union(selectRect);
			selectRect = newRectangle;
			dirty.grow(5, 5);
			super.repaint(dirty);
		} else if(this.hasPen) {
			if(newGraphic != null) {
				newGraphic.mouseDragged(e);
				if(newGraphic.getState() != Graphic.CREATING) {
					this.addGraphic(this.newGraphic);
					this.newGraphic.setState(Graphic.SELECTED);
					this.addGraphicEvent(new NewGraphicEvent(this.newGraphic));
					this.newGraphic = null;
				}
			} else if(this.vertexSelected == null) {
				Iterator iter = this.selectedGraphics.iterator();
				while(iter.hasNext()) {
					Graphic graphic = (Graphic) iter.next();
					graphic.mouseDragged(e);
				}
			} else
				this.vertexSelected.mouseDragged(e);
		}
	}

	/**
	 * Invoked when the mouse button has been moved on a component
	 * (with no buttons or mouse buttons pressed)
	 */
	public void mouseMoved(MouseEvent e) {
		if(!this.hasPen && !this.isIncoming())
			return;

		if(newGraphic != null) {
			newGraphic.mouseMoved(e);
			int state = this.newGraphic.getState();
			if(state != Graphic.CREATING) {
				this.addGraphic(this.newGraphic);
				this.newGraphic.setState(Graphic.SELECTED);
				this.addGraphicEvent(new NewGraphicEvent(this.newGraphic));
				this.newGraphic = null;
			}
		} else {
			Iterator iter = this.selectedGraphics.iterator();
			while(iter.hasNext()) {
				Graphic graphic = (Graphic)iter.next();
				graphic.mouseMoved(e);
			}
		}
	}

		/**
	 * Invoked when the mouse exits a component.
	 */
	public void mouseExited(MouseEvent e) {}

		/**
		 * Invoked when the mouse enters a component.
	 */
	public void mouseEntered(MouseEvent e) {}

	/**
	 * Invoked when a key has been typed. This event occurs when a key press is
	 * followed by a key release.
	 */
	public void keyTyped(KeyEvent e) {
		if(!this.hasPen && !this.isIncoming())
			return;

		if(this.newGraphic != null && this.newGraphic instanceof TextGraphic) {
			TextGraphic textGraphic = (TextGraphic)this.newGraphic;
			textGraphic.keyTyped(e);
			if(textGraphic.getState() != Graphic.CREATING) {
				this.addGraphic(this.newGraphic);
				this.addGraphicEvent(new NewGraphicEvent(this.newGraphic));
				this.newGraphic.setState(Graphic.SELECTED);
				this.newGraphic = null;
			}
		} else {
			if(this.selectedGraphics.size() == 1 && this.selectedGraphics.elementAt(0) instanceof TextGraphic) {
				TextGraphic textGraphic = (TextGraphic)this.selectedGraphics.elementAt(0);
				textGraphic.keyTyped(e);
			}
		}
	}

	/**
	 * Invoked when a key has been pressed.
	 */
	public void keyPressed(KeyEvent e) {
		if(!this.hasPen && !this.isIncoming())
			return;

		if(this.newGraphic != null && this.newGraphic instanceof TextGraphic) {
			TextGraphic textGraphic = (TextGraphic)this.newGraphic;
			textGraphic.keyPressed(e);
			if(textGraphic.getState() != Graphic.CREATING) {
				this.addGraphic(this.newGraphic);
				this.addGraphicEvent(new NewGraphicEvent(this.newGraphic));
				this.newGraphic.setState(Graphic.SELECTED);
				this.newGraphic = null;
			}
		} else if(this.selectedGraphics.size() == 1 && this.selectedGraphics.elementAt(0) instanceof TextGraphic) {
			TextGraphic textGraphic = (TextGraphic)this.selectedGraphics.elementAt(0);
			textGraphic.keyPressed(e);
		}
	}

	/**
	 * Invoked when a key has been released.
	 */
	public void keyReleased(KeyEvent e) {
		if(!this.hasPen && !this.isIncoming())
			return;
	}

	/**
	 * Method iterates through the vector of all graphics in the graphicPanel
	 * and creates a new vectosr of the selected ones, which replaces the selected
	 * graphics as a single component of the vector of all graphics.
	 */
	public void editGroup() {
		if(!this.hasPen && !this.isIncoming())
			return;

		GroupGraphic group = new GroupGraphic(this);

			Vector oldSelectedGraphics = this.selectedGraphics;
			this.selectedGraphics = new Vector();

		Iterator iter = oldSelectedGraphics.iterator();
		while (iter.hasNext()) {
			Graphic graphic = (Graphic) iter.next();

			graphic.setState(Graphic.DORMANT);
			this.graphics.remove(graphic);

			group.addGraphic(graphic);
		}

		this.addGraphic(group);
		group.setState(Graphic.SELECTED);

		group.updateCache();

		if(!this.isIncoming())
			this.addGraphicEvent(new GroupGraphicEvent(group, GroupGraphicEvent.TYPE_GROUP));

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	public void editUngroup() {
		if(!this.hasPen && !this.isIncoming())
			return;

		GroupGraphic group = (GroupGraphic)this.selectedGraphics.elementAt(0);

		if(this.state == SCALE)
			this.setState(SELECT);

		// Do the following three in this order so the GroupGraphic gets repainted
		this.selectedGraphics.clear();
		this.removeGraphic(group);

		Iterator iter = group.iterator();

		while(iter.hasNext()) {
			Graphic graphic = (Graphic)iter.next();

			graphic.setState(Graphic.SELECTED);

			this.graphics.add(graphic);
		}

		this.canvasPanel.getConveyFrame().updateButtons();

		if(!this.isIncoming())
			this.addGraphicEvent(new GroupGraphicEvent(group, GroupGraphicEvent.TYPE_UNGROUP));
	}

	public void editCut() {
		if(!this.hasPen && !this.isIncoming())
			return;

		this.canvasPanel.getConveyFrame().getClipboardGraphics().removeAllElements();

		Vector oldSelectedGraphics = this.selectedGraphics;
		this.selectedGraphics = new Vector();

		Vector graphicEvents = new Vector();

		Iterator iter = oldSelectedGraphics.iterator();
		while(iter.hasNext()) {
			Graphic graphic = (Graphic)iter.next();

			// Do the following two in this order so the Graphic gets erased
			this.removeGraphic(graphic);

			this.canvasPanel.getConveyFrame().getClipboardGraphics().add(graphic.toElement());

			graphicEvents.add(new DeleteGraphicEvent(graphic));
		}

		if(graphicEvents.size() > 1)
			this.addGraphicEvent(new CompositeGraphicEvent(graphicEvents));
		else if(graphicEvents.size() == 1)
			this.addGraphicEvent((GraphicEvent)graphicEvents.elementAt(0));

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	public void editCopy() {
		Graphic graphic;
		this.canvasPanel.getConveyFrame().getClipboardGraphics().removeAllElements();
		Iterator iter = this.selectedGraphics.iterator();
		while (iter.hasNext()) {
			graphic = (Graphic)iter.next();
			this.canvasPanel.getConveyFrame().getClipboardGraphics().add(graphic.toElement());
		}
		this.canvasPanel.getConveyFrame().updateButtons();
	}

	public void editPaste() {
		if(!this.hasPen && !this.isIncoming())
			return;

		Graphic graphic;

		deselectAll();

		Vector graphicEvents = new Vector();

		Iterator iter = this.canvasPanel.getConveyFrame().getClipboardGraphics().iterator();
		while(iter.hasNext()) {
			graphic = this.createGraphicFromSVGElement((Element)iter.next());

			this.addGraphic(graphic);
			graphic.setGraphicPanel(this);

			graphic.setState(Graphic.SELECTED);

			graphic.updateCache();

			graphicEvents.add(new NewGraphicEvent(graphic));
		}

		if(graphicEvents.size() > 1)
			this.addGraphicEvent(new CompositeGraphicEvent(graphicEvents));
		else if(graphicEvents.size() == 1)
			this.addGraphicEvent((GraphicEvent)graphicEvents.elementAt(0));

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	public void editDelete() {
		if(!this.hasPen && !this.isIncoming())
			return;

		// Hack to avoid deleting a TextGraphic while it is in edit mode. When in
		// edit mode, we want the TextGraphic to handle the delete key press.
		if(this.selectedGraphics.size() == 1 && this.selectedGraphics.elementAt(0) instanceof TextGraphic)
			if(((TextGraphic)this.selectedGraphics.elementAt(0)).getCursor() != -1)
				return;

		Vector graphicEvents = new Vector();

		Vector oldSelectedGraphics = this.selectedGraphics;
		this.selectedGraphics = new Vector();

		Iterator iter = oldSelectedGraphics.iterator();
		while(iter.hasNext()) {
			Graphic graphic = (Graphic)iter.next();

			// Do the following two in this order so the Graphic gets erased
			this.removeGraphic(graphic);

			graphicEvents.add(new DeleteGraphicEvent(graphic));
		}

		if(graphicEvents.size() > 1)
			this.addGraphicEvent(new CompositeGraphicEvent(graphicEvents));
		else if(graphicEvents.size() == 1)
			this.addGraphicEvent((GraphicEvent)graphicEvents.elementAt(0));

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	public void editClear() {
		if(!this.hasPen && !this.isIncoming())
			return;

		Vector oldGraphics = this.graphics;
		this.graphics = new Vector();

		Vector graphicEvents = new Vector();

		Iterator iter = oldGraphics.iterator();
		while(iter.hasNext()) {
			Graphic graphic = (Graphic)iter.next();

			graphic.setState(Graphic.DORMANT);

			graphicEvents.add(new DeleteGraphicEvent(graphic));
		}

		if(graphicEvents.size() > 1)
			this.addGraphicEvent(new CompositeGraphicEvent(graphicEvents));
		else if(graphicEvents.size() == 1)
			this.addGraphicEvent((GraphicEvent)graphicEvents.elementAt(0));

		this.canvasPanel.getConveyFrame().updateButtons();

		super.repaint();
	}

	public void handleConveyElement(Element conveyElement) {
		this.setIncoming(true);
		Iterator iter = conveyElement.getChildren().iterator();

		while(iter.hasNext()) {
			Element element = (Element)iter.next();

			handleGraphicEventElement(element);
		}
		this.setIncoming(false);

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	/**
	 * @todo Implement EllipseGraphicEvent and QuadGraphicEvent handling. They
	 * weren't implemented yet because we still cannot even modify them via
	 * vertex manipulation. This are no longer necessary because these events
	 * are implemented via fitToRect().
	 */
	public void handleGraphicEventElement(Element element) {
		String name = element.getName();

		if(name.equals("new")) {
			Iterator childIter = element.getChildren().iterator();
			while(childIter.hasNext()) {
				Element svgElement = (Element)childIter.next();
				Graphic graphic = this.createGraphicFromSVGElement(svgElement);

				this.addGraphic(graphic);
				graphic.setState(Graphic.DORMANT);
			}
		} else if(name.equals("name")) {
			Graphic graphic = (Graphic)this.nameGraphicTable.get(element.getAttributeValue("old"));
			if(graphic == null)
				return;
			graphic.setName(element.getAttributeValue("new"));
		} else if(name.equals("composite")) {
			Iterator iter = element.getChildren().iterator();
			while(iter.hasNext())
				this.handleGraphicEventElement((Element)iter.next());
		} else if(name.equals("group")) {
			this.deselectAll();
			switch(Integer.parseInt(element.getAttributeValue("type"))) {
				case GroupGraphicEvent.TYPE_GROUP:
					Iterator iter = element.getChildren().iterator();
					while(iter.hasNext()) {
						Element childElement = (Element)iter.next();
						Graphic g = (Graphic)this.nameGraphicTable.get(childElement.getAttributeValue("name"));
						if(g == null)
							return;
						g.setState(Graphic.SELECTED);
					}
					this.editGroup();
					break;
				case GroupGraphicEvent.TYPE_UNGROUP:
					Graphic g = (Graphic)this.nameGraphicTable.get(element.getAttributeValue("name"));
					if(g == null)
						return;
					g.setState(Graphic.SELECTED);
					this.editUngroup();
					break;
			}
		} else {
			Graphic g = (Graphic)this.nameGraphicTable.get(element.getAttributeValue("name"));
			if(g == null)
				return;

			if(name.equals("shape")) {
				ShapeGraphic graphic = (ShapeGraphic) g;
				switch (Integer.parseInt(element.getAttributeValue("type"))) {
					case ShapeGraphicEvent.TYPE_FILL:
						graphic.setFillColor(ShapeGraphic.stringToColor(element.getAttributeValue("newColor")));
						break;
					case ShapeGraphicEvent.TYPE_STROKE:
						graphic.setStrokeColor(ShapeGraphic.stringToColor(element.getAttributeValue("newColor")));
						break;
				}
			}
			else if(name.equals("delete"))
				this.removeGraphic(g);
			else if(name.equals("translate"))
				g.translate(Integer.parseInt(element.getAttributeValue("x")),
										Integer.parseInt(element.getAttributeValue("y")));
			else if(name.equals("fitToRect")) {
				Element newRect = element.getChild("new");
				g.setOrig();
				g.fitToRect(new Rectangle(Integer.parseInt(newRect.getAttributeValue("x")),
																	Integer.parseInt(newRect.getAttributeValue("y")),
																	Integer.parseInt(newRect.getAttributeValue("w")),
																	Integer.parseInt(newRect.getAttributeValue("h"))));
			} else if (name.equals("polyline")) {
				PolylineGraphic graphic = (PolylineGraphic) g;
				Vector points = graphic.getPoints();
				Point2D p = (Point2D) points.elementAt(Integer.parseInt(element.getAttributeValue("index")));
				Element pElement = element.getChild("new");
				p.setLocation(Double.parseDouble(pElement.getAttributeValue("x")),
											Double.parseDouble(pElement.getAttributeValue("y")));
				graphic.setPoints(points);
			} else if (name.equals("polygon")) {
				PolygonGraphic graphic = (PolygonGraphic) g;
				Vector points = graphic.getPoints();
				Point2D p = (Point2D) points.elementAt(Integer.parseInt(element.getAttributeValue("index")));
				Element pElement = element.getChild("new");
				p.setLocation(Double.parseDouble(pElement.getAttributeValue("x")),
											Double.parseDouble(pElement.getAttributeValue("y")));
				graphic.setPoints(points);
			} else if (name.equals("cubicCurve")) {
				CubicCurveGraphic graphic = (CubicCurveGraphic) g;
				Element pElement = element.getChild("new");
				CubicCurve2D curve = new CubicCurve2D.Double(Double.parseDouble(pElement.getAttributeValue("x1")),
						Double.parseDouble(pElement.getAttributeValue("y1")),
						Double.parseDouble(pElement.getAttributeValue("ctrlx1")),
						Double.parseDouble(pElement.getAttributeValue("ctrly1")),
						Double.parseDouble(pElement.getAttributeValue("ctrlx2")),
						Double.parseDouble(pElement.getAttributeValue("ctrly2")),
						Double.parseDouble(pElement.getAttributeValue("x2")),
						Double.parseDouble(pElement.getAttributeValue("y2")));
				graphic.setCurve(curve);
			} else if(name.equals("quadCurve")) {
				QuadCurveGraphic graphic = (QuadCurveGraphic) g;
				Element pElement = element.getChild("new");
				QuadCurve2D curve = new QuadCurve2D.Double(Double.parseDouble(pElement.getAttributeValue("x1")),
						Double.parseDouble(pElement.getAttributeValue("y1")),
						Double.parseDouble(pElement.getAttributeValue("ctrlx")),
						Double.parseDouble(pElement.getAttributeValue("ctrly")),
						Double.parseDouble(pElement.getAttributeValue("x2")),
						Double.parseDouble(pElement.getAttributeValue("y2")));
				graphic.setCurve(curve);
			} else if(name.equals("text")) {
				TextGraphic graphic = (TextGraphic)g;
				Element newChild = element.getChild("new");
				graphic.setText(newChild.getText());
				graphic.setTextColor(Graphic.stringToColor(newChild.getAttributeValue("color")));
			} else if(name.equals("position")) {
				this.removeGraphic(g);
				this.insertGraphic(g, Integer.parseInt(element.getAttributeValue("newIndex")));
			}
		}

		super.repaint();
	}

	public Graphic createGraphicFromSVGElement(Element element) {
		Graphic graphic = null;
		String name = element.getName();
		if(name.equals("g"))
			graphic = new GroupGraphic(this);
		else if(name.equals("path")) {
			String d = element.getAttributeValue("d");
			for(int i = 0; i < d.length(); i++) {
				if(d.charAt(i) == 'Q')
					graphic = new QuadCurveGraphic(this);
				else if(d.charAt(i) == 'C') {
					graphic = new CubicCurveGraphic(this);
				} else if (d.charAt(i) == 'M')  {
					graphic = new FreehandGraphic(this);
				}
			}
		} else if(name.equals("rect"))
			graphic = new QuadGraphic(this);
		else if(name.equals("ellipse"))
			graphic = new EllipseGraphic(this);
		else if(name.equals("polyline"))
			graphic = new PolylineGraphic(this);
		else if(name.equals("polygon"))
			graphic = new PolygonGraphic(this);
		else if(name.equals("text"))
			graphic = new TextGraphic(this);

		if(graphic != null)
			graphic.fromElement(element);

		return graphic;
	}

	protected Graphic hitGraphic(Point p) {
		if(this.graphics.size() == 0)
			return null;

		ListIterator iter = this.graphics.listIterator(this.graphics.size());
		while(iter.hasPrevious()) {
			Graphic graphic = (Graphic)iter.previous();
			if(graphic.hitPath(p) || graphic.hitVertex(p))
				return graphic;
		}

		return null;
	}

	public int graphicCount() {
		return this.graphics.size();
	}

	public int selectedGraphicCount() {
		return this.selectedGraphics.size();
	}

	public Graphic selectedGraphic(int index) {
		return (Graphic)this.selectedGraphics.elementAt(index);
	}

	public void selectAll() {
		Iterator iter = this.graphics.iterator();
		while(iter.hasNext()) {
			Graphic graphic = (Graphic)iter.next();
			graphic.setState(Graphic.SELECTED);
		}

		this.canvasPanel.getConveyFrame().updateButtons();
	}

	public void pushGraphicEvent(GraphicEvent event) {
		this.graphicEventStack.add(event);
	}

	public GraphicEvent popAllGraphicEvents() {
		if(this.graphicEventStack.size() == 0)
			return null;
		else if(this.graphicEventStack.size() == 1) {
			GraphicEvent event = (GraphicEvent)this.graphicEventStack.elementAt(0);
			this.graphicEventStack.clear();
			return event;
		}

		CompositeGraphicEvent event = new CompositeGraphicEvent(this.graphicEventStack);
		this.graphicEventStack = new Vector();
		return event;
	}

	public void addGraphicEvent(GraphicEvent event) {
		if(this.lastGraphicEventIndex < this.graphicEvents.size() - 1) {
			while(this.lastGraphicEventIndex < this.graphicEvents.size() - 1)
				this.graphicEvents.remove(this.graphicEvents.size() - 1);
		}
		this.graphicEvents.add(event);
		this.lastGraphicEventIndex++;

		if(this.getCanvasPanel().getConveyFrame().isAutoSend()) {
			if(this.canvasPanel instanceof JabberCanvasPanel) {
				JabberCanvasPanel panel = (JabberCanvasPanel)this.canvasPanel;
				panel.sendGraphicEvent(event);
			}
		} else
			graphicEventQueue.add(event);
	}

	public void flushGraphicEventQueue() {
		if(this.canvasPanel instanceof JabberCanvasPanel) {
			if(this.graphicEventQueue.size() == 0)
				return;
			else if(this.graphicEventQueue.size() == 1) {
				GraphicEvent event = (GraphicEvent)this.graphicEventQueue.elementAt(0);
				this.graphicEventQueue.clear();
				JabberCanvasPanel panel = (JabberCanvasPanel)this.canvasPanel;
				panel.sendGraphicEvent(event);
			}

			CompositeGraphicEvent event = new CompositeGraphicEvent(this.graphicEventQueue);
			this.graphicEventQueue = new Vector();
			JabberCanvasPanel panel = (JabberCanvasPanel)this.canvasPanel;
			panel.sendGraphicEvent(event);
		}
	}

	protected void undoGraphicEvent(GraphicEvent event) {
		if(event instanceof CompositeGraphicEvent) {
			Iterator iter = ((CompositeGraphicEvent)event).getGraphicEvents().iterator();
			while(iter.hasNext()) {
				event = (GraphicEvent)iter.next();
				this.undoGraphicEvent(event);
			}
		} else {
			Graphic graphic = event.getGraphic();
			graphic.undoGraphicEvent(event);
		}
	}

	public void editUndo() {
		if(!this.hasPen && !this.isIncoming())
			return;

		if(this.lastGraphicEventIndex > -1) {
			GraphicEvent event = (GraphicEvent)this.graphicEvents.elementAt(this.lastGraphicEventIndex);
			this.undoGraphicEvent(event);
			lastGraphicEventIndex--;
		}
		this.canvasPanel.getConveyFrame().updateButtons();
	}

	protected void redoGraphicEvent(GraphicEvent event) {
		if(event instanceof CompositeGraphicEvent) {
			Iterator iter = ((CompositeGraphicEvent)event).getGraphicEvents().iterator();
			while(iter.hasNext()) {
				event = (GraphicEvent)iter.next();
				this.redoGraphicEvent(event);
			}
		} else {
			Graphic graphic = event.getGraphic();
			graphic.redoGraphicEvent(event);
		}
	}

	public void editRedo() {
		if(!this.hasPen && !this.isIncoming())
			return;

		if(this.lastGraphicEventIndex < this.graphicEvents.size() - 1) {
			this.lastGraphicEventIndex++;
			GraphicEvent event = (GraphicEvent)this.graphicEvents.elementAt(this.lastGraphicEventIndex);
			this.redoGraphicEvent(event);
		}
		this.canvasPanel.getConveyFrame().updateButtons();
	}

	public Vector getGraphicEvents() {
		return this.graphicEvents;
	}

	public int getLastGraphicEventIndex() {
		return this.lastGraphicEventIndex;
	}

	public void removeGraphic(Graphic graphic) {
		if(this.nameGraphicTable.containsKey(graphic.getName()))
			this.nameGraphicTable.remove(graphic.getName());
		if(this.graphics.contains(graphic))
			this.graphics.remove(graphic);

		graphic.setState(Graphic.DORMANT);
		graphic.forceRepaint();
	}

	public void addGraphic(Graphic graphic) {
		this.insertGraphic(graphic, this.graphics.size());
	}

	public void insertGraphic(Graphic graphic, int index) {
		if(!this.nameGraphicTable.containsKey(graphic.getName()))
			this.nameGraphicTable.put(graphic.getName(), graphic);
		else {
			String origName = graphic.getName();
			int i;
			for(i = origName.length() - 1; i >= 0; i--) {
				if(!Character.isDigit(origName.charAt(i))) {
					origName = origName.substring(0, i + 1);
					break;
				}
			}
			if(i == 0)
				origName = "";
			for(i = 1; i < Integer.MAX_VALUE; i++) {
				String tryName = origName + String.valueOf(i);
				if(!this.nameGraphicTable.containsKey(tryName)) {

					// This breaks OOP ideology. We are accessing a protected member
					// of another class in this package. We are doing this because we
					// do not want to send the Name change graphic event across the
					// network before we have sent the NewGraphicEvent.
					//
					// We need a more elegant solution.
					graphic.name = tryName;
					this.nameGraphicTable.put(tryName, graphic);
					break;
				}
			}
		}

		if(!this.graphics.contains(graphic))
			this.graphics.insertElementAt(graphic, index);

		graphic.setState(Graphic.DORMANT);
		graphic.forceRepaint();
	}

	public void addSelectedGraphic(Graphic graphic) {
		// These must be done in this order to prevent infinite loop
		if(!this.selectedGraphics.contains(graphic))
			this.selectedGraphics.add(graphic);
		graphic.setState(Graphic.SELECTED);
	}

	public void removeSelectedGraphic(Graphic graphic) {
		// These must be done in this order to prevent infinite loop
		if(this.selectedGraphics.contains(graphic))
			this.selectedGraphics.remove(graphic);
		graphic.setState(Graphic.DORMANT);
	}

	public CanvasPanel getCanvasPanel() {
		return this.canvasPanel;
	}

	public Vector getSelectedGraphics() {
		return this.selectedGraphics;
	}

	public boolean containsName(String name) {
		return this.nameGraphicTable.containsKey(name);
	}

	public boolean isFocusTraversible() {
		return true;
	}

	public void setSelectedFillColors(Color color) {
		if(!this.hasPen && !this.isIncoming())
			return;

		Iterator iter = this.selectedGraphics.iterator();
		while(iter.hasNext()) {
			Graphic graphic = (Graphic)iter.next();
			if(graphic instanceof ShapeGraphic)
				((ShapeGraphic)graphic).setFillColor(color);
		}
	}

	public void setSelectedStrokeColors(Color color) {
		if(!this.hasPen && !this.isIncoming())
			return;

		Iterator iter = this.selectedGraphics.iterator();
		while(iter.hasNext()) {
			Graphic graphic = (Graphic)iter.next();
			if(graphic instanceof ShapeGraphic)
				((ShapeGraphic)graphic).setStrokeColor(color);
		}
	}

	public void setSelectedTextColors(Color color) {
		if(!this.hasPen && !this.isIncoming())
			return;

		Iterator iter = this.selectedGraphics.iterator();
		while(iter.hasNext()) {
			Graphic graphic = (Graphic)iter.next();
			if(graphic instanceof TextGraphic)
				((TextGraphic)graphic).setTextColor(color);
		}
	}

	public void editSendToBack() {
		if(!this.hasPen && !this.isIncoming())
			return;

		Object[] graphics = this.graphics.toArray();
		int index = 0;
		for(int i = 0; i < graphics.length; i++) {
			Graphic graphic = (Graphic)graphics[i];
			if(graphic.getState() == Graphic.SELECTED) {
				this.pushGraphicEvent(new PositionChangeEvent(graphic, i, index));
				this.removeGraphic(graphic);
				this.insertGraphic(graphic, index);
				graphic.setState(Graphic.SELECTED);
				index++;
			}
		}
		GraphicEvent event = this.popAllGraphicEvents();
		if(event != null)
			this.addGraphicEvent(event);
	}

	public void editBringToFront() {
		if(!this.hasPen && !this.isIncoming())
			return;

		Object[] graphics = this.graphics.toArray();
		int index = graphics.length - 1;
		for(int i = 0; i < graphics.length; i++) {
			Graphic graphic = (Graphic)graphics[i];
			if(graphic.getState() == Graphic.SELECTED) {
				this.pushGraphicEvent(new PositionChangeEvent(graphic, i, index));
				this.removeGraphic(graphic);
				this.addGraphic(graphic);
				graphic.setState(Graphic.SELECTED);
				index--;
			}
		}
		GraphicEvent event = this.popAllGraphicEvents();
		if(event != null)
			this.addGraphicEvent(event);
	}

	public void editSendBackward() {
		if(!this.hasPen && !this.isIncoming())
			return;

		Object[] graphics = this.graphics.toArray();

		int lowestIndex;
		for(lowestIndex = 0; lowestIndex < graphics.length; lowestIndex++) {
			Graphic graphic = (Graphic)graphics[lowestIndex];
			if(graphic.getState() != Graphic.SELECTED)
				break;
		}

		int begin;
		for(begin = lowestIndex; begin < graphics.length; begin++) {
			Graphic graphic = (Graphic)graphics[begin];
			if(graphic.getState() == Graphic.SELECTED) {
				int end;
				for(end = begin + 1; end < graphics.length; end++) {
					graphic = (Graphic)graphics[end];
					if(graphic.getState() != Graphic.SELECTED)
						break;
				}

				for(int k = begin; k < end; k++) {
					graphic = (Graphic)graphics[k];
					this.pushGraphicEvent(new PositionChangeEvent(graphic, k, k - 1));
					this.removeGraphic(graphic);
					this.insertGraphic(graphic, k - 1);
					graphic.setState(Graphic.SELECTED);
				}
			}
		}
		GraphicEvent event = this.popAllGraphicEvents();
		if(event != null)
			this.addGraphicEvent(event);
	}

	public void editBringForward() {
		if(!this.hasPen && !this.isIncoming())
			return;

		Object[] graphics = this.graphics.toArray();

		int highestIndex;
		for(highestIndex = graphics.length - 1; highestIndex >= 0 ; highestIndex--) {
			Graphic graphic = (Graphic)graphics[highestIndex];
			if(graphic.getState() != Graphic.SELECTED)
				break;
		}

		int begin;
		for(begin = highestIndex; begin >= 0; begin--) {
			Graphic graphic = (Graphic)graphics[begin];
			if(graphic.getState() == Graphic.SELECTED) {
				int end;
				for(end = begin - 1; end >= 0; end--) {
					graphic = (Graphic)graphics[end];
					if(graphic.getState() != Graphic.SELECTED)
						break;
				}

				for(int k = begin; k > end; k--) {
					graphic = (Graphic)graphics[k];
					this.pushGraphicEvent(new PositionChangeEvent(graphic, k, k + 1));
					this.removeGraphic(graphic);
					this.insertGraphic(graphic, k + 1);
					graphic.setState(Graphic.SELECTED);
				}
			}
		}
		GraphicEvent event = this.popAllGraphicEvents();
		if(event != null)
			this.addGraphicEvent(event);
	}

}