1. /*

  2.  * @(#)GTKEngine.java	1.53 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. 

  12. /**

  13.  * GTKEngine mirrors that of a a GtkStyleClass.

  14.  * <p>

  15.  * The states that are passed in correspond to gtk's set of states:

  16.  * <table>

  17.  * <tr><td>Synth<td>GTK

  18.  * <tr><td>GTKConstants.ENABLED<td>NORMAL

  19.  * <tr><td>GTKConstants.PRESSED<td>ACTIVE

  20.  * <tr><td>GTKConstants.SELECTED<td>SELECTED

  21.  * <tr><td>GTKConstants.MOUSE_OVER<td>PRELIGHT

  22.  * <tr><td>GTKConstants.DISABLED<td>INSENSITIVE

  23.  * </table>

  24.  * @version 1.53, 01/13/04

  25.  * @author Josh Outwater

  26.  * @author Scott Violet

  27.  */

  28. class GTKEngine {

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

  30. 

  31.     static final int[] DEFAULT_FOCUS_PATTERN = new int[] {1, 1};

  32. 

  33.     static int adjustAxisForComponentOrientation(JComponent c,

  34.                                                  int axis) {

  35.         if (c.getComponentOrientation().isLeftToRight()) {

  36.             return axis;

  37.         }

  38.         switch (axis) {

  39.         case SwingConstants.EAST:

  40.             return SwingConstants.WEST;

  41.         case SwingConstants.WEST:

  42.             return SwingConstants.EAST;

  43.         }

  44.         return axis;

  45.     }

  46. 

  47. 

  48.     public void paintArrow(SynthContext context, Graphics g, int state,

  49.                            int shadowType, int direction, String info,

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

  51.         // Draw the arrow

  52.         int sizeW = w / 2;

  53.         if (w % 2 == 1) {

  54.             sizeW++;

  55.         }

  56.         int sizeH = h / 2;

  57.         if (h % 2 == 1) {

  58.             sizeH++;

  59.         }

  60.         int size = Math.max(2, Math.min(sizeW, sizeH));

  61. 

  62.         switch (direction) {

  63.         case GTKConstants.ARROW_UP:

  64.             x += w / 2 - 1;

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

  66.             break;

  67.         case GTKConstants.ARROW_DOWN:

  68.             x += w / 2 - 1;

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

  70.             break;

  71.         case GTKConstants.ARROW_LEFT:

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

  73.             y += h / 2 - 1;

  74.             break;

  75.         case GTKConstants.ARROW_RIGHT:

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

  77.             y += h / 2 - 1;

  78.             break;

  79.         }

  80. 

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

  82.         int mid, i, j;

  83. 

  84.         j = 0;

  85.         mid = (size / 2) - 1;

  86. 

  87.         g.translate(x, y);

  88. 

  89.         if (state == SynthConstants.DISABLED) {

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

  91.                        context.getRegion(), state, GTKColorType.WHITE));

  92.         }

  93.         else {

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

  95.                        context.getRegion(), state, GTKColorType.FOREGROUND));

  96.         }

  97. 

  98.         switch(direction) {

  99.         case GTKConstants.ARROW_UP:

  100.             for(i = 0; i < size; i++) {

  101.                 g.drawLine(mid-i, i, mid+i, i);

  102.             }

  103.             break;

  104.         case GTKConstants.ARROW_DOWN:

  105.             j = 0;

  106.             for (i = size-1; i >= 0; i--) {

  107.                 g.drawLine(mid-i, j, mid+i, j);

  108.                 j++;

  109.             }

  110.             break;

  111.         case GTKConstants.ARROW_LEFT:

  112.             for (i = 0; i < size; i++) {

  113.                 g.drawLine(i, mid-i, i, mid+i);

  114.             }

  115.             break;

  116.         case GTKConstants.ARROW_RIGHT:

  117.             j = 0;

  118.             for (i = size-1; i >= 0; i--)   {

  119.                 g.drawLine(j, mid-i, j, mid+i);

  120.                 j++;

  121.             }

  122.             break;

  123.         }

  124.         g.translate(-x, -y);

  125.     }

  126. 

  127.     public void paintBox(SynthContext context, Graphics g, int state,

  128.                          int shadowType, String info, int x, int y,

  129.                          int w, int h) {

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

  131.         Region region = context.getRegion();

  132.         // This should really happen after the shadow is drawn.

  133.          if (info == "menuitem" && state == SynthConstants.MOUSE_OVER &&

  134.                                    GTKLookAndFeel.is2_2()) {

  135.              paintBackground(context, g, state,

  136.                     style.getGTKColor(context.getComponent(), region,

  137.                   SynthConstants.SELECTED, GTKColorType.BACKGROUND), x, y, w,h);

  138.          }

  139.          else {

  140.              paintBackground(context, g, state,

  141.                 style.getGTKColor(context.getComponent(), region, state,

  142.                 GTKColorType.BACKGROUND), x, y, w, h);

  143.          }

  144.          paintShadow(context, g, state, shadowType, info, x, y, w, h);

  145.     }

  146. 

  147.     public void paintBoxGap(SynthContext context, Graphics g, int state,

  148.                             int shadowType, String info, int x, int y,

  149.                             int w, int h, int boxGapType, int tabBegin,

  150.                             int size) {

  151.         _paintBoxGap(context, g, state, shadowType, x, y, w, h, boxGapType,

  152.                      tabBegin, size, GTKColorType.BACKGROUND,

  153.                      GTKColorType.LIGHT, GTKColorType.BLACK,

  154.                      GTKColorType.DARK, false);

  155.     }

  156. 

  157.     void _paintBoxGap(SynthContext context, Graphics g, int state,

  158.                       int shadowType, int x, int y, int w, int h,

  159.                       int boxGapType, int tabBegin, int size,

  160.                       ColorType backgroundType, ColorType upperLeftType,

  161.                       ColorType bottomRightType, ColorType innerRightType,

  162.                       boolean paintWhite) {

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

  164.         JComponent c = context.getComponent();

  165.         Region region = context.getRegion();

  166. 

  167.         paintBackground(context, g, state, style.getGTKColor(c, region, state,

  168.                         backgroundType), x, y, w, h);

  169.         int tabEnd = tabBegin + size;

  170. 

  171.         Color upperLeft = style.getGTKColor(c, region, state, upperLeftType);

  172.         Color bottomRight = style.getGTKColor(c, region, state,

  173.                                               bottomRightType);

  174.         Color innerRight = style.getGTKColor(c, region, state, innerRightType);

  175.         Color white = style.getGTKColor(c, region, state, GTKColorType.WHITE);

  176. 

  177.         g.translate(x, y);

  178.         if (boxGapType == GTKConstants.TOP) {

  179.             // Paint bottom.

  180.             g.setColor(bottomRight);

  181.             g.drawLine(0, h - 1, w - 1, h - 1);

  182.             g.setColor(innerRight);

  183.             g.drawLine(1, h - 2, w - 2, h - 2);

  184. 

  185.             // Paint left side.

  186.             g.setColor(upperLeft);

  187.             g.drawLine(0, 0, 0, h - 2);

  188.             if (paintWhite) {

  189.                 g.setColor(white);

  190.                 g.drawLine(1, 0, 1, h - 3);

  191.             }

  192. 

  193.             // Paint right side.

  194.             g.setColor(bottomRight);

  195.             g.drawLine(w - 1, 0, w - 1, h - 1);

  196.             g.setColor(innerRight);

  197.             g.drawLine(w - 2, 0, w - 2, h - 2);

  198. 

  199.             // Paint top.

  200.             if (tabBegin > 0) {

  201.                 g.setColor(upperLeft);

  202.                 g.drawLine(0, 0, tabBegin, 0);

  203.             }

  204.             g.setColor(upperLeft);

  205.             g.drawLine(tabEnd, 0, w - 2, 0);

  206.             if (paintWhite) {

  207.                 g.setColor(white);

  208.                 if (tabBegin > 0) {

  209.                     g.drawLine(0, 1, tabBegin, 1);

  210.                 }

  211.                 g.drawLine(tabEnd, 1, w - 2, 1);

  212.             }

  213.         }

  214.         else if (boxGapType == GTKConstants.BOTTOM) {

  215.             // Paint top.

  216.             g.setColor(upperLeft);

  217.             g.drawLine(0, 0, w - 1, 0);

  218.             if (paintWhite) {

  219.                 g.setColor(white);

  220.                 g.drawLine(0, 1, w - 1, 1);

  221.             }

  222. 

  223.             // Paint left side.

  224.             g.setColor(upperLeft);

  225.             g.drawLine(0, 0, 0, h - 1);

  226.             if (paintWhite) {

  227.                 g.setColor(white);

  228.                 g.drawLine(1, 1, 1, h - 2);

  229.             }

  230. 

  231.             // Paint right side.

  232.             g.setColor(bottomRight);

  233.             g.drawLine(w - 1, 0, w - 1, h - 1);

  234.             g.setColor(innerRight);

  235.             g.drawLine(w - 2, 1, w - 2, h - 2);

  236. 

  237.             // Paint bottom.

  238.             if (tabBegin > 0) {

  239.                 g.setColor(bottomRight);

  240.                 g.drawLine(0, h - 1, tabBegin, h - 1);

  241.                 g.setColor(innerRight);

  242.                 g.drawLine(1, h - 2, tabBegin, h - 2);

  243.             }

  244.             g.setColor(bottomRight);

  245.             g.drawLine(tabEnd, h - 1, w - 1, h - 1);

  246.             g.setColor(innerRight);

  247.             g.drawLine(tabEnd, h - 2, w - 2, h - 2);

  248.         }

  249.         else if (boxGapType == GTKConstants.RIGHT) {

  250.             // Paint top.

  251.             g.setColor(upperLeft);

  252.             g.drawLine(0, 0, w - 1, 0);

  253.             if (paintWhite) {

  254.                 g.setColor(white);

  255.                 g.drawLine(0, 1, w - 1, 1);

  256.             }

  257. 

  258.             // Paint bottom.

  259.             g.setColor(bottomRight);

  260.             g.drawLine(0, h - 1, w - 1, h - 1);

  261.             g.setColor(innerRight);

  262.             g.drawLine(1, h - 2, w - 2, h - 2);

  263. 

  264.             // Paint left side.

  265.             g.setColor(upperLeft);

  266.             g.drawLine(0, 0, 0, h - 2);

  267.             if (paintWhite) {

  268.                 g.setColor(white);

  269.                 g.drawLine(1, 1, 1, h - 3);

  270.             }

  271. 

  272.             if (tabBegin > 0) {

  273.                 g.setColor(bottomRight);

  274.                 g.drawLine(w - 1, 0, w - 1, tabBegin);

  275.                 g.setColor(innerRight);

  276.                 g.drawLine(w - 2, 1, w - 2, tabBegin);

  277.             }

  278.             g.setColor(bottomRight);

  279.             g.drawLine(w - 1, tabEnd, w - 1, h - 1);

  280.             g.setColor(innerRight);

  281.             g.drawLine(w - 2, tabEnd, w - 2, h - 2);

  282.         }

  283.         else if (boxGapType == GTKConstants.LEFT) {

  284.             // Paint top.

  285.             g.setColor(upperLeft);

  286.             g.drawLine(0, 0, w - 2, 0);

  287.             if (paintWhite) {

  288.                 g.setColor(white);

  289.                 g.drawLine(0, 1, w - 2, 1);

  290.             }

  291. 

  292.             // Paint bottom.

  293.             g.setColor(bottomRight);

  294.             g.drawLine(0, h - 1, w - 1, h - 1);

  295.             g.setColor(innerRight);

  296.             g.drawLine(1, h - 2, w - 2, h - 2);

  297. 

  298.             // Paint right side.

  299.             g.setColor(bottomRight);

  300.             g.drawLine(w - 1, 1, w - 1, h - 1);

  301.             g.setColor(innerRight);

  302.             g.drawLine(w - 2, 0, w - 2, h - 2);

  303. 

  304.             // Paint left side.

  305.             if (tabBegin > 0) {

  306.                 g.setColor(upperLeft);

  307.                 g.drawLine(0, 0, 0, tabBegin);

  308.             }

  309.             g.setColor(upperLeft);

  310.             g.drawLine(0, tabEnd, 0, h - 2);

  311.             if (paintWhite) {

  312.                 g.setColor(white);

  313.                 if (tabBegin > 0) {

  314.                     g.drawLine(1, 0, 1, tabBegin);

  315.                 }

  316.                 g.drawLine(1, tabEnd, 1, h - 3);

  317.             }

  318.         }

  319.         g.translate(-x, -y);

  320.     }

  321. 

  322.     public void paintCheck(SynthContext context, Graphics g, int state,

  323.                            int shadowType, String info, int x, int y,

  324.                            int w, int h) {

  325.         int componentState = context.getComponentState();

  326.         JComponent component = context.getComponent();

  327.         Region r = context.getRegion();

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

  329. 

  330.         if ("checkbutton" == info) {

  331.             if ((componentState & SynthConstants.PRESSED) == 0) {

  332.                 paintBox(context, g, SynthConstants.ENABLED,

  333.                         GTKConstants.SHADOW_IN, info, x, y, w, h);

  334.                 g.setColor(style.getGTKColor(component, r, state,

  335.                         GTKColorType.WHITE));

  336.             } else {

  337.                 paintBox(context, g, SynthConstants.PRESSED,

  338.                         GTKConstants.SHADOW_IN, info, x, y, w, h);

  339.                 g.setColor(style.getGTKColor(component, r, state,

  340.                         GTKColorType.BACKGROUND));

  341.             }

  342.         }

  343. 

  344.         g.translate(x, y);

  345. 

  346.         int centerY = h / 2 - 1;

  347. 

  348.         if ("checkbutton" == info) {

  349.             g.fillRect(2, 2, w - 4, h - 4);

  350.         }

  351. 

  352.         // Paint check mark in center if selected.

  353.         if ((componentState & SynthConstants.SELECTED) != 0) {

  354.             g.setColor(

  355.                 style.getGTKColor(component, r, state, GTKColorType.FOREGROUND));

  356.             g.drawLine(3, centerY + 2, 4, centerY + 2);

  357.             g.drawLine(5, centerY + 3, 6, centerY + 3);

  358.             g.drawLine(6, centerY + 2, 6, centerY + 4);

  359.             g.drawLine(7, centerY + 1, 7, centerY);

  360.             g.drawLine(7, centerY, 8, centerY);

  361.             g.drawLine(8, centerY, 8, centerY - 1);

  362.             g.drawLine(8, centerY - 1, 9, centerY - 1);

  363.             g.drawLine(9, centerY - 1, 9, centerY - 2);

  364. 

  365.             if (!GTKLookAndFeel.is2_2()) {

  366.                 if ((componentState & SynthConstants.PRESSED) != 0) {

  367.                     g.setColor(style.getGTKColor(component, r,

  368.                     SynthConstants.PRESSED, GTKColorType.DARK));

  369.                 } else {

  370.                     g.setColor(style.getGTKColor(component, r,

  371.                     SynthConstants.ENABLED, GTKColorType.DARK));

  372.                 }

  373.             }

  374.             g.drawLine(3, centerY + 1, 4, centerY + 1);

  375.             g.drawLine(4, centerY + 3, 4, centerY + 3);

  376.             g.drawLine(5, centerY + 2, 5, centerY + 2);

  377.             g.drawLine(6, centerY + 1, 6, centerY + 1);

  378.             g.drawLine(7, centerY + 2, 7, centerY + 2);

  379.             g.drawLine(10, centerY - 2, 10, centerY - 2);

  380.         }

  381.         g.translate(-x, -y);

  382.     }

  383. 

  384.     public void paintExtension(SynthContext context, Graphics g, int state,

  385.                                int shadowType, String info, int x, int y,

  386.                                int w, int h, int placement) {

  387.         _paintExtension(context, g, state, shadowType, x, y, w, h, placement,

  388.                         GTKColorType.LIGHT, GTKColorType.BACKGROUND,

  389.                         GTKColorType.BLACK, GTKColorType.DARK, false);

  390.     }

  391. 

  392.     void _paintExtension(SynthContext context, Graphics g, int state,

  393.                     int shadowType, int x, int y,

  394.                     int w, int h, int placement, ColorType upperLeftType,

  395.                     ColorType backgroundType, ColorType bottomRightType,

  396.                     ColorType innerRightType, boolean paintWhite) {

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

  398.         TabContext tabContext = (TabContext)context;

  399.         JComponent c = context.getComponent();

  400.         Region region = context.getRegion();

  401.         int xThickness = style.getXThickness();

  402.         int yThickness = style.getYThickness();

  403. 

  404.         if (xThickness < 0 && yThickness < 0) {

  405.             // nothing to paint.

  406.             return;

  407.         }

  408. 

  409.         Color upperLeft =

  410.             style.getGTKColor(c, region, state, upperLeftType);

  411.         Color background =

  412.             style.getGTKColor(c, region, state, backgroundType);

  413.         Color bottomRight =

  414.             style.getGTKColor(c, region, state, bottomRightType);

  415.         Color innerRight =

  416.             style.getGTKColor(c, region, state, innerRightType);

  417.         Color white = style.getGTKColor(c, region, state, GTKColorType.WHITE);

  418. 

  419.         int tabIndex = tabContext.getTabIndex();

  420.         int selectedIndex = ((JTabbedPane)c).getSelectedIndex();

  421. 

  422.         g.translate(x, y);

  423. 

  424.         // NOTE: placement refers to the size of the extension, so that

  425.         // BOTTOM corresponds to a TabbedPane with the tabs placed at the top.

  426.         if (placement == GTKConstants.BOTTOM) {

  427.             // Fill the background.

  428.             paintBackground(context, g, state, background, 0, 1, w, h);

  429. 

  430.             if (tabIndex == selectedIndex || tabIndex == 0) {

  431.                 g.setColor(upperLeft);

  432.                 g.drawLine(0, 1, 0, h - 1);

  433.                 g.drawLine(1, 0, w - 2, 0);

  434.                 if (paintWhite) {

  435.                     g.setColor(white);

  436.                     g.drawLine(1, 1, 1, h - 1);

  437.                     g.drawLine(1, 1, w - 3, 1);

  438.                 }

  439.             } else {

  440.                 g.setColor(upperLeft);

  441.                 g.drawLine(0, 0, w - 2, 0);

  442.                 if (paintWhite) {

  443.                     g.setColor(white);

  444.                     g.drawLine(0, 1, w - 3, 1);

  445.                 }

  446.             }

  447.             if ((tabIndex + 1) != selectedIndex) {

  448.                 g.setColor(innerRight);

  449.                 g.drawLine(w - 2, 2, w - 2, h - 1);

  450.                 g.setColor(bottomRight);

  451.                 g.drawLine(w - 1, 1, w - 1, h - 1);

  452.             }

  453. 

  454.         } else if (placement == GTKConstants.TOP) {

  455.             // Fill the background.

  456.             paintBackground(context, g, state, background, 0, 0, w, h - 1);

  457. 

  458.             if (tabIndex == selectedIndex || tabIndex == 0) {

  459.                 g.setColor(upperLeft);

  460.                 g.drawLine(0, 0, 0, h - 2);

  461.                 g.setColor(bottomRight);

  462.                 g.drawLine(1, h - 1, w - 2, h - 1);

  463.                 g.setColor(innerRight);

  464.                 g.drawLine(2, h - 2, w - 2, h - 2);

  465.                 if (paintWhite) {

  466.                     g.setColor(white);

  467.                     g.drawLine(1, 0, 1, h - 2);

  468.                 }

  469.             } else {

  470.                 g.setColor(bottomRight);

  471.                 g.drawLine(0, h - 1, w - 2, h - 1);

  472.                 g.setColor(innerRight);

  473.                 g.drawLine(0, h - 2, w - 2, h - 2);

  474.                 if (paintWhite) {

  475.                     g.setColor(white);

  476.                     g.drawLine(0, 0, 0, h - 2);

  477.                 }

  478.             }

  479.             if ((tabIndex + 1) != selectedIndex) {

  480.                 g.setColor(bottomRight);

  481.                 g.drawLine(w - 1, 0, w - 1, h - 2);

  482.                 g.setColor(innerRight);

  483.                 g.drawLine(w - 2, 0, w - 2, h - 2);

  484.             }

  485.         } else if (placement == GTKConstants.RIGHT) {

  486.             // Fill the background.

  487.             paintBackground(context, g, state, background, 1, 0, w, h);

  488. 

  489.             if (tabIndex == selectedIndex || tabIndex == 0) {

  490.                 g.setColor(upperLeft);

  491.                 g.drawLine(1, 0, w - 1, 0);

  492.                 g.drawLine(0, 1, 0, h - 2);

  493.                 if (paintWhite) {

  494.                     g.setColor(white);

  495.                     g.drawLine(1, 1, w, 1);

  496.                     g.drawLine(1, 1, 1, h - 3);

  497.                 }

  498.             } else {

  499.                 g.setColor(upperLeft);

  500.                 g.drawLine(0, 0, 0, h - 2);

  501.                 if (paintWhite) {

  502.                     g.setColor(white);

  503.                     g.drawLine(1, 1, 1, h - 3);

  504.                 }

  505.             }

  506.             if ((tabIndex + 1) != selectedIndex) {

  507.                 g.setColor(bottomRight);

  508.                 g.drawLine(1, h - 1, w - 1, h - 1);

  509.                 g.setColor(innerRight);

  510.                 g.drawLine(2, h - 2, w - 1, h - 2);

  511.             }

  512.         } else if (placement == GTKConstants.LEFT) {

  513.             // Fill the background.

  514.             paintBackground(context, g, state, background, 0, 0, w - 1, h);

  515. 

  516.             if (tabIndex == selectedIndex || tabIndex == 0) {

  517.                 g.setColor(upperLeft);

  518.                 g.drawLine(0, 0, w - 2, 0);

  519.                 g.setColor(bottomRight);

  520.                 g.drawLine(w - 1, 1, w - 1, h - 2);

  521.                 g.setColor(innerRight);

  522.                 g.drawLine(w - 2, 2, w - 2, h - 2);

  523.                 if (paintWhite) {

  524.                     g.setColor(white);

  525.                     g.drawLine(0, 1, w - 2, 1);

  526.                     g.drawLine(w - 2, 1, w - 2, h - 3);

  527.                 }

  528.             } else {

  529.                 g.setColor(bottomRight);

  530.                 g.drawLine(w - 1, 0, w - 1, h - 2);

  531.                 g.setColor(innerRight);

  532.                 g.drawLine(w - 2, 0, w - 2, h - 2);

  533.                 if (paintWhite) {

  534.                     g.setColor(white);

  535.                     g.drawLine(w - 2, 1, w - 2, h - 3);

  536.                 }

  537.             }

  538.             if ((tabIndex + 1) != selectedIndex) {

  539.                 g.setColor(bottomRight);

  540.                 g.drawLine(0, h - 1, w - 2, h - 1);

  541.                 g.setColor(innerRight);

  542.                 g.drawLine(0, h - 2, w - 2, h - 2);

  543. 

  544.             }

  545.         }

  546.         g.translate(-x, -y);

  547.     }

  548. 

  549.     void paintFlatBoxNormal(SynthContext context, Graphics g, int state,

  550.                              String key, int x, int y, int w, int h) {

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

  552.                 context.getComponent(), context.getRegion(), state,

  553.                 GTKColorType.BACKGROUND));

  554.         paintFlatBox(context, g, state, key, x, y, w, h);

  555.     }

  556. 

  557.     void paintFlatBoxText(SynthContext context, Graphics g, int state,

  558.                              String key, int x, int y, int w, int h) {

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

  560.                 context.getComponent(), context.getRegion(), state,

  561.                 GTKColorType.TEXT_BACKGROUND));

  562.         paintFlatBox(context, g, state, key, x, y, w, h);

  563.     }

  564. 

  565.     // NOTE: this assumes you have set the right color before calling this

  566.     public void paintFlatBox(SynthContext context, Graphics g, int state,

  567.                              String key, int x, int y, int w, int h) {

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

  569. 

  570.         if (key == "cell_odd") {

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

  572.         }

  573.         else {

  574.             paintBackground(context, g, state, g.getColor(), x, y, w, h);

  575.         }

  576. 

  577.         if (key == "tooltip") {

  578.             g.setColor(Color.BLACK);

  579.             g.drawRect(x, y, w - 1, h - 1);

  580.         }

  581.     }

  582. 

  583.     public void paintFocus(SynthContext context, Graphics g, int state,

  584.                            String key, int x, int y, int w, int h) {

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

  586.         int[] pattern = (int[])style.getClassSpecificValue(

  587.                                      context, "focus-line-pattern");

  588.         int size = style.getClassSpecificIntValue(context,

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

  590. 

  591.         if (pattern == null) {

  592.             pattern = DEFAULT_FOCUS_PATTERN;

  593.         }

  594.         if (size <= 0) {

  595.             return;

  596.         }

  597.         g.setColor(getFocusColor(context, state));

  598. 

  599.         _paintFocus(g, x, y, w, h, pattern, size);

  600.     }

  601. 

  602.     void _paintFocus(Graphics g, int x, int y, int w, int h, int[] pattern,

  603.                      int size) {

  604.         g.translate(x, y);

  605. 

  606.         // PENDING: This will need to be optimized

  607.         int initial = size / 2;

  608.         int offset = initial;

  609.         int index = 0;

  610. 

  611.         int max1 = w - size;

  612.         int max2 = max1 + h - size;

  613.         int max3 = max2 + w - size;

  614.         int max4 = max3 + h;

  615. 

  616.         while (offset < max4) {

  617.             int next = offset + pattern[index];

  618. 

  619.             if (index % 2 == 0) {

  620.                 if (offset < max1) {

  621.                     // top

  622.                     g.fillRect(offset, 0, Math.min(next, w) - offset, size);

  623.                     offset = Math.min(next, max1);

  624.                 }

  625.                 if (offset != next && offset < max2) {

  626.                     // right

  627.                     g.fillRect(w - size, offset - max1, size,

  628.                                Math.min(max2, next) - offset);

  629.                     offset = Math.min(max2, next);

  630.                 }

  631.                 if (offset != next && offset < max3) {

  632.                     // bottom

  633.                     int x2 = w - (offset - max2);

  634.                     int temp = Math.min(next - offset, max3 - offset);

  635.                     g.fillRect(x2 - temp, h - size, temp, size);

  636.                     offset += temp;

  637.                 }

  638.                 if (offset != next) {

  639.                     int y2 = h - (offset - max3);

  640.                     int temp = Math.min(next - offset, max4 - offset);

  641.                     g.fillRect(0, y2 - temp, size, temp);

  642.                     offset += temp;

  643.                 }

  644.             }

  645.             else {

  646.                 offset = next;

  647.             }

  648.             index = (index + 1) % pattern.length;

  649.         }

  650. 

  651.         g.translate(-x, -y);

  652.     }

  653. 

  654.     Color getFocusColor(SynthContext context, int state) {

  655.         return ((GTKStyle)context.getStyle()).getGTKColor(

  656.                context.getComponent(), context.getRegion(), state,

  657.                ColorType.FOREGROUND);

  658.     }

  659. 

  660.     public void paintHandle(SynthContext context, Graphics g, int paintState,

  661.                             int shadowType, String info, int x, int y,

  662.                             int w, int h, int orientation) {

  663.         paintBox(context, g, paintState, shadowType, info, x, y, w, h);

  664. 

  665.         g.translate(x, y);

  666. 

  667.         Region region = context.getRegion();

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

  669.         JComponent component = context.getComponent();

  670.         Color lightColor = style.getGTKColor(component, region, paintState,

  671.                                           GTKColorType.LIGHT);

  672.         Color darkColor = style.getGTKColor(component, region, paintState,

  673.                                           GTKColorType.DARK);

  674.         Color blackColor = style.getGTKColor(component, region, paintState,

  675.                                           GTKColorType.BLACK);

  676.         int startX;

  677.         int startY;

  678.         if (info == "paned") {

  679.             JSplitPane splitPane = (JSplitPane)component;

  680. 

  681.             int markerLength = 7 * 3 + 6 * 2;  // 7 markers width of 3

  682.                                                // + 6 spacers width of 2.

  683.             if (orientation == GTKConstants.HORIZONTAL) {

  684.                 // Components are above/below.

  685.                 startX = w / 2 - markerLength / 2;

  686.                 startY = splitPane.getDividerSize() / 2 - 1;

  687.             } else {

  688.                 // Components are left/right

  689.                 startX = splitPane.getDividerSize() / 2 - 1;

  690.                 startY = h / 2 - markerLength / 2;

  691.             }

  692. 

  693.             for (int i = 0; i < 7; i++) {

  694.                 // Add length of one marker and spacing.

  695.                 if (orientation == GTKConstants.HORIZONTAL) {

  696.                     startX += 5;

  697.                 } else {

  698.                     startY += 5;

  699.                 }

  700.                 g.setColor(lightColor);

  701.                 g.fillRect(startX, startY, 2, 2);

  702.                 g.setColor(blackColor);

  703.                 g.fillRect(startX + 1, startY + 1, 2, 2);

  704.                 g.setColor(darkColor);

  705.                 g.fillRect(startX + 1, startY + 1, 1, 1);

  706.             }

  707.         } else if (info == "handlebox") {

  708.             JToolBar tb = (JToolBar)component;

  709.             startX = 2;

  710.             startY = 2;

  711.             if (tb.getOrientation() == JToolBar.HORIZONTAL) {

  712.                 while (startY < h) {

  713.                     g.setColor(darkColor);

  714.                     g.fillRect(startX + 1, startY + 1, 2, 2);

  715.                     g.fillRect(startX + 4, startY + 2, 2, 2);

  716.                     g.setColor(lightColor);

  717.                     g.fillRect(startX, startY, 2, 2);

  718.                     g.fillRect(startX + 3, startY + 1, 2, 2);

  719.                     startY += 3;

  720.                 }

  721.             } else {

  722.                 boolean toggle = true;

  723.                 while (startX < w) {

  724.                     g.setColor(darkColor);

  725.                     g.fillRect(startX + 1, startY + 1, 2, 2);

  726.                     g.fillRect(startX + 1, startY + 4, 2, 2);

  727.                     g.setColor(lightColor);

  728.                     g.fillRect(startX, startY, 2, 2);

  729.                     g.fillRect(startX, startY + 3, 2, 2);

  730.                     startX += 3;

  731.                     if (toggle) {

  732.                         startY++;

  733.                         toggle = false;

  734.                     } else {

  735.                         startY--;

  736.                         toggle = true;

  737.                     }

  738.                 }

  739.             }

  740.             // Fix up the shadow.

  741.             paintShadow(context, g, paintState, shadowType, info, 0, 0, w, h);

  742.         }

  743.         g.translate(-x, -y);

  744.     }

  745. 

  746.     public void paintOption(SynthContext context, Graphics g, int paintState,

  747.                             int shadowType, String info, int x, int y,

  748.                             int w, int h) {

  749.         g.translate(x, y);

  750. 

  751.         int componentState = context.getComponentState();

  752.         int centerY = h / 2 - 1;

  753.         JComponent component = context.getComponent();

  754.         Region region = context.getRegion();

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

  756. 

  757.         // If the radio button is being pressed we fill the center with the

  758.         // MID gtk color, otherwise we fill it WHITE.  We need to use the state

  759.         // from the context since the state passed in may have been modified.

  760.         if ((componentState & SynthConstants.PRESSED) == 0) {

  761.             g.setColor(style.getGTKColor(component, region, paintState,

  762.                                          GTKColorType.WHITE));

  763.         } else {

  764.             g.setColor(style.getGTKColor(component, region, paintState,

  765.                                          GTKColorType.MID));

  766.         }

  767. 

  768.         if (region != Region.RADIO_BUTTON_MENU_ITEM) {

  769.             // Paint center portion.

  770.             g.fillOval(1, 0 , 11, 11);

  771.             g.drawLine(13, centerY - 1, 13, centerY + 2);

  772.             g.drawLine(12, centerY + 3, 12, centerY + 4);

  773.             g.drawLine(11, centerY + 5, 11, centerY + 5);

  774.             g.drawLine(9, centerY + 6, 10, centerY + 6);

  775.             g.drawLine(5, centerY + 7, 8, centerY + 7);

  776. 

  777.             // Paint dark shadow.

  778.             g.setColor(style.getGTKColor(component, region, paintState,

  779.                                          GTKColorType.DARK));

  780.             g.drawOval(1, 0, 11, 11);

  781. 

  782.             // Paint black shadow.

  783.             g.setColor(style.getGTKColor(component, region, paintState,

  784.                                          GTKColorType.BLACK));

  785.             g.drawLine(5, centerY - 4, 8, centerY - 4);

  786.             g.drawLine(9, centerY - 4, 10, centerY - 3);

  787.             g.drawLine(3, centerY - 3, 4, centerY - 3);

  788.             g.drawLine(3, centerY - 2, 2, centerY - 1);

  789.             g.drawLine(2, centerY, 2, centerY + 2);

  790.             g.drawLine(2, centerY + 3, 3, centerY + 4);

  791.         }

  792. 

  793.         // Fill in center if selected.

  794.         if ((componentState & SynthConstants.SELECTED) != 0) {

  795.             if (region == Region.RADIO_BUTTON_MENU_ITEM) {

  796.                 g.setColor(style.getGTKColor(component, region, paintState,

  797.                                              GTKColorType.FOREGROUND));

  798.             }

  799.             g.fillRect(5, centerY, 5, 3);

  800.             g.drawLine(6, centerY - 1, 8, centerY - 1);

  801.             g.drawLine(6, centerY + 3, 8, centerY + 3);

  802.         }

  803.         g.translate(-x, -y);

  804.     }

  805. 

  806.     public void paintShadow(SynthContext context, Graphics g, int state,

  807.                             int shadowType, String info, int x, int y,

  808.                             int w, int h) {

  809.         if (info == "buttondefault") {

  810.             // YES, this appears to be special cased.

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

  812.                            context.getComponent(), context.getRegion(),

  813.                            state, GTKColorType.BLACK));

  814.             g.drawRect(x, y, w - 1, h - 1);

  815.             return;

  816.         }

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

  818.         JComponent c = context.getComponent();

  819.         Region region = context.getRegion();

  820.         int xThickness = style.getXThickness();

  821.         int yThickness = style.getYThickness();

  822. 

  823.         if (info == "trough" ||

  824.                 (info == "spinbutton" && c instanceof JButton)) {

  825.             // YES, this appears to be special cased.

  826.             xThickness = yThickness = 1;

  827.         }

  828. 

  829.         if (xThickness < 0 && yThickness < 0) {

  830.             // nothing to paint.

  831.             return;

  832.         }

  833.         Color upperLeft = null, innerLeft = null, bottomRight = null,

  834.               innerRight = null;

  835.         switch (shadowType) {

  836.         case GTKConstants.SHADOW_IN:

  837.             if (info == "spinbutton" && c instanceof JButton) {

  838.                 upperLeft = style.getGTKColor(c, region, state,

  839.                         GTKColorType.DARK);

  840.                 innerRight = upperLeft;

  841.                 bottomRight = style.getGTKColor(c, region, state,

  842.                         GTKColorType.BLACK);

  843.             } else {

  844.                 upperLeft = style.getGTKColor(c, region, state,

  845.                         GTKColorType.DARK);

  846.                 innerLeft = style.getGTKColor(c, region, state,

  847.                         GTKColorType.BLACK);

  848.                 bottomRight = style.getGTKColor(c, region, state,

  849.                         GTKColorType.LIGHT);

  850.                 innerRight = style.getGTKColor(c, region, state,

  851.                         GTKColorType.BACKGROUND);

  852.             }

  853.             break;

  854.         case GTKConstants.SHADOW_OUT:

  855.             upperLeft = style.getGTKColor(c, region, state,GTKColorType.LIGHT);

  856.             innerLeft = style.getGTKColor(c, region, state,

  857.                                           GTKColorType.BACKGROUND);

  858.             bottomRight = style.getGTKColor(c, region, state,

  859.                                             GTKColorType.BLACK);

  860.             innerRight = style.getGTKColor(c, region, state,GTKColorType.DARK);

  861.             break;

  862.         default:

  863.             assert true : "Unknown shadow type!";

  864.         }

  865.         if (info == "spinbutton" && c instanceof JButton) {

  866.             _paintSpinButtonShadow(g, x, y, w, h, xThickness, yThickness,

  867.                     upperLeft, innerLeft, bottomRight, innerRight);

  868.         } else {

  869.             _paintShadow(g,  x, y, w, h, xThickness, yThickness,

  870.                     upperLeft, innerLeft, bottomRight, innerRight);

  871.         }

  872.     }

  873. 

  874.     void _paintShadow(Graphics g, int x, int y, int w, int h,

  875.                  int xThickness, int yThickness, Color upperLeft,

  876.                  Color innerLeft, Color bottomRight, Color innerRight) {

  877.         g.translate(x, y);

  878.         // left/top

  879.         g.setColor(upperLeft);

  880.         if (xThickness > 0) {

  881.             g.drawLine(0, 0, 0, h - 1);

  882.         }

  883.         if (yThickness > 0) {

  884.             g.drawLine(1, 0, w - 1, 0);

  885.         }

  886. 

  887.         // Inner left/top

  888.         if (xThickness > 1 || yThickness > 1) {

  889.             g.setColor(innerLeft);

  890.             if (xThickness > 1) {

  891.                 g.drawLine(1, 1, 1, h - 2);

  892.             }

  893.             if (yThickness > 1) {

  894.                 g.drawLine(2, 1, w - 2, 1);

  895.             }

  896.         }

  897. 

  898.         // Bottom/right

  899.         g.setColor(bottomRight);

  900.         if (xThickness > 0) {

  901.             g.drawLine(w - 1, 1, w - 1, h - 1);

  902.         }

  903.         if (yThickness > 0) {

  904.             g.drawLine(1, h - 1, w - 2, h - 1);

  905.         }

  906.         // Inner bottom/right

  907.         if (xThickness > 1 || yThickness > 1) {

  908.             g.setColor(innerRight);

  909.             if (xThickness > 1) {

  910.                 g.drawLine(w - 2, 2, w - 2, h - 2);

  911.             }

  912.             if (yThickness > 1) {

  913.                 g.drawLine(2, h - 2, w - 3, h - 2);

  914.             }

  915.         }

  916.         g.translate(-x, -y);

  917.     }

  918. 

  919.     void _paintSpinButtonShadow(Graphics g, int x, int y,

  920.                  int w, int h, int xThickness, int yThickness, Color upperLeft,

  921.                  Color innerLeft, Color bottomRight, Color innerRight) {

  922.         g.translate(x, y);

  923. 

  924.         // top

  925.         g.setColor(upperLeft);

  926.         g.drawLine(0, 0, w - 1, 0);

  927.         // bottom

  928.         g.setColor(innerRight);

  929.         g.drawLine(0, h - 1, w - 1, h - 1);

  930.         // left/right

  931.         g.setColor(bottomRight);

  932.         g.drawLine(0, 0, 0, h - 1);

  933.         g.drawLine(w - 1, 0, w - 1, h - 1);

  934. 

  935.         g.translate(-x, -y);

  936.     }

  937. 

  938.     public void paintExpander(SynthContext context, Graphics g, int state,

  939.                               int expanderStyle, String info, int x,

  940.                               int y, int w, int h) {

  941.         if (expanderStyle == GTKConstants.EXPANDER_COLLAPSED) {

  942.             if (state != SynthConstants.MOUSE_OVER) {

  943.                 paintHollowTriangle(context, g, state,

  944.                     x, y, Math.min(w,h),

  945.                     adjustAxisForComponentOrientation(

  946.                     context.getComponent(), SwingConstants.EAST));

  947.             } else {

  948.             }

  949.         }

  950.         else {

  951.             if (state != SynthConstants.MOUSE_OVER) {

  952.                 paintHollowTriangle(context, g, state,

  953.                     x, y, Math.min(w,h), SwingConstants.SOUTH);

  954.             } else {

  955.             }

  956.         }

  957.     }

  958. 

  959.     private void paintHollowTriangle(SynthContext ss, Graphics g, int state,

  960.                                      int x, int y, int size, int direction) {

  961.         GTKStyle style = (GTKStyle)ss.getStyle();

  962.         int mid, height, thick, i, j, up, down;

  963. 

  964.         mid = (size / 2);

  965.         height = size / 2 + 1;

  966.         thick = Math.max(1, size / 7);

  967. 

  968.         g.translate(x, y);

  969. 

  970.         Color foreground = style.getGTKColor(ss.getComponent(), ss.getRegion(),

  971.                 state, GTKColorType.FOREGROUND);

  972.         Color background = style.getGTKColor(ss.getComponent(), ss.getRegion(),

  973.                 state, GTKColorType.BACKGROUND);

  974. 

  975.         switch(direction) {

  976.         case SwingConstants.NORTH:

  977.             j = size / 2 + height / 2 - 1;

  978.             // Fill in the background of the expander icon.

  979.             g.setColor(background);

  980.             for(i = height - 1; i > 0; i--) {

  981.                 g.drawLine(mid - i + 1, j, mid + i - 1, j);

  982.                 j--;

  983.             }

  984. 

  985.             g.setColor(foreground);

  986.             j = size / 2 + height / 2 - 1;

  987.             down = thick - 1;

  988.             // Draw the base of the triangle.

  989.             for (up = 0; up < thick; up++) {

  990.                 g.drawLine(0 - down, j - up, size + down, j - up);

  991.                 down--;

  992.             }

  993.             j--;

  994. 

  995.             // Paint sides of triangle.

  996.             for(i = height - 1; i > 0; i--) {

  997.                 for (up = 0; up < thick; up++ ) {

  998.                     g.drawLine(mid - i + 1 - up, j, mid - i + 1 - up, j);

  999.                     g.drawLine(mid + i - 1 + up, j, mid + i - 1 + up, j);

  1000.                 }

  1001.                 j--;

  1002.             }

  1003. 

  1004.             // Paint remainder of tip if necessary.

  1005.             if (thick > 1) {

  1006.                 for (up = thick - 2; up >= 0; up--) {

  1007.                     g.drawLine(mid - up, j, mid + up, j);

  1008.                     j--;

  1009.                 }

  1010.             }

  1011.             break;

  1012.         case SwingConstants.SOUTH:

  1013.             j = size / 2 - height / 2 - 1;

  1014.             // Fill in the background of the expander icon.

  1015.             g.setColor(background);

  1016.             for (i = height - 1; i > 0; i--) {

  1017.                 g.drawLine(mid - i + 1, j, mid + i - 1, j);

  1018.                 j++;

  1019.             }

  1020. 

  1021.             g.setColor(foreground);

  1022.             j = size / 2 - height / 2 - 1;

  1023.             down = thick - 1;

  1024.             // Draw the base of the triangle.

  1025.             for (up = 0; up < thick; up++) {

  1026.                 g.drawLine(0 - down, j + up, size + down, j + up);

  1027.                 down--;

  1028.             }

  1029.             j++;

  1030. 

  1031.             // Paint sides of triangle.

  1032.             for (i = height - 1; i > 0; i--) {

  1033.                 for (up = 0; up < thick; up++ ) {

  1034.                     g.drawLine(mid - i + 1 - up, j, mid - i + 1 - up, j);

  1035.                     g.drawLine(mid + i - 1 + up, j, mid + i - 1 + up, j);

  1036.                 }

  1037.                 j++;

  1038.             }

  1039. 

  1040.             // Paint remainder of tip if necessary.

  1041.             if (thick > 1) {

  1042.                 for (up = thick - 2; up >= 0; up--) {

  1043.                     g.drawLine(mid - up, j, mid + up, j);

  1044.                     j++;

  1045.                 }

  1046.             }

  1047.             break;

  1048.         case SwingConstants.WEST:

  1049.             i = size / 2 + height / 2 - 1;

  1050.             // Fill in the background of the expander icon.

  1051.             g.setColor(background);

  1052.             for (j = height - 1; j > 0; j--) {

  1053.                 g.drawLine(i, mid - j + 1, i, mid + j - 1);

  1054.                 i--;

  1055.             }

  1056. 

  1057.             g.setColor(foreground);

  1058.             i = size / 2 + height / 2 - 1;

  1059.             down = thick - 1;

  1060.             // Draw the base of the triangle.

  1061.             for (up = 0; up < thick; up++) {

  1062.                 g.drawLine(i - up, 0 - down, i - up, size + down);

  1063.                 down--;

  1064.             }

  1065.             i--;

  1066. 

  1067.             // Paint sides of triangle.

  1068.             for (j = height - 1; j > 0; j--) {

  1069.                 for (up = 0; up < thick; up++) {

  1070.                     g.drawLine(i, mid - j + 1 - up, i, mid - j + 1 - up);

  1071.                     g.drawLine(i, mid + j - 1 + up, i, mid + j - 1 + up);

  1072.                 }

  1073.                 i--;

  1074.             }

  1075. 

  1076.             // Paint remainder of tip if necessary.

  1077.             if (thick > 1) {

  1078.                 for (up = thick - 2; up >= 0; up--) {

  1079.                     g.drawLine(i, mid - up, i, mid + up);

  1080.                     i--;

  1081.                 }

  1082.             }

  1083.             break;

  1084.         case SwingConstants.EAST:

  1085.             i = size / 2 - height / 2 - 1;

  1086. 

  1087.             // Fill in the background of the expander icon.

  1088.             g.setColor(background);

  1089.             for (j = height - 1; j > 0; j--) {

  1090.                 g.drawLine(i, mid - j + 1, i, mid + j - 1);

  1091.                 i++;

  1092.             }

  1093. 

  1094.             g.setColor(foreground);

  1095.             i = size / 2 - height / 2 - 1;

  1096.             down = thick - 1;

  1097.             // Draw the base of the triangle.

  1098.             for (up = 0; up < thick; up++) {

  1099.                 g.drawLine(i + up, 0 - down, i + up, size + down);

  1100.                 down--;

  1101.             }

  1102.             i++;

  1103. 

  1104.             // Paint sides of triangle.

  1105.             for (j = height - 1; j > 0; j--) {

  1106.                 for (up = 0; up < thick; up++) {

  1107.                     g.drawLine(i, mid - j + 1 - up, i, mid - j + 1 - up);

  1108.                     g.drawLine(i, mid + j - 1 + up, i, mid + j - 1 + up);

  1109.                 }

  1110.                 i++;

  1111.             }

  1112. 

  1113.             // Paint remainder of tip if necessary.

  1114.             if (thick > 1) {

  1115.                 for (up = thick - 2; up >= 0; up--) {

  1116.                     g.drawLine(i, mid - up, i, mid + up);

  1117.                     i++;

  1118.                 }

  1119.             }

  1120.             break;

  1121.         }

  1122.         g.translate(-x, -y);

  1123.     }

  1124. 

  1125.     public void paintSlider(SynthContext context, Graphics g, int state,

  1126.                            int shadowType, String info,

  1127.                            int x, int y, int w, int h, int orientation) {

  1128.         paintBox(context, g, state, shadowType, info, x, y, w, h);

  1129.         if (context.getRegion() == Region.SLIDER_THUMB) {

  1130.             if (orientation == GTKConstants.HORIZONTAL) {

  1131.                 paintVline(context, g, state, info, x + w / 2 - 1, y + 2, 2,

  1132.                            h - 4);

  1133.             } else {

  1134.                 paintHline(context, g, state, info, x + 2, y + h / 2 - 1,

  1135.                            w - 4, 2);

  1136.             }

  1137.         }

  1138.     }

  1139. 

  1140.     public void paintHline(SynthContext context, Graphics g, int state,

  1141.                            String info, int x, int y, int w, int h) {

  1142.         g.translate(x, y);

  1143. 

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

  1145.         int centerY = h / 2;

  1146.         if (h == 2) {

  1147.             centerY = 0;

  1148.         }

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

  1150.                                      context.getRegion(), state,

  1151.                                      GTKColorType.DARK));

  1152.         g.drawLine(0, centerY, w - 2, centerY);

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

  1154.                                      context.getRegion(), state,

  1155.                                      GTKColorType.LIGHT));

  1156.         g.drawLine(0, centerY + 1, w - 1, centerY + 1);

  1157.         g.drawLine(w - 1, centerY, w - 1, centerY + 1);

  1158. 

  1159.         g.translate(-x, -y);

  1160.     }

  1161.     public void paintVline(SynthContext context, Graphics g, int state,

  1162.                            String info, int x, int y, int w, int h) {

  1163.         g.translate(x, y);

  1164. 

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

  1166.         int centerX = w / 2;

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

  1168.                                      context.getRegion(),

  1169.                                      state, GTKColorType.DARK));

  1170.         g.drawLine(centerX, 0, centerX, h - 2);

  1171.         g.drawLine(centerX, 0, centerX + 1, 0);

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

  1173.                                      context.getRegion(),

  1174.                                      state, GTKColorType.LIGHT));

  1175.         g.drawLine(centerX + 1, 1, centerX + 1, h - 1);

  1176.         g.drawLine(centerX, h - 1, centerX + 1, h - 1);

  1177. 

  1178.         g.translate(-x, -y);

  1179.     }

  1180. 

  1181. 

  1182.     /**

  1183.      * If necessary paints the background.

  1184.      */

  1185.     void paintBackground(SynthContext context, Graphics g, int state,

  1186.                                  Color color, int x, int y, int w, int h) {

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

  1188. 

  1189.         if (style.fillBackground(context, state)) {

  1190.             g.setColor(color);

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

  1192.         }

  1193.         else {

  1194.             Image image = style.getBackgroundImage(context, state);

  1195.             int iW;

  1196.             int iH;

  1197. 

  1198.             if (image != null && (iW = image.getWidth(null)) > 0 &&

  1199.                                  (iH = image.getHeight(null)) > 0) {

  1200.                 // Map the x/y location to originate from the origin of the

  1201.                 // window

  1202.                 int x2 = x;

  1203.                 int y2 = y;

  1204.                 Component parent = context.getComponent().getParent();

  1205. 

  1206.                 while (parent != null && !(parent instanceof Window) &&

  1207.                        !(parent instanceof java.applet.Applet)) {

  1208.                     Component nextParent = parent.getParent();

  1209. 

  1210.                     if (parent instanceof JRootPane &&

  1211.                                !(nextParent instanceof Window) &&

  1212.                                !(nextParent instanceof java.applet.Applet)) {

  1213.                         x2 += parent.getX();

  1214.                         y2 += parent.getY();

  1215.                     }

  1216.                     parent = nextParent;

  1217.                 }

  1218.                 x2 = x2 % iW;

  1219.                 y2 = y2 % iH;

  1220. 

  1221.                 Rectangle clip = g.getClipRect();

  1222.                 int cx1 = clip.x;

  1223.                 int cy1 = clip.y;

  1224.                 int cx2 = cx1 + clip.width;

  1225.                 int cy2 = cy1 + clip.height;

  1226. 

  1227.                 int lastIY = y2;

  1228.                 for (int yCounter = y, maxY = y + h; yCounter < maxY;

  1229.                          yCounter += (iH - lastIY), lastIY = 0) {

  1230.                     int lastIX = x2;

  1231.                     for (int xCounter = x, maxX = x + w; xCounter < maxX;

  1232.                              xCounter += (iW - lastIX), lastIX = 0) {

  1233.                         int dx2 = Math.min(maxX, xCounter + iW - lastIX);

  1234.                         int dy2 = Math.min(maxY, yCounter + iH - lastIY);

  1235.                         if (dx2 > cx1 && dy2 > cy1 && cx2 > xCounter &&

  1236.                                          cy2 > yCounter) {

  1237.                             g.drawImage(image, xCounter, yCounter, dx2, dy2,

  1238.                                     lastIX, lastIY, lastIX + dx2 - xCounter,

  1239.                                     lastIY + dy2 - yCounter, null);

  1240.                         }

  1241.                     }

  1242.                 }

  1243.             }

  1244.         }

  1245.     }

  1246. }