1. /*

  2.  * @(#)GTKLookAndFeel.java	1.71 04/07/16

  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 com.sun.java.swing.SwingUtilities2;

  10. import java.lang.ref.*;

  11. import javax.swing.plaf.synth.*;

  12. import java.awt.*;

  13. import java.awt.event.*;

  14. import java.beans.*;

  15. import java.io.File;

  16. import java.lang.reflect.*;

  17. import java.security.AccessController;

  18. import java.security.PrivilegedAction;

  19. import java.util.HashMap;

  20. import java.util.Locale;

  21. import javax.swing.*;

  22. import javax.swing.colorchooser.*;

  23. import javax.swing.plaf.*;

  24. import javax.swing.text.DefaultEditorKit;

  25. import java.io.IOException;

  26. 

  27. import sun.security.action.GetPropertyAction;

  28. 

  29. /**

  30.  * @version 1.71, 07/16/04

  31.  * @author Scott Violet

  32.  */

  33. public class GTKLookAndFeel extends SynthLookAndFeel {

  34.     private static final boolean IS_22;

  35. 

  36.     /**

  37.      * Whether or not text is drawn antialiased.  This keys off the

  38.      * desktop property 'gnome.Xft/Antialias'.

  39.      */

  40.     static Boolean aaText = Boolean.FALSE;

  41. 

  42.     /**

  43.      * Whether or not the default locale is CJK. If it is,

  44.      * the GNOME desktop property for antialiasing is ignored

  45.      * and the text is always rendered w/o aa.

  46.      * This is done to be consistent with what GTK does - they

  47.      * disable text aa for CJK locales as well.

  48.      *

  49.      * Note: this doesn't work well with changing locales

  50.      * at runtime. But most of Swing/2D code (including fonts

  51.      * initialization) doesn't either.

  52.      */

  53.     static boolean cjkLocale;

  54. 

  55.     /**

  56.      * Font to use in places where there is no widget.

  57.      */

  58.     private Font fallbackFont;

  59. 

  60.     /**

  61.      * If true, GTKLookAndFeel is inside the <code>initialize</code>

  62.      * method.

  63.      */

  64.     private boolean inInitialize;

  65. 

  66.     static {

  67.         // Backup for specifying the version, this isn't currently documented.

  68.         // If you pass in anything but 2.2 you got the 2.0 colors/look.

  69.         String version = (String)java.security.AccessController.doPrivileged(

  70.                new GetPropertyAction("swing.gtk.version"));

  71.         if (version != null) {

  72.             IS_22 = version.equals("2.2");

  73.         }

  74.         else {

  75.             IS_22 = true;

  76.         }

  77.     }

  78. 

  79.     /**

  80.      * Returns true if running on system containing at least 2.2.

  81.      */

  82.     static boolean is2_2() {

  83.         // NOTE: We're currently hard coding to use 2.2.

  84.         // If we want to support both GTK 2.0 and 2.2, we'll

  85.         // need to get the major/minor/micro version from the .so.

  86.         // Refer to bug 4912613 for details.

  87.         return IS_22;

  88.     }

  89. 

  90.     /**

  91.      * Maps a swing constant to a GTK constant.

  92.      */

  93.     static int SwingOrientationConstantToGTK(int side) {

  94.         switch (side) {

  95.         case SwingConstants.LEFT:

  96.             return GTKConstants.LEFT;

  97.         case SwingConstants.RIGHT:

  98.             return GTKConstants.RIGHT;

  99.         case SwingConstants.TOP:

  100.             return GTKConstants.TOP;

  101.         case SwingConstants.BOTTOM:

  102.             return GTKConstants.BOTTOM;

  103.         }

  104.         assert false : "Unknowning orientation: " + side;

  105.         return side;

  106.     }

  107. 

  108.     /**

  109.      * Maps from a Synth state to the corresponding GTK state. 

  110.      * The GTK states are named differently than Synth's states, the

  111.      * following gives the mapping:

  112.      * <table><tr><td>Synth<td>GTK

  113.      * <tr><td>SynthConstants.PRESSED<td>ACTIVE

  114.      * <tr><td>SynthConstants.SELECTED<td>SELECTED

  115.      * <tr><td>SynthConstants.MOUSE_OVER<td>PRELIGHT

  116.      * <tr><td>SynthConstants.DISABLED<td>INACTIVE

  117.      * <tr><td>SynthConstants.ENABLED<td>NORMAL

  118.      * </table>

  119.      * Additionally some widgets are special cased.

  120.      */

  121.     static int synthStateToGTKState(Region region, int state) {

  122.         int orgState = state;

  123. 

  124.         if ((state & SynthConstants.PRESSED) != 0) {

  125.             if (region == Region.RADIO_BUTTON

  126.                     || region == Region.CHECK_BOX

  127.                     || region == Region.TOGGLE_BUTTON

  128.                     || region == Region.MENU

  129.                     || region == Region.MENU_ITEM

  130.                     || region == Region.RADIO_BUTTON_MENU_ITEM

  131.                     || region == Region.CHECK_BOX_MENU_ITEM

  132.                     || region == Region.SPLIT_PANE) {

  133.                 state = SynthConstants.MOUSE_OVER;

  134.             } else {

  135.                 state = SynthConstants.PRESSED;

  136.             }

  137.         }

  138.         else if ((state & SynthConstants.SELECTED) != 0) {

  139.             if (region == Region.MENU) {

  140.                 state = SynthConstants.MOUSE_OVER;

  141.             } else if (region == Region.RADIO_BUTTON ||

  142.                           region == Region.TOGGLE_BUTTON ||

  143.                           region == Region.RADIO_BUTTON_MENU_ITEM ||

  144.                           region == Region.CHECK_BOX_MENU_ITEM ||

  145.                           region == Region.CHECK_BOX ||

  146.                           region == Region.BUTTON) {

  147.                 // If the button is SELECTED and is PRELIGHT we need to

  148.                 // make the state MOUSE_OVER otherwise we don't paint the

  149.                 // PRELIGHT.

  150.                 if ((state & SynthConstants.MOUSE_OVER) != 0) {

  151.                     state = SynthConstants.MOUSE_OVER;

  152.                 } else {

  153.                     state = SynthConstants.PRESSED;

  154.                 }

  155.             } else if (region == Region.TABBED_PANE_TAB) {

  156.                 state = SynthConstants.ENABLED;

  157.             } else {

  158.                 state = SynthConstants.SELECTED;

  159.             }

  160.         }

  161.         else if ((state & SynthConstants.MOUSE_OVER) != 0) {

  162.             state = SynthConstants.MOUSE_OVER;

  163.         }

  164.         else if ((state & SynthConstants.DISABLED) != 0) {

  165.             state = SynthConstants.DISABLED;

  166.         }

  167.         else {

  168.             if (region == Region.SLIDER_TRACK) {

  169.                 state = SynthConstants.PRESSED;

  170.             } else if (region == Region.TABBED_PANE_TAB) {

  171.                 state = SynthConstants.PRESSED;

  172.             } else {

  173.                 state = SynthConstants.ENABLED;

  174.             }

  175.         }

  176.         return state;

  177.     }

  178. 

  179.     static boolean isText(Region region) {

  180.         // These Regions treat FOREGROUND as TEXT.

  181.         return (region == Region.TEXT_FIELD ||

  182.                 region == Region.FORMATTED_TEXT_FIELD ||

  183.                 region == Region.LIST ||

  184.                 region == Region.PASSWORD_FIELD ||

  185.                 region == Region.SPINNER ||

  186.                 region == Region.TABLE ||

  187.                 region == Region.TEXT_AREA ||

  188.                 region == Region.TEXT_FIELD ||

  189.                 region == Region.TEXT_PANE ||

  190.                 region == Region.TREE);

  191.     }

  192. 

  193.     public UIDefaults getDefaults() {

  194.         // We need to call super for basic's properties file.

  195.         UIDefaults table = super.getDefaults();

  196. 

  197.         initResourceBundle(table);

  198.         // For compatability with apps expecting certain defaults we'll

  199.         // populate the table with the values from basic.

  200.         initSystemColorDefaults(table);

  201.         initComponentDefaults(table);

  202.         return table;

  203.     }

  204. 

  205.     private void initResourceBundle(UIDefaults table) {

  206.         table.addResourceBundle("com.sun.java.swing.plaf.gtk.resources.gtk");

  207.     }

  208. 

  209.     protected void initComponentDefaults(UIDefaults table) {

  210.         // For compatability with apps expecting certain defaults we'll

  211.         // populate the table with the values from basic.

  212.         super.initComponentDefaults(table);

  213. 

  214.         Object tempBorder = new GTKStyle.GTKLazyValue(

  215.             "com.sun.java.swing.plaf.gtk.GTKPainter$ListTableFocusBorder");

  216. 

  217.         Integer caretBlinkRate = new Integer(500);

  218.         Insets zeroInsets = new InsetsUIResource(0, 0, 0, 0);

  219. 

  220.         Double defaultCaretAspectRatio = new Double(0.025);

  221.         Color caretColor = table.getColor("caretColor");

  222.         

  223.         Object fieldInputMap = new UIDefaults.LazyInputMap(new Object[] {

  224.                        "ctrl C", DefaultEditorKit.copyAction,

  225.                        "ctrl V", DefaultEditorKit.pasteAction,

  226.                        "ctrl X", DefaultEditorKit.cutAction,

  227.                          "COPY", DefaultEditorKit.copyAction,

  228.                         "PASTE", DefaultEditorKit.pasteAction,

  229.                           "CUT", DefaultEditorKit.cutAction,

  230.                    "shift LEFT", DefaultEditorKit.selectionBackwardAction,

  231.                 "shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,

  232.                   "shift RIGHT", DefaultEditorKit.selectionForwardAction,

  233.                "shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,

  234.                     "ctrl LEFT", DefaultEditorKit.previousWordAction,

  235.                  "ctrl KP_LEFT", DefaultEditorKit.previousWordAction,

  236.                    "ctrl RIGHT", DefaultEditorKit.nextWordAction,

  237.                 "ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,

  238.               "ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,

  239.            "ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,

  240.              "ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,

  241.           "ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,

  242.                        "ctrl A", DefaultEditorKit.selectAllAction,

  243.                          "HOME", DefaultEditorKit.beginLineAction,

  244.                           "END", DefaultEditorKit.endLineAction,

  245.                    "shift HOME", DefaultEditorKit.selectionBeginLineAction,

  246.                     "shift END", DefaultEditorKit.selectionEndLineAction,

  247.                    "BACK_SPACE", DefaultEditorKit.deletePrevCharAction,

  248.                        "ctrl H", DefaultEditorKit.deletePrevCharAction,

  249.                        "DELETE", DefaultEditorKit.deleteNextCharAction,

  250.                         "RIGHT", DefaultEditorKit.forwardAction,

  251.                          "LEFT", DefaultEditorKit.backwardAction,

  252.                      "KP_RIGHT", DefaultEditorKit.forwardAction,

  253.                       "KP_LEFT", DefaultEditorKit.backwardAction,

  254.                         "ENTER", JTextField.notifyAction,

  255.               "ctrl BACK_SLASH", "unselect"/*DefaultEditorKit.unselectAction*/,

  256.                "control shift O", "toggle-componentOrientation"/*DefaultEditorKit.toggleComponentOrientation*/

  257.             });

  258. 

  259.         Object passwordInputMap = new UIDefaults.LazyInputMap(new Object[] {

  260.                        "ctrl C", DefaultEditorKit.copyAction,

  261.                        "ctrl V", DefaultEditorKit.pasteAction,

  262.                        "ctrl X", DefaultEditorKit.cutAction,

  263.                          "COPY", DefaultEditorKit.copyAction,

  264.                         "PASTE", DefaultEditorKit.pasteAction,

  265.                           "CUT", DefaultEditorKit.cutAction,

  266.                    "shift LEFT", DefaultEditorKit.selectionBackwardAction,

  267.                 "shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,

  268.                   "shift RIGHT", DefaultEditorKit.selectionForwardAction,

  269.                "shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,

  270.                     "ctrl LEFT", DefaultEditorKit.beginLineAction,

  271.                  "ctrl KP_LEFT", DefaultEditorKit.beginLineAction,

  272.                    "ctrl RIGHT", DefaultEditorKit.endLineAction,

  273.                 "ctrl KP_RIGHT", DefaultEditorKit.endLineAction,

  274.               "ctrl shift LEFT", DefaultEditorKit.selectionBeginLineAction,

  275.            "ctrl shift KP_LEFT", DefaultEditorKit.selectionBeginLineAction,

  276.              "ctrl shift RIGHT", DefaultEditorKit.selectionEndLineAction,

  277.           "ctrl shift KP_RIGHT", DefaultEditorKit.selectionEndLineAction,

  278.                        "ctrl A", DefaultEditorKit.selectAllAction,

  279.                          "HOME", DefaultEditorKit.beginLineAction,

  280.                           "END", DefaultEditorKit.endLineAction,

  281.                    "shift HOME", DefaultEditorKit.selectionBeginLineAction,

  282.                     "shift END", DefaultEditorKit.selectionEndLineAction,

  283.                    "BACK_SPACE", DefaultEditorKit.deletePrevCharAction,

  284.                        "ctrl H", DefaultEditorKit.deletePrevCharAction,

  285.                        "DELETE", DefaultEditorKit.deleteNextCharAction,

  286.                         "RIGHT", DefaultEditorKit.forwardAction,

  287.                          "LEFT", DefaultEditorKit.backwardAction,

  288.                      "KP_RIGHT", DefaultEditorKit.forwardAction,

  289.                       "KP_LEFT", DefaultEditorKit.backwardAction,

  290.                         "ENTER", JTextField.notifyAction,

  291.               "ctrl BACK_SLASH", "unselect"/*DefaultEditorKit.unselectAction*/,

  292.                "control shift O", "toggle-componentOrientation"/*DefaultEditorKit.toggleComponentOrientation*/

  293.             });

  294. 

  295.         Object editorMargin = new InsetsUIResource(3,3,3,3);

  296. 

  297.         Object multilineInputMap = new UIDefaults.LazyInputMap(new Object[] {

  298.                            "ctrl C", DefaultEditorKit.copyAction,

  299.                            "ctrl V", DefaultEditorKit.pasteAction,

  300.                            "ctrl X", DefaultEditorKit.cutAction,

  301.                              "COPY", DefaultEditorKit.copyAction,

  302.                             "PASTE", DefaultEditorKit.pasteAction,

  303.                               "CUT", DefaultEditorKit.cutAction,

  304.                        "shift LEFT", DefaultEditorKit.selectionBackwardAction,

  305.                     "shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,

  306.                       "shift RIGHT", DefaultEditorKit.selectionForwardAction,

  307.                    "shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,

  308.                         "ctrl LEFT", DefaultEditorKit.previousWordAction,

  309.                      "ctrl KP_LEFT", DefaultEditorKit.previousWordAction,

  310.                        "ctrl RIGHT", DefaultEditorKit.nextWordAction,

  311.                     "ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,

  312.                   "ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,

  313.                "ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,

  314.                  "ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,

  315.               "ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,

  316.                            "ctrl A", DefaultEditorKit.selectAllAction,

  317.                              "HOME", DefaultEditorKit.beginLineAction,

  318.                               "END", DefaultEditorKit.endLineAction,

  319.                        "shift HOME", DefaultEditorKit.selectionBeginLineAction,

  320.                         "shift END", DefaultEditorKit.selectionEndLineAction,

  321. 

  322.                                "UP", DefaultEditorKit.upAction,

  323.                             "KP_UP", DefaultEditorKit.upAction,

  324.                              "DOWN", DefaultEditorKit.downAction,

  325.                           "KP_DOWN", DefaultEditorKit.downAction,

  326.                           "PAGE_UP", DefaultEditorKit.pageUpAction,

  327.                         "PAGE_DOWN", DefaultEditorKit.pageDownAction,

  328.                     "shift PAGE_UP", "selection-page-up",

  329.                   "shift PAGE_DOWN", "selection-page-down",

  330.                "ctrl shift PAGE_UP", "selection-page-left",

  331.              "ctrl shift PAGE_DOWN", "selection-page-right",

  332.                          "shift UP", DefaultEditorKit.selectionUpAction,

  333.                       "shift KP_UP", DefaultEditorKit.selectionUpAction,

  334.                        "shift DOWN", DefaultEditorKit.selectionDownAction,

  335.                     "shift KP_DOWN", DefaultEditorKit.selectionDownAction,

  336.                             "ENTER", DefaultEditorKit.insertBreakAction,

  337.                        "BACK_SPACE", DefaultEditorKit.deletePrevCharAction,

  338.                            "ctrl H", DefaultEditorKit.deletePrevCharAction,

  339.                            "DELETE", DefaultEditorKit.deleteNextCharAction,

  340.                             "RIGHT", DefaultEditorKit.forwardAction,

  341.                              "LEFT", DefaultEditorKit.backwardAction, 

  342.                          "KP_RIGHT", DefaultEditorKit.forwardAction,

  343.                           "KP_LEFT", DefaultEditorKit.backwardAction,

  344.                               "TAB", DefaultEditorKit.insertTabAction,

  345.                   "ctrl BACK_SLASH", "unselect"/*DefaultEditorKit.unselectAction*/,

  346.                         "ctrl HOME", DefaultEditorKit.beginAction,

  347.                          "ctrl END", DefaultEditorKit.endAction,

  348.                   "ctrl shift HOME", DefaultEditorKit.selectionBeginAction,

  349.                    "ctrl shift END", DefaultEditorKit.selectionEndAction,

  350.                            "ctrl T", "next-link-action",

  351.                      "ctrl shift T", "previous-link-action",

  352.                        "ctrl SPACE", "activate-link-action",

  353.                    "control shift O", "toggle-componentOrientation"/*DefaultEditorKit.toggleComponentOrientation*/

  354.             });

  355. 

  356.         class FontLazyValue implements UIDefaults.LazyValue {

  357.             private Region region;

  358.             FontLazyValue(Region region) {

  359.                 this.region = region;

  360.             }

  361.             public Object createValue(UIDefaults table) {

  362.                 GTKStyleFactory factory = (GTKStyleFactory)getStyleFactory();

  363.                 GTKStyle style = (GTKStyle)factory.getStyle(

  364.                         GTKStyleFactory.gtkClassFor(region));

  365.                 return style.getFontForState(

  366.                         null, region, SynthConstants.ENABLED);

  367.             }

  368.         }

  369.         

  370.         Object[] defaults = new Object[] {

  371.             "ArrowButton.size", new Integer(13),

  372. 

  373. 

  374.             "Button.defaultButtonFollowsFocus", Boolean.FALSE,

  375. 	    "Button.focusInputMap", new UIDefaults.LazyInputMap(new Object[] {

  376.                          "SPACE", "pressed",

  377.                 "released SPACE", "released",

  378.                          "ENTER", "pressed",

  379.                 "released ENTER", "released"

  380.               }),

  381.             "Button.font", new FontLazyValue(Region.BUTTON),

  382. 

  383. 

  384. 	    "CheckBox.focusInputMap", new UIDefaults.LazyInputMap(new Object[]{

  385.                          "SPACE", "pressed",

  386.                 "released SPACE", "released",

  387.               }),

  388.             "CheckBox.icon", new GTKStyle.GTKLazyValue(

  389.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  390.                               "getCheckBoxIcon"),

  391.             "CheckBox.font", new FontLazyValue(Region.CHECK_BOX),

  392. 

  393. 

  394.             "CheckBoxMenuItem.arrowIcon", new GTKStyle.GTKLazyValue(

  395.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  396.                               "getCheckBoxMenuItemArrowIcon"),

  397.             "CheckBoxMenuItem.checkIcon", new GTKStyle.GTKLazyValue(

  398.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  399.                               "getCheckBoxMenuItemCheckIcon"),

  400.             "CheckBoxMenuItem.font", 

  401.                 new FontLazyValue(Region.CHECK_BOX_MENU_ITEM),

  402.             "CheckBoxMenuItem.margin", zeroInsets,

  403. 

  404. 

  405.             "ColorChooser.showPreviewPanelText", Boolean.FALSE,

  406.             "ColorChooser.panels", new UIDefaults.ActiveValue() {

  407.                 public Object createValue(UIDefaults table) {

  408.                     return new AbstractColorChooserPanel[] {

  409.                                        new GTKColorChooserPanel() };

  410.                 }

  411.             },

  412.             "ColorChooser.font", new FontLazyValue(Region.COLOR_CHOOSER),

  413. 

  414. 

  415. 	    "ComboBox.ancestorInputMap",

  416. 	       new UIDefaults.LazyInputMap(new Object[] {

  417. 		     "ESCAPE", "hidePopup",

  418. 		    "PAGE_UP", "pageUpPassThrough",

  419. 		  "PAGE_DOWN", "pageDownPassThrough",

  420. 		       "HOME", "homePassThrough",

  421. 		        "END", "endPassThrough",

  422. 		       "DOWN", "selectNext",

  423. 		    "KP_DOWN", "selectNext",

  424. 		   "alt DOWN", "togglePopup",

  425. 		"alt KP_DOWN", "togglePopup",

  426. 		     "alt UP", "togglePopup",

  427. 		  "alt KP_UP", "togglePopup",

  428. 		      "SPACE", "spacePopup",

  429.                       "ENTER", "enterPressed",

  430. 		         "UP", "selectPrevious",

  431. 		      "KP_UP", "selectPrevious"

  432. 

  433. 		 }),

  434.             "ComboBox.font", new FontLazyValue(Region.COMBO_BOX),

  435. 

  436. 

  437.             "EditorPane.caretForeground", caretColor,

  438.             "EditorPane.caretAspectRatio", defaultCaretAspectRatio,

  439.             "EditorPane.caretBlinkRate", caretBlinkRate,

  440.             "EditorPane.margin", editorMargin,

  441.             "EditorPane.focusInputMap", multilineInputMap,

  442.             "EditorPane.font", new FontLazyValue(Region.EDITOR_PANE),

  443. 

  444. 

  445. 	    "FileChooser.ancestorInputMap",

  446. 	       new UIDefaults.LazyInputMap(new Object[] {

  447. 		     "ESCAPE", "cancelSelection"

  448. 		 }),

  449.             "FileChooserUI", "com.sun.java.swing.plaf.gtk.GTKLookAndFeel",

  450. 

  451. 

  452.             "FormattedTextField.caretForeground", caretColor,

  453.             "FormattedTextField.caretAspectRatio", defaultCaretAspectRatio,

  454.             "FormattedTextField.caretBlinkRate", caretBlinkRate,

  455. 	    "FormattedTextField.focusInputMap",

  456.               new UIDefaults.LazyInputMap(new Object[] {

  457.                            "ctrl C", DefaultEditorKit.copyAction,

  458.                            "ctrl V", DefaultEditorKit.pasteAction,

  459.                            "ctrl X", DefaultEditorKit.cutAction,

  460.                              "COPY", DefaultEditorKit.copyAction,

  461.                             "PASTE", DefaultEditorKit.pasteAction,

  462.                               "CUT", DefaultEditorKit.cutAction,

  463.                        "shift LEFT", DefaultEditorKit.selectionBackwardAction,

  464.                     "shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,

  465.                       "shift RIGHT", DefaultEditorKit.selectionForwardAction,

  466.                    "shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,

  467.                         "ctrl LEFT", DefaultEditorKit.previousWordAction,

  468.                      "ctrl KP_LEFT", DefaultEditorKit.previousWordAction,

  469.                        "ctrl RIGHT", DefaultEditorKit.nextWordAction,

  470.                     "ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,

  471.                   "ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,

  472.                "ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,

  473.                  "ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,

  474.               "ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,

  475.                            "ctrl A", DefaultEditorKit.selectAllAction,

  476.                              "HOME", DefaultEditorKit.beginLineAction,

  477.                               "END", DefaultEditorKit.endLineAction,

  478.                        "shift HOME", DefaultEditorKit.selectionBeginLineAction,

  479.                         "shift END", DefaultEditorKit.selectionEndLineAction,

  480.                        "BACK_SPACE", DefaultEditorKit.deletePrevCharAction,

  481.                            "ctrl H", DefaultEditorKit.deletePrevCharAction,

  482.                            "DELETE", DefaultEditorKit.deleteNextCharAction,

  483.                             "RIGHT", DefaultEditorKit.forwardAction,

  484.                              "LEFT", DefaultEditorKit.backwardAction,

  485.                          "KP_RIGHT", DefaultEditorKit.forwardAction,

  486.                           "KP_LEFT", DefaultEditorKit.backwardAction,

  487.                             "ENTER", JTextField.notifyAction,

  488.                   "ctrl BACK_SLASH", "unselect",

  489.                   "control shift O", "toggle-componentOrientation",

  490.                            "ESCAPE", "reset-field-edit",

  491.                                "UP", "increment",

  492.                             "KP_UP", "increment",

  493.                              "DOWN", "decrement",

  494.                           "KP_DOWN", "decrement",

  495.               }),

  496.             "FormattedTextField.font", 

  497.                 new FontLazyValue(Region.FORMATTED_TEXT_FIELD),

  498. 

  499. 

  500. 	    "InternalFrameTitlePane.titlePaneLayout",

  501. 				new GTKStyle.GTKLazyValue("com.sun.java.swing.plaf.gtk.Metacity",

  502. 						 "getTitlePaneLayout"),

  503.             "InternalFrame.windowBindings", new Object[] {

  504.                   "shift ESCAPE", "showSystemMenu",

  505.                     "ctrl SPACE", "showSystemMenu",

  506.                         "ESCAPE", "hideSystemMenu" },

  507.             "InternalFrame.layoutTitlePaneAtOrigin", Boolean.TRUE,

  508.             "InternalFrame.useTaskBar", Boolean.TRUE,

  509. 

  510.             "Label.font", new FontLazyValue(Region.LABEL), 

  511. 

  512.             "List.focusCellHighlightBorder", tempBorder,

  513. 	    "List.focusInputMap",

  514. 	       new UIDefaults.LazyInputMap(new Object[] {

  515.                            "ctrl C", "copy",

  516.                            "ctrl V", "paste",

  517.                            "ctrl X", "cut",

  518.                              "COPY", "copy",

  519.                             "PASTE", "paste",

  520.                               "CUT", "cut",

  521. 		               "UP", "selectPreviousRow",

  522. 		            "KP_UP", "selectPreviousRow",

  523. 		         "shift UP", "selectPreviousRowExtendSelection",

  524. 		      "shift KP_UP", "selectPreviousRowExtendSelection",

  525.                     "ctrl shift UP", "selectPreviousRowExtendSelection",

  526.                  "ctrl shift KP_UP", "selectPreviousRowExtendSelection",

  527.                           "ctrl UP", "selectPreviousRowChangeLead",

  528.                        "ctrl KP_UP", "selectPreviousRowChangeLead",

  529. 		             "DOWN", "selectNextRow",

  530. 		          "KP_DOWN", "selectNextRow",

  531. 		       "shift DOWN", "selectNextRowExtendSelection",

  532. 		    "shift KP_DOWN", "selectNextRowExtendSelection",

  533.                   "ctrl shift DOWN", "selectNextRowExtendSelection",

  534.                "ctrl shift KP_DOWN", "selectNextRowExtendSelection",

  535.                         "ctrl DOWN", "selectNextRowChangeLead",

  536.                      "ctrl KP_DOWN", "selectNextRowChangeLead",

  537. 		             "LEFT", "selectPreviousColumn",

  538. 		          "KP_LEFT", "selectPreviousColumn",

  539. 		       "shift LEFT", "selectPreviousColumnExtendSelection",

  540. 		    "shift KP_LEFT", "selectPreviousColumnExtendSelection",

  541.                   "ctrl shift LEFT", "selectPreviousColumnExtendSelection",

  542.                "ctrl shift KP_LEFT", "selectPreviousColumnExtendSelection",

  543.                         "ctrl LEFT", "selectPreviousColumnChangeLead",

  544.                      "ctrl KP_LEFT", "selectPreviousColumnChangeLead",

  545. 		            "RIGHT", "selectNextColumn",

  546. 		         "KP_RIGHT", "selectNextColumn",

  547. 		      "shift RIGHT", "selectNextColumnExtendSelection",

  548. 		   "shift KP_RIGHT", "selectNextColumnExtendSelection",

  549.                  "ctrl shift RIGHT", "selectNextColumnExtendSelection",

  550.               "ctrl shift KP_RIGHT", "selectNextColumnExtendSelection",

  551.                        "ctrl RIGHT", "selectNextColumnChangeLead",

  552.                     "ctrl KP_RIGHT", "selectNextColumnChangeLead",

  553. 		             "HOME", "selectFirstRow",

  554. 		       "shift HOME", "selectFirstRowExtendSelection",

  555.                   "ctrl shift HOME", "selectFirstRowExtendSelection",

  556.                         "ctrl HOME", "selectFirstRowChangeLead",

  557. 		              "END", "selectLastRow",

  558. 		        "shift END", "selectLastRowExtendSelection",

  559.                    "ctrl shift END", "selectLastRowExtendSelection",

  560.                          "ctrl END", "selectLastRowChangeLead",

  561. 		          "PAGE_UP", "scrollUp",

  562. 		    "shift PAGE_UP", "scrollUpExtendSelection",

  563.                "ctrl shift PAGE_UP", "scrollUpExtendSelection",

  564.                      "ctrl PAGE_UP", "scrollUpChangeLead",

  565. 		        "PAGE_DOWN", "scrollDown",

  566. 		  "shift PAGE_DOWN", "scrollDownExtendSelection",

  567.              "ctrl shift PAGE_DOWN", "scrollDownExtendSelection",

  568.                    "ctrl PAGE_DOWN", "scrollDownChangeLead",

  569. 		           "ctrl A", "selectAll",

  570. 		       "ctrl SLASH", "selectAll",

  571. 		  "ctrl BACK_SLASH", "clearSelection",

  572.                             "SPACE", "addToSelection",

  573.                        "ctrl SPACE", "toggleAndAnchor",

  574.                       "shift SPACE", "extendTo",

  575.                  "ctrl shift SPACE", "moveSelectionTo"

  576. 		 }),

  577. 	    "List.focusInputMap.RightToLeft",

  578. 	       new UIDefaults.LazyInputMap(new Object[] {

  579. 		             "LEFT", "selectNextColumn",

  580. 		          "KP_LEFT", "selectNextColumn",

  581. 		       "shift LEFT", "selectNextColumnExtendSelection",

  582. 		    "shift KP_LEFT", "selectNextColumnExtendSelection",

  583.                   "ctrl shift LEFT", "selectNextColumnExtendSelection",

  584.                "ctrl shift KP_LEFT", "selectNextColumnExtendSelection",

  585.                         "ctrl LEFT", "selectNextColumnChangeLead",

  586.                      "ctrl KP_LEFT", "selectNextColumnChangeLead",

  587. 		            "RIGHT", "selectPreviousColumn",

  588. 		         "KP_RIGHT", "selectPreviousColumn",

  589. 		      "shift RIGHT", "selectPreviousColumnExtendSelection",

  590. 		   "shift KP_RIGHT", "selectPreviousColumnExtendSelection",

  591.                  "ctrl shift RIGHT", "selectPreviousColumnExtendSelection",

  592.               "ctrl shift KP_RIGHT", "selectPreviousColumnExtendSelection",

  593.                        "ctrl RIGHT", "selectPreviousColumnChangeLead",

  594.                     "ctrl KP_RIGHT", "selectPreviousColumnChangeLead",

  595. 		 }),

  596.             "List.font", new FontLazyValue(Region.LIST),

  597. 

  598. 

  599.  	    "Menu.shortcutKeys", new int[] {KeyEvent.ALT_MASK},

  600.             "Menu.arrowIcon", new GTKStyle.GTKLazyValue(

  601.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  602.                               "getMenuArrowIcon"),

  603.             "Menu.font", new FontLazyValue(Region.MENU),

  604.             "Menu.margin", zeroInsets,

  605. 

  606. 

  607. 	    "MenuBar.windowBindings", new Object[] {

  608. 		"F10", "takeFocus" },

  609.             "MenuBar.font", new FontLazyValue(Region.MENU_BAR),

  610. 

  611. 

  612.             "MenuItem.arrowIcon", new GTKStyle.GTKLazyValue(

  613.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  614.                               "getMenuItemArrowIcon"),

  615.             "MenuItem.font", new FontLazyValue(Region.MENU_ITEM),

  616.             "MenuItem.margin", zeroInsets,

  617. 

  618. 

  619.             "OptionPane.setButtonMargin", Boolean.FALSE,

  620.             "OptionPane.sameSizeButtons", Boolean.TRUE,

  621.             "OptionPane.buttonOrientation", new Integer(SwingConstants.RIGHT),

  622.             "OptionPane.minimumSize", new DimensionUIResource(262, 90),

  623.             "OptionPane.buttonPadding", new Integer(10),

  624. 	    "OptionPane.windowBindings", new Object[] {

  625. 		"ESCAPE", "close" },

  626. 	    "OptionPane.buttonClickThreshhold", new Integer(500),

  627.             "OptionPane.isYesLast", Boolean.TRUE,

  628.             "OptionPane.font", new FontLazyValue(Region.OPTION_PANE),

  629. 

  630.             "Panel.font", new FontLazyValue(Region.PANEL),

  631. 

  632.             "PasswordField.caretForeground", caretColor,

  633.             "PasswordField.caretAspectRatio", defaultCaretAspectRatio,

  634.             "PasswordField.caretBlinkRate", caretBlinkRate,

  635.             "PasswordField.margin", zeroInsets,

  636.             "PasswordField.focusInputMap", passwordInputMap,

  637.             "PasswordField.font", new FontLazyValue(Region.PASSWORD_FIELD),

  638. 

  639. 

  640.             "PopupMenu.consumeEventOnClose", Boolean.TRUE,

  641. 	    "PopupMenu.selectedWindowInputMapBindings", new Object[] {

  642. 		  "ESCAPE", "cancel",

  643.                     "DOWN", "selectNext",

  644. 		 "KP_DOWN", "selectNext",

  645. 		      "UP", "selectPrevious",

  646. 		   "KP_UP", "selectPrevious",

  647. 		    "LEFT", "selectParent",

  648. 		 "KP_LEFT", "selectParent",

  649. 		   "RIGHT", "selectChild",

  650. 		"KP_RIGHT", "selectChild",

  651. 		   "ENTER", "return",

  652. 		   "SPACE", "return"

  653. 	    },

  654. 	    "PopupMenu.selectedWindowInputMapBindings.RightToLeft",

  655.                   new Object[] {

  656. 		    "LEFT", "selectChild",

  657. 		 "KP_LEFT", "selectChild",

  658. 		   "RIGHT", "selectParent",

  659. 		"KP_RIGHT", "selectParent",

  660. 	    },

  661.             "PopupMenu.font", new FontLazyValue(Region.POPUP_MENU),

  662. 

  663.             "ProgressBar.horizontalSize", new DimensionUIResource(146, 16),

  664.             "ProgressBar.verticalSize", new DimensionUIResource(16, 146),

  665.             "ProgressBar.font", new FontLazyValue(Region.PROGRESS_BAR),

  666. 

  667. 	    "RadioButton.focusInputMap",

  668.                    new UIDefaults.LazyInputMap(new Object[] {

  669. 		            "SPACE", "pressed",

  670.                    "released SPACE", "released",

  671.                            "RETURN", "pressed"

  672. 	           }),

  673.             "RadioButton.icon", new GTKStyle.GTKLazyValue(

  674.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  675.                               "getRadioButtonIcon"),

  676.             "RadioButton.font", new FontLazyValue(Region.RADIO_BUTTON),

  677. 

  678. 

  679.             "RadioButtonMenuItem.arrowIcon", new GTKStyle.GTKLazyValue(

  680.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  681.                               "getRadioButtonMenuItemArrowIcon"),

  682.             "RadioButtonMenuItem.checkIcon", new GTKStyle.GTKLazyValue(

  683.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  684.                               "getRadioButtonMenuItemCheckIcon"),

  685.             "RadioButtonMenuItem.font", new FontLazyValue(Region.RADIO_BUTTON_MENU_ITEM), 

  686.             "RadioButtonMenuItem.margin", zeroInsets,

  687. 

  688.             // These bindings are only enabled when there is a default

  689.             // button set on the rootpane.

  690.             "RootPane.defaultButtonWindowKeyBindings", new Object[] {

  691. 		               "ENTER", "press",

  692. 		      "released ENTER", "release",

  693. 		          "ctrl ENTER", "press",

  694.                  "ctrl released ENTER", "release"

  695.             },

  696. 

  697. 

  698.             "ScrollBar.squareButtons", Boolean.TRUE,

  699.             "ScrollBar.thumbHeight", new Integer(14),

  700.             "ScrollBar.width", new Integer(16),

  701.             "ScrollBar.minimumThumbSize", new Dimension(8, 8),

  702.             "ScrollBar.maximumThumbSize", new Dimension(4096, 4096),

  703.             "ScrollBar.allowsAbsolutePositioning", Boolean.TRUE,

  704.             "ScrollBar.ancestorInputMap",

  705. 	           new UIDefaults.LazyInputMap(new Object[] {

  706. 		       "RIGHT", "positiveUnitIncrement",

  707. 		    "KP_RIGHT", "positiveUnitIncrement",

  708. 		        "DOWN", "positiveUnitIncrement",

  709. 		     "KP_DOWN", "positiveUnitIncrement",

  710. 		   "PAGE_DOWN", "positiveBlockIncrement",

  711. 		        "LEFT", "negativeUnitIncrement",

  712. 		     "KP_LEFT", "negativeUnitIncrement",

  713. 		          "UP", "negativeUnitIncrement",

  714. 		       "KP_UP", "negativeUnitIncrement",

  715. 		     "PAGE_UP", "negativeBlockIncrement",

  716. 		        "HOME", "minScroll",

  717. 		         "END", "maxScroll"

  718.                    }),

  719.             "ScrollBar.ancestorInputMap.RightToLeft",

  720.                     new UIDefaults.LazyInputMap(new Object[] {

  721. 		       "RIGHT", "negativeUnitIncrement",

  722. 		    "KP_RIGHT", "negativeUnitIncrement",

  723. 		        "LEFT", "positiveUnitIncrement",

  724. 		     "KP_LEFT", "positiveUnitIncrement",

  725.                     }),

  726. 

  727. 

  728.             "ScrollPane.ancestorInputMap",

  729.                     new UIDefaults.LazyInputMap(new Object[] {

  730. 		           "RIGHT", "unitScrollRight",

  731. 		        "KP_RIGHT", "unitScrollRight",

  732. 		            "DOWN", "unitScrollDown",

  733. 		         "KP_DOWN", "unitScrollDown",

  734. 		            "LEFT", "unitScrollLeft",

  735. 		         "KP_LEFT", "unitScrollLeft",

  736. 		              "UP", "unitScrollUp",

  737. 		           "KP_UP", "unitScrollUp",

  738. 		         "PAGE_UP", "scrollUp",

  739. 		       "PAGE_DOWN", "scrollDown",

  740. 		    "ctrl PAGE_UP", "scrollLeft",

  741. 		  "ctrl PAGE_DOWN", "scrollRight",

  742. 		       "ctrl HOME", "scrollHome",

  743. 		        "ctrl END", "scrollEnd"

  744.                     }),

  745.             "ScrollPane.ancestorInputMap.RightToLeft",

  746.                     new UIDefaults.LazyInputMap(new Object[] {

  747. 		    "ctrl PAGE_UP", "scrollRight",

  748. 		  "ctrl PAGE_DOWN", "scrollLeft",

  749.                     }),

  750.             "ScrollPane.font", new FontLazyValue(Region.SCROLL_PANE),

  751. 

  752. 

  753.             "Separator.insets", zeroInsets,

  754.             "Separator.thickness", new Integer(2),

  755. 

  756. 

  757.             "Slider.paintValue", Boolean.TRUE,

  758.             "Slider.thumbWidth", new Integer(30),

  759.             "Slider.thumbHeight", new Integer(14),

  760.             "Slider.focusInputMap",

  761.                     new UIDefaults.LazyInputMap(new Object[] {

  762.                             "RIGHT", "positiveUnitIncrement",

  763.                          "KP_RIGHT", "positiveUnitIncrement",

  764.                              "DOWN", "negativeUnitIncrement",

  765.                           "KP_DOWN", "negativeUnitIncrement",

  766.                         "PAGE_DOWN", "negativeBlockIncrement",

  767.                              "LEFT", "negativeUnitIncrement",

  768.                           "KP_LEFT", "negativeUnitIncrement",

  769.                                "UP", "positiveUnitIncrement",

  770.                             "KP_UP", "positiveUnitIncrement",

  771.                           "PAGE_UP", "positiveBlockIncrement",

  772.                              "HOME", "minScroll",

  773.                               "END", "maxScroll"

  774.                         }),

  775.             "Slider.focusInputMap.RightToLeft",

  776.                     new UIDefaults.LazyInputMap(new Object[] {

  777.                             "RIGHT", "negativeUnitIncrement",

  778.                          "KP_RIGHT", "negativeUnitIncrement",

  779.                              "LEFT", "positiveUnitIncrement",

  780.                           "KP_LEFT", "positiveUnitIncrement",

  781.                          }),

  782. 

  783. 

  784.             "Spinner.ancestorInputMap",

  785. 	       new UIDefaults.LazyInputMap(new Object[] {

  786.                                "UP", "increment",

  787.                             "KP_UP", "increment",

  788.                              "DOWN", "decrement",

  789.                           "KP_DOWN", "decrement",

  790.                }),

  791.             "Spinner.font", new FontLazyValue(Region.SPINNER),

  792. 

  793. 

  794.             "SplitPane.ancestorInputMap",

  795.                     new UIDefaults.LazyInputMap(new Object[] {

  796.    		        "UP", "negativeIncrement",

  797. 		      "DOWN", "positiveIncrement",

  798. 		      "LEFT", "negativeIncrement",

  799. 		     "RIGHT", "positiveIncrement",

  800. 		     "KP_UP", "negativeIncrement",

  801. 		   "KP_DOWN", "positiveIncrement",

  802. 		   "KP_LEFT", "negativeIncrement",

  803. 		  "KP_RIGHT", "positiveIncrement",

  804. 		      "HOME", "selectMin",

  805. 		       "END", "selectMax",

  806. 		        "F8", "startResize",

  807. 		        "F6", "toggleFocus",

  808. 		  "ctrl TAB", "focusOutForward",

  809.  	    "ctrl shift TAB", "focusOutBackward"

  810.                     }),

  811. 

  812. 

  813.             "SplitPane.size", new Integer(7),

  814.             "SplitPane.oneTouchOffset", new Integer(2),

  815.             "SplitPane.oneTouchButtonSize", new Integer(5),

  816.             "SplitPane.supportsOneTouchButtons", Boolean.FALSE,

  817. 

  818. 

  819. 	    "TabbedPane.focusInputMap",

  820. 	      new UIDefaults.LazyInputMap(new Object[] {

  821. 		         "RIGHT", "navigateRight",

  822. 	              "KP_RIGHT", "navigateRight",

  823. 	                  "LEFT", "navigateLeft",

  824. 	               "KP_LEFT", "navigateLeft",

  825. 	                    "UP", "navigateUp",

  826. 	                 "KP_UP", "navigateUp",

  827. 	                  "DOWN", "navigateDown",

  828. 	               "KP_DOWN", "navigateDown",

  829. 	             "ctrl DOWN", "requestFocusForVisibleComponent",

  830. 	          "ctrl KP_DOWN", "requestFocusForVisibleComponent",

  831. 			 "SPACE", "selectTabWithFocus"

  832. 		}),

  833. 	    "TabbedPane.ancestorInputMap",

  834. 	       new UIDefaults.LazyInputMap(new Object[] {

  835. 		         "ctrl TAB", "navigateNext",

  836. 		   "ctrl shift TAB", "navigatePrevious",

  837. 		   "ctrl PAGE_DOWN", "navigatePageDown",

  838. 	             "ctrl PAGE_UP", "navigatePageUp",

  839. 	                  "ctrl UP", "requestFocus",

  840. 	               "ctrl KP_UP", "requestFocus",

  841. 		 }),

  842. 

  843.             "TabbedPane.selectionFollowsFocus", Boolean.FALSE,

  844.             "TabbedPane.font", new FontLazyValue(Region.TABBED_PANE),

  845. 

  846. 

  847.             "Table.focusCellHighlightBorder", tempBorder,

  848.             "Table.ancestorInputMap", 

  849.                     new UIDefaults.LazyInputMap(new Object[] {

  850.                                "ctrl C", "copy",

  851.                                "ctrl V", "paste",

  852.                                "ctrl X", "cut",

  853.                                  "COPY", "copy",

  854.                                 "PASTE", "paste",

  855.                                   "CUT", "cut",

  856.                                 "RIGHT", "selectNextColumn",

  857.                              "KP_RIGHT", "selectNextColumn",

  858.                           "shift RIGHT", "selectNextColumnExtendSelection",

  859.                        "shift KP_RIGHT", "selectNextColumnExtendSelection",

  860.                      "ctrl shift RIGHT", "selectNextColumnExtendSelection",

  861.                   "ctrl shift KP_RIGHT", "selectNextColumnExtendSelection",

  862.                            "ctrl RIGHT", "selectNextColumnChangeLead",

  863.                         "ctrl KP_RIGHT", "selectNextColumnChangeLead",

  864.                                  "LEFT", "selectPreviousColumn",

  865.                               "KP_LEFT", "selectPreviousColumn",

  866.                            "shift LEFT", "selectPreviousColumnExtendSelection",

  867.                         "shift KP_LEFT", "selectPreviousColumnExtendSelection",

  868.                       "ctrl shift LEFT", "selectPreviousColumnExtendSelection",

  869.                    "ctrl shift KP_LEFT", "selectPreviousColumnExtendSelection",

  870.                             "ctrl LEFT", "selectPreviousColumnChangeLead",

  871.                          "ctrl KP_LEFT", "selectPreviousColumnChangeLead",

  872.                                  "DOWN", "selectNextRow",

  873.                               "KP_DOWN", "selectNextRow",

  874.                            "shift DOWN", "selectNextRowExtendSelection",

  875.                         "shift KP_DOWN", "selectNextRowExtendSelection",

  876.                       "ctrl shift DOWN", "selectNextRowExtendSelection",

  877.                    "ctrl shift KP_DOWN", "selectNextRowExtendSelection",

  878.                             "ctrl DOWN", "selectNextRowChangeLead",

  879.                          "ctrl KP_DOWN", "selectNextRowChangeLead",

  880.                                    "UP", "selectPreviousRow",

  881.                                 "KP_UP", "selectPreviousRow",

  882.                              "shift UP", "selectPreviousRowExtendSelection",

  883.                           "shift KP_UP", "selectPreviousRowExtendSelection",

  884.                         "ctrl shift UP", "selectPreviousRowExtendSelection",

  885.                      "ctrl shift KP_UP", "selectPreviousRowExtendSelection",

  886.                               "ctrl UP", "selectPreviousRowChangeLead",

  887.                            "ctrl KP_UP", "selectPreviousRowChangeLead",

  888.                                  "HOME", "selectFirstColumn",

  889.                            "shift HOME", "selectFirstColumnExtendSelection",

  890.                       "ctrl shift HOME", "selectFirstRowExtendSelection",

  891.                             "ctrl HOME", "selectFirstRow",

  892.                                   "END", "selectLastColumn",

  893.                             "shift END", "selectLastColumnExtendSelection",

  894.                        "ctrl shift END", "selectLastRowExtendSelection",

  895.                              "ctrl END", "selectLastRow",

  896.                               "PAGE_UP", "scrollUpChangeSelection",

  897.                         "shift PAGE_UP", "scrollUpExtendSelection",

  898.                    "ctrl shift PAGE_UP", "scrollLeftExtendSelection",

  899.                          "ctrl PAGE_UP", "scrollLeftChangeSelection",

  900.                             "PAGE_DOWN", "scrollDownChangeSelection",

  901.                       "shift PAGE_DOWN", "scrollDownExtendSelection",

  902.                  "ctrl shift PAGE_DOWN", "scrollRightExtendSelection",

  903.                        "ctrl PAGE_DOWN", "scrollRightChangeSelection",

  904.                                   "TAB", "selectNextColumnCell",

  905.                             "shift TAB", "selectPreviousColumnCell",

  906.                                 "ENTER", "selectNextRowCell",

  907.                           "shift ENTER", "selectPreviousRowCell",

  908.                                "ctrl A", "selectAll",

  909.                            "ctrl SLASH", "selectAll",

  910.                       "ctrl BACK_SLASH", "clearSelection",

  911.                                "ESCAPE", "cancel",

  912.                                    "F2", "startEditing",

  913.                                 "SPACE", "addToSelection",

  914.                            "ctrl SPACE", "toggleAndAnchor",

  915.                           "shift SPACE", "extendTo",

  916.                      "ctrl shift SPACE", "moveSelectionTo"

  917.                     }),

  918.             "Table.ancestorInputMap.RightToLeft",

  919.                     new UIDefaults.LazyInputMap(new Object[] {

  920.                                 "RIGHT", "selectPreviousColumn",

  921.                              "KP_RIGHT", "selectPreviousColumn",

  922.                           "shift RIGHT", "selectPreviousColumnExtendSelection",

  923.                        "shift KP_RIGHT", "selectPreviousColumnExtendSelection",

  924.                      "ctrl shift RIGHT", "selectPreviousColumnExtendSelection",

  925.                   "ctrl shift KP_RIGHT", "selectPreviousColumnExtendSelection",

  926.                           "shift RIGHT", "selectPreviousColumnChangeLead",

  927.                        "shift KP_RIGHT", "selectPreviousColumnChangeLead",

  928.                                  "LEFT", "selectNextColumn",

  929.                               "KP_LEFT", "selectNextColumn",

  930.                            "shift LEFT", "selectNextColumnExtendSelection",

  931.                         "shift KP_LEFT", "selectNextColumnExtendSelection",

  932.                       "ctrl shift LEFT", "selectNextColumnExtendSelection",

  933.                    "ctrl shift KP_LEFT", "selectNextColumnExtendSelection",

  934.                             "ctrl LEFT", "selectNextColumnChangeLead",

  935.                          "ctrl KP_LEFT", "selectNextColumnChangeLead",

  936.                          "ctrl PAGE_UP", "scrollRightChangeSelection",

  937.                        "ctrl PAGE_DOWN", "scrollLeftChangeSelection",

  938.                    "ctrl shift PAGE_UP", "scrollRightExtendSelection",

  939.                  "ctrl shift PAGE_DOWN", "scrollLeftExtendSelection",

  940.                     }),

  941.             "Table.font", new FontLazyValue(Region.TABLE),

  942.             

  943.             "TableHeader.font", new FontLazyValue(Region.TABLE_HEADER),

  944. 

  945.             "TextArea.caretForeground", caretColor,

  946.             "TextArea.caretAspectRatio", defaultCaretAspectRatio,

  947.             "TextArea.caretBlinkRate", caretBlinkRate,

  948.             "TextArea.margin", zeroInsets,

  949.             "TextArea.focusInputMap", multilineInputMap,

  950.             "TextArea.font", new FontLazyValue(Region.TEXT_AREA),

  951. 

  952. 

  953.             "TextField.caretForeground", caretColor,

  954.             "TextField.caretAspectRatio", defaultCaretAspectRatio,

  955.             "TextField.caretBlinkRate", caretBlinkRate,

  956.             "TextField.margin", zeroInsets,

  957.             "TextField.focusInputMap", fieldInputMap,

  958.             "TextField.font", new FontLazyValue(Region.TEXT_FIELD),

  959. 

  960. 

  961.             "TextPane.caretForeground", caretColor,

  962.             "TextPane.caretAspectRatio", defaultCaretAspectRatio,

  963.             "TextPane.caretBlinkRate", caretBlinkRate,

  964.             "TextPane.margin", editorMargin,

  965.             "TextPane.focusInputMap", multilineInputMap,

  966.             "TextPane.font", new FontLazyValue(Region.TEXT_PANE),

  967. 

  968. 

  969.             "TitledBorder.titleColor", new ColorUIResource(Color.BLACK),

  970.             "TitledBorder.border", new UIDefaults.ProxyLazyValue(

  971.                       "javax.swing.plaf.BorderUIResource",

  972.                       "getEtchedBorderUIResource"),

  973. 

  974. 	    "ToggleButton.focusInputMap",

  975.                    new UIDefaults.LazyInputMap(new Object[] {

  976. 		            "SPACE", "pressed",

  977.                    "released SPACE", "released"

  978. 	           }),

  979.             "ToggleButton.font", new FontLazyValue(Region.TOGGLE_BUTTON),

  980. 

  981. 

  982.             "ToolBar.separatorSize", new DimensionUIResource(10, 10),

  983.             "ToolBar.handleIcon", new UIDefaults.ActiveValue() {

  984.                 public Object createValue(UIDefaults table) {

  985.                     return GTKIconFactory.getToolBarHandleIcon();

  986.                 }

  987.             },

  988. 	    "ToolBar.ancestorInputMap",

  989. 	       new UIDefaults.LazyInputMap(new Object[] {

  990. 		        "UP", "navigateUp",

  991. 		     "KP_UP", "navigateUp",

  992. 		      "DOWN", "navigateDown",

  993. 		   "KP_DOWN", "navigateDown",

  994. 		      "LEFT", "navigateLeft",

  995. 		   "KP_LEFT", "navigateLeft",

  996. 		     "RIGHT", "navigateRight",

  997. 		  "KP_RIGHT", "navigateRight"

  998. 		 }),

  999.             "ToolBar.font", new FontLazyValue(Region.TOOL_BAR),

  1000. 

  1001.             "ToolTip.font", new FontLazyValue(Region.TOOL_TIP),

  1002. 

  1003.             "Tree.padding", new Integer(4),

  1004.             "Tree.drawHorizontalLines", Boolean.FALSE,

  1005.             "Tree.drawVerticalLines", Boolean.FALSE,

  1006.             "Tree.rowHeight", new Integer(-1),

  1007.             "Tree.scrollsOnExpand", Boolean.FALSE,

  1008.             "Tree.expanderSize", new Integer(10),

  1009. 	    "Tree.closedIcon", null,

  1010. 	    "Tree.leafIcon", null,

  1011. 	    "Tree.openIcon", null,

  1012.             "Tree.expandedIcon", new GTKStyle.GTKLazyValue(

  1013.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  1014.                               "getTreeExpandedIcon"),

  1015.             "Tree.collapsedIcon", new GTKStyle.GTKLazyValue(

  1016.                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",

  1017.                               "getTreeCollapsedIcon"),

  1018.             "Tree.leftChildIndent", new Integer(2),

  1019.             "Tree.rightChildIndent", new Integer(12),

  1020.             "Tree.scrollsHorizontallyAndVertically", Boolean.FALSE,

  1021.             "Tree.drawsFocusBorder", Boolean.TRUE,

  1022.             "Tree.focusInputMap",

  1023.                     new UIDefaults.LazyInputMap(new Object[] {

  1024.                                  "ctrl C", "copy",

  1025.                                  "ctrl V", "paste",

  1026.                                  "ctrl X", "cut",

  1027.                                    "COPY", "copy",

  1028.                                   "PASTE", "paste",

  1029.                                     "CUT", "cut",

  1030. 		                     "UP", "selectPrevious",

  1031. 		                  "KP_UP", "selectPrevious",

  1032. 		               "shift UP", "selectPreviousExtendSelection",

  1033. 		            "shift KP_UP", "selectPreviousExtendSelection",

  1034.                           "ctrl shift UP", "selectPreviousExtendSelection",

  1035.                        "ctrl shift KP_UP", "selectPreviousExtendSelection",

  1036.                                 "ctrl UP", "selectPreviousChangeLead",

  1037.                              "ctrl KP_UP", "selectPreviousChangeLead",

  1038. 		                   "DOWN", "selectNext",

  1039. 		                "KP_DOWN", "selectNext",

  1040. 		             "shift DOWN", "selectNextExtendSelection",

  1041. 		          "shift KP_DOWN", "selectNextExtendSelection",

  1042.                         "ctrl shift DOWN", "selectNextExtendSelection",

  1043.                      "ctrl shift KP_DOWN", "selectNextExtendSelection",

  1044.                               "ctrl DOWN", "selectNextChangeLead",

  1045.                            "ctrl KP_DOWN", "selectNextChangeLead",

  1046. 		                  "RIGHT", "selectChild",

  1047. 		               "KP_RIGHT", "selectChild",

  1048. 		                   "LEFT", "selectParent",

  1049. 		                "KP_LEFT", "selectParent",

  1050.                                 "typed +", "expand",

  1051.                                 "typed -", "collapse",

  1052.                              "BACK_SPACE", "moveSelectionToParent",

  1053. 		                "PAGE_UP", "scrollUpChangeSelection",

  1054. 		          "shift PAGE_UP", "scrollUpExtendSelection",

  1055.                      "ctrl shift PAGE_UP", "scrollUpExtendSelection",

  1056.                            "ctrl PAGE_UP", "scrollUpChangeLead",

  1057. 		              "PAGE_DOWN", "scrollDownChangeSelection",

  1058. 		        "shift PAGE_DOWN", "scrollDownExtendSelection",

  1059.                    "ctrl shift PAGE_DOWN", "scrollDownExtendSelection",

  1060.                          "ctrl PAGE_DOWN", "scrollDownChangeLead",

  1061. 		                   "HOME", "selectFirst",

  1062. 		             "shift HOME", "selectFirstExtendSelection",

  1063.                         "ctrl shift HOME", "selectFirstExtendSelection",

  1064.                               "ctrl HOME", "selectFirstChangeLead",

  1065. 		                    "END", "selectLast",

  1066. 		              "shift END", "selectLastExtendSelection",

  1067.                          "ctrl shift END", "selectLastExtendSelection",

  1068.                                "ctrl END", "selectLastChangeLead",

  1069. 		                     "F2", "startEditing",

  1070. 		                 "ctrl A", "selectAll",

  1071. 		             "ctrl SLASH", "selectAll",

  1072. 		        "ctrl BACK_SLASH", "clearSelection",

  1073. 		              "ctrl LEFT", "scrollLeft",

  1074. 		           "ctrl KP_LEFT", "scrollLeft",

  1075. 		             "ctrl RIGHT", "scrollRight",

  1076. 		          "ctrl KP_RIGHT", "scrollRight",

  1077.                                   "SPACE", "addToSelection",

  1078.                              "ctrl SPACE", "toggleAndAnchor",

  1079.                             "shift SPACE", "extendTo",

  1080.                        "ctrl shift SPACE", "moveSelectionTo"

  1081.                     }),

  1082.             "Tree.focusInputMap.RightToLeft",

  1083.                     new UIDefaults.LazyInputMap(new Object[] {

  1084. 		                  "RIGHT", "selectParent",

  1085. 		               "KP_RIGHT", "selectParent",

  1086. 		                   "LEFT", "selectChild",

  1087. 		                "KP_LEFT", "selectChild",

  1088. 		 }),

  1089.             "Tree.ancestorInputMap",

  1090.                       new UIDefaults.LazyInputMap(new Object[] {

  1091. 		         "ESCAPE", "cancel"

  1092.                       }),

  1093.             "Tree.font", new FontLazyValue(Region.TREE),

  1094.             

  1095.             "Viewport.font", new FontLazyValue(Region.VIEWPORT)

  1096.         };

  1097. 	table.putDefaults(defaults);

  1098. 

  1099.         if (fallbackFont != null) {

  1100.             table.put("TitledBorder.font", fallbackFont);

  1101.         }

  1102.     }

  1103. 

  1104.     protected void initSystemColorDefaults(UIDefaults table) {

  1105.         GTKStyleFactory factory = (GTKStyleFactory)getStyleFactory();

  1106.         GTKStyle windowStyle = (GTKStyle)factory.getStyle("GtkWindow");

  1107.         table.put("window", windowStyle.getGTKColor(SynthConstants.ENABLED,

  1108.                                                     GTKColorType.BACKGROUND));

  1109.         table.put("windowText", windowStyle.getGTKColor(

  1110.                 SynthConstants.ENABLED, GTKColorType.TEXT_FOREGROUND));

  1111. 

  1112.         GTKStyle entryStyle = (GTKStyle)factory.getStyle("GtkEntry");

  1113.         table.put("text", entryStyle.getGTKColor(SynthConstants.ENABLED,

  1114.                                            GTKColorType.TEXT_BACKGROUND));

  1115.         table.put("textText", entryStyle.getGTKColor(SynthConstants.ENABLED,

  1116.                                            GTKColorType.TEXT_FOREGROUND));

  1117.         table.put("textHighlight",

  1118.                   entryStyle.getGTKColor(SynthConstants.SELECTED,

  1119.                                          GTKColorType.TEXT_BACKGROUND));

  1120.         table.put("textHighlightText",

  1121.                   entryStyle.getGTKColor(SynthConstants.SELECTED,

  1122.                                          GTKColorType.TEXT_FOREGROUND));

  1123.         table.put("textInactiveText",

  1124.                   entryStyle.getGTKColor(SynthConstants.DISABLED,

  1125.                                          GTKColorType.TEXT_FOREGROUND));

  1126.         Object caretColor =

  1127.             entryStyle.getClassSpecificValue(Region.TEXT_FIELD, "cursor-color");

  1128.         if (caretColor == null) {

  1129.             caretColor = GTKStyle.BLACK_COLOR;

  1130.         }

  1131.         table.put("caretColor", caretColor);

  1132.         

  1133.         GTKStyle widgetStyle = (GTKStyle)factory.getStyle("GtkWidget");

  1134.         table.put("control", widgetStyle.getGTKColor(SynthConstants.ENABLED,

  1135.                                            GTKColorType.BACKGROUND));

  1136.         table.put("controlText", widgetStyle.getGTKColor(

  1137.                       SynthConstants.ENABLED,

  1138.                       GTKColorType.TEXT_FOREGROUND));

  1139.         

  1140.         table.put("controlHighlight", widgetStyle.getGTKColor(

  1141.                 SynthConstants.ENABLED, GTKColorType.BACKGROUND));

  1142.         table.put("controlLtHighlight", widgetStyle.getGTKColor(

  1143.                 SynthConstants.ENABLED, GTKColorType.LIGHT));

  1144.         table.put("controlShadow", widgetStyle.getGTKColor(

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

  1146.         table.put("controlDkShadow", widgetStyle.getGTKColor(

  1147.                 SynthConstants.ENABLED, GTKColorType.BLACK));

  1148.         

  1149.         

  1150.         GTKStyle menuStyle = (GTKStyle)factory.getStyle("GtkMenuItem");

  1151.         table.put("menu", menuStyle.getGTKColor(SynthConstants.ENABLED,

  1152.                                            GTKColorType.BACKGROUND));

  1153.         table.put("menuText", menuStyle.getGTKColor(SynthConstants.ENABLED,

  1154.                                            GTKColorType.TEXT_FOREGROUND));

  1155.         

  1156.         GTKStyle scrollbarStyle = (GTKStyle)factory.getStyle("GtkScrollbar");

  1157.         table.put("scrollbar", scrollbarStyle.getGTKColor(SynthConstants.ENABLED,

  1158.                                            GTKColorType.BACKGROUND));

  1159.         

  1160.         GTKStyle infoStyle = (GTKStyle)factory.getStyle("GtkMessageDialog");

  1161.         table.put("info", scrollbarStyle.getGTKColor(SynthConstants.ENABLED,

  1162.                                            GTKColorType.BACKGROUND));

  1163.         table.put("infoText", scrollbarStyle.getGTKColor(SynthConstants.ENABLED,

  1164.                                            GTKColorType.TEXT_FOREGROUND));

  1165.         

  1166.         GTKStyle desktopStyle = (GTKStyle)factory.getStyle("GtkContainer");

  1167.         table.put("desktop", scrollbarStyle.getGTKColor(SynthConstants.ENABLED,

  1168.                                            GTKColorType.BACKGROUND));

  1169.         

  1170.         // colors specific only for GTK

  1171.         table.put("light", widgetStyle.getGTKColor(

  1172.                 SynthConstants.ENABLED, GTKColorType.LIGHT));

  1173.         table.put("mid", widgetStyle.getGTKColor(

  1174.                 SynthConstants.ENABLED, GTKColorType.MID));

  1175.         table.put("dark", widgetStyle.getGTKColor(

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

  1177.         table.put("black", widgetStyle.getGTKColor(

  1178.                 SynthConstants.ENABLED, GTKColorType.BLACK));

  1179.         table.put("white", widgetStyle.getGTKColor(

  1180.                 SynthConstants.ENABLED, GTKColorType.WHITE));

  1181.     }

  1182. 

  1183.     /**

  1184.      * Creates the GTK look and feel class for the passed in Component.

  1185.      */

  1186.     public static ComponentUI createUI(JComponent c) {

  1187.         String key = c.getUIClassID().intern();

  1188. 

  1189.         if (key == "FileChooserUI") {

  1190.             return GTKFileChooserUI.createUI(c);

  1191. 	}

  1192.         return SynthLookAndFeel.createUI(c);

  1193.     }

  1194. 

  1195.     /**

  1196.      * Updates the <code>aaText</code> field.

  1197.      */

  1198.     static void updateAAText() {

  1199.         if (!cjkLocale) {

  1200.             Object aaValue = Toolkit.getDefaultToolkit().

  1201.                 getDesktopProperty("gnome.Xft/Antialias");

  1202.             aaText = Boolean.valueOf(((aaValue instanceof Number) &&

  1203.                                       ((Number)aaValue).intValue() == 1));

  1204.         }

  1205.     }

  1206. 

  1207.     static boolean isLeftToRight(Component c) {

  1208.         return c.getComponentOrientation().isLeftToRight();

  1209.     }

  1210. 

  1211.     private static boolean isLocalDisplay() {

  1212.         try {

  1213.             Class x11Class = Class.forName("sun.awt.X11GraphicsEnvironment");

  1214.             Method isDisplayLocalMethod = x11Class.getMethod(

  1215.                       "isDisplayLocal", new Class[0]);

  1216.             return (Boolean)isDisplayLocalMethod.invoke(null, null);

  1217.         } catch (NoSuchMethodException nsme) {

  1218.         } catch (ClassNotFoundException cnfe) {

  1219.         } catch (IllegalAccessException iae) {

  1220.         } catch (InvocationTargetException ite) {

  1221.         }

  1222.         // If we get here we're most likely being run on Windows, return

  1223.         // false.

  1224.         return false;

  1225.     }

  1226. 

  1227. 

  1228.     public void initialize() {

  1229.         super.initialize();

  1230.         inInitialize = true;

  1231.         loadStylesFromThemeFiles();

  1232.         inInitialize = false;

  1233. 

  1234.         Toolkit kit = Toolkit.getDefaultToolkit();

  1235.         WeakPCL pcl = new WeakPCL(this, kit, "gnome.Net/ThemeName");

  1236.         kit.addPropertyChangeListener(pcl.getKey(), pcl);

  1237.         pcl = new WeakPCL(this, kit, "gnome.Gtk/FontName");

  1238.         kit.addPropertyChangeListener(pcl.getKey(), pcl);

  1239.         pcl = new WeakPCL(this, kit, "gnome.Xft/DPI");

  1240.         kit.addPropertyChangeListener(pcl.getKey(), pcl);

  1241. 

  1242.         String language = Locale.getDefault().getLanguage();

  1243.         cjkLocale = 

  1244.             (Locale.CHINESE.getLanguage().equals(language) ||

  1245.              Locale.JAPANESE.getLanguage().equals(language) ||

  1246.              Locale.KOREAN.getLanguage().equals(language));

  1247. 

  1248.         if (isLocalDisplay()) {

  1249.             pcl = new WeakPCL(this, kit, "gnome.Xft/Antialias");

  1250.             kit.addPropertyChangeListener(pcl.getKey(), pcl);

  1251.             updateAAText();

  1252.         }

  1253.         flushUnreferenced();

  1254.     }

  1255. 

  1256.     static ReferenceQueue queue = new ReferenceQueue();

  1257. 

  1258.     static void flushUnreferenced() {

  1259.         WeakPCL pcl;

  1260. 

  1261.         while ((pcl = (WeakPCL)queue.poll()) != null) {

  1262.             pcl.dispose();

  1263.         }

  1264.     }

  1265. 

  1266.     static class WeakPCL extends WeakReference implements

  1267.             PropertyChangeListener {

  1268.         private Toolkit kit;

  1269.         private String key;

  1270. 

  1271.         WeakPCL(Object target, Toolkit kit, String key) {

  1272.             super(target, queue);

  1273.             this.kit = kit;

  1274.             this.key = key;

  1275.         }

  1276. 

  1277.         public String getKey() { return key; }

  1278. 

  1279.         public void propertyChange(final PropertyChangeEvent pce) {

  1280.             final GTKLookAndFeel lnf = (GTKLookAndFeel)get();

  1281. 

  1282.             if (lnf == null) {

  1283.                 // The property was GC'ed, we're no longer interested in

  1284.                 // PropertyChanges, remove the listener.

  1285.                 dispose();

  1286.             }

  1287.             else {

  1288.                 // We are using invokeLater here because we are getting called

  1289.                 // on the AWT-Motif thread which can cause a deadlock.

  1290.                 SwingUtilities.invokeLater(new Runnable() {

  1291.                     public void run() {

  1292.                         if ("gnome.Xft/Antialias".equals(

  1293.                                                   pce.getPropertyName())) {

  1294.                             updateAAText();

  1295.                         }

  1296.                         lnf.loadStylesFromThemeFiles();

  1297.                         Frame appFrames[] = Frame.getFrames();

  1298.                         for (int i = 0; i < appFrames.length; i++) {

  1299.                             SynthLookAndFeel.updateStyles(appFrames[i]);

  1300.                         }

  1301.                     }

  1302.                 });

  1303.             }

  1304.         }

  1305. 

  1306.         void dispose() {

  1307.             kit.removePropertyChangeListener(key, this);

  1308.         }

  1309.     }

  1310. 

  1311.     public void propertyChange(PropertyChangeEvent evt) {

  1312.         String propertyName = evt.getPropertyName();

  1313. 	loadStylesFromThemeFiles();

  1314.         Frame appFrames[] = Frame.getFrames();

  1315.         for (int i = 0; i < appFrames.length; i++) {

  1316.             SynthLookAndFeel.updateStyles(appFrames[i]);

  1317.         }

  1318.     }

  1319. 

  1320.     public boolean isSupportedLookAndFeel() {

  1321.         return true;

  1322.     }

  1323. 

  1324.     public boolean isNativeLookAndFeel() {

  1325.         return false;

  1326.     }

  1327. 

  1328.     public String getDescription() {

  1329.         return "GTK look and feel";

  1330.     }

  1331. 

  1332.     public String getName() {

  1333.         return "GTK look and feel";

  1334.     }

  1335. 

  1336.     public String getID() {

  1337.         return "GTK";

  1338.     }

  1339. 

  1340.     // Subclassed to pass in false to the superclass, we don't want to try

  1341.     // and load the system colors.

  1342.     protected void loadSystemColors(UIDefaults table, String[] systemColors, boolean useNative) {

  1343.         super.loadSystemColors(table, systemColors, false);

  1344.     }

  1345. 

  1346.     private void loadStylesFromThemeFiles() {

  1347.         AccessController.doPrivileged(new PrivilegedAction() {

  1348.             public Object run() {

  1349.                 GTKParser parser = new GTKParser();

  1350. 

  1351.                 // GTK rc file parsing:

  1352.                 // First, attempts to load the file specified in the

  1353.                 // swing.gtkthemefile system property.

  1354.                 // RC files come from one of the following locations:

  1355.                 // 1 - environment variable GTK2_RC_FILES, which is colon

  1356.                 //     separated list of rc files or

  1357.                 // 2 - SYSCONFDIR/gtk-2.0/gtkrc and ~/.gtkrc-2.0

  1358.                 // 

  1359.                 // Additionally the default Theme file is parsed last. The default

  1360.                 // theme name comes from the desktop property gnome.Net/ThemeName

  1361.                 //     Default theme is looked for in ~/.themes/THEME/gtk-2.0/gtkrc

  1362.                 //     and env variable GTK_DATA_PREFIX/THEME/gtkrc or

  1363.                 //     GTK_DATA_PREFIX/THEME/gtk-2.0/gtkrc

  1364.                 //     (or compiled GTK_DATA_PREFIX) GTK_DATA_PREFIX is

  1365.                 //     /usr/share/themes on debian,

  1366.                 //     /usr/sfw/share/themes on Solaris.

  1367.                 // Lastly key bindings are supposed to come from a different theme

  1368.                 // with the path built as above, using the desktop property

  1369.                 // named gnome.Gtk/KeyThemeName.

  1370. 

  1371.                 // Try system property override first:

  1372.                 String filename = System.getProperty("swing.gtkthemefile");

  1373.                 String sep = File.separator;

  1374. 

  1375.                 if (filename == null || !parseThemeFile(filename, parser)) {

  1376. 	            // Try to load user's theme first

  1377. 	            String userHome = System.getProperty("user.home");

  1378. 	            if (userHome != null) {

  1379.                         parseThemeFile(userHome + sep + ".gtkrc-2.0", parser);

  1380. 	            }

  1381. 	            // Now try to load "Default" theme

  1382. 	            String themeName = (String)Toolkit.getDefaultToolkit().

  1383.                         getDesktopProperty("gnome.Net/ThemeName");

  1384. 	            if (themeName == null) {

  1385. 	        	themeName = "Default";

  1386. 	            }

  1387.                     String[] dirs = new String[] {

  1388.                         userHome + "/.themes",

  1389.                         System.getProperty("swing.gtkthemedir"),

  1390.                         "/usr/share/themes" // Debian/Redhat/Solaris/SuSE

  1391.                     };

  1392. 

  1393.                     String themeDirName = null;

  1394.                     // Find the first existing rc file in the list.

  1395.                     for (int i = 0; i < dirs.length; i++) {

  1396.                         if (dirs[i] == null) {

  1397.                             continue;

  1398.                         }

  1399. 

  1400.                         if (new File(dirs[i] + sep + themeName + sep +

  1401.                                     "gtk-2.0" + sep + "gtkrc").canRead()) {

  1402.                             themeDirName = dirs[i];

  1403.                             break;

  1404.                         }

  1405.                     }

  1406. 

  1407.                     if (themeDirName != null) {

  1408.                         parseThemeFile(themeDirName + sep + themeName + sep +

  1409.                                 "gtk-2.0" + sep + "gtkrc", parser);

  1410.                     }

  1411. 	        }

  1412.                 setStyleFactory(handleParsedData(parser));

  1413.                 parser.clearParser();

  1414. 		return null;

  1415. 	    }

  1416. 	});

  1417.         // If we are in initialize initializations will be

  1418.         // called later, don't do it now.

  1419.         if (!inInitialize) {

  1420.             UIDefaults table = UIManager.getLookAndFeelDefaults();

  1421.             initSystemColorDefaults(table);

  1422.             initComponentDefaults(table);            

  1423.         }

  1424.     }

  1425. 

  1426.     private boolean parseThemeFile(String fileName, GTKParser parser) {

  1427.         File file = new File(fileName);

  1428. 	if (file.exists()) {

  1429.             try {

  1430.                 parser.parseFile(file, fileName);

  1431.             } catch (IOException ioe) {

  1432.                 System.err.println("error: (" + ioe.toString()

  1433.                                    + ") while parsing file: \""

  1434.                                    + fileName

  1435.                                    + "\"");

  1436.             }

  1437.             return true;

  1438. 	}

  1439.         return false; // file doesn't exist

  1440.     }

  1441. 

  1442.     /**

  1443.      * This method is responsible for handling the data that was parsed.

  1444.      * One of it's jobs is to fetch and deal with the GTK settings stored

  1445.      * in the parser. It's other job is to create a style factory with an

  1446.      * appropriate default style, load into it the styles from the parser,

  1447.      * and return that factory.

  1448.      */

  1449.     private GTKStyleFactory handleParsedData(GTKParser parser) {

  1450.         HashMap settings = parser.getGTKSettings();

  1451. 

  1452.         /*

  1453.          * The following is a list of the settings that GTK supports and their meanings.

  1454.          * Currently, we only support a subset ("gtk-font-name" and "gtk-icon-sizes"):

  1455.          *

  1456.          *   "gtk-can-change-accels"     : Whether menu accelerators can be changed

  1457.          *                                 by pressing a key over the menu item.

  1458.          *   "gtk-color-palette"         : Palette to use in the color selector.

  1459.          *   "gtk-cursor-blink"          : Whether the cursor should blink.

  1460.          *   "gtk-cursor-blink-time"     : Length of the cursor blink cycle, in milleseconds.

  1461.          *   "gtk-dnd-drag-threshold"    : Number of pixels the cursor can move before dragging.

  1462.          *   "gtk-double-click-time"     : Maximum time allowed between two clicks for them

  1463.          *                                 to be considered a double click (in milliseconds).

  1464.          *   "gtk-entry-select-on-focus" : Whether to select the contents of an entry when it

  1465.          *                                 is focused.

  1466.          *   "gtk-font-name"             : Name of default font to use.

  1467.          *   "gtk-icon-sizes"            : List of icon sizes (gtk-menu=16,16:gtk-button=20,20...

  1468.          *   "gtk-key-theme-name"        : Name of key theme RC file to load.

  1469.          *   "gtk-menu-bar-accel"        : Keybinding to activate the menu bar.

  1470.          *   "gtk-menu-bar-popup-delay"  : Delay before the submenus of a menu bar appear.

  1471.          *   "gtk-menu-popdown-delay"    : The time before hiding a submenu when the pointer is

  1472.          *                                 moving towards the submenu.

  1473.          *   "gtk-menu-popup-delay"      : Minimum time the pointer must stay over a menu item

  1474.          *                                 before the submenu appear.

  1475.          *   "gtk-split-cursor"          : Whether two cursors should be displayed for mixed

  1476.          *                                 left-to-right and right-to-left text.

  1477.          *   "gtk-theme-name"            : Name of theme RC file to load.

  1478.          *   "gtk-toolbar-icon-size"     : Size of icons in default toolbars.

  1479.          *   "gtk-toolbar-style"         : Whether default toolbars have text only, text and icons,

  1480.          *                                 icons only, etc.

  1481.          */

  1482. 

  1483.         Object iconSizes = settings.get("gtk-icon-sizes");

  1484.         if (iconSizes instanceof String) {

  1485.             if (!configIconSizes((String)iconSizes)) {

  1486.                 System.err.println("Error parsing gtk-icon-sizes string: '" + iconSizes + "'");

  1487.             }

  1488.         }

  1489. 

  1490.         // Desktop property appears to have preference over rc font.

  1491.         Object fontName = Toolkit.getDefaultToolkit().getDesktopProperty(

  1492.                                   "gnome.Gtk/FontName");

  1493. 

  1494.         if (!(fontName instanceof String)) {

  1495.             fontName = settings.get("gtk-font-name");

  1496.             if (!(fontName instanceof String)) {

  1497.                 fontName = "sans 10";

  1498.             }

  1499.         }

  1500.         Font defaultFont = PangoFonts.lookupFont((String)fontName);

  1501.         GTKStyle defaultStyle = new GTKStyle(defaultFont);

  1502.         GTKStyleFactory factory = new GTKStyleFactory(defaultStyle);

  1503. 

  1504.         parser.loadStylesInto(factory);

  1505.         fallbackFont = defaultFont;

  1506.         return factory;

  1507.     }

  1508. 

  1509.     private boolean configIconSizes(String sizeString) {

  1510.         String[] sizes = sizeString.split(":");

  1511.         for (int i = 0; i < sizes.length; i++) {

  1512.             String[] splits = sizes[i].split("=");

  1513. 

  1514.             if (splits.length != 2) {

  1515.                 return false;

  1516.             }

  1517.             

  1518.             String size = splits[0].trim().intern();

  1519.             if (size.length() < 1) {

  1520.                 return false;

  1521.             }

  1522. 

  1523.             splits = splits[1].split(",");

  1524.             

  1525.             if (splits.length != 2) {

  1526.                 return false;

  1527.             }

  1528.             

  1529.             String width = splits[0].trim();

  1530.             String height = splits[1].trim();

  1531.             

  1532.             if (width.length() < 1 || height.length() < 1) {

  1533.                 return false;

  1534.             }

  1535. 

  1536.             int w = 0;

  1537.             int h = 0;

  1538. 

  1539.             try {

  1540.                 w = Integer.parseInt(width);

  1541.                 h = Integer.parseInt(height);

  1542.             } catch (NumberFormatException nfe) {

  1543.                 return false;

  1544.             }

  1545. 

  1546.             if (w > 0 && h > 0) {

  1547.                 int type = GTKStyle.GTKStockIconInfo.getIconType(size); 

  1548.                 GTKStyle.GTKStockIconInfo.setIconSize(type, w, h);

  1549.             } else {

  1550.                 System.err.println("Invalid size in gtk-icon-sizes: " + w + "," + h);

  1551.             }

  1552.         }

  1553.         

  1554.         return true;

  1555.     }

  1556. 

  1557.     /**

  1558.      * Returns whether or not the UIs should update their

  1559.      * <code>SynthStyles</code> from the <code>SynthStyleFactory</code>

  1560.      * when the ancestor of the Component changes.

  1561.      *

  1562.      * @return whether or not the UIs should update their

  1563.      * <code>SynthStyles</code> from the <code>SynthStyleFactory</code>

  1564.      * when the ancestor changed.

  1565.      */

  1566.     public boolean shouldUpdateStyleOnAncestorChanged() {

  1567.         return true;

  1568.     }

  1569. }