edgeview.java

用JGraph编的软件

		protected boolean firstOverlayCall = true;

		protected boolean isEdgeConnectable = true;

		protected EdgeView relevantEdge = null;

		public EdgeHandle(EdgeView edge, GraphContext ctx) {
			this.graph = ctx.getGraph();
			this.edge = edge;
			loc = new Rectangle();
			orig =
				(EdgeView) graph.getGraphLayoutCache().getMapping(
					edge.getCell(),
					false);
			reloadPoints(orig);
			isEdgeConnectable =
				GraphConstants.isConnectable(edge.getAllAttributes());
		}

		protected void reloadPoints(EdgeView edge) {
			relevantEdge = edge;
			r = new Rectangle[edge.getPointCount()];
			for (int i = 0; i < r.length; i++)
				r[i] = new Rectangle();
			invalidate();
		}

		// Update and paint control points
		public void paint(Graphics g) {
			invalidate();
			for (int i = 0; i < r.length; i++) {
				if (isEdgeConnectable)
					g.setColor(graph.getHandleColor());
				else
					g.setColor(graph.getLockedHandleColor());
				g.fill3DRect(r[i].x, r[i].y, r[i].width, r[i].height, true);
				CellView port = null;
				if (i == 0 && edge.getSource() != null)
					port = edge.getSource();
				else if (i == r.length - 1 && edge.getTarget() != null)
					port = edge.getTarget();
				if (port != null) {
					g.setColor(graph.getLockedHandleColor());
					Point tmp =
						GraphConstants.getOffset(port.getAllAttributes());
					if (tmp != null) {
						g.drawLine(
							r[i].x + 1,
							r[i].y + 1,
							r[i].x + r[i].width - 3,
							r[i].y + r[i].height - 3);
						g.drawLine(
							r[i].x + 1,
							r[i].y + r[i].height - 3,
							r[i].x + r[i].width - 3,
							r[i].y + 1);
					} else
						g.drawRect(
							r[i].x + 2,
							r[i].y + 2,
							r[i].width - 5,
							r[i].height - 5);
				}
			}
		}

		public void overlay(Graphics g) {
			if (edge != null && !firstOverlayCall) {
				//g.setColor(graph.getBackground()); // JDK 1.3
				g.setColor(graph.getForeground());
				//g.setXORMode(graph.getBackground());
				g.setXORMode(graph.getBackground().darker());
				Graphics2D g2 = (Graphics2D) g;
				AffineTransform oldTransform = g2.getTransform();
				g2.scale(graph.getScale(), graph.getScale());
				graph.getUI().paintCell(g, edge, edge.getBounds(), true);
				g2.setTransform(oldTransform);
				if (isSourceEditing() && edge.getSource() != null)
					paintPort(g, edge.getSource());
				else if (isTargetEditing() && edge.getTarget() != null)
					paintPort(g, edge.getTarget());
			}
			firstOverlayCall = false;
		}

		protected void paintPort(Graphics g, CellView p) {
			boolean offset =
				(GraphConstants.getOffset(p.getAllAttributes()) != null);
			Rectangle r =
				(offset) ? p.getBounds() : p.getParentView().getBounds();
			r = graph.toScreen(new Rectangle(r));
			int s = 3;
			r.translate(-s, -s);
			r.setSize(r.width + 2 * s, r.height + 2 * s);
			graph.getUI().paintCell(g, p, r, true);
		}

		protected boolean snap(boolean source, Point point) {
			boolean connect = graph.isConnectable() && isEdgeConnectable;
			Object port = graph.getPortForLocation(point.x, point.y);
			if (port != null && connect) {
				CellView portView =
					graph.getGraphLayoutCache().getMapping(port, false);
				if (GraphConstants
					.isConnectable(
						portView.getParentView().getAllAttributes())) {
					Object cell = edge.getCell();
					if (source
						&& edge.getSource() != portView
						&& getModel().acceptsSource(cell, port)) {
						overlay(graph.getGraphics());
						edge.setSource(portView);
						edge.update();
						overlay(graph.getGraphics());
					} else if (
						!source
							&& edge.getTarget() != portView
							&& getModel().acceptsTarget(cell, port)) {
						overlay(graph.getGraphics());
						edge.setTarget(portView);
						edge.update();
						overlay(graph.getGraphics());
					}
					return portView != null;
				}
			}
			return false;
		}

		protected boolean isSourceEditing() {
			return source;
			//return (index == 0 && edge.getSource() != null);
		}

		protected boolean isTargetEditing() {
			return target;
			//return (
			//	index == edge.getPointCount() - 1 && edge.getTarget() != null);
		}

		/* Returns true if either the source, target, label or a point is being edited. */
		protected boolean isEditing() {
			return source || target || label || currentPoint != null;
		}

		/**
		 * Invoked when the mouse pointer has been moved on a component
		 * (with no buttons down).
		 */
		public void mouseMoved(MouseEvent event) {
			for (int i = 0; i < r.length; i++)
				if (r[i].contains(event.getPoint())) {
					graph.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
					event.consume();
					return;
				}
			if (loc.contains(event.getPoint())
				&& graph.isMoveable()
				&& GraphConstants.isMoveable(edge.getAllAttributes())) {
				graph.setCursor(new Cursor(Cursor.HAND_CURSOR));
				event.consume();
			}
		}

		// Handle mouse pressed event.
		public void mousePressed(MouseEvent event) {
			/* INV: currentPoint = null; source = target = label = false; */
			boolean bendable =
				graph.isBendable()
					&& GraphConstants.isBendable(edge.getAllAttributes());
			boolean disconnectable =
				graph.isDisconnectable()
					&& GraphConstants.isDisconnectable(orig.getAllAttributes());
			int x = event.getX();
			int y = event.getY();
			// Detect hit on control point
			int index = 0;
			for (index = 0; index < r.length; index++) {
				if (r[index].contains(x, y)) {
					currentPoint = edge.getPoint(index);
					source =
						index == 0
							&& (edge.getSource() == null
								|| (disconnectable
									&& GraphConstants.isDisconnectable(
										edge
											.getSource()
											.getParentView()
											.getAllAttributes())));
					target =
						index == r.length - 1
							&& (edge.getTarget() == null
								|| (disconnectable
									&& GraphConstants.isDisconnectable(
										edge
											.getTarget()
											.getParentView()
											.getAllAttributes())));
					break;
				}
			}
			// Detect hit on label
			if (!isEditing()
				&& graph.isMoveable()
				&& GraphConstants.isMoveable(edge.getAllAttributes())
				&& loc != null
				&& loc.contains(x, y)
				&& !isAddPointEvent(event)
				&& !isRemovePointEvent(event)) {
				if (event.getClickCount() == graph.getEditClickCount())
					graph.startEditingAtCell(edge);
				else
					label = true;
				// Remove Point
			}
			if (isRemovePointEvent(event)
				&& currentPoint != null
				&& bendable) {
				edge.removePoint(index);
				mouseReleased(event);
				// Add Point
			} else if (isAddPointEvent(event) && !isEditing() && bendable) {
				int s = graph.getHandleSize();
				Rectangle rect =
					graph.fromScreen(new Rectangle(x - s, y - s, 2 * s, 2 * s));
				if (edge.intersects(graph.getGraphics(), rect)) {
					Point point =
						graph.fromScreen(
							graph.snap(new Point(event.getPoint())));
					double min = Double.MAX_VALUE, dist = 0;
					for (int i = 0; i < edge.getPointCount() - 1; i++) {
						Point p = edge.getPoint(i);
						Point p1 = edge.getPoint(i + 1);
						dist = new Line2D.Double(p, p1).ptLineDistSq(point);
						if (dist < min) {
							min = dist;
							index = i + 1;
						}
					}
					edge.addPoint(index, point);
					currentPoint = point;
					reloadPoints(edge);
					paint(graph.getGraphics());
				}
			}
			if (isEditing())
				event.consume();
		}

		public void mouseDragged(MouseEvent event) {
			Point p = graph.fromScreen(new Point(event.getPoint()));
			// Move Label
			if (label) {
				Rectangle r = edge.getBounds();
				if (r != null) {
					Point p0 = edge.getPoint(0);
					Point pe = edge.getPoint(edge.getPointCount() - 1);
					int vx = p.x - r.x;
					if (p0.x > pe.x)
						vx = r.x + r.width - p.x;
					int vy = p.y - r.y;
					if (p0.y > pe.y)
						vy = r.y + r.height - p.y;
					int xunit = 1;
					if (r.width != 0)
						xunit = GraphConstants.PERMILLE / r.width;
					int yunit = 1;
					if (r.height != 0)
						yunit = GraphConstants.PERMILLE / r.height;
					p = new Point(vx * xunit, vy * yunit);
					overlay(graph.getGraphics());
					edge.setLabelPosition(p);
					edge.update();
					overlay(graph.getGraphics());
				}
			} else if (isEditing()) {
				// Find Source/Target Port
				if (!((source && snap(true, p))
					|| (target && snap(false, p)))) { // Else Use Point
					if ((source && getModel().acceptsSource(cell, null))
						|| (target && getModel().acceptsTarget(cell, null))
						|| !(source || target)) {
						overlay(graph.getGraphics());
						p =
							graph.fromScreen(
								graph.snap(new Point(event.getPoint())));
						// Constrained movement
						if (isConstrainedMoveEvent(event)) {
							// Reset Initial Positions
							EdgeView orig =
								(EdgeView) graph
									.getGraphLayoutCache()
									.getMapping(
									edge.getCell(),
									false);
							int index = 0;
							if (target)
								index = orig.getPointCount() - 1;
							else
								edge.getPoints().indexOf(currentPoint);
							Point origPoint = orig.getPoint(index);
							int totDx = p.x - origPoint.x;
							int totDy = p.y - origPoint.y;
							if (Math.abs(totDx) < Math.abs(totDy))
								p.x = origPoint.x;
							else
								p.y = origPoint.y;
						}
						// Do not move into negative space
						p.x =
							GraphConstants.NEGATIVE_ALLOWED
								? p.x
								: Math.max(0, p.x);
						p.y =
							GraphConstants.NEGATIVE_ALLOWED
								? p.y
								: Math.max(0, p.y);
						currentPoint.setLocation(p);
						if (source) {
							edge.setPoint(0, p);
							edge.setSource(null);
						} else if (target) {
							edge.setPoint(edge.getPointCount() - 1, p);
							edge.setTarget(null);
						}
						edge.update();
						overlay(graph.getGraphics());
					}
				}
			}
		} // Handle mouse released event

		public void mouseReleased(MouseEvent e) {
			boolean clone = e.isControlDown() && graph.isCloneable();
			ConnectionSet cs = createConnectionSet(edge, edge.getCell(), clone);
			Map nested =
				GraphConstants.createAttributes(new CellView[] { edge }, null);
			if (clone) {
				Map cellMap = graph.cloneCells(new Object[] { edge.getCell()});
				nested = GraphConstants.replaceKeys(cellMap, nested);
				cs = cs.clone(cellMap);
				graph.getGraphLayoutCache().insert(
					cellMap.values().toArray(),
					nested,
					cs,
					null,
					null);
			} else
				graph.getGraphLayoutCache().edit(nested, cs, null, null);
			e.consume();
		}

		protected ConnectionSet createConnectionSet(
			EdgeView view,
			Object edge,
			boolean verbose) {
			ConnectionSet cs = new ConnectionSet();
			Object sourcePort = null, targetPort = null;
			if (view.getSource() != null)
				sourcePort = view.getSource().getCell();
			if (view.getTarget() != null)
				targetPort = view.getTarget().getCell();
			if (verbose || sourcePort != getModel().getSource(edge))
				cs.connect(edge, sourcePort, true);
			if (verbose || targetPort != getModel().getTarget(edge))
				cs.connect(edge, targetPort, false);
			return cs;
		}

		// Update control points
		protected void invalidate() {
			EdgeView e = relevantEdge;
			int handlesize = graph.getHandleSize();
			EdgeRenderer er = (EdgeRenderer) edge.getRenderer();
			for (int i = 0; i < r.length; i++) {
				Point p = graph.toScreen(new Point(e.getPoint(i)));
				r[i].setBounds(
					p.x - handlesize,
					p.y - handlesize,
					2 * handlesize,
					2 * handlesize);
				p = graph.toScreen(er.getLabelPosition(e));
				Dimension d = er.getLabelSize(e);
				if (p != null && d != null) {
					Point s = graph.toScreen(new Point(d.width, d.height));
					loc.setBounds(p.x - s.x / 2, p.y - s.y / 2, s.x, s.y);
				}
			}
		}

	}

}