gpoverviewpanel.java

用JGraph编的软件

				pannerViewRectangleCopy = new Rectangle(pannerViewRectangle);
				pannerContainerRectangleCopy = new Rectangle(pannerContainerRectangle);
			}

		}

		public void mouseDragged(MouseEvent e) {
			if (isActive) {
				updatePannerLocation(e);
				updateViewPort(e);
			}
			else if (isResizing) {
				Cursor c = container.getCursor();
				int cursorType = c.getType();

				switch (cursorType) {
					case Cursor.SE_RESIZE_CURSOR :
						SECornerResize(e);
						break;
					case Cursor.NE_RESIZE_CURSOR :
						//NECornerResize(e);
						break;
					case Cursor.SW_RESIZE_CURSOR :
						//SWCornerResize(e);
						break;
					case Cursor.NW_RESIZE_CURSOR :
						//NWCornerResize(e);
						break;
				}
			}
		}

		private void SECornerResize(MouseEvent e) {

			//resizing from SE corner
			int x = (int) pannerViewRectangleCopy.getX();
			int y = (int) pannerViewRectangleCopy.getY();
			double wx = e.getX() - pannerViewRectangleCopy.getMinX();
			double hx = e.getY() - pannerViewRectangleCopy.getMinY();
			if (wx > hx) {
				hx = wx * pannerViewRectangleCopy.getHeight() / pannerViewRectangleCopy.getWidth();
			}
			else {
				wx = hx * pannerViewRectangleCopy.getWidth() / pannerViewRectangleCopy.getHeight();
			}
			pannerViewRectangle.setBounds(x, y, (int) wx, (int) hx);
			ensureMinResize();
			ensureMaxResize();

			//recalculate scale
			double x_scale = (pannerViewRectangle.getWidth() / pannerViewRectangleCopy.getWidth());
			originalGraph.setScale((1 / (x_scale)) * zoomScale);

			container.repaint();
		}

		private void SWCornerResize(MouseEvent e) {
		}

		private void NWCornerResize(MouseEvent e) {
		}

		private void NECornerResize(MouseEvent e) {
		}

		private int findClosestDragPoint(MouseEvent e, double buffer) {

			double mx = e.getX();
			double my = e.getY();

			double lx = pannerViewRectangle.getX();
			double uy = pannerViewRectangle.getY();

			double rx = lx + pannerViewRectangle.getWidth();
			double ly = uy + pannerViewRectangle.getHeight();

			int mask = 0;
			//leftVertical
			if (Math.abs(mx - lx) < buffer && (my + buffer > uy && my < ly + buffer)) {
				//lv
				mask |= LEFT_VERTICAL;
			}
			if (Math.abs(mx - rx) < buffer && (my + buffer > uy && my < ly + buffer)) {
				//rv
				mask |= RIGHT_VERTICAL;
			}
			if (Math.abs(my - uy) < buffer && (mx + buffer > lx && mx < rx + buffer)) {
				//uh
				mask |= UPPER_HORIZONTAL;
			}
			if (Math.abs(my - ly) < buffer && (mx + buffer > lx && mx < rx + buffer)) {
				//lh
				mask |= LOWER_HORIZONTAL;
			}
			return mask;
		}

		public void mouseReleased(MouseEvent e) {
			if (isActive) {
				isActive = false;
			}
			if (isResizing) {
				zoomScale = originalGraph.getScale();
				combinedScale = graphWindowToPannerScale / zoomScale;
				isResizing = false;
				updateViewPort(e);
			}			
		}

		private void updateViewPort(MouseEvent e) {
			int x = (int) (1 / combinedScale * pannerViewRectangle.getX());
			int y = (int) (1 / combinedScale * pannerViewRectangle.getY());

			Rectangle r = viewport.getViewRect();

			//ensure that we can not go out of view bounds while setting viewport
			if (x + r.getWidth() > viewport.getViewSize().getWidth()) {
				x = (int) (viewport.getViewSize().getWidth() - r.getWidth());
			}
			if (y + r.getHeight() > viewport.getViewSize().getHeight()) {
				y = (int) (viewport.getViewSize().getHeight() - r.getHeight());
			}
			viewportPosition.setLocation(x, y);
			viewport.setViewPosition(viewportPosition);
		}

		public void mouseClicked(MouseEvent e) {
			//move panner viewport to new location
			if (!isContained(e)) {
				isActive = true;
				pannerViewRectangle.setLocation(e.getPoint());
				container.repaint();
				isActive = false;
				updateViewPort(e);
			}
		}

		public void mouseMoved(MouseEvent e) {
			//detect resizing points
			int dragPoint = findClosestDragPoint(e, 5.0);
			int cursor = convertDragPointToCursor(dragPoint);
			container.setCursor(Cursor.getPredefinedCursor(cursor));
		}

		public void mouseExited(MouseEvent e) {
		}

		public void mouseEntered(MouseEvent e) {
		}

		private int convertDragPointToCursor(int dragPoint) {

			//for now, we are only interested in se corner
			int cursor = Cursor.DEFAULT_CURSOR;
			switch (dragPoint) {
				case UPPER_HORIZONTAL :
				case LOWER_HORIZONTAL :
				case LEFT_VERTICAL :
				case RIGHT_VERTICAL :
				case SW_CORNER :
				case NW_CORNER :
				case NE_CORNER :
					cursor = Cursor.DEFAULT_CURSOR;
					break;
				case SE_CORNER :
					cursor = Cursor.SE_RESIZE_CURSOR;
					break;
			}
			return cursor;
		}

		public void updatePannerLocation(MouseEvent e) {
			pannerViewRectangle.setLocation(last_x + e.getX(), last_y + e.getY());
			ensureWithinPannerBounds();
			container.repaint();
		}

		public void update(Graphics g) {
			Graphics2D g2 = (Graphics2D) g;

			Rectangle viewportR = viewport.getViewRect();
			Dimension viewD = viewport.getView().getSize();
			combinedScale = graphWindowToPannerScale / zoomScale;

			if (pannerContainerRectangle == null) {
				pannerContainerRectangle = new Rectangle();
			}
			pannerContainerRectangle.setSize(
				((int) (viewD.getWidth() * combinedScale)) - PANEL_BUFFER,
				((int) (viewD.getHeight() * combinedScale)) - PANEL_BUFFER);

			scaledWidth =
				(int) (viewportR.getWidth()
					* pannerContainerRectangle.getWidth()
					/ viewD.getWidth());
			scaledHeight =
				(int) (viewportR.getHeight()
					* pannerContainerRectangle.getHeight()
					/ viewD.getHeight());

			if (!isResizing) {
				g2.setStroke(stroke);
				pannerViewRectangle.setSize(scaledWidth, scaledHeight);
			}
			else {
				g2.setStroke(dashStroke);
			}

			int maxx = (int) pannerViewRectangle.getMaxX();
			int maxy = (int) pannerViewRectangle.getMaxY();
			pannerResizeDecoration.setLocation(maxx - DECORATION_SIZE/2,  
											   maxy - DECORATION_SIZE/2);

			g2.setColor(Color.red);
			g2.fill(pannerResizeDecoration);
			g2.draw(pannerViewRectangle);
		}

		private void ensureWithinPannerBounds() {
			int new_x = pannerViewRectangle.x;
			int new_y = pannerViewRectangle.y;

			if ((pannerViewRectangle.x + scaledWidth) > pannerContainerRectangle.getWidth()) {
				new_x = (int) pannerContainerRectangle.getWidth() - scaledWidth;
			}

			if (pannerViewRectangle.x < 0) {
				new_x = 1;
			}
			if ((pannerViewRectangle.y + scaledHeight) > pannerContainerRectangle.getHeight()) {
				new_y = (int) pannerContainerRectangle.getHeight() - scaledHeight;
			}
			if (pannerViewRectangle.y < 0) {
				new_y = 1;
			}
			pannerViewRectangle.setLocation(new_x, new_y);
		}

		private void ensureMaxResize() {
			//ensure resizing doesn't go out of the bounds of
			//pannerContainer, if hit is detected prevent further
			//resizing

			if (!pannerContainerRectangle.contains(pannerViewRectangle)) {
				Rectangle r = pannerViewRectangle.intersection(pannerContainerRectangleCopy);
				if (r.width < pannerViewRectangle.width) {
					pannerViewRectangle.width = r.width;
					pannerViewRectangle.height =
						pannerViewRectangle.width
							* pannerViewRectangleCopy.height
							/ pannerViewRectangleCopy.width;
				}
				if (r.height < pannerViewRectangle.height) {
					pannerViewRectangle.height = r.height;
					pannerViewRectangle.width =
						pannerViewRectangle.height
							* pannerViewRectangleCopy.width
							/ pannerViewRectangleCopy.height;
				}
			}
		}

		private void ensureMinResize() {
			int minSize = 20;
			Rectangle pvrc = pannerViewRectangleCopy;
			if (pvrc.width > pvrc.height && pannerViewRectangle.width < minSize) {
				pannerViewRectangle.width = minSize;
				pannerViewRectangle.height = (int) (pvrc.getHeight() * minSize / pvrc.getWidth());
			}
			else if (pvrc.height > pvrc.width && pannerViewRectangle.height < minSize) {
				pannerViewRectangle.height = minSize;
				pannerViewRectangle.width = (int) (pvrc.getHeight() * minSize / pvrc.getWidth());
			}
		}
	}
}