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</code> 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</code> from the <code>SynthStyleFactory</code> 1675 * when the ancestor of the Component changes. 1676 * 1677 * @return whether or not the UIs should update their 1678 * <code>SynthStyles</code> from the <code>SynthStyleFactory</code> 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 }