public Dimension preferredLayoutSize(Container parent) {
JToolBar tb = (JToolBar) parent;
Insets insets = tb.getInsets();
Dimension dim = new Dimension();
SeaGlassContext context = getContext(tb);
if (tb.getOrientation() == JToolBar.HORIZONTAL) {
dim.width = tb.isFloatable() ? SeaGlassIcon.getIconWidth(handleIcon, context) : 0;
Dimension compDim;
for (int i = 0; i < tb.getComponentCount(); i++) {
Component component = tb.getComponent(i);
if (component.isVisible()) {
compDim = component.getPreferredSize();
dim.width += compDim.width;
dim.height = Math.max(dim.height, compDim.height);
}
}
} else {
dim.height = tb.isFloatable() ? SeaGlassIcon.getIconHeight(handleIcon, context) : 0;
Dimension compDim;
for (int i = 0; i < tb.getComponentCount(); i++) {
Component component = tb.getComponent(i);
if (component.isVisible()) {
compDim = component.getPreferredSize();
dim.width = Math.max(dim.width, compDim.width);
dim.height += compDim.height;
}
}
}
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom;
context.dispose();
return dim;
}
/**
* This method is called when the mouse is pressed in the JToolBar. If the press doesn't occur
* in a place where it causes the JToolBar to be dragged, it returns. Otherwise, it starts a
* drag session.
*
* @param e The MouseEvent.
*/
public void mousePressed(MouseEvent e) {
if (!toolBar.isFloatable()) return;
Point ssd = e.getPoint();
Insets insets = toolBar.getInsets();
// Verify that this click occurs in the top inset.
if (toolBar.getOrientation() == SwingConstants.HORIZONTAL) {
if (e.getX() > insets.left) return;
} else {
if (e.getY() > insets.top) return;
}
origin = new Point(0, 0);
if (toolBar.isShowing()) SwingUtilities.convertPointToScreen(ssd, toolBar);
if (!(SwingUtilities.getAncestorOfClass(Window.class, toolBar) instanceof UIResource))
// Need to know who keeps the toolBar if it gets dragged back into it.
origParent = toolBar.getParent();
if (toolBar.isShowing()) SwingUtilities.convertPointToScreen(origin, toolBar);
isDragging = true;
if (dragWindow != null)
dragWindow.setOffset(new Point(cachedBounds.width / 2, cachedBounds.height / 2));
dragTo(e.getPoint(), origin);
}
/**
* This method returns the border insets for the JToolBar.
*
* @param c The Component to find insets for.
* @return The border insets.
*/
public Insets getBorderInsets(Component c) {
if (c instanceof JToolBar) {
JToolBar tb = (JToolBar) c;
int orientation = tb.getOrientation();
if (!tb.isFloatable()) return new Insets(regular, regular, regular, regular);
else if (orientation == SwingConstants.HORIZONTAL)
return new Insets(regular, offset, regular, regular);
else return new Insets(offset, regular, regular, regular);
}
return new Insets(0, 0, 0, 0);
}
/**
* This method paints the border around the given Component.
*
* @param c The Component whose border is being painted.
* @param g The Graphics object to paint with.
* @param x The x coordinate of the component.
* @param y The y coordinate of the component.
* @param width The width of the component.
* @param height The height of the component.
*/
public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
if (c instanceof JToolBar) {
JToolBar tb = (JToolBar) c;
int orientation = tb.getOrientation();
if (orientation == SwingConstants.HORIZONTAL) {
paintBumps(g, x, y, offset, height, 1, Color.WHITE);
paintBumps(g, x + 1, y + 1, offset - 1, height - 1, 1, Color.GRAY);
} else {
paintBumps(g, x, y, width, offset, 1, Color.WHITE);
paintBumps(g, x + 1, y + 1, width - 1, offset - 1, 1, Color.GRAY);
}
}
}
/**
* This method is called to drag the DragWindow around when the JToolBar is being dragged around.
*
* @param position The mouse cursor coordinates relative to the JToolBar.
* @param origin The screen position of the JToolBar.
*/
protected void dragTo(Point position, Point origin) {
int loc = areaOfClick(origParent, SwingUtilities.convertPoint(toolBar, position, origParent));
if (loc != -1) {
dragWindow.setBorderColor(dockingBorderColor);
dragWindow.setBackground(dockingColor);
} else {
dragWindow.setBorderColor(floatingBorderColor);
dragWindow.setBackground(floatingColor);
}
int w = 0;
int h = 0;
boolean tmp = (loc == SwingConstants.NORTH) || (loc == SwingConstants.SOUTH) || (loc == -1);
cachedOrientation = toolBar.getOrientation();
cachedBounds = toolBar.getSize();
if (((cachedOrientation == SwingConstants.HORIZONTAL) && tmp)
|| ((cachedOrientation == VERTICAL) && !tmp)) {
w = cachedBounds.width;
h = cachedBounds.height;
} else {
w = cachedBounds.height;
h = cachedBounds.width;
}
Point p = dragWindow.getOffset();
Insets insets = toolBar.getInsets();
dragWindow.setBounds(
(origin.x + position.x) - p.x - ((insets.left + insets.right) / 2),
(origin.y + position.y) - p.y - ((insets.top + insets.bottom) / 2),
w,
h);
if (!dragWindow.isVisible()) dragWindow.show();
}
@Override
public int getIconHeight(SynthContext context) {
if (context == null) {
return height;
}
JComponent c = context.getComponent();
if (c instanceof JToolBar) {
JToolBar toolbar = (JToolBar) c;
if (toolbar.getOrientation() == JToolBar.HORIZONTAL) {
// we only do the -1 hack for UIResource borders, assuming
// that the border is probably going to be our border
if (toolbar.getBorder() instanceof UIResource) {
return c.getHeight() - 1;
} else {
return c.getHeight();
}
} else {
return scale(context, width);
}
} else {
return scale(context, height);
}
}
@RunsInCurrentThread
private boolean isHorizontal(@Nonnull JToolBar toolBar) {
return toolBar.getOrientation() == HORIZONTAL;
}
@Override
public void paintIcon(SynthContext context, Graphics g, int x, int y, int w, int h) {
Painter painter = null;
if (context != null) {
painter = (Painter) context.getStyle().get(context, key);
}
if (painter == null) {
painter = (Painter) UIManager.get(prefix + "[Enabled]." + key);
}
if (painter != null && context != null) {
JComponent c = context.getComponent();
boolean rotate = false;
boolean flip = false;
// translatex and translatey are additional translations that
// must occur on the graphics context when rendering a toolbar
// icon
int translatex = 0;
int translatey = 0;
if (c instanceof JToolBar) {
JToolBar toolbar = (JToolBar) c;
rotate = toolbar.getOrientation() == JToolBar.VERTICAL;
flip = !toolbar.getComponentOrientation().isLeftToRight();
Object o = NimbusLookAndFeel.resolveToolbarConstraint(toolbar);
// we only do the +1 hack for UIResource borders, assuming
// that the border is probably going to be our border
if (toolbar.getBorder() instanceof UIResource) {
if (o == BorderLayout.SOUTH) {
translatey = 1;
} else if (o == BorderLayout.EAST) {
translatex = 1;
}
}
}
if (g instanceof Graphics2D) {
Graphics2D gfx = (Graphics2D) g;
gfx.translate(x, y);
gfx.translate(translatex, translatey);
if (rotate) {
gfx.rotate(Math.toRadians(90));
gfx.translate(0, -w);
painter.paint(gfx, context.getComponent(), h, w);
gfx.translate(0, w);
gfx.rotate(Math.toRadians(-90));
} else if (flip) {
gfx.scale(-1, 1);
gfx.translate(-w, 0);
painter.paint(gfx, context.getComponent(), w, h);
gfx.translate(w, 0);
gfx.scale(-1, 1);
} else {
painter.paint(gfx, context.getComponent(), w, h);
}
gfx.translate(-translatex, -translatey);
gfx.translate(-x, -y);
} else {
// use image if we are printing to a Java 1.1 PrintGraphics as
// it is not a instance of Graphics2D
BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
Graphics2D gfx = img.createGraphics();
if (rotate) {
gfx.rotate(Math.toRadians(90));
gfx.translate(0, -w);
painter.paint(gfx, context.getComponent(), h, w);
} else if (flip) {
gfx.scale(-1, 1);
gfx.translate(-w, 0);
painter.paint(gfx, context.getComponent(), w, h);
} else {
painter.paint(gfx, context.getComponent(), w, h);
}
gfx.dispose();
g.drawImage(img, x, y, null);
img = null;
}
}
}
public void layoutContainer(Container parent) {
JToolBar tb = (JToolBar) parent;
Insets insets = tb.getInsets();
boolean ltr = tb.getComponentOrientation().isLeftToRight();
SeaGlassContext context = getContext(tb);
Component c;
Dimension d;
// JToolBar by default uses a somewhat modified BoxLayout as
// its layout manager. For compatibility reasons, we want to
// support Box "glue" as a way to move things around on the
// toolbar. "glue" is represented in BoxLayout as a Box.Filler
// with a minimum and preferred size of (0,0).
// So what we do here is find the number of such glue fillers
// and figure out how much space should be allocated to them.
int glueCount = 0;
for (int i = 0; i < tb.getComponentCount(); i++) {
if (isGlue(tb.getComponent(i))) glueCount++;
}
if (tb.getOrientation() == JToolBar.HORIZONTAL) {
int handleWidth = tb.isFloatable() ? SeaGlassIcon.getIconWidth(handleIcon, context) : 0;
// Note: contentRect does not take insets into account
// since it is used for determining the bounds that are
// passed to paintToolBarContentBackground().
contentRect.x = ltr ? handleWidth : 0;
contentRect.y = 0;
contentRect.width = tb.getWidth() - handleWidth;
contentRect.height = tb.getHeight();
// However, we do take the insets into account here for
// the purposes of laying out the toolbar child components.
int x = ltr ? handleWidth + insets.left : tb.getWidth() - handleWidth - insets.right;
int baseY = insets.top;
int baseH = tb.getHeight() - insets.top - insets.bottom;
// we need to get the minimum width for laying things out
// so that we can calculate how much empty space needs to
// be distributed among the "glue", if any
int extraSpacePerGlue = 0;
if (glueCount > 0) {
int minWidth = minimumLayoutSize(parent).width;
extraSpacePerGlue = (tb.getWidth() - minWidth) / glueCount;
if (extraSpacePerGlue < 0) extraSpacePerGlue = 0;
}
for (int i = 0; i < tb.getComponentCount(); i++) {
c = tb.getComponent(i);
if (c.isVisible()) {
d = c.getPreferredSize();
int y, h;
if (d.height >= baseH || c instanceof JSeparator) {
// Fill available height
y = baseY;
h = baseH;
} else {
// Center component vertically in the available
// space
y = baseY + (baseH / 2) - (d.height / 2);
h = d.height;
}
// if the component is a "glue" component then add to
// its
// width the extraSpacePerGlue it is due
if (isGlue(c)) d.width += extraSpacePerGlue;
c.setBounds(ltr ? x : x - d.width, y, d.width, h);
x = ltr ? x + d.width : x - d.width;
}
}
} else {
int handleHeight = tb.isFloatable() ? SeaGlassIcon.getIconHeight(handleIcon, context) : 0;
// See notes above regarding the use of insets
contentRect.x = 0;
contentRect.y = handleHeight;
contentRect.width = tb.getWidth();
contentRect.height = tb.getHeight() - handleHeight;
int baseX = insets.left;
int baseW = tb.getWidth() - insets.left - insets.right;
int y = handleHeight + insets.top;
// we need to get the minimum height for laying things out
// so that we can calculate how much empty space needs to
// be distributed among the "glue", if any
int extraSpacePerGlue = 0;
if (glueCount > 0) {
int minHeight = minimumLayoutSize(parent).height;
extraSpacePerGlue = (tb.getHeight() - minHeight) / glueCount;
if (extraSpacePerGlue < 0) extraSpacePerGlue = 0;
}
for (int i = 0; i < tb.getComponentCount(); i++) {
c = tb.getComponent(i);
if (c.isVisible()) {
d = c.getPreferredSize();
int x, w;
if (d.width >= baseW || c instanceof JSeparator) {
// Fill available width
x = baseX;
w = baseW;
} else {
// Center component horizontally in the available
// space
x = baseX + (baseW / 2) - (d.width / 2);
w = d.width;
}
// if the component is a "glue" component then add to
// its
// height the extraSpacePerGlue it is due
if (isGlue(c)) d.height += extraSpacePerGlue;
c.setBounds(x, y, w, d.height);
y += d.height;
}
}
}
context.dispose();
}