1. /*

  2.  * @(#)GTKPainter.java	1.58 04/01/13

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package com.sun.java.swing.plaf.gtk;

  8. 

  9. import java.awt.*;

  10. import javax.swing.*;

  11. import javax.swing.border.*;

  12. import javax.swing.plaf.*;

  13. 

  14. /**

  15.  * @version 1.58, 01/13/04

  16.  * @author Joshua Outwater

  17.  * @author Scott Violet

  18.  */

  19. // Need to support:

  20. // default_outside_border: Insets when default.

  21. // interior_focus: Indicates if focus should appear inside border, or

  22. //                       outside border.

  23. // focus-line-width: Integer giving size of focus border

  24. // focus-padding: Integer giving padding between border and focus

  25. //        indicator.

  26. // focus-line-pattern:

  27. //

  28. class GTKPainter extends SynthPainter {

  29.     static final GTKPainter INSTANCE = new GTKPainter();

  30.     static final Insets EMPTY_INSETS = new Insets(0, 0, 0, 0);

  31.     private static final Insets TEMP_INSETS = new Insets(0, 0, 0, 0);

  32. 

  33.     /**

  34.      * Space for the default border.

  35.      */

  36.     private static final Insets BUTTON_DEFAULT_BORDER_INSETS =

  37.                                        new Insets(1, 1, 1, 1);

  38. 

  39. 

  40.     public void paint(SynthContext context, Object paintKey, Graphics g,

  41.                       int x, int y, int w, int h) {

  42.         Region id = context.getRegion();

  43.         String name = (id.isSubregion()) ? null :

  44.                                            context.getComponent().getName();

  45.         GTKEngine engine = ((GTKStyle)context.getStyle()).getEngine(context);

  46. 

  47.         if (paintKey == "background") {

  48.             if (!id.isSubregion()) {

  49.                 // Offset by the insets, if necessary.

  50.                 Border border = context.getComponent().getBorder();

  51. 

  52.                 if (border != null && !(border instanceof UIResource)) {

  53.                     Insets insets = context.getComponent().getInsets(

  54.                                             TEMP_INSETS);

  55. 

  56.                     if (insets != null) {

  57.                         x += insets.left;

  58.                         y += insets.right;

  59.                         w -= (insets.left + insets.right);

  60.                         h -= (insets.top + insets.bottom);

  61.                     }

  62.                 }

  63.             }

  64.             if (id == Region.ARROW_BUTTON) {

  65.                 paintArrowButtonBackground(context, engine, g, x, y, w, h);

  66.             }

  67.             else if (id == Region.BUTTON) {

  68.                 if (name != null &&

  69.                         name.startsWith("InternalFrameTitlePane.")) {

  70.                     Metacity.INSTANCE.paintButtonBackground(context,

  71.                             g, x, y, w, h);

  72.                 } else {

  73.                     paintButtonBackground(context, engine, g, x, y, w, h,

  74.                                           "button");

  75.                 }

  76.             }

  77.             else if (id == Region.FORMATTED_TEXT_FIELD) {

  78.                 paintTextFieldBackground(context, engine, g, x, y, w, h);

  79.             }

  80.             else if (id == Region.LABEL) {

  81.                 if ("TableHeader.renderer" == name ||

  82.                                name == "GTKFileChooser.directoryListLabel" ||

  83.                                name == "GTKFileChooser.fileListLabel") {

  84.                     paintButtonBackground(context, engine, g, x, y, w, h,

  85.                                           "button");

  86.                 }

  87.                 else if (name == "ComboBox.renderer") {

  88.                     paintTextFieldBackground(context, engine, g, x, y, w, h);

  89.                 }

  90.             }

  91.             else if (id == Region.LIST) {

  92.                 paintListBackground(context, engine, g, x, y, w, h);

  93.             }

  94.             else if (id == Region.MENU) {

  95.                 paintMenuBackground(context, engine, g, x, y, w, h);

  96.             }

  97.             else if (id == Region.MENU_BAR) {

  98.                 paintMenuBarBackground(context, engine, g, x, y, w, h);

  99.             }

  100.             else if (id == Region.MENU_ITEM) {

  101.                 paintMenuItemBackground(context, engine, g, x, y, w, h);

  102.             }

  103.             else if (id == Region.POPUP_MENU) {

  104.                 paintPopupMenuBackground(context, engine, g, x, y, w, h);

  105.             }

  106.             else if (id == Region.PROGRESS_BAR) {

  107.                 paintProgressBarBackground(context, engine, g, x, y, w, h);

  108.             }

  109.             else if (id == Region.CHECK_BOX || id == Region.RADIO_BUTTON) {

  110.                 paintCheckButtonBackground(context, engine, g, x, y, w, h);

  111.             }

  112.             else if (id == Region.CHECK_BOX_MENU_ITEM

  113.                     || id == Region.RADIO_BUTTON_MENU_ITEM) {

  114.                 paintCheckButtonMenuItemBackground(context, engine, g,

  115.                         x, y, w, h);

  116.             }

  117.             else if (id == Region.ROOT_PANE) {

  118.                 paintRootPaneBackground(context, engine, g, x, y, w, h);

  119.             }

  120.             else if (id == Region.SCROLL_BAR) {

  121.                 paintScrollBarBackground(context, engine, g, x, y, w, h);

  122.             }

  123.             else if (id == Region.SCROLL_BAR_THUMB) {

  124.                 paintScrollBarThumbBackground(context, engine, g, x, y, w, h);

  125.             }

  126.             /*

  127.             else if (id == Region.SCROLL_PANE) {

  128.                 paintScrollPaneBackground(context, engine, g, x, y, w, h);

  129.             }

  130.             */

  131.             else if (id == Region.SEPARATOR) {

  132.                 paintSeparatorBackground(context, engine, g, x, y, w, h);

  133.             }

  134.             else if (id == Region.SLIDER_TRACK) {

  135.                 paintSliderTrackBackground(context, engine, g, x, y, w, h);

  136.             }

  137.             else if (id == Region.SLIDER_THUMB) {

  138.                 paintSliderThumbBackground(context, engine, g, x, y, w, h);

  139.             }

  140.             else if (id == Region.SPINNER) {

  141.                 paintSpinnerBackground(context, engine, g, x, y, w, h);

  142.             }

  143.             else if (id == Region.SPLIT_PANE_DIVIDER) {

  144.                 paintSplitPaneDividerBackground(context, engine, g, x, y, w, h);

  145.             }

  146.             else if (id == Region.TABBED_PANE_CONTENT) {

  147.                 paintTabbedPaneContentBackground(context,

  148.                     engine, g, x, y, w, h);

  149.             }

  150.             else if (id == Region.TABBED_PANE_TAB) {

  151.                 paintTabbedPaneTabBackground(context, engine, g, x, y, w, h);

  152.             }

  153.             else if (id == Region.TEXT_AREA) {

  154.                 paintTextAreaBackground(context, engine, g, x, y, w, h);

  155.             }

  156.             else if (id == Region.TEXT_FIELD) {

  157.                 if (name == "Tree.cellEditor") {

  158.                     paintTreeCellEditorBackground(context, engine, g, x, y, w,

  159.                                                   h);

  160.                 }

  161.                 else {

  162.                     paintTextFieldBackground(context, engine, g, x, y, w, h);

  163.                 }

  164.             }

  165.             else if (id == Region.TOGGLE_BUTTON) {

  166.                 paintToggleButtonBackground(context, engine, g, x, y, w, h);

  167.             }

  168.             else if (id == Region.TOOL_BAR ||

  169.                      id == Region.TOOL_BAR_DRAG_WINDOW) {

  170.                 paintToolBarBackground(context, engine, g, x, y, w, h);

  171.             }

  172.             else if (id == Region.TOOL_BAR_CONTENT) {

  173.                 paintToolBarContentBackground(context, engine, g, x, y, w, h);

  174.             }

  175.             else if (id == Region.TOOL_TIP) {

  176.                 paintToolTipBackground(context, engine, g, x, y, w, h);

  177.             }

  178.             else if (id == Region.TREE) {

  179.                 paintTreeBackground(context, engine, g, x, y, w, h);

  180.             }

  181.             else if (id == Region.TREE_CELL) {

  182.                 paintTreeCellBackground(context, engine, g, x, y, w, h);

  183.             }

  184.             else if (id == Region.VIEWPORT) {

  185.                 paintViewportBackground(context, engine, g, x, y, w, h);

  186.             }

  187.         } else if (paintKey == "border") {

  188.             if (id == Region.INTERNAL_FRAME) {

  189.                 Metacity.INSTANCE.paintFrameBorder(context, g, x, y, w, h);

  190.             }

  191.             else if (id == Region.VIEWPORT) {

  192.                 paintScrollPaneBackground(context, engine, g, x, y, w, h);

  193.             }

  194.         }

  195.         else if (paintKey == "foreground") {

  196.             if (id == Region.ARROW_BUTTON) {

  197.                 paintArrowButtonForeground(context, engine, g, x, y, w, h);

  198.             }

  199.             else if (id == Region.PROGRESS_BAR) {

  200.                 paintProgressBarForeground(context, engine, g, x, y, w, h);

  201.             }

  202.             else if (id == Region.SPLIT_PANE_DIVIDER) {

  203.                 paintSplitPaneDividerDragBackground(context, engine, g, x, y,

  204.                                                     w,h);

  205.             }

  206.         }

  207.         else if (paintKey == "focus") {

  208.             if (id == Region.TREE_CELL) {

  209.                 paintTreeCellFocus(context, engine, g, x, y, w, h);

  210.             }

  211.         }

  212.     }

  213. 

  214.     Insets getInsets(SynthContext state, Insets insets) {

  215.         Region id = state.getRegion();

  216.         String name = (id.isSubregion()) ? null :

  217.                                            state.getComponent().getName();

  218. 

  219.         if (insets == null) {

  220.             insets = new Insets(0, 0, 0, 0);

  221.         }

  222.         else {

  223.             insets.top = insets.bottom = insets.left = insets.right = 0;

  224.         }

  225.         if (id == Region.BUTTON || id == Region.TOGGLE_BUTTON

  226.                 || id == Region.CHECK_BOX || id == Region.RADIO_BUTTON

  227.                 || id == Region.ARROW_BUTTON || id == Region.TOGGLE_BUTTON

  228.                 || id == Region.MENU

  229.                 || id == Region.MENU_ITEM

  230.                 || id == Region.RADIO_BUTTON_MENU_ITEM

  231.                 || id == Region.CHECK_BOX_MENU_ITEM) {

  232.             if ("Spinner.previousButton" == name ||

  233.                     "Spinner.nextButton" == name) {

  234.                 return getSpinnerButtonInsets(state, insets);

  235.             } else {

  236.                 return getButtonInsets(state, insets);

  237.             }

  238.         }

  239.         else if (id == Region.FORMATTED_TEXT_FIELD) {

  240.             return getTextFieldInsets(state, insets);

  241.         }

  242.         else if (id == Region.INTERNAL_FRAME) {

  243.             insets = Metacity.INSTANCE.getBorderInsets(state, insets);

  244.         }

  245.         else if (id == Region.LABEL) {

  246.             if ("TableHeader.renderer" == name) {

  247.                 return getButtonInsets(state, insets);

  248.             }

  249.             else if ("ComboBox.renderer" == name) {

  250.                 return getTextFieldInsets(state, insets);

  251.             }

  252.             else if ("Tree.cellRenderer" == name) {

  253.                 return getTreeCellRendererInsets(state, insets);

  254.             }

  255.         }

  256.         else if (id == Region.MENU_BAR) {

  257.             return getMenuBarInsets(state, insets);

  258.         }

  259.         else if (id == Region.OPTION_PANE) {

  260.             return getOptionPaneInsets(state, insets);

  261.         }

  262.         else if (id == Region.POPUP_MENU) {

  263.             return getPopupMenuInsets(state, insets);

  264.         }

  265.         else if (id == Region.PROGRESS_BAR) {

  266.             return getProgressBarInsets(state, insets);

  267.         }

  268.         else if (id == Region.SCROLL_BAR) {

  269.             return getScrollBarInsets(state, insets);

  270.         }

  271.         else if (id == Region.SEPARATOR) {

  272.             return getSeparatorInsets(state, insets);

  273.         }

  274.         else if (id == Region.SLIDER) {

  275.             return getSliderInsets(state, insets);

  276.         }

  277.         else if (id == Region.SLIDER_TRACK) {

  278.             return getSliderTrackInsets(state, insets);

  279.         }

  280.         else if (id == Region.SPINNER) {

  281.             return getSpinnerInsets(state, insets);

  282.         }

  283.         else if (id == Region.TABBED_PANE) {

  284.             return getTabbedPaneInsets(state, insets);

  285.         }

  286.         else if (id == Region.TABBED_PANE_CONTENT) {

  287.             return getTabbedPaneContentInsets(state, insets);

  288.         }

  289.         else if (id == Region.TABBED_PANE_TAB) {

  290.             return getTabbedPaneTabInsets(state, insets);

  291.         }

  292.         else if (id == Region.TEXT_FIELD) {

  293.             if (name == "Tree.cellEditor") {

  294.                 return getTreeCellEditorInsets(state, insets);

  295.             }

  296.             return getTextFieldInsets(state, insets);

  297.         }

  298.         else if (id == Region.TOOL_BAR) {

  299.             return getToolBarInsets(state, insets);

  300.         }

  301.         else if (id == Region.TOOL_TIP) {

  302.             return getToolTipInsets(state, insets);

  303.         }

  304.         return insets;

  305.     }

  306. 

  307.     //

  308.     // BUTTON

  309.     //

  310.     private Insets getButtonInsets(SynthContext context, Insets insets) {

  311.         GTKStyle style = (GTKStyle)context.getStyle();

  312.         int focusSize = style.getClassSpecificIntValue(context,

  313.                                                        "focus-line-width",1);

  314.         int focusPad = style.getClassSpecificIntValue(context,

  315.                                                       "focus-padding", 1);

  316.         int xThickness = style.getXThickness();

  317.         int yThickness = style.getYThickness();

  318.         int w = focusSize + focusPad + xThickness;

  319.         int h = focusSize + focusPad + yThickness;

  320.         Component component = context.getComponent();

  321. 

  322.         insets.left = insets.right = w;

  323.         insets.top = insets.bottom = h;

  324.         if ((component instanceof JButton) &&

  325.                        ((JButton)component).isDefaultCapable()) {

  326.             Insets defaultInsets = style.getClassSpecificInsetsValue(context,

  327.                           "default-border", BUTTON_DEFAULT_BORDER_INSETS);

  328.             insets.left += defaultInsets.left;

  329.             insets.right += defaultInsets.right;

  330.             insets.top += defaultInsets.top;

  331.             insets.bottom += defaultInsets.bottom;

  332.         }

  333.         return insets;

  334.     }

  335. 

  336.     private void paintButtonBackground(SynthContext context, GTKEngine engine,

  337.                                        Graphics g, int x, int y, int w, int h,

  338.                                        String detail) {

  339.         // paing the default shadow

  340.         int state = context.getComponentState();

  341.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  342.                                       context.getRegion(), state);

  343.         GTKStyle style = (GTKStyle)context.getStyle();

  344.         boolean interiorFocus = style.getClassSpecificBoolValue(context,

  345.                                                  "interior-focus", true);

  346.         int focusSize = style.getClassSpecificIntValue(context,

  347.                                                        "focus-line-width",1);

  348.         int focusPad = style.getClassSpecificIntValue(context, "focus-padding",

  349.                                                       1);

  350.         int totalFocusSize = focusSize + focusPad;

  351.         int xThickness = style.getXThickness();

  352.         int yThickness = style.getYThickness();

  353.         Component component = context.getComponent();

  354. 

  355.         // Paint the default indicator

  356.         if ((component instanceof JButton) &&

  357.                        ((JButton)component).isDefaultCapable()) {

  358.             Insets defaultInsets = (Insets)style.getClassSpecificInsetsValue(

  359.                       context, "default-border", BUTTON_DEFAULT_BORDER_INSETS);

  360. 

  361.             if ((state & SynthConstants.DEFAULT) == SynthConstants.DEFAULT) {

  362.                 engine.paintBox(context, g, SynthConstants.ENABLED,

  363.                                 GTKConstants.SHADOW_IN, "buttondefault",

  364.                                 x, y, w, h);

  365.             }

  366.             x += defaultInsets.left;

  367.             y += defaultInsets.top;

  368.             w -= (defaultInsets.left + defaultInsets.right);

  369.             h -= (defaultInsets.top + defaultInsets.bottom);

  370.         }

  371. 

  372.         // Render the box.

  373.         if (!interiorFocus && (state & SynthConstants.FOCUSED) ==

  374.                               SynthConstants.FOCUSED) {

  375.             x += totalFocusSize;

  376.             y += totalFocusSize;

  377.             w -= 2 * totalFocusSize;

  378.             h -= 2 * totalFocusSize;

  379.         }

  380.         if (!(component.getParent() instanceof JToolBar) ||

  381.                         gtkState != SynthConstants.ENABLED) {

  382.             int shadowType;

  383.             if ((state & SynthConstants.PRESSED) == SynthConstants.PRESSED) {

  384.                 shadowType = GTKConstants.SHADOW_IN;

  385.             }

  386.             else {

  387.                 shadowType = GTKConstants.SHADOW_OUT;

  388.             }

  389.             engine.paintBox(context, g, gtkState,  shadowType, detail,

  390.                             x, y, w, h);

  391.         }

  392. 

  393.         // focus

  394.         if ((state & SynthConstants.FOCUSED) == SynthConstants.FOCUSED) {

  395.             if (interiorFocus) {

  396.                 x += xThickness + focusPad;

  397.                 y += yThickness + focusPad;

  398.                 w -= 2 * (xThickness + focusPad);

  399.                 h -= 2 * (yThickness + focusPad);

  400.             }

  401.             else {

  402.                 x -= totalFocusSize;

  403.                 y -= totalFocusSize;

  404.                 w += 2 * totalFocusSize;

  405.                 h += 2 * totalFocusSize;

  406.             }

  407.             engine.paintFocus(context, g, gtkState, detail, x, y, w, h);

  408.         }

  409.     }

  410. 

  411. 

  412.     //

  413.     // ARROW_BUTTON

  414.     //

  415.     private void paintArrowButtonForeground(SynthContext context,

  416.                                             GTKEngine engine, Graphics g,

  417.                                             int x, int y, int w, int h) {

  418.         int state = GTKLookAndFeel.synthStateToGTKState(

  419.                            Region.ARROW_BUTTON, context.getComponentState());

  420.         int shadowType;

  421. 

  422.         if (state == SynthConstants.PRESSED) {

  423.             shadowType = GTKConstants.SHADOW_IN;

  424.         }

  425.         else {

  426.             shadowType = GTKConstants.SHADOW_OUT;

  427.         }

  428.         int direction = ((SynthArrowButton)context.getComponent()).

  429.                         getDirection();

  430.         switch (direction) {

  431.         case SwingConstants.NORTH:

  432.             direction = GTKConstants.ARROW_UP;

  433.             break;

  434.         case SwingConstants.SOUTH:

  435.             direction = GTKConstants.ARROW_DOWN;

  436.             break;

  437.         case SwingConstants.EAST:

  438.             direction = GTKConstants.ARROW_RIGHT;

  439.             break;

  440.         case SwingConstants.WEST:

  441.             direction = GTKConstants.ARROW_LEFT;

  442.             break;

  443.         }

  444.         Component c = context.getComponent();

  445.         String name = c.getName();

  446.         String detail = "arrow";

  447. 

  448.         if (name == "ScrollBar.button") {

  449.             if (c.getParent() instanceof JScrollBar) {

  450.                 if (((JScrollBar)c.getParent()).getOrientation() ==

  451.                                    SwingConstants.HORIZONTAL) {

  452.                     detail = "hscrollbar";

  453.                 }

  454.                 else {

  455.                     detail = "vscrollbar";

  456.                 }

  457.             }

  458.         }

  459.         else if (name == "Spinner.nextButton" ||

  460.                 name == "Spinner.previousButton") {

  461.             detail = "spinbutton";

  462.         }

  463. 

  464.         // Note quite sure what their algorithm is, but this works pretty

  465.         // good.

  466.         int size = Math.min(w / 2, h / 2);

  467.         x += (w - size) / 2;

  468.         y += (h - size) / 2;

  469. 

  470.         engine.paintArrow(context, g, state, shadowType, direction,

  471.                           detail, x, y, size, size);

  472.     }

  473. 

  474.     private void paintArrowButtonBackground(SynthContext context,

  475.                                             GTKEngine engine, Graphics g,

  476.                                             int x, int y, int w, int h) {

  477.         Component c = context.getComponent();

  478.         String name = c.getName();

  479.         String detail = "button";

  480. 

  481.         if (name == "ScrollBar.button") {

  482.             if (c.getParent() instanceof JScrollBar) {

  483.                 if (((JScrollBar)c.getParent()).getOrientation() ==

  484.                                    SwingConstants.HORIZONTAL) {

  485.                     detail = "hscrollbar";

  486.                 }

  487.                 else {

  488.                     detail = "vscrollbar";

  489.                 }

  490.             }

  491.         } else if ("Spinner.previousButton" == name ||

  492.                    "Spinner.nextButton" == name) {

  493.             detail = "spinbutton";

  494.         }

  495.         paintButtonBackground(context, engine, g, x, y, w, h, detail);

  496.     }

  497. 

  498.     //

  499.     // CHECK_BUTTON

  500.     //

  501.     private void paintCheckButtonBackground(SynthContext context,

  502.                                             GTKEngine engine, Graphics g,

  503.                                             int x, int y, int w, int h) {

  504.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  505.                 context.getRegion(), context.getComponentState());

  506. 

  507.         if ((gtkState & SynthConstants.MOUSE_OVER) != 0) {

  508.             engine.paintFlatBoxNormal(context, g, SynthConstants.MOUSE_OVER,

  509.                                 "checkbutton", x, y, w, h);

  510.         }

  511.     }

  512. 

  513. 

  514.     //

  515.     // CHECK_BUTTON_MENU_ITEM

  516.     //

  517.     public void paintCheckButtonMenuItemBackground(SynthContext context,

  518.                                             GTKEngine engine, Graphics g,

  519.                                             int x, int y, int w, int h) {

  520.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  521.                 context.getRegion(), context.getComponentState());

  522.         if ((context.getComponentState() & SynthConstants.MOUSE_OVER) != 0) {

  523.               if (GTKLookAndFeel.is2_2()) {

  524.                  engine.paintBox(context, g, gtkState, GTKConstants.SHADOW_NONE,

  525.                                  "menuitem", x, y, w, h);

  526.              }

  527.              else {

  528.             engine.paintBox(context, g, gtkState, GTKConstants.SHADOW_OUT,

  529.                 "menuitem", x, y, w, h);

  530.            }

  531.         }

  532.     }

  533. 

  534.     //

  535.     // LIST

  536.     //

  537.     private void paintListBackground(SynthContext context,

  538.                                     GTKEngine engine, Graphics g,

  539.                                     int x, int y, int w, int h) {

  540.         int state = GTKLookAndFeel.synthStateToGTKState(

  541.                 Region.LIST, context.getComponentState());

  542. 

  543.         if (context.getComponent().getName() == "ComboBox.list") {

  544.             // Paint it's shadow.

  545.         }

  546.         engine.paintFlatBoxText(context, g, state, "base", x, y, w, h);

  547. 

  548.     }

  549. 

  550.     //

  551.     // MENU_BAR

  552.     //

  553.     private Insets getMenuBarInsets(SynthContext context, Insets insets) {

  554.         GTKStyle style = (GTKStyle)context.getStyle();

  555.         int internalPadding = style.getClassSpecificIntValue(context,

  556.                                                        "internal-padding", 1);

  557.         int xThickness = style.getXThickness();

  558.         int yThickness = style.getYThickness();

  559.         insets.top = insets.bottom = internalPadding + yThickness;

  560.         insets.left = insets.right = internalPadding + xThickness;

  561.         return insets;

  562.     }

  563. 

  564.     private void paintMenuBarBackground(SynthContext context,

  565.                                         GTKEngine engine, Graphics g,

  566.                                         int x, int y, int w, int h) {

  567.         GTKStyle style = (GTKStyle)context.getStyle();

  568.         int shadowType = style.getClassSpecificIntValue(context,

  569.                 "shadow-type", GTKConstants.SHADOW_OUT);

  570.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  571.                 context.getRegion(), context.getComponentState());

  572. 

  573.         engine.paintBox(context, g, gtkState, shadowType, "menubar",

  574.                 x, y, w, h);

  575.     }

  576. 

  577.     //

  578.     // MENU

  579.     //

  580.     private void paintMenuBackground(SynthContext context,

  581.                                      GTKEngine engine, Graphics g,

  582.                                      int x, int y, int w, int h) {

  583.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  584.                 context.getRegion(), context.getComponentState());

  585.         if (gtkState == SynthConstants.MOUSE_OVER) {

  586.             if (GTKLookAndFeel.is2_2()) {

  587.                  engine.paintBox(context, g, gtkState, GTKConstants.SHADOW_NONE,

  588.                                  "menuitem", x, y, w, h);

  589.              }

  590.              else {

  591.             engine.paintBox(context, g, gtkState, GTKConstants.SHADOW_OUT,

  592.                 "menuitem", x, y, w, h);

  593.             }

  594.         }

  595.     }

  596. 

  597.     //

  598.     // MENU_ITEM

  599.     //

  600.     private Insets getMenuItemInsets(SynthContext context, Insets insets) {

  601.         GTKStyle style = (GTKStyle)context.getStyle();

  602.         int internalPadding = style.getClassSpecificIntValue(context,

  603.                                                        "internal-padding", 1);

  604.         int xThickness = style.getXThickness();

  605.         int yThickness = style.getYThickness();

  606.         insets.top = insets.bottom = internalPadding + yThickness;

  607.         insets.left = insets.right = internalPadding + xThickness;

  608.         return insets;

  609.     }

  610. 

  611.     private void paintMenuItemBackground(SynthContext context,

  612.                                      GTKEngine engine, Graphics g,

  613.                                      int x, int y, int w, int h) {

  614.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  615.                 context.getRegion(), context.getComponentState());

  616.         if ((context.getComponentState() & SynthConstants.MOUSE_OVER) != 0) {

  617.              if (GTKLookAndFeel.is2_2()) {

  618.                  engine.paintBox(context, g, gtkState, GTKConstants.SHADOW_NONE,

  619.                                  "menuitem", x, y, w, h);

  620.              }

  621.              else {

  622.                 engine.paintBox(context, g, gtkState, GTKConstants.SHADOW_OUT,

  623.                                 "menuitem", x, y, w, h);

  624.              }

  625.         }

  626.     }

  627. 

  628.     private Insets getPopupMenuInsets(SynthContext context, Insets insets) {

  629.         insets.left = insets.right = insets.top = insets.bottom = 2;

  630.         return insets;

  631.     }

  632. 

  633.     private void paintPopupMenuBackground(SynthContext context,

  634.                                         GTKEngine engine, Graphics g,

  635.                                         int x, int y, int w, int h) {

  636.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  637.                 context.getRegion(), context.getComponentState());

  638.         engine.paintBox(context, g, gtkState, GTKConstants.SHADOW_OUT,

  639.                 "menu", x, y, w, h);

  640. 

  641.         GTKStyle style = (GTKStyle)context.getStyle();

  642.         int xThickness = style.getXThickness();

  643.         int yThickness = style.getYThickness();

  644. 

  645.         engine.paintBackground(context, g, gtkState, style.getGTKColor(

  646.                context.getComponent(), context.getRegion(), gtkState,

  647.                GTKColorType.BACKGROUND), x + xThickness, y + yThickness,

  648.                w - xThickness - xThickness, h - yThickness - yThickness);

  649.     }

  650. 

  651.     //

  652.     // PROGRESS_BAR

  653.     //

  654.     private Insets getProgressBarInsets(SynthContext context, Insets insets) {

  655.         GTKStyle style = (GTKStyle)context.getStyle();

  656.         insets.left = insets.right = style.getXThickness();

  657.         insets.top = insets.bottom = style.getYThickness();

  658.         return insets;

  659.     }

  660. 

  661.     private void paintProgressBarBackground(SynthContext context,

  662.                                             GTKEngine engine, Graphics g,

  663.                                             int x, int y, int w, int h) {

  664.         GTKStyle style = (GTKStyle)context.getStyle();

  665.         // Draw the trough.

  666.         engine.paintBox(context, g, SynthConstants.ENABLED,

  667.                             GTKConstants.SHADOW_IN, "trough", x, y, w, h);

  668. 

  669.     }

  670. 

  671.     private void paintProgressBarForeground(SynthContext context,

  672.                                             GTKEngine engine, Graphics g,

  673.                                             int x, int y, int w, int h) {

  674.         // Draw the actual progress of the progress bar.

  675.         if (w != 0 || h != 0) {

  676.             engine.paintBox(context, g, SynthConstants.MOUSE_OVER,

  677.                 GTKConstants.SHADOW_OUT, "bar", x, y, w, h);

  678.         }

  679.     }

  680. 

  681.     private void paintScrollPaneBackground(SynthContext context,

  682.                                            GTKEngine engine, Graphics g,

  683.                                            int x, int y, int w, int h) {

  684.         engine.paintShadow(context, g, SynthConstants.ENABLED,

  685.                            GTKConstants.SHADOW_IN, "scrolled_window",

  686.                            x, y, w, h);

  687.     }

  688. 

  689.     Insets getScrollPaneInsets(SynthContext context, Insets insets) {

  690.         GTKStyle style = (GTKStyle)context.getStyle();

  691.         insets.right = insets.left = style.getXThickness();

  692.         insets.top = insets.bottom = style.getYThickness();

  693.         return insets;

  694.     }

  695. 

  696.     //

  697.     // SEPARATOR

  698.     //

  699.     private Insets getSeparatorInsets(SynthContext context, Insets insets) {

  700.         return insets;

  701.     }

  702. 

  703.     private void paintSeparatorBackground(SynthContext context,

  704.                                           GTKEngine engine, Graphics g,

  705.                                           int x, int y, int w, int h) {

  706.         if (((JSeparator)context.getComponent()).getOrientation() ==

  707.                 JSeparator.HORIZONTAL) {

  708.             engine.paintHline(context, g, SynthConstants.ENABLED,

  709.                 "hseparator", x, y, w, h);

  710.         } else {

  711.             engine.paintVline(context, g, SynthConstants.ENABLED,

  712.                 "vseparator", x, y, w, h);

  713.         }

  714.     }

  715. 

  716.     //

  717.     // SLIDER

  718.     //

  719.     private Insets getSliderInsets(SynthContext context, Insets insets) {

  720.         GTKStyle style = (GTKStyle)context.getStyle();

  721.         int xThickness = style.getXThickness();

  722.         int yThickness = style.getYThickness();

  723.         insets.top = insets.bottom = yThickness;

  724.         insets.right = insets.left = xThickness;

  725.         return insets;

  726.     }

  727. 

  728.     private Insets getSliderTrackInsets(SynthContext context, Insets insets) {

  729.         GTKStyle style = (GTKStyle)context.getStyle();

  730.         int focusSize = style.getClassSpecificIntValue(context,

  731.                                                         "focus-line-width", 1);

  732.         int focusPad = style.getClassSpecificIntValue(context,

  733.                                                       "focus-padding", 1);

  734.         insets.top = insets.bottom = insets.left = insets.right =

  735.             focusSize + focusPad;

  736.         return insets;

  737.     }

  738. 

  739.     private void paintSliderTrackBackground(SynthContext context,

  740.                                        GTKEngine engine, Graphics g,

  741.                                        int x, int y, int w,int h) {

  742.         GTKStyle style = (GTKStyle)context.getStyle();

  743. 

  744.         int state = context.getComponentState();

  745.         int gtkState = GTKLookAndFeel.synthStateToGTKState(context.getRegion(),

  746.                                                            state);

  747.         engine.paintBox(context, g, gtkState,

  748.                             GTKConstants.SHADOW_IN, "trough", x, y, w, h);

  749. 

  750.         if ((state & SynthConstants.FOCUSED) == SynthConstants.FOCUSED) {

  751.             int focusSize = style.getClassSpecificIntValue(context,

  752.                 "focus-line-width", 1);

  753.             focusSize += style.getClassSpecificIntValue(context,

  754.                 "focus-padding", 1);

  755.             x -= focusSize;

  756.             y -= focusSize;

  757.             w += 2 * focusSize;

  758.             h += 2 * focusSize;

  759.             engine.paintFocus(context, g, SynthConstants.ENABLED,

  760.                               "trough", x, y, w, h);

  761.         }

  762.     }

  763. 

  764.     private void paintSliderThumbBackground(SynthContext context,

  765.                                        GTKEngine engine, Graphics g,

  766.                                        int x, int y, int w, int h) {

  767.         int orientation;

  768. 

  769.         if (((JSlider)context.getComponent()).getOrientation() ==

  770.                               JSlider.HORIZONTAL) {

  771.             orientation = GTKConstants.HORIZONTAL;

  772.         }

  773.         else {

  774.             orientation = GTKConstants.VERTICAL;

  775.         }

  776.         engine.paintSlider(context, g, GTKLookAndFeel.synthStateToGTKState(

  777.                context.getRegion(), context.getComponentState()),

  778.                GTKConstants.SHADOW_OUT, "slider", x, y, w, h, orientation);

  779.     }

  780. 

  781.     //

  782.     // SPINNER

  783.     //

  784.     private void paintSpinnerBackground(SynthContext context,

  785.                                         GTKEngine engine, Graphics g,

  786.                                         int x, int y, int w, int h) {

  787.         // This is handled in paintTextFieldBackground

  788.     }

  789. 

  790.     private Insets getSpinnerInsets(SynthContext context, Insets insets) {

  791.         // Spinner's have no insets, the text field gets the insets.

  792.         return insets;

  793.     }

  794. 

  795.     private Insets getSpinnerButtonInsets(SynthContext context, Insets insets) {

  796.         insets.top = insets.bottom = 1;

  797.         insets.right = insets.left = 1;

  798.         return insets;

  799.     }

  800. 

  801.     //

  802.     // SPLIT_PANE_DIVIDER

  803.     //

  804.     private void paintSplitPaneDividerBackground(SynthContext context,

  805.                                        GTKEngine engine, Graphics g,

  806.                                        int x, int y, int w, int h) {

  807.         int orientation;

  808.         if (((JSplitPane)context.getComponent()).getOrientation() ==

  809.                                  JSplitPane.VERTICAL_SPLIT) {

  810.             orientation = GTKConstants.HORIZONTAL;

  811.         }

  812.         else {

  813.             orientation = GTKConstants.VERTICAL;

  814.         }

  815. 

  816.         engine.paintHandle(context, g, GTKLookAndFeel.synthStateToGTKState(

  817.                 context.getRegion(), context.getComponentState()),

  818.                 GTKConstants.UNDEFINED, "paned", x, y, w, h, orientation);

  819.     }

  820. 

  821.     private void paintSplitPaneDividerDragBackground(SynthContext context,

  822.                                        GTKEngine engine, Graphics g,

  823.                                        int x, int y, int w, int h) {

  824.         g.setColor(context.getStyle().getColor(context,

  825.                                                GTKColorType.BACKGROUND));

  826.         g.fillRect(x, y, w, h);

  827.         paintSplitPaneDividerBackground(context, engine, g, x, y, w, h);

  828.     }

  829. 

  830.     //

  831.     // TABBED_PANE

  832.     //

  833.     private Insets getTabbedPaneInsets(SynthContext context, Insets insets) {

  834.         GTKStyle style = (GTKStyle)context.getStyle();

  835.         int xThickness = style.getXThickness();

  836.         int yThickness = style.getYThickness();

  837.         insets.top = insets.bottom = yThickness;

  838.         insets.right = insets.left = xThickness;

  839.         return insets;

  840.     }

  841. 

  842.     //

  843.     // TABBED_PANE_CONTENT

  844.     //

  845.     private Insets getTabbedPaneContentInsets(SynthContext context,

  846.             Insets insets) {

  847.         GTKStyle style = (GTKStyle)context.getStyle();

  848.         int xThickness = style.getXThickness();

  849.         int yThickness = style.getYThickness();

  850.         insets.top = insets.bottom = yThickness;

  851.         insets.right = insets.left = xThickness;

  852.         return insets;

  853.     }

  854. 

  855.     private void paintTabbedPaneContentBackground(SynthContext context,

  856.                                             GTKEngine engine, Graphics g,

  857.                                             int x, int y, int w, int h) {

  858.         JTabbedPane tabPane = (JTabbedPane)context.getComponent();

  859.         GTKStyle style = (GTKStyle)context.getStyle();

  860.         Region region = context.getRegion();

  861.         int placement = GTKLookAndFeel.SwingOrientationConstantToGTK(

  862.                                      tabPane.getTabPlacement());

  863.         int start = 0;

  864.         int size = 0;

  865. 

  866.         int selectedIndex = tabPane.getSelectedIndex();

  867.         if (selectedIndex != -1) {

  868.             Rectangle tabBounds = tabPane.getBoundsAt(selectedIndex);

  869. 

  870.             if (placement == GTKConstants.TOP ||

  871.                              placement == GTKConstants.BOTTOM) {

  872.                 start = tabBounds.x - 1;

  873.                 size = tabBounds.width;

  874.             }

  875.             else {

  876.                 start = tabBounds.y - 1;

  877.                 size = tabBounds.height;

  878.             }

  879.         }

  880.         engine.paintBoxGap(context, g, GTKLookAndFeel.synthStateToGTKState(

  881.                     context.getRegion(), context.getComponentState()),

  882.                     GTKConstants.SHADOW_OUT, "notebook", x, y, w, h,

  883.                     placement, start, size);

  884.     }

  885. 

  886.     //

  887.     // TABBED_PANE_TAB

  888.     //

  889.     private Insets getTabbedPaneTabInsets(SynthContext context,

  890.             Insets insets) {

  891.         GTKStyle style = (GTKStyle)context.getStyle();

  892.         int xThickness = style.getXThickness();

  893.         int yThickness = style.getYThickness();

  894.         int focusSize = 0;

  895.         int pad = 2;

  896. 

  897.         focusSize = style.getClassSpecificIntValue(context,

  898.                 "focus-line-width",1);

  899.         insets.left = insets.right = focusSize + pad + xThickness;

  900.         insets.top = insets.bottom = focusSize + pad + yThickness;

  901.         return insets;

  902.     }

  903. 

  904.     private void paintTabbedPaneTabBackground(SynthContext context,

  905.                                            GTKEngine engine, Graphics g,

  906.                                            int x, int y, int w, int h) {

  907.         GTKStyle style = (GTKStyle)context.getStyle();

  908.         int state = context.getComponentState();

  909.         int tabIndex = ((TabContext)context).getTabIndex();

  910.         int selectedIndex = ((JTabbedPane)context.getComponent()).

  911.                             getSelectedIndex();

  912.         int offset = (selectedIndex == tabIndex) ? 0 : 2;

  913.         int side;

  914.         state = GTKLookAndFeel.synthStateToGTKState(context.getRegion(), state);

  915.         switch (((JTabbedPane)context.getComponent()).getTabPlacement()) {

  916.         case SwingConstants.TOP:

  917.             side = GTKConstants.BOTTOM;

  918.             y += offset;

  919.             h -= offset;

  920.             break;

  921.         case SwingConstants.BOTTOM:

  922.             h -= offset;

  923.             side = GTKConstants.TOP;

  924.             break;

  925.         case SwingConstants.LEFT:

  926.             x += offset;

  927.             w -= offset;

  928.             side = GTKConstants.RIGHT;

  929.             break;

  930.         default:

  931.             w -= offset;

  932.             side = GTKConstants.LEFT;

  933.             break;

  934.         }

  935.         engine.paintExtension(context, g, state, GTKConstants.SHADOW_OUT,

  936.                 "tab", x, y, w, h, side);

  937.     }

  938. 

  939.     //

  940.     // TEXT_AREA

  941.     //

  942.     private void paintTextAreaBackground(SynthContext context,

  943.                                          GTKEngine engine, Graphics g,

  944.                                          int x, int y, int w, int h) {

  945.         GTKStyle style = (GTKStyle)context.getStyle();

  946.         int state = context.getComponentState();

  947.         engine.paintFlatBoxText(context, g, state, "base", x, y, w, h);

  948.     }

  949. 

  950.     //

  951.     // TEXT_FIELD

  952.     //

  953.     // NOTE: comobobox and FormattedTextField calls this too.

  954.     private void paintTextFieldBackground(SynthContext context,

  955.                                           GTKEngine engine, Graphics g,

  956.                                           int x, int y, int w, int h) {

  957.         GTKStyle style = (GTKStyle)context.getStyle();

  958.         boolean interiorFocus = style.getClassSpecificBoolValue(context,

  959.                                                  "interior-focus", true);

  960.         int state = context.getComponentState();

  961.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  962.                                         context.getRegion(), state);

  963.         int focusSize;

  964.         int xThickness = style.getXThickness();

  965.         int yThickness = style.getYThickness();

  966. 

  967.         paintTextBackground(context, engine, g, x, y, w, h);

  968.         state = GTKLookAndFeel.synthStateToGTKState(context.getRegion(),state);

  969. 

  970.         if (!interiorFocus && (state & SynthConstants.FOCUSED) ==

  971.                               SynthConstants.FOCUSED) {

  972.             focusSize = style.getClassSpecificIntValue(context,

  973.                                                        "focus-line-width",1);

  974.             x += focusSize;

  975.             y += focusSize;

  976.             w -= 2 * focusSize;

  977.             h -= 2 * focusSize;

  978.         }

  979.         else {

  980.             focusSize = 0;

  981.         }

  982. 

  983.         engine.paintShadow(context, g, SynthConstants.ENABLED,

  984.                 GTKConstants.SHADOW_IN, "entry", x, y, w, h);

  985.         g.setColor(style.getGTKColor(context.getComponent(),

  986.                 context.getRegion(), SynthConstants.ENABLED,

  987.                 GTKColorType.TEXT_BACKGROUND));

  988.         g.fillRect(x + xThickness, y + yThickness, w - (2 * xThickness),

  989.                 h - (2 * yThickness));

  990. 

  991.         engine.paintFlatBoxText(context, g, SynthConstants.ENABLED, "entry_bg",

  992.                 x + xThickness, y + yThickness, w - (2 * xThickness),

  993.                 h - (2 * yThickness));

  994. 

  995.         if (focusSize > 0) {

  996.             x -= focusSize;

  997.             y -= focusSize;

  998.             w += 2 * focusSize;

  999.             h += 2 * focusSize;

  1000.             engine.paintFocus(context, g, gtkState, "entry", x, y, w, h);

  1001.         }

  1002.     }

  1003. 

  1004.     // NOTE: this is called for ComboBox, and FormattedTextField. too.

  1005.     private Insets getTextFieldInsets(SynthContext context, Insets insets) {

  1006.         GTKStyle style = (GTKStyle)context.getStyle();

  1007.         int xThickness = style.getXThickness();

  1008.         int yThickness = style.getYThickness();

  1009.         boolean interiorFocus = style.getClassSpecificBoolValue(context,

  1010.                                                  "interior-focus", true);

  1011.         int focusSize = 0;

  1012.         int pad = 2;

  1013. 

  1014.         if (!interiorFocus) {

  1015.             focusSize = style.getClassSpecificIntValue(context,

  1016.                                                        "focus-line-width",1);

  1017.         }

  1018.         insets.left = insets.right = focusSize + pad + xThickness;

  1019.         insets.top = insets.bottom = focusSize + pad + yThickness;

  1020.         return insets;

  1021.     }

  1022. 

  1023. 

  1024.     private void paintTextBackground(SynthContext context,

  1025.                                      GTKEngine engine, Graphics g,

  1026.                                      int x, int y, int w,int h) {

  1027.         // Text is odd, the background is filled in with

  1028.         // TEXT_BACKGROUND

  1029.         JComponent c = context.getComponent();

  1030.         // Text is odd in that it uses the TEXT_BACKGROUND vs BACKGROUND.

  1031.         if (c.isOpaque() && c.getBackground() instanceof ColorUIResource) {

  1032.             g.setColor(((GTKStyle)context.getStyle()).getGTKColor(

  1033.                        context.getComponent(), context.getRegion(),

  1034.                        SynthConstants.ENABLED, GTKColorType.TEXT_BACKGROUND));

  1035.             g.fillRect(x, y, w, h);

  1036.         }

  1037.     }

  1038. 

  1039. 

  1040.     //

  1041.     // OPTION_Pane

  1042.     //

  1043. 

  1044.     private Insets getOptionPaneInsets(SynthContext context, Insets insets) {

  1045.         insets.left = insets.right = insets.top = insets.bottom = 6;

  1046.         return insets;

  1047.     }

  1048. 

  1049. 

  1050.     //

  1051.     // TOGGLE_BUTTON

  1052.     //

  1053.     public void paintToggleButtonBackground(SynthContext context,

  1054.                                             GTKEngine engine, Graphics g,

  1055.                                             int x, int y, int w, int h) {

  1056. 

  1057.         int state = context.getComponentState();

  1058.         int gtkState = GTKLookAndFeel.synthStateToGTKState(context.getRegion(),

  1059.                                                            state);

  1060.         GTKStyle style = (GTKStyle)context.getStyle();

  1061.         boolean interiorFocus = style.getClassSpecificBoolValue(context,

  1062.                                                  "interior-focus", true);

  1063.         int focusSize = style.getClassSpecificIntValue(context,

  1064.                                                        "focus-line-width",1);

  1065.         int focusPad = style.getClassSpecificIntValue(context, "focus-padding",

  1066.                                                       1);

  1067.         int totalFocusSize = focusSize + focusPad;

  1068.         int xThickness = style.getXThickness();

  1069.         int yThickness = style.getYThickness();

  1070.         JToggleButton toggleButton = (JToggleButton)context.getComponent();

  1071. 

  1072.         if (!interiorFocus && (state & SynthConstants.FOCUSED) ==

  1073.                               SynthConstants.FOCUSED) {

  1074.             x += totalFocusSize;

  1075.             y += totalFocusSize;

  1076.             w -= 2 * totalFocusSize;

  1077.             h -= 2 * totalFocusSize;

  1078.         }

  1079. 

  1080.         int shadow = GTKConstants.SHADOW_OUT;

  1081.         if (toggleButton.isSelected() ||

  1082.                 ((state & SynthConstants.PRESSED) != 0)) {

  1083.             shadow = GTKConstants.SHADOW_IN;

  1084.         }

  1085.         engine.paintBox(context, g, gtkState, shadow, "button", x, y, w, h);

  1086. 

  1087.         // focus

  1088.         if ((state & SynthConstants.FOCUSED) == SynthConstants.FOCUSED) {

  1089.             if (interiorFocus) {

  1090.                 x += xThickness + focusPad;

  1091.                 y += yThickness + focusPad;

  1092.                 w -= 2 * (xThickness + focusPad);

  1093.                 h -= 2 * (yThickness + focusPad);

  1094.             }

  1095.             else {

  1096.                 x -= totalFocusSize;

  1097.                 y -= totalFocusSize;

  1098.                 w += 2 * totalFocusSize;

  1099.                 h += 2 * totalFocusSize;

  1100.             }

  1101.             engine.paintFocus(context, g, gtkState, "button", x, y, w, h);

  1102.         }

  1103.     }

  1104. 

  1105.     //

  1106.     // ROOT_PANE

  1107.     //

  1108.     public void paintRootPaneBackground(SynthContext context,

  1109.                                         GTKEngine engine, Graphics g,

  1110.                                         int x, int y, int w, int h) {

  1111.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  1112.                           context.getRegion(), context.getComponentState());

  1113. 

  1114.         engine.paintFlatBoxNormal(context, g, gtkState, "base", x, y, w, h);

  1115.     }

  1116. 

  1117.     //

  1118.     // SCROLL_BAR

  1119.     //

  1120.     private void paintScrollBarBackground(SynthContext context,

  1121.                                           GTKEngine engine, Graphics g,

  1122.                                           int x, int y, int w,int h) {

  1123.         GTKStyle style = (GTKStyle)context.getStyle();

  1124.         int state = context.getComponentState();

  1125.         int gtkState = GTKLookAndFeel.synthStateToGTKState(context.getRegion(),

  1126.                                                            state);

  1127.         int focusSize = style.getClassSpecificIntValue(context,

  1128.                                                         "focus-line-width",1);

  1129.         int focusPad = style.getClassSpecificIntValue(context,

  1130.                                                       "focus-padding", 1);

  1131.         int totalFocus = focusSize + focusPad;

  1132. 

  1133.         engine.paintBox(context, g, SynthConstants.PRESSED,

  1134.                             GTKConstants.SHADOW_IN, "trough", x + totalFocus,

  1135.                             y + totalFocus, w - 2 * totalFocus,

  1136.                             h - 2 * totalFocus);

  1137.         if ((state & SynthConstants.FOCUSED) == SynthConstants.FOCUSED) {

  1138.             engine.paintFocus(context, g, SynthConstants.ENABLED,

  1139.                               "trough", x, y, w, h);

  1140.         }

  1141.     }

  1142. 

  1143.     private Insets getScrollBarInsets(SynthContext context, Insets insets) {

  1144.         GTKStyle style = (GTKStyle)context.getStyle();

  1145.         if (context.getComponent().isFocusable()) {

  1146.             int focusSize = style.getClassSpecificIntValue(context,

  1147.                                                         "focus-line-width",1);

  1148.             int focusPad = style.getClassSpecificIntValue(context,

  1149.                                                       "focus-padding", 1);

  1150.             int w = focusSize + focusPad;

  1151.             int h = focusSize + focusPad;

  1152. 

  1153.             insets.left = insets.right = w;

  1154.             insets.top = insets.bottom = h;

  1155.         }

  1156.         int troughBorder = style.getClassSpecificIntValue(context,

  1157.                                                           "trough-border", 1);

  1158.         insets.left += troughBorder;

  1159.         insets.right += troughBorder;

  1160.         insets.top += troughBorder;

  1161.         insets.bottom += troughBorder;

  1162.         return insets;

  1163.     }

  1164. 

  1165. 

  1166.     //

  1167.     // SCROLL_BAR_THUMB

  1168.     //

  1169.     private void paintScrollBarThumbBackground(SynthContext context,

  1170.                                           GTKEngine engine, Graphics g,

  1171.                                           int x, int y, int w, int h) {

  1172.         int orientation;

  1173.         if (((JScrollBar)context.getComponent()).getOrientation() ==

  1174.                          JScrollBar.VERTICAL) {

  1175.             orientation = GTKConstants.VERTICAL;

  1176.         }

  1177.         else {

  1178.             orientation = GTKConstants.HORIZONTAL;

  1179.         }

  1180.         engine.paintSlider(context, g, GTKLookAndFeel.synthStateToGTKState(

  1181.                context.getRegion(), context.getComponentState()),

  1182.                GTKConstants.SHADOW_OUT, "slider", x, y, w, h, orientation);

  1183.     }

  1184. 

  1185.     //

  1186.     // TOOL_BAR

  1187.     //

  1188.     private void paintToolBarBackground(SynthContext context, GTKEngine engine,

  1189.                                         Graphics g, int x, int y,

  1190.                                         int w, int h) {

  1191.         int state = context.getComponentState();

  1192.         int gtkState = GTKLookAndFeel.synthStateToGTKState(context.getRegion(),

  1193.                 state);

  1194.         GTKStyle style = (GTKStyle)context.getStyle();

  1195. 

  1196.         g.setColor(style.getGTKColor(context.getComponent(),

  1197.                 context.getRegion(), state, GTKColorType.BACKGROUND));

  1198.         engine.paintFlatBox(context, g, gtkState, "handlebox_bin", x, y, w, h);

  1199.     }

  1200. 

  1201.     private Insets getToolBarInsets(SynthContext context, Insets insets) {

  1202.         GTKStyle style = (GTKStyle)context.getStyle();

  1203.         int xThickness = style.getXThickness();

  1204.         int yThickness = style.getYThickness();

  1205.         insets.top = insets.bottom = yThickness;

  1206.         insets.right = insets.left = xThickness;

  1207.         return insets;

  1208.     }

  1209. 

  1210.     private void paintToolBarContentBackground(SynthContext context,

  1211.             GTKEngine engine, Graphics g, int x, int y, int w, int h) {

  1212.         int state = context.getComponentState();

  1213.         int gtkState = GTKLookAndFeel.synthStateToGTKState(context.getRegion(),

  1214.                                                            state);

  1215.         engine.paintShadow(context, g, SynthConstants.ENABLED,

  1216.             GTKConstants.SHADOW_OUT, "handlebox_bin", x, y, w, h);

  1217.     }

  1218. 

  1219.     //

  1220.     // TOOL_TIP

  1221.     //

  1222.     private void paintToolTipBackground(SynthContext context,

  1223.                                         GTKEngine engine, Graphics g,

  1224.                                         int x, int y, int w,int h) {

  1225.         engine.paintFlatBoxNormal(context, g, SynthConstants.ENABLED,"tooltip",

  1226.                             x, y, w, h);

  1227.     }

  1228. 

  1229.     private Insets getToolTipInsets(SynthContext context, Insets insets) {

  1230.         GTKStyle style = (GTKStyle)context.getStyle();

  1231. 

  1232.         insets.left = insets.right = style.getXThickness();

  1233.         insets.top = insets.bottom = style.getYThickness();

  1234.         return insets;

  1235.     }

  1236. 

  1237. 

  1238.     //

  1239.     // TREE_CELL

  1240.     //

  1241.     private void paintTreeCellBackground(SynthContext context,

  1242.                                         GTKEngine engine, Graphics g,

  1243.                                         int x, int y, int w,int h) {

  1244.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  1245.                           context.getRegion(), context.getComponentState());

  1246.         // the string arg should alternate based on row being painted, but

  1247.         // we currently don't pass that in.

  1248.         engine.paintFlatBoxText(context, g, gtkState, "cell_odd", x, y, w, h);

  1249.     }

  1250. 

  1251.     private void paintTreeCellFocus(SynthContext context,

  1252.                                     GTKEngine engine, Graphics g,

  1253.                                     int x, int y, int w,int h) {

  1254.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  1255.                           context.getRegion(), context.getComponentState());

  1256.         engine.paintFocus(context, g, gtkState, "treeview", x, y, w, h);

  1257.     }

  1258. 

  1259. 

  1260.     //

  1261.     // TREE_CELL_RENDERER

  1262.     //

  1263.     private Insets getTreeCellRendererInsets(SynthContext context,

  1264.                                              Insets insets) {

  1265.         insets.left = insets.right = insets.top = insets.bottom = 1;

  1266.         return insets;

  1267.     }

  1268. 

  1269. 

  1270.     //

  1271.     // TREE_CELL_EDITOR

  1272.     //

  1273.     private Insets getTreeCellEditorInsets(SynthContext context,

  1274.                                              Insets insets) {

  1275.         insets.left = insets.right = insets.top = insets.bottom = 1;

  1276.         return insets;

  1277.     }

  1278. 

  1279.     private void paintTreeCellEditorBackground(SynthContext context,

  1280.                                      GTKEngine engine, Graphics g,

  1281.                                      int x, int y, int w,int h) {

  1282.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  1283.                           context.getRegion(), context.getComponentState());

  1284.         engine.paintFlatBoxText(context, g, gtkState, "entry_bg", x, y, w, h);

  1285.     }

  1286. 

  1287. 

  1288.     //

  1289.     // TREE

  1290.     //

  1291.     private void paintTreeBackground(SynthContext context,

  1292.                                         GTKEngine engine, Graphics g,

  1293.                                         int x, int y, int w,int h) {

  1294.         // As far as I can tell, these don't call into the engine.

  1295.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  1296.                           context.getRegion(), context.getComponentState());

  1297.         g.setColor(((GTKStyle)context.getStyle()).getGTKColor(

  1298.                 context.getComponent(), context.getRegion(), gtkState,

  1299.                 GTKColorType.TEXT_BACKGROUND));

  1300.         g.fillRect(x, y, w, h);

  1301.     }

  1302. 

  1303. 

  1304.     //

  1305.     // VIEWPORT

  1306.     //

  1307.     private void paintViewportBackground(SynthContext context,

  1308.                                         GTKEngine engine, Graphics g,

  1309.                                         int x, int y, int w,int h) {

  1310.         // As far as I can tell, these don't call into the engine.

  1311.         // Also note that you don't want this to call into the engine

  1312.         // as if it where to paint a background JViewport wouldn't scroll

  1313.         // correctly.

  1314.         int gtkState = GTKLookAndFeel.synthStateToGTKState(

  1315.                           context.getRegion(), context.getComponentState());

  1316.         g.setColor(((GTKStyle)context.getStyle()).getGTKColor(

  1317.                 context.getComponent(), context.getRegion(), gtkState,

  1318.                 GTKColorType.TEXT_BACKGROUND));

  1319.         g.fillRect(x, y, w, h);

  1320.     }

  1321. 

  1322. 

  1323. 

  1324.     // Refer to GTKLookAndFeel for details on this.

  1325.     static class ListTableFocusBorder extends AbstractBorder implements

  1326.                           UIResource {

  1327.         public void paintBorder(Component c, Graphics g, int x, int y,

  1328.                                 int w, int h) {

  1329.             g.setColor(Color.BLACK);

  1330.             GTKEngine.INSTANCE._paintFocus(g, x, y, w, h,

  1331.                                            GTKEngine.DEFAULT_FOCUS_PATTERN, 1);

  1332.         }

  1333.         public Insets getBorderInsets(Component c) {

  1334.             return new Insets(1, 1, 1, 1);

  1335.         }

  1336.         public Insets getBorderInsets(Component c, Insets i) {

  1337.             if (i == null) {

  1338.                 return getBorderInsets(c);

  1339.             }

  1340.             i.left = i.right = i.top = i.bottom = 1;

  1341.             return i;

  1342.         }

  1343.         public boolean isBorderOpaque() {

  1344.             return true;

  1345.         }

  1346.     }

  1347. }