/**
* Returns the minimum amount of space the layout needs.
*
* @param the Container for which this layout manager is being used
* @return a Dimension object containing the layout's minimum size
*/
public Dimension minimumLayoutSize(Container parent) {
Dimension cpd;
int cpWidth = 0;
int cpHeight = 0;
int mbWidth = 0;
int mbHeight = 0;
int tpWidth = 0;
Insets i = parent.getInsets();
JRootPane root = (JRootPane) parent;
if (root.getContentPane() != null) {
cpd = root.getContentPane().getMinimumSize();
} else {
cpd = root.getSize();
}
if (cpd != null) {
cpWidth = cpd.width;
cpHeight = cpd.height;
}
return new Dimension(
Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,
cpHeight + mbHeight + tpWidth + i.top + i.bottom);
}
@Override
public Dimension getMinimumSize(JComponent c) {
AbstractButton b = (AbstractButton) c;
String style = (String) c.getClientProperty("Quaqua.Button.style");
if (style == null) {
style = "push";
}
if (style.equals("help")) {
return getPreferredSize(c);
}
Dimension d = super.getMinimumSize(c);
if (isFixedHeight(c)) {
Dimension p = getPreferredSize(c);
if (d != null && p != null) {
d.height = Math.max(d.height, p.height);
}
}
if (!QuaquaUtilities.isSmallSizeVariant(c)
&& style.equals("push") //
&& b.getIcon() == null
&& b.getText() != null) {
if (d != null) {
d.width = Math.max(d.width, UIManager.getInt("Button.minimumWidth"));
}
}
return d;
}
/**
* 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;
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;
}
}
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);
}
/**
* Stores the position and size of the bouncing box that would be painted for the current
* animation index in <code>r</code> and returns <code>r</code>. Subclasses that add to the
* painting performed in this class's implementation of <code>paintIndeterminate</code> -- to draw
* an outline around the bouncing box, for example -- can use this method to get the location of
* the bouncing box that was just painted. By overriding this method, you have complete control
* over the size and position of the bouncing box, without having to reimplement <code>
* paintIndeterminate</code>.
*
* @param r the Rectangle instance to be modified; may be <code>null</code>
* @return <code>null</code> if no box should be drawn; otherwise, returns the passed-in rectangle
* (if non-null) or a new rectangle
* @see #setAnimationIndex
* @since 1.4
*/
protected Rectangle getBox(Rectangle r) {
int currentFrame = getAnimationIndex();
int middleFrame = numFrames / 2;
if (sizeChanged() || delta == 0.0 || maxPosition == 0.0) {
updateSizes();
}
r = getGenericBox(r);
if (r == null) {
return null;
}
if (middleFrame <= 0) {
return null;
}
// assert currentFrame >= 0 && currentFrame < numFrames
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
if (currentFrame < middleFrame) {
r.x = componentInnards.x + (int) Math.round(delta * (double) currentFrame);
} else {
r.x = maxPosition - (int) Math.round(delta * (currentFrame - middleFrame));
}
} else { // VERTICAL indeterminate progress bar
if (currentFrame < middleFrame) {
r.y = componentInnards.y + (int) Math.round(delta * currentFrame);
} else {
r.y = maxPosition - (int) Math.round(delta * (currentFrame - middleFrame));
}
}
return r;
}
public int filterRGB(int x, int y, int rgb) {
int r = ((rgb >> 16) & 0xff);
int g = ((rgb >> 8) & 0xff);
int b = (rgb & 0xff);
int gray = Math.max(Math.max(r, g), b);
return (rgb & 0xff000000) | (gray << 16) | (gray << 8) | (gray << 0);
}
/**
* Returns the amount of space the layout would like to have.
*
* @param the Container for which this layout manager is being used
* @return a Dimension object containing the layout's preferred size
*/
public Dimension preferredLayoutSize(Container parent) {
Dimension cpd, tpd;
int cpWidth = 0;
int cpHeight = 0;
int mbWidth = 0;
int mbHeight = 0;
int tpWidth = 0;
Insets i = parent.getInsets();
JRootPane root = (JRootPane) parent;
if (root.getContentPane() != null) {
cpd = root.getContentPane().getPreferredSize();
} else {
cpd = root.getSize();
}
if (cpd != null) {
cpWidth = cpd.width;
cpHeight = cpd.height;
}
if (root.getWindowDecorationStyle() != JRootPane.NONE
&& (root.getUI() instanceof RootPaneUI)) {
JComponent titlePane = ((RootPaneUI) root.getUI()).getTitlePane();
if (titlePane != null) {
tpd = titlePane.getPreferredSize();
if (tpd != null) {
tpWidth = tpd.width;
}
}
}
return new Dimension(
Math.max(Math.max(cpWidth, mbWidth), tpWidth) + i.left + i.right,
cpHeight + mbHeight + tpWidth + i.top + i.bottom);
}
/*
* (non-Javadoc)
*
* @see
* org.jvnet.flamingo.common.ui.BasicCommandButtonUI#paintButtonBackground
* (java.awt.Graphics, java.awt.Rectangle)
*/
@Override
protected void paintButtonBackground(Graphics graphics, Rectangle toFill) {
if (SubstanceCoreUtilities.isButtonNeverPainted(this.commandButton)) return;
ButtonModel actionModel = this.commandButton.getActionModel();
PopupButtonModel popupModel = ((JCommandButton) this.commandButton).getPopupModel();
Rectangle actionArea = this.getLayoutInfo().actionClickArea;
Rectangle popupArea = this.getLayoutInfo().popupClickArea;
BufferedImage fullAlphaBackground =
CommandButtonBackgroundDelegate.getCombinedCommandButtonBackground(
this.commandButton, actionModel, actionArea, popupModel, popupArea);
// Two special cases here:
// 1. Button has flat appearance and doesn't show the popup
// 2. Button is disabled.
// For both cases, we need to set custom translucency.
boolean isFlat =
this.commandButton.isFlat()
&& !((JCommandButton) this.commandButton).getPopupModel().isPopupShowing();
boolean isSpecial = isFlat || !this.commandButton.isEnabled();
float extraAlpha = 1.0f;
if (isSpecial) {
if (isFlat) {
float extraActionAlpha = 0.0f;
for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry :
getActionTransitionTracker().getModelStateInfo().getStateContributionMap().entrySet()) {
ComponentState activeState = activeEntry.getKey();
if (activeState.isDisabled()) continue;
if (activeState == ComponentState.ENABLED) continue;
extraActionAlpha += activeEntry.getValue().getContribution();
}
float extraPopupAlpha = 0.0f;
for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry :
getPopupTransitionTracker().getModelStateInfo().getStateContributionMap().entrySet()) {
ComponentState activeState = activeEntry.getKey();
if (activeState.isDisabled()) continue;
if (activeState == ComponentState.ENABLED) continue;
extraPopupAlpha += activeEntry.getValue().getContribution();
}
extraAlpha = Math.max(extraActionAlpha, extraPopupAlpha);
} else {
ComponentState actionAreaState = ComponentState.getState(actionModel, this.commandButton);
if (actionAreaState.isDisabled()) {
extraAlpha = SubstanceColorSchemeUtilities.getAlpha(this.commandButton, actionAreaState);
}
}
}
// System.out.println(extraAlpha);
extraAlpha = Math.min(1.0f, extraAlpha);
if (extraAlpha > 0.0f) {
Graphics2D g2d = (Graphics2D) graphics.create();
g2d.setComposite(
LafWidgetUtilities.getAlphaComposite(this.commandButton, extraAlpha, graphics));
g2d.drawImage(fullAlphaBackground, 0, 0, null);
g2d.dispose();
}
}
/**
* 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 HokageRootPaneUI)) {
JComponent titlePane = ((HokageRootPaneUI) 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);
}
/*
* Borders are handled by the UI since they are shared between cells
* and therefore must overlay after the painting of the cells
*/
private void paintBorders(Graphics g, int rowMin, int rowMax, int colMin, int colMax) {
// Include borders from adjacent rows/columns of the clip region
rowMin = Math.max(0, rowMin - 1);
rowMax = Math.min(grid.getRowCount() - 1, rowMax + 1);
colMin = Math.max(0, colMin - 1);
colMax = Math.min(grid.getColumnCount() - 1, colMax + 1);
for (int row = rowMin; row <= rowMax; row++) {
for (int column = colMin; column <= colMax; column++) {
Rectangle cellRect = grid.getCellBounds(row, column);
paintBorder(g, cellRect, row, column);
}
}
}
/**
* Restricts the region based on the receivers offsets and messages the painter to paint the
* region.
*/
void paintLayeredHighlights(
Graphics g, int p0, int p1, Shape viewBounds, JTextComponent editor, View view) {
int start = getStartOffset();
int end = getEndOffset();
// Restrict the region to what we represent
p0 = Math.max(start, p0);
p1 = Math.min(end, p1);
// Paint the appropriate region using the painter and union
// the effected region with our bounds.
union(
((LayeredHighlighter.LayerPainter) painter)
.paintLayer(g, p0, p1, viewBounds, editor, view));
}
/**
* This determines the amount of the progress bar that should be filled based on the percent done
* gathered from the model. This is a common operation so it was abstracted out. It assumes that
* your progress bar is linear. That is, if you are making a circular progress indicator, you will
* want to override this method.
*/
protected int getAmountFull(Insets b, int width, int height) {
int amountFull = 0;
BoundedRangeModel model = progressBar.getModel();
if ((model.getMaximum() - model.getMinimum()) != 0) {
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
amountFull = (int) Math.round(width * progressBar.getPercentComplete());
} else {
amountFull = (int) Math.round(height * progressBar.getPercentComplete());
}
}
return amountFull;
}
/** Removes all highlights. */
public void removeAllHighlights() {
TextUI mapper = component.getUI();
if (getDrawsLayeredHighlights()) {
int len = highlights.size();
if (len != 0) {
int minX = 0;
int minY = 0;
int maxX = 0;
int maxY = 0;
int p0 = -1;
int p1 = -1;
for (int i = 0; i < len; i++) {
HighlightInfo hi = highlights.elementAt(i);
if (hi instanceof LayeredHighlightInfo) {
LayeredHighlightInfo info = (LayeredHighlightInfo) hi;
minX = Math.min(minX, info.x);
minY = Math.min(minY, info.y);
maxX = Math.max(maxX, info.x + info.width);
maxY = Math.max(maxY, info.y + info.height);
} else {
if (p0 == -1) {
p0 = hi.p0.getOffset();
p1 = hi.p1.getOffset();
} else {
p0 = Math.min(p0, hi.p0.getOffset());
p1 = Math.max(p1, hi.p1.getOffset());
}
}
}
if (minX != maxX && minY != maxY) {
component.repaint(minX, minY, maxX - minX, maxY - minY);
}
if (p0 != -1) {
try {
safeDamageRange(p0, p1);
} catch (BadLocationException e) {
}
}
highlights.removeAllElements();
}
} else if (mapper != null) {
int len = highlights.size();
if (len != 0) {
int p0 = Integer.MAX_VALUE;
int p1 = 0;
for (int i = 0; i < len; i++) {
HighlightInfo info = highlights.elementAt(i);
p0 = Math.min(p0, info.p0.getOffset());
p1 = Math.max(p1, info.p1.getOffset());
}
try {
safeDamageRange(p0, p1);
} catch (BadLocationException e) {
}
highlights.removeAllElements();
}
}
}
private static boolean computeIntersection(Rectangle dest, int rx, int ry, int rw, int rh) {
int x1 = Math.max(rx, dest.x);
int x2 = Math.min(rx + rw, dest.x + dest.width);
int y1 = Math.max(ry, dest.y);
int y2 = Math.min(ry + rh, dest.y + dest.height);
dest.x = x1;
dest.y = y1;
dest.width = x2 - x1;
dest.height = y2 - y1;
if (dest.width <= 0 || dest.height <= 0) {
return false;
}
return true;
}
protected void paintImage(
Component c, Graphics g, int x, int y, int imageW, int imageH, Image image, Object[] args) {
boolean isVertical = ((Boolean) args[1]).booleanValue();
// Render to the screen
g.translate(x, y);
if (isVertical) {
for (int counter = 0; counter < w; counter += IMAGE_SIZE) {
int tileSize = Math.min(IMAGE_SIZE, w - counter);
g.drawImage(image, counter, 0, counter + tileSize, h, 0, 0, tileSize, h, null);
}
} else {
for (int counter = 0; counter < h; counter += IMAGE_SIZE) {
int tileSize = Math.min(IMAGE_SIZE, h - counter);
g.drawImage(image, 0, counter, w, counter + tileSize, 0, 0, w, tileSize, null);
}
}
g.translate(-x, -y);
}
protected void setButtonsSize() {
int nMaxWidth = 0, nMaxHeight = 0;
Dimension objSize;
Iterator objIterator = buttons.values().iterator();
while (objIterator.hasNext()) {
JButton objButton = (JButton) objIterator.next();
objButton.setPreferredSize(null);
objSize = objButton.getPreferredSize();
nMaxWidth = Math.max(nMaxWidth, objSize.width);
nMaxHeight = Math.max(nMaxHeight, objSize.height);
}
objSize = new Dimension(nMaxWidth, nMaxHeight);
d = objSize;
objIterator = buttons.values().iterator();
while (objIterator.hasNext()) {
((JButton) objIterator.next()).setPreferredSize(objSize);
}
}
/**
* Designate the place where the progress string will be painted. This implementation places it at
* the center of the progress bar (in both x and y). Override this if you want to right, left,
* top, or bottom align the progress string or if you need to nudge it around for any reason.
*/
protected Point getStringPlacement(
Graphics g, String progressString, int x, int y, int width, int height) {
FontMetrics fontSizer = SwingUtilities2.getFontMetrics(progressBar, g, progressBar.getFont());
int stringWidth = SwingUtilities2.stringWidth(progressBar, fontSizer, progressString);
if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
return new Point(
x + Math.round(width / 2 - stringWidth / 2),
y
+ ((height + fontSizer.getAscent() - fontSizer.getLeading() - fontSizer.getDescent())
/ 2));
} else { // VERTICAL
return new Point(
x
+ ((width - fontSizer.getAscent() + fontSizer.getLeading() + fontSizer.getDescent())
/ 2),
y + Math.round(height / 2 - stringWidth / 2));
}
}
@Override
public Dimension getMaximumSize(JComponent c) {
String style = (String) c.getClientProperty("Quaqua.Button.style");
if (style != null && style.equals("help")) {
return getPreferredSize(c);
}
Dimension d = super.getMaximumSize(c);
if (isFixedHeight(c)) {
Dimension p = getPreferredSize(c);
d.height = Math.max(d.height, p.height);
}
return d;
}
void union(Shape bounds) {
if (bounds == null) return;
Rectangle alloc;
if (bounds instanceof Rectangle) {
alloc = (Rectangle) bounds;
} else {
alloc = bounds.getBounds();
}
if (width == 0 || height == 0) {
x = alloc.x;
y = alloc.y;
width = alloc.width;
height = alloc.height;
} else {
width = Math.max(x + width, alloc.x + alloc.width);
height = Math.max(y + height, alloc.y + alloc.height);
x = Math.min(x, alloc.x);
width -= x;
y = Math.min(y, alloc.y);
height -= y;
}
}
/**
* Computes the alpha value for painting the separators.
*
* @return Alpha value for painting the separators.
*/
private float getSeparatorAlpha() {
ComponentState actionAreaState =
this.getActionTransitionTracker().getModelStateInfo().getCurrModelState();
if (!actionAreaState.isFacetActive(ComponentStateFacet.SELECTION)
&& !actionAreaState.isDisabled()) {
float actionRolloverCycle =
this.getActionTransitionTracker().getFacetStrength(ComponentStateFacet.ROLLOVER);
float popupRolloverCycle =
this.getPopupTransitionTracker().getFacetStrength(ComponentStateFacet.ROLLOVER);
return Math.min(1.0f, actionRolloverCycle + popupRolloverCycle);
}
return 1.0f;
}
public int filterRGB(int x, int y, int rgb) {
// Coefficients are from the sRGB color space:
int gray =
Math.min(
255,
(int)
(((0.2125f * ((rgb >> 16) & 0xFF))
+ (0.7154f * ((rgb >> 8) & 0xFF))
+ (0.0721f * (rgb & 0xFF))
+ .5f)
* factor
+ min));
return (rgb & 0xff000000) | (gray << 16) | (gray << 8) | (gray << 0);
}
/** Initialize cycleTime, repaintInterval, numFrames, animationIndex. */
private void initIndeterminateDefaults() {
initRepaintInterval(); // initialize repaint interval
initCycleTime(); // initialize cycle length
// Make sure repaintInterval is reasonable.
if (repaintInterval <= 0) {
repaintInterval = 100;
}
// Make sure cycleTime is reasonable.
if (repaintInterval > cycleTime) {
cycleTime = repaintInterval * 20;
} else {
// Force cycleTime to be a even multiple of repaintInterval.
int factor = (int) Math.ceil(((double) cycleTime) / ((double) repaintInterval * 2));
cycleTime = repaintInterval * factor * 2;
}
}
/**
* Paints a portion of a highlight.
*
* @param g the graphics context
* @param offs0 the starting model offset >= 0
* @param offs1 the ending model offset >= offs1
* @param bounds the bounding box of the view, which is not necessarily the region to paint.
* @param c the editor
* @param view View painting for
* @return region drawing occurred in
*/
public Shape paintLayer(
Graphics g, int offs0, int offs1, Shape bounds, JTextComponent c, View view) {
Color color = getColor();
if (color == null) {
g.setColor(c.getSelectionColor());
} else {
g.setColor(color);
}
Rectangle r;
if (offs0 == view.getStartOffset() && offs1 == view.getEndOffset()) {
// Contained in view, can just use bounds.
if (bounds instanceof Rectangle) {
r = (Rectangle) bounds;
} else {
r = bounds.getBounds();
}
} else {
// Should only render part of View.
try {
// --- determine locations ---
Shape shape =
view.modelToView(offs0, Position.Bias.Forward, offs1, Position.Bias.Backward, bounds);
r = (shape instanceof Rectangle) ? (Rectangle) shape : shape.getBounds();
} catch (BadLocationException e) {
// can't render
r = null;
}
}
if (r != null) {
// If we are asked to highlight, we should draw something even
// if the model-to-view projection is of zero width (6340106).
r.width = Math.max(r.width, 1);
g.fillRect(r.x, r.y, r.width, r.height);
}
return r;
}
/**
* Changes a highlight.
*
* @param tag the highlight tag
* @param p0 the beginning of the range >= 0
* @param p1 the end of the range >= p0
* @exception BadLocationException if the specified location is invalid
*/
public void changeHighlight(Object tag, int p0, int p1) throws BadLocationException {
if (p0 < 0) {
throw new BadLocationException("Invalid beginning of the range", p0);
}
if (p1 < p0) {
throw new BadLocationException("Invalid end of the range", p1);
}
Document doc = component.getDocument();
if (tag instanceof LayeredHighlightInfo) {
LayeredHighlightInfo lhi = (LayeredHighlightInfo) tag;
if (lhi.width > 0 && lhi.height > 0) {
component.repaint(lhi.x, lhi.y, lhi.width, lhi.height);
}
// Mark the highlights region as invalid, it will reset itself
// next time asked to paint.
lhi.width = lhi.height = 0;
lhi.p0 = doc.createPosition(p0);
lhi.p1 = doc.createPosition(p1);
safeDamageRange(Math.min(p0, p1), Math.max(p0, p1));
} else {
HighlightInfo info = (HighlightInfo) tag;
int oldP0 = info.p0.getOffset();
int oldP1 = info.p1.getOffset();
if (p0 == oldP0) {
safeDamageRange(Math.min(oldP1, p1), Math.max(oldP1, p1));
} else if (p1 == oldP1) {
safeDamageRange(Math.min(p0, oldP0), Math.max(p0, oldP0));
} else {
safeDamageRange(oldP0, oldP1);
safeDamageRange(p0, p1);
}
info.p0 = doc.createPosition(p0);
info.p1 = doc.createPosition(p1);
}
}
/**
* Paints the border for the specified component with the specified position and size.
*
* @param c the component for which this border is being painted
* @param g the paint graphics
* @param x the x position of the painted border
* @param y the y position of the painted border
* @param width the width of the painted border
* @param height the height of the painted border
*/
public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
Border border = getBorder();
if (label == null) {
if (border != null) {
border.paintBorder(c, g, x, y, width, height);
}
return;
}
Rectangle grooveRect =
new Rectangle(
x + EDGE_SPACING,
y + EDGE_SPACING,
width - (EDGE_SPACING * 2),
height - (EDGE_SPACING * 2));
Dimension labelDim = label.getPreferredSize();
int baseline = label.getBaseline(labelDim.width, labelDim.height);
int ascent = Math.max(0, baseline);
int descent = labelDim.height - ascent;
int diff;
Insets insets;
if (border != null) {
insets = border.getBorderInsets(c);
} else {
insets = new Insets(0, 0, 0, 0);
}
diff = Math.max(0, ascent / 2 + TEXT_SPACING - EDGE_SPACING);
grooveRect.y += diff;
grooveRect.height -= diff;
compLoc.y = grooveRect.y + insets.top / 2 - (ascent + descent) / 2 - 1;
int justification;
if (c.getComponentOrientation().isLeftToRight()) {
justification = LEFT;
} else {
justification = RIGHT;
}
switch (justification) {
case LEFT:
compLoc.x = grooveRect.x + TEXT_INSET_H + insets.left;
break;
case RIGHT:
compLoc.x =
(grooveRect.x + grooveRect.width - (labelDim.width + TEXT_INSET_H + insets.right));
break;
}
// If title is positioned in middle of border AND its fontsize
// is greater than the border's thickness, we'll need to paint
// the border in sections to leave space for the component's background
// to show through the title.
//
if (border != null) {
if (grooveRect.y > compLoc.y - ascent) {
Rectangle clipRect = new Rectangle();
// save original clip
Rectangle saveClip = g.getClipBounds();
// paint strip left of text
clipRect.setBounds(saveClip);
if (computeIntersection(clipRect, x, y, compLoc.x - 1 - x, height)) {
g.setClip(clipRect);
border.paintBorder(
c, g, grooveRect.x, grooveRect.y, grooveRect.width, grooveRect.height);
}
// paint strip right of text
clipRect.setBounds(saveClip);
if (computeIntersection(
clipRect,
compLoc.x + labelDim.width + 1,
y,
x + width - (compLoc.x + labelDim.width + 1),
height)) {
g.setClip(clipRect);
border.paintBorder(
c, g, grooveRect.x, grooveRect.y, grooveRect.width, grooveRect.height);
}
// paint strip below text
clipRect.setBounds(saveClip);
if (computeIntersection(
clipRect,
compLoc.x - 1,
compLoc.y + ascent + descent,
labelDim.width + 2,
y + height - compLoc.y - ascent - descent)) {
g.setClip(clipRect);
border.paintBorder(
c, g, grooveRect.x, grooveRect.y, grooveRect.width, grooveRect.height);
}
// restore clip
g.setClip(saveClip);
} else {
border.paintBorder(c, g, grooveRect.x, grooveRect.y, grooveRect.width, grooveRect.height);
}
label.setLocation(compLoc);
label.setSize(labelDim);
}
}
private int clipToRange(int i, int a, int b) {
return Math.min(Math.max(i, a), b - 1);
}
@Override
public void paint(Graphics g) {
Color origColor;
boolean isPressed, isRollOver, isEnabled;
int w, h, size;
w = getWidth();
h = getHeight();
origColor = g.getColor();
isPressed = getModel().isPressed();
isRollOver = getModel().isRollover();
isEnabled = isEnabled();
g.setColor(getBackground());
g.fillRect(0, 0, w, h);
g.setColor(shadow);
// Using the background color set above
if (direction == WEST) {
g.drawLine(0, 0, 0, h - 1); // left
g.drawLine(w - 1, 0, w - 1, 0); // right
} else g.drawLine(w - 2, h - 1, w - 2, 0); // right
g.drawLine(0, 0, w - 2, 0); // top
if (isRollOver) {
// do highlights or shadows
Color color1;
Color color2;
if (isPressed) {
color2 = Color.WHITE;
color1 = shadow;
} else {
color1 = Color.WHITE;
color2 = shadow;
}
g.setColor(color1);
if (direction == WEST) {
g.drawLine(1, 1, 1, h - 1); // left
g.drawLine(1, 1, w - 2, 1); // top
g.setColor(color2);
g.drawLine(w - 1, h - 1, w - 1, 1); // right
} else {
g.drawLine(0, 1, 0, h - 1);
g.drawLine(0, 1, w - 3, 1); // top
g.setColor(color2);
g.drawLine(w - 3, h - 1, w - 3, 1); // right
}
}
// g.drawLine(0, h - 1, w - 1, h - 1); //bottom
// If there's no room to draw arrow, bail
if (h < 5 || w < 5) {
g.setColor(origColor);
return;
}
if (isPressed) {
g.translate(1, 1);
}
// Draw the arrow
size = Math.min((h - 4) / 3, (w - 4) / 3);
size = Math.max(size, 2);
boolean highlight = false;
if (!highlightedTabs.isEmpty()
&& ((direction == WEST && tabScroller.scrollBackwardButton.isEnabled())
|| (direction == EAST && tabScroller.scrollForwardButton.isEnabled()))) {
Rectangle viewRect = tabScroller.viewport.getViewRect();
if (direction == WEST) {
int leadingTabIndex = getClosestTab(viewRect.x, viewRect.y);
for (int i = 0; i < leadingTabIndex; i++) {
if (highlightedTabs.contains(i) && !isScrollTabVisible(i)) {
highlight = true;
break;
}
}
} else {
int leadingTabIndex = getClosestTab(viewRect.x + viewRect.y, viewRect.y);
for (int i = leadingTabIndex; i < tabPane.getTabCount(); i++) {
if (highlightedTabs.contains(i) && !isScrollTabVisible(i)) {
highlight = true;
break;
}
}
}
if (highlight) {
Image img =
DesktopUtilActivator.getImage(
direction == WEST
? "service.gui.icons.TAB_UNREAD_BACKWARD_ICON"
: "service.gui.icons.TAB_UNREAD_FORWARD_ICON");
int wi = img.getWidth(null);
g.drawImage(img, (w - wi) / 2, (h - size) / 2 - 2 /* 2 borders 1px width*/, null);
}
}
if (!highlight) paintTriangle(g, (w - size) / 2, (h - size) / 2, size, direction, isEnabled);
// Reset the Graphics back to it's original settings
if (isPressed) {
g.translate(-1, -1);
}
g.setColor(origColor);
}
/**
* Returns the length of the "bouncing box" to be painted. This method is invoked by the default
* implementation of <code>paintIndeterminate</code> to get the width (if the progress bar is
* horizontal) or height (if vertical) of the box. For example:
*
* <blockquote>
*
* <pre>
* boxRect.width = getBoxLength(componentInnards.width,
* componentInnards.height);
* </pre>
*
* </blockquote>
*
* @param availableLength the amount of space available for the bouncing box to move in; for a
* horizontal progress bar, for example, this should be the inside width of the progress bar
* (the component width minus borders)
* @param otherDimension for a horizontal progress bar, this should be the inside height of the
* progress bar; this value might be used to constrain or determine the return value
* @return the size of the box dimension being determined; must be no larger than <code>
* availableLength</code>
* @see javax.swing.SwingUtilities#calculateInnerArea
* @since 1.5
*/
protected int getBoxLength(int availableLength, int otherDimension) {
return (int) Math.round(availableLength / 6.0);
}
public static Dimension getPreferredSize(AbstractButton b) {
String style = (String) b.getClientProperty("Quaqua.Button.style");
if (style == null) {
style = "push";
}
if (style.equals("help")) {
Icon helpIcon = UIManager.getIcon("Button.helpIcon");
Insets insets = b.getInsets();
return new Dimension(
helpIcon.getIconWidth() + insets.left + insets.right,
helpIcon.getIconHeight() + insets.top + insets.bottom);
}
if (b.getComponentCount() > 0) {
return null;
}
int textIconGap = Methods.invokeGetter(b, "getIconTextGap", 4);
Icon icon = (Icon) b.getIcon();
String text = b.getText();
Font font = b.getFont();
FontMetrics fm = b.getFontMetrics(font);
viewR.x = viewR.y = 0;
viewR.width = Short.MAX_VALUE;
viewR.height = Short.MAX_VALUE;
iconR.x = iconR.y = iconR.width = iconR.height = 0;
textR.x = textR.y = textR.width = textR.height = 0;
SwingUtilities.layoutCompoundLabel(
(JComponent) b,
fm,
text,
icon,
b.getVerticalAlignment(),
b.getHorizontalAlignment(),
b.getVerticalTextPosition(),
b.getHorizontalTextPosition(),
viewR,
iconR,
textR,
(text == null ? 0 : textIconGap));
/* The preferred size of the button is the size of
* the text and icon rectangles plus the buttons insets.
*/
Rectangle r = iconR.union(textR);
// if (b.isBorderPainted()) {
Insets insets = b.getInsets();
r.width += insets.left + insets.right;
r.height += insets.top + insets.bottom;
// }
if (!QuaquaUtilities.isSmallSizeVariant(b)
&& style.equals("push")
&& b.getIcon() == null
&& b.getText() != null) {
r.width = Math.max(r.width, UIManager.getInt("Button.minimumWidth"));
}
return r.getSize();
}