toolbarui.java

用于java swing的皮肤软件

//				table.getColor("ToggleButton.light"),
//				table.getColor("ToggleButton.highlight")),
//			new ToolBarMarginBorder());
	}

	/**
	 * No longer used, use BasicToolBarUI.createFloatingWindow(JToolBar)
	 * @see #createFloatingWindow
	 */
	protected JFrame createFloatingFrame(JToolBar toolbar)
	{
		Window window= SwingUtilities.getWindowAncestor(toolbar);
		JFrame frame=
			new JFrame(
				toolbar.getName(),
				(window != null) ? window.getGraphicsConfiguration() : null)
		{
				// Override createRootPane() to automatically resize
		// the frame when contents change
	protected JRootPane createRootPane()
			{
				JRootPane rootPane= new JRootPane()
				{
					private boolean packing= false;

					public void validate()
					{
						super.validate();
						if (!packing)
						{
							packing= true;
							pack();
							packing= false;
						}
					}
				};
				rootPane.setOpaque(true);
				return rootPane;
			}
		};
		frame.setResizable(false);
		WindowListener wl= createFrameListener();
		frame.addWindowListener(wl);
		return frame;
	}

	/**
	 * Creates a window which contains the toolbar after it has been
	 * dragged out from its container
	 * @returns a <code>RootPaneContainer</code> object, containing the toolbar.
	 */
	protected RootPaneContainer createFloatingWindow(JToolBar toolbar)
	{
		class ToolBarDialog extends JDialog
		{
			public ToolBarDialog(Frame owner, String title, boolean modal)
			{
				super(owner, title, modal);
			}

			public ToolBarDialog(Dialog owner, String title, boolean modal)
			{
				super(owner, title, modal);
			}

			// Override createRootPane() to automatically resize
			// the frame when contents change
			protected JRootPane createRootPane()
			{
				JRootPane rootPane= new JRootPane()
				{
					private boolean packing= false;

					public void validate()
					{
						super.validate();
						if (!packing)
						{
							packing= true;
							pack();
							packing= false;
						}
					}
				};
				rootPane.setOpaque(true);
				return rootPane;
			}
		}

		JDialog dialog;
		Window window= SwingUtilities.getWindowAncestor(toolbar);
		if (window instanceof Frame)
		{
			dialog= new ToolBarDialog((Frame) window, toolbar.getName(), false);
		}
		else if (window instanceof Dialog)
		{
			dialog= new ToolBarDialog((Dialog) window, toolbar.getName(), false);
		}
		else
		{
			dialog= new ToolBarDialog((Frame) null, toolbar.getName(), false);
		}

		dialog.setTitle(toolbar.getName());
		dialog.setResizable(false);
		WindowListener wl= createFrameListener();
		dialog.addWindowListener(wl);
		return dialog;
	}

	protected DragWindow createMyDragWindow(JToolBar toolbar)
	{
		Window frame= null;
		if (toolBar != null)
		{
			Container p;
			for (p= toolBar.getParent();
				p != null && !(p instanceof Window);
				p= p.getParent());
			if (p != null && p instanceof Window)
				frame= (Window) p;
		}
		if (floatingToolBar == null)
		{
			floatingToolBar= createFloatingWindow(toolBar);
		}
		if (floatingToolBar instanceof Window)
			frame= (Window) floatingToolBar;
		DragWindow dragWindow= new DragWindow(frame);
		return dragWindow;
	}

	/**
	 * Returns a flag to determine whether rollover button borders 
	 * are enabled.
	 *
	 * @return true if rollover borders are enabled; false otherwise
	 * @see #setRolloverBorders
	 * @since 1.4
	 */
	public boolean isRolloverBorders()
	{
		return rolloverBorders;
	}

	/**
	 * Sets the flag for enabling rollover borders on the toolbar and it will
	 * also install the apropriate border depending on the state of the flag.
	 *    
	 * @param rollover if true, rollover borders are installed. 
	 *	      Otherwise non-rollover borders are installed
	 * @see #isRolloverBorders
	 * @since 1.4
	 */
	public void setRolloverBorders(boolean rollover)
	{
		rolloverBorders= rollover;

		if (rolloverBorders)
		{
			installRolloverBorders(toolBar);
		}
		else
		{
			installNonRolloverBorders(toolBar);
		}
	}

	/**
	 * Installs rollover borders on all the child components of the JComponent.
	 * <p>
	 * This is a convenience method to call <code>setBorderToRollover</code> 
	 * for each child component.
	 *    
	 * @param c container which holds the child components (usally a JToolBar)
	 * @see #setBorderToRollover
	 * @since 1.4
	 */
	protected void installRolloverBorders(JComponent c)
	{
		// Put rollover borders on buttons
		Component[] components= c.getComponents();

		for (int i= 0; i < components.length; ++i)
		{
			if (components[i] instanceof JComponent)
			{
				((JComponent) components[i]).updateUI();
				setBorderToRollover(components[i]);
			}
		}
	}

	/**
	 * Installs non-rollover borders on all the child components of the JComponent.
	 * A non-rollover border is the border that is installed on the child component
	 * while it is in the toolbar.
	 * <p>
	 * This is a convenience method to call <code>setBorderToNonRollover</code> 
	 * for each child component.
	 *    
	 * @param c container which holds the child components (usally a JToolBar)
	 * @see #setBorderToNonRollover
	 * @since 1.4
	 */
	protected void installNonRolloverBorders(JComponent c)
	{
		// Put non-rollover borders on buttons. These borders reduce the margin.
		Component[] components= c.getComponents();

		for (int i= 0; i < components.length; ++i)
		{
			if (components[i] instanceof JComponent)
			{
				((JComponent) components[i]).updateUI();
				setBorderToNonRollover(components[i]);
			}
		}
	}

	/**
	 * Installs normal borders on all the child components of the JComponent.
	 * A normal border is the original border that was installed on the child
	 * component before it was added to the toolbar.
	 * <p>
	 * This is a convenience method to call <code>setBorderNormal</code> 
	 * for each child component.
	 *    
	 * @param c container which holds the child components (usally a JToolBar)
	 * @see #setBorderToNonRollover
	 * @since 1.4
	 */
	protected void installNormalBorders(JComponent c)
	{
		// Put back the normal borders on buttons
		Component[] components= c.getComponents();

		for (int i= 0; i < components.length; ++i)
		{
			setBorderToNormal(components[i]);
		}
	}

	/**
	 * Sets the border of the component to have a rollover border which
	 * was created by <code>createRolloverBorder</code>. 
	 *
	 * @param c component which will have a rollover border installed 
	 * @see #createRolloverBorder
	 * @since 1.4
	 */
	protected void setBorderToRollover(Component c)
	{
		if (c instanceof AbstractButton)
		{
			AbstractButton b= (AbstractButton) c;

			Border border= (Border) borderTable.get(b);
			if (border == null || border instanceof UIResource)
			{
				borderTable.put(b, b.getBorder());
			}
			// Don't set a border if the existing border is null
			if (b.getBorder() != null)
			{
				b.setBorder(rolloverBorder);
			}

			rolloverTable.put(
				b,
				b.isRolloverEnabled() ? Boolean.TRUE : Boolean.FALSE);
			b.setRolloverEnabled(true);
		}
	}

	/**
	 * Sets the border of the component to have a non-rollover border which
	 * was created by <code>createNonRolloverBorder</code>. 
	 *
	 * @param c component which will have a non-rollover border installed 
	 * @see #createNonRolloverBorder
	 * @since 1.4
	 */
	protected void setBorderToNonRollover(Component c)
	{
		if (c instanceof AbstractButton)
		{
			AbstractButton b= (AbstractButton) c;

			Border border= (Border) borderTable.get(b);
			if (border == null || border instanceof UIResource)
			{
				borderTable.put(b, b.getBorder());
			}
			if (b.getBorder() != null)
			{
				if (b instanceof JToggleButton)
				{
					((JToggleButton) b).setBorder(nonRolloverToggleBorder);
				}
				else
				{
					// Don't set a border if the existing border is null
					b.setBorder(nonRolloverBorder);
				}
			}
			rolloverTable.put(
				b,
				b.isRolloverEnabled() ? Boolean.TRUE : Boolean.FALSE);
			b.setRolloverEnabled(false);
		}
	}

	/**
	 * Sets the border of the component to have a normal border.
	 * A normal border is the original border that was installed on the child
	 * component before it was added to the toolbar.
	 *
	 * @param c component which will have a normal border re-installed 
	 * @see #createNonRolloverBorder
	 * @since 1.4
	 */
	protected void setBorderToNormal(Component c)
	{
		if (c instanceof AbstractButton)
		{
			AbstractButton b= (AbstractButton) c;

			Border border= (Border) borderTable.remove(b);
			b.setBorder(border);

			Boolean value= (Boolean) rolloverTable.remove(b);
			if (value != null)
			{
				b.setRolloverEnabled(value.booleanValue());
			}
		}
	}

	public Dimension getMinimumSize(JComponent c)
	{
		return getPreferredSize(c);
	}

	public Dimension getPreferredSize(JComponent c)
	{
		return null; 
	}

	public Dimension getMaximumSize(JComponent c)
	{
		return getPreferredSize(c);
	}


//	public void paint(Graphics g, JComponent c)
//	{
//		super.paint(g, c);
//		
//		g.setColor(UIManager.getColor("Button.borderColor"));
//			
//		switch(toolBar.getOrientation())
//		{
//			case WEST:
//				break;
//				
//			case NORTH:
//				g.setColor(Color.WHITE);
//				g.drawLine(0, c.getHeight()-2, c.getWidth()-1, c.getHeight()-2);
//				g.setColor(UIManager.getColor("Button.borderColor"));
//				g.drawLine(0, c.getHeight()-1, c.getWidth()-1, c.getHeight()-1);
//				break;
//					
//			case SOUTH:
//			case EAST:
//		}
//	}


	public void setFloatingLocation(int x, int y)
	{
		floatingX= x;
		floatingY= y;
	}

	public boolean isFloating()
	{
		return floating;
	}

	public void setFloating(boolean b, Point p)
	{
		if (toolBar.isFloatable() == true)
		{
			if (dragWindow != null)
				dragWindow.setVisible(false);
			this.floating= b;
			if (b == true)
			{
				if (dockingSource == null)
				{
					dockingSource= toolBar.getParent();
					dockingSource.remove(toolBar);
				}
				Point l= new Point();
				toolBar.getLocation(l);
				constraintBeforeFloating= calculateConstraint(dockingSource, l);
				if (propertyListener != null)
					UIManager.addPropertyChangeListener(propertyListener);
				if (floatingToolBar == null)
					floatingToolBar= createFloatingWindow(toolBar);
				floatingToolBar.getContentPane().add(toolBar, BorderLayout.CENTER);
				setOrientation(JToolBar.HORIZONTAL);
				if (floatingToolBar instanceof Window)
					 ((Window) floatingToolBar).pack();
				if (floatingToolBar instanceof Window)
					 ((Window) floatingToolBar).setLocation(floatingX, floatingY);
				if (floatingToolBar instanceof Window)
					 ((Window) floatingToolBar).show();
			}
			else
			{
				if (floatingToolBar == null)
					floatingToolBar= createFloatingWindow(toolBar);
				if (floatingToolBar instanceof Window)
					 ((Window) floatingToolBar).setVisible(false);
				floatingToolBar.getContentPane().remove(toolBar);
				String constraint= getDockingConstraint(dockingSource, p);
				int orientation= mapConstraintToOrientation(constraint);
				setOrientation(orientation);
				if (dockingSource == null)
					dockingSource= toolBar.getParent();
				if (propertyListener != null)
					UIManager.removePropertyChangeListener(propertyListener);
				dockingSource.add(constraint, toolBar);
			}
			dockingSource.invalidate();
			Container dockingSourceParent= dockingSource.getParent();
			if (dockingSourceParent != null)
				dockingSourceParent.validate();
			dockingSource.repaint();
		}
	}

	private int mapConstraintToOrientation(String constraint)
	{
		int orientation= toolBar.getOrientation();

		if (constraint != null)
		{
			if (constraint.equals(BorderLayout.EAST)
				|| constraint.equals(BorderLayout.WEST))
				orientation= JToolBar.VERTICAL;
			else if (
				constraint.equals(BorderLayout.NORTH)
					|| constraint.equals(BorderLayout.SOUTH))
				orientation= JToolBar.HORIZONTAL;
		}

		return orientation;
	}

	public void setOrientation(int orientation)
	{
		toolBar.setOrientation(orientation);

		if(toolBar.getOrientation()==JToolBar.HORIZONTAL)
			toolBar.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
		else
			toolBar.setLayout(new VerticalFlowLayout(VerticalFlowLayout.TOP, 0, 0));
		
		if (dragWindow != null)
			dragWindow.setOrientation(orientation);
	}

	/**
	 * Gets the color displayed when over a docking area
	 */
	public Color getDockingColor()
	{
		return dockingColor;
	}

	/**
	 * Sets the color displayed when over a docking area
	 */
	public void setDockingColor(Color c)
	{
		this.dockingColor= c;
	}

	/**
	 * Gets the color displayed when over a floating area
	 */
	public Color getFloatingColor()
	{
		return floatingColor;
	}

	/**
	 * Sets the color displayed when over a floating area
	 */
	public void setFloatingColor(Color c)
	{
		this.floatingColor= c;
	}

	public boolean canDock(Component c, Point p)
	{
		boolean b= false;
		if (c.contains(p))
		{
			dockingSensitivity=
				(toolBar.getOrientation() == JToolBar.HORIZONTAL)
					? toolBar.getSize().height
					: toolBar.getSize().width;
			// North
			if (p.y < dockingSensitivity)
				b= true;
			// South
			if (p.y > c.getSize().height - dockingSensitivity)
				b= true;
			// West  (Base distance on height for now!)
			if (p.x < dockingSensitivity)
				b= true;
			// East  (Base distance on height for now!)
			if (p.x > c.getSize().width - dockingSensitivity)
				b= true;
		}
		return b;
	}

	private String calculateConstraint(Component c, Point p)