protected void paintGrid(Graphics g, int rowMin, int rowMax, int colMin, int colMax) {
if (!grid.getShowGrid()) {
return; // do nothing
}
int y1 = grid.getRowPosition(rowMin);
int y2 = grid.getRowPosition(rowMax) + grid.getRowHeight(rowMax);
int x1 = grid.getColumnPosition(colMin);
int x2 = grid.getColumnPosition(colMax) + grid.getColumnWidth(colMax);
g.setColor(grid.getGridColor());
// Draw the horizontal lines
for (int row = rowMin; row <= rowMax; row++) {
int rowY = grid.getRowPosition(row);
g.drawLine(x1, rowY, x2, rowY);
}
g.drawLine(x1, y2, x2, y2);
// Draw the vertical gridlines
for (int col = colMin; col <= colMax; col++) {
int colX = grid.getColumnPosition(col);
g.drawLine(colX, y1, colX, y2);
}
g.drawLine(x2, y1, x2, y2);
}
protected void paintButtonPressed(Graphics g, AbstractButton b) {
if (b.isContentAreaFilled()) {
Dimension size = b.getSize();
g.setColor(getSelectColor());
g.fillRect(0, 0, size.width, size.height);
}
}
protected void paintBackground(Graphics g, JComponent c, int x, int y, int w, int h) {
JMenuItem b = (JMenuItem) c;
ButtonModel model = b.getModel();
if (c.getParent() instanceof JMenuBar) {
if (model.isArmed() || (c instanceof JMenu && model.isSelected())) {
g.setColor(AbstractLookAndFeel.getMenuSelectionBackgroundColor());
g.fillRect(x, y, w, h);
}
} else {
if (model.isArmed() || (c instanceof JMenu && model.isSelected())) {
g.setColor(AbstractLookAndFeel.getMenuSelectionBackgroundColor());
g.fillRect(x, y, w, h);
} else if (!AbstractLookAndFeel.getTheme().isMenuOpaque()) {
Graphics2D g2D = (Graphics2D) g;
Composite composite = g2D.getComposite();
AlphaComposite alpha =
AlphaComposite.getInstance(
AlphaComposite.SRC_OVER, AbstractLookAndFeel.getTheme().getMenuAlpha());
g2D.setComposite(alpha);
g.setColor(AbstractLookAndFeel.getMenuBackgroundColor());
g.fillRect(x, y, w, h);
g2D.setComposite(composite);
} else {
g.setColor(AbstractLookAndFeel.getMenuBackgroundColor());
g.fillRect(x, y, w, h);
}
}
if (menuItem.isSelected() && menuItem.isArmed()) {
g.setColor(AbstractLookAndFeel.getMenuSelectionForegroundColor());
} else {
g.setColor(AbstractLookAndFeel.getMenuForegroundColor());
}
}
/**
* Method which renders the text of the current button.
*
* <p>
*
* @param g Graphics context
* @param b Current button to render
* @param textRect Bounding rectangle to render the text.
* @param text String to render
* @since 1.4
*/
@Override
protected void paintText(Graphics g, AbstractButton b, Rectangle textRect, String text) {
ButtonModel model = b.getModel();
FontMetrics fm = g.getFontMetrics();
int mnemonicIndex = Methods.invokeGetter(b, "getDisplayedMnemonicIndex", -1);
boolean borderHasPressedCue = borderHasPressedCue(b);
/* Draw the Text */
if (model.isPressed() && model.isArmed() && !borderHasPressedCue) {
g.setColor(new Color(0xa0000000, true));
QuaquaUtilities.drawStringUnderlineCharAt(
g,
text,
mnemonicIndex,
textRect.x + getTextShiftOffset(),
textRect.y + fm.getAscent() + getTextShiftOffset() + 1);
}
if (model.isEnabled()) {
/** * paint the text normally */
g.setColor(b.getForeground());
} else {
Color c = UIManager.getColor(getPropertyPrefix() + "disabledForeground");
g.setColor((c != null) ? c : b.getForeground());
}
QuaquaUtilities.drawStringUnderlineCharAt(
g,
text,
mnemonicIndex,
textRect.x + getTextShiftOffset(),
textRect.y + fm.getAscent() + getTextShiftOffset());
}
@Override
protected void paintContentBorderTopEdge(
Graphics g, int tabPlacement, int selectedIndex, int x, int y, int w, int h) {
if (tabPane.getTabCount() < 1) return;
g.setColor(shadow);
g.drawLine(x, y, x + w - 2, y);
}
public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
if (comp.hasFocus() || focusLostTemporarily) {
Color color = g.getColor();
g.setColor(focusColor);
BasicGraphicsUtils.drawDashedRect(g, x, y, width, height);
g.setColor(color);
}
}
static void drawActiveButtonBorder(Graphics g, int x, int y, int w, int h) {
drawFlush3DBorder(g, x, y, w, h);
g.setColor(MetalLookAndFeel.getPrimaryControl());
g.drawLine(x + 1, y + 1, x + 1, h - 3);
g.drawLine(x + 1, y + 1, w - 3, x + 1);
g.setColor(MetalLookAndFeel.getPrimaryControlDarkShadow());
g.drawLine(x + 2, h - 2, w - 2, h - 2);
g.drawLine(w - 2, y + 2, w - 2, h - 2);
}
static void drawDefaultButtonBorder(Graphics g, int x, int y, int w, int h, boolean active) {
drawButtonBorder(g, x + 1, y + 1, w - 1, h - 1, active);
g.translate(x, y);
g.setColor(MetalLookAndFeel.getControlDarkShadow());
g.drawRect(0, 0, w - 3, h - 3);
g.drawLine(w - 2, 0, w - 2, 0);
g.drawLine(0, h - 2, 0, h - 2);
g.translate(-x, -y);
}
/** This draws a variant "Flush 3D Border" It is used for things like pressed buttons. */
static void drawPressed3DBorder(Graphics g, int x, int y, int w, int h) {
g.translate(x, y);
drawFlush3DBorder(g, 0, 0, w, h);
g.setColor(MetalLookAndFeel.getControlShadow());
g.drawLine(1, 1, 1, h - 2);
g.drawLine(1, 1, w - 2, 1);
g.translate(-x, -y);
}
@Override
protected void paintTabBackground(
Graphics g, int tabPlacement, int tabIndex, int x, int y, int w, int h, boolean isSelected) {
g = g.create();
try {
internalPaintTabBackground(g, tabPlacement, tabIndex, x, y, w, h, isSelected);
} finally {
g.dispose();
}
}
@Override
protected void paintContentBorderBottomEdge(
Graphics g, int tabPlacement, int selectedIndex, int x, int y, int w, int h) {
if (tabPane.getTabCount() < 1) return;
g.setColor(shadow);
g.drawLine(x + 1, y + h - 3, x + w - 2, y + h - 3);
g.drawLine(x + 1, y + h - 2, x + w - 2, y + h - 2);
g.setColor(shadow.brighter());
g.drawLine(x + 2, y + h - 1, x + w - 1, y + h - 1);
}
public int getIconHeight() {
Graphics g = textLabel.getGraphics();
if (g != null) {
int h = g.getFontMetrics(textLabel.getFont()).getAscent() * 6 / 10;
if (h % 2 == 0) {
h += 1; // Make it odd
}
return h;
} else {
return 7;
}
}
public void paintViewport(Graphics g, JViewport c) {
if (!browser.isPreviewColumnFilled()) {
Dimension vs = c.getSize();
Dimension bs = browser.getSize();
JScrollBar vb = getVerticalBar();
g.setColor(Color.black);
Dimension ss = vb.getPreferredSize();
// Paint scroll bar tracks at the right to fill the viewport
if (bs.width < vs.width) {
int fixedCellWidth = browser.getFixedCellWidth();
// FIXME - Apparently we have to do layout manually, because
// invoking cellRendererPane.paneComponent with
// "shouldValidate" set to true does not appear to have
// the desired effect.
try {
vb.setSize(ss.width, vs.height);
vb.doLayout();
} catch (NullPointerException e) {
// We get NPE here in JDK 1.3. We ignore it.
}
for (int x = browser.getWidth() + fixedCellWidth;
x < vs.width;
x += fixedCellWidth + ss.width) {
getCellRendererPane().paintComponent(g, vb, c, x, 0, ss.width, vs.height, false);
}
}
}
}
/*
* (non-Javadoc)
*
* @seeorg.jvnet.flamingo.common.ui.BasicCommandButtonUI#
* paintButtonVerticalSeparator(java.awt.Graphics, int)
*/
@Override
protected void paintButtonVerticalSeparator(Graphics graphics, Rectangle separatorArea) {
Graphics2D g2d = (Graphics2D) graphics.create();
g2d.translate(separatorArea.x, 0);
SubstanceColorScheme colorScheme =
SubstanceColorSchemeUtilities.getColorScheme(
this.commandButton,
ColorSchemeAssociationKind.SEPARATOR,
ComponentState.getState(this.commandButton.getActionModel(), this.commandButton));
float fadeAlpha = this.getSeparatorAlpha();
g2d.setComposite(AlphaComposite.SrcOver.derive(fadeAlpha));
SeparatorPainterUtils.paintSeparator(
this.commandButton,
g2d,
colorScheme,
1,
this.commandButton.getHeight(),
JSlider.VERTICAL,
true,
4,
4,
true);
g2d.dispose();
}
protected void paintText(Graphics g, JComponent c, Rectangle textRect, String text) {
AbstractButton b = (AbstractButton) c;
ButtonModel model = b.getModel();
FontMetrics fm = SwingUtilities2.getFontMetrics(c, g);
int mnemIndex = b.getDisplayedMnemonicIndex();
/* Draw the Text */
if (model.isEnabled()) {
/** * paint the text normally */
g.setColor(b.getForeground());
} else {
/** * paint the text disabled ** */
g.setColor(getDisabledTextColor());
}
SwingUtilities2.drawStringUnderlineCharAt(
c, g, text, mnemIndex, textRect.x, textRect.y + fm.getAscent());
}
/*
* (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();
}
}
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);
}
/** This draws the "Flush 3D Border" which is used throughout the Metal L&F */
static void drawFlush3DBorder(Graphics g, int x, int y, int w, int h) {
g.translate(x, y);
g.setColor(MetalLookAndFeel.getControlDarkShadow());
g.drawRect(0, 0, w - 2, h - 2);
g.setColor(MetalLookAndFeel.getControlHighlight());
g.drawRect(1, 1, w - 2, h - 2);
g.setColor(MetalLookAndFeel.getControl());
g.drawLine(0, h - 1, 1, h - 2);
g.drawLine(w - 1, 0, w - 2, 1);
g.translate(-x, -y);
}
protected void paintText(Graphics g, JMenuItem menuItem, Rectangle textRect, String text) {
Graphics2D g2D = (Graphics2D) g;
Object savedRenderingHint = null;
if (AbstractLookAndFeel.getTheme().isTextAntiAliasingOn()) {
savedRenderingHint = g2D.getRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING);
g2D.setRenderingHint(
RenderingHints.KEY_TEXT_ANTIALIASING,
AbstractLookAndFeel.getTheme().getTextAntiAliasingHint());
}
if (menuItem.isSelected() && menuItem.isArmed()) {
g.setColor(AbstractLookAndFeel.getMenuSelectionForegroundColor());
} else {
g.setColor(AbstractLookAndFeel.getMenuForegroundColor());
}
super.paintText(g, menuItem, textRect, text);
if (AbstractLookAndFeel.getTheme().isTextAntiAliasingOn()) {
g2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, savedRenderingHint);
}
}
/**
* 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;
}
/** special paint handler for merged cell regions */
protected void paintSpans(Graphics g, int rowMin, int rowMax, int colMin, int colMax) {
Rectangle clip = g.getClipBounds();
Iterator cell = grid.getSpanModel().getSpanIterator();
while (cell.hasNext()) {
CellSpan span = (CellSpan) cell.next();
Rectangle cellBounds = grid.getCellBounds(span.getRow(), span.getColumn());
// Only paint cell if visible
if (span.getLastRow() >= rowMin
&& span.getLastColumn() >= colMin
&& span.getFirstRow() <= rowMax
&& span.getFirstColumn() <= colMax) {
paintCell(g, cellBounds, span.getRow(), span.getColumn());
// Paint grid line around cell
if (grid.getShowGrid()) {
g.setColor(grid.getGridColor());
g.drawRect(cellBounds.x, cellBounds.y, cellBounds.width, cellBounds.height);
}
}
}
}
/**
* Paints the specified component.
*
* @param context context for the component being painted
* @param g the {@code Graphics} object used for painting
* @see #update(Graphics,JComponent)
*/
protected void paint(SynthContext context, Graphics g) {
AbstractButton b = (AbstractButton) context.getComponent();
g.setColor(context.getStyle().getColor(context, ColorType.TEXT_FOREGROUND));
g.setFont(style.getFont(context));
context
.getStyle()
.getGraphicsUtils(context)
.paintText(
context,
g,
b.getText(),
getIcon(b),
b.getHorizontalAlignment(),
b.getVerticalAlignment(),
b.getHorizontalTextPosition(),
b.getVerticalTextPosition(),
b.getIconTextGap(),
b.getDisplayedMnemonicIndex(),
getTextShiftOffset(context));
}
/**
* Paints 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 for the highlight
* @param c the editor
*/
public void paint(Graphics g, int offs0, int offs1, Shape bounds, JTextComponent c) {
Rectangle alloc = bounds.getBounds();
try {
// --- determine locations ---
TextUI mapper = c.getUI();
Rectangle p0 = mapper.modelToView(c, offs0);
Rectangle p1 = mapper.modelToView(c, offs1);
// --- render ---
Color color = getColor();
if (color == null) {
g.setColor(c.getSelectionColor());
} else {
g.setColor(color);
}
if (p0.y == p1.y) {
// same line, render a rectangle
Rectangle r = p0.union(p1);
g.fillRect(r.x, r.y, r.width, r.height);
} else {
// different lines
int p0ToMarginWidth = alloc.x + alloc.width - p0.x;
g.fillRect(p0.x, p0.y, p0ToMarginWidth, p0.height);
if ((p0.y + p0.height) != p1.y) {
g.fillRect(alloc.x, p0.y + p0.height, alloc.width, p1.y - (p0.y + p0.height));
}
g.fillRect(alloc.x, p1.y, (p1.x - alloc.x), p1.height);
}
} catch (BadLocationException e) {
// can't render
}
}
static void drawDefaultButtonPressedBorder(Graphics g, int x, int y, int w, int h) {
drawPressed3DBorder(g, x + 1, y + 1, w - 1, h - 1);
g.translate(x, y);
g.setColor(MetalLookAndFeel.getControlDarkShadow());
g.drawRect(0, 0, w - 3, h - 3);
g.drawLine(w - 2, 0, w - 2, 0);
g.drawLine(0, h - 2, 0, h - 2);
g.setColor(MetalLookAndFeel.getControl());
g.drawLine(w - 1, 0, w - 1, 0);
g.drawLine(0, h - 1, 0, h - 1);
g.translate(-x, -y);
}
protected void paintFocus(
Graphics g, AbstractButton b, Rectangle viewRect, Rectangle textRect, Rectangle iconRect) {
Rectangle focusRect = new Rectangle();
String text = b.getText();
boolean isIcon = b.getIcon() != null;
// If there is text
if (text != null && !text.equals("")) {
if (!isIcon) {
focusRect.setBounds(textRect);
} else {
focusRect.setBounds(iconRect.union(textRect));
}
}
// If there is an icon and no text
else if (isIcon) {
focusRect.setBounds(iconRect);
}
g.setColor(getFocusColor());
g.drawRect((focusRect.x - 1), (focusRect.y - 1), focusRect.width + 1, focusRect.height + 1);
}
public void paint(Graphics g) {
super.paint(g);
if (!isEditing) return;
Dimension psize = getPreferredSize();
if (isFocused) g.setColor(Color.yellow);
else g.setColor(Color.green);
g.drawLine(0, 0, psize.width, 0);
g.drawLine(0, 0, 0, psize.height);
g.drawLine(0, psize.height - 1, psize.width - 1, psize.height - 1);
g.drawLine(psize.width - 1, 0, psize.width - 1, psize.height - 1);
}
protected void paintFocus(
Graphics g, AbstractButton b, Rectangle viewRect, Rectangle textRect, Rectangle iconRect) {
Graphics2D g2D = (Graphics2D) g;
int width = b.getWidth();
int height = b.getHeight();
if (((width < 64) || (height < 16)) && ((b.getText() == null) || b.getText().length() == 0)) {
g.setColor(AbstractLookAndFeel.getFocusColor());
BasicGraphicsUtils.drawDashedRect(g, 4, 3, width - 8, height - 6);
} else {
Object savedRenderingHint = g2D.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2D.setColor(AbstractLookAndFeel.getFocusColor());
int d = b.getHeight() - 4;
g2D.drawRoundRect(2, 2, b.getWidth() - 5, b.getHeight() - 5, d, d);
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, savedRenderingHint);
}
}
public void paint(Graphics g, JComponent c) {
if (grid.getRowCount() <= 0 || grid.getColumnCount() <= 0) {
return; // nothing to paint
}
Rectangle clip = g.getClipBounds();
Point minLocation = clip.getLocation();
Point maxLocation = new Point(clip.x + clip.width - 1, clip.y + clip.height - 1);
int rowMin = grid.rowAtPoint(minLocation);
int rowMax = grid.rowAtPoint(maxLocation);
// This should never happen.
if (rowMin == -1) {
rowMin = 0;
}
// If the spread does not have enough rows to fill the view we'll get -1.
// Replace this with the index of the last row.
if (rowMax == -1) {
rowMax = grid.getRowCount() - 1;
}
int colMin = grid.columnAtPoint(minLocation);
int colMax = grid.columnAtPoint(maxLocation);
// This should never happen.
if (colMin == -1) {
colMin = 0;
}
// If the spread does not have enough columns to fill the view we'll get -1.
// Replace this with the index of the last column.
if (colMax == -1) {
colMax = grid.getColumnCount() - 1;
}
// Paint cells
paintCells(g, rowMin, rowMax, colMin, colMax);
// Paint grid
paintGrid(g, rowMin, rowMax, colMin, colMax);
// Paint spans
paintSpans(g, rowMin, rowMax, colMin, colMax);
// Paint borders
paintBorders(g, rowMin, rowMax, colMin, colMax);
// Paint editor
paintEditor(g);
}
public void paintIcon(Component c, Graphics g, int x, int y) {
int w = getIconWidth();
int h = w;
Polygon p = new Polygon();
switch (direction) {
case EAST:
p.addPoint(x + 2, y);
p.addPoint(x + w - 2, y + h / 2);
p.addPoint(x + 2, y + h - 1);
break;
case SOUTH:
p.addPoint(x, y + 2);
p.addPoint(x + w / 2, y + h - 2);
p.addPoint(x + w - 1, y + 2);
break;
}
g.fillPolygon(p);
}
/*
* (non-Javadoc)
*
* @see
* org.jvnet.flamingo.common.ui.BasicCommandButtonUI#paintButtonIcon(java
* .awt.Graphics, java.awt.Rectangle)
*/
@Override
protected void paintButtonIcon(Graphics g, Rectangle iconRect) {
JCommandButton jcb = (JCommandButton) this.commandButton;
Icon regular = jcb.getIcon();
if (toUseDisabledIcon()
&& (jcb.getDisabledIcon() != null)
&& ((regular != null) && !regular.getClass().isAnnotationPresent(TransitionAware.class)))
regular = jcb.getDisabledIcon();
if ((iconRect == null)
|| (regular == null)
|| (iconRect.width == 0)
|| (iconRect.height == 0)) {
return;
}
boolean useThemed = SubstanceCoreUtilities.useThemedDefaultIcon(this.commandButton);
if (regular != null) {
Graphics2D g2d = (Graphics2D) g.create();
GhostPaintingUtils.paintGhostIcon(g2d, jcb, regular, iconRect);
g2d.setComposite(LafWidgetUtilities.getAlphaComposite(jcb, g));
if (!useThemed) {
regular.paintIcon(jcb, g2d, iconRect.x, iconRect.y);
} else {
StateTransitionTracker tracker =
this.substanceVisualStateTracker.getActionStateTransitionTracker();
ButtonModel model = commandButton.getActionModel();
if (jcb.getCommandButtonKind() == CommandButtonKind.POPUP_ONLY) {
tracker = this.substanceVisualStateTracker.getPopupStateTransitionTracker();
model = jcb.getPopupModel();
}
CommandButtonBackgroundDelegate.paintThemedCommandButtonIcon(
g2d, iconRect, jcb, regular, model, tracker);
}
g2d.dispose();
}
}
