GNU Classpath (0.20) | |
Frames | No Frames |
1: /* Toolkit.java -- AWT Toolkit superclass 2: Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 3: Free Software Foundation, Inc. 4: 5: This file is part of GNU Classpath. 6: 7: GNU Classpath is free software; you can redistribute it and/or modify 8: it under the terms of the GNU General Public License as published by 9: the Free Software Foundation; either version 2, or (at your option) 10: any later version. 11: 12: GNU Classpath is distributed in the hope that it will be useful, but 13: WITHOUT ANY WARRANTY; without even the implied warranty of 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15: General Public License for more details. 16: 17: You should have received a copy of the GNU General Public License 18: along with GNU Classpath; see the file COPYING. If not, write to the 19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 20: 02110-1301 USA. 21: 22: Linking this library statically or dynamically with other modules is 23: making a combined work based on this library. Thus, the terms and 24: conditions of the GNU General Public License cover the whole 25: combination. 26: 27: As a special exception, the copyright holders of this library give you 28: permission to link this library with independent modules to produce an 29: executable, regardless of the license terms of these independent 30: modules, and to copy and distribute the resulting executable under 31: terms of your choice, provided that you also meet, for each linked 32: independent module, the terms and conditions of the license of that 33: module. An independent module is a module which is not derived from 34: or based on this library. If you modify this library, you may extend 35: this exception to your version of the library, but you are not 36: obligated to do so. If you do not wish to do so, delete this 37: exception statement from your version. */ 38: 39: 40: package java.awt; 41: 42: import java.awt.datatransfer.Clipboard; 43: import java.awt.dnd.DragGestureEvent; 44: import java.awt.dnd.DragGestureListener; 45: import java.awt.dnd.DragGestureRecognizer; 46: import java.awt.dnd.DragSource; 47: import java.awt.dnd.peer.DragSourceContextPeer; 48: import java.awt.event.AWTEventListener; 49: import java.awt.event.KeyEvent; 50: import java.awt.im.InputMethodHighlight; 51: import java.awt.image.ColorModel; 52: import java.awt.image.ImageObserver; 53: import java.awt.image.ImageProducer; 54: import java.awt.peer.ButtonPeer; 55: import java.awt.peer.CanvasPeer; 56: import java.awt.peer.CheckboxMenuItemPeer; 57: import java.awt.peer.CheckboxPeer; 58: import java.awt.peer.ChoicePeer; 59: import java.awt.peer.DialogPeer; 60: import java.awt.peer.FileDialogPeer; 61: import java.awt.peer.FontPeer; 62: import java.awt.peer.FramePeer; 63: import java.awt.peer.LabelPeer; 64: import java.awt.peer.LightweightPeer; 65: import java.awt.peer.ListPeer; 66: import java.awt.peer.MenuBarPeer; 67: import java.awt.peer.MenuItemPeer; 68: import java.awt.peer.MenuPeer; 69: import java.awt.peer.PanelPeer; 70: import java.awt.peer.PopupMenuPeer; 71: import java.awt.peer.ScrollPanePeer; 72: import java.awt.peer.ScrollbarPeer; 73: import java.awt.peer.TextAreaPeer; 74: import java.awt.peer.TextFieldPeer; 75: import java.awt.peer.WindowPeer; 76: import java.beans.PropertyChangeListener; 77: import java.beans.PropertyChangeSupport; 78: import java.net.URL; 79: import java.util.Map; 80: import java.util.Properties; 81: 82: /** 83: * The AWT system uses a set of native peer objects to implement its 84: * widgets. These peers are provided by a peer toolkit, that is accessed 85: * via a subclass of this superclass. The system toolkit is retrieved 86: * by the static methods <code>getDefaultToolkit</code>. This method 87: * determines the system toolkit by examining the system property 88: * <code>awt.toolkit</code>. That property is set to the name of the 89: * <code>Toolkit</code> subclass for the specified peer set. If the 90: * <code>awt.toolkit</code> property is not set, then the default 91: * toolkit <code>gnu.java.awt.peer.gtk.GtkToolkit</code> is used. This 92: * toolkit creates its peers using the GTK+ toolkit. 93: * 94: * @author Aaron M. Renn (arenn@urbanophile.com) 95: */ 96: public abstract class Toolkit 97: { 98: /** The default toolkit name. */ 99: private static String default_toolkit_name 100: = gnu.classpath.Configuration.default_awt_peer_toolkit; 101: 102: /** 103: * The toolkit in use. Once we load it, we don't ever change it 104: * if the awt.toolkit property is set. 105: */ 106: private static Toolkit toolkit; 107: 108: /** The toolkit properties. */ 109: private static Properties props = new Properties(); 110: 111: protected final Map desktopProperties = new Properties(); 112: 113: protected final PropertyChangeSupport desktopPropsSupport 114: = new PropertyChangeSupport(this); 115: 116: /** 117: * Default constructor for subclasses. 118: */ 119: public Toolkit() 120: { 121: } 122: 123: /** 124: * Creates a peer object for the specified <code>Button</code>. 125: * 126: * @param target The <code>Button</code> to create the peer for. 127: * 128: * @return The peer for the specified <code>Button</code> object. 129: * 130: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 131: */ 132: protected abstract ButtonPeer createButton(Button target); 133: 134: /** 135: * Creates a peer object for the specified <code>TextField</code>. 136: * 137: * @param target The <code>TextField</code> to create the peer for. 138: * 139: * @return The peer for the specified <code>TextField</code> object. 140: * 141: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 142: */ 143: protected abstract TextFieldPeer createTextField(TextField target); 144: 145: /** 146: * Creates a peer object for the specified <code>Label</code>. 147: * 148: * @param target The <code>Label</code> to create the peer for. 149: * 150: * @return The peer for the specified <code>Label</code> object. 151: * 152: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 153: */ 154: protected abstract LabelPeer createLabel(Label target); 155: 156: /** 157: * Creates a peer object for the specified <code>List</code>. 158: * 159: * @param target The <code>List</code> to create the peer for. 160: * 161: * @return The peer for the specified <code>List</code> object. 162: * 163: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 164: */ 165: protected abstract ListPeer createList(List target); 166: 167: /** 168: * Creates a peer object for the specified <code>Checkbox</code>. 169: * 170: * @param target The <code>Checkbox</code> to create the peer for. 171: * 172: * @return The peer for the specified <code>Checkbox</code> object. 173: * 174: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 175: */ 176: protected abstract CheckboxPeer createCheckbox(Checkbox target); 177: 178: /** 179: * Creates a peer object for the specified <code>Scrollbar</code>. 180: * 181: * @param target The <code>Scrollbar</code> to create the peer for. 182: * 183: * @return The peer for the specified <code>Scrollbar</code> object. 184: * 185: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 186: */ 187: protected abstract ScrollbarPeer createScrollbar(Scrollbar target); 188: 189: /** 190: * Creates a peer object for the specified <code>ScrollPane</code>. 191: * 192: * @param target The <code>ScrollPane</code> to create the peer for. 193: * 194: * @return The peer for the specified <code>ScrollPane</code> object. 195: * 196: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 197: */ 198: protected abstract ScrollPanePeer createScrollPane(ScrollPane target); 199: 200: /** 201: * Creates a peer object for the specified <code>TextArea</code>. 202: * 203: * @param target The <code>TextArea</code> to create the peer for. 204: * 205: * @return The peer for the specified <code>TextArea</code> object. 206: * 207: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 208: */ 209: protected abstract TextAreaPeer createTextArea(TextArea target); 210: 211: /** 212: * Creates a peer object for the specified <code>Choice</code>. 213: * 214: * @param target The <code>Choice</code> to create the peer for. 215: * 216: * @return The peer for the specified <code>Choice</code> object. 217: * 218: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 219: */ 220: protected abstract ChoicePeer createChoice(Choice target); 221: 222: /** 223: * Creates a peer object for the specified <code>Frame</code>. 224: * 225: * @param target The <code>Frame</code> to create the peer for. 226: * 227: * @return The peer for the specified <code>Frame</code> object. 228: * 229: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 230: */ 231: protected abstract FramePeer createFrame(Frame target); 232: 233: /** 234: * Creates a peer object for the specified <code>Canvas</code>. 235: * 236: * @param target The <code>Canvas</code> to create the peer for. 237: * 238: * @return The peer for the specified <code>Canvas</code> object. 239: */ 240: protected abstract CanvasPeer createCanvas(Canvas target); 241: 242: /** 243: * Creates a peer object for the specified <code>Panel</code>. 244: * 245: * @param target The <code>Panel</code> to create the peer for. 246: * 247: * @return The peer for the specified <code>Panel</code> object. 248: */ 249: protected abstract PanelPeer createPanel(Panel target); 250: 251: /** 252: * Creates a peer object for the specified <code>Window</code>. 253: * 254: * @param target The <code>Window</code> to create the peer for. 255: * 256: * @return The peer for the specified <code>Window</code> object. 257: * 258: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 259: */ 260: protected abstract WindowPeer createWindow(Window target); 261: 262: /** 263: * Creates a peer object for the specified <code>Dialog</code>. 264: * 265: * @param target The dialog to create the peer for 266: * 267: * @return The peer for the specified font name. 268: * 269: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 270: */ 271: protected abstract DialogPeer createDialog(Dialog target); 272: 273: /** 274: * Creates a peer object for the specified <code>MenuBar</code>. 275: * 276: * @param target The <code>MenuBar</code> to create the peer for. 277: * 278: * @return The peer for the specified <code>MenuBar</code> object. 279: * 280: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 281: */ 282: protected abstract MenuBarPeer createMenuBar(MenuBar target); 283: 284: /** 285: * Creates a peer object for the specified <code>Menu</code>. 286: * 287: * @param target The <code>Menu</code> to create the peer for. 288: * 289: * @return The peer for the specified <code>Menu</code> object. 290: * 291: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 292: */ 293: protected abstract MenuPeer createMenu(Menu target); 294: 295: /** 296: * Creates a peer object for the specified <code>PopupMenu</code>. 297: * 298: * @param target The <code>PopupMenu</code> to create the peer for. 299: * 300: * @return The peer for the specified <code>PopupMenu</code> object. 301: * 302: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 303: */ 304: protected abstract PopupMenuPeer createPopupMenu(PopupMenu target); 305: 306: /** 307: * Creates a peer object for the specified <code>MenuItem</code>. 308: * 309: * @param target The <code>MenuItem</code> to create the peer for. 310: * 311: * @return The peer for the specified <code>MenuItem</code> object. 312: * 313: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 314: */ 315: protected abstract MenuItemPeer createMenuItem(MenuItem target); 316: 317: /** 318: * Creates a peer object for the specified <code>FileDialog</code>. 319: * 320: * @param target The <code>FileDialog</code> to create the peer for. 321: * 322: * @return The peer for the specified <code>FileDialog</code> object. 323: * 324: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 325: */ 326: protected abstract FileDialogPeer createFileDialog(FileDialog target); 327: 328: /** 329: * Creates a peer object for the specified <code>CheckboxMenuItem</code>. 330: * 331: * @param target The <code>CheckboxMenuItem</code> to create the peer for. 332: * 333: * @return The peer for the specified <code>CheckboxMenuItem</code> object. 334: * 335: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 336: */ 337: protected abstract CheckboxMenuItemPeer 338: createCheckboxMenuItem(CheckboxMenuItem target); 339: 340: /** 341: * Creates a peer object for the specified <code>Component</code>. The 342: * peer returned by this method is not a native windowing system peer 343: * with its own native window. Instead, this method allows the component 344: * to draw on its parent window as a "lightweight" widget. 345: * 346: * @param target The <code>Component</code> to create the peer for. 347: * 348: * @return The peer for the specified <code>Component</code> object. 349: */ 350: protected LightweightPeer createComponent(Component target) 351: { 352: return new gnu.java.awt.peer.GLightweightPeer (target); 353: } 354: 355: /** 356: * Creates a peer object for the specified font name. 357: * 358: * @param name The font to create the peer for. 359: * @param style The font style to create the peer for. 360: * 361: * @return The peer for the specified font name. 362: * 363: * @deprecated 364: */ 365: protected abstract FontPeer getFontPeer(String name, int style); 366: 367: /** 368: * Copies the current system colors into the specified array. This is 369: * the interface used by the <code>SystemColor</code> class. Although 370: * this method fills in the array with some default colors a real Toolkit 371: * should override this method and provide real system colors for the 372: * native GUI platform. 373: * 374: * @param systemColors The array to copy the system colors into. 375: * It must be at least 26 elements. 376: * 377: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 378: * 379: * @see java.awt.SystemColor 380: */ 381: protected void loadSystemColors(int systemColors[]) 382: { 383: systemColors[SystemColor.DESKTOP] = 0xFF005C5C; 384: systemColors[SystemColor.ACTIVE_CAPTION] = 0xFF000080; 385: systemColors[SystemColor.ACTIVE_CAPTION_TEXT] = 0xFFFFFFFF; 386: systemColors[SystemColor.ACTIVE_CAPTION_BORDER] = 0xFFC0C0C0; 387: systemColors[SystemColor.INACTIVE_CAPTION] = 0xFF808080; 388: systemColors[SystemColor.INACTIVE_CAPTION_TEXT] = 0xFFC0C0C0; 389: systemColors[SystemColor.INACTIVE_CAPTION_BORDER] = 0xFFC0C0C0; 390: systemColors[SystemColor.WINDOW] = 0xFFFFFFFF; 391: systemColors[SystemColor.WINDOW_BORDER] = 0xFF000000; 392: systemColors[SystemColor.WINDOW_TEXT] = 0xFF000000; 393: systemColors[SystemColor.MENU] = 0xFFC0C0C0; 394: systemColors[SystemColor.MENU_TEXT] = 0xFF000000; 395: systemColors[SystemColor.TEXT] = 0xFFC0C0C0; 396: systemColors[SystemColor.TEXT_TEXT] = 0xFF000000; 397: systemColors[SystemColor.TEXT_HIGHLIGHT] = 0xFF000090; 398: systemColors[SystemColor.TEXT_HIGHLIGHT_TEXT] = 0xFFFFFFFF; 399: systemColors[SystemColor.TEXT_INACTIVE_TEXT] = 0xFF808080; 400: systemColors[SystemColor.CONTROL] = 0xFFC0C0C0; 401: systemColors[SystemColor.CONTROL_TEXT] = 0xFF000000; 402: systemColors[SystemColor.CONTROL_HIGHLIGHT] = 0xFFFFFFFF; 403: systemColors[SystemColor.CONTROL_LT_HIGHLIGHT] = 0xFFE0E0E0; 404: systemColors[SystemColor.CONTROL_SHADOW] = 0xFF808080; 405: systemColors[SystemColor.CONTROL_DK_SHADOW] = 0xFF000000; 406: systemColors[SystemColor.SCROLLBAR] = 0xFFE0E0E0; 407: systemColors[SystemColor.INFO] = 0xFFE0E000; 408: systemColors[SystemColor.INFO_TEXT] = 0xFF000000; 409: } 410: 411: /** 412: * @since 1.4 413: * 414: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 415: */ 416: public void setDynamicLayout(boolean dynamic) 417: { 418: } 419: 420: /** 421: * @since 1.4 422: * 423: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 424: */ 425: protected boolean isDynamicLayoutSet() 426: { 427: return false; 428: } 429: 430: /** 431: * @since 1.4 432: * 433: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 434: */ 435: public boolean isDynamicLayoutActive() 436: { 437: return false; 438: } 439: 440: /** 441: * Returns the dimensions of the screen in pixels. 442: * 443: * @return The dimensions of the screen in pixels. 444: * 445: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 446: */ 447: public abstract Dimension getScreenSize(); 448: 449: /** 450: * Returns the screen resolution in dots per square inch. 451: * 452: * @return The screen resolution in dots per square inch. 453: * 454: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 455: */ 456: public abstract int getScreenResolution(); 457: 458: /** 459: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 460: * 461: * @since 1.4 462: */ 463: public Insets getScreenInsets(GraphicsConfiguration gc) 464: { 465: return null; 466: } 467: 468: /** 469: * Returns the color model of the screen. 470: * 471: * @return The color model of the screen. 472: * 473: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 474: */ 475: public abstract ColorModel getColorModel(); 476: 477: /** 478: * Returns the names of the available fonts. 479: * 480: * @return The names of the available fonts. 481: * 482: * @deprecated 483: */ 484: public abstract String[] getFontList(); 485: 486: /** 487: * Return the font metrics for the specified font 488: * 489: * @param name The name of the font to return metrics for. 490: * 491: * @return The requested font metrics. 492: * 493: * @deprecated 494: */ 495: public abstract FontMetrics getFontMetrics(Font name); 496: 497: /** 498: * Flushes any buffered data to the screen so that it is in sync with 499: * what the AWT system has drawn to it. 500: */ 501: public abstract void sync(); 502: 503: /** 504: * Returns an instance of the default toolkit. The default toolkit is 505: * the subclass of <code>Toolkit</code> specified in the system property 506: * <code>awt.toolkit</code>, or <code>gnu.java.awt.peer.gtk.GtkToolkit</code> 507: * if the property is not set. 508: * 509: * @return An instance of the system default toolkit. 510: * 511: * @throws AWTError If the toolkit cannot be loaded. 512: */ 513: public static Toolkit getDefaultToolkit() 514: { 515: if (toolkit != null) 516: return toolkit; 517: String toolkit_name = System.getProperty("awt.toolkit", 518: default_toolkit_name); 519: try 520: { 521: Class cls = Class.forName(toolkit_name); 522: Object obj = cls.newInstance(); 523: if (!(obj instanceof Toolkit)) 524: throw new AWTError(toolkit_name + " is not a subclass of " + 525: "java.awt.Toolkit"); 526: toolkit = (Toolkit) obj; 527: return toolkit; 528: } 529: catch (ThreadDeath death) 530: { 531: throw death; 532: } 533: catch (Throwable t) 534: { 535: AWTError e = new AWTError("Cannot load AWT toolkit: " + toolkit_name); 536: throw (AWTError) e.initCause(t); 537: } 538: } 539: 540: /** 541: * Returns an image from the specified file, which must be in a 542: * recognized format. Supported formats vary from toolkit to toolkit. 543: * 544: * @return name The name of the file to read the image from. 545: */ 546: public abstract Image getImage(String name); 547: 548: /** 549: * Returns an image from the specified URL, which must be in a 550: * recognized format. Supported formats vary from toolkit to toolkit. 551: * 552: * @return url The URl to read the image from. 553: */ 554: public abstract Image getImage(URL url); 555: 556: public abstract Image createImage(String filename); 557: 558: public abstract Image createImage(URL url); 559: 560: /** 561: * Readies an image to be rendered on the screen. The width and height 562: * values can be set to the default sizes for the image by passing -1 563: * in those parameters. 564: * 565: * @param image The image to prepare for rendering. 566: * @param width The width of the image. 567: * @param height The height of the image. 568: * @param observer The observer to receive events about the preparation 569: * process. 570: * 571: * @return <code>true</code> if the image is already prepared for rendering, 572: * <code>false</code> otherwise. 573: */ 574: public abstract boolean prepareImage(Image image, int width, int height, 575: ImageObserver observer); 576: 577: /** 578: * Checks the status of specified image as it is being readied for 579: * rendering. 580: * 581: * @param image The image to prepare for rendering. 582: * @param width The width of the image. 583: * @param height The height of the image. 584: * @param observer The observer to receive events about the preparation 585: * process. 586: * 587: * @return A union of the bitmasks from 588: * <code>java.awt.image.ImageObserver</code> that indicates the current 589: * state of the imaging readying process. 590: */ 591: public abstract int checkImage(Image image, int width, int height, 592: ImageObserver observer); 593: 594: /** 595: * Creates an image using the specified <code>ImageProducer</code> 596: * 597: * @param producer The <code>ImageProducer</code> to create the image from. 598: * 599: * @return The created image. 600: */ 601: public abstract Image createImage(ImageProducer producer); 602: 603: /** 604: * Creates an image from the specified byte array. The array must be in 605: * a recognized format. Supported formats vary from toolkit to toolkit. 606: * 607: * @param data The raw image data. 608: * 609: * @return The created image. 610: */ 611: public Image createImage(byte[] data) 612: { 613: return createImage(data, 0, data.length); 614: } 615: 616: /** 617: * Creates an image from the specified portion of the byte array passed. 618: * The array must be in a recognized format. Supported formats vary from 619: * toolkit to toolkit. 620: * 621: * @param data The raw image data. 622: * @param offset The offset into the data where the image data starts. 623: * @param len The length of the image data. 624: * 625: * @return The created image. 626: */ 627: public abstract Image createImage(byte[] data, int offset, int len); 628: 629: /** 630: * Returns a instance of <code>PrintJob</code> for the specified 631: * arguments. 632: * 633: * @param frame The window initiating the print job. 634: * @param title The print job title. 635: * @param props The print job properties. 636: * 637: * @return The requested print job, or <code>null</code> if the job 638: * was cancelled. 639: * 640: * @exception NullPointerException If frame is null, 641: * or GraphicsEnvironment.isHeadless() returns true. 642: * @exception SecurityException If this thread is not allowed to initiate 643: * a print job request. 644: */ 645: public abstract PrintJob getPrintJob(Frame frame, String title, 646: Properties props); 647: 648: /** 649: * Returns a instance of <code>PrintJob</code> for the specified 650: * arguments. 651: * 652: * @param frame The window initiating the print job. 653: * @param title The print job title. 654: * @param jobAttr A set of job attributes which will control the print job. 655: * @param pageAttr A set of page attributes which will control the print job. 656: * 657: * @exception NullPointerException If frame is null, and either jobAttr is null 658: * or jobAttr.getDialog() returns JobAttributes.DialogType.NATIVE. 659: * @exception IllegalArgumentException If pageAttrspecifies differing cross 660: * feed and feed resolutions, or when GraphicsEnvironment.isHeadless() returns 661: * true. 662: * @exception SecurityException If this thread is not allowed to initiate 663: * a print job request. 664: * 665: * @since 1.3 666: */ 667: public PrintJob getPrintJob(Frame frame, String title, 668: JobAttributes jobAttr, PageAttributes pageAttr) 669: { 670: return null; 671: } 672: 673: /** 674: * Causes a "beep" tone to be generated. 675: */ 676: public abstract void beep(); 677: 678: /** 679: * Returns the system clipboard. 680: * 681: * @return THe system clipboard. 682: * 683: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 684: */ 685: public abstract Clipboard getSystemClipboard(); 686: 687: /** 688: * Gets the singleton instance of the system selection as a Clipboard object. 689: * 690: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 691: * 692: * @since 1.4 693: */ 694: public Clipboard getSystemSelection() 695: { 696: return null; 697: } 698: 699: /** 700: * Returns the accelerator key mask for menu shortcuts. The default is 701: * <code>Event.CTRL_MASK</code>. A toolkit must override this method 702: * to change the default. 703: * 704: * @return The key mask for the menu accelerator key. 705: * 706: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 707: */ 708: public int getMenuShortcutKeyMask() 709: { 710: return Event.CTRL_MASK; 711: } 712: 713: /** 714: * Returns whether the given locking key on the keyboard is currently in its 715: * "on" state. 716: * 717: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 718: * @exception IllegalArgumentException If keyCode is not one of the valid keys. 719: * @exception UnsupportedOperationException If the host system doesn't allow 720: * getting the state of this key programmatically, or if the keyboard doesn't 721: * have this key. 722: */ 723: public boolean getLockingKeyState(int keyCode) 724: { 725: if (keyCode != KeyEvent.VK_CAPS_LOCK 726: && keyCode != KeyEvent.VK_NUM_LOCK 727: && keyCode != KeyEvent.VK_SCROLL_LOCK) 728: throw new IllegalArgumentException(); 729: 730: throw new UnsupportedOperationException(); 731: } 732: 733: /** 734: * Sets the state of the given locking key on the keyboard. 735: * 736: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 737: * @exception IllegalArgumentException If keyCode is not one of the valid keys. 738: * @exception UnsupportedOperationException If the host system doesn't allow 739: * getting the state of this key programmatically, or if the keyboard doesn't 740: * have this key. 741: */ 742: public void setLockingKeyState(int keyCode, boolean on) 743: { 744: if (keyCode != KeyEvent.VK_CAPS_LOCK 745: && keyCode != KeyEvent.VK_NUM_LOCK 746: && keyCode != KeyEvent.VK_SCROLL_LOCK) 747: throw new IllegalArgumentException(); 748: 749: throw new UnsupportedOperationException(); 750: } 751: 752: /** 753: * Returns the native container object of the specified component. This 754: * method is necessary because the parent component might be a lightweight 755: * component. 756: * 757: * @param component The component to fetch the native container for. 758: * 759: * @return The native container object for this component. 760: */ 761: protected static Container getNativeContainer(Component component) 762: { 763: component = component.getParent(); 764: while (true) 765: { 766: if (component == null) 767: return null; 768: if (! (component instanceof Container)) 769: { 770: component = component.getParent(); 771: continue; 772: } 773: if (component.getPeer() instanceof LightweightPeer) 774: { 775: component = component.getParent(); 776: continue; 777: } 778: return (Container) component; 779: } 780: } 781: 782: /** 783: * Creates a new custom cursor object. 784: * 785: * @exception IndexOutOfBoundsException If the hotSpot values are outside 786: * the bounds of the cursor. 787: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 788: */ 789: public Cursor createCustomCursor(Image cursor, Point hotSpot, String name) 790: { 791: // Presumably the only reason this isn't abstract is for backwards 792: // compatibility? FIXME? 793: if (GraphicsEnvironment.isHeadless()) 794: throw new HeadlessException("No custom cursor in an headless graphics " 795: + "environment."); 796: return null; 797: } 798: 799: /** 800: * Returns the supported cursor dimension which is closest to the 801: * desired sizes. 802: * 803: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 804: */ 805: public Dimension getBestCursorSize(int preferredWidth, int preferredHeight) 806: { 807: if (GraphicsEnvironment.isHeadless()) 808: throw new HeadlessException("No best cursor size in an headless " 809: + "graphics environment."); 810: return new Dimension (0,0); 811: } 812: 813: /** 814: * Returns the maximum number of colors the Toolkit supports in a custom 815: * cursor palette. 816: * 817: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 818: */ 819: public int getMaximumCursorColors() 820: { 821: return 0; 822: } 823: 824: /** 825: * Returns whether Toolkit supports this state for Frames. 826: * 827: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 828: * 829: * @since 1.4 830: */ 831: public boolean isFrameStateSupported(int state) 832: { 833: return false; 834: } 835: 836: /** 837: * Returns the value of the property with the specified name, or the 838: * default value if the property does not exist. 839: * 840: * @param key The name of the property to retrieve. 841: * @param def The default value of the property. 842: */ 843: public static String getProperty(String key, String def) 844: { 845: return props.getProperty(key, def); 846: } 847: 848: 849: /** 850: * Returns the event queue that is suitable for the calling context. 851: * 852: * <p>Despite the word “System” in the name of this 853: * method, a toolkit may provide different event queues for each 854: * applet. There is no guarantee that the same queue is shared 855: * system-wide. 856: * 857: * <p>The implementation first checks whether a 858: * SecurityManager has been installed. If so, its {@link 859: * java.lang.SecurityManager#checkAwtEventQueueAccess()} method gets 860: * called. The security manager will throw a SecurityException if it 861: * does not grant the permission to access the event queue. 862: * 863: * <p>Next, the call is delegated to {@link 864: * #getSystemEventQueueImpl()}. 865: * 866: * @return The event queue for this applet (or application). 867: * 868: * @throws SecurityException if a security manager has been 869: * installed, and it does not grant the permission to access the 870: * event queue. 871: */ 872: public final EventQueue getSystemEventQueue() 873: { 874: SecurityManager sm; 875: 876: sm = System.getSecurityManager(); 877: if (sm != null) 878: sm.checkAwtEventQueueAccess(); 879: 880: return getSystemEventQueueImpl(); 881: } 882: 883: 884: /** 885: * Returns the event queue that is suitable for the calling context. 886: * 887: * <p>Despite the word “System” in the name of this 888: * method, a toolkit may provide different event queues for each 889: * applet. There is no guarantee that the same queue is shared 890: * system-wide. 891: * 892: * <p>No security checks are performed, which is why this method 893: * may only be called by Toolkits. 894: * 895: * @see #getSystemEventQueue() 896: */ 897: protected abstract EventQueue getSystemEventQueueImpl(); 898: 899: 900: /** 901: * @since 1.3 902: */ 903: public abstract DragSourceContextPeer 904: createDragSourceContextPeer(DragGestureEvent e); 905: 906: /** 907: * @since 1.3 908: */ 909: public DragGestureRecognizer 910: createDragGestureRecognizer(Class recognizer, DragSource ds, 911: Component comp, int actions, 912: DragGestureListener l) 913: { 914: return null; 915: } 916: 917: public final Object getDesktopProperty(String propertyName) 918: { 919: return desktopProperties.get(propertyName); 920: } 921: 922: protected final void setDesktopProperty(String name, Object newValue) 923: { 924: Object oldValue = getDesktopProperty(name); 925: desktopProperties.put(name, newValue); 926: desktopPropsSupport.firePropertyChange(name, oldValue, newValue); 927: } 928: 929: protected Object lazilyLoadDesktopProperty(String name) 930: { 931: // FIXME - what is this?? 932: return null; 933: } 934: 935: protected void initializeDesktopProperties() 936: { 937: // Overridden by toolkit implementation? 938: } 939: 940: public void addPropertyChangeListener(String name, 941: PropertyChangeListener pcl) 942: { 943: desktopPropsSupport.addPropertyChangeListener(name, pcl); 944: } 945: 946: public void removePropertyChangeListener(String name, 947: PropertyChangeListener pcl) 948: { 949: desktopPropsSupport.removePropertyChangeListener(name, pcl); 950: } 951: 952: /** 953: * @since 1.4 954: */ 955: public PropertyChangeListener[] getPropertyChangeListeners() 956: { 957: return desktopPropsSupport.getPropertyChangeListeners(); 958: } 959: 960: /** 961: * @since 1.4 962: */ 963: public PropertyChangeListener[] getPropertyChangeListeners(String name) 964: { 965: return desktopPropsSupport.getPropertyChangeListeners(name); 966: } 967: 968: public void addAWTEventListener(AWTEventListener listener, long eventMask) 969: { 970: // SecurityManager s = System.getSecurityManager(); 971: // if (s != null) 972: // s.checkPermission(AWTPermission("listenToAllAWTEvents")); 973: // FIXME 974: } 975: 976: public void removeAWTEventListener(AWTEventListener listener) 977: { 978: // FIXME 979: } 980: 981: /** 982: * @since 1.4 983: */ 984: public AWTEventListener[] getAWTEventListeners() 985: { 986: return null; 987: } 988: 989: /** 990: * @since 1.4 991: */ 992: public AWTEventListener[] getAWTEventListeners(long mask) 993: { 994: return null; 995: } 996: 997: /** 998: * @since 1.3 999: */ 1000: public abstract Map mapInputMethodHighlight(InputMethodHighlight highlight); 1001: } // class Toolkit
GNU Classpath (0.20) |