1 /*
   2  * Copyright (c) 2002, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.java.swing.plaf.gtk;
  27 
  28 import java.awt.*;
  29 import java.beans.*;
  30 import java.io.File;
  31 import java.lang.ref.*;
  32 import java.security.AccessController;
  33 import java.security.PrivilegedAction;
  34 import java.util.Locale;
  35 import javax.swing.*;
  36 import javax.swing.colorchooser.*;
  37 import javax.swing.plaf.*;
  38 import javax.swing.plaf.synth.*;
  39 import javax.swing.text.DefaultEditorKit;
  40 
  41 import com.sun.java.swing.plaf.gtk.GTKConstants.PositionType;
  42 import com.sun.java.swing.plaf.gtk.GTKConstants.StateType;
  43 import java.util.HashMap;
  44 import java.util.Map;
  45 import sun.awt.SunToolkit;
  46 import sun.awt.UNIXToolkit;
  47 import sun.awt.OSInfo;
  48 import sun.security.action.GetPropertyAction;
  49 import sun.swing.DefaultLayoutStyle;
  50 import sun.swing.SwingUtilities2;
  51 
  52 /**
  53  * @author Scott Violet
  54  */
  55 @SuppressWarnings("serial") // Superclass not serializable
  56 public class GTKLookAndFeel extends SynthLookAndFeel {
  57     private static final boolean IS_22;
  58 
  59     /**
  60      * Whether or not text is drawn antialiased.  This keys off the
  61      * desktop property 'gnome.Xft/Antialias' and 'gnome.Xft/RGBA'
  62      * We should assume ON - or some variation of ON as no GTK desktop
  63      * ships with it OFF.
  64      */
  65     static Map<Object, Object> aaTextInfo;
  66 
  67     /**
  68      * Solaris, or Linux with Sun JDS in a CJK Locale.
  69      * Used to determine if Sun's high quality CJK fonts are present.
  70      */
  71     private static boolean isSunCJK;
  72 
  73     /*
  74      * Used to override if system (desktop) text anti-aliasing settings should
  75      * be used. The reasons for this are are is that currently its "off"
  76      * for CJK locales which is not likely to be a good universal answer, and
  77      * also its off for remote display. So this provides an unsupported
  78      * way to explicitly request that it be "on".
  79      */
  80     private static boolean gtkAAFontSettingsCond;
  81 
  82     /**
  83      * Font to use in places where there is no widget.
  84      */
  85     private Font fallbackFont;
  86 
  87     /**
  88      * If true, GTKLookAndFeel is inside the {@code initialize}
  89      * method.
  90      */
  91     private boolean inInitialize;
  92 
  93     /**
  94      * If true, PropertyChangeListeners have been installed for the
  95      * Toolkit.
  96      */
  97     private boolean pclInstalled;
  98 
  99     /**
 100      * StyleFactory needs to be created only the first time.
 101      */
 102     private GTKStyleFactory styleFactory;
 103 
 104     /**
 105      * Cached theme name. Used by GTKGraphicsUtils
 106      */
 107     private static String gtkThemeName = "Default";
 108 
 109     static {
 110         // Backup for specifying the version, this isn't currently documented.
 111         // If you pass in anything but 2.2 you got the 2.0 colors/look.
 112         String version = AccessController.doPrivileged(
 113                new GetPropertyAction("swing.gtk.version"));
 114         if (version != null) {
 115             IS_22 = version.equals("2.2");
 116         }
 117         else {
 118             IS_22 = true;
 119         }
 120 
 121         String language = Locale.getDefault().getLanguage();
 122         boolean cjkLocale =
 123             (Locale.CHINESE.getLanguage().equals(language) ||
 124              Locale.JAPANESE.getLanguage().equals(language) ||
 125              Locale.KOREAN.getLanguage().equals(language));
 126 
 127         if (cjkLocale) {
 128             boolean isSunDesktop = false;
 129             switch (OSInfo.getOSType()) {
 130                 case SOLARIS:
 131                     isSunDesktop = true;
 132                     break;
 133 
 134                 case LINUX:
 135                     Boolean val = AccessController.doPrivileged(
 136                                     new PrivilegedAction<Boolean>() {
 137                                         public Boolean run() {
 138                                             File f = new File("/etc/sun-release");
 139                                             return Boolean.valueOf(f.exists());
 140                                         }
 141                                     });
 142                     isSunDesktop = val.booleanValue();
 143             }
 144             if (isSunDesktop && !sun.java2d.SunGraphicsEnvironment.isOpenSolaris) {
 145                 isSunCJK = true;
 146             }
 147         }
 148     }
 149 
 150     /**
 151      * Returns true if running on system containing at least 2.2.
 152      */
 153     static boolean is2_2() {
 154         // NOTE: We're currently hard coding to use 2.2.
 155         // If we want to support both GTK 2.0 and 2.2, we'll
 156         // need to get the major/minor/micro version from the .so.
 157         // Refer to bug 4912613 for details.
 158         return IS_22;
 159     }
 160 
 161     /**
 162      * Maps a swing constant to a GTK constant.
 163      */
 164     static PositionType SwingOrientationConstantToGTK(int side) {
 165         switch (side) {
 166         case SwingConstants.LEFT:
 167             return PositionType.LEFT;
 168         case SwingConstants.RIGHT:
 169             return PositionType.RIGHT;
 170         case SwingConstants.TOP:
 171             return PositionType.TOP;
 172         case SwingConstants.BOTTOM:
 173             return PositionType.BOTTOM;
 174         }
 175         assert false : "Unknown orientation: " + side;
 176         return PositionType.TOP;
 177     }
 178 
 179     /**
 180      * Maps from Synth state to native GTK state using typesafe enumeration
 181      * StateType.  This is only used by GTKEngine.
 182      */
 183     static StateType synthStateToGTKStateType(int state) {
 184         StateType result;
 185         switch (state) {
 186             case SynthConstants.PRESSED:
 187                 result = StateType.ACTIVE;
 188                 break;
 189             case SynthConstants.MOUSE_OVER:
 190                 result = StateType.PRELIGHT;
 191                 break;
 192             case SynthConstants.SELECTED:
 193                 result = StateType.SELECTED;
 194                 break;
 195             case SynthConstants.DISABLED:
 196                 result = StateType.INSENSITIVE;
 197                 break;
 198             case SynthConstants.ENABLED:
 199             default:
 200                 result = StateType.NORMAL;
 201                 break;
 202         }
 203         return result;
 204     }
 205 
 206     /**
 207      * Maps from a Synth state to the corresponding GTK state.
 208      * The GTK states are named differently than Synth's states, the
 209      * following gives the mapping:
 210      * <table><tr><td>Synth<td>GTK
 211      * <tr><td>SynthConstants.PRESSED<td>ACTIVE
 212      * <tr><td>SynthConstants.SELECTED<td>SELECTED
 213      * <tr><td>SynthConstants.MOUSE_OVER<td>PRELIGHT
 214      * <tr><td>SynthConstants.DISABLED<td>INSENSITIVE
 215      * <tr><td>SynthConstants.ENABLED<td>NORMAL
 216      * </table>
 217      * Additionally some widgets are special cased.
 218      */
 219     static int synthStateToGTKState(Region region, int state) {
 220         if ((state & SynthConstants.PRESSED) != 0) {
 221             if (region == Region.RADIO_BUTTON
 222                     || region == Region.CHECK_BOX
 223                     || region == Region.MENU
 224                     || region == Region.MENU_ITEM
 225                     || region == Region.RADIO_BUTTON_MENU_ITEM
 226                     || region == Region.CHECK_BOX_MENU_ITEM
 227                     || region == Region.SPLIT_PANE) {
 228                 state = SynthConstants.MOUSE_OVER;
 229             } else {
 230                 state = SynthConstants.PRESSED;
 231             }
 232 
 233         } else if (region == Region.TABBED_PANE_TAB) {
 234             if ((state & SynthConstants.DISABLED) != 0) {
 235                 state = SynthConstants.DISABLED;
 236             }
 237             else if ((state & SynthConstants.SELECTED) != 0) {
 238                 state = SynthConstants.ENABLED;
 239             } else {
 240                 state = SynthConstants.PRESSED;
 241             }
 242 
 243         } else if ((state & SynthConstants.SELECTED) != 0) {
 244             if (region == Region.MENU) {
 245                 state = SynthConstants.MOUSE_OVER;
 246             } else if (region == Region.RADIO_BUTTON ||
 247                           region == Region.TOGGLE_BUTTON ||
 248                           region == Region.RADIO_BUTTON_MENU_ITEM ||
 249                           region == Region.CHECK_BOX_MENU_ITEM ||
 250                           region == Region.CHECK_BOX ||
 251                           region == Region.BUTTON) {
 252                 if ((state & SynthConstants.DISABLED) != 0) {
 253                     state = SynthConstants.DISABLED;
 254                 }
 255                 // If the button is SELECTED and is PRELIGHT we need to
 256                 // make the state MOUSE_OVER otherwise we don't paint the
 257                 // PRELIGHT.
 258                 else if ((state & SynthConstants.MOUSE_OVER) != 0) {
 259                     state = SynthConstants.MOUSE_OVER;
 260                 } else {
 261                     state = SynthConstants.PRESSED;
 262                 }
 263             } else {
 264                 state = SynthConstants.SELECTED;
 265             }
 266         }
 267 
 268         else if ((state & SynthConstants.MOUSE_OVER) != 0) {
 269             state = SynthConstants.MOUSE_OVER;
 270         }
 271         else if ((state & SynthConstants.DISABLED) != 0) {
 272             state = SynthConstants.DISABLED;
 273         }
 274         else {
 275             if (region == Region.SLIDER_TRACK) {
 276                 state = SynthConstants.PRESSED;
 277             } else {
 278                 state = SynthConstants.ENABLED;
 279             }
 280         }
 281         return state;
 282     }
 283 
 284     static boolean isText(Region region) {
 285         // These Regions treat FOREGROUND as TEXT.
 286         return (region == Region.TEXT_FIELD ||
 287                 region == Region.FORMATTED_TEXT_FIELD ||
 288                 region == Region.LIST ||
 289                 region == Region.PASSWORD_FIELD ||
 290                 region == Region.SPINNER ||
 291                 region == Region.TABLE ||
 292                 region == Region.TEXT_AREA ||
 293                 region == Region.TEXT_FIELD ||
 294                 region == Region.TEXT_PANE ||
 295                 region == Region.TREE);
 296     }
 297 
 298     public UIDefaults getDefaults() {
 299         // We need to call super for basic's properties file.
 300         UIDefaults table = super.getDefaults();
 301 
 302         // SynthTabbedPaneUI supports rollover on tabs, GTK does not
 303         table.put("TabbedPane.isTabRollover", Boolean.FALSE);
 304 
 305         // Prevents Synth from setting text AA by itself
 306         table.put("Synth.doNotSetTextAA", true);
 307 
 308         initResourceBundle(table);
 309         // For compatibility with apps expecting certain defaults we'll
 310         // populate the table with the values from basic.
 311         initSystemColorDefaults(table);
 312         initComponentDefaults(table);
 313         installPropertyChangeListeners();
 314         return table;
 315     }
 316 
 317     private void installPropertyChangeListeners() {
 318         if(!pclInstalled) {
 319             Toolkit kit = Toolkit.getDefaultToolkit();
 320             WeakPCL pcl = new WeakPCL(this, kit, "gnome.Net/ThemeName");
 321             kit.addPropertyChangeListener(pcl.getKey(), pcl);
 322             pcl = new WeakPCL(this, kit, "gnome.Gtk/FontName");
 323             kit.addPropertyChangeListener(pcl.getKey(), pcl);
 324             pcl = new WeakPCL(this, kit, "gnome.Xft/DPI");
 325             kit.addPropertyChangeListener(pcl.getKey(), pcl);
 326 
 327             flushUnreferenced();
 328             pclInstalled = true;
 329         }
 330     }
 331 
 332     private void initResourceBundle(UIDefaults table) {
 333         table.addResourceBundle("com.sun.java.swing.plaf.gtk.resources.gtk");
 334     }
 335 
 336     protected void initComponentDefaults(UIDefaults table) {
 337         // For compatibility with apps expecting certain defaults we'll
 338         // populate the table with the values from basic.
 339         super.initComponentDefaults(table);
 340 
 341         UIDefaults.LazyValue zeroBorder =
 342             t -> new BorderUIResource.EmptyBorderUIResource(0, 0, 0, 0);
 343 
 344         Object focusBorder = new GTKStyle.GTKLazyValue(
 345             "com.sun.java.swing.plaf.gtk.GTKPainter$ListTableFocusBorder",
 346             "getUnselectedCellBorder");
 347         Object focusSelectedBorder = new GTKStyle.GTKLazyValue(
 348             "com.sun.java.swing.plaf.gtk.GTKPainter$ListTableFocusBorder",
 349             "getSelectedCellBorder");
 350         Object noFocusBorder = new GTKStyle.GTKLazyValue(
 351             "com.sun.java.swing.plaf.gtk.GTKPainter$ListTableFocusBorder",
 352             "getNoFocusCellBorder");
 353 
 354         GTKStyleFactory factory = (GTKStyleFactory)getStyleFactory();
 355         GTKStyle tableStyle = (GTKStyle)factory.getStyle(null, Region.TREE);
 356         Color tableBg = tableStyle.getGTKColor(SynthConstants.ENABLED,
 357                 GTKColorType.TEXT_BACKGROUND);
 358         Color tableFocusCellBg = tableStyle.getGTKColor(SynthConstants.ENABLED,
 359                 GTKColorType.BACKGROUND);
 360         Color tableFocusCellFg = tableStyle.getGTKColor(SynthConstants.ENABLED,
 361                 GTKColorType.FOREGROUND);
 362 
 363         // The following progress bar size calculations come from
 364         // gtkprogressbar.c (version 2.8.20), see MIN_* constants and
 365         // the gtk_progress_bar_size_request() method.
 366         GTKStyle progStyle = (GTKStyle)
 367             factory.getStyle(null, Region.PROGRESS_BAR);
 368         int progXThickness = progStyle.getXThickness();
 369         int progYThickness = progStyle.getYThickness();
 370         int hProgWidth  = 150 - (progXThickness * 2);
 371         int hProgHeight =  20 - (progYThickness * 2);
 372         int vProgWidth  =  22 - (progXThickness * 2);
 373         int vProgHeight =  80 - (progYThickness * 2);
 374 
 375         Integer caretBlinkRate;
 376         if (Boolean.FALSE.equals(GTKEngine.INSTANCE.getSetting(
 377                 GTKEngine.Settings.GTK_CURSOR_BLINK))) {
 378             caretBlinkRate = Integer.valueOf(0);
 379         } else {
 380             caretBlinkRate = (Integer) GTKEngine.INSTANCE.getSetting(
 381                     GTKEngine.Settings.GTK_CURSOR_BLINK_TIME);
 382             if (caretBlinkRate == null) {
 383                 caretBlinkRate = Integer.valueOf(500);
 384             }
 385         }
 386         Insets zeroInsets = new InsetsUIResource(0, 0, 0, 0);
 387 
 388         Double defaultCaretAspectRatio = new Double(0.025);
 389         Color caretColor = table.getColor("caretColor");
 390         Color controlText = table.getColor("controlText");
 391 
 392         Object fieldInputMap = new UIDefaults.LazyInputMap(new Object[] {
 393                        "ctrl C", DefaultEditorKit.copyAction,
 394                        "ctrl V", DefaultEditorKit.pasteAction,
 395                        "ctrl X", DefaultEditorKit.cutAction,
 396                          "COPY", DefaultEditorKit.copyAction,
 397                         "PASTE", DefaultEditorKit.pasteAction,
 398                           "CUT", DefaultEditorKit.cutAction,
 399                "control INSERT", DefaultEditorKit.copyAction,
 400                  "shift INSERT", DefaultEditorKit.pasteAction,
 401                  "shift DELETE", DefaultEditorKit.cutAction,
 402                    "shift LEFT", DefaultEditorKit.selectionBackwardAction,
 403                 "shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,
 404                   "shift RIGHT", DefaultEditorKit.selectionForwardAction,
 405                "shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,
 406                     "ctrl LEFT", DefaultEditorKit.previousWordAction,
 407                  "ctrl KP_LEFT", DefaultEditorKit.previousWordAction,
 408                    "ctrl RIGHT", DefaultEditorKit.nextWordAction,
 409                 "ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,
 410               "ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,
 411            "ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,
 412              "ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,
 413           "ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,
 414                        "ctrl A", DefaultEditorKit.selectAllAction,
 415                          "HOME", DefaultEditorKit.beginLineAction,
 416                           "END", DefaultEditorKit.endLineAction,
 417                    "shift HOME", DefaultEditorKit.selectionBeginLineAction,
 418                     "shift END", DefaultEditorKit.selectionEndLineAction,
 419                    "BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
 420              "shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
 421                        "ctrl H", DefaultEditorKit.deletePrevCharAction,
 422                        "DELETE", DefaultEditorKit.deleteNextCharAction,
 423                   "ctrl DELETE", DefaultEditorKit.deleteNextWordAction,
 424               "ctrl BACK_SPACE", DefaultEditorKit.deletePrevWordAction,
 425                         "RIGHT", DefaultEditorKit.forwardAction,
 426                          "LEFT", DefaultEditorKit.backwardAction,
 427                      "KP_RIGHT", DefaultEditorKit.forwardAction,
 428                       "KP_LEFT", DefaultEditorKit.backwardAction,
 429                         "ENTER", JTextField.notifyAction,
 430               "ctrl BACK_SLASH", "unselect"/*DefaultEditorKit.unselectAction*/,
 431                "control shift O", "toggle-componentOrientation"/*DefaultEditorKit.toggleComponentOrientation*/
 432             });
 433 
 434         Object passwordInputMap = new UIDefaults.LazyInputMap(new Object[] {
 435                        "ctrl C", DefaultEditorKit.copyAction,
 436                        "ctrl V", DefaultEditorKit.pasteAction,
 437                        "ctrl X", DefaultEditorKit.cutAction,
 438                          "COPY", DefaultEditorKit.copyAction,
 439                         "PASTE", DefaultEditorKit.pasteAction,
 440                           "CUT", DefaultEditorKit.cutAction,
 441                "control INSERT", DefaultEditorKit.copyAction,
 442                  "shift INSERT", DefaultEditorKit.pasteAction,
 443                  "shift DELETE", DefaultEditorKit.cutAction,
 444                    "shift LEFT", DefaultEditorKit.selectionBackwardAction,
 445                 "shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,
 446                   "shift RIGHT", DefaultEditorKit.selectionForwardAction,
 447                "shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,
 448                     "ctrl LEFT", DefaultEditorKit.beginLineAction,
 449                  "ctrl KP_LEFT", DefaultEditorKit.beginLineAction,
 450                    "ctrl RIGHT", DefaultEditorKit.endLineAction,
 451                 "ctrl KP_RIGHT", DefaultEditorKit.endLineAction,
 452               "ctrl shift LEFT", DefaultEditorKit.selectionBeginLineAction,
 453            "ctrl shift KP_LEFT", DefaultEditorKit.selectionBeginLineAction,
 454              "ctrl shift RIGHT", DefaultEditorKit.selectionEndLineAction,
 455           "ctrl shift KP_RIGHT", DefaultEditorKit.selectionEndLineAction,
 456                        "ctrl A", DefaultEditorKit.selectAllAction,
 457                          "HOME", DefaultEditorKit.beginLineAction,
 458                           "END", DefaultEditorKit.endLineAction,
 459                    "shift HOME", DefaultEditorKit.selectionBeginLineAction,
 460                     "shift END", DefaultEditorKit.selectionEndLineAction,
 461                    "BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
 462              "shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
 463                        "ctrl H", DefaultEditorKit.deletePrevCharAction,
 464                        "DELETE", DefaultEditorKit.deleteNextCharAction,
 465                         "RIGHT", DefaultEditorKit.forwardAction,
 466                          "LEFT", DefaultEditorKit.backwardAction,
 467                      "KP_RIGHT", DefaultEditorKit.forwardAction,
 468                       "KP_LEFT", DefaultEditorKit.backwardAction,
 469                         "ENTER", JTextField.notifyAction,
 470               "ctrl BACK_SLASH", "unselect"/*DefaultEditorKit.unselectAction*/,
 471                "control shift O", "toggle-componentOrientation"/*DefaultEditorKit.toggleComponentOrientation*/
 472             });
 473 
 474         Object editorMargin = new InsetsUIResource(3,3,3,3);
 475 
 476         Object multilineInputMap = new UIDefaults.LazyInputMap(new Object[] {
 477                            "ctrl C", DefaultEditorKit.copyAction,
 478                            "ctrl V", DefaultEditorKit.pasteAction,
 479                            "ctrl X", DefaultEditorKit.cutAction,
 480                              "COPY", DefaultEditorKit.copyAction,
 481                             "PASTE", DefaultEditorKit.pasteAction,
 482                               "CUT", DefaultEditorKit.cutAction,
 483                    "control INSERT", DefaultEditorKit.copyAction,
 484                      "shift INSERT", DefaultEditorKit.pasteAction,
 485                      "shift DELETE", DefaultEditorKit.cutAction,
 486                        "shift LEFT", DefaultEditorKit.selectionBackwardAction,
 487                     "shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,
 488                       "shift RIGHT", DefaultEditorKit.selectionForwardAction,
 489                    "shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,
 490                         "ctrl LEFT", DefaultEditorKit.previousWordAction,
 491                      "ctrl KP_LEFT", DefaultEditorKit.previousWordAction,
 492                        "ctrl RIGHT", DefaultEditorKit.nextWordAction,
 493                     "ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,
 494                   "ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,
 495                "ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,
 496                  "ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,
 497               "ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,
 498                            "ctrl A", DefaultEditorKit.selectAllAction,
 499                              "HOME", DefaultEditorKit.beginLineAction,
 500                               "END", DefaultEditorKit.endLineAction,
 501                        "shift HOME", DefaultEditorKit.selectionBeginLineAction,
 502                         "shift END", DefaultEditorKit.selectionEndLineAction,
 503 
 504                                "UP", DefaultEditorKit.upAction,
 505                             "KP_UP", DefaultEditorKit.upAction,
 506                              "DOWN", DefaultEditorKit.downAction,
 507                           "KP_DOWN", DefaultEditorKit.downAction,
 508                           "PAGE_UP", DefaultEditorKit.pageUpAction,
 509                         "PAGE_DOWN", DefaultEditorKit.pageDownAction,
 510                     "shift PAGE_UP", "selection-page-up",
 511                   "shift PAGE_DOWN", "selection-page-down",
 512                "ctrl shift PAGE_UP", "selection-page-left",
 513              "ctrl shift PAGE_DOWN", "selection-page-right",
 514                          "shift UP", DefaultEditorKit.selectionUpAction,
 515                       "shift KP_UP", DefaultEditorKit.selectionUpAction,
 516                        "shift DOWN", DefaultEditorKit.selectionDownAction,
 517                     "shift KP_DOWN", DefaultEditorKit.selectionDownAction,
 518                             "ENTER", DefaultEditorKit.insertBreakAction,
 519                        "BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
 520                  "shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
 521                            "ctrl H", DefaultEditorKit.deletePrevCharAction,
 522                            "DELETE", DefaultEditorKit.deleteNextCharAction,
 523                       "ctrl DELETE", DefaultEditorKit.deleteNextWordAction,
 524                   "ctrl BACK_SPACE", DefaultEditorKit.deletePrevWordAction,
 525                             "RIGHT", DefaultEditorKit.forwardAction,
 526                              "LEFT", DefaultEditorKit.backwardAction,
 527                          "KP_RIGHT", DefaultEditorKit.forwardAction,
 528                           "KP_LEFT", DefaultEditorKit.backwardAction,
 529                               "TAB", DefaultEditorKit.insertTabAction,
 530                   "ctrl BACK_SLASH", "unselect"/*DefaultEditorKit.unselectAction*/,
 531                         "ctrl HOME", DefaultEditorKit.beginAction,
 532                          "ctrl END", DefaultEditorKit.endAction,
 533                   "ctrl shift HOME", DefaultEditorKit.selectionBeginAction,
 534                    "ctrl shift END", DefaultEditorKit.selectionEndAction,
 535                            "ctrl T", "next-link-action",
 536                      "ctrl shift T", "previous-link-action",
 537                        "ctrl SPACE", "activate-link-action",
 538                    "control shift O", "toggle-componentOrientation"/*DefaultEditorKit.toggleComponentOrientation*/
 539             });
 540 
 541         class FontLazyValue implements UIDefaults.LazyValue {
 542             private Region region;
 543             FontLazyValue(Region region) {
 544                 this.region = region;
 545             }
 546             public Object createValue(UIDefaults table) {
 547                 GTKStyleFactory factory = (GTKStyleFactory)getStyleFactory();
 548                 GTKStyle style = (GTKStyle)factory.getStyle(null, region);
 549                 return style.getFontForState(null);
 550             }
 551         }
 552 
 553         Object[] defaults = new Object[] {
 554             "ArrowButton.size", Integer.valueOf(13),
 555 
 556 
 557             "Button.defaultButtonFollowsFocus", Boolean.FALSE,
 558             "Button.focusInputMap", new UIDefaults.LazyInputMap(new Object[] {
 559                          "SPACE", "pressed",
 560                 "released SPACE", "released",
 561                          "ENTER", "pressed",
 562                 "released ENTER", "released"
 563               }),
 564             "Button.font", new FontLazyValue(Region.BUTTON),
 565             "Button.margin", zeroInsets,
 566 
 567 
 568             "CheckBox.focusInputMap", new UIDefaults.LazyInputMap(new Object[]{
 569                          "SPACE", "pressed",
 570                 "released SPACE", "released"
 571               }),
 572             "CheckBox.icon", new GTKStyle.GTKLazyValue(
 573                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",
 574                               "getCheckBoxIcon"),
 575             "CheckBox.font", new FontLazyValue(Region.CHECK_BOX),
 576             "CheckBox.margin", zeroInsets,
 577 
 578 
 579             "CheckBoxMenuItem.arrowIcon", null,
 580             "CheckBoxMenuItem.checkIcon", new GTKStyle.GTKLazyValue(
 581                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",
 582                               "getCheckBoxMenuItemCheckIcon"),
 583             "CheckBoxMenuItem.font",
 584                 new FontLazyValue(Region.CHECK_BOX_MENU_ITEM),
 585             "CheckBoxMenuItem.margin", zeroInsets,
 586             "CheckBoxMenuItem.alignAcceleratorText", Boolean.FALSE,
 587 
 588 
 589             "ColorChooser.showPreviewPanelText", Boolean.FALSE,
 590             "ColorChooser.panels", new UIDefaults.ActiveValue() {
 591                 public Object createValue(UIDefaults table) {
 592                     return new AbstractColorChooserPanel[] {
 593                                        new GTKColorChooserPanel() };
 594                 }
 595             },
 596             "ColorChooser.font", new FontLazyValue(Region.COLOR_CHOOSER),
 597 
 598 
 599             "ComboBox.ancestorInputMap",
 600                new UIDefaults.LazyInputMap(new Object[] {
 601                      "ESCAPE", "hidePopup",
 602                     "PAGE_UP", "pageUpPassThrough",
 603                   "PAGE_DOWN", "pageDownPassThrough",
 604                        "HOME", "homePassThrough",
 605                         "END", "endPassThrough",
 606                        "DOWN", "selectNext",
 607                     "KP_DOWN", "selectNext",
 608                    "alt DOWN", "togglePopup",
 609                 "alt KP_DOWN", "togglePopup",
 610                      "alt UP", "togglePopup",
 611                   "alt KP_UP", "togglePopup",
 612                       "SPACE", "spacePopup",
 613                       "ENTER", "enterPressed",
 614                          "UP", "selectPrevious",
 615                       "KP_UP", "selectPrevious"
 616 
 617                  }),
 618             "ComboBox.font", new FontLazyValue(Region.COMBO_BOX),
 619             "ComboBox.isEnterSelectablePopup", Boolean.TRUE,
 620 
 621 
 622             "EditorPane.caretForeground", caretColor,
 623             "EditorPane.caretAspectRatio", defaultCaretAspectRatio,
 624             "EditorPane.caretBlinkRate", caretBlinkRate,
 625             "EditorPane.margin", editorMargin,
 626             "EditorPane.focusInputMap", multilineInputMap,
 627             "EditorPane.font", new FontLazyValue(Region.EDITOR_PANE),
 628 
 629 
 630             "FileChooser.ancestorInputMap",
 631                new UIDefaults.LazyInputMap(new Object[] {
 632                      "ESCAPE", "cancelSelection",
 633                  "ctrl ENTER", "approveSelection"
 634                  }),
 635             "FileChooserUI", "com.sun.java.swing.plaf.gtk.GTKLookAndFeel",
 636 
 637 
 638             "FormattedTextField.caretForeground", caretColor,
 639             "FormattedTextField.caretAspectRatio", defaultCaretAspectRatio,
 640             "FormattedTextField.caretBlinkRate", caretBlinkRate,
 641             "FormattedTextField.focusInputMap",
 642               new UIDefaults.LazyInputMap(new Object[] {
 643                            "ctrl C", DefaultEditorKit.copyAction,
 644                            "ctrl V", DefaultEditorKit.pasteAction,
 645                            "ctrl X", DefaultEditorKit.cutAction,
 646                              "COPY", DefaultEditorKit.copyAction,
 647                             "PASTE", DefaultEditorKit.pasteAction,
 648                               "CUT", DefaultEditorKit.cutAction,
 649                    "control INSERT", DefaultEditorKit.copyAction,
 650                      "shift INSERT", DefaultEditorKit.pasteAction,
 651                      "shift DELETE", DefaultEditorKit.cutAction,
 652                        "shift LEFT", DefaultEditorKit.selectionBackwardAction,
 653                     "shift KP_LEFT", DefaultEditorKit.selectionBackwardAction,
 654                       "shift RIGHT", DefaultEditorKit.selectionForwardAction,
 655                    "shift KP_RIGHT", DefaultEditorKit.selectionForwardAction,
 656                         "ctrl LEFT", DefaultEditorKit.previousWordAction,
 657                      "ctrl KP_LEFT", DefaultEditorKit.previousWordAction,
 658                        "ctrl RIGHT", DefaultEditorKit.nextWordAction,
 659                     "ctrl KP_RIGHT", DefaultEditorKit.nextWordAction,
 660                   "ctrl shift LEFT", DefaultEditorKit.selectionPreviousWordAction,
 661                "ctrl shift KP_LEFT", DefaultEditorKit.selectionPreviousWordAction,
 662                  "ctrl shift RIGHT", DefaultEditorKit.selectionNextWordAction,
 663               "ctrl shift KP_RIGHT", DefaultEditorKit.selectionNextWordAction,
 664                            "ctrl A", DefaultEditorKit.selectAllAction,
 665                              "HOME", DefaultEditorKit.beginLineAction,
 666                               "END", DefaultEditorKit.endLineAction,
 667                        "shift HOME", DefaultEditorKit.selectionBeginLineAction,
 668                         "shift END", DefaultEditorKit.selectionEndLineAction,
 669                        "BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
 670                  "shift BACK_SPACE", DefaultEditorKit.deletePrevCharAction,
 671                            "ctrl H", DefaultEditorKit.deletePrevCharAction,
 672                            "DELETE", DefaultEditorKit.deleteNextCharAction,
 673                       "ctrl DELETE", DefaultEditorKit.deleteNextWordAction,
 674                   "ctrl BACK_SPACE", DefaultEditorKit.deletePrevWordAction,
 675                             "RIGHT", DefaultEditorKit.forwardAction,
 676                              "LEFT", DefaultEditorKit.backwardAction,
 677                          "KP_RIGHT", DefaultEditorKit.forwardAction,
 678                           "KP_LEFT", DefaultEditorKit.backwardAction,
 679                             "ENTER", JTextField.notifyAction,
 680                   "ctrl BACK_SLASH", "unselect",
 681                   "control shift O", "toggle-componentOrientation",
 682                            "ESCAPE", "reset-field-edit",
 683                                "UP", "increment",
 684                             "KP_UP", "increment",
 685                              "DOWN", "decrement",
 686                           "KP_DOWN", "decrement",
 687               }),
 688             "FormattedTextField.font",
 689                 new FontLazyValue(Region.FORMATTED_TEXT_FIELD),
 690 
 691 
 692             "InternalFrameTitlePane.titlePaneLayout",
 693                                 new GTKStyle.GTKLazyValue("com.sun.java.swing.plaf.gtk.Metacity",
 694                                                  "getTitlePaneLayout"),
 695             "InternalFrame.windowBindings", new Object[] {
 696                   "shift ESCAPE", "showSystemMenu",
 697                     "ctrl SPACE", "showSystemMenu",
 698                         "ESCAPE", "hideSystemMenu" },
 699             "InternalFrame.layoutTitlePaneAtOrigin", Boolean.TRUE,
 700             "InternalFrame.useTaskBar", Boolean.TRUE,
 701 
 702             "InternalFrameTitlePane.iconifyButtonOpacity", null,
 703             "InternalFrameTitlePane.maximizeButtonOpacity", null,
 704             "InternalFrameTitlePane.closeButtonOpacity", null,
 705 
 706             "Label.font", new FontLazyValue(Region.LABEL),
 707 
 708             "List.background", tableBg,
 709             "List.focusCellHighlightBorder", focusBorder,
 710             "List.focusSelectedCellHighlightBorder", focusSelectedBorder,
 711             "List.noFocusBorder", noFocusBorder,
 712             "List.focusInputMap",
 713                new UIDefaults.LazyInputMap(new Object[] {
 714                            "ctrl C", "copy",
 715                            "ctrl V", "paste",
 716                            "ctrl X", "cut",
 717                              "COPY", "copy",
 718                             "PASTE", "paste",
 719                               "CUT", "cut",
 720                    "control INSERT", "copy",
 721                      "shift INSERT", "paste",
 722                      "shift DELETE", "cut",
 723                                "UP", "selectPreviousRow",
 724                             "KP_UP", "selectPreviousRow",
 725                          "shift UP", "selectPreviousRowExtendSelection",
 726                       "shift KP_UP", "selectPreviousRowExtendSelection",
 727                     "ctrl shift UP", "selectPreviousRowExtendSelection",
 728                  "ctrl shift KP_UP", "selectPreviousRowExtendSelection",
 729                           "ctrl UP", "selectPreviousRowChangeLead",
 730                        "ctrl KP_UP", "selectPreviousRowChangeLead",
 731                              "DOWN", "selectNextRow",
 732                           "KP_DOWN", "selectNextRow",
 733                        "shift DOWN", "selectNextRowExtendSelection",
 734                     "shift KP_DOWN", "selectNextRowExtendSelection",
 735                   "ctrl shift DOWN", "selectNextRowExtendSelection",
 736                "ctrl shift KP_DOWN", "selectNextRowExtendSelection",
 737                         "ctrl DOWN", "selectNextRowChangeLead",
 738                      "ctrl KP_DOWN", "selectNextRowChangeLead",
 739                              "LEFT", "selectPreviousColumn",
 740                           "KP_LEFT", "selectPreviousColumn",
 741                        "shift LEFT", "selectPreviousColumnExtendSelection",
 742                     "shift KP_LEFT", "selectPreviousColumnExtendSelection",
 743                   "ctrl shift LEFT", "selectPreviousColumnExtendSelection",
 744                "ctrl shift KP_LEFT", "selectPreviousColumnExtendSelection",
 745                         "ctrl LEFT", "selectPreviousColumnChangeLead",
 746                      "ctrl KP_LEFT", "selectPreviousColumnChangeLead",
 747                             "RIGHT", "selectNextColumn",
 748                          "KP_RIGHT", "selectNextColumn",
 749                       "shift RIGHT", "selectNextColumnExtendSelection",
 750                    "shift KP_RIGHT", "selectNextColumnExtendSelection",
 751                  "ctrl shift RIGHT", "selectNextColumnExtendSelection",
 752               "ctrl shift KP_RIGHT", "selectNextColumnExtendSelection",
 753                        "ctrl RIGHT", "selectNextColumnChangeLead",
 754                     "ctrl KP_RIGHT", "selectNextColumnChangeLead",
 755                              "HOME", "selectFirstRow",
 756                        "shift HOME", "selectFirstRowExtendSelection",
 757                   "ctrl shift HOME", "selectFirstRowExtendSelection",
 758                         "ctrl HOME", "selectFirstRowChangeLead",
 759                               "END", "selectLastRow",
 760                         "shift END", "selectLastRowExtendSelection",
 761                    "ctrl shift END", "selectLastRowExtendSelection",
 762                          "ctrl END", "selectLastRowChangeLead",
 763                           "PAGE_UP", "scrollUp",
 764                     "shift PAGE_UP", "scrollUpExtendSelection",
 765                "ctrl shift PAGE_UP", "scrollUpExtendSelection",
 766                      "ctrl PAGE_UP", "scrollUpChangeLead",
 767                         "PAGE_DOWN", "scrollDown",
 768                   "shift PAGE_DOWN", "scrollDownExtendSelection",
 769              "ctrl shift PAGE_DOWN", "scrollDownExtendSelection",
 770                    "ctrl PAGE_DOWN", "scrollDownChangeLead",
 771                            "ctrl A", "selectAll",
 772                        "ctrl SLASH", "selectAll",
 773                   "ctrl BACK_SLASH", "clearSelection",
 774                             "SPACE", "addToSelection",
 775                        "ctrl SPACE", "toggleAndAnchor",
 776                       "shift SPACE", "extendTo",
 777                  "ctrl shift SPACE", "moveSelectionTo"
 778                  }),
 779             "List.focusInputMap.RightToLeft",
 780                new UIDefaults.LazyInputMap(new Object[] {
 781                              "LEFT", "selectNextColumn",
 782                           "KP_LEFT", "selectNextColumn",
 783                        "shift LEFT", "selectNextColumnExtendSelection",
 784                     "shift KP_LEFT", "selectNextColumnExtendSelection",
 785                   "ctrl shift LEFT", "selectNextColumnExtendSelection",
 786                "ctrl shift KP_LEFT", "selectNextColumnExtendSelection",
 787                         "ctrl LEFT", "selectNextColumnChangeLead",
 788                      "ctrl KP_LEFT", "selectNextColumnChangeLead",
 789                             "RIGHT", "selectPreviousColumn",
 790                          "KP_RIGHT", "selectPreviousColumn",
 791                       "shift RIGHT", "selectPreviousColumnExtendSelection",
 792                    "shift KP_RIGHT", "selectPreviousColumnExtendSelection",
 793                  "ctrl shift RIGHT", "selectPreviousColumnExtendSelection",
 794               "ctrl shift KP_RIGHT", "selectPreviousColumnExtendSelection",
 795                        "ctrl RIGHT", "selectPreviousColumnChangeLead",
 796                     "ctrl KP_RIGHT", "selectPreviousColumnChangeLead",
 797                  }),
 798             "List.font", new FontLazyValue(Region.LIST),
 799             "List.rendererUseUIBorder", Boolean.FALSE,
 800 
 801             "Menu.arrowIcon", new GTKStyle.GTKLazyValue(
 802                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",
 803                               "getMenuArrowIcon"),
 804             "Menu.checkIcon", null,
 805             "Menu.font", new FontLazyValue(Region.MENU),
 806             "Menu.margin", zeroInsets,
 807             "Menu.cancelMode", "hideMenuTree",
 808             "Menu.alignAcceleratorText", Boolean.FALSE,
 809             "Menu.useMenuBarForTopLevelMenus", Boolean.TRUE,
 810 
 811 
 812                 "MenuBar.windowBindings", new Object[] {
 813                 "F10", "takeFocus" },
 814             "MenuBar.font", new FontLazyValue(Region.MENU_BAR),
 815 
 816 
 817             "MenuItem.arrowIcon", null,
 818             "MenuItem.checkIcon", null,
 819             "MenuItem.font", new FontLazyValue(Region.MENU_ITEM),
 820             "MenuItem.margin", zeroInsets,
 821             "MenuItem.alignAcceleratorText", Boolean.FALSE,
 822 
 823 
 824             "OptionPane.setButtonMargin", Boolean.FALSE,
 825             "OptionPane.sameSizeButtons", Boolean.TRUE,
 826             "OptionPane.buttonOrientation", SwingConstants.RIGHT,
 827             "OptionPane.minimumSize", new DimensionUIResource(262, 90),
 828             "OptionPane.buttonPadding", 10,
 829             "OptionPane.windowBindings", new Object[] {
 830                 "ESCAPE", "close" },
 831             "OptionPane.buttonClickThreshhold", 500,
 832             "OptionPane.isYesLast", Boolean.TRUE,
 833             "OptionPane.font", new FontLazyValue(Region.OPTION_PANE),
 834 
 835             "Panel.font", new FontLazyValue(Region.PANEL),
 836 
 837             "PasswordField.caretForeground", caretColor,
 838             "PasswordField.caretAspectRatio", defaultCaretAspectRatio,
 839             "PasswordField.caretBlinkRate", caretBlinkRate,
 840             "PasswordField.margin", zeroInsets,
 841             "PasswordField.focusInputMap", passwordInputMap,
 842             "PasswordField.font", new FontLazyValue(Region.PASSWORD_FIELD),
 843 
 844 
 845             "PopupMenu.consumeEventOnClose", Boolean.TRUE,
 846             "PopupMenu.selectedWindowInputMapBindings", new Object[] {
 847                   "ESCAPE", "cancel",
 848                     "DOWN", "selectNext",
 849                  "KP_DOWN", "selectNext",
 850                       "UP", "selectPrevious",
 851                    "KP_UP", "selectPrevious",
 852                     "LEFT", "selectParent",
 853                  "KP_LEFT", "selectParent",
 854                    "RIGHT", "selectChild",
 855                 "KP_RIGHT", "selectChild",
 856                    "ENTER", "return",
 857                    "SPACE", "return"
 858             },
 859             "PopupMenu.selectedWindowInputMapBindings.RightToLeft",
 860                   new Object[] {
 861                     "LEFT", "selectChild",
 862                  "KP_LEFT", "selectChild",
 863                    "RIGHT", "selectParent",
 864                 "KP_RIGHT", "selectParent",
 865             },
 866             "PopupMenu.font", new FontLazyValue(Region.POPUP_MENU),
 867 
 868             "ProgressBar.horizontalSize",
 869                 new DimensionUIResource(hProgWidth, hProgHeight),
 870             "ProgressBar.verticalSize",
 871                 new DimensionUIResource(vProgWidth, vProgHeight),
 872             "ProgressBar.font", new FontLazyValue(Region.PROGRESS_BAR),
 873 
 874             "RadioButton.focusInputMap",
 875                    new UIDefaults.LazyInputMap(new Object[] {
 876                             "SPACE", "pressed",
 877                    "released SPACE", "released",
 878                            "RETURN", "pressed"
 879                    }),
 880             "RadioButton.icon", new GTKStyle.GTKLazyValue(
 881                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",
 882                               "getRadioButtonIcon"),
 883             "RadioButton.font", new FontLazyValue(Region.RADIO_BUTTON),
 884             "RadioButton.margin", zeroInsets,
 885 
 886 
 887             "RadioButtonMenuItem.arrowIcon", null,
 888             "RadioButtonMenuItem.checkIcon", new GTKStyle.GTKLazyValue(
 889                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",
 890                               "getRadioButtonMenuItemCheckIcon"),
 891             "RadioButtonMenuItem.font", new FontLazyValue(Region.RADIO_BUTTON_MENU_ITEM),
 892             "RadioButtonMenuItem.margin", zeroInsets,
 893             "RadioButtonMenuItem.alignAcceleratorText", Boolean.FALSE,
 894 
 895 
 896             // These bindings are only enabled when there is a default
 897             // button set on the rootpane.
 898             "RootPane.defaultButtonWindowKeyBindings", new Object[] {
 899                                "ENTER", "press",
 900                       "released ENTER", "release",
 901                           "ctrl ENTER", "press",
 902                  "ctrl released ENTER", "release"
 903             },
 904 
 905 
 906             "ScrollBar.squareButtons", Boolean.FALSE,
 907             "ScrollBar.thumbHeight", Integer.valueOf(14),
 908             "ScrollBar.width", Integer.valueOf(16),
 909             "ScrollBar.minimumThumbSize", new Dimension(8, 8),
 910             "ScrollBar.maximumThumbSize", new Dimension(4096, 4096),
 911             "ScrollBar.allowsAbsolutePositioning", Boolean.TRUE,
 912             "ScrollBar.alwaysShowThumb", Boolean.TRUE,
 913             "ScrollBar.ancestorInputMap",
 914                    new UIDefaults.LazyInputMap(new Object[] {
 915                        "RIGHT", "positiveUnitIncrement",
 916                     "KP_RIGHT", "positiveUnitIncrement",
 917                         "DOWN", "positiveUnitIncrement",
 918                      "KP_DOWN", "positiveUnitIncrement",
 919                    "PAGE_DOWN", "positiveBlockIncrement",
 920                         "LEFT", "negativeUnitIncrement",
 921                      "KP_LEFT", "negativeUnitIncrement",
 922                           "UP", "negativeUnitIncrement",
 923                        "KP_UP", "negativeUnitIncrement",
 924                      "PAGE_UP", "negativeBlockIncrement",
 925                         "HOME", "minScroll",
 926                          "END", "maxScroll"
 927                    }),
 928             "ScrollBar.ancestorInputMap.RightToLeft",
 929                     new UIDefaults.LazyInputMap(new Object[] {
 930                        "RIGHT", "negativeUnitIncrement",
 931                     "KP_RIGHT", "negativeUnitIncrement",
 932                         "LEFT", "positiveUnitIncrement",
 933                      "KP_LEFT", "positiveUnitIncrement",
 934                     }),
 935 
 936 
 937             "Spinner.disableOnBoundaryValues", Boolean.TRUE,
 938 
 939 
 940             "ScrollPane.fillUpperCorner", Boolean.TRUE,
 941             "ScrollPane.fillLowerCorner", Boolean.TRUE,
 942             "ScrollPane.ancestorInputMap",
 943                     new UIDefaults.LazyInputMap(new Object[] {
 944                            "RIGHT", "unitScrollRight",
 945                         "KP_RIGHT", "unitScrollRight",
 946                             "DOWN", "unitScrollDown",
 947                          "KP_DOWN", "unitScrollDown",
 948                             "LEFT", "unitScrollLeft",
 949                          "KP_LEFT", "unitScrollLeft",
 950                               "UP", "unitScrollUp",
 951                            "KP_UP", "unitScrollUp",
 952                          "PAGE_UP", "scrollUp",
 953                        "PAGE_DOWN", "scrollDown",
 954                     "ctrl PAGE_UP", "scrollLeft",
 955                   "ctrl PAGE_DOWN", "scrollRight",
 956                        "ctrl HOME", "scrollHome",
 957                         "ctrl END", "scrollEnd"
 958                     }),
 959             "ScrollPane.ancestorInputMap.RightToLeft",
 960                     new UIDefaults.LazyInputMap(new Object[] {
 961                     "ctrl PAGE_UP", "scrollRight",
 962                   "ctrl PAGE_DOWN", "scrollLeft",
 963                     }),
 964             "ScrollPane.font", new FontLazyValue(Region.SCROLL_PANE),
 965 
 966 
 967             "Separator.insets", zeroInsets,
 968             "Separator.thickness", Integer.valueOf(2),
 969 
 970 
 971             "Slider.paintValue", Boolean.TRUE,
 972             "Slider.thumbWidth", Integer.valueOf(30),
 973             "Slider.thumbHeight", Integer.valueOf(14),
 974             "Slider.focusInputMap",
 975                     new UIDefaults.LazyInputMap(new Object[] {
 976                             "RIGHT", "positiveUnitIncrement",
 977                          "KP_RIGHT", "positiveUnitIncrement",
 978                              "DOWN", "negativeUnitIncrement",
 979                           "KP_DOWN", "negativeUnitIncrement",
 980                         "PAGE_DOWN", "negativeBlockIncrement",
 981                              "LEFT", "negativeUnitIncrement",
 982                           "KP_LEFT", "negativeUnitIncrement",
 983                                "UP", "positiveUnitIncrement",
 984                             "KP_UP", "positiveUnitIncrement",
 985                           "PAGE_UP", "positiveBlockIncrement",
 986                              "HOME", "minScroll",
 987                               "END", "maxScroll"
 988                         }),
 989             "Slider.focusInputMap.RightToLeft",
 990                     new UIDefaults.LazyInputMap(new Object[] {
 991                             "RIGHT", "negativeUnitIncrement",
 992                          "KP_RIGHT", "negativeUnitIncrement",
 993                              "LEFT", "positiveUnitIncrement",
 994                           "KP_LEFT", "positiveUnitIncrement",
 995                          }),
 996             "Slider.onlyLeftMouseButtonDrag", Boolean.FALSE,
 997 
 998             "Spinner.ancestorInputMap",
 999                new UIDefaults.LazyInputMap(new Object[] {
1000                                "UP", "increment",
1001                             "KP_UP", "increment",
1002                              "DOWN", "decrement",
1003                           "KP_DOWN", "decrement",
1004                }),
1005             "Spinner.font", new FontLazyValue(Region.SPINNER),
1006             "Spinner.editorAlignment", JTextField.LEADING,
1007 
1008             "SplitPane.ancestorInputMap",
1009                     new UIDefaults.LazyInputMap(new Object[] {
1010                         "UP", "negativeIncrement",
1011                       "DOWN", "positiveIncrement",
1012                       "LEFT", "negativeIncrement",
1013                      "RIGHT", "positiveIncrement",
1014                      "KP_UP", "negativeIncrement",
1015                    "KP_DOWN", "positiveIncrement",
1016                    "KP_LEFT", "negativeIncrement",
1017                   "KP_RIGHT", "positiveIncrement",
1018                       "HOME", "selectMin",
1019                        "END", "selectMax",
1020                         "F8", "startResize",
1021                         "F6", "toggleFocus",
1022                   "ctrl TAB", "focusOutForward",
1023             "ctrl shift TAB", "focusOutBackward"
1024                     }),
1025 
1026 
1027             "SplitPane.size", Integer.valueOf(7),
1028             "SplitPane.oneTouchOffset", Integer.valueOf(2),
1029             "SplitPane.oneTouchButtonSize", Integer.valueOf(5),
1030             "SplitPane.supportsOneTouchButtons", Boolean.FALSE,
1031 
1032 
1033             "TabbedPane.focusInputMap",
1034               new UIDefaults.LazyInputMap(new Object[] {
1035                          "RIGHT", "navigateRight",
1036                       "KP_RIGHT", "navigateRight",
1037                           "LEFT", "navigateLeft",
1038                        "KP_LEFT", "navigateLeft",
1039                             "UP", "navigateUp",
1040                          "KP_UP", "navigateUp",
1041                           "DOWN", "navigateDown",
1042                        "KP_DOWN", "navigateDown",
1043                      "ctrl DOWN", "requestFocusForVisibleComponent",
1044                   "ctrl KP_DOWN", "requestFocusForVisibleComponent",
1045                          "SPACE", "selectTabWithFocus"
1046                 }),
1047             "TabbedPane.ancestorInputMap",
1048                new UIDefaults.LazyInputMap(new Object[] {
1049                          "ctrl TAB", "navigateNext",
1050                    "ctrl shift TAB", "navigatePrevious",
1051                    "ctrl PAGE_DOWN", "navigatePageDown",
1052                      "ctrl PAGE_UP", "navigatePageUp",
1053                           "ctrl UP", "requestFocus",
1054                        "ctrl KP_UP", "requestFocus",
1055                  }),
1056 
1057             "TabbedPane.labelShift", 3,
1058             "TabbedPane.selectedLabelShift", 3,
1059             "TabbedPane.font", new FontLazyValue(Region.TABBED_PANE),
1060             "TabbedPane.selectedTabPadInsets", new InsetsUIResource(2, 2, 0, 1),
1061 
1062             "Table.scrollPaneBorder", zeroBorder,
1063             "Table.background", tableBg,
1064             "Table.focusCellBackground", tableFocusCellBg,
1065             "Table.focusCellForeground", tableFocusCellFg,
1066             "Table.focusCellHighlightBorder", focusBorder,
1067             "Table.focusSelectedCellHighlightBorder", focusSelectedBorder,
1068             "Table.ancestorInputMap",
1069                     new UIDefaults.LazyInputMap(new Object[] {
1070                                "ctrl C", "copy",
1071                                "ctrl V", "paste",
1072                                "ctrl X", "cut",
1073                                  "COPY", "copy",
1074                                 "PASTE", "paste",
1075                                   "CUT", "cut",
1076                        "control INSERT", "copy",
1077                          "shift INSERT", "paste",
1078                          "shift DELETE", "cut",
1079                                 "RIGHT", "selectNextColumn",
1080                              "KP_RIGHT", "selectNextColumn",
1081                           "shift RIGHT", "selectNextColumnExtendSelection",
1082                        "shift KP_RIGHT", "selectNextColumnExtendSelection",
1083                      "ctrl shift RIGHT", "selectNextColumnExtendSelection",
1084                   "ctrl shift KP_RIGHT", "selectNextColumnExtendSelection",
1085                            "ctrl RIGHT", "selectNextColumnChangeLead",
1086                         "ctrl KP_RIGHT", "selectNextColumnChangeLead",
1087                                  "LEFT", "selectPreviousColumn",
1088                               "KP_LEFT", "selectPreviousColumn",
1089                            "shift LEFT", "selectPreviousColumnExtendSelection",
1090                         "shift KP_LEFT", "selectPreviousColumnExtendSelection",
1091                       "ctrl shift LEFT", "selectPreviousColumnExtendSelection",
1092                    "ctrl shift KP_LEFT", "selectPreviousColumnExtendSelection",
1093                             "ctrl LEFT", "selectPreviousColumnChangeLead",
1094                          "ctrl KP_LEFT", "selectPreviousColumnChangeLead",
1095                                  "DOWN", "selectNextRow",
1096                               "KP_DOWN", "selectNextRow",
1097                            "shift DOWN", "selectNextRowExtendSelection",
1098                         "shift KP_DOWN", "selectNextRowExtendSelection",
1099                       "ctrl shift DOWN", "selectNextRowExtendSelection",
1100                    "ctrl shift KP_DOWN", "selectNextRowExtendSelection",
1101                             "ctrl DOWN", "selectNextRowChangeLead",
1102                          "ctrl KP_DOWN", "selectNextRowChangeLead",
1103                                    "UP", "selectPreviousRow",
1104                                 "KP_UP", "selectPreviousRow",
1105                              "shift UP", "selectPreviousRowExtendSelection",
1106                           "shift KP_UP", "selectPreviousRowExtendSelection",
1107                         "ctrl shift UP", "selectPreviousRowExtendSelection",
1108                      "ctrl shift KP_UP", "selectPreviousRowExtendSelection",
1109                               "ctrl UP", "selectPreviousRowChangeLead",
1110                            "ctrl KP_UP", "selectPreviousRowChangeLead",
1111                                  "HOME", "selectFirstColumn",
1112                            "shift HOME", "selectFirstColumnExtendSelection",
1113                       "ctrl shift HOME", "selectFirstRowExtendSelection",
1114                             "ctrl HOME", "selectFirstRow",
1115                                   "END", "selectLastColumn",
1116                             "shift END", "selectLastColumnExtendSelection",
1117                        "ctrl shift END", "selectLastRowExtendSelection",
1118                              "ctrl END", "selectLastRow",
1119                               "PAGE_UP", "scrollUpChangeSelection",
1120                         "shift PAGE_UP", "scrollUpExtendSelection",
1121                    "ctrl shift PAGE_UP", "scrollLeftExtendSelection",
1122                          "ctrl PAGE_UP", "scrollLeftChangeSelection",
1123                             "PAGE_DOWN", "scrollDownChangeSelection",
1124                       "shift PAGE_DOWN", "scrollDownExtendSelection",
1125                  "ctrl shift PAGE_DOWN", "scrollRightExtendSelection",
1126                        "ctrl PAGE_DOWN", "scrollRightChangeSelection",
1127                                   "TAB", "selectNextColumnCell",
1128                             "shift TAB", "selectPreviousColumnCell",
1129                                 "ENTER", "selectNextRowCell",
1130                           "shift ENTER", "selectPreviousRowCell",
1131                                "ctrl A", "selectAll",
1132                            "ctrl SLASH", "selectAll",
1133                       "ctrl BACK_SLASH", "clearSelection",
1134                                "ESCAPE", "cancel",
1135                                    "F2", "startEditing",
1136                                 "SPACE", "addToSelection",
1137                            "ctrl SPACE", "toggleAndAnchor",
1138                           "shift SPACE", "extendTo",
1139                      "ctrl shift SPACE", "moveSelectionTo",
1140                                    "F8", "focusHeader"
1141                     }),
1142             "Table.ancestorInputMap.RightToLeft",
1143                     new UIDefaults.LazyInputMap(new Object[] {
1144                                 "RIGHT", "selectPreviousColumn",
1145                              "KP_RIGHT", "selectPreviousColumn",
1146                           "shift RIGHT", "selectPreviousColumnExtendSelection",
1147                        "shift KP_RIGHT", "selectPreviousColumnExtendSelection",
1148                      "ctrl shift RIGHT", "selectPreviousColumnExtendSelection",
1149                   "ctrl shift KP_RIGHT", "selectPreviousColumnExtendSelection",
1150                           "shift RIGHT", "selectPreviousColumnChangeLead",
1151                        "shift KP_RIGHT", "selectPreviousColumnChangeLead",
1152                                  "LEFT", "selectNextColumn",
1153                               "KP_LEFT", "selectNextColumn",
1154                            "shift LEFT", "selectNextColumnExtendSelection",
1155                         "shift KP_LEFT", "selectNextColumnExtendSelection",
1156                       "ctrl shift LEFT", "selectNextColumnExtendSelection",
1157                    "ctrl shift KP_LEFT", "selectNextColumnExtendSelection",
1158                             "ctrl LEFT", "selectNextColumnChangeLead",
1159                          "ctrl KP_LEFT", "selectNextColumnChangeLead",
1160                          "ctrl PAGE_UP", "scrollRightChangeSelection",
1161                        "ctrl PAGE_DOWN", "scrollLeftChangeSelection",
1162                    "ctrl shift PAGE_UP", "scrollRightExtendSelection",
1163                  "ctrl shift PAGE_DOWN", "scrollLeftExtendSelection",
1164                     }),
1165             "Table.font", new FontLazyValue(Region.TABLE),
1166             "Table.ascendingSortIcon",  new GTKStyle.GTKLazyValue(
1167                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",
1168                               "getAscendingSortIcon"),
1169             "Table.descendingSortIcon",  new GTKStyle.GTKLazyValue(
1170                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",
1171                               "getDescendingSortIcon"),
1172 
1173             "TableHeader.font", new FontLazyValue(Region.TABLE_HEADER),
1174             "TableHeader.alignSorterArrow", Boolean.TRUE,
1175 
1176             "TextArea.caretForeground", caretColor,
1177             "TextArea.caretAspectRatio", defaultCaretAspectRatio,
1178             "TextArea.caretBlinkRate", caretBlinkRate,
1179             "TextArea.margin", zeroInsets,
1180             "TextArea.focusInputMap", multilineInputMap,
1181             "TextArea.font", new FontLazyValue(Region.TEXT_AREA),
1182 
1183 
1184             "TextField.caretForeground", caretColor,
1185             "TextField.caretAspectRatio", defaultCaretAspectRatio,
1186             "TextField.caretBlinkRate", caretBlinkRate,
1187             "TextField.margin", zeroInsets,
1188             "TextField.focusInputMap", fieldInputMap,
1189             "TextField.font", new FontLazyValue(Region.TEXT_FIELD),
1190 
1191 
1192             "TextPane.caretForeground", caretColor,
1193             "TextPane.caretAspectRatio", defaultCaretAspectRatio,
1194             "TextPane.caretBlinkRate", caretBlinkRate,
1195             "TextPane.margin", editorMargin,
1196             "TextPane.focusInputMap", multilineInputMap,
1197             "TextPane.font", new FontLazyValue(Region.TEXT_PANE),
1198 
1199 
1200             "TitledBorder.titleColor", controlText,
1201             "TitledBorder.border", new UIDefaults.LazyValue() {
1202                 public Object createValue(UIDefaults table) {
1203                     return new GTKPainter.TitledBorder();
1204                 }
1205             },
1206 
1207             "ToggleButton.focusInputMap",
1208                    new UIDefaults.LazyInputMap(new Object[] {
1209                             "SPACE", "pressed",
1210                    "released SPACE", "released"
1211                    }),
1212             "ToggleButton.font", new FontLazyValue(Region.TOGGLE_BUTTON),
1213             "ToggleButton.margin", zeroInsets,
1214 
1215 
1216             "ToolBar.separatorSize", new DimensionUIResource(10, 10),
1217             "ToolBar.handleIcon", new UIDefaults.ActiveValue() {
1218                 public Object createValue(UIDefaults table) {
1219                     return GTKIconFactory.getToolBarHandleIcon();
1220                 }
1221             },
1222             "ToolBar.ancestorInputMap",
1223                new UIDefaults.LazyInputMap(new Object[] {
1224                         "UP", "navigateUp",
1225                      "KP_UP", "navigateUp",
1226                       "DOWN", "navigateDown",
1227                    "KP_DOWN", "navigateDown",
1228                       "LEFT", "navigateLeft",
1229                    "KP_LEFT", "navigateLeft",
1230                      "RIGHT", "navigateRight",
1231                   "KP_RIGHT", "navigateRight"
1232                  }),
1233             "ToolBar.font", new FontLazyValue(Region.TOOL_BAR),
1234 
1235             "ToolTip.font", new FontLazyValue(Region.TOOL_TIP),
1236 
1237             "Tree.padding", Integer.valueOf(4),
1238             "Tree.background", tableBg,
1239             "Tree.drawHorizontalLines", Boolean.FALSE,
1240             "Tree.drawVerticalLines", Boolean.FALSE,
1241             "Tree.rowHeight", Integer.valueOf(-1),
1242             "Tree.scrollsOnExpand", Boolean.FALSE,
1243             "Tree.expanderSize", Integer.valueOf(10),
1244             "Tree.repaintWholeRow", Boolean.TRUE,
1245             "Tree.closedIcon", null,
1246             "Tree.leafIcon", null,
1247             "Tree.openIcon", null,
1248             "Tree.expandedIcon", new GTKStyle.GTKLazyValue(
1249                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",
1250                               "getTreeExpandedIcon"),
1251             "Tree.collapsedIcon", new GTKStyle.GTKLazyValue(
1252                               "com.sun.java.swing.plaf.gtk.GTKIconFactory",
1253                               "getTreeCollapsedIcon"),
1254             "Tree.leftChildIndent", Integer.valueOf(2),
1255             "Tree.rightChildIndent", Integer.valueOf(12),
1256             "Tree.scrollsHorizontallyAndVertically", Boolean.FALSE,
1257             "Tree.drawsFocusBorder", Boolean.TRUE,
1258             "Tree.focusInputMap",
1259                     new UIDefaults.LazyInputMap(new Object[] {
1260                                  "ctrl C", "copy",
1261                                  "ctrl V", "paste",
1262                                  "ctrl X", "cut",
1263                                    "COPY", "copy",
1264                                   "PASTE", "paste",
1265                                     "CUT", "cut",
1266                          "control INSERT", "copy",
1267                            "shift INSERT", "paste",
1268                            "shift DELETE", "cut",
1269                                      "UP", "selectPrevious",
1270                                   "KP_UP", "selectPrevious",
1271                                "shift UP", "selectPreviousExtendSelection",
1272                             "shift KP_UP", "selectPreviousExtendSelection",
1273                           "ctrl shift UP", "selectPreviousExtendSelection",
1274                        "ctrl shift KP_UP", "selectPreviousExtendSelection",
1275                                 "ctrl UP", "selectPreviousChangeLead",
1276                              "ctrl KP_UP", "selectPreviousChangeLead",
1277                                    "DOWN", "selectNext",
1278                                 "KP_DOWN", "selectNext",
1279                              "shift DOWN", "selectNextExtendSelection",
1280                           "shift KP_DOWN", "selectNextExtendSelection",
1281                         "ctrl shift DOWN", "selectNextExtendSelection",
1282                      "ctrl shift KP_DOWN", "selectNextExtendSelection",
1283                               "ctrl DOWN", "selectNextChangeLead",
1284                            "ctrl KP_DOWN", "selectNextChangeLead",
1285                                   "RIGHT", "selectChild",
1286                                "KP_RIGHT", "selectChild",
1287                                    "LEFT", "selectParent",
1288                                 "KP_LEFT", "selectParent",
1289                                 "typed +", "expand",
1290                                 "typed -", "collapse",
1291                              "BACK_SPACE", "moveSelectionToParent",
1292                                 "PAGE_UP", "scrollUpChangeSelection",
1293                           "shift PAGE_UP", "scrollUpExtendSelection",
1294                      "ctrl shift PAGE_UP", "scrollUpExtendSelection",
1295                            "ctrl PAGE_UP", "scrollUpChangeLead",
1296                               "PAGE_DOWN", "scrollDownChangeSelection",
1297                         "shift PAGE_DOWN", "scrollDownExtendSelection",
1298                    "ctrl shift PAGE_DOWN", "scrollDownExtendSelection",
1299                          "ctrl PAGE_DOWN", "scrollDownChangeLead",
1300                                    "HOME", "selectFirst",
1301                              "shift HOME", "selectFirstExtendSelection",
1302                         "ctrl shift HOME", "selectFirstExtendSelection",
1303                               "ctrl HOME", "selectFirstChangeLead",
1304                                     "END", "selectLast",
1305                               "shift END", "selectLastExtendSelection",
1306                          "ctrl shift END", "selectLastExtendSelection",
1307                                "ctrl END", "selectLastChangeLead",
1308                                      "F2", "startEditing",
1309                                  "ctrl A", "selectAll",
1310                              "ctrl SLASH", "selectAll",
1311                         "ctrl BACK_SLASH", "clearSelection",
1312                               "ctrl LEFT", "scrollLeft",
1313                            "ctrl KP_LEFT", "scrollLeft",
1314                              "ctrl RIGHT", "scrollRight",
1315                           "ctrl KP_RIGHT", "scrollRight",
1316                                   "SPACE", "addToSelection",
1317                              "ctrl SPACE", "toggleAndAnchor",
1318                             "shift SPACE", "extendTo",
1319                        "ctrl shift SPACE", "moveSelectionTo"
1320                     }),
1321             "Tree.focusInputMap.RightToLeft",
1322                     new UIDefaults.LazyInputMap(new Object[] {
1323                                   "RIGHT", "selectParent",
1324                                "KP_RIGHT", "selectParent",
1325                                    "LEFT", "selectChild",
1326                                 "KP_LEFT", "selectChild",
1327                  }),
1328             "Tree.ancestorInputMap",
1329                       new UIDefaults.LazyInputMap(new Object[] {
1330                          "ESCAPE", "cancel"
1331                       }),
1332             "Tree.font", new FontLazyValue(Region.TREE),
1333 
1334             "Viewport.font", new FontLazyValue(Region.VIEWPORT)
1335         };
1336         table.putDefaults(defaults);
1337 
1338         if (fallbackFont != null) {
1339             table.put("TitledBorder.font", fallbackFont);
1340         }
1341         if (aaTextInfo != null) {
1342             table.putAll(aaTextInfo);
1343         }
1344     }
1345 
1346     protected void initSystemColorDefaults(UIDefaults table) {
1347         GTKStyleFactory factory = (GTKStyleFactory)getStyleFactory();
1348         GTKStyle windowStyle =
1349                 (GTKStyle)factory.getStyle(null, Region.INTERNAL_FRAME);
1350         table.put("window", windowStyle.getGTKColor(SynthConstants.ENABLED,
1351                 GTKColorType.BACKGROUND));
1352         table.put("windowText", windowStyle.getGTKColor(SynthConstants.ENABLED,
1353                 GTKColorType.TEXT_FOREGROUND));
1354 
1355         GTKStyle entryStyle = (GTKStyle)factory.getStyle(null, Region.TEXT_FIELD);
1356         table.put("text", entryStyle.getGTKColor(SynthConstants.ENABLED,
1357                                            GTKColorType.TEXT_BACKGROUND));
1358         table.put("textText", entryStyle.getGTKColor(SynthConstants.ENABLED,
1359                                            GTKColorType.TEXT_FOREGROUND));
1360         table.put("textHighlight",
1361                 entryStyle.getGTKColor(SynthConstants.SELECTED,
1362                                          GTKColorType.TEXT_BACKGROUND));
1363         table.put("textHighlightText",
1364                   entryStyle.getGTKColor(SynthConstants.SELECTED,
1365                                          GTKColorType.TEXT_FOREGROUND));
1366         table.put("textInactiveText",
1367                   entryStyle.getGTKColor(SynthConstants.DISABLED,
1368                                          GTKColorType.TEXT_FOREGROUND));
1369         Object caretColor =
1370             entryStyle.getClassSpecificValue("cursor-color");
1371         if (caretColor == null) {
1372             caretColor = GTKStyle.BLACK_COLOR;
1373         }
1374         table.put("caretColor", caretColor);
1375 
1376         GTKStyle menuStyle = (GTKStyle)factory.getStyle(null, Region.MENU_ITEM);
1377         table.put("menu", menuStyle.getGTKColor(SynthConstants.ENABLED,
1378                                            GTKColorType.BACKGROUND));
1379         table.put("menuText", menuStyle.getGTKColor(SynthConstants.ENABLED,
1380                                            GTKColorType.TEXT_FOREGROUND));
1381 
1382         GTKStyle scrollbarStyle = (GTKStyle)factory.getStyle(null, Region.SCROLL_BAR);
1383         table.put("scrollbar", scrollbarStyle.getGTKColor(SynthConstants.ENABLED,
1384                                            GTKColorType.BACKGROUND));
1385 
1386         GTKStyle infoStyle = (GTKStyle)factory.getStyle(null, Region.OPTION_PANE);
1387         table.put("info", infoStyle.getGTKColor(SynthConstants.ENABLED,
1388                                            GTKColorType.BACKGROUND));
1389         table.put("infoText", infoStyle.getGTKColor(SynthConstants.ENABLED,
1390                                            GTKColorType.TEXT_FOREGROUND));
1391 
1392         GTKStyle desktopStyle = (GTKStyle)factory.getStyle(null, Region.DESKTOP_PANE);
1393         table.put("desktop", desktopStyle.getGTKColor(SynthConstants.ENABLED,
1394                                            GTKColorType.BACKGROUND));
1395 
1396         // colors specific only for GTK
1397         // It is impossible to create a simple GtkWidget without specifying the
1398         // type. So for GtkWidget we can use any appropriate concrete type of
1399         // wigdet. LABEL in this case.
1400         GTKStyle widgetStyle = (GTKStyle)factory.getStyle(null, Region.LABEL);
1401         Color bg = widgetStyle.getGTKColor(SynthConstants.ENABLED,
1402                                            GTKColorType.BACKGROUND);
1403         table.put("control", bg);
1404         table.put("controlHighlight", bg);
1405         table.put("controlText", widgetStyle.getGTKColor(SynthConstants.ENABLED,
1406                                                GTKColorType.TEXT_FOREGROUND));
1407         table.put("controlLtHighlight", widgetStyle.getGTKColor(
1408                 SynthConstants.ENABLED, GTKColorType.LIGHT));
1409         table.put("controlShadow", widgetStyle.getGTKColor(
1410                 SynthConstants.ENABLED, GTKColorType.DARK));
1411         table.put("controlDkShadow", widgetStyle.getGTKColor(
1412                 SynthConstants.ENABLED, GTKColorType.BLACK));
1413         table.put("light", widgetStyle.getGTKColor(
1414                 SynthConstants.ENABLED, GTKColorType.LIGHT));
1415         table.put("mid", widgetStyle.getGTKColor(
1416                 SynthConstants.ENABLED, GTKColorType.MID));
1417         table.put("dark", widgetStyle.getGTKColor(
1418                 SynthConstants.ENABLED, GTKColorType.DARK));
1419         table.put("black", widgetStyle.getGTKColor(
1420                 SynthConstants.ENABLED, GTKColorType.BLACK));
1421         table.put("white", widgetStyle.getGTKColor(
1422                 SynthConstants.ENABLED, GTKColorType.WHITE));
1423     }
1424 
1425     /**
1426      * Creates the GTK look and feel class for the passed in Component.
1427      */
1428     public static ComponentUI createUI(JComponent c) {
1429         String key = c.getUIClassID().intern();
1430 
1431         if (key == "FileChooserUI") {
1432             return GTKFileChooserUI.createUI(c);
1433         }
1434         return SynthLookAndFeel.createUI(c);
1435     }
1436 
1437     /**
1438      * Returns the cached gtkThemeName
1439      */
1440     static String getGtkThemeName() {
1441         return gtkThemeName;
1442     }
1443 
1444     static boolean isLeftToRight(Component c) {
1445         return c.getComponentOrientation().isLeftToRight();
1446     }
1447 
1448     public void initialize() {
1449         /*
1450          * We need to call loadGTK() to ensure that the native GTK
1451          * libraries are loaded.  It is very unlikely that this call will
1452          * fail (since we've already verified native GTK support in
1453          * isSupportedLookAndFeel()), but we can throw an error in the
1454          * failure situation just in case.
1455          */
1456         Toolkit toolkit = Toolkit.getDefaultToolkit();
1457         if (toolkit instanceof UNIXToolkit &&
1458             !((UNIXToolkit)toolkit).loadGTK())
1459         {
1460             throw new InternalError("Unable to load native GTK libraries");
1461         }
1462 
1463         super.initialize();
1464         inInitialize = true;
1465         loadStyles();
1466         inInitialize = false;
1467 
1468         /*
1469          * Check if system AA font settings should be used.
1470          * Sun's JDS (for Linux and Solaris) ships with high quality CJK
1471          * fonts and specifies via fontconfig that these be rendered in
1472          * B&W to take advantage of the embedded bitmaps.
1473          * If is a Sun CJK locale or remote display, indicate by the condition
1474          * variable that in this case the L&F recommends ignoring desktop
1475          * settings. On other Unixes (eg Linux) this doesn't apply.
1476          * REMIND 1: The isSunCJK test is really just a place holder
1477          * until we can properly query fontconfig and use the properties
1478          * set for specific fonts.
1479          * REMIND 2: See comment on isLocalDisplay() definition regarding
1480          * XRender.
1481          */
1482         gtkAAFontSettingsCond = !isSunCJK && SwingUtilities2.isLocalDisplay();
1483         aaTextInfo = new HashMap<>(2);
1484         SwingUtilities2.putAATextInfo(gtkAAFontSettingsCond, aaTextInfo);
1485     }
1486 
1487     static ReferenceQueue<GTKLookAndFeel> queue = new ReferenceQueue<GTKLookAndFeel>();
1488 
1489     private static void flushUnreferenced() {
1490         WeakPCL pcl;
1491 
1492         while ((pcl = (WeakPCL)queue.poll()) != null) {
1493             pcl.dispose();
1494         }
1495     }
1496 
1497     static class WeakPCL extends WeakReference<GTKLookAndFeel> implements
1498             PropertyChangeListener {
1499         private Toolkit kit;
1500         private String key;
1501 
1502         WeakPCL(GTKLookAndFeel target, Toolkit kit, String key) {
1503             super(target, queue);
1504             this.kit = kit;
1505             this.key = key;
1506         }
1507 
1508         public String getKey() { return key; }
1509 
1510         public void propertyChange(final PropertyChangeEvent pce) {
1511             final GTKLookAndFeel lnf = get();
1512 
1513             if (lnf == null || UIManager.getLookAndFeel() != lnf) {
1514                 // The property was GC'ed, we're no longer interested in
1515                 // PropertyChanges, remove the listener.
1516                 dispose();
1517             }
1518             else {
1519                 // We are using invokeLater here because we are getting called
1520                 // on the AWT-Motif thread which can cause a deadlock.
1521                 SwingUtilities.invokeLater(new Runnable() {
1522                     public void run() {
1523                         String name = pce.getPropertyName();
1524                         /* We are listening for GTK desktop text AA settings:
1525                          * "gnome.Xft/Antialias" and "gnome.Xft/RGBA".
1526                          * However we don't need to read these here as
1527                          * the UIDefaults reads them and this event causes
1528                          * those to be reinitialised.
1529                          */
1530                         if ("gnome.Net/ThemeName".equals(name)) {
1531                             GTKEngine.INSTANCE.themeChanged();
1532                             GTKIconFactory.resetIcons();
1533                         }
1534                         lnf.loadStyles();
1535                         Window appWindows[] = Window.getWindows();
1536                         for (int i = 0; i < appWindows.length; i++) {
1537                             SynthLookAndFeel.updateStyles(appWindows[i]);
1538                         }
1539                     }
1540                 });
1541             }
1542         }
1543 
1544         void dispose() {
1545             kit.removePropertyChangeListener(key, this);
1546         }
1547     }
1548 
1549     public boolean isSupportedLookAndFeel() {
1550         Toolkit toolkit = Toolkit.getDefaultToolkit();
1551         return (toolkit instanceof SunToolkit &&
1552                 ((SunToolkit)toolkit).isNativeGTKAvailable());
1553     }
1554 
1555     public boolean isNativeLookAndFeel() {
1556         return true;
1557     }
1558 
1559     public String getDescription() {
1560         return "GTK look and feel";
1561     }
1562 
1563     public String getName() {
1564         return "GTK look and feel";
1565     }
1566 
1567     public String getID() {
1568         return "GTK";
1569     }
1570 
1571     // Subclassed to pass in false to the superclass, we don't want to try
1572     // and load the system colors.
1573     protected void loadSystemColors(UIDefaults table, String[] systemColors, boolean useNative) {
1574         super.loadSystemColors(table, systemColors, false);
1575     }
1576 
1577     private void loadStyles() {
1578         gtkThemeName = (String)Toolkit.getDefaultToolkit().
1579                 getDesktopProperty("gnome.Net/ThemeName");
1580 
1581         setStyleFactory(getGTKStyleFactory());
1582 
1583         // If we are in initialize initializations will be
1584         // called later, don't do it now.
1585         if (!inInitialize) {
1586             UIDefaults table = UIManager.getLookAndFeelDefaults();
1587             initSystemColorDefaults(table);
1588             initComponentDefaults(table);
1589         }
1590     }
1591 
1592     private GTKStyleFactory getGTKStyleFactory() {
1593 
1594         GTKEngine engine = GTKEngine.INSTANCE;
1595         Object iconSizes = engine.getSetting(GTKEngine.Settings.GTK_ICON_SIZES);
1596         if (iconSizes instanceof String) {
1597             if (!configIconSizes((String)iconSizes)) {
1598                 System.err.println("Error parsing gtk-icon-sizes string: '" + iconSizes + "'");
1599             }
1600         }
1601 
1602         // Desktop property appears to have preference over rc font.
1603         Object fontName = Toolkit.getDefaultToolkit().getDesktopProperty(
1604                                   "gnome.Gtk/FontName");
1605 
1606        if (!(fontName instanceof String)) {
1607             fontName = engine.getSetting(GTKEngine.Settings.GTK_FONT_NAME);
1608             if (!(fontName instanceof String)) {
1609                fontName = "sans 10";
1610             }
1611         }
1612 
1613         if (styleFactory == null) {
1614             styleFactory = new GTKStyleFactory();
1615         }
1616 
1617         Font defaultFont = PangoFonts.lookupFont((String)fontName);
1618         fallbackFont = defaultFont;
1619         styleFactory.initStyles(defaultFont);
1620 
1621         return styleFactory;
1622     }
1623 
1624     private boolean configIconSizes(String sizeString) {
1625         String[] sizes = sizeString.split(":");
1626         for (int i = 0; i < sizes.length; i++) {
1627             String[] splits = sizes[i].split("=");
1628 
1629             if (splits.length != 2) {
1630                 return false;
1631             }
1632 
1633             String size = splits[0].trim().intern();
1634             if (size.length() < 1) {
1635                 return false;
1636             }
1637 
1638             splits = splits[1].split(",");
1639 
1640             if (splits.length != 2) {
1641                 return false;
1642             }
1643 
1644             String width = splits[0].trim();
1645             String height = splits[1].trim();
1646 
1647             if (width.length() < 1 || height.length() < 1) {
1648                 return false;
1649             }
1650 
1651             int w;
1652             int h;
1653 
1654             try {
1655                 w = Integer.parseInt(width);
1656                 h = Integer.parseInt(height);
1657             } catch (NumberFormatException nfe) {
1658                 return false;
1659             }
1660 
1661             if (w > 0 && h > 0) {
1662                 int type = GTKStyle.GTKStockIconInfo.getIconType(size);
1663                 GTKStyle.GTKStockIconInfo.setIconSize(type, w, h);
1664             } else {
1665                 System.err.println("Invalid size in gtk-icon-sizes: " + w + "," + h);
1666             }
1667         }
1668 
1669         return true;
1670     }
1671 
1672     /**
1673      * Returns whether or not the UIs should update their
1674      * {@code SynthStyles} from the {@code SynthStyleFactory}
1675      * when the ancestor of the Component changes.
1676      *
1677      * @return whether or not the UIs should update their
1678      * {@code SynthStyles} from the {@code SynthStyleFactory}
1679      * when the ancestor changed.
1680      */
1681     public boolean shouldUpdateStyleOnAncestorChanged() {
1682         return true;
1683     }
1684 
1685     /**
1686      * {@inheritDoc}
1687      */
1688     public LayoutStyle getLayoutStyle() {
1689         return GnomeLayoutStyle.INSTANCE;
1690     }
1691 
1692 
1693     /**
1694      * Gnome layout style.  From:
1695      * http://developer.gnome.org/projects/gup/hig/2.0/design-window.html#window-layout-spacing
1696      * You'll notice this doesn't do the radiobutton/checkbox border
1697      * adjustments that windows/metal do.  This is because gtk doesn't
1698      * provide margins/insets for checkbox/radiobuttons.
1699      */
1700     @SuppressWarnings("fallthrough")
1701     private static class GnomeLayoutStyle extends DefaultLayoutStyle {
1702         private static GnomeLayoutStyle INSTANCE = new GnomeLayoutStyle();
1703 
1704         @Override
1705         public int getPreferredGap(JComponent component1,
1706                 JComponent component2, ComponentPlacement type, int position,
1707                 Container parent) {
1708             // Checks args
1709             super.getPreferredGap(component1, component2, type, position,
1710                                   parent);
1711 
1712             switch(type) {
1713             case INDENT:
1714                 if (position == SwingConstants.EAST ||
1715                         position == SwingConstants.WEST) {
1716                     // Indent group members 12 pixels to denote hierarchy and
1717                     // association.
1718                     return 12;
1719                 }
1720                 // Fall through to related
1721             // As a basic rule of thumb, leave space between user
1722             // interface components in increments of 6 pixels, going up as
1723             // the relationship between related elements becomes more
1724             // distant. For example, between icon labels and associated
1725             // graphics within an icon, 6 pixels are adequate. Between
1726             // labels and associated components, leave 12 horizontal
1727             // pixels. For vertical spacing between groups of components,
1728             // 18 pixels is adequate.
1729             //
1730             // The first part of this is handled automatically by Icon (which
1731             // won't give you 6 pixels).
1732             case RELATED:
1733                 if (isLabelAndNonlabel(component1, component2, position)) {
1734                     return 12;
1735                 }
1736                 return 6;
1737             case UNRELATED:
1738                 return 12;
1739             }
1740             return 0;
1741         }
1742 
1743         @Override
1744         public int getContainerGap(JComponent component, int position,
1745                                    Container parent) {
1746             // Checks args
1747             super.getContainerGap(component, position, parent);
1748             // A general padding of 12 pixels is
1749             // recommended between the contents of a dialog window and the
1750             // window borders.
1751             return 12;
1752         }
1753     }
1754 }
--- EOF ---