| GNU Classpath (0.95) | |
| Frames | No Frames |
1: /* Toolkit.java -- AWT Toolkit superclass 2: Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 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 gnu.classpath.SystemProperties; 43: import gnu.java.awt.AWTUtilities; 44: import gnu.java.awt.peer.GLightweightPeer; 45: import gnu.java.awt.peer.headless.HeadlessToolkit; 46: 47: import java.awt.datatransfer.Clipboard; 48: import java.awt.dnd.DragGestureEvent; 49: import java.awt.dnd.DragGestureListener; 50: import java.awt.dnd.DragGestureRecognizer; 51: import java.awt.dnd.DragSource; 52: import java.awt.dnd.peer.DragSourceContextPeer; 53: import java.awt.event.AWTEventListener; 54: import java.awt.event.AWTEventListenerProxy; 55: import java.awt.event.KeyEvent; 56: import java.awt.font.TextAttribute; 57: import java.awt.im.InputMethodHighlight; 58: import java.awt.image.ColorModel; 59: import java.awt.image.ImageObserver; 60: import java.awt.image.ImageProducer; 61: import java.awt.peer.ButtonPeer; 62: import java.awt.peer.CanvasPeer; 63: import java.awt.peer.CheckboxMenuItemPeer; 64: import java.awt.peer.CheckboxPeer; 65: import java.awt.peer.ChoicePeer; 66: import java.awt.peer.DesktopPeer; 67: import java.awt.peer.DialogPeer; 68: import java.awt.peer.FileDialogPeer; 69: import java.awt.peer.FontPeer; 70: import java.awt.peer.FramePeer; 71: import java.awt.peer.LabelPeer; 72: import java.awt.peer.LightweightPeer; 73: import java.awt.peer.ListPeer; 74: import java.awt.peer.MenuBarPeer; 75: import java.awt.peer.MenuItemPeer; 76: import java.awt.peer.MenuPeer; 77: import java.awt.peer.MouseInfoPeer; 78: import java.awt.peer.PanelPeer; 79: import java.awt.peer.PopupMenuPeer; 80: import java.awt.peer.ScrollPanePeer; 81: import java.awt.peer.ScrollbarPeer; 82: import java.awt.peer.TextAreaPeer; 83: import java.awt.peer.TextFieldPeer; 84: import java.awt.peer.WindowPeer; 85: import java.beans.PropertyChangeListener; 86: import java.beans.PropertyChangeSupport; 87: import java.io.File; 88: import java.io.FileInputStream; 89: import java.net.URL; 90: import java.security.AccessController; 91: import java.security.PrivilegedAction; 92: import java.util.ArrayList; 93: import java.util.Hashtable; 94: import java.util.Map; 95: import java.util.Properties; 96: import java.util.StringTokenizer; 97: 98: /** 99: * The AWT system uses a set of native peer objects to implement its 100: * widgets. These peers are provided by a peer toolkit, that is accessed 101: * via a subclass of this superclass. The system toolkit is retrieved 102: * by the static methods <code>getDefaultToolkit</code>. This method 103: * determines the system toolkit by examining the system property 104: * <code>awt.toolkit</code>. That property is set to the name of the 105: * <code>Toolkit</code> subclass for the specified peer set. If the 106: * <code>awt.toolkit</code> property is not set, then the default 107: * toolkit <code>gnu.java.awt.peer.gtk.GtkToolkit</code> is used. This 108: * toolkit creates its peers using the GTK+ toolkit. 109: * 110: * @author Aaron M. Renn (arenn@urbanophile.com) 111: */ 112: public abstract class Toolkit 113: { 114: /** The default toolkit name. */ 115: private static String default_toolkit_name 116: = gnu.classpath.Configuration.default_awt_peer_toolkit; 117: 118: /** 119: * The toolkit in use. Once we load it, we don't ever change it 120: * if the awt.toolkit property is set. 121: */ 122: private static Toolkit toolkit; 123: 124: /** The toolkit properties. */ 125: private static Properties props = new Properties(); 126: 127: protected final Map<String,Object> desktopProperties = 128: new Hashtable<String,Object>(); 129: 130: protected final PropertyChangeSupport desktopPropsSupport 131: = new PropertyChangeSupport(this); 132: 133: /** 134: * All registered AWTEventListener objects. This is package private, so the 135: * event queue can efficiently access this list. 136: */ 137: AWTEventListenerProxy[] awtEventListeners; 138: 139: /** 140: * The shared peer for all lightweight components. 141: */ 142: private GLightweightPeer lightweightPeer; 143: 144: /** 145: * Default constructor for subclasses. 146: */ 147: public Toolkit() 148: { 149: awtEventListeners = new AWTEventListenerProxy[0]; 150: } 151: 152: /** 153: * 154: * @param target 155: * @return 156: * @throws HeadlessException 157: */ 158: protected abstract DesktopPeer createDesktopPeer(Desktop target) 159: throws HeadlessException; 160: 161: /** 162: * Creates a peer object for the specified <code>Button</code>. 163: * 164: * @param target The <code>Button</code> to create the peer for. 165: * 166: * @return The peer for the specified <code>Button</code> object. 167: * 168: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 169: */ 170: protected abstract ButtonPeer createButton(Button target); 171: 172: /** 173: * Creates a peer object for the specified <code>TextField</code>. 174: * 175: * @param target The <code>TextField</code> to create the peer for. 176: * 177: * @return The peer for the specified <code>TextField</code> object. 178: * 179: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 180: */ 181: protected abstract TextFieldPeer createTextField(TextField target); 182: 183: /** 184: * Creates a peer object for the specified <code>Label</code>. 185: * 186: * @param target The <code>Label</code> to create the peer for. 187: * 188: * @return The peer for the specified <code>Label</code> object. 189: * 190: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 191: */ 192: protected abstract LabelPeer createLabel(Label target); 193: 194: /** 195: * Creates a peer object for the specified <code>List</code>. 196: * 197: * @param target The <code>List</code> to create the peer for. 198: * 199: * @return The peer for the specified <code>List</code> object. 200: * 201: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 202: */ 203: protected abstract ListPeer createList(List target); 204: 205: /** 206: * Creates a peer object for the specified <code>Checkbox</code>. 207: * 208: * @param target The <code>Checkbox</code> to create the peer for. 209: * 210: * @return The peer for the specified <code>Checkbox</code> object. 211: * 212: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 213: */ 214: protected abstract CheckboxPeer createCheckbox(Checkbox target); 215: 216: /** 217: * Creates a peer object for the specified <code>Scrollbar</code>. 218: * 219: * @param target The <code>Scrollbar</code> to create the peer for. 220: * 221: * @return The peer for the specified <code>Scrollbar</code> object. 222: * 223: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 224: */ 225: protected abstract ScrollbarPeer createScrollbar(Scrollbar target); 226: 227: /** 228: * Creates a peer object for the specified <code>ScrollPane</code>. 229: * 230: * @param target The <code>ScrollPane</code> to create the peer for. 231: * 232: * @return The peer for the specified <code>ScrollPane</code> object. 233: * 234: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 235: */ 236: protected abstract ScrollPanePeer createScrollPane(ScrollPane target); 237: 238: /** 239: * Creates a peer object for the specified <code>TextArea</code>. 240: * 241: * @param target The <code>TextArea</code> to create the peer for. 242: * 243: * @return The peer for the specified <code>TextArea</code> object. 244: * 245: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 246: */ 247: protected abstract TextAreaPeer createTextArea(TextArea target); 248: 249: /** 250: * Creates a peer object for the specified <code>Choice</code>. 251: * 252: * @param target The <code>Choice</code> to create the peer for. 253: * 254: * @return The peer for the specified <code>Choice</code> object. 255: * 256: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 257: */ 258: protected abstract ChoicePeer createChoice(Choice target); 259: 260: /** 261: * Creates a peer object for the specified <code>Frame</code>. 262: * 263: * @param target The <code>Frame</code> to create the peer for. 264: * 265: * @return The peer for the specified <code>Frame</code> object. 266: * 267: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 268: */ 269: protected abstract FramePeer createFrame(Frame target); 270: 271: /** 272: * Creates a peer object for the specified <code>Canvas</code>. 273: * 274: * @param target The <code>Canvas</code> to create the peer for. 275: * 276: * @return The peer for the specified <code>Canvas</code> object. 277: */ 278: protected abstract CanvasPeer createCanvas(Canvas target); 279: 280: /** 281: * Creates a peer object for the specified <code>Panel</code>. 282: * 283: * @param target The <code>Panel</code> to create the peer for. 284: * 285: * @return The peer for the specified <code>Panel</code> object. 286: */ 287: protected abstract PanelPeer createPanel(Panel target); 288: 289: /** 290: * Creates a peer object for the specified <code>Window</code>. 291: * 292: * @param target The <code>Window</code> to create the peer for. 293: * 294: * @return The peer for the specified <code>Window</code> object. 295: * 296: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 297: */ 298: protected abstract WindowPeer createWindow(Window target); 299: 300: /** 301: * Creates a peer object for the specified <code>Dialog</code>. 302: * 303: * @param target The dialog to create the peer for 304: * 305: * @return The peer for the specified font name. 306: * 307: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 308: */ 309: protected abstract DialogPeer createDialog(Dialog target); 310: 311: /** 312: * Creates a peer object for the specified <code>MenuBar</code>. 313: * 314: * @param target The <code>MenuBar</code> to create the peer for. 315: * 316: * @return The peer for the specified <code>MenuBar</code> object. 317: * 318: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 319: */ 320: protected abstract MenuBarPeer createMenuBar(MenuBar target); 321: 322: /** 323: * Creates a peer object for the specified <code>Menu</code>. 324: * 325: * @param target The <code>Menu</code> to create the peer for. 326: * 327: * @return The peer for the specified <code>Menu</code> object. 328: * 329: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 330: */ 331: protected abstract MenuPeer createMenu(Menu target); 332: 333: /** 334: * Creates a peer object for the specified <code>PopupMenu</code>. 335: * 336: * @param target The <code>PopupMenu</code> to create the peer for. 337: * 338: * @return The peer for the specified <code>PopupMenu</code> object. 339: * 340: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 341: */ 342: protected abstract PopupMenuPeer createPopupMenu(PopupMenu target); 343: 344: /** 345: * Creates a peer object for the specified <code>MenuItem</code>. 346: * 347: * @param target The <code>MenuItem</code> to create the peer for. 348: * 349: * @return The peer for the specified <code>MenuItem</code> object. 350: * 351: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 352: */ 353: protected abstract MenuItemPeer createMenuItem(MenuItem target); 354: 355: /** 356: * Returns a MouseInfoPeer. 357: * The default implementation of this method throws 358: * UnsupportedOperationException. 359: * 360: * Toolkit implementations should overload this if possible, however. 361: */ 362: protected MouseInfoPeer getMouseInfoPeer() 363: { 364: throw new UnsupportedOperationException("No mouse info peer."); 365: } 366: 367: /** 368: * Creates a peer object for the specified <code>FileDialog</code>. 369: * 370: * @param target The <code>FileDialog</code> to create the peer for. 371: * 372: * @return The peer for the specified <code>FileDialog</code> object. 373: * 374: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 375: */ 376: protected abstract FileDialogPeer createFileDialog(FileDialog target); 377: 378: /** 379: * Creates a peer object for the specified <code>CheckboxMenuItem</code>. 380: * 381: * @param target The <code>CheckboxMenuItem</code> to create the peer for. 382: * 383: * @return The peer for the specified <code>CheckboxMenuItem</code> object. 384: * 385: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 386: */ 387: protected abstract CheckboxMenuItemPeer 388: createCheckboxMenuItem(CheckboxMenuItem target); 389: 390: /** 391: * Creates a peer object for the specified <code>Component</code>. The 392: * peer returned by this method is not a native windowing system peer 393: * with its own native window. Instead, this method allows the component 394: * to draw on its parent window as a "lightweight" widget. 395: * 396: * @param target The <code>Component</code> to create the peer for. 397: * 398: * @return The peer for the specified <code>Component</code> object. 399: */ 400: protected LightweightPeer createComponent(Component target) 401: { 402: if (lightweightPeer == null) 403: lightweightPeer = new GLightweightPeer(); 404: return lightweightPeer; 405: } 406: 407: /** 408: * Creates a peer object for the specified font name. 409: * 410: * @param name The font to create the peer for. 411: * @param style The font style to create the peer for. 412: * 413: * @return The peer for the specified font name. 414: * 415: * @deprecated 416: */ 417: protected abstract FontPeer getFontPeer(String name, int style); 418: 419: /** 420: * Copies the current system colors into the specified array. This is 421: * the interface used by the <code>SystemColor</code> class. Although 422: * this method fills in the array with some default colors a real Toolkit 423: * should override this method and provide real system colors for the 424: * native GUI platform. 425: * 426: * @param systemColors The array to copy the system colors into. 427: * It must be at least 26 elements. 428: * 429: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 430: * 431: * @see java.awt.SystemColor 432: */ 433: protected void loadSystemColors(int systemColors[]) 434: { 435: systemColors[SystemColor.DESKTOP] = 0xFF005C5C; 436: systemColors[SystemColor.ACTIVE_CAPTION] = 0xFF000080; 437: systemColors[SystemColor.ACTIVE_CAPTION_TEXT] = 0xFFFFFFFF; 438: systemColors[SystemColor.ACTIVE_CAPTION_BORDER] = 0xFFC0C0C0; 439: systemColors[SystemColor.INACTIVE_CAPTION] = 0xFF808080; 440: systemColors[SystemColor.INACTIVE_CAPTION_TEXT] = 0xFFC0C0C0; 441: systemColors[SystemColor.INACTIVE_CAPTION_BORDER] = 0xFFC0C0C0; 442: systemColors[SystemColor.WINDOW] = 0xFFFFFFFF; 443: systemColors[SystemColor.WINDOW_BORDER] = 0xFF000000; 444: systemColors[SystemColor.WINDOW_TEXT] = 0xFF000000; 445: systemColors[SystemColor.MENU] = 0xFFC0C0C0; 446: systemColors[SystemColor.MENU_TEXT] = 0xFF000000; 447: systemColors[SystemColor.TEXT] = 0xFFC0C0C0; 448: systemColors[SystemColor.TEXT_TEXT] = 0xFF000000; 449: systemColors[SystemColor.TEXT_HIGHLIGHT] = 0xFF000090; 450: systemColors[SystemColor.TEXT_HIGHLIGHT_TEXT] = 0xFFFFFFFF; 451: systemColors[SystemColor.TEXT_INACTIVE_TEXT] = 0xFF808080; 452: systemColors[SystemColor.CONTROL] = 0xFFC0C0C0; 453: systemColors[SystemColor.CONTROL_TEXT] = 0xFF000000; 454: systemColors[SystemColor.CONTROL_HIGHLIGHT] = 0xFFFFFFFF; 455: systemColors[SystemColor.CONTROL_LT_HIGHLIGHT] = 0xFFE0E0E0; 456: systemColors[SystemColor.CONTROL_SHADOW] = 0xFF808080; 457: systemColors[SystemColor.CONTROL_DK_SHADOW] = 0xFF000000; 458: systemColors[SystemColor.SCROLLBAR] = 0xFFE0E0E0; 459: systemColors[SystemColor.INFO] = 0xFFE0E000; 460: systemColors[SystemColor.INFO_TEXT] = 0xFF000000; 461: } 462: 463: /** 464: * @since 1.4 465: * 466: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 467: */ 468: public void setDynamicLayout(boolean dynamic) 469: { 470: } 471: 472: /** 473: * @since 1.4 474: * 475: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 476: */ 477: protected boolean isDynamicLayoutSet() 478: { 479: return false; 480: } 481: 482: /** 483: * @since 1.4 484: * 485: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 486: */ 487: public boolean isDynamicLayoutActive() 488: { 489: return false; 490: } 491: 492: /** 493: * Returns the dimensions of the screen in pixels. 494: * 495: * @return The dimensions of the screen in pixels. 496: * 497: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 498: */ 499: public abstract Dimension getScreenSize(); 500: 501: /** 502: * Returns the screen resolution in dots per square inch. 503: * 504: * @return The screen resolution in dots per square inch. 505: * 506: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 507: */ 508: public abstract int getScreenResolution(); 509: 510: /** 511: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 512: * 513: * @since 1.4 514: */ 515: public Insets getScreenInsets(GraphicsConfiguration gc) 516: { 517: return new Insets(0, 0, 0, 0); 518: } 519: 520: /** 521: * Returns the color model of the screen. 522: * 523: * @return The color model of the screen. 524: * 525: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 526: */ 527: public abstract ColorModel getColorModel(); 528: 529: /** 530: * Returns the names of the available fonts. 531: * 532: * @return The names of the available fonts. 533: * 534: * @deprecated 535: */ 536: public abstract String[] getFontList(); 537: 538: /** 539: * Return the font metrics for the specified font 540: * 541: * @param name The name of the font to return metrics for. 542: * 543: * @return The requested font metrics. 544: * 545: * @deprecated 546: */ 547: public abstract FontMetrics getFontMetrics(Font name); 548: 549: /** 550: * Flushes any buffered data to the screen so that it is in sync with 551: * what the AWT system has drawn to it. 552: */ 553: public abstract void sync(); 554: 555: /** 556: * Returns an instance of the default toolkit. The default toolkit is 557: * the subclass of <code>Toolkit</code> specified in the system property 558: * <code>awt.toolkit</code>, or <code>gnu.java.awt.peer.gtk.GtkToolkit</code> 559: * if the property is not set. 560: * 561: * @return An instance of the system default toolkit. 562: * 563: * @throws AWTError If the toolkit cannot be loaded. 564: */ 565: public static synchronized Toolkit getDefaultToolkit() 566: { 567: if (toolkit != null) 568: return toolkit; 569: 570: String toolkit_name = SystemProperties.getProperty("awt.toolkit", 571: default_toolkit_name); 572: try 573: { 574: ClassLoader cl; 575: cl = (ClassLoader) AccessController.doPrivileged 576: (new PrivilegedAction() 577: { 578: public Object run() 579: { 580: return ClassLoader.getSystemClassLoader(); 581: } 582: }); 583: Class cls = Class.forName(toolkit_name, true, cl); 584: Object obj = cls.newInstance(); 585: if (!(obj instanceof Toolkit)) 586: throw new AWTError(toolkit_name + " is not a subclass of " + 587: "java.awt.Toolkit"); 588: toolkit = (Toolkit) obj; 589: 590: initAccessibility(); 591: return toolkit; 592: } 593: catch (ThreadDeath death) 594: { 595: throw death; 596: } 597: catch (Throwable t) 598: { 599: // Check for the headless property. 600: if (GraphicsEnvironment.isHeadless()) 601: { 602: toolkit = new HeadlessToolkit(); 603: return toolkit; 604: } 605: else 606: { 607: AWTError e = new AWTError("Cannot load AWT toolkit: " 608: + toolkit_name); 609: throw (AWTError) e.initCause(t); 610: } 611: } 612: } 613: 614: /** 615: * Returns an image from the specified file, which must be in a 616: * recognized format. Supported formats vary from toolkit to toolkit. 617: * 618: * @return name The name of the file to read the image from. 619: */ 620: public abstract Image getImage(String name); 621: 622: /** 623: * Returns an image from the specified URL, which must be in a 624: * recognized format. Supported formats vary from toolkit to toolkit. 625: * 626: * @return url The URl to read the image from. 627: */ 628: public abstract Image getImage(URL url); 629: 630: public abstract Image createImage(String filename); 631: 632: public abstract Image createImage(URL url); 633: 634: /** 635: * Readies an image to be rendered on the screen. The width and height 636: * values can be set to the default sizes for the image by passing -1 637: * in those parameters. 638: * 639: * @param image The image to prepare for rendering. 640: * @param width The width of the image. 641: * @param height The height of the image. 642: * @param observer The observer to receive events about the preparation 643: * process. 644: * 645: * @return <code>true</code> if the image is already prepared for rendering, 646: * <code>false</code> otherwise. 647: */ 648: public abstract boolean prepareImage(Image image, int width, int height, 649: ImageObserver observer); 650: 651: /** 652: * Checks the status of specified image as it is being readied for 653: * rendering. 654: * 655: * @param image The image to prepare for rendering. 656: * @param width The width of the image. 657: * @param height The height of the image. 658: * @param observer The observer to receive events about the preparation 659: * process. 660: * 661: * @return A union of the bitmasks from 662: * <code>java.awt.image.ImageObserver</code> that indicates the current 663: * state of the imaging readying process. 664: */ 665: public abstract int checkImage(Image image, int width, int height, 666: ImageObserver observer); 667: 668: /** 669: * Creates an image using the specified <code>ImageProducer</code> 670: * 671: * @param producer The <code>ImageProducer</code> to create the image from. 672: * 673: * @return The created image. 674: */ 675: public abstract Image createImage(ImageProducer producer); 676: 677: /** 678: * Creates an image from the specified byte array. The array must be in 679: * a recognized format. Supported formats vary from toolkit to toolkit. 680: * 681: * @param data The raw image data. 682: * 683: * @return The created image. 684: */ 685: public Image createImage(byte[] data) 686: { 687: return createImage(data, 0, data.length); 688: } 689: 690: /** 691: * Creates an image from the specified portion of the byte array passed. 692: * The array must be in a recognized format. Supported formats vary from 693: * toolkit to toolkit. 694: * 695: * @param data The raw image data. 696: * @param offset The offset into the data where the image data starts. 697: * @param len The length of the image data. 698: * 699: * @return The created image. 700: */ 701: public abstract Image createImage(byte[] data, int offset, int len); 702: 703: /** 704: * Returns a instance of <code>PrintJob</code> for the specified 705: * arguments. 706: * 707: * @param frame The window initiating the print job. 708: * @param title The print job title. 709: * @param props The print job properties. 710: * 711: * @return The requested print job, or <code>null</code> if the job 712: * was cancelled. 713: * 714: * @exception NullPointerException If frame is null, 715: * or GraphicsEnvironment.isHeadless() returns true. 716: * @exception SecurityException If this thread is not allowed to initiate 717: * a print job request. 718: */ 719: public abstract PrintJob getPrintJob(Frame frame, String title, 720: Properties props); 721: 722: /** 723: * Returns a instance of <code>PrintJob</code> for the specified 724: * arguments. 725: * 726: * @param frame The window initiating the print job. 727: * @param title The print job title. 728: * @param jobAttr A set of job attributes which will control the print job. 729: * @param pageAttr A set of page attributes which will control the print job. 730: * 731: * @exception NullPointerException If frame is null, and either jobAttr is null 732: * or jobAttr.getDialog() returns JobAttributes.DialogType.NATIVE. 733: * @exception IllegalArgumentException If pageAttrspecifies differing cross 734: * feed and feed resolutions, or when GraphicsEnvironment.isHeadless() returns 735: * true. 736: * @exception SecurityException If this thread is not allowed to initiate 737: * a print job request. 738: * 739: * @since 1.3 740: */ 741: public PrintJob getPrintJob(Frame frame, String title, 742: JobAttributes jobAttr, PageAttributes pageAttr) 743: { 744: // FIXME: it is possible this check may be removed 745: // if this method, when written, always delegates to 746: // getPrintJob(Frame, String, Properties). 747: SecurityManager sm; 748: sm = System.getSecurityManager(); 749: if (sm != null) 750: sm.checkPrintJobAccess(); 751: 752: return null; 753: } 754: 755: /** 756: * Causes a "beep" tone to be generated. 757: */ 758: public abstract void beep(); 759: 760: /** 761: * Returns the system clipboard. 762: * 763: * @return THe system clipboard. 764: * 765: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 766: */ 767: public abstract Clipboard getSystemClipboard(); 768: 769: /** 770: * Gets the singleton instance of the system selection as a 771: * Clipboard object. The system selection contains the selected text 772: * of the last component/widget that had focus and a text selection. 773: * The default implementation returns null. 774: * 775: * @return The Clipboard holding the system (text) selection or null 776: * if the Toolkit or system doesn't support a selection clipboard. 777: * 778: * @exception HeadlessException If GraphicsEnvironment.isHeadless() 779: * is true. 780: * @exception SecurityException If the current security manager 781: * checkSystemClipboardAccess() doesn't allow access. 782: * 783: * @since 1.4 784: */ 785: public Clipboard getSystemSelection() 786: { 787: return null; 788: } 789: 790: /** 791: * Returns the accelerator key mask for menu shortcuts. The default is 792: * <code>Event.CTRL_MASK</code>. A toolkit must override this method 793: * to change the default. 794: * 795: * @return The key mask for the menu accelerator key. 796: * 797: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 798: */ 799: public int getMenuShortcutKeyMask() 800: { 801: return Event.CTRL_MASK; 802: } 803: 804: /** 805: * Returns whether the given locking key on the keyboard is currently in its 806: * "on" state. 807: * 808: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 809: * @exception IllegalArgumentException If keyCode is not one of the valid keys. 810: * @exception UnsupportedOperationException If the host system doesn't allow 811: * getting the state of this key programmatically, or if the keyboard doesn't 812: * have this key. 813: */ 814: public boolean getLockingKeyState(int keyCode) 815: { 816: if (AWTUtilities.isValidKey(keyCode)) 817: throw new UnsupportedOperationException 818: ("cannot get locking state of key code " + keyCode); 819: 820: throw new IllegalArgumentException("invalid key code " + keyCode); 821: } 822: 823: /** 824: * Sets the state of the given locking key on the keyboard. 825: * 826: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 827: * @exception IllegalArgumentException If keyCode is not one of the valid keys. 828: * @exception UnsupportedOperationException If the host system doesn't allow 829: * getting the state of this key programmatically, or if the keyboard doesn't 830: * have this key. 831: */ 832: public void setLockingKeyState(int keyCode, boolean on) 833: { 834: if (keyCode != KeyEvent.VK_CAPS_LOCK 835: && keyCode != KeyEvent.VK_NUM_LOCK 836: && keyCode != KeyEvent.VK_SCROLL_LOCK) 837: throw new IllegalArgumentException(); 838: 839: throw new UnsupportedOperationException(); 840: } 841: 842: /** 843: * Returns the native container object of the specified component. This 844: * method is necessary because the parent component might be a lightweight 845: * component. 846: * 847: * @param component The component to fetch the native container for. 848: * 849: * @return The native container object for this component. 850: */ 851: protected static Container getNativeContainer(Component component) 852: { 853: component = component.getParent(); 854: while (true) 855: { 856: if (component == null) 857: return null; 858: if (! (component instanceof Container)) 859: { 860: component = component.getParent(); 861: continue; 862: } 863: if (component.getPeer() instanceof LightweightPeer) 864: { 865: component = component.getParent(); 866: continue; 867: } 868: return (Container) component; 869: } 870: } 871: 872: /** 873: * Creates a new custom cursor object. 874: * 875: * @exception IndexOutOfBoundsException If the hotSpot values are outside 876: * the bounds of the cursor. 877: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 878: */ 879: public Cursor createCustomCursor(Image cursor, Point hotSpot, String name) 880: { 881: // Presumably the only reason this isn't abstract is for backwards 882: // compatibility? FIXME? 883: if (GraphicsEnvironment.isHeadless()) 884: throw new HeadlessException("No custom cursor in an headless graphics " 885: + "environment."); 886: return null; 887: } 888: 889: /** 890: * Returns the supported cursor dimension which is closest to the 891: * desired sizes. 892: * 893: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 894: */ 895: public Dimension getBestCursorSize(int preferredWidth, int preferredHeight) 896: { 897: if (GraphicsEnvironment.isHeadless()) 898: throw new HeadlessException("No best cursor size in an headless " 899: + "graphics environment."); 900: return new Dimension (0,0); 901: } 902: 903: /** 904: * Returns the maximum number of colors the Toolkit supports in a custom 905: * cursor palette. 906: * 907: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 908: */ 909: public int getMaximumCursorColors() 910: { 911: return 0; 912: } 913: 914: /** 915: * Returns whether Toolkit supports this state for Frames. 916: * 917: * @exception HeadlessException If GraphicsEnvironment.isHeadless() is true. 918: * 919: * @since 1.4 920: */ 921: public boolean isFrameStateSupported(int state) 922: { 923: return false; 924: } 925: 926: /** 927: * Returns the value of the property with the specified name, or the 928: * default value if the property does not exist. 929: * 930: * @param key The name of the property to retrieve. 931: * @param def The default value of the property. 932: */ 933: public static String getProperty(String key, String def) 934: { 935: return props.getProperty(key, def); 936: } 937: 938: 939: /** 940: * Returns the event queue that is suitable for the calling context. 941: * 942: * <p>Despite the word “System” in the name of this 943: * method, a toolkit may provide different event queues for each 944: * applet. There is no guarantee that the same queue is shared 945: * system-wide. 946: * 947: * <p>The implementation first checks whether a 948: * SecurityManager has been installed. If so, its {@link 949: * java.lang.SecurityManager#checkAwtEventQueueAccess()} method gets 950: * called. The security manager will throw a SecurityException if it 951: * does not grant the permission to access the event queue. 952: * 953: * <p>Next, the call is delegated to {@link 954: * #getSystemEventQueueImpl()}. 955: * 956: * @return The event queue for this applet (or application). 957: * 958: * @throws SecurityException if a security manager has been 959: * installed, and it does not grant the permission to access the 960: * event queue. 961: */ 962: public final EventQueue getSystemEventQueue() 963: { 964: SecurityManager sm; 965: 966: sm = System.getSecurityManager(); 967: if (sm != null) 968: sm.checkAwtEventQueueAccess(); 969: 970: return getSystemEventQueueImpl(); 971: } 972: 973: 974: /** 975: * Returns the event queue that is suitable for the calling context. 976: * 977: * <p>Despite the word “System” in the name of this 978: * method, a toolkit may provide different event queues for each 979: * applet. There is no guarantee that the same queue is shared 980: * system-wide. 981: * 982: * <p>No security checks are performed, which is why this method 983: * may only be called by Toolkits. 984: * 985: * @see #getSystemEventQueue() 986: */ 987: protected abstract EventQueue getSystemEventQueueImpl(); 988: 989: 990: /** 991: * @since 1.3 992: */ 993: public abstract DragSourceContextPeer 994: createDragSourceContextPeer(DragGestureEvent e); 995: 996: /** 997: * @since 1.3 998: */ 999: public <T extends DragGestureRecognizer> T 1000: createDragGestureRecognizer(Class<T> recognizer, DragSource ds, 1001: Component comp, int actions, 1002: DragGestureListener l) 1003: { 1004: return null; 1005: } 1006: 1007: public final Object getDesktopProperty(String propertyName) 1008: { 1009: return desktopProperties.get(propertyName); 1010: } 1011: 1012: protected final void setDesktopProperty(String name, Object newValue) 1013: { 1014: Object oldValue = getDesktopProperty(name); 1015: desktopProperties.put(name, newValue); 1016: desktopPropsSupport.firePropertyChange(name, oldValue, newValue); 1017: } 1018: 1019: protected Object lazilyLoadDesktopProperty(String name) 1020: { 1021: // FIXME - what is this?? 1022: return null; 1023: } 1024: 1025: protected void initializeDesktopProperties() 1026: { 1027: // Overridden by toolkit implementation? 1028: } 1029: 1030: public void addPropertyChangeListener(String name, 1031: PropertyChangeListener pcl) 1032: { 1033: desktopPropsSupport.addPropertyChangeListener(name, pcl); 1034: } 1035: 1036: public void removePropertyChangeListener(String name, 1037: PropertyChangeListener pcl) 1038: { 1039: desktopPropsSupport.removePropertyChangeListener(name, pcl); 1040: } 1041: 1042: /** 1043: * @since 1.4 1044: */ 1045: public PropertyChangeListener[] getPropertyChangeListeners() 1046: { 1047: return desktopPropsSupport.getPropertyChangeListeners(); 1048: } 1049: 1050: /** 1051: * @since 1.4 1052: */ 1053: public PropertyChangeListener[] getPropertyChangeListeners(String name) 1054: { 1055: return desktopPropsSupport.getPropertyChangeListeners(name); 1056: } 1057: 1058: /** 1059: * Adds an AWTEventListener to this toolkit. This listener is informed about 1060: * all events that pass the eventqueue that match the specified 1061: * <code>evenMask</code>. The <code>eventMask</code> is an ORed combination 1062: * of event masks as defined in {@link AWTEvent}. 1063: * 1064: * If a security manager is installed, it is asked first if an 1065: * <code>AWTPermission("listenToAllAWTEvents")</code> is allowed. 1066: * This may result in a <code>SecurityException</code> beeing thrown. 1067: * 1068: * It is not recommended to use this kind of notification for normal 1069: * applications. It is intended solely for the purpose of debugging and to 1070: * support special facilities. 1071: * 1072: * @param listener the listener to add 1073: * @param eventMask the event mask of event types which the listener is 1074: * interested in 1075: * 1076: * @since 1.2 1077: * 1078: * @throws SecurityException if there is a <code>SecurityManager</code> that 1079: * doesn't grant 1080: * <code>AWTPermission("listenToAllAWTEvents")</code> 1081: * 1082: * @see #getAWTEventListeners() 1083: * @see #getAWTEventListeners(long) 1084: * @see #removeAWTEventListener(AWTEventListener) 1085: */ 1086: public void addAWTEventListener(AWTEventListener listener, long eventMask) 1087: { 1088: // First we must check the security permissions. 1089: SecurityManager s = System.getSecurityManager(); 1090: if (s != null) 1091: s.checkPermission(new AWTPermission("listenToAllAWTEvents")); 1092: 1093: // Go through the list and check if the requested listener is already 1094: // registered. 1095: boolean found = false; 1096: for (int i = 0; i < awtEventListeners.length; ++i) 1097: { 1098: AWTEventListenerProxy proxy = awtEventListeners[i]; 1099: if (proxy.getListener() == listener) 1100: { 1101: found = true; 1102: // Modify the proxies event mask to include the new event mask. 1103: AWTEventListenerProxy newProxy = 1104: new AWTEventListenerProxy(proxy.getEventMask() | eventMask, 1105: listener); 1106: awtEventListeners[i] = newProxy; 1107: break; 1108: } 1109: } 1110: 1111: // If that listener was not found, then add it. 1112: if (! found) 1113: { 1114: AWTEventListenerProxy proxy = 1115: new AWTEventListenerProxy(eventMask, listener); 1116: AWTEventListenerProxy[] newArray = 1117: new AWTEventListenerProxy[awtEventListeners.length + 1]; 1118: System.arraycopy(awtEventListeners, 0, newArray, 0, 1119: awtEventListeners.length); 1120: newArray[newArray.length - 1] = proxy; 1121: awtEventListeners = newArray; 1122: } 1123: } 1124: 1125: /** 1126: * Removes an AWT event listener from this toolkit. This listener is no 1127: * longer informed of any event types it was registered in. 1128: * 1129: * If a security manager is installed, it is asked first if an 1130: * <code>AWTPermission("listenToAllAWTEvents")</code> is allowed. 1131: * This may result in a <code>SecurityException</code> beeing thrown. 1132: * 1133: * It is not recommended to use this kind of notification for normal 1134: * applications. It is intended solely for the purpose of debugging and to 1135: * support special facilities. 1136: * 1137: * @param listener the listener to remove 1138: * 1139: * @throws SecurityException if there is a <code>SecurityManager</code> that 1140: * doesn't grant 1141: * <code>AWTPermission("listenToAllAWTEvents")</code> 1142: * 1143: * @since 1.2 1144: * 1145: * @see #addAWTEventListener(AWTEventListener, long) 1146: * @see #getAWTEventListeners() 1147: * @see #getAWTEventListeners(long) 1148: */ 1149: public void removeAWTEventListener(AWTEventListener listener) 1150: { 1151: // First we must check the security permissions. 1152: SecurityManager s = System.getSecurityManager(); 1153: if (s != null) 1154: s.checkPermission(new AWTPermission("listenToAllAWTEvents")); 1155: 1156: 1157: // Find the index of the listener. 1158: int index = -1; 1159: for (int i = 0; i < awtEventListeners.length; ++i) 1160: { 1161: AWTEventListenerProxy proxy = awtEventListeners[i]; 1162: if (proxy.getListener() == listener) 1163: { 1164: index = i; 1165: break; 1166: } 1167: } 1168: 1169: // Copy over the arrays and leave out the removed element. 1170: if (index != -1) 1171: { 1172: AWTEventListenerProxy[] newArray = 1173: new AWTEventListenerProxy[awtEventListeners.length - 1]; 1174: if (index > 0) 1175: System.arraycopy(awtEventListeners, 0, newArray, 0, index); 1176: if (index < awtEventListeners.length - 1) 1177: System.arraycopy(awtEventListeners, index + 1, newArray, index, 1178: awtEventListeners.length - index - 1); 1179: awtEventListeners = newArray; 1180: } 1181: } 1182: 1183: /** 1184: * Returns all registered AWT event listeners. This method returns a copy of 1185: * the listener array, so that application cannot trash the listener list. 1186: * 1187: * If a security manager is installed, it is asked first if an 1188: * <code>AWTPermission("listenToAllAWTEvents")</code> is allowed. 1189: * This may result in a <code>SecurityException</code> beeing thrown. 1190: * 1191: * It is not recommended to use this kind of notification for normal 1192: * applications. It is intended solely for the purpose of debugging and to 1193: * support special facilities. 1194: * 1195: * @return all registered AWT event listeners 1196: * 1197: * @throws SecurityException if there is a <code>SecurityManager</code> that 1198: * doesn't grant 1199: * <code>AWTPermission("listenToAllAWTEvents")</code> 1200: * 1201: * @since 1.4 1202: * 1203: * @see #addAWTEventListener(AWTEventListener, long) 1204: * @see #removeAWTEventListener(AWTEventListener) 1205: * @see #getAWTEventListeners(long) 1206: */ 1207: public AWTEventListener[] getAWTEventListeners() 1208: { 1209: // First we must check the security permissions. 1210: SecurityManager s = System.getSecurityManager(); 1211: if (s != null) 1212: s.checkPermission(new AWTPermission("listenToAllAWTEvents")); 1213: 1214: // Create a copy of the array. 1215: AWTEventListener[] copy = new AWTEventListener[awtEventListeners.length]; 1216: System.arraycopy(awtEventListeners, 0, copy, 0, awtEventListeners.length); 1217: return copy; 1218: } 1219: 1220: /** 1221: * Returns all registered AWT event listeners that listen for events with 1222: * the specified <code>eventMask</code>. This method returns a copy of 1223: * the listener array, so that application cannot trash the listener list. 1224: * 1225: * If a security manager is installed, it is asked first if an 1226: * <code>AWTPermission("listenToAllAWTEvents")</code> is allowed. 1227: * This may result in a <code>SecurityException</code> beeing thrown. 1228: * 1229: * It is not recommended to use this kind of notification for normal 1230: * applications. It is intended solely for the purpose of debugging and to 1231: * support special facilities. 1232: * 1233: * @param mask the event mask 1234: * 1235: * @throws SecurityException if there is a <code>SecurityManager</code> that 1236: * doesn't grant 1237: * <code>AWTPermission("listenToAllAWTEvents")</code> 1238: * 1239: * 1240: * @since 1.4 1241: * 1242: * @see #addAWTEventListener(AWTEventListener, long) 1243: * @see #removeAWTEventListener(AWTEventListener) 1244: * @see #getAWTEventListeners() 1245: */ 1246: public AWTEventListener[] getAWTEventListeners(long mask) 1247: { 1248: // First we must check the security permissions. 1249: SecurityManager s = System.getSecurityManager(); 1250: if (s != null) 1251: s.checkPermission(new AWTPermission("listenToAllAWTEvents")); 1252: 1253: // Create a copy of the array with only the requested listeners in it. 1254: ArrayList l = new ArrayList(awtEventListeners.length); 1255: for (int i = 0; i < awtEventListeners.length; ++i) 1256: { 1257: if ((awtEventListeners[i].getEventMask() & mask) != 0) 1258: l.add(awtEventListeners[i]); 1259: } 1260: 1261: return (AWTEventListener[] ) l.toArray(new AWTEventListener[l.size()]); 1262: } 1263: 1264: 1265: /** 1266: * Dispatches events to listeners registered to this Toolkit. This is called 1267: * by {@link Component#dispatchEventImpl(AWTEvent)} in order to dispatch 1268: * events globally. 1269: * 1270: * @param ev the event to dispatch 1271: */ 1272: void globalDispatchEvent(AWTEvent ev) 1273: { 1274: // We do not use the accessor methods here because they create new 1275: // arrays each time. We must be very efficient, so we access this directly. 1276: for (int i = 0; i < awtEventListeners.length; ++i) 1277: { 1278: AWTEventListenerProxy proxy = awtEventListeners[i]; 1279: if ((proxy.getEventMask() & AWTEvent.eventIdToMask(ev.getID())) != 0) 1280: proxy.eventDispatched(ev); 1281: } 1282: } 1283: 1284: /** 1285: * @since 1.3 1286: */ 1287: public abstract Map<TextAttribute,?> 1288: mapInputMethodHighlight(InputMethodHighlight highlight); 1289: 1290: /** 1291: * Initializes the accessibility framework. In particular, this loads the 1292: * properties javax.accessibility.screen_magnifier_present and 1293: * javax.accessibility.screen_reader_present and loads 1294: * the classes specified in javax.accessibility.assistive_technologies. 1295: */ 1296: private static void initAccessibility() 1297: { 1298: AccessController.doPrivileged 1299: (new PrivilegedAction() 1300: { 1301: public Object run() 1302: { 1303: Properties props = new Properties(); 1304: String sep = File.separator; 1305: 1306: // Try the user configuration. 1307: try 1308: { 1309: File propsFile = new File(System.getProperty("user.home") + sep 1310: + ".accessibility.properties"); 1311: FileInputStream in = new FileInputStream(propsFile); 1312: props.load(in); 1313: in.close(); 1314: } 1315: catch (Exception ex) 1316: { 1317: // User configuration not present, ignore. 1318: } 1319: 1320: // Try the system configuration if there was no user configuration. 1321: if (props.size() == 0) 1322: { 1323: try 1324: { 1325: File propsFile = 1326: new File(System.getProperty("gnu.classpath.home.url") 1327: + sep + "accessibility.properties"); 1328: FileInputStream in = new FileInputStream(propsFile); 1329: props.load(in); 1330: in.close(); 1331: } 1332: catch (Exception ex) 1333: { 1334: // System configuration not present, ignore. 1335: } 1336: } 1337: 1338: // Fetch the screen_magnifier_present property. Check systen properties 1339: // first, then fallback to the configuration file. 1340: String magPresent = SystemProperties.getProperty 1341: ("javax.accessibility.screen_magnifier_present"); 1342: if (magPresent == null) 1343: { 1344: magPresent = props.getProperty("screen_magnifier_present"); 1345: if (magPresent != null) 1346: { 1347: SystemProperties.setProperty 1348: ("javax.accessibility.screen_magnifier_present", magPresent); 1349: } 1350: } 1351: 1352: // Fetch the screen_reader_present property. Check systen properties 1353: // first, then fallback to the configuration file. 1354: String readerPresent = SystemProperties.getProperty 1355: ("javax.accessibility.screen_reader_present"); 1356: if (readerPresent == null) 1357: { 1358: readerPresent = props.getProperty("screen_reader_present"); 1359: if (readerPresent != null) 1360: { 1361: SystemProperties.setProperty 1362: ("javax.accessibility.screen_reader_present", readerPresent); 1363: } 1364: } 1365: 1366: // Fetch the list of classes to be loaded. 1367: String classes = SystemProperties.getProperty 1368: ("javax.accessibility.assistive_technologies"); 1369: if (classes == null) 1370: { 1371: classes = props.getProperty("assistive_technologies"); 1372: if (classes != null) 1373: { 1374: SystemProperties.setProperty 1375: ("javax.accessibility.assistive_technologies", classes); 1376: } 1377: } 1378: 1379: // Try to load the assisitive_technologies classes. 1380: if (classes != null) 1381: { 1382: ClassLoader cl = ClassLoader.getSystemClassLoader(); 1383: StringTokenizer tokenizer = new StringTokenizer(classes, ","); 1384: while (tokenizer.hasMoreTokens()) 1385: { 1386: String className = tokenizer.nextToken(); 1387: try 1388: { 1389: Class atClass = cl.loadClass(className); 1390: atClass.newInstance(); 1391: } 1392: catch (ClassNotFoundException ex) 1393: { 1394: AWTError err = new AWTError("Assistive Technology class not" 1395: + " found: " + className); 1396: err.initCause(ex); 1397: throw err; 1398: } 1399: catch (InstantiationException ex) 1400: { 1401: AWTError err = 1402: new AWTError("Assistive Technology class cannot be " 1403: + "instantiated: " + className); 1404: err.initCause(ex); 1405: throw err; 1406: } 1407: catch (IllegalAccessException ex) 1408: { 1409: AWTError err = 1410: new AWTError("Assistive Technology class cannot be " 1411: + "accessed: " + className); 1412: err.initCause(err); 1413: throw err; 1414: } 1415: } 1416: } 1417: return null; 1418: } 1419: }); 1420: 1421: } 1422: 1423: } // class Toolkit
| GNU Classpath (0.95) |