rootpaneui.java

用于java swing的皮肤软件

				}
			}
			if (root.getWindowDecorationStyle() != JRootPane.NONE
						&& (root.getUI() instanceof RootPaneUI))
			{
				JComponent titlePane = ((RootPaneUI) root.getUI()).getTitlePane();
				if (titlePane != null)
				{
					tpd = titlePane.getMinimumSize();
					if (tpd != null)
					{
						tpWidth = tpd.width;
						tpHeight = tpd.height;
					}
				}
			}

			return new Dimension(Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,
						cpHeight + mbHeight + tpWidth + i.top + i.bottom);
		}


		/**
		 * Returns the maximum amount of space the layout can use.
		 * 
		 * @param the Container for which this layout manager is being used
		 * @return a Dimension object containing the layout's maximum size
		 */
		public Dimension maximumLayoutSize(Container target)
		{
			Dimension cpd, mbd, tpd;
			int cpWidth = Integer.MAX_VALUE;
			int cpHeight = Integer.MAX_VALUE;
			int mbWidth = Integer.MAX_VALUE;
			int mbHeight = Integer.MAX_VALUE;
			int tpWidth = Integer.MAX_VALUE;
			int tpHeight = Integer.MAX_VALUE;
			Insets i = target.getInsets();
			JRootPane root = (JRootPane) target;

			if (root.getContentPane() != null)
			{
				cpd = root.getContentPane().getMaximumSize();
				if (cpd != null)
				{
					cpWidth = cpd.width;
					cpHeight = cpd.height;
				}
			}

			if (root.getMenuBar() != null)
			{
				mbd = root.getMenuBar().getMaximumSize();
				if (mbd != null)
				{
					mbWidth = mbd.width;
					mbHeight = mbd.height;
				}
			}

			if (root.getWindowDecorationStyle() != JRootPane.NONE
						&& (root.getUI() instanceof RootPaneUI))
			{
				JComponent titlePane = ((RootPaneUI) root.getUI()).getTitlePane();
				if (titlePane != null)
				{
					tpd = titlePane.getMaximumSize();
					if (tpd != null)
					{
						tpWidth = tpd.width;
						tpHeight = tpd.height;
					}
				}
			}

			int maxHeight = Math.max(Math.max(cpHeight, mbHeight), tpHeight);
			// Only overflows if 3 real non-MAX_VALUE heights, sum to > MAX_VALUE
			// Only will happen if sums to more than 2 billion units. Not likely.
			if (maxHeight != Integer.MAX_VALUE)
			{
				maxHeight = cpHeight + mbHeight + tpHeight + i.top + i.bottom;
			}

			int maxWidth = Math.max(Math.max(cpWidth, mbWidth), tpWidth);
			// Similar overflow comment as above
			if (maxWidth != Integer.MAX_VALUE)
			{
				maxWidth += i.left + i.right;
			}

			return new Dimension(maxWidth, maxHeight);
		}


		/**
		 * Instructs the layout manager to perform the layout for the specified
		 * container.
		 * 
		 * @param the Container for which this layout manager is being used
		 */
		public void layoutContainer(Container parent)
		{
			JRootPane root = (JRootPane) parent;
			Rectangle b = root.getBounds();
			Insets i = root.getInsets();
			int nextY = 0;
			int w = b.width - i.right - i.left;
			int h = b.height - i.top - i.bottom;

			if (root.getLayeredPane() != null)
			{
				root.getLayeredPane().setBounds(i.left, i.top, w, h);
			}
			if (root.getGlassPane() != null)
			{
				root.getGlassPane().setBounds(i.left, i.top, w, h);
			}
			// Note: This is laying out the children in the layeredPane,
			// technically, these are not our children.
			if (root.getWindowDecorationStyle() != JRootPane.NONE
						&& (root.getUI() instanceof RootPaneUI))
			{
				JComponent titlePane = ((RootPaneUI) root.getUI()).getTitlePane();
				if (titlePane != null)
				{
					Dimension tpd = titlePane.getPreferredSize();
					if (tpd != null)
					{
						int tpHeight = tpd.height;
						titlePane.setBounds(0, 0, w, tpHeight);
						nextY += tpHeight;
					}
				}
			}
			if (root.getMenuBar() != null)
			{
				Dimension mbd = root.getMenuBar().getPreferredSize();
				root.getMenuBar().setBounds(0, nextY, w, mbd.height);
				nextY += mbd.height;
			}
			if (root.getContentPane() != null)
			{
				Dimension cpd = root.getContentPane().getPreferredSize();
				root.getContentPane().setBounds(0, nextY, w, h < nextY ? 0 : h - nextY);
			}
		}


		public void addLayoutComponent(String name, Component comp)
		{
		}


		public void removeLayoutComponent(Component comp)
		{
		}


		public void addLayoutComponent(Component comp, Object constraints)
		{
		}


		public float getLayoutAlignmentX(Container target)
		{
			return 0.0f;
		}


		public float getLayoutAlignmentY(Container target)
		{
			return 0.0f;
		}


		public void invalidateLayout(Container target)
		{
		}
	}


	/**
	 * Maps from positions to cursor type. Refer to calculateCorner and
	 * calculatePosition for details of this.
	 */
	private static final int[]	cursorMapping	= new int[]
															{
				Cursor.NW_RESIZE_CURSOR, Cursor.NW_RESIZE_CURSOR, Cursor.N_RESIZE_CURSOR,
				Cursor.NE_RESIZE_CURSOR, Cursor.NE_RESIZE_CURSOR, Cursor.NW_RESIZE_CURSOR, 0, 0, 0,
				Cursor.NE_RESIZE_CURSOR, Cursor.W_RESIZE_CURSOR, 0, 0, 0, Cursor.E_RESIZE_CURSOR,
				Cursor.SW_RESIZE_CURSOR, 0, 0, 0, Cursor.SE_RESIZE_CURSOR, Cursor.SW_RESIZE_CURSOR,
				Cursor.SW_RESIZE_CURSOR, Cursor.S_RESIZE_CURSOR, Cursor.SE_RESIZE_CURSOR,
				Cursor.SE_RESIZE_CURSOR
															};

	/**
	 * MouseInputHandler is responsible for handling resize/moving of the Window.
	 * It sets the cursor directly on the Window when then mouse moves over a hot
	 * spot.
	 */
	private class MouseInputHandler implements MouseInputListener
	{
		/**
		 * Set to true if the drag operation is moving the window.
		 */
		private boolean	isMovingWindow;

		/**
		 * Used to determine the corner the resize is occuring from.
		 */
		private int			dragCursor;

		/**
		 * X location the mouse went down on for a drag operation.
		 */
		private int			dragOffsetX;

		/**
		 * Y location the mouse went down on for a drag operation.
		 */
		private int			dragOffsetY;

		/**
		 * Width of the window when the drag started.
		 */
		private int			dragWidth;

		/**
		 * Height of the window when the drag started.
		 */
		private int			dragHeight;

		private Point		prevMousePos;


		public void mousePressed(MouseEvent ev)
		{
			prevMousePos = new Point();
			prevMousePos.x=ev.getX()+root.getLocationOnScreen().x;
			prevMousePos.y=ev.getY()+root.getLocationOnScreen().y;
			
			JRootPane rootPane = getRootPane();

			if (rootPane.getWindowDecorationStyle() == JRootPane.NONE)
			{
				return;
			}
			Point dragWindowOffset = ev.getPoint();
			Window w = (Window) ev.getSource();
			if (w != null)
			{
				w.toFront();
			}
			Point convertedDragWindowOffset = SwingUtilities.convertPoint(w, dragWindowOffset,
						getTitlePane());

			Frame f = null;
			Dialog d = null;

			if (w instanceof Frame)
			{
				f = (Frame) w;
			}
			else if (w instanceof Dialog)
			{
				d = (Dialog) w;
			}

			int frameState = (f != null) ? f.getExtendedState() : 0;

			if (getTitlePane() != null && getTitlePane().contains(convertedDragWindowOffset))
			{
				if ((f != null && ((frameState & Frame.MAXIMIZED_BOTH) == 0) || (d != null))
							&& dragWindowOffset.y >= BORDER_DRAG_THICKNESS
							&& dragWindowOffset.x >= BORDER_DRAG_THICKNESS
							&& dragWindowOffset.x < w.getWidth() - BORDER_DRAG_THICKNESS)
				{
					isMovingWindow = true;
					dragOffsetX = dragWindowOffset.x;
					dragOffsetY = dragWindowOffset.y;
				}
			}
			else if (f != null && f.isResizable() && ((frameState & Frame.MAXIMIZED_BOTH) == 0)
						|| (d != null && d.isResizable()))
			{
				dragOffsetX = dragWindowOffset.x;
				dragOffsetY = dragWindowOffset.y;
				dragWidth = w.getWidth();
				dragHeight = w.getHeight();
				dragCursor = getCursor(calculateCorner(w, dragWindowOffset.x, dragWindowOffset.y));
			}
		}


		public void mouseReleased(MouseEvent ev)
		{
			if (dragCursor != 0 && window != null && !window.isValid())
			{
				// Some Window systems validate as you resize, others won't,
				// thus the check for validity before repainting.
				window.validate();
				getRootPane().repaint();
			}
			isMovingWindow = false;
			dragCursor = 0;
		}


		public void mouseMoved(MouseEvent ev)
		{
			JRootPane root = getRootPane();

			if (root.getWindowDecorationStyle() == JRootPane.NONE)
			{
				return;
			}

			Window w = (Window) ev.getSource();

			Frame f = null;
			Dialog d = null;

			if (w instanceof Frame)
			{
				f = (Frame) w;
			}
			else if (w instanceof Dialog)
			{
				d = (Dialog) w;
			}

			// Update the cursor
			int cursor = getCursor(calculateCorner(w, ev.getX(), ev.getY()));

			if (cursor != 0
						&& ((f != null && (f.isResizable() && (f.getExtendedState() & Frame.MAXIMIZED_BOTH) == 0)) || (d != null && d
									.isResizable())))
			{
				w.setCursor(Cursor.getPredefinedCursor(cursor));
			}
			else
			{
				w.setCursor(lastCursor);
			}
		}


		private void adjust(Rectangle bounds, Dimension min, int deltaX, int deltaY, int deltaWidth,
					int deltaHeight)
		{
			bounds.x += deltaX;
			bounds.y += deltaY;
			bounds.width += deltaWidth;
			bounds.height += deltaHeight;
			if (min != null)
			{
				if (bounds.width < min.width)
				{
					int correction = min.width - bounds.width;
					if (deltaX != 0)
					{
						bounds.x -= correction;
					}
					bounds.width = min.width;
				}
				if (bounds.height < min.height)
				{
					int correction = min.height - bounds.height;
					if (deltaY != 0)
					{
						bounds.y -= correction;
					}
					bounds.height = min.height;
				}
			}
		}


		public void mouseDragged(MouseEvent ev)
		{
			Window w = (Window) ev.getSource();
			Point pt = ev.getPoint();

			if (isMovingWindow)
			{
				Point windowPt = w.getLocationOnScreen();

				windowPt.x += pt.x - dragOffsetX;
				windowPt.y += pt.y - dragOffsetY;
				w.setLocation(windowPt);
			}
			else if (dragCursor != 0)
			{
				Rectangle r = w.getBounds();
				Rectangle startBounds = new Rectangle(r);
				Dimension min = w.getMinimumSize();

				switch (dragCursor)
				{
					case Cursor.E_RESIZE_CURSOR :
						adjust(r, min, 0, 0, pt.x + (dragWidth - dragOffsetX) - r.width, 0);
						break;
					case Cursor.S_RESIZE_CURSOR :
						adjust(r, min, 0, 0, 0, pt.y + (dragHeight - dragOffsetY) - r.height);
						break;
					case Cursor.N_RESIZE_CURSOR :
						adjust(r, min, 0, pt.y - dragOffsetY, 0, -(pt.y - dragOffsetY));
						break;
					case Cursor.W_RESIZE_CURSOR :
						adjust(r, min, pt.x - dragOffsetX, 0, -(pt.x - dragOffsetX), 0);
						break;
					case Cursor.NE_RESIZE_CURSOR :
						adjust(r, min, 0, pt.y - dragOffsetY, pt.x + (dragWidth - dragOffsetX) - r.width,
									-(pt.y - dragOffsetY));
						break;
					case Cursor.SE_RESIZE_CURSOR :
						adjust(r, min, 0, 0, pt.x + (dragWidth - dragOffsetX) - r.width, pt.y
									+ (dragHeight - dragOffsetY) - r.height);
						break;
					case Cursor.NW_RESIZE_CURSOR :
						adjust(r, min, pt.x - dragOffsetX, pt.y - dragOffsetY, -(pt.x - dragOffsetX),
									-(pt.y - dragOffsetY));
						break;
					case Cursor.SW_RESIZE_CURSOR :
						adjust(r, min, pt.x - dragOffsetX, 0, -(pt.x - dragOffsetX), pt.y
									+ (dragHeight - dragOffsetY) - r.height);
						break;
					default :
						break;
				}
				if (!r.equals(startBounds))
				{
					w.setBounds(r);
					// Defer repaint/validate on mouseReleased unless dynamic
					// layout is active.
					if (Toolkit.getDefaultToolkit().isDynamicLayoutActive())
					{
						w.validate();
						getRootPane().repaint();
					}
				}
			}
		}


		public void mouseEntered(MouseEvent ev)
		{
			Window w = (Window) ev.getSource();
			lastCursor = w.getCursor();
			mouseMoved(ev);
		}


		public void mouseExited(MouseEvent ev)
		{
			Window w = (Window) ev.getSource();
			w.setCursor(lastCursor);
		}


		public void mouseClicked(MouseEvent ev)
		{
			Window w = (Window) ev.getSource();
			Frame f = null;

			if (w instanceof Frame)
			{
				f = (Frame) w;
			}
			else
			{
				return;
			}

			if(prevMousePos!=null)
			{			
				int deltaX=Math.abs(prevMousePos.x-ev.getX()-root.getLocationOnScreen().x);
				int deltaY=Math.abs(prevMousePos.y-ev.getY()-root.getLocationOnScreen().y);
				System.out.println("Mouse pos: "+ev.getPoint()+", prev Pos="+prevMousePos+", dx="+deltaX+", dy="+deltaY);
				
				if(deltaX>5 || deltaY>5)
					return;
			}
			
			Point convertedPoint = SwingUtilities.convertPoint(w, ev.getPoint(), getTitlePane());

			int state = f.getExtendedState();
			if (getTitlePane() != null && getTitlePane().contains(convertedPoint))
			{
				if ((ev.getClickCount() % 2) == 0
							&& ((ev.getModifiers() & InputEvent.BUTTON1_MASK) != 0))
				{
					if (f.isResizable())
					{
						if ((state & Frame.MAXIMIZED_BOTH) != 0)
						{
							f.setExtendedState(state & ~Frame.MAXIMIZED_BOTH);
						}
						else
						{
							f.setExtendedState(state | Frame.MAXIMIZED_BOTH);
						}
						return;
					}
				}
			}
		}


		/**
		 * Returns the corner that contains the point <code>x</code>,
		 * <code>y</code>, or -1 if the position doesn't match a corner.
		 */
		private int calculateCorner(Component c, int x, int y)
		{
			int xPosition = calculatePosition(x, c.getWidth());
			int yPosition = calculatePosition(y, c.getHeight());

			if (xPosition == -1 || yPosition == -1)
			{
				return -1;
			}
			return yPosition * 5 + xPosition;
		}


		/**
		 * Returns the Cursor to render for the specified corner. This returns 0
		 * if the corner doesn't map to a valid Cursor
		 */
		private int getCursor(int corner)
		{
			if (corner == -1)
			{
				return 0;
			}
			return cursorMapping[corner];
		}


		/**
		 * Returns an integer indicating the position of <code>spot</code> in
		 * <code>width</code>. The return value will be: 0 if <
		 * BORDER_DRAG_THICKNESS 1 if < CORNER_DRAG_WIDTH 2 if >=
		 * CORNER_DRAG_WIDTH && < width - BORDER_DRAG_THICKNESS 3 if >= width -
		 * CORNER_DRAG_WIDTH 4 if >= width - BORDER_DRAG_THICKNESS 5 otherwise
		 */
		private int calculatePosition(int spot, int width)
		{
			if (spot < BORDER_DRAG_THICKNESS)
			{
				return 0;
			}
			if (spot < CORNER_DRAG_WIDTH)
			{
				return 1;
			}
			if (spot >= (width - BORDER_DRAG_THICKNESS))
			{
				return 4;
			}
			if (spot >= (width - CORNER_DRAG_WIDTH))
			{
				return 3;
			}
			return 2;
		}
	}
}