Java example source code file (GTKPainter.java)
The GTKPainter.java Java example source code/*
* Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.java.swing.plaf.gtk;
import sun.awt.UNIXToolkit;
import javax.swing.plaf.synth.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.plaf.*;
import com.sun.java.swing.plaf.gtk.GTKConstants.ArrowType;
import com.sun.java.swing.plaf.gtk.GTKConstants.ExpanderStyle;
import com.sun.java.swing.plaf.gtk.GTKConstants.Orientation;
import com.sun.java.swing.plaf.gtk.GTKConstants.PositionType;
import com.sun.java.swing.plaf.gtk.GTKConstants.ShadowType;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @author Joshua Outwater
* @author Scott Violet
*/
// Need to support:
// default_outside_border: Insets when default.
// interior_focus: Indicates if focus should appear inside border, or
// outside border.
// focus-line-width: Integer giving size of focus border
// focus-padding: Integer giving padding between border and focus
// indicator.
// focus-line-pattern:
//
class GTKPainter extends SynthPainter {
private static final PositionType[] POSITIONS = {
PositionType.BOTTOM, PositionType.RIGHT,
PositionType.TOP, PositionType.LEFT
};
private static final ShadowType SHADOWS[] = {
ShadowType.NONE, ShadowType.IN, ShadowType.OUT,
ShadowType.ETCHED_IN, ShadowType.OUT
};
private final static GTKEngine ENGINE = GTKEngine.INSTANCE;
final static GTKPainter INSTANCE = new GTKPainter();
private GTKPainter() {
}
private String getName(SynthContext context) {
return (context.getRegion().isSubregion()) ? null :
context.getComponent().getName();
}
public void paintCheckBoxBackground(SynthContext context,
Graphics g, int x, int y, int w, int h) {
paintRadioButtonBackground(context, g, x, y, w, h);
}
public void paintCheckBoxMenuItemBackground(SynthContext context,
Graphics g, int x, int y, int w, int h) {
paintRadioButtonMenuItemBackground(context, g, x, y, w, h);
}
// FORMATTED_TEXT_FIELD
public void paintFormattedTextFieldBackground(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
paintTextBackground(context, g, x, y, w, h);
}
//
// TOOL_BAR_DRAG_WINDOW
//
public void paintToolBarDragWindowBackground(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
paintToolBarBackground(context, g, x, y, w, h);
}
//
// TOOL_BAR
//
public void paintToolBarBackground(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
Region id = context.getRegion();
int state = context.getComponentState();
int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
int orientation = ((JToolBar)context.getComponent()).getOrientation();
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id,
state, orientation))
{
ENGINE.startPainting(g, x, y, w, h, id, state, orientation);
ENGINE.paintBox(g, context, id, gtkState, ShadowType.OUT,
"handlebox_bin", x, y, w, h);
ENGINE.finishPainting();
}
}
}
public void paintToolBarContentBackground(SynthContext context,
Graphics g,
int x, int y, int w, int h) {
Region id = context.getRegion();
int orientation = ((JToolBar)context.getComponent()).getOrientation();
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id, orientation)) {
ENGINE.startPainting(g, x, y, w, h, id, orientation);
ENGINE.paintBox(g, context, id, SynthConstants.ENABLED,
ShadowType.OUT, "toolbar", x, y, w, h);
ENGINE.finishPainting();
}
}
}
//
// PASSWORD_FIELD
//
public void paintPasswordFieldBackground(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
paintTextBackground(context, g, x, y, w, h);
}
//
// TEXT_FIELD
//
public void paintTextFieldBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
if (getName(context) == "Tree.cellEditor") {
paintTreeCellEditorBackground(context, g, x, y, w, h);
} else {
paintTextBackground(context, g, x, y, w, h);
}
}
//
// RADIO_BUTTON
//
// NOTE: this is called for JCheckBox too
public void paintRadioButtonBackground(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
Region id = context.getRegion();
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
if (gtkState == SynthConstants.MOUSE_OVER) {
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
ENGINE.startPainting(g, x, y, w, h, id);
ENGINE.paintFlatBox(g, context, id,
SynthConstants.MOUSE_OVER, ShadowType.ETCHED_OUT,
"checkbutton", x, y, w, h, ColorType.BACKGROUND);
ENGINE.finishPainting();
}
}
}
}
//
// RADIO_BUTTON_MENU_ITEM
//
// NOTE: this is called for JCheckBoxMenuItem too
public void paintRadioButtonMenuItemBackground(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
Region id = context.getRegion();
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
if (gtkState == SynthConstants.MOUSE_OVER) {
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
ShadowType shadow = (GTKLookAndFeel.is2_2() ?
ShadowType.NONE : ShadowType.OUT);
ENGINE.startPainting(g, x, y, w, h, id);
ENGINE.paintBox(g, context, id, gtkState,
shadow, "menuitem", x, y, w, h);
ENGINE.finishPainting();
}
}
}
}
//
// LABEL
//
public void paintLabelBackground(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
String name = getName(context);
JComponent c = context.getComponent();
Container container = c.getParent();
if (name == "TableHeader.renderer" ||
name == "GTKFileChooser.directoryListLabel" ||
name == "GTKFileChooser.fileListLabel") {
paintButtonBackgroundImpl(context, g, Region.BUTTON, "button",
x, y, w, h, true, false, false, false);
}
/*
* If the label is a ListCellRenderer and it's in a container
* (CellRendererPane) which is in a JComboBox then we paint the label
* as a TextField like a gtk_entry for a combobox.
*/
else if (c instanceof ListCellRenderer &&
container != null &&
container.getParent() instanceof JComboBox ) {
paintTextBackground(context, g, x, y, w, h);
}
}
//
// INTERNAL_FRAME
//
public void paintInternalFrameBorder(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
Metacity.INSTANCE.paintFrameBorder(context, g, x, y, w, h);
}
//
// DESKTOP_PANE
//
public void paintDesktopPaneBackground(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
// Does not call into ENGINE for better performance
fillArea(context, g, x, y, w, h, ColorType.BACKGROUND);
}
//
// DESKTOP_ICON
//
public void paintDesktopIconBorder(SynthContext context,
Graphics g, int x, int y,
int w, int h) {
Metacity.INSTANCE.paintFrameBorder(context, g, x, y, w, h);
}
public void paintButtonBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
String name = getName(context);
if (name != null && name.startsWith("InternalFrameTitlePane.")) {
Metacity.INSTANCE.paintButtonBackground(context, g, x, y, w, h);
} else {
AbstractButton button = (AbstractButton)context.getComponent();
boolean paintBG = button.isContentAreaFilled() &&
button.isBorderPainted();
boolean paintFocus = button.isFocusPainted();
boolean defaultCapable = (button instanceof JButton) &&
((JButton)button).isDefaultCapable();
boolean toolButton = (button.getParent() instanceof JToolBar);
paintButtonBackgroundImpl(context, g, Region.BUTTON, "button",
x, y, w, h, paintBG, paintFocus, defaultCapable, toolButton);
}
}
private void paintButtonBackgroundImpl(SynthContext context, Graphics g,
Region id, String detail, int x, int y, int w, int h,
boolean paintBackground, boolean paintFocus,
boolean defaultCapable, boolean toolButton) {
int state = context.getComponentState();
synchronized (UNIXToolkit.GTK_LOCK) {
if (ENGINE.paintCachedImage(g, x, y, w, h, id, state, detail,
paintBackground, paintFocus, defaultCapable, toolButton)) {
return;
}
ENGINE.startPainting(g, x, y, w, h, id, state, detail,
paintBackground, paintFocus, defaultCapable, toolButton);
// Paint the default indicator
GTKStyle style = (GTKStyle)context.getStyle();
if (defaultCapable && !toolButton) {
Insets defaultInsets = style.getClassSpecificInsetsValue(
context, "default-border",
GTKStyle.BUTTON_DEFAULT_BORDER_INSETS);
if (paintBackground && (state & SynthConstants.DEFAULT) != 0) {
ENGINE.paintBox(g, context, id, SynthConstants.ENABLED,
ShadowType.IN, "buttondefault", x, y, w, h);
}
x += defaultInsets.left;
y += defaultInsets.top;
w -= (defaultInsets.left + defaultInsets.right);
h -= (defaultInsets.top + defaultInsets.bottom);
}
boolean interiorFocus = style.getClassSpecificBoolValue(
context, "interior-focus", true);
int focusSize = style.getClassSpecificIntValue(
context, "focus-line-width",1);
int focusPad = style.getClassSpecificIntValue(
context, "focus-padding", 1);
int totalFocusSize = focusSize + focusPad;
int xThickness = style.getXThickness();
int yThickness = style.getYThickness();
// Render the box.
if (!interiorFocus &&
(state & SynthConstants.FOCUSED) == SynthConstants.FOCUSED) {
x += totalFocusSize;
y += totalFocusSize;
w -= 2 * totalFocusSize;
h -= 2 * totalFocusSize;
}
int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
boolean paintBg;
if (toolButton) {
// Toolbar buttons should only have their background painted
// in the PRESSED, SELECTED, or MOUSE_OVER states.
paintBg =
(gtkState != SynthConstants.ENABLED) &&
(gtkState != SynthConstants.DISABLED);
} else {
// Otherwise, always paint the button's background, unless
// the user has overridden it and we're in the ENABLED state.
paintBg =
paintBackground ||
(gtkState != SynthConstants.ENABLED);
}
if (paintBg) {
ShadowType shadowType = ShadowType.OUT;
if ((state & (SynthConstants.PRESSED |
SynthConstants.SELECTED)) != 0) {
shadowType = ShadowType.IN;
}
ENGINE.paintBox(g, context, id, gtkState,
shadowType, detail, x, y, w, h);
}
// focus
if (paintFocus && (state & SynthConstants.FOCUSED) != 0) {
if (interiorFocus) {
x += xThickness + focusPad;
y += yThickness + focusPad;
w -= 2 * (xThickness + focusPad);
h -= 2 * (yThickness + focusPad);
} else {
x -= totalFocusSize;
y -= totalFocusSize;
w += 2 * totalFocusSize;
h += 2 * totalFocusSize;
}
ENGINE.paintFocus(g, context, id, gtkState, detail, x, y, w, h);
}
ENGINE.finishPainting();
}
}
//
// ARROW_BUTTON
//
public void paintArrowButtonForeground(SynthContext context, Graphics g,
int x, int y, int w, int h,
int direction) {
Region id = context.getRegion();
Component c = context.getComponent();
String name = c.getName();
ArrowType arrowType = null;
switch (direction) {
case SwingConstants.NORTH:
arrowType = ArrowType.UP; break;
case SwingConstants.SOUTH:
arrowType = ArrowType.DOWN; break;
case SwingConstants.EAST:
arrowType = ArrowType.RIGHT; break;
case SwingConstants.WEST:
arrowType = ArrowType.LEFT; break;
}
String detail = "arrow";
if ((name == "ScrollBar.button") || (name == "TabbedPane.button")) {
if (arrowType == ArrowType.UP || arrowType == ArrowType.DOWN) {
detail = "vscrollbar";
} else {
detail = "hscrollbar";
}
} else if (name == "Spinner.nextButton" ||
name == "Spinner.previousButton") {
detail = "spinbutton";
} else if (name != "ComboBox.arrowButton") {
assert false : "unexpected name: " + name;
}
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
ShadowType shadowType = (gtkState == SynthConstants.PRESSED ?
ShadowType.IN : ShadowType.OUT);
synchronized (UNIXToolkit.GTK_LOCK) {
if (ENGINE.paintCachedImage(g, x, y, w, h,
gtkState, name, direction)) {
return;
}
ENGINE.startPainting(g, x, y, w, h, gtkState, name, direction);
ENGINE.paintArrow(g, context, id, gtkState,
shadowType, arrowType, detail, x, y, w, h);
ENGINE.finishPainting();
}
}
public void paintArrowButtonBackground(SynthContext context,
Graphics g, int x, int y, int w, int h) {
Region id = context.getRegion();
AbstractButton button = (AbstractButton)context.getComponent();
String name = button.getName();
String detail = "button";
int direction = SwingConstants.CENTER;
if ((name == "ScrollBar.button") || (name == "TabbedPane.button")) {
Integer prop = (Integer)
button.getClientProperty("__arrow_direction__");
direction = (prop != null) ?
prop.intValue() : SwingConstants.WEST;
switch (direction) {
default:
case SwingConstants.EAST:
case SwingConstants.WEST:
detail = "hscrollbar";
break;
case SwingConstants.NORTH:
case SwingConstants.SOUTH:
detail = "vscrollbar";
break;
}
} else if (name == "Spinner.previousButton") {
detail = "spinbutton_down";
} else if (name == "Spinner.nextButton") {
detail = "spinbutton_up";
} else if (name != "ComboBox.arrowButton") {
assert false : "unexpected name: " + name;
}
int state = context.getComponentState();
synchronized (UNIXToolkit.GTK_LOCK) {
if (ENGINE.paintCachedImage(g, x, y, w, h, id,
state, detail, direction))
{
return;
}
ENGINE.startPainting(g, x, y, w, h, id,
state, detail, direction);
if (detail.startsWith("spin")) {
/*
* The ubuntulooks engine (and presumably others) expect us to
* first draw the full "spinbutton" background, and then draw
* the individual "spinbutton_up/down" buttons on top of that.
* Note that it is the state of the JSpinner (not its arrow
* button) that determines how we draw this background.
*/
int spinState = button.getParent().isEnabled() ?
SynthConstants.ENABLED : SynthConstants.DISABLED;
int mody = (detail == "spinbutton_up") ? y : y-h;
int modh = h*2;
ENGINE.paintBox(g, context, id, spinState,
ShadowType.IN, "spinbutton",
x, mody, w, modh);
}
int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
ShadowType shadowType = ShadowType.OUT;
if ((gtkState & (SynthConstants.PRESSED |
SynthConstants.SELECTED)) != 0)
{
shadowType = ShadowType.IN;
}
ENGINE.paintBox(g, context, id, gtkState,
shadowType, detail,
x, y, w, h);
ENGINE.finishPainting();
}
}
//
// LIST
//
public void paintListBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
// Does not call into ENGINE for better performance
fillArea(context, g, x, y, w, h, GTKColorType.TEXT_BACKGROUND);
}
public void paintMenuBarBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
Region id = context.getRegion();
synchronized (UNIXToolkit.GTK_LOCK) {
if (ENGINE.paintCachedImage(g, x, y, w, h, id)) {
return;
}
GTKStyle style = (GTKStyle)context.getStyle();
int shadow = style.getClassSpecificIntValue(
context, "shadow-type", 2);
ShadowType shadowType = SHADOWS[shadow];
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
ENGINE.startPainting(g, x, y, w, h, id);
ENGINE.paintBox(g, context, id, gtkState,
shadowType, "menubar", x, y, w, h);
ENGINE.finishPainting();
}
}
//
// MENU
//
public void paintMenuBackground(SynthContext context,
Graphics g,
int x, int y, int w, int h) {
paintMenuItemBackground(context, g, x, y, w, h);
}
// This is called for both MENU and MENU_ITEM
public void paintMenuItemBackground(SynthContext context,
Graphics g,
int x, int y, int w, int h) {
int gtkState = GTKLookAndFeel.synthStateToGTKState(
context.getRegion(), context.getComponentState());
if (gtkState == SynthConstants.MOUSE_OVER) {
Region id = Region.MENU_ITEM;
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
ShadowType shadow = (GTKLookAndFeel.is2_2() ?
ShadowType.NONE : ShadowType.OUT);
ENGINE.startPainting(g, x, y, w, h, id);
ENGINE.paintBox(g, context, id, gtkState, shadow,
"menuitem", x, y, w, h);
ENGINE.finishPainting();
}
}
}
}
public void paintPopupMenuBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
Region id = context.getRegion();
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
synchronized (UNIXToolkit.GTK_LOCK) {
if (ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState)) {
return;
}
ENGINE.startPainting(g, x, y, w, h, id, gtkState);
ENGINE.paintBox(g, context, id, gtkState,
ShadowType.OUT, "menu", x, y, w, h);
GTKStyle style = (GTKStyle)context.getStyle();
int xThickness = style.getXThickness();
int yThickness = style.getYThickness();
ENGINE.paintBackground(g, context, id, gtkState,
style.getGTKColor(context, gtkState, GTKColorType.BACKGROUND),
x + xThickness, y + yThickness,
w - xThickness - xThickness, h - yThickness - yThickness);
ENGINE.finishPainting();
}
}
public void paintProgressBarBackground(SynthContext context,
Graphics g,
int x, int y, int w, int h) {
Region id = context.getRegion();
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
ENGINE.startPainting(g, x, y, w, h, id);
ENGINE.paintBox(g, context, id, SynthConstants.ENABLED,
ShadowType.IN, "trough", x, y, w, h);
ENGINE.finishPainting();
}
}
}
public void paintProgressBarForeground(SynthContext context, Graphics g,
int x, int y, int w, int h,
int orientation) {
Region id = context.getRegion();
synchronized (UNIXToolkit.GTK_LOCK) {
// Note that we don't call paintCachedImage() here. Since the
// progress bar foreground is painted differently for each value
// it would be wasteful to try to cache an image for each state,
// so instead we simply avoid caching in this case.
if (w <= 0 || h <= 0) {
return;
}
ENGINE.startPainting(g, x, y, w, h, id, "fg");
ENGINE.paintBox(g, context, id, SynthConstants.MOUSE_OVER,
ShadowType.OUT, "bar", x, y, w, h);
ENGINE.finishPainting(false); // don't bother caching the image
}
}
public void paintViewportBorder(SynthContext context, Graphics g,
int x, int y, int w, int h) {
Region id = context.getRegion();
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
ENGINE.startPainting(g, x, y, w, h, id);
ENGINE.paintShadow(g, context, id, SynthConstants.ENABLED,
ShadowType.IN, "scrolled_window", x, y, w, h);
ENGINE.finishPainting();
}
}
}
public void paintSeparatorBackground(SynthContext context,
Graphics g,
int x, int y, int w, int h,
int orientation) {
Region id = context.getRegion();
int state = context.getComponentState();
JComponent c = context.getComponent();
/*
* Note: In theory, the style's x/y thickness values would determine
* the width of the separator content. In practice, however, some
* engines will render a line that is wider than the corresponding
* thickness value. For example, ubuntulooks reports x/y thickness
* values of 1 for separators, but always renders a 2-pixel wide line.
* As a result of all this, we need to be careful not to restrict
* the w/h values below too much, so that the full thickness of the
* rendered line will be captured by our image caching code.
*/
String detail;
if (c instanceof JToolBar.Separator) {
/*
* GTK renders toolbar separators differently in that an
* artificial padding is added to each end of the separator.
* The value of 0.2f below is derived from the source code of
* gtktoolbar.c in the current version of GTK+ (2.8.20 at the
* time of this writing). Specifically, the relevant values are:
* SPACE_LINE_DIVISION 10.0
* SPACE_LINE_START 2.0
* SPACE_LINE_END 8.0
* These are used to determine the distance from the top (or left)
* edge of the toolbar to the other edge. So for example, the
* starting/top point of a vertical separator is 2/10 of the
* height of a horizontal toolbar away from the top edge, which
* is how we arrive at 0.2f below. Likewise, the ending/bottom
* point is 8/10 of the height away from the top edge, or in other
* words, it is 2/10 away from the bottom edge, which is again
* how we arrive at the 0.2f value below.
*
* The separator is also centered horizontally or vertically,
* depending on its orientation. This was determined empirically
* and by examining the code referenced above.
*/
detail = "toolbar";
float pct = 0.2f;
JToolBar.Separator sep = (JToolBar.Separator)c;
Dimension size = sep.getSeparatorSize();
GTKStyle style = (GTKStyle)context.getStyle();
if (orientation == JSeparator.HORIZONTAL) {
x += (int)(w * pct);
w -= (int)(w * pct * 2);
y += (size.height - style.getYThickness()) / 2;
} else {
y += (int)(h * pct);
h -= (int)(h * pct * 2);
x += (size.width - style.getXThickness()) / 2;
}
} else {
// For regular/menu separators, we simply subtract out the insets.
detail = "separator";
Insets insets = c.getInsets();
x += insets.left;
y += insets.top;
if (orientation == JSeparator.HORIZONTAL) {
w -= (insets.left + insets.right);
} else {
h -= (insets.top + insets.bottom);
}
}
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id,
state, detail, orientation)) {
ENGINE.startPainting(g, x, y, w, h, id,
state, detail, orientation);
if (orientation == JSeparator.HORIZONTAL) {
ENGINE.paintHline(g, context, id, state,
detail, x, y, w, h);
} else {
ENGINE.paintVline(g, context, id, state,
detail, x, y, w, h);
}
ENGINE.finishPainting();
}
}
}
public void paintSliderTrackBackground(SynthContext context,
Graphics g,
int x, int y, int w,int h) {
Region id = context.getRegion();
int state = context.getComponentState();
// For focused sliders, we paint focus rect outside the bounds passed.
// Need to adjust for that.
boolean focused = ((state & SynthConstants.FOCUSED) != 0);
int focusSize = 0;
if (focused) {
GTKStyle style = (GTKStyle)context.getStyle();
focusSize = style.getClassSpecificIntValue(
context, "focus-line-width", 1) +
style.getClassSpecificIntValue(
context, "focus-padding", 1);
x -= focusSize;
y -= focusSize;
w += focusSize * 2;
h += focusSize * 2;
}
// The ubuntulooks engine paints slider troughs differently depending
// on the current slider value and its component orientation.
JSlider slider = (JSlider)context.getComponent();
double value = slider.getValue();
double min = slider.getMinimum();
double max = slider.getMaximum();
double visible = 20; // not used for sliders; any value will work
synchronized (UNIXToolkit.GTK_LOCK) {
// Note that we don't call paintCachedImage() here. Since some
// engines (e.g. ubuntulooks) paint the slider background
// differently for any given slider value, it would be wasteful
// to try to cache an image for each state, so instead we simply
// avoid caching in this case.
if (w <= 0 || h <= 0) {
return;
}
ENGINE.startPainting(g, x, y, w, h, id, state, value);
int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
ENGINE.setRangeValue(context, id, value, min, max, visible);
ENGINE.paintBox(g, context, id, gtkState, ShadowType.IN,
"trough", x + focusSize, y + focusSize,
w - 2 * focusSize, h - 2 * focusSize);
if (focused) {
ENGINE.paintFocus(g, context, id, SynthConstants.ENABLED,
"trough", x, y, w, h);
}
ENGINE.finishPainting(false); // don't bother caching the image
}
}
public void paintSliderThumbBackground(SynthContext context,
Graphics g, int x, int y, int w, int h, int dir) {
Region id = context.getRegion();
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState, dir)) {
Orientation orientation = (dir == JSlider.HORIZONTAL ?
Orientation.HORIZONTAL : Orientation.VERTICAL);
String detail = (dir == JSlider.HORIZONTAL ?
"hscale" : "vscale");
ENGINE.startPainting(g, x, y, w, h, id, gtkState, dir);
ENGINE.paintSlider(g, context, id, gtkState,
ShadowType.OUT, detail, x, y, w, h, orientation);
ENGINE.finishPainting();
}
}
}
//
// SPINNER
//
public void paintSpinnerBackground(SynthContext context,
Graphics g,
int x, int y, int w, int h) {
// This is handled in paintTextFieldBackground
}
//
// SPLIT_PANE_DIVIDER
//
public void paintSplitPaneDividerBackground(SynthContext context,
Graphics g,
int x, int y, int w, int h) {
Region id = context.getRegion();
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
JSplitPane splitPane = (JSplitPane)context.getComponent();
Orientation orientation =
(splitPane.getOrientation() == JSplitPane.HORIZONTAL_SPLIT ?
Orientation.VERTICAL : Orientation.HORIZONTAL);
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h,
id, gtkState, orientation)) {
ENGINE.startPainting(g, x, y, w, h, id, gtkState, orientation);
ENGINE.paintHandle(g, context, id, gtkState,
ShadowType.OUT, "paned", x, y, w, h, orientation);
ENGINE.finishPainting();
}
}
}
public void paintSplitPaneDragDivider(SynthContext context,
Graphics g,int x, int y, int w, int h,
int orientation) {
paintSplitPaneDividerForeground(context, g, x, y, w, h, orientation);
}
public void paintTabbedPaneContentBackground(SynthContext context,
Graphics g, int x, int y, int w, int h) {
JTabbedPane pane = (JTabbedPane)context.getComponent();
int selectedIndex = pane.getSelectedIndex();
PositionType placement = GTKLookAndFeel.SwingOrientationConstantToGTK(
pane.getTabPlacement());
int gapStart = 0;
int gapSize = 0;
if (selectedIndex != -1) {
Rectangle tabBounds = pane.getBoundsAt(selectedIndex);
if (placement == PositionType.TOP ||
placement == PositionType.BOTTOM) {
gapStart = tabBounds.x - x;
gapSize = tabBounds.width;
}
else {
gapStart = tabBounds.y - y;
gapSize = tabBounds.height;
}
}
Region id = context.getRegion();
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h,
id, gtkState, placement, gapStart, gapSize)) {
ENGINE.startPainting(g, x, y, w, h,
id, gtkState, placement, gapStart, gapSize);
ENGINE.paintBoxGap(g, context, id, gtkState, ShadowType.OUT,
"notebook", x, y, w, h, placement, gapStart, gapSize);
ENGINE.finishPainting();
}
}
}
public void paintTabbedPaneTabBackground(SynthContext context,
Graphics g,
int x, int y, int w, int h,
int tabIndex) {
Region id = context.getRegion();
int state = context.getComponentState();
int gtkState = ((state & SynthConstants.SELECTED) != 0 ?
SynthConstants.ENABLED : SynthConstants.PRESSED);
JTabbedPane pane = (JTabbedPane)context.getComponent();
int placement = pane.getTabPlacement();
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h,
id, gtkState, placement, tabIndex)) {
PositionType side = POSITIONS[placement - 1];
ENGINE.startPainting(g, x, y, w, h,
id, gtkState, placement, tabIndex);
ENGINE.paintExtension(g, context, id, gtkState,
ShadowType.OUT, "tab", x, y, w, h, side, tabIndex);
ENGINE.finishPainting();
}
}
}
//
// TEXT_PANE
//
public void paintTextPaneBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
paintTextAreaBackground(context, g, x, y, w, h);
}
//
// EDITOR_PANE
//
public void paintEditorPaneBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
paintTextAreaBackground(context, g, x, y, w, h);
}
//
// TEXT_AREA
//
public void paintTextAreaBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
// Does not call into ENGINE for better performance
fillArea(context, g, x, y, w, h, GTKColorType.TEXT_BACKGROUND);
}
//
// TEXT_FIELD
//
// NOTE: Combobox and Label, Password and FormattedTextField calls this
// too.
private void paintTextBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
// Text is odd in that it uses the TEXT_BACKGROUND vs BACKGROUND.
JComponent c = context.getComponent();
Container container = c.getParent();
Container containerParent = null;
GTKStyle style = (GTKStyle)context.getStyle();
Region id = context.getRegion();
int state = context.getComponentState();
if (c instanceof ListCellRenderer && container != null) {
containerParent = container.getParent();
if (containerParent instanceof JComboBox
&& containerParent.hasFocus()) {
state |= SynthConstants.FOCUSED;
}
}
synchronized (UNIXToolkit.GTK_LOCK) {
if (ENGINE.paintCachedImage(g, x, y, w, h, id, state)) {
return;
}
int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
int focusSize = 0;
boolean interiorFocus = style.getClassSpecificBoolValue(
context, "interior-focus", true);
focusSize = style.getClassSpecificIntValue(context,
"focus-line-width",1);
if (!interiorFocus && (state & SynthConstants.FOCUSED) != 0) {
x += focusSize;
y += focusSize;
w -= 2 * focusSize;
h -= 2 * focusSize;
}
int xThickness = style.getXThickness();
int yThickness = style.getYThickness();
ENGINE.startPainting(g, x, y, w, h, id, state);
ENGINE.paintShadow(g, context, id, gtkState,
ShadowType.IN, "entry", x, y, w, h);
ENGINE.paintFlatBox(g, context, id,
gtkState, ShadowType.NONE, "entry_bg",
x + xThickness,
y + yThickness,
w - (2 * xThickness),
h - (2 * yThickness),
ColorType.TEXT_BACKGROUND);
if (focusSize > 0 && (state & SynthConstants.FOCUSED) != 0) {
if (!interiorFocus) {
x -= focusSize;
y -= focusSize;
w += 2 * focusSize;
h += 2 * focusSize;
} else {
if (containerParent instanceof JComboBox) {
x += (focusSize + 2);
y += (focusSize + 1);
w -= (2 * focusSize + 1);
h -= (2 * focusSize + 2);
} else {
x += focusSize;
y += focusSize;
w -= 2 * focusSize;
h -= 2 * focusSize;
}
}
ENGINE.paintFocus(g, context, id, gtkState,
"entry", x, y, w, h);
}
ENGINE.finishPainting();
}
}
private void paintTreeCellEditorBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
Region id = context.getRegion();
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState)) {
ENGINE.startPainting(g, x, y, w, h, id, gtkState);
ENGINE.paintFlatBox(g, context, id, gtkState, ShadowType.NONE,
"entry_bg", x, y, w, h, ColorType.TEXT_BACKGROUND);
ENGINE.finishPainting();
}
}
}
//
// ROOT_PANE
//
public void paintRootPaneBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
// Does not call into ENGINE for better performance
fillArea(context, g, x, y, w, h, GTKColorType.BACKGROUND);
}
//
// TOGGLE_BUTTON
//
public void paintToggleButtonBackground(SynthContext context,
Graphics g,
int x, int y, int w, int h) {
Region id = context.getRegion();
JToggleButton toggleButton = (JToggleButton)context.getComponent();
boolean paintBG = toggleButton.isContentAreaFilled() &&
toggleButton.isBorderPainted();
boolean paintFocus = toggleButton.isFocusPainted();
boolean toolButton = (toggleButton.getParent() instanceof JToolBar);
paintButtonBackgroundImpl(context, g, id, "button",
x, y, w, h,
paintBG, paintFocus, false, toolButton);
}
//
// SCROLL_BAR
//
public void paintScrollBarBackground(SynthContext context,
Graphics g,
int x, int y, int w,int h) {
Region id = context.getRegion();
boolean focused =
(context.getComponentState() & SynthConstants.FOCUSED) != 0;
synchronized (UNIXToolkit.GTK_LOCK) {
if (ENGINE.paintCachedImage(g, x, y, w, h, id, focused)) {
return;
}
ENGINE.startPainting(g, x, y, w, h, id, focused);
// Note: the scrollbar insets already include the "trough-border",
// which is needed to position the scrollbar buttons properly.
// But when we render, we need to take the trough border out
// of the equation so that we paint the entire area covered by
// the trough border and the scrollbar content itself.
Insets insets = context.getComponent().getInsets();
GTKStyle style = (GTKStyle)context.getStyle();
int troughBorder =
style.getClassSpecificIntValue(context, "trough-border", 1);
insets.left -= troughBorder;
insets.right -= troughBorder;
insets.top -= troughBorder;
insets.bottom -= troughBorder;
ENGINE.paintBox(g, context, id, SynthConstants.PRESSED,
ShadowType.IN, "trough",
x + insets.left,
y + insets.top,
w - insets.left - insets.right,
h - insets.top - insets.bottom);
if (focused) {
ENGINE.paintFocus(g, context, id,
SynthConstants.ENABLED, "trough", x, y, w, h);
}
ENGINE.finishPainting();
}
}
//
// SCROLL_BAR_THUMB
//
public void paintScrollBarThumbBackground(SynthContext context,
Graphics g, int x, int y, int w, int h, int dir) {
Region id = context.getRegion();
int gtkState = GTKLookAndFeel.synthStateToGTKState(
id, context.getComponentState());
// The clearlooks engine paints scrollbar thumbs differently
// depending on the current scroll value (specifically, it will avoid
// rendering a certain line when the thumb is at the starting or
// ending position). Therefore, we normalize the current value to
// the range [0,100] here and then pass it down to setRangeValue()
// so that the native widget is configured appropriately. Note that
// there are really only four values that matter (min, middle, max,
// or fill) so we restrict to one of those four values to avoid
// blowing out the image cache.
JScrollBar sb = (JScrollBar)context.getComponent();
boolean rtl =
sb.getOrientation() == JScrollBar.HORIZONTAL &&
!sb.getComponentOrientation().isLeftToRight();
double min = 0;
double max = 100;
double visible = 20;
double value;
if (sb.getMaximum() - sb.getMinimum() == sb.getVisibleAmount()) {
// In this case, the thumb fills the entire track, so it is
// touching both ends at the same time
value = 0;
visible = 100;
} else if (sb.getValue() == sb.getMinimum()) {
// At minimum
value = rtl ? 100 : 0;
} else if (sb.getValue() >= sb.getMaximum() - sb.getVisibleAmount()) {
// At maximum
value = rtl ? 0 : 100;
} else {
// Somewhere in between
value = 50;
}
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState,
dir, value, visible, rtl))
{
ENGINE.startPainting(g, x, y, w, h, id, gtkState,
dir, value, visible, rtl);
Orientation orientation = (dir == JScrollBar.HORIZONTAL ?
Orientation.HORIZONTAL : Orientation.VERTICAL);
ENGINE.setRangeValue(context, id, value, min, max, visible);
ENGINE.paintSlider(g, context, id, gtkState,
ShadowType.OUT, "slider", x, y, w, h, orientation);
ENGINE.finishPainting();
}
}
}
//
// TOOL_TIP
//
public void paintToolTipBackground(SynthContext context, Graphics g,
int x, int y, int w,int h) {
Region id = context.getRegion();
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
ENGINE.startPainting(g, x, y, w, h, id);
ENGINE.paintFlatBox(g, context, id, SynthConstants.ENABLED,
ShadowType.OUT, "tooltip", x, y, w, h,
ColorType.BACKGROUND);
ENGINE.finishPainting();
}
}
}
//
// TREE_CELL
//
public void paintTreeCellBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
Region id = context.getRegion();
int state = context.getComponentState();
int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id, state)) {
ENGINE.startPainting(g, x, y, w, h, id, state);
// the string arg should alternate based on row being painted,
// but we currently don't pass that in.
ENGINE.paintFlatBox(g, context, id, gtkState, ShadowType.NONE,
"cell_odd", x, y, w, h, ColorType.TEXT_BACKGROUND);
ENGINE.finishPainting();
}
}
}
public void paintTreeCellFocus(SynthContext context, Graphics g,
int x, int y, int w, int h) {
Region id = Region.TREE_CELL;
int state = context.getComponentState();
paintFocus(context, g, id, state, "treeview", x, y, w, h);
}
//
// TREE
//
public void paintTreeBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
// As far as I can tell, these don't call into the ENGINE.
fillArea(context, g, x, y, w, h, GTKColorType.TEXT_BACKGROUND);
}
//
// VIEWPORT
//
public void paintViewportBackground(SynthContext context, Graphics g,
int x, int y, int w, int h) {
// As far as I can tell, these don't call into the ENGINE.
// Also note that you don't want this to call into the ENGINE
// as if it where to paint a background JViewport wouldn't scroll
// correctly.
fillArea(context, g, x, y, w, h, GTKColorType.TEXT_BACKGROUND);
}
void paintFocus(SynthContext context, Graphics g, Region id,
int state, String detail, int x, int y, int w, int h) {
int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id, gtkState, "focus")) {
ENGINE.startPainting(g, x, y, w, h, id, gtkState, "focus");
ENGINE.paintFocus(g, context, id, gtkState, detail, x, y, w, h);
ENGINE.finishPainting();
}
}
}
void paintMetacityElement(SynthContext context, Graphics g,
int gtkState, String detail, int x, int y, int w, int h,
ShadowType shadow, ArrowType direction) {
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(
g, x, y, w, h, gtkState, detail, shadow, direction)) {
ENGINE.startPainting(
g, x, y, w, h, gtkState, detail, shadow, direction);
if (detail == "metacity-arrow") {
ENGINE.paintArrow(g, context, Region.INTERNAL_FRAME_TITLE_PANE,
gtkState, shadow, direction, "", x, y, w, h);
} else if (detail == "metacity-box") {
ENGINE.paintBox(g, context, Region.INTERNAL_FRAME_TITLE_PANE,
gtkState, shadow, "", x, y, w, h);
} else if (detail == "metacity-vline") {
ENGINE.paintVline(g, context, Region.INTERNAL_FRAME_TITLE_PANE,
gtkState, "", x, y, w, h);
}
ENGINE.finishPainting();
}
}
}
void paintIcon(SynthContext context, Graphics g,
Method paintMethod, int x, int y, int w, int h) {
int state = context.getComponentState();
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, state, paintMethod)) {
ENGINE.startPainting(g, x, y, w, h, state, paintMethod);
try {
paintMethod.invoke(this, context, g, state, x, y, w, h);
} catch (IllegalAccessException iae) {
assert false;
} catch (InvocationTargetException ite) {
assert false;
}
ENGINE.finishPainting();
}
}
}
void paintIcon(SynthContext context, Graphics g,
Method paintMethod, int x, int y, int w, int h, Object direction) {
int state = context.getComponentState();
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g,
x, y, w, h, state, paintMethod, direction)) {
ENGINE.startPainting(g,
x, y, w, h, state, paintMethod, direction);
try {
paintMethod.invoke(this, context,
g, state, x, y, w, h, direction);
} catch (IllegalAccessException iae) {
assert false;
} catch (InvocationTargetException ite) {
assert false;
}
ENGINE.finishPainting();
}
}
}
// All icon painting methods are called from under GTK_LOCK
public void paintTreeExpandedIcon(SynthContext context,
Graphics g, int state, int x, int y, int w, int h) {
ENGINE.paintExpander(g, context, Region.TREE,
GTKLookAndFeel.synthStateToGTKState(context.getRegion(), state),
ExpanderStyle.EXPANDED, "treeview", x, y, w, h);
}
public void paintTreeCollapsedIcon(SynthContext context,
Graphics g, int state, int x, int y, int w, int h) {
ENGINE.paintExpander(g, context, Region.TREE,
GTKLookAndFeel.synthStateToGTKState(context.getRegion(), state),
ExpanderStyle.COLLAPSED, "treeview", x, y, w, h);
}
public void paintCheckBoxIcon(SynthContext context,
Graphics g, int state, int x, int y, int w, int h) {
GTKStyle style = (GTKStyle)context.getStyle();
int size = style.getClassSpecificIntValue(context,
"indicator-size", GTKIconFactory.DEFAULT_ICON_SIZE);
int offset = style.getClassSpecificIntValue(context,
"indicator-spacing", GTKIconFactory.DEFAULT_ICON_SPACING);
ENGINE.paintCheck(g, context, Region.CHECK_BOX, "checkbutton",
x+offset, y+offset, size, size);
}
public void paintRadioButtonIcon(SynthContext context,
Graphics g, int state, int x, int y, int w, int h) {
GTKStyle style = (GTKStyle)context.getStyle();
int size = style.getClassSpecificIntValue(context,
"indicator-size", GTKIconFactory.DEFAULT_ICON_SIZE);
int offset = style.getClassSpecificIntValue(context,
"indicator-spacing", GTKIconFactory.DEFAULT_ICON_SPACING);
ENGINE.paintOption(g, context, Region.RADIO_BUTTON, "radiobutton",
x+offset, y+offset, size, size);
}
public void paintMenuArrowIcon(SynthContext context, Graphics g,
int state, int x, int y, int w, int h, ArrowType dir) {
int gtkState = GTKLookAndFeel.synthStateToGTKState(
context.getRegion(), state);
ShadowType shadow = ShadowType.OUT;
if (gtkState == SynthConstants.MOUSE_OVER) {
shadow = ShadowType.IN;
}
ENGINE.paintArrow(g, context, Region.MENU_ITEM, gtkState, shadow,
dir, "menuitem", x + 3, y + 3, 7, 7);
}
public void paintCheckBoxMenuItemCheckIcon(SynthContext context,
Graphics g, int state, int x, int y, int w, int h) {
GTKStyle style = (GTKStyle)context.getStyle();
int size = style.getClassSpecificIntValue(context,"indicator-size",
GTKIconFactory.DEFAULT_TOGGLE_MENU_ITEM_SIZE);
ENGINE.paintCheck(g, context, Region.CHECK_BOX_MENU_ITEM, "check",
x + GTKIconFactory.CHECK_ICON_EXTRA_INSET,
y + GTKIconFactory.CHECK_ICON_EXTRA_INSET,
size, size);
}
public void paintRadioButtonMenuItemCheckIcon(SynthContext context,
Graphics g, int state, int x, int y, int w, int h) {
GTKStyle style = (GTKStyle)context.getStyle();
int size = style.getClassSpecificIntValue(context,"indicator-size",
GTKIconFactory.DEFAULT_TOGGLE_MENU_ITEM_SIZE);
ENGINE.paintOption(g, context, Region.RADIO_BUTTON_MENU_ITEM, "option",
x + GTKIconFactory.CHECK_ICON_EXTRA_INSET,
y + GTKIconFactory.CHECK_ICON_EXTRA_INSET,
size, size);
}
public void paintToolBarHandleIcon(SynthContext context, Graphics g,
int state, int x, int y, int w, int h, Orientation orientation) {
int gtkState = GTKLookAndFeel.synthStateToGTKState(
context.getRegion(), state);
// The orientation parameter passed down by Synth refers to the
// orientation of the toolbar, but the one we pass to GTK refers
// to the orientation of the handle. Therefore, we need to swap
// the value here: horizontal toolbars have vertical handles, and
// vice versa.
orientation = (orientation == Orientation.HORIZONTAL) ?
Orientation.VERTICAL : Orientation.HORIZONTAL;
ENGINE.paintHandle(g, context, Region.TOOL_BAR, gtkState,
ShadowType.OUT, "handlebox", x, y, w, h, orientation);
}
public void paintAscendingSortIcon(SynthContext context,
Graphics g, int state, int x, int y, int w, int h) {
ENGINE.paintArrow(g, context, Region.TABLE, SynthConstants.ENABLED,
ShadowType.IN, ArrowType.UP, "arrow", x, y, w, h);
}
public void paintDescendingSortIcon(SynthContext context,
Graphics g, int state, int x, int y, int w, int h) {
ENGINE.paintArrow(g, context, Region.TABLE, SynthConstants.ENABLED,
ShadowType.IN, ArrowType.DOWN, "arrow", x, y, w, h);
}
/*
* Fill an area with color determined from this context's Style using the
* specified GTKColorType
*/
private void fillArea(SynthContext context, Graphics g,
int x, int y, int w, int h, ColorType colorType) {
if (context.getComponent().isOpaque()) {
Region id = context.getRegion();
int gtkState = GTKLookAndFeel.synthStateToGTKState(id,
context.getComponentState());
GTKStyle style = (GTKStyle)context.getStyle();
g.setColor(style.getGTKColor(context, gtkState, colorType));
g.fillRect(x, y, w, h);
}
}
// Refer to GTKLookAndFeel for details on this.
static class ListTableFocusBorder extends AbstractBorder implements
UIResource {
private boolean selectedCell;
private boolean focusedCell;
public static ListTableFocusBorder getSelectedCellBorder() {
return new ListTableFocusBorder(true, true);
}
public static ListTableFocusBorder getUnselectedCellBorder() {
return new ListTableFocusBorder(false, true);
}
public static ListTableFocusBorder getNoFocusCellBorder() {
return new ListTableFocusBorder(false, false);
}
public ListTableFocusBorder(boolean selectedCell, boolean focusedCell) {
this.selectedCell = selectedCell;
this.focusedCell = focusedCell;
}
private SynthContext getContext(Component c) {
SynthContext context = null;
ComponentUI ui = null;
if (c instanceof JLabel) {
ui = ((JLabel)c).getUI();
}
if (ui instanceof SynthUI) {
context = ((SynthUI)ui).getContext((JComponent)c);
}
return context;
}
public void paintBorder(Component c, Graphics g, int x, int y,
int w, int h) {
if (focusedCell) {
SynthContext context = getContext(c);
int state = (selectedCell? SynthConstants.SELECTED:
SynthConstants.FOCUSED | SynthConstants.ENABLED);
if (context != null) {
GTKPainter.INSTANCE.paintFocus(context, g,
Region.TABLE, state, "", x, y, w, h);
}
}
}
public Insets getBorderInsets(Component c, Insets i) {
SynthContext context = getContext(c);
if (context != null) {
i = context.getStyle().getInsets(context, i);
}
return i;
}
public boolean isBorderOpaque() {
return true;
}
}
// TitledBorder implementation for GTK L&F
static class TitledBorder extends AbstractBorder implements UIResource {
public void paintBorder(Component c, Graphics g, int x, int y,
int w, int h) {
SynthContext context = getContext((JComponent)c);
Region id = context.getRegion();
int state = context.getComponentState();
int gtkState = GTKLookAndFeel.synthStateToGTKState(id, state);
synchronized (UNIXToolkit.GTK_LOCK) {
if (! ENGINE.paintCachedImage(g, x, y, w, h, id)) {
ENGINE.startPainting(g, x, y, w, h, id);
ENGINE.paintShadow(g, context, id, gtkState, ShadowType.ETCHED_IN,
"frame", x, y, w, h);
ENGINE.finishPainting();
}
}
}
public Insets getBorderInsets(Component c, Insets i) {
SynthContext context = getContext((JComponent)c);
return context.getStyle().getInsets(context, i);
}
public boolean isBorderOpaque() {
return true;
}
private SynthStyle getStyle(JComponent c) {
return SynthLookAndFeel.getStyle(c, GTKEngine.CustomRegion.TITLED_BORDER);
}
private SynthContext getContext(JComponent c) {
int state = SynthConstants.DEFAULT;
return new SynthContext(c, GTKEngine.CustomRegion.TITLED_BORDER,
getStyle(c), state);
}
}
}
Other Java examples (source code examples)Here is a short list of links related to this Java GTKPainter.java source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
