Java Code Examples for org.pushingpixels.substance.internal.animation.StateTransitionTracker#ModelStateInfo

/**
 * Returns the foreground color for the specified component.
 * 
 * @param component
 *            Component.
 * @param text
 *            Text. If empty or <code>null</code>, the result is <code>null</code>.
 * @param textAlpha
 *            Alpha channel for painting the text. If value is less than 1.0, the result is an
 *            opaque color which is an interpolation between the "real" foreground color and the
 *            background color of the component. This is done to ensure that native text
 *            rasterization will be performed on 6u10 on Windows.
 * @return The foreground color for the specified component.
 */
public static Color getForegroundColor(JComponent component, String text,
        StateTransitionTracker.ModelStateInfo modelStateInfo, float textAlpha) {
    if ((text == null) || (text.length() == 0))
        return null;

    boolean toEnforceFgColor = (SwingUtilities.getAncestorOfClass(CellRendererPane.class, component) != null)
            || Boolean.TRUE.equals(component.getClientProperty(ENFORCE_FG_COLOR));

    Color fgColor = null;
    if (toEnforceFgColor) {
        fgColor = component.getForeground();
    } else {
        fgColor = SubstanceColorUtilities.getForegroundColor(component, modelStateInfo);
    }

    if (textAlpha < 1.0f) {
        Color bgFillColor = SubstanceColorUtilities.getBackgroundFillColor(component);
        fgColor = SubstanceColorUtilities.getInterpolatedColor(fgColor, bgFillColor, textAlpha);
    }
    return fgColor;
}
 

public StateTransitionTracker.ModelStateInfo getModelStateInfo(int row,
        Component rendererComponent) {
    if (this.stateTransitionMultiTracker.size() == 0)
        return null;
    StateTransitionTracker tracker = this.stateTransitionMultiTracker.getTracker(row);
    if (tracker == null) {
        return null;
    } else {
        return tracker.getModelStateInfo();
    }
}
 

private static Color getMenuButtonForegroundColor(AbstractCommandButton menuButton,
        StateTransitionTracker.ModelStateInfo modelStateInfo) {
    ComponentState currState = modelStateInfo.getCurrModelStateNoSelection();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateNoSelectionContributionMap();

    SubstanceSlices.ColorSchemeAssociationKind currAssocKind = SubstanceSlices.ColorSchemeAssociationKind.FILL;
    // use HIGHLIGHT on active and non-rollover menu items
    if (!currState.isDisabled() && (currState != ComponentState.ENABLED)
            && !currState.isFacetActive(SubstanceSlices.ComponentStateFacet.ROLLOVER))
        currAssocKind = SubstanceSlices.ColorSchemeAssociationKind.HIGHLIGHT;
    SubstanceColorScheme colorScheme = SubstanceColorSchemeUtilities.getColorScheme(menuButton,
            currAssocKind, currState);
    if (currState.isDisabled() || (activeStates == null) || (activeStates.size() == 1)) {
        return colorScheme.getForegroundColor();
    }

    float aggrRed = 0;
    float aggrGreen = 0;
    float aggrBlue = 0;
    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
            .entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        float alpha = activeEntry.getValue().getContribution();
        SubstanceSlices.ColorSchemeAssociationKind assocKind = SubstanceSlices.ColorSchemeAssociationKind.FILL;
        // use HIGHLIGHT on active and non-rollover menu items
        if (!activeState.isDisabled() && (activeState != ComponentState.ENABLED)
                && !activeState.isFacetActive(SubstanceSlices.ComponentStateFacet.ROLLOVER))
            assocKind = SubstanceSlices.ColorSchemeAssociationKind.HIGHLIGHT;
        SubstanceColorScheme activeColorScheme = SubstanceColorSchemeUtilities
                .getColorScheme(menuButton, assocKind, activeState);
        Color activeForeground = activeColorScheme.getForegroundColor();
        aggrRed += alpha * activeForeground.getRed();
        aggrGreen += alpha * activeForeground.getGreen();
        aggrBlue += alpha * activeForeground.getBlue();
    }
    return new Color((int) aggrRed, (int) aggrGreen, (int) aggrBlue);
}
 

public StateTransitionTracker.ModelStateInfo getModelStateInfo(TreePathId pathId) {
	if (this.stateTransitionMultiTracker.size() == 0)
		return null;
	StateTransitionTracker tracker = this.stateTransitionMultiTracker.getTracker(pathId);
	if (tracker == null) {
		return null;
	} else {
		return tracker.getModelStateInfo();
	}
}
 

/**
 * Returns the current state for the specified cell.
 * 
 * @param cellId
 *            Cell index.
 * @return The current state for the specified cell.
 */
public StateTransitionTracker.ModelStateInfo getModelStateInfo(TableCellId cellId) {
    if (this.stateTransitionMultiTracker.size() == 0)
        return null;
    StateTransitionTracker tracker = this.stateTransitionMultiTracker.getTracker(cellId);
    if (tracker == null) {
        return null;
    } else {
        return tracker.getModelStateInfo();
    }
}
 

public static void paintText(Graphics g, JComponent component, Rectangle textRect, String text,
        int mnemonicIndex, StateTransitionTracker.ModelStateInfo modelStateInfo,
        float textAlpha) {
    Color fgColor = getForegroundColor(component, text, modelStateInfo, textAlpha);

    SubstanceTextUtilities.paintText(g, component, textRect, text, mnemonicIndex,
            component.getFont(), fgColor, null);
}
 

public static void paintMenuItemText(Graphics g, JMenuItem menuItem, Rectangle textRect,
        String text, int mnemonicIndex, StateTransitionTracker.ModelStateInfo modelStateInfo,
        float textAlpha) {
    Color fgColor = getMenuComponentForegroundColor(menuItem, text, modelStateInfo, textAlpha);

    SubstanceTextUtilities.paintText(g, menuItem, textRect, text, mnemonicIndex,
            menuItem.getFont(), fgColor, null);
}
 

/**
 * Returns the current icon to paint.
 * 
 * @return Icon to paint.
 */
private ImageWrapperIcon getIconToPaint() {
    if (this.menuItem == null)
        return null;

    TransitionAwareUI transitionAwareUI = (TransitionAwareUI) this.menuItem.getUI();
    StateTransitionTracker stateTransitionTracker = transitionAwareUI.getTransitionTracker();

    StateTransitionTracker.ModelStateInfo modelStateInfo = stateTransitionTracker
            .getModelStateInfo();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateContributionMap();

    SubstanceFillPainter fillPainter = SubstanceCoreUtilities.getFillPainter(this.menuItem);
    SubstanceBorderPainter borderPainter = SubstanceCoreUtilities
            .getBorderPainter(this.menuItem);
    ComponentState currState = modelStateInfo.getCurrModelState();

    SubstanceColorScheme baseFillColorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(this.menuItem, ColorSchemeAssociationKind.MARK_BOX, currState);
    SubstanceColorScheme baseMarkColorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(this.menuItem, ColorSchemeAssociationKind.MARK, currState);
    SubstanceColorScheme baseBorderColorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(this.menuItem, ColorSchemeAssociationKind.BORDER, currState);
    float visibility = stateTransitionTracker.getFacetStrength(ComponentStateFacet.SELECTION);
    boolean isCheckMarkFadingOut = !currState.isFacetActive(ComponentStateFacet.SELECTION);
    float alpha = SubstanceColorSchemeUtilities.getAlpha(this.menuItem, currState);

    int fontSize = SubstanceSizeUtils.getComponentFontSize(this.menuItem);
    int checkMarkSize = this.size + 3;

    HashMapKey keyBase = SubstanceCoreUtilities.getHashKey(fontSize, checkMarkSize,
            fillPainter.getDisplayName(), borderPainter.getDisplayName(),
            baseFillColorScheme.getDisplayName(), baseMarkColorScheme.getDisplayName(),
            baseBorderColorScheme.getDisplayName(), visibility, isCheckMarkFadingOut,
            alpha);
    ImageWrapperIcon iconBase = iconMap.get(keyBase);
    if (iconBase == null) {
        iconBase = new ImageWrapperIcon(
                SubstanceImageCreator.getCheckBox(this.menuItem, fillPainter, borderPainter,
                        checkMarkSize, currState, baseFillColorScheme, baseMarkColorScheme,
                        baseBorderColorScheme, visibility, isCheckMarkFadingOut, alpha));
        iconMap.put(keyBase, iconBase);
    }
    if (currState.isDisabled() || (activeStates.size() == 1)) {
        return iconBase;
    }

    BufferedImage result = SubstanceCoreUtilities.getBlankImage(iconBase.getIconWidth(),
            iconBase.getIconHeight());
    Graphics2D g2d = result.createGraphics();
    // draw the base layer
    iconBase.paintIcon(this.menuItem, g2d, 0, 0);

    // draw other active layers
    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
            .entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        // System.out.println("Painting state " + activeState + "[curr is "
        // + currState + "] with " + activeEntry.getValue());
        if (activeState == currState)
            continue;

        float stateContribution = activeEntry.getValue().getContribution();
        if (stateContribution > 0.0f) {
            g2d.setComposite(AlphaComposite.SrcOver.derive(stateContribution));
            SubstanceColorScheme fillColorScheme = SubstanceColorSchemeUtilities.getColorScheme(
                    this.menuItem, ColorSchemeAssociationKind.MARK_BOX, activeState);
            SubstanceColorScheme markColorScheme = SubstanceColorSchemeUtilities.getColorScheme(
                    this.menuItem, ColorSchemeAssociationKind.MARK, activeState);
            SubstanceColorScheme borderColorScheme = SubstanceColorSchemeUtilities
                    .getColorScheme(this.menuItem, ColorSchemeAssociationKind.BORDER,
                            activeState);

            HashMapKey keyLayer = SubstanceCoreUtilities.getHashKey(fontSize, checkMarkSize,
                    fillPainter.getDisplayName(), borderPainter.getDisplayName(),
                    fillColorScheme.getDisplayName(), markColorScheme.getDisplayName(),
                    borderColorScheme.getDisplayName(), visibility, alpha);
            ImageWrapperIcon iconLayer = iconMap.get(keyLayer);
            if (iconLayer == null) {
                iconLayer = new ImageWrapperIcon(SubstanceImageCreator.getCheckBox(
                        this.menuItem, fillPainter, borderPainter, checkMarkSize, currState,
                        fillColorScheme, markColorScheme, borderColorScheme, visibility,
                        isCheckMarkFadingOut, alpha));
                iconMap.put(keyLayer, iconLayer);
            }

            iconLayer.paintIcon(this.menuItem, g2d, 0, 0);
        }
    }

    g2d.dispose();
    return new ImageWrapperIcon(result);
}
 

@Override
public void paintTrack(Graphics g) {
    Graphics2D graphics = (Graphics2D) g.create();

    boolean drawInverted = this.drawInverted();

    Rectangle paintRect = this.getPaintTrackRect();

    // Width and height of the painting rectangle.
    int width = paintRect.width;
    int height = paintRect.height;

    if (this.slider.getOrientation() == JSlider.VERTICAL) {
        // apply rotation / translate transformation on vertical
        // slider tracks
        int temp = width;
        width = height;
        height = temp;
        AffineTransform at = graphics.getTransform();
        at.translate(paintRect.x, width + paintRect.y);
        at.rotate(-Math.PI / 2);
        graphics.setTransform(at);
    } else {
        graphics.translate(paintRect.x, paintRect.y);
    }

    StateTransitionTracker.ModelStateInfo modelStateInfo = this.stateTransitionTracker
            .getModelStateInfo();

    SubstanceColorScheme trackSchemeUnselected = SubstanceColorSchemeUtilities
            .getColorScheme(this.slider, this.slider.isEnabled() ? ComponentState.ENABLED
                    : ComponentState.DISABLED_UNSELECTED);
    SubstanceColorScheme trackBorderSchemeUnselected = SubstanceColorSchemeUtilities
            .getColorScheme(this.slider, ColorSchemeAssociationKind.BORDER,
                    this.slider.isEnabled() ? ComponentState.ENABLED
                            : ComponentState.DISABLED_UNSELECTED);
    this.paintSliderTrack(graphics, drawInverted, trackSchemeUnselected,
            trackBorderSchemeUnselected, width, height);

    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateContributionMap();
    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
            .entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        if (!activeState.isActive())
            continue;

        float contribution = activeEntry.getValue().getContribution();
        if (contribution == 0.0f)
            continue;

        graphics.setComposite(
                WidgetUtilities.getAlphaComposite(this.slider, contribution, g));

        SubstanceColorScheme activeFillScheme = SubstanceColorSchemeUtilities
                .getColorScheme(this.slider, activeState);
        SubstanceColorScheme activeBorderScheme = SubstanceColorSchemeUtilities
                .getColorScheme(this.slider, ColorSchemeAssociationKind.BORDER, activeState);
        this.paintSliderTrackSelected(graphics, drawInverted, paintRect, activeFillScheme,
                activeBorderScheme, width, height);
    }

    graphics.dispose();
}
 

/**
 * Returns the foreground text color of the specified component.
 *
 * @param component      Component.
 * @param modelStateInfo Component model state info.
 * @return The foreground text color of the specified component.
 */
public static Color getForegroundColor(Component component,
        StateTransitionTracker.ModelStateInfo modelStateInfo) {
    ComponentState currState = modelStateInfo.getCurrModelState();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates =
            modelStateInfo.getStateContributionMap();

    // special case for enabled buttons with no background -
    // always use the color scheme for the default state.
    if (component instanceof AbstractButton) {
        AbstractButton button = (AbstractButton) component;
        if (SubstanceCoreUtilities.isButtonNeverPainted(button)
                || !button.isContentAreaFilled()
                || (button instanceof JRadioButton)
                || (button instanceof JCheckBox)) {
            if (!currState.isDisabled()) {
                currState = ComponentState.ENABLED;
                activeStates = null;
            } else {
                currState = ComponentState.DISABLED_UNSELECTED;
                activeStates = null;
            }
        }
    }

    SubstanceColorScheme colorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(component, currState);
    if (currState.isDisabled() || (activeStates == null)
            || (activeStates.size() == 1)) {
        return colorScheme.getForegroundColor();
    }

    float aggrRed = 0;
    float aggrGreen = 0;
    float aggrBlue = 0;
    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry :
            activeStates.entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        float alpha = activeEntry.getValue().getContribution();
        SubstanceColorScheme activeColorScheme = SubstanceColorSchemeUtilities
                .getColorScheme(component, activeState);
        Color activeForeground = activeColorScheme.getForegroundColor();
        aggrRed += alpha * activeForeground.getRed();
        aggrGreen += alpha * activeForeground.getGreen();
        aggrBlue += alpha * activeForeground.getBlue();
    }
    return new Color((int) aggrRed, (int) aggrGreen, (int) aggrBlue);
}
 

public void updateBackground(Graphics g, JComboBox combo, ButtonModel comboModel) {
    // failsafe for LAF change
    if (!SubstanceCoreUtilities.isCurrentLookAndFeel())
        return;

    int width = combo.getWidth();
    int height = combo.getHeight();
    int y = 0;

    SubstanceFillPainter fillPainter = SubstanceCoreUtilities.getFillPainter(combo);
    SubstanceBorderPainter borderPainter = SubstanceCoreUtilities.getBorderPainter(combo);

    BufferedImage bgImage = getFullAlphaBackground(combo, comboModel, fillPainter,
            borderPainter, width, height);

    TransitionAwareUI transitionAwareUI = (TransitionAwareUI) combo.getUI();
    StateTransitionTracker stateTransitionTracker = transitionAwareUI.getTransitionTracker();
    StateTransitionTracker.ModelStateInfo modelStateInfo = stateTransitionTracker
            .getModelStateInfo();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateContributionMap();

    // Two special cases here:
    // 1. Combobox has flat appearance.
    // 2. Combobox is disabled.
    // For both cases, we need to set custom translucency.
    boolean isFlat = SubstanceCoreUtilities.hasFlatAppearance(combo, false);
    boolean isSpecial = isFlat || !combo.isEnabled();
    float extraAlpha = 1.0f;
    if (isSpecial) {
        if (isFlat) {
            // Special handling of flat combos
            extraAlpha = 0.0f;
            for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
                    .entrySet()) {
                ComponentState activeState = activeEntry.getKey();
                if (activeState.isDisabled())
                    continue;
                if (activeState == ComponentState.ENABLED)
                    continue;
                extraAlpha += activeEntry.getValue().getContribution();
            }
        } else {
            if (!combo.isEnabled()) {
                extraAlpha = SubstanceColorSchemeUtilities.getAlpha(combo,
                        modelStateInfo.getCurrModelState());
            }
        }
    }
    if (extraAlpha > 0.0f) {
        Graphics2D graphics = (Graphics2D) g.create();
        graphics.setComposite(WidgetUtilities.getAlphaComposite(combo, extraAlpha, g));
        graphics.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        NeonCortex.drawImage(graphics, bgImage, 0, y);
        graphics.dispose();
    }
}
 

/**
 * Returns the icon that matches the current and previous states of the radio button.
 * 
 * @param button
 *            Button (should be {@link JRadioButton}).
 * @param stateTransitionTracker
 *            State transition tracker for the radio button.
 * @return Matching icon.
 */
private static ImageWrapperIcon getIcon(JToggleButton button,
        StateTransitionTracker stateTransitionTracker) {
    StateTransitionTracker.ModelStateInfo modelStateInfo = stateTransitionTracker
            .getModelStateInfo();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateContributionMap();

    int fontSize = SubstanceSizeUtils.getComponentFontSize(button);
    int checkMarkSize = SubstanceSizeUtils.getRadioButtonMarkSize(fontSize);

    SubstanceFillPainter fillPainter = SubstanceCoreUtilities.getFillPainter(button);
    SubstanceBorderPainter borderPainter = SubstanceCoreUtilities.getBorderPainter(button);
    ComponentState currState = modelStateInfo.getCurrModelState();

    SubstanceColorScheme baseFillColorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(button, ColorSchemeAssociationKind.MARK_BOX, currState);
    SubstanceColorScheme baseMarkColorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(button, ColorSchemeAssociationKind.MARK, currState);
    SubstanceColorScheme baseBorderColorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(button, ColorSchemeAssociationKind.BORDER, currState);
    float visibility = stateTransitionTracker.getFacetStrength(ComponentStateFacet.SELECTION);
    float alpha = SubstanceColorSchemeUtilities.getAlpha(button, currState);

    HashMapKey keyBase = SubstanceCoreUtilities.getHashKey(fontSize, checkMarkSize,
            fillPainter.getDisplayName(), borderPainter.getDisplayName(),
            baseFillColorScheme.getDisplayName(), baseMarkColorScheme.getDisplayName(),
            baseBorderColorScheme.getDisplayName(), visibility, alpha);
    ImageWrapperIcon iconBase = icons.get(keyBase);
    if (iconBase == null) {
        iconBase = new ImageWrapperIcon(SubstanceImageCreator.getRadioButton(button, fillPainter,
                borderPainter, checkMarkSize, currState, 0, baseFillColorScheme,
                baseMarkColorScheme, baseBorderColorScheme, visibility, alpha));
        icons.put(keyBase, iconBase);
    }
    if (currState.isDisabled() || (activeStates.size() == 1)) {
        return iconBase;
    }

    BufferedImage result = SubstanceCoreUtilities.getBlankImage(iconBase.getIconWidth(),
            iconBase.getIconHeight());
    Graphics2D g2d = result.createGraphics();
    // draw the base layer
    iconBase.paintIcon(button, g2d, 0, 0);

    // draw other active layers
    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
            .entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        // System.out.println("Painting state " + activeState + "[curr is "
        // + currState + "] with " + activeEntry.getValue());
        if (activeState == currState)
            continue;

        float stateContribution = activeEntry.getValue().getContribution();
        if (stateContribution > 0.0f) {
            g2d.setComposite(AlphaComposite.SrcOver.derive(stateContribution));
            SubstanceColorScheme fillColorScheme = SubstanceColorSchemeUtilities
                    .getColorScheme(button, ColorSchemeAssociationKind.MARK_BOX, activeState);
            SubstanceColorScheme markColorScheme = SubstanceColorSchemeUtilities
                    .getColorScheme(button, ColorSchemeAssociationKind.MARK, activeState);
            SubstanceColorScheme borderColorScheme = SubstanceColorSchemeUtilities
                    .getColorScheme(button, ColorSchemeAssociationKind.BORDER, activeState);

            HashMapKey keyLayer = SubstanceCoreUtilities.getHashKey(fontSize, checkMarkSize,
                    fillPainter.getDisplayName(), borderPainter.getDisplayName(),
                    fillColorScheme.getDisplayName(), markColorScheme.getDisplayName(),
                    borderColorScheme.getDisplayName(), visibility, alpha);
            ImageWrapperIcon iconLayer = icons.get(keyLayer);
            if (iconLayer == null) {
                iconLayer = new ImageWrapperIcon(
                        SubstanceImageCreator.getRadioButton(button, fillPainter, borderPainter,
                                checkMarkSize, currState, 0, fillColorScheme, markColorScheme,
                                borderColorScheme, visibility, alpha));
                icons.put(keyLayer, iconLayer);
            }

            iconLayer.paintIcon(button, g2d, 0, 0);
        }
    }

    g2d.dispose();
    return new ImageWrapperIcon(result);
}
 

/**
 * Retrieves image for vertical thumb.
 * 
 * @param thumbBounds
 *            Thumb bounding rectangle.
 * @return Image for vertical thumb.
 */
private BufferedImage getThumbVertical(Rectangle thumbBounds) {
    int width = Math.max(1, thumbBounds.width);
    int delta = Math.max(0, (int) (0.4 * width));
    if (delta % 2 == 1) {
        delta--;
    }
    width -= delta;

    int height = Math.max(1, thumbBounds.height);

    StateTransitionTracker.ModelStateInfo modelStateInfo = this.compositeStateTransitionTracker
            .getModelStateInfo();
    ComponentState currState = modelStateInfo.getCurrModelState();

    // enabled scroll bar is always painted as active
    SubstanceColorScheme baseFillScheme = (currState != ComponentState.ENABLED)
            ? SubstanceColorSchemeUtilities.getColorScheme(this.scrollbar, currState)
            : SubstanceColorSchemeUtilities.getActiveColorScheme(this.scrollbar, currState);
    SubstanceColorScheme baseBorderScheme = SubstanceColorSchemeUtilities
            .getColorScheme(this.scrollbar, ColorSchemeAssociationKind.BORDER, currState);
    BufferedImage baseLayer = getThumbVertical(this.scrollbar, width, height, baseFillScheme,
            baseBorderScheme);

    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateContributionMap();
    if (currState.isDisabled() || (activeStates.size() == 1)) {
        return baseLayer;
    }

    BufferedImage result = SubstanceCoreUtilities.getBlankUnscaledImage(baseLayer);
    Graphics2D g2d = result.createGraphics();
    g2d.drawImage(baseLayer, 0, 0, baseLayer.getWidth(), baseLayer.getHeight(), null);

    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
            .entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        if (activeState == modelStateInfo.getCurrModelState())
            continue;

        float contribution = activeEntry.getValue().getContribution();
        if (contribution == 0.0f)
            continue;

        g2d.setComposite(AlphaComposite.SrcOver.derive(contribution));

        SubstanceColorScheme fillScheme = (activeState != ComponentState.ENABLED)
                ? SubstanceColorSchemeUtilities.getColorScheme(this.scrollbar, activeState)
                : SubstanceColorSchemeUtilities.getActiveColorScheme(this.scrollbar,
                        activeState);
        SubstanceColorScheme borderScheme = SubstanceColorSchemeUtilities
                .getColorScheme(this.scrollbar, ColorSchemeAssociationKind.BORDER, activeState);
        BufferedImage layer = getThumbVertical(this.scrollbar, width, height, fillScheme,
                borderScheme);
        g2d.drawImage(layer, 0, 0, layer.getWidth(), layer.getHeight(), null);
    }

    g2d.dispose();
    return result;
}
 

/**
 * Returns the icon that matches the current and previous states of the checkbox.
 *
 * @param button                 Button (should be {@link JCheckBox}).
 * @param stateTransitionTracker State transition tracker for the checkbox.
 * @return Matching icon.
 */
private static Icon getIcon(JToggleButton button,
        StateTransitionTracker stateTransitionTracker) {
    StateTransitionTracker.ModelStateInfo modelStateInfo =
            stateTransitionTracker.getModelStateInfo();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates =
            modelStateInfo.getStateContributionMap();

    SubstanceFillPainter fillPainter = SubstanceCoreUtilities.getFillPainter(button);
    SubstanceBorderPainter borderPainter = SubstanceCoreUtilities.getBorderPainter(button);
    ComponentState currState = modelStateInfo.getCurrModelState();

    SubstanceColorScheme baseFillColorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(button, ColorSchemeAssociationKind.MARK_BOX, currState);
    SubstanceColorScheme baseMarkColorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(button, ColorSchemeAssociationKind.MARK, currState);
    SubstanceColorScheme baseBorderColorScheme = SubstanceColorSchemeUtilities
            .getColorScheme(button, ColorSchemeAssociationKind.BORDER, currState);
    float visibility = stateTransitionTracker.getFacetStrength(ComponentStateFacet.SELECTION);
    boolean isCheckMarkFadingOut = !currState.isFacetActive(ComponentStateFacet.SELECTION);
    float alpha = SubstanceColorSchemeUtilities.getAlpha(button, currState);

    int fontSize = SubstanceSizeUtils.getComponentFontSize(button);
    int checkMarkSize = SubstanceSizeUtils.getCheckBoxMarkSize(fontSize);

    HashMapKey keyBase = SubstanceCoreUtilities.getHashKey(fontSize, checkMarkSize,
            fillPainter.getDisplayName(), borderPainter.getDisplayName(),
            baseFillColorScheme.getDisplayName(), baseMarkColorScheme.getDisplayName(),
            baseBorderColorScheme.getDisplayName(), visibility, isCheckMarkFadingOut,
            alpha);
    ImageWrapperIcon iconBase = icons.get(keyBase);
    if (iconBase == null) {
        iconBase = new ImageWrapperIcon(
                SubstanceImageCreator.getCheckBox(button, fillPainter, borderPainter,
                        checkMarkSize, currState, baseFillColorScheme, baseMarkColorScheme,
                        baseBorderColorScheme, visibility, isCheckMarkFadingOut,
                        alpha));
        icons.put(keyBase, iconBase);
    }
    if (currState.isDisabled() || (activeStates.size() == 1)) {
        return iconBase;
    }

    BufferedImage result = SubstanceCoreUtilities.getBlankImage(iconBase.getIconWidth(),
            iconBase.getIconHeight());
    Graphics2D g2d = result.createGraphics();
    // draw the base layer
    iconBase.paintIcon(button, g2d, 0, 0);

    // draw other active layers
    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry
            : activeStates.entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        // System.out.println("Painting state " + activeState + "[curr is "
        // + currState + "] with " + activeEntry.getValue());
        if (activeState == currState) {
            continue;
        }

        float stateContribution = activeEntry.getValue().getContribution();
        if (stateContribution > 0.0f) {
            g2d.setComposite(AlphaComposite.SrcOver.derive(stateContribution));
            SubstanceColorScheme fillColorScheme = SubstanceColorSchemeUtilities
                    .getColorScheme(button, ColorSchemeAssociationKind.MARK_BOX, activeState);
            SubstanceColorScheme markColorScheme = SubstanceColorSchemeUtilities
                    .getColorScheme(button, ColorSchemeAssociationKind.MARK, activeState);
            SubstanceColorScheme borderColorScheme = SubstanceColorSchemeUtilities
                    .getColorScheme(button, ColorSchemeAssociationKind.BORDER, activeState);

            HashMapKey keyLayer = SubstanceCoreUtilities.getHashKey(fontSize, checkMarkSize,
                    fillPainter.getDisplayName(), borderPainter.getDisplayName(),
                    fillColorScheme.getDisplayName(), markColorScheme.getDisplayName(),
                    borderColorScheme.getDisplayName(), visibility);
            ImageWrapperIcon iconLayer = icons.get(keyLayer);
            if (iconLayer == null) {
                iconLayer = new ImageWrapperIcon(
                        SubstanceImageCreator.getCheckBox(button, fillPainter, borderPainter,
                                checkMarkSize, currState, fillColorScheme, markColorScheme,
                                borderColorScheme, visibility, isCheckMarkFadingOut, alpha));
                icons.put(keyLayer, iconLayer);
            }

            iconLayer.paintIcon(button, g2d, 0, 0);
        }
    }

    g2d.dispose();
    return new ImageWrapperIcon(result);
}
 

private ResizableIcon getIconToPaint() {
    StateTransitionTracker stateTransitionTracker = this.transitionAwareUIDelegate
            .getTransitionAwareUI().getTransitionTracker();
    StateTransitionTracker.ModelStateInfo modelStateInfo = stateTransitionTracker
            .getModelStateInfo();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateNoSelectionContributionMap();
    ComponentState currState = modelStateInfo.getCurrModelStateNoSelection();

    // Use HIGHLIGHT when necessary and MARK for the rest
    ColorSchemeAssociationKind baseAssociationKind = currState
            .isFacetActive(this.facetForHighlights) ? ColorSchemeAssociationKind.HIGHLIGHT
                    : ColorSchemeAssociationKind.MARK;
    SubstanceColorScheme baseScheme = SubstanceColorSchemeUtilities
            .getColorScheme(this.component, baseAssociationKind, currState);
    float baseAlpha = SubstanceColorSchemeUtilities.getAlpha(this.component, currState);

    HashMapKey keyBase = SubstanceCoreUtilities.getHashKey(this.component.getClass().getName(),
            this.uniqueIconTypeId, SubstanceSizeUtils.getComponentFontSize(this.component),
            baseScheme.getDisplayName(), baseAlpha);
    ResizableIcon layerBase = iconMap.get(keyBase);
    if (layerBase == null) {
        ResizableIcon baseFullOpacity = this.delegate.getColorSchemeIcon(baseScheme);
        if (baseAlpha == 1.0f) {
            layerBase = baseFullOpacity;
            iconMap.put(keyBase, layerBase);
        } else {
            BufferedImage baseImage = SubstanceCoreUtilities.getBlankImage(
                    baseFullOpacity.getIconWidth(), baseFullOpacity.getIconHeight());
            Graphics2D g2base = baseImage.createGraphics();
            g2base.setComposite(AlphaComposite.SrcOver.derive(baseAlpha));
            baseFullOpacity.paintIcon(this.component, g2base, 0, 0);
            g2base.dispose();
            layerBase = new ImageWrapperIcon(baseImage);
            iconMap.put(keyBase, layerBase);
        }
    }

    if (currState.isDisabled() || (activeStates.size() == 1)) {
        return layerBase;
    }

    BufferedImage result = SubstanceCoreUtilities.getBlankImage(layerBase.getIconWidth(),
            layerBase.getIconHeight());
    Graphics2D g2d = result.createGraphics();
    // draw the base layer
    layerBase.paintIcon(this.component, g2d, 0, 0);

    // draw the other active layers
    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
            .entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        if (activeState == currState)
            continue;

        float stateContribution = activeEntry.getValue().getContribution();
        if (stateContribution > 0.0f) {
            g2d.setComposite(AlphaComposite.SrcOver.derive(stateContribution));

            // Use HIGHLIGHT when necessary and MARK for the rest
            ColorSchemeAssociationKind associationKind = activeState.isFacetActive(
                    this.facetForHighlights) ? ColorSchemeAssociationKind.HIGHLIGHT
                            : ColorSchemeAssociationKind.MARK;
            SubstanceColorScheme scheme = SubstanceColorSchemeUtilities
                    .getColorScheme(this.component, associationKind, activeState);
            float alpha = SubstanceColorSchemeUtilities.getAlpha(this.component, activeState);

            HashMapKey key = SubstanceCoreUtilities.getHashKey(
                    this.component.getClass().getName(), this.uniqueIconTypeId,
                    SubstanceSizeUtils.getComponentFontSize(this.component),
                    scheme.getDisplayName(), alpha);
            ResizableIcon layer = iconMap.get(key);
            if (layer == null) {
                ResizableIcon fullOpacity = this.delegate.getColorSchemeIcon(scheme);
                if (alpha == 1.0f) {
                    layer = fullOpacity;
                    iconMap.put(key, layer);
                } else {
                    BufferedImage image = SubstanceCoreUtilities.getBlankImage(
                            fullOpacity.getIconWidth(), fullOpacity.getIconHeight());
                    Graphics2D g2layer = image.createGraphics();
                    g2layer.setComposite(AlphaComposite.SrcOver.derive(alpha));
                    fullOpacity.paintIcon(this.component, g2layer, 0, 0);
                    g2layer.dispose();
                    layer = new ImageWrapperIcon(image);
                    iconMap.put(key, layer);
                }
            }
            layer.paintIcon(this.component, g2d, 0, 0);
        }
    }
    g2d.dispose();
    return new ImageWrapperIcon(result);
}
 

/**
 * Retrieves icon that matches the specified state of the slider thumb.
 * 
 * @param slider
 *            The slider itself.
 * @return Icon that matches the specified state of the slider thumb.
 */
private ImageWrapperIcon getIcon(JSlider slider,
        StateTransitionTracker stateTransitionTracker) {
    StateTransitionTracker.ModelStateInfo modelStateInfo = stateTransitionTracker
            .getModelStateInfo();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateContributionMap();
    ComponentState currState = stateTransitionTracker.getModelStateInfo()
            .getCurrModelState();

    float activeStrength = stateTransitionTracker.getActiveStrength();
    int height = (int) (this.size * (2.0 + activeStrength) / 3.0);
    height = Math.min(height, this.size - 2);
    int delta = (this.size - height) / 2 - 1;

    SubstanceFillPainter fillPainter = SubstanceCoreUtilities.getFillPainter(slider);
    SubstanceBorderPainter borderPainter = SubstanceCoreUtilities.getBorderPainter(slider);

    SubstanceColorScheme baseFillScheme = SubstanceColorSchemeUtilities
            .getColorScheme(slider, currState);
    SubstanceColorScheme baseBorderScheme = SubstanceColorSchemeUtilities
            .getColorScheme(slider, ColorSchemeAssociationKind.BORDER, currState);

    HashMapKey baseKey = SubstanceCoreUtilities.getHashKey(this.size, height,
            slider.getComponentOrientation(), baseFillScheme.getDisplayName(),
            baseBorderScheme.getDisplayName(), fillPainter.getDisplayName(),
            borderPainter.getDisplayName(), this.isMirrorred);

    ImageWrapperIcon baseLayer = SliderVerticalIcon.icons.get(baseKey);
    if (baseLayer == null) {
        baseLayer = getSingleLayer(slider, height, delta, fillPainter, borderPainter,
                baseFillScheme, baseBorderScheme);
        SliderVerticalIcon.icons.put(baseKey, baseLayer);
    }

    if (currState.isDisabled() || (activeStates.size() == 1))
        return baseLayer;

    BufferedImage result = SubstanceCoreUtilities.getBlankImage(baseLayer.getIconWidth(),
            baseLayer.getIconHeight());
    Graphics2D g2d = result.createGraphics();
    baseLayer.paintIcon(slider, g2d, 0, 0);

    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
            .entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        if (activeState == currState)
            continue;

        float contribution = activeEntry.getValue().getContribution();
        if (contribution == 0.0f)
            continue;

        SubstanceColorScheme fillScheme = SubstanceColorSchemeUtilities
                .getColorScheme(slider, activeState);
        SubstanceColorScheme borderScheme = SubstanceColorSchemeUtilities
                .getColorScheme(slider, ColorSchemeAssociationKind.BORDER, activeState);

        HashMapKey key = SubstanceCoreUtilities.getHashKey(this.size, height,
                slider.getComponentOrientation(), fillScheme.getDisplayName(),
                borderScheme.getDisplayName(), fillPainter.getDisplayName(),
                borderPainter.getDisplayName(), this.isMirrorred);

        ImageWrapperIcon layer = SliderVerticalIcon.icons.get(key);
        if (layer == null) {
            layer = getSingleLayer(slider, height, delta, fillPainter, borderPainter,
                    fillScheme, borderScheme);
            SliderVerticalIcon.icons.put(key, layer);
        }

        g2d.setComposite(AlphaComposite.SrcOver.derive(contribution));
        layer.paintIcon(slider, g2d, 0, 0);
    }

    g2d.dispose();
    return new ImageWrapperIcon(result);
}
 

/**
 * Retrieves icon that matches the specified state of the slider thumb.
 * 
 * @param slider
 *            The slider itself.
 * @return Icon that matches the specified state of the slider thumb.
 */
private ImageWrapperIcon getIcon(JSlider slider,
        StateTransitionTracker stateTransitionTracker) {
    StateTransitionTracker.ModelStateInfo modelStateInfo = stateTransitionTracker
            .getModelStateInfo();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateContributionMap();
    ComponentState currState = stateTransitionTracker.getModelStateInfo()
            .getCurrModelState();

    float activeStrength = stateTransitionTracker.getActiveStrength();
    float width = this.size * (2.0f + activeStrength) / 3.0f;

    SubstanceFillPainter fillPainter = SubstanceCoreUtilities.getFillPainter(slider);
    SubstanceBorderPainter borderPainter = SubstanceCoreUtilities.getBorderPainter(slider);

    SubstanceColorScheme baseFillScheme = SubstanceColorSchemeUtilities
            .getColorScheme(slider, currState);
    SubstanceColorScheme baseBorderScheme = SubstanceColorSchemeUtilities
            .getColorScheme(slider, ColorSchemeAssociationKind.BORDER, currState);

    HashMapKey baseKey = SubstanceCoreUtilities.getHashKey(this.size, width,
            baseFillScheme.getDisplayName(), baseBorderScheme.getDisplayName(),
            fillPainter.getDisplayName(), borderPainter.getDisplayName());

    ImageWrapperIcon baseLayer = SliderRoundIcon.icons.get(baseKey);
    if (baseLayer == null) {
        baseLayer = getSingleLayer(slider, width, fillPainter, borderPainter,
                baseFillScheme, baseBorderScheme);
        SliderRoundIcon.icons.put(baseKey, baseLayer);
    }

    if (currState.isDisabled() || (activeStates.size() == 1))
        return baseLayer;

    BufferedImage result = SubstanceCoreUtilities.getBlankImage(baseLayer.getIconWidth(),
            baseLayer.getIconHeight());
    Graphics2D g2d = result.createGraphics();
    baseLayer.paintIcon(slider, g2d, 0, 0);

    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
            .entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        if (activeState == currState)
            continue;

        float contribution = activeEntry.getValue().getContribution();
        if (contribution == 0.0f)
            continue;

        SubstanceColorScheme fillScheme = SubstanceColorSchemeUtilities
                .getColorScheme(slider, activeState);
        SubstanceColorScheme borderScheme = SubstanceColorSchemeUtilities
                .getColorScheme(slider, ColorSchemeAssociationKind.BORDER, activeState);

        HashMapKey key = SubstanceCoreUtilities.getHashKey(this.size, width,
                fillScheme.getDisplayName(), borderScheme.getDisplayName(),
                fillPainter.getDisplayName(), borderPainter.getDisplayName());

        ImageWrapperIcon layer = SliderRoundIcon.icons.get(key);
        if (layer == null) {
            layer = getSingleLayer(slider, width, fillPainter, borderPainter, fillScheme,
                    borderScheme);
            SliderRoundIcon.icons.put(key, layer);
        }

        g2d.setComposite(AlphaComposite.SrcOver.derive(contribution));
        layer.paintIcon(slider, g2d, 0, 0);
    }

    g2d.dispose();
    return new ImageWrapperIcon(result);
}
 

/**
 * Retrieves image for horizontal thumb.
 * 
 * @param thumbBounds
 *            Thumb bounding rectangle.
 * @return Image for horizontal thumb.
 */
private BufferedImage getThumbHorizontal(Rectangle thumbBounds) {
    int width = Math.max(1, thumbBounds.width);
    int height = Math.max(1, thumbBounds.height);
    int delta = Math.max(0, (int) (0.4 * height));
    if (delta % 2 == 1) {
        delta--;
    }
    height -= delta;

    StateTransitionTracker.ModelStateInfo modelStateInfo = this.compositeStateTransitionTracker
            .getModelStateInfo();
    ComponentState currState = modelStateInfo.getCurrModelState();

    SubstanceColorScheme baseFillScheme = (currState != ComponentState.ENABLED)
            ? SubstanceColorSchemeUtilities.getColorScheme(this.scrollbar, currState)
            : SubstanceColorSchemeUtilities.getActiveColorScheme(this.scrollbar, currState);
    SubstanceColorScheme baseBorderScheme = SubstanceColorSchemeUtilities
            .getColorScheme(this.scrollbar, ColorSchemeAssociationKind.BORDER, currState);
    BufferedImage baseLayer = getThumbHorizontal(this.scrollbar, width, height, baseFillScheme,
            baseBorderScheme);

    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates = modelStateInfo
            .getStateContributionMap();
    if (currState.isDisabled() || (activeStates.size() == 1)) {
        return baseLayer;
    }

    BufferedImage result = SubstanceCoreUtilities.getBlankUnscaledImage(baseLayer);
    Graphics2D g2d = result.createGraphics();
    g2d.drawImage(baseLayer, 0, 0, baseLayer.getWidth(), baseLayer.getHeight(), null);

    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry : activeStates
            .entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        if (activeState == modelStateInfo.getCurrModelState())
            continue;
        // if (activeState == ComponentState.ENABLED)
        // activeState = ComponentState.SELECTED;

        float contribution = activeEntry.getValue().getContribution();
        if (contribution == 0.0f)
            continue;

        g2d.setComposite(AlphaComposite.SrcOver.derive(contribution));

        SubstanceColorScheme fillScheme = (activeState != ComponentState.ENABLED)
                ? SubstanceColorSchemeUtilities.getColorScheme(this.scrollbar, activeState)
                : SubstanceColorSchemeUtilities.getActiveColorScheme(this.scrollbar,
                        activeState);
        SubstanceColorScheme borderScheme = SubstanceColorSchemeUtilities
                .getColorScheme(this.scrollbar, ColorSchemeAssociationKind.BORDER, activeState);
        BufferedImage layer = getThumbHorizontal(this.scrollbar, width, height, fillScheme,
                borderScheme);
        g2d.drawImage(layer, 0, 0, layer.getWidth(), layer.getHeight(), null);
    }

    g2d.dispose();
    return result;
}
 

/**
 * Returns the current icon to paint.
 *
 * @return Icon to paint.
 */
private ResizableIcon getIconToPaint() {
    StateTransitionTracker stateTransitionTracker = this.stateTransitionTrackerDelegate
            .getStateTransitionTracker();

    StateTransitionTracker.ModelStateInfo modelStateInfo = stateTransitionTracker
            .getModelStateInfo();
    Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates =
            modelStateInfo.getStateContributionMap();

    ComponentState currState = modelStateInfo.getCurrModelState();

    SubstanceColorScheme baseScheme = SubstanceColorSchemeUtilities.getColorScheme(
            this.comp, ColorSchemeAssociationKind.MARK, currState);
    float baseAlpha = SubstanceColorSchemeUtilities.getAlpha(this.comp, currState);

    HashMapKey keyBase = SubstanceCoreUtilities.getHashKey(baseScheme.getDisplayName(),
            baseAlpha, this.width, this.height);
    // System.out.println(key);
    ResizableIcon layerBase = this.iconMap.get(keyBase);
    if (layerBase == null) {
        ResizableIcon baseFullOpacity = this.delegate.getColorSchemeIcon(baseScheme, width, height);
        if (baseAlpha == 1.0f) {
            layerBase = baseFullOpacity;
            iconMap.put(keyBase, layerBase);
        } else {
            BufferedImage baseImage = SubstanceCoreUtilities.getBlankImage(
                    baseFullOpacity.getIconWidth(), baseFullOpacity.getIconHeight());
            Graphics2D g2base = baseImage.createGraphics();
            g2base.setComposite(AlphaComposite.SrcOver.derive(baseAlpha));
            baseFullOpacity.paintIcon(this.comp, g2base, 0, 0);
            g2base.dispose();
            layerBase = new ImageWrapperIcon(baseImage);
            iconMap.put(keyBase, layerBase);
        }
    }
    if (currState.isDisabled() || (activeStates.size() == 1)) {
        return layerBase;
    }

    BufferedImage result = SubstanceCoreUtilities.getBlankImage(layerBase
            .getIconWidth(), layerBase.getIconHeight());
    Graphics2D g2d = result.createGraphics();
    g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
            RenderingHints.VALUE_INTERPOLATION_BICUBIC);

    // draw the base layer
    layerBase.paintIcon(this.comp, g2d, 0, 0);

    // draw the other active layers
    for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry
            : activeStates.entrySet()) {
        ComponentState activeState = activeEntry.getKey();
        // System.out.println("Painting state " + activeState + "[curr is "
        // + currState + "] with " + activeEntry.getValue());
        if (activeState == currState)
            continue;

        float stateContribution = activeEntry.getValue().getContribution();
        if (stateContribution > 0.0f) {
            g2d.setComposite(AlphaComposite.SrcOver.derive(stateContribution));

            SubstanceColorScheme scheme = SubstanceColorSchemeUtilities.getColorScheme(this.comp,
                    ColorSchemeAssociationKind.MARK, activeState);
            float alpha = SubstanceColorSchemeUtilities.getAlpha(this.comp, activeState);

            HashMapKey key = SubstanceCoreUtilities.getHashKey(scheme.getDisplayName(), alpha,
                    this.width, this.height);
            ResizableIcon layer = iconMap.get(key);
            if (layer == null) {
                ResizableIcon fullOpacity = this.delegate.getColorSchemeIcon(scheme, width, height);
                if (alpha == 1.0f) {
                    layer = fullOpacity;
                    iconMap.put(key, layer);
                } else {
                    BufferedImage image = SubstanceCoreUtilities.getBlankImage(
                            fullOpacity.getIconWidth(), fullOpacity.getIconHeight());
                    Graphics2D g2layer = image.createGraphics();
                    g2layer.setComposite(AlphaComposite.SrcOver.derive(alpha));
                    fullOpacity.paintIcon(this.comp, g2layer, 0, 0);
                    g2layer.dispose();
                    layer = new ImageWrapperIcon(image);
                    iconMap.put(key, layer);
                }
            }
            layer.paintIcon(this.comp, g2d, 0, 0);
        }
    }
    g2d.dispose();
    return new ImageWrapperIcon(result);
}
 

private static Color getForegroundColor(AbstractCommandButton button,
            StateTransitionTracker.ModelStateInfo modelStateInfo) {
        ComponentState currStateIgnoreSelection =
                ComponentState.getState(button.getActionModel(), button, true);
        ComponentState currState = ComponentState.getState(button.getActionModel(), button, false);
        Map<ComponentState, StateTransitionTracker.StateContributionInfo> activeStates =
                modelStateInfo.getStateNoSelectionContributionMap();

        SubstanceColorScheme buttonFillScheme = SubstanceColorSchemeUtilities.getColorScheme(
                button, ColorSchemeAssociationKind.FILL, currStateIgnoreSelection);
        SubstanceSkin skin = SubstanceCoreUtilities.getSkin(button);
        SubstanceSlices.DecorationAreaType parentDecorationAreaType =
                SubstanceCortex.ComponentOrParentChainScope.getDecorationType(button.getParent());
        SubstanceColorScheme parentFillScheme = skin.getBackgroundColorScheme(parentDecorationAreaType);

        if (currState.isDisabled() || (activeStates == null) || (activeStates.size() == 1)) {
            SubstanceColorScheme schemeForCurrState = (currState == ComponentState.ENABLED)
                    ? parentFillScheme : buttonFillScheme;
//            System.out.println("For " + button.getText() + " state is " + currState +
//                    " and scheme is " + schemeForCurrState.getDisplayName() +
//                    " -> " + schemeForCurrState.getForegroundColor());
            return schemeForCurrState.getForegroundColor();
        }

        float aggrRed = 0;
        float aggrGreen = 0;
        float aggrBlue = 0;
//        System.out.println(
//                "For " + button.getText() + " in " + currState + ":" + currStateIgnoreSelection);
        for (Map.Entry<ComponentState, StateTransitionTracker.StateContributionInfo> activeEntry :
                activeStates.entrySet()) {
            ComponentState activeState = activeEntry.getKey();
            float alpha = activeEntry.getValue().getContribution();

            boolean correspondsToParentFill = (activeState == ComponentState.ENABLED) &&
                    !button.getActionModel().isSelected();
            SubstanceColorScheme activeColorScheme =
                    SubstanceColorSchemeUtilities.getColorScheme(button,
                            ColorSchemeAssociationKind.FILL, activeState);
            //System.out.println("\t" + activeState + " : " + currState);
            Color activeForeground = correspondsToParentFill
                    ? parentFillScheme.getForegroundColor()
                    : activeColorScheme.getForegroundColor();

//            System.out.println("\t" + activeState + " at alpha " + alpha + " from " +
//                    (correspondsToParentFill ? parentFillScheme :
//                            activeColorScheme).getDisplayName()
//                    + "[" + correspondsToParentFill + "] contributes color " +
//                    activeForeground);
            aggrRed += alpha * activeForeground.getRed();
            aggrGreen += alpha * activeForeground.getGreen();
            aggrBlue += alpha * activeForeground.getBlue();
        }
        return new Color((int) aggrRed, (int) aggrGreen, (int) aggrBlue);
    }