1 /*
   2  * Copyright (c) 1995, 2014, 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 java.awt;
  27 
  28 import java.beans.PropertyChangeEvent;
  29 import java.awt.event.*;
  30 import java.awt.peer.*;
  31 import java.awt.im.InputMethodHighlight;
  32 import java.awt.image.ImageObserver;
  33 import java.awt.image.ImageProducer;
  34 import java.awt.image.ColorModel;
  35 import java.awt.datatransfer.Clipboard;
  36 import java.awt.dnd.DragSource;
  37 import java.awt.dnd.DragGestureRecognizer;
  38 import java.awt.dnd.DragGestureEvent;
  39 import java.awt.dnd.DragGestureListener;
  40 import java.awt.dnd.InvalidDnDOperationException;
  41 import java.awt.dnd.peer.DragSourceContextPeer;
  42 import java.net.URL;
  43 import java.io.File;
  44 import java.io.FileInputStream;
  45 
  46 import java.util.*;
  47 import java.beans.PropertyChangeListener;
  48 import java.beans.PropertyChangeSupport;
  49 import sun.awt.AppContext;
  50 
  51 import sun.awt.HeadlessToolkit;
  52 import sun.awt.NullComponentPeer;
  53 import sun.awt.PeerEvent;
  54 import sun.awt.SunToolkit;
  55 import sun.awt.AWTAccessor;
  56 import sun.awt.AWTPermissions;
  57 
  58 import sun.util.CoreResourceBundleControl;
  59 
  60 /**
  61  * This class is the abstract superclass of all actual
  62  * implementations of the Abstract Window Toolkit. Subclasses of
  63  * the <code>Toolkit</code> class are used to bind the various components
  64  * to particular native toolkit implementations.
  65  * <p>
  66  * Many GUI events may be delivered to user
  67  * asynchronously, if the opposite is not specified explicitly.
  68  * As well as
  69  * many GUI operations may be performed asynchronously.
  70  * This fact means that if the state of a component is set, and then
  71  * the state immediately queried, the returned value may not yet
  72  * reflect the requested change.  This behavior includes, but is not
  73  * limited to:
  74  * <ul>
  75  * <li>Scrolling to a specified position.
  76  * <br>For example, calling <code>ScrollPane.setScrollPosition</code>
  77  *     and then <code>getScrollPosition</code> may return an incorrect
  78  *     value if the original request has not yet been processed.
  79  *
  80  * <li>Moving the focus from one component to another.
  81  * <br>For more information, see
  82  * <a href="http://docs.oracle.com/javase/tutorial/uiswing/misc/focus.html#transferTiming">Timing
  83  * Focus Transfers</a>, a section in
  84  * <a href="http://java.sun.com/docs/books/tutorial/uiswing/">The Swing
  85  * Tutorial</a>.
  86  *
  87  * <li>Making a top-level container visible.
  88  * <br>Calling <code>setVisible(true)</code> on a <code>Window</code>,
  89  *     <code>Frame</code> or <code>Dialog</code> may occur
  90  *     asynchronously.
  91  *
  92  * <li>Setting the size or location of a top-level container.
  93  * <br>Calls to <code>setSize</code>, <code>setBounds</code> or
  94  *     <code>setLocation</code> on a <code>Window</code>,
  95  *     <code>Frame</code> or <code>Dialog</code> are forwarded
  96  *     to the underlying window management system and may be
  97  *     ignored or modified.  See {@link java.awt.Window} for
  98  *     more information.
  99  * </ul>
 100  * <p>
 101  * Most applications should not call any of the methods in this
 102  * class directly. The methods defined by <code>Toolkit</code> are
 103  * the "glue" that joins the platform-independent classes in the
 104  * <code>java.awt</code> package with their counterparts in
 105  * <code>java.awt.peer</code>. Some methods defined by
 106  * <code>Toolkit</code> query the native operating system directly.
 107  *
 108  * @author      Sami Shaio
 109  * @author      Arthur van Hoff
 110  * @author      Fred Ecks
 111  * @since       1.0
 112  */
 113 public abstract class Toolkit {
 114 
 115     /**
 116      * Creates this toolkit's implementation of the <code>Desktop</code>
 117      * using the specified peer interface.
 118      * @param     target the desktop to be implemented
 119      * @return    this toolkit's implementation of the <code>Desktop</code>
 120      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 121      * returns true
 122      * @see       java.awt.GraphicsEnvironment#isHeadless
 123      * @see       java.awt.Desktop
 124      * @see       java.awt.peer.DesktopPeer
 125      * @since 1.6
 126      */
 127     protected abstract DesktopPeer createDesktopPeer(Desktop target)
 128       throws HeadlessException;
 129 
 130 
 131     /**
 132      * Creates this toolkit's implementation of <code>Button</code> using
 133      * the specified peer interface.
 134      * @param     target the button to be implemented.
 135      * @return    this toolkit's implementation of <code>Button</code>.
 136      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 137      * returns true
 138      * @see       java.awt.GraphicsEnvironment#isHeadless
 139      * @see       java.awt.Button
 140      * @see       java.awt.peer.ButtonPeer
 141      */
 142     protected abstract ButtonPeer createButton(Button target)
 143         throws HeadlessException;
 144 
 145     /**
 146      * Creates this toolkit's implementation of <code>TextField</code> using
 147      * the specified peer interface.
 148      * @param     target the text field to be implemented.
 149      * @return    this toolkit's implementation of <code>TextField</code>.
 150      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 151      * returns true
 152      * @see       java.awt.GraphicsEnvironment#isHeadless
 153      * @see       java.awt.TextField
 154      * @see       java.awt.peer.TextFieldPeer
 155      */
 156     protected abstract TextFieldPeer createTextField(TextField target)
 157         throws HeadlessException;
 158 
 159     /**
 160      * Creates this toolkit's implementation of <code>Label</code> using
 161      * the specified peer interface.
 162      * @param     target the label to be implemented.
 163      * @return    this toolkit's implementation of <code>Label</code>.
 164      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 165      * returns true
 166      * @see       java.awt.GraphicsEnvironment#isHeadless
 167      * @see       java.awt.Label
 168      * @see       java.awt.peer.LabelPeer
 169      */
 170     protected abstract LabelPeer createLabel(Label target)
 171         throws HeadlessException;
 172 
 173     /**
 174      * Creates this toolkit's implementation of <code>List</code> using
 175      * the specified peer interface.
 176      * @param     target the list to be implemented.
 177      * @return    this toolkit's implementation of <code>List</code>.
 178      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 179      * returns true
 180      * @see       java.awt.GraphicsEnvironment#isHeadless
 181      * @see       java.awt.List
 182      * @see       java.awt.peer.ListPeer
 183      */
 184     protected abstract ListPeer createList(java.awt.List target)
 185         throws HeadlessException;
 186 
 187     /**
 188      * Creates this toolkit's implementation of <code>Checkbox</code> using
 189      * the specified peer interface.
 190      * @param     target the check box to be implemented.
 191      * @return    this toolkit's implementation of <code>Checkbox</code>.
 192      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 193      * returns true
 194      * @see       java.awt.GraphicsEnvironment#isHeadless
 195      * @see       java.awt.Checkbox
 196      * @see       java.awt.peer.CheckboxPeer
 197      */
 198     protected abstract CheckboxPeer createCheckbox(Checkbox target)
 199         throws HeadlessException;
 200 
 201     /**
 202      * Creates this toolkit's implementation of <code>Scrollbar</code> using
 203      * the specified peer interface.
 204      * @param     target the scroll bar to be implemented.
 205      * @return    this toolkit's implementation of <code>Scrollbar</code>.
 206      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 207      * returns true
 208      * @see       java.awt.GraphicsEnvironment#isHeadless
 209      * @see       java.awt.Scrollbar
 210      * @see       java.awt.peer.ScrollbarPeer
 211      */
 212     protected abstract ScrollbarPeer createScrollbar(Scrollbar target)
 213         throws HeadlessException;
 214 
 215     /**
 216      * Creates this toolkit's implementation of <code>ScrollPane</code> using
 217      * the specified peer interface.
 218      * @param     target the scroll pane to be implemented.
 219      * @return    this toolkit's implementation of <code>ScrollPane</code>.
 220      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 221      * returns true
 222      * @see       java.awt.GraphicsEnvironment#isHeadless
 223      * @see       java.awt.ScrollPane
 224      * @see       java.awt.peer.ScrollPanePeer
 225      * @since     1.1
 226      */
 227     protected abstract ScrollPanePeer createScrollPane(ScrollPane target)
 228         throws HeadlessException;
 229 
 230     /**
 231      * Creates this toolkit's implementation of <code>TextArea</code> using
 232      * the specified peer interface.
 233      * @param     target the text area to be implemented.
 234      * @return    this toolkit's implementation of <code>TextArea</code>.
 235      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 236      * returns true
 237      * @see       java.awt.GraphicsEnvironment#isHeadless
 238      * @see       java.awt.TextArea
 239      * @see       java.awt.peer.TextAreaPeer
 240      */
 241     protected abstract TextAreaPeer createTextArea(TextArea target)
 242         throws HeadlessException;
 243 
 244     /**
 245      * Creates this toolkit's implementation of <code>Choice</code> using
 246      * the specified peer interface.
 247      * @param     target the choice to be implemented.
 248      * @return    this toolkit's implementation of <code>Choice</code>.
 249      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 250      * returns true
 251      * @see       java.awt.GraphicsEnvironment#isHeadless
 252      * @see       java.awt.Choice
 253      * @see       java.awt.peer.ChoicePeer
 254      */
 255     protected abstract ChoicePeer createChoice(Choice target)
 256         throws HeadlessException;
 257 
 258     /**
 259      * Creates this toolkit's implementation of <code>Frame</code> using
 260      * the specified peer interface.
 261      * @param     target the frame to be implemented.
 262      * @return    this toolkit's implementation of <code>Frame</code>.
 263      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 264      * returns true
 265      * @see       java.awt.GraphicsEnvironment#isHeadless
 266      * @see       java.awt.Frame
 267      * @see       java.awt.peer.FramePeer
 268      */
 269     protected abstract FramePeer createFrame(Frame target)
 270         throws HeadlessException;
 271 
 272     /**
 273      * Creates this toolkit's implementation of <code>Canvas</code> using
 274      * the specified peer interface.
 275      * @param     target the canvas to be implemented.
 276      * @return    this toolkit's implementation of <code>Canvas</code>.
 277      * @see       java.awt.Canvas
 278      * @see       java.awt.peer.CanvasPeer
 279      */
 280     protected abstract CanvasPeer       createCanvas(Canvas target);
 281 
 282     /**
 283      * Creates this toolkit's implementation of <code>Panel</code> using
 284      * the specified peer interface.
 285      * @param     target the panel to be implemented.
 286      * @return    this toolkit's implementation of <code>Panel</code>.
 287      * @see       java.awt.Panel
 288      * @see       java.awt.peer.PanelPeer
 289      */
 290     protected abstract PanelPeer        createPanel(Panel target);
 291 
 292     /**
 293      * Creates this toolkit's implementation of <code>Window</code> using
 294      * the specified peer interface.
 295      * @param     target the window to be implemented.
 296      * @return    this toolkit's implementation of <code>Window</code>.
 297      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 298      * returns true
 299      * @see       java.awt.GraphicsEnvironment#isHeadless
 300      * @see       java.awt.Window
 301      * @see       java.awt.peer.WindowPeer
 302      */
 303     protected abstract WindowPeer createWindow(Window target)
 304         throws HeadlessException;
 305 
 306     /**
 307      * Creates this toolkit's implementation of <code>Dialog</code> using
 308      * the specified peer interface.
 309      * @param     target the dialog to be implemented.
 310      * @return    this toolkit's implementation of <code>Dialog</code>.
 311      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 312      * returns true
 313      * @see       java.awt.GraphicsEnvironment#isHeadless
 314      * @see       java.awt.Dialog
 315      * @see       java.awt.peer.DialogPeer
 316      */
 317     protected abstract DialogPeer createDialog(Dialog target)
 318         throws HeadlessException;
 319 
 320     /**
 321      * Creates this toolkit's implementation of <code>MenuBar</code> using
 322      * the specified peer interface.
 323      * @param     target the menu bar to be implemented.
 324      * @return    this toolkit's implementation of <code>MenuBar</code>.
 325      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 326      * returns true
 327      * @see       java.awt.GraphicsEnvironment#isHeadless
 328      * @see       java.awt.MenuBar
 329      * @see       java.awt.peer.MenuBarPeer
 330      */
 331     protected abstract MenuBarPeer createMenuBar(MenuBar target)
 332         throws HeadlessException;
 333 
 334     /**
 335      * Creates this toolkit's implementation of <code>Menu</code> using
 336      * the specified peer interface.
 337      * @param     target the menu to be implemented.
 338      * @return    this toolkit's implementation of <code>Menu</code>.
 339      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 340      * returns true
 341      * @see       java.awt.GraphicsEnvironment#isHeadless
 342      * @see       java.awt.Menu
 343      * @see       java.awt.peer.MenuPeer
 344      */
 345     protected abstract MenuPeer createMenu(Menu target)
 346         throws HeadlessException;
 347 
 348     /**
 349      * Creates this toolkit's implementation of <code>PopupMenu</code> using
 350      * the specified peer interface.
 351      * @param     target the popup menu to be implemented.
 352      * @return    this toolkit's implementation of <code>PopupMenu</code>.
 353      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 354      * returns true
 355      * @see       java.awt.GraphicsEnvironment#isHeadless
 356      * @see       java.awt.PopupMenu
 357      * @see       java.awt.peer.PopupMenuPeer
 358      * @since     1.1
 359      */
 360     protected abstract PopupMenuPeer createPopupMenu(PopupMenu target)
 361         throws HeadlessException;
 362 
 363     /**
 364      * Creates this toolkit's implementation of <code>MenuItem</code> using
 365      * the specified peer interface.
 366      * @param     target the menu item to be implemented.
 367      * @return    this toolkit's implementation of <code>MenuItem</code>.
 368      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 369      * returns true
 370      * @see       java.awt.GraphicsEnvironment#isHeadless
 371      * @see       java.awt.MenuItem
 372      * @see       java.awt.peer.MenuItemPeer
 373      */
 374     protected abstract MenuItemPeer createMenuItem(MenuItem target)
 375         throws HeadlessException;
 376 
 377     /**
 378      * Creates this toolkit's implementation of <code>FileDialog</code> using
 379      * the specified peer interface.
 380      * @param     target the file dialog to be implemented.
 381      * @return    this toolkit's implementation of <code>FileDialog</code>.
 382      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 383      * returns true
 384      * @see       java.awt.GraphicsEnvironment#isHeadless
 385      * @see       java.awt.FileDialog
 386      * @see       java.awt.peer.FileDialogPeer
 387      */
 388     protected abstract FileDialogPeer createFileDialog(FileDialog target)
 389         throws HeadlessException;
 390 
 391     /**
 392      * Creates this toolkit's implementation of <code>CheckboxMenuItem</code> using
 393      * the specified peer interface.
 394      * @param     target the checkbox menu item to be implemented.
 395      * @return    this toolkit's implementation of <code>CheckboxMenuItem</code>.
 396      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 397      * returns true
 398      * @see       java.awt.GraphicsEnvironment#isHeadless
 399      * @see       java.awt.CheckboxMenuItem
 400      * @see       java.awt.peer.CheckboxMenuItemPeer
 401      */
 402     protected abstract CheckboxMenuItemPeer createCheckboxMenuItem(
 403         CheckboxMenuItem target) throws HeadlessException;
 404 
 405     /**
 406      * Obtains this toolkit's implementation of helper class for
 407      * <code>MouseInfo</code> operations.
 408      * @return    this toolkit's implementation of  helper for <code>MouseInfo</code>
 409      * @throws    UnsupportedOperationException if this operation is not implemented
 410      * @see       java.awt.peer.MouseInfoPeer
 411      * @see       java.awt.MouseInfo
 412      * @since 1.5
 413      */
 414     protected MouseInfoPeer getMouseInfoPeer() {
 415         throw new UnsupportedOperationException("Not implemented");
 416     }
 417 
 418     private static LightweightPeer lightweightMarker;
 419 
 420     /**
 421      * Creates a peer for a component or container.  This peer is windowless
 422      * and allows the Component and Container classes to be extended directly
 423      * to create windowless components that are defined entirely in java.
 424      *
 425      * @param target The Component to be created.
 426      */
 427     protected LightweightPeer createComponent(Component target) {
 428         if (lightweightMarker == null) {
 429             lightweightMarker = new NullComponentPeer();
 430         }
 431         return lightweightMarker;
 432     }
 433 
 434     /**
 435      * Creates this toolkit's implementation of <code>Font</code> using
 436      * the specified peer interface.
 437      * @param     name the font to be implemented
 438      * @param     style the style of the font, such as <code>PLAIN</code>,
 439      *            <code>BOLD</code>, <code>ITALIC</code>, or a combination
 440      * @return    this toolkit's implementation of <code>Font</code>
 441      * @see       java.awt.Font
 442      * @see       java.awt.peer.FontPeer
 443      * @see       java.awt.GraphicsEnvironment#getAllFonts
 444      * @deprecated  see java.awt.GraphicsEnvironment#getAllFonts
 445      */
 446     @Deprecated
 447     protected abstract FontPeer getFontPeer(String name, int style);
 448 
 449     // The following method is called by the private method
 450     // <code>updateSystemColors</code> in <code>SystemColor</code>.
 451 
 452     /**
 453      * Fills in the integer array that is supplied as an argument
 454      * with the current system color values.
 455      *
 456      * @param     systemColors an integer array.
 457      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 458      * returns true
 459      * @see       java.awt.GraphicsEnvironment#isHeadless
 460      * @since     1.1
 461      */
 462     protected void loadSystemColors(int[] systemColors)
 463         throws HeadlessException {
 464         GraphicsEnvironment.checkHeadless();
 465     }
 466 
 467     /**
 468      * Controls whether the layout of Containers is validated dynamically
 469      * during resizing, or statically, after resizing is complete.
 470      * Use {@code isDynamicLayoutActive()} to detect if this feature enabled
 471      * in this program and is supported by this operating system
 472      * and/or window manager.
 473      * Note that this feature is supported not on all platforms, and
 474      * conversely, that this feature cannot be turned off on some platforms.
 475      * On these platforms where dynamic layout during resizing is not supported
 476      * (or is always supported), setting this property has no effect.
 477      * Note that this feature can be set or unset as a property of the
 478      * operating system or window manager on some platforms.  On such
 479      * platforms, the dynamic resize property must be set at the operating
 480      * system or window manager level before this method can take effect.
 481      * This method does not change support or settings of the underlying
 482      * operating system or
 483      * window manager.  The OS/WM support can be
 484      * queried using getDesktopProperty("awt.dynamicLayoutSupported") method.
 485      *
 486      * @param     dynamic  If true, Containers should re-layout their
 487      *            components as the Container is being resized.  If false,
 488      *            the layout will be validated after resizing is completed.
 489      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 490      *            returns true
 491      * @see       #isDynamicLayoutSet()
 492      * @see       #isDynamicLayoutActive()
 493      * @see       #getDesktopProperty(String propertyName)
 494      * @see       java.awt.GraphicsEnvironment#isHeadless
 495      * @since     1.4
 496      */
 497     public void setDynamicLayout(final boolean dynamic)
 498         throws HeadlessException {
 499         GraphicsEnvironment.checkHeadless();
 500         if (this != getDefaultToolkit()) {
 501             getDefaultToolkit().setDynamicLayout(dynamic);
 502         }
 503     }
 504 
 505     /**
 506      * Returns whether the layout of Containers is validated dynamically
 507      * during resizing, or statically, after resizing is complete.
 508      * Note: this method returns the value that was set programmatically;
 509      * it does not reflect support at the level of the operating system
 510      * or window manager for dynamic layout on resizing, or the current
 511      * operating system or window manager settings.  The OS/WM support can
 512      * be queried using getDesktopProperty("awt.dynamicLayoutSupported").
 513      *
 514      * @return    true if validation of Containers is done dynamically,
 515      *            false if validation is done after resizing is finished.
 516      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 517      *            returns true
 518      * @see       #setDynamicLayout(boolean dynamic)
 519      * @see       #isDynamicLayoutActive()
 520      * @see       #getDesktopProperty(String propertyName)
 521      * @see       java.awt.GraphicsEnvironment#isHeadless
 522      * @since     1.4
 523      */
 524     protected boolean isDynamicLayoutSet()
 525         throws HeadlessException {
 526         GraphicsEnvironment.checkHeadless();
 527 
 528         if (this != Toolkit.getDefaultToolkit()) {
 529             return Toolkit.getDefaultToolkit().isDynamicLayoutSet();
 530         } else {
 531             return false;
 532         }
 533     }
 534 
 535     /**
 536      * Returns whether dynamic layout of Containers on resize is
 537      * currently active (both set in program
 538      *( {@code isDynamicLayoutSet()} )
 539      *, and supported
 540      * by the underlying operating system and/or window manager).
 541      * If dynamic layout is currently inactive then Containers
 542      * re-layout their components when resizing is completed. As a result
 543      * the {@code Component.validate()} method will be invoked only
 544      * once per resize.
 545      * If dynamic layout is currently active then Containers
 546      * re-layout their components on every native resize event and
 547      * the {@code validate()} method will be invoked each time.
 548      * The OS/WM support can be queried using
 549      * the getDesktopProperty("awt.dynamicLayoutSupported") method.
 550      *
 551      * @return    true if dynamic layout of Containers on resize is
 552      *            currently active, false otherwise.
 553      * @exception HeadlessException if the GraphicsEnvironment.isHeadless()
 554      *            method returns true
 555      * @see       #setDynamicLayout(boolean dynamic)
 556      * @see       #isDynamicLayoutSet()
 557      * @see       #getDesktopProperty(String propertyName)
 558      * @see       java.awt.GraphicsEnvironment#isHeadless
 559      * @since     1.4
 560      */
 561     public boolean isDynamicLayoutActive()
 562         throws HeadlessException {
 563         GraphicsEnvironment.checkHeadless();
 564 
 565         if (this != Toolkit.getDefaultToolkit()) {
 566             return Toolkit.getDefaultToolkit().isDynamicLayoutActive();
 567         } else {
 568             return false;
 569         }
 570     }
 571 
 572     /**
 573      * Gets the size of the screen.  On systems with multiple displays, the
 574      * primary display is used.  Multi-screen aware display dimensions are
 575      * available from <code>GraphicsConfiguration</code> and
 576      * <code>GraphicsDevice</code>.
 577      * @return    the size of this toolkit's screen, in pixels.
 578      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 579      * returns true
 580      * @see       java.awt.GraphicsConfiguration#getBounds
 581      * @see       java.awt.GraphicsDevice#getDisplayMode
 582      * @see       java.awt.GraphicsEnvironment#isHeadless
 583      */
 584     public abstract Dimension getScreenSize()
 585         throws HeadlessException;
 586 
 587     /**
 588      * Returns the screen resolution in dots-per-inch.
 589      * @return    this toolkit's screen resolution, in dots-per-inch.
 590      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 591      * returns true
 592      * @see       java.awt.GraphicsEnvironment#isHeadless
 593      */
 594     public abstract int getScreenResolution()
 595         throws HeadlessException;
 596 
 597     /**
 598      * Gets the insets of the screen.
 599      * @param     gc a <code>GraphicsConfiguration</code>
 600      * @return    the insets of this toolkit's screen, in pixels.
 601      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 602      * returns true
 603      * @see       java.awt.GraphicsEnvironment#isHeadless
 604      * @since     1.4
 605      */
 606     public Insets getScreenInsets(GraphicsConfiguration gc)
 607         throws HeadlessException {
 608         GraphicsEnvironment.checkHeadless();
 609         if (this != Toolkit.getDefaultToolkit()) {
 610             return Toolkit.getDefaultToolkit().getScreenInsets(gc);
 611         } else {
 612             return new Insets(0, 0, 0, 0);
 613         }
 614     }
 615 
 616     /**
 617      * Determines the color model of this toolkit's screen.
 618      * <p>
 619      * <code>ColorModel</code> is an abstract class that
 620      * encapsulates the ability to translate between the
 621      * pixel values of an image and its red, green, blue,
 622      * and alpha components.
 623      * <p>
 624      * This toolkit method is called by the
 625      * <code>getColorModel</code> method
 626      * of the <code>Component</code> class.
 627      * @return    the color model of this toolkit's screen.
 628      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
 629      * returns true
 630      * @see       java.awt.GraphicsEnvironment#isHeadless
 631      * @see       java.awt.image.ColorModel
 632      * @see       java.awt.Component#getColorModel
 633      */
 634     public abstract ColorModel getColorModel()
 635         throws HeadlessException;
 636 
 637     /**
 638      * Returns the names of the available fonts in this toolkit.<p>
 639      * For 1.1, the following font names are deprecated (the replacement
 640      * name follows):
 641      * <ul>
 642      * <li>TimesRoman (use Serif)
 643      * <li>Helvetica (use SansSerif)
 644      * <li>Courier (use Monospaced)
 645      * </ul><p>
 646      * The ZapfDingbats fontname is also deprecated in 1.1 but the characters
 647      * are defined in Unicode starting at 0x2700, and as of 1.1 Java supports
 648      * those characters.
 649      * @return    the names of the available fonts in this toolkit.
 650      * @deprecated see {@link java.awt.GraphicsEnvironment#getAvailableFontFamilyNames()}
 651      * @see java.awt.GraphicsEnvironment#getAvailableFontFamilyNames()
 652      */
 653     @Deprecated
 654     public abstract String[] getFontList();
 655 
 656     /**
 657      * Gets the screen device metrics for rendering of the font.
 658      * @param     font   a font
 659      * @return    the screen metrics of the specified font in this toolkit
 660      * @deprecated  As of JDK version 1.2, replaced by the <code>Font</code>
 661      *          method <code>getLineMetrics</code>.
 662      * @see java.awt.font.LineMetrics
 663      * @see java.awt.Font#getLineMetrics
 664      * @see java.awt.GraphicsEnvironment#getScreenDevices
 665      */
 666     @Deprecated
 667     public abstract FontMetrics getFontMetrics(Font font);
 668 
 669     /**
 670      * Synchronizes this toolkit's graphics state. Some window systems
 671      * may do buffering of graphics events.
 672      * <p>
 673      * This method ensures that the display is up-to-date. It is useful
 674      * for animation.
 675      */
 676     public abstract void sync();
 677 
 678     /**
 679      * The default toolkit.
 680      */
 681     private static Toolkit toolkit;
 682 
 683     /**
 684      * Used internally by the assistive technologies functions; set at
 685      * init time and used at load time
 686      */
 687     private static String atNames;
 688 
 689     /**
 690      * Initializes properties related to assistive technologies.
 691      * These properties are used both in the loadAssistiveProperties()
 692      * function below, as well as other classes in the jdk that depend
 693      * on the properties (such as the use of the screen_magnifier_present
 694      * property in Java2D hardware acceleration initialization).  The
 695      * initialization of the properties must be done before the platform-
 696      * specific Toolkit class is instantiated so that all necessary
 697      * properties are set up properly before any classes dependent upon them
 698      * are initialized.
 699      */
 700     private static void initAssistiveTechnologies() {
 701 
 702         // Get accessibility properties
 703         final String sep = File.separator;
 704         final Properties properties = new Properties();
 705 
 706 
 707         atNames = java.security.AccessController.doPrivileged(
 708             new java.security.PrivilegedAction<String>() {
 709             public String run() {
 710 
 711                 // Try loading the per-user accessibility properties file.
 712                 try {
 713                     File propsFile = new File(
 714                       System.getProperty("user.home") +
 715                       sep + ".accessibility.properties");
 716                     FileInputStream in =
 717                         new FileInputStream(propsFile);
 718 
 719                     // Inputstream has been buffered in Properties class
 720                     properties.load(in);
 721                     in.close();
 722                 } catch (Exception e) {
 723                     // Per-user accessibility properties file does not exist
 724                 }
 725 
 726                 // Try loading the system-wide accessibility properties
 727                 // file only if a per-user accessibility properties
 728                 // file does not exist or is empty.
 729                 if (properties.size() == 0) {
 730                     try {
 731                         File propsFile = new File(
 732                             System.getProperty("java.home") + sep + "lib" +
 733                             sep + "accessibility.properties");
 734                         FileInputStream in =
 735                             new FileInputStream(propsFile);
 736 
 737                         // Inputstream has been buffered in Properties class
 738                         properties.load(in);
 739                         in.close();
 740                     } catch (Exception e) {
 741                         // System-wide accessibility properties file does
 742                         // not exist;
 743                     }
 744                 }
 745 
 746                 // Get whether a screen magnifier is present.  First check
 747                 // the system property and then check the properties file.
 748                 String magPresent = System.getProperty("javax.accessibility.screen_magnifier_present");
 749                 if (magPresent == null) {
 750                     magPresent = properties.getProperty("screen_magnifier_present", null);
 751                     if (magPresent != null) {
 752                         System.setProperty("javax.accessibility.screen_magnifier_present", magPresent);
 753                     }
 754                 }
 755 
 756                 // Get the names of any assistive technolgies to load.  First
 757                 // check the system property and then check the properties
 758                 // file.
 759                 String classNames = System.getProperty("javax.accessibility.assistive_technologies");
 760                 if (classNames == null) {
 761                     classNames = properties.getProperty("assistive_technologies", null);
 762                     if (classNames != null) {
 763                         System.setProperty("javax.accessibility.assistive_technologies", classNames);
 764                     }
 765                 }
 766                 return classNames;
 767             }
 768         });
 769     }
 770 
 771     /**
 772      * Loads additional classes into the VM, using the property
 773      * 'assistive_technologies' specified in the Sun reference
 774      * implementation by a line in the 'accessibility.properties'
 775      * file.  The form is "assistive_technologies=..." where
 776      * the "..." is a comma-separated list of assistive technology
 777      * classes to load.  Each class is loaded in the order given
 778      * and a single instance of each is created using
 779      * Class.forName(class).newInstance().  All errors are handled
 780      * via an AWTError exception.
 781      *
 782      * <p>The assumption is made that assistive technology classes are supplied
 783      * as part of INSTALLED (as opposed to: BUNDLED) extensions or specified
 784      * on the class path
 785      * (and therefore can be loaded using the class loader returned by
 786      * a call to <code>ClassLoader.getSystemClassLoader</code>, whose
 787      * delegation parent is the extension class loader for installed
 788      * extensions).
 789      */
 790     private static void loadAssistiveTechnologies() {
 791         // Load any assistive technologies
 792         if (atNames != null) {
 793             ClassLoader cl = ClassLoader.getSystemClassLoader();
 794             StringTokenizer parser = new StringTokenizer(atNames," ,");
 795             String atName;
 796             while (parser.hasMoreTokens()) {
 797                 atName = parser.nextToken();
 798                 try {
 799                     Class<?> clazz;
 800                     if (cl != null) {
 801                         clazz = cl.loadClass(atName);
 802                     } else {
 803                         clazz = Class.forName(atName);
 804                     }
 805                     clazz.newInstance();
 806                 } catch (ClassNotFoundException e) {
 807                     throw new AWTError("Assistive Technology not found: "
 808                             + atName);
 809                 } catch (InstantiationException e) {
 810                     throw new AWTError("Could not instantiate Assistive"
 811                             + " Technology: " + atName);
 812                 } catch (IllegalAccessException e) {
 813                     throw new AWTError("Could not access Assistive"
 814                             + " Technology: " + atName);
 815                 } catch (Exception e) {
 816                     throw new AWTError("Error trying to install Assistive"
 817                             + " Technology: " + atName + " " + e);
 818                 }
 819             }
 820         }
 821     }
 822 
 823     /**
 824      * Gets the default toolkit.
 825      * <p>
 826      * If a system property named <code>"java.awt.headless"</code> is set
 827      * to <code>true</code> then the headless implementation
 828      * of <code>Toolkit</code> is used.
 829      * <p>
 830      * If there is no <code>"java.awt.headless"</code> or it is set to
 831      * <code>false</code> and there is a system property named
 832      * <code>"awt.toolkit"</code>,
 833      * that property is treated as the name of a class that is a subclass
 834      * of <code>Toolkit</code>;
 835      * otherwise the default platform-specific implementation of
 836      * <code>Toolkit</code> is used.
 837      * <p>
 838      * Also loads additional classes into the VM, using the property
 839      * 'assistive_technologies' specified in the Sun reference
 840      * implementation by a line in the 'accessibility.properties'
 841      * file.  The form is "assistive_technologies=..." where
 842      * the "..." is a comma-separated list of assistive technology
 843      * classes to load.  Each class is loaded in the order given
 844      * and a single instance of each is created using
 845      * Class.forName(class).newInstance().  This is done just after
 846      * the AWT toolkit is created.  All errors are handled via an
 847      * AWTError exception.
 848      * @return    the default toolkit.
 849      * @exception  AWTError  if a toolkit could not be found, or
 850      *                 if one could not be accessed or instantiated.
 851      */
 852     public static synchronized Toolkit getDefaultToolkit() {
 853         if (toolkit == null) {
 854             java.security.AccessController.doPrivileged(
 855                     new java.security.PrivilegedAction<Void>() {
 856                 public Void run() {
 857                     Class<?> cls = null;
 858                     String nm = System.getProperty("awt.toolkit");
 859                     try {
 860                         cls = Class.forName(nm);
 861                     } catch (ClassNotFoundException e) {
 862                         ClassLoader cl = ClassLoader.getSystemClassLoader();
 863                         if (cl != null) {
 864                             try {
 865                                 cls = cl.loadClass(nm);
 866                             } catch (final ClassNotFoundException ignored) {
 867                                 throw new AWTError("Toolkit not found: " + nm);
 868                             }
 869                         }
 870                     }
 871                     try {
 872                         if (cls != null) {
 873                             toolkit = (Toolkit)cls.newInstance();
 874                             if (GraphicsEnvironment.isHeadless()) {
 875                                 toolkit = new HeadlessToolkit(toolkit);
 876                             }
 877                         }
 878                     } catch (final InstantiationException ignored) {
 879                         throw new AWTError("Could not instantiate Toolkit: " + nm);
 880                     } catch (final IllegalAccessException ignored) {
 881                         throw new AWTError("Could not access Toolkit: " + nm);
 882                     }
 883                     return null;
 884                 }
 885             });
 886             loadAssistiveTechnologies();
 887         }
 888         return toolkit;
 889     }
 890 
 891     /**
 892      * Returns an image which gets pixel data from the specified file,
 893      * whose format can be either GIF, JPEG or PNG.
 894      * The underlying toolkit attempts to resolve multiple requests
 895      * with the same filename to the same returned Image.
 896      * <p>
 897      * Since the mechanism required to facilitate this sharing of
 898      * <code>Image</code> objects may continue to hold onto images
 899      * that are no longer in use for an indefinite period of time,
 900      * developers are encouraged to implement their own caching of
 901      * images by using the {@link #createImage(java.lang.String) createImage}
 902      * variant wherever available.
 903      * If the image data contained in the specified file changes,
 904      * the <code>Image</code> object returned from this method may
 905      * still contain stale information which was loaded from the
 906      * file after a prior call.
 907      * Previously loaded image data can be manually discarded by
 908      * calling the {@link Image#flush flush} method on the
 909      * returned <code>Image</code>.
 910      * <p>
 911      * This method first checks if there is a security manager installed.
 912      * If so, the method calls the security manager's
 913      * <code>checkRead</code> method with the file specified to ensure
 914      * that the access to the image is allowed.
 915      * @param     filename   the name of a file containing pixel data
 916      *                         in a recognized file format.
 917      * @return    an image which gets its pixel data from
 918      *                         the specified file.
 919      * @throws SecurityException  if a security manager exists and its
 920      *                            checkRead method doesn't allow the operation.
 921      * @see #createImage(java.lang.String)
 922      */
 923     public abstract Image getImage(String filename);
 924 
 925     /**
 926      * Returns an image which gets pixel data from the specified URL.
 927      * The pixel data referenced by the specified URL must be in one
 928      * of the following formats: GIF, JPEG or PNG.
 929      * The underlying toolkit attempts to resolve multiple requests
 930      * with the same URL to the same returned Image.
 931      * <p>
 932      * Since the mechanism required to facilitate this sharing of
 933      * <code>Image</code> objects may continue to hold onto images
 934      * that are no longer in use for an indefinite period of time,
 935      * developers are encouraged to implement their own caching of
 936      * images by using the {@link #createImage(java.net.URL) createImage}
 937      * variant wherever available.
 938      * If the image data stored at the specified URL changes,
 939      * the <code>Image</code> object returned from this method may
 940      * still contain stale information which was fetched from the
 941      * URL after a prior call.
 942      * Previously loaded image data can be manually discarded by
 943      * calling the {@link Image#flush flush} method on the
 944      * returned <code>Image</code>.
 945      * <p>
 946      * This method first checks if there is a security manager installed.
 947      * If so, the method calls the security manager's
 948      * <code>checkPermission</code> method with the
 949      * url.openConnection().getPermission() permission to ensure
 950      * that the access to the image is allowed. For compatibility
 951      * with pre-1.2 security managers, if the access is denied with
 952      * <code>FilePermission</code> or <code>SocketPermission</code>,
 953      * the method throws the <code>SecurityException</code>
 954      * if the corresponding 1.1-style SecurityManager.checkXXX method
 955      * also denies permission.
 956      * @param     url   the URL to use in fetching the pixel data.
 957      * @return    an image which gets its pixel data from
 958      *                         the specified URL.
 959      * @throws SecurityException  if a security manager exists and its
 960      *                            checkPermission method doesn't allow
 961      *                            the operation.
 962      * @see #createImage(java.net.URL)
 963      */
 964     public abstract Image getImage(URL url);
 965 
 966     /**
 967      * Returns an image which gets pixel data from the specified file.
 968      * The returned Image is a new object which will not be shared
 969      * with any other caller of this method or its getImage variant.
 970      * <p>
 971      * This method first checks if there is a security manager installed.
 972      * If so, the method calls the security manager's
 973      * <code>checkRead</code> method with the specified file to ensure
 974      * that the image creation is allowed.
 975      * @param     filename   the name of a file containing pixel data
 976      *                         in a recognized file format.
 977      * @return    an image which gets its pixel data from
 978      *                         the specified file.
 979      * @throws SecurityException  if a security manager exists and its
 980      *                            checkRead method doesn't allow the operation.
 981      * @see #getImage(java.lang.String)
 982      */
 983     public abstract Image createImage(String filename);
 984 
 985     /**
 986      * Returns an image which gets pixel data from the specified URL.
 987      * The returned Image is a new object which will not be shared
 988      * with any other caller of this method or its getImage variant.
 989      * <p>
 990      * This method first checks if there is a security manager installed.
 991      * If so, the method calls the security manager's
 992      * <code>checkPermission</code> method with the
 993      * url.openConnection().getPermission() permission to ensure
 994      * that the image creation is allowed. For compatibility
 995      * with pre-1.2 security managers, if the access is denied with
 996      * <code>FilePermission</code> or <code>SocketPermission</code>,
 997      * the method throws <code>SecurityException</code>
 998      * if the corresponding 1.1-style SecurityManager.checkXXX method
 999      * also denies permission.
1000      * @param     url   the URL to use in fetching the pixel data.
1001      * @return    an image which gets its pixel data from
1002      *                         the specified URL.
1003      * @throws SecurityException  if a security manager exists and its
1004      *                            checkPermission method doesn't allow
1005      *                            the operation.
1006      * @see #getImage(java.net.URL)
1007      */
1008     public abstract Image createImage(URL url);
1009 
1010     /**
1011      * Prepares an image for rendering.
1012      * <p>
1013      * If the values of the width and height arguments are both
1014      * <code>-1</code>, this method prepares the image for rendering
1015      * on the default screen; otherwise, this method prepares an image
1016      * for rendering on the default screen at the specified width and height.
1017      * <p>
1018      * The image data is downloaded asynchronously in another thread,
1019      * and an appropriately scaled screen representation of the image is
1020      * generated.
1021      * <p>
1022      * This method is called by components <code>prepareImage</code>
1023      * methods.
1024      * <p>
1025      * Information on the flags returned by this method can be found
1026      * with the definition of the <code>ImageObserver</code> interface.
1027 
1028      * @param     image      the image for which to prepare a
1029      *                           screen representation.
1030      * @param     width      the width of the desired screen
1031      *                           representation, or <code>-1</code>.
1032      * @param     height     the height of the desired screen
1033      *                           representation, or <code>-1</code>.
1034      * @param     observer   the <code>ImageObserver</code>
1035      *                           object to be notified as the
1036      *                           image is being prepared.
1037      * @return    <code>true</code> if the image has already been
1038      *                 fully prepared; <code>false</code> otherwise.
1039      * @see       java.awt.Component#prepareImage(java.awt.Image,
1040      *                 java.awt.image.ImageObserver)
1041      * @see       java.awt.Component#prepareImage(java.awt.Image,
1042      *                 int, int, java.awt.image.ImageObserver)
1043      * @see       java.awt.image.ImageObserver
1044      */
1045     public abstract boolean prepareImage(Image image, int width, int height,
1046                                          ImageObserver observer);
1047 
1048     /**
1049      * Indicates the construction status of a specified image that is
1050      * being prepared for display.
1051      * <p>
1052      * If the values of the width and height arguments are both
1053      * <code>-1</code>, this method returns the construction status of
1054      * a screen representation of the specified image in this toolkit.
1055      * Otherwise, this method returns the construction status of a
1056      * scaled representation of the image at the specified width
1057      * and height.
1058      * <p>
1059      * This method does not cause the image to begin loading.
1060      * An application must call <code>prepareImage</code> to force
1061      * the loading of an image.
1062      * <p>
1063      * This method is called by the component's <code>checkImage</code>
1064      * methods.
1065      * <p>
1066      * Information on the flags returned by this method can be found
1067      * with the definition of the <code>ImageObserver</code> interface.
1068      * @param     image   the image whose status is being checked.
1069      * @param     width   the width of the scaled version whose status is
1070      *                 being checked, or <code>-1</code>.
1071      * @param     height  the height of the scaled version whose status
1072      *                 is being checked, or <code>-1</code>.
1073      * @param     observer   the <code>ImageObserver</code> object to be
1074      *                 notified as the image is being prepared.
1075      * @return    the bitwise inclusive <strong>OR</strong> of the
1076      *                 <code>ImageObserver</code> flags for the
1077      *                 image data that is currently available.
1078      * @see       java.awt.Toolkit#prepareImage(java.awt.Image,
1079      *                 int, int, java.awt.image.ImageObserver)
1080      * @see       java.awt.Component#checkImage(java.awt.Image,
1081      *                 java.awt.image.ImageObserver)
1082      * @see       java.awt.Component#checkImage(java.awt.Image,
1083      *                 int, int, java.awt.image.ImageObserver)
1084      * @see       java.awt.image.ImageObserver
1085      */
1086     public abstract int checkImage(Image image, int width, int height,
1087                                    ImageObserver observer);
1088 
1089     /**
1090      * Creates an image with the specified image producer.
1091      * @param     producer the image producer to be used.
1092      * @return    an image with the specified image producer.
1093      * @see       java.awt.Image
1094      * @see       java.awt.image.ImageProducer
1095      * @see       java.awt.Component#createImage(java.awt.image.ImageProducer)
1096      */
1097     public abstract Image createImage(ImageProducer producer);
1098 
1099     /**
1100      * Creates an image which decodes the image stored in the specified
1101      * byte array.
1102      * <p>
1103      * The data must be in some image format, such as GIF or JPEG,
1104      * that is supported by this toolkit.
1105      * @param     imagedata   an array of bytes, representing
1106      *                         image data in a supported image format.
1107      * @return    an image.
1108      * @since     1.1
1109      */
1110     public Image createImage(byte[] imagedata) {
1111         return createImage(imagedata, 0, imagedata.length);
1112     }
1113 
1114     /**
1115      * Creates an image which decodes the image stored in the specified
1116      * byte array, and at the specified offset and length.
1117      * The data must be in some image format, such as GIF or JPEG,
1118      * that is supported by this toolkit.
1119      * @param     imagedata   an array of bytes, representing
1120      *                         image data in a supported image format.
1121      * @param     imageoffset  the offset of the beginning
1122      *                         of the data in the array.
1123      * @param     imagelength  the length of the data in the array.
1124      * @return    an image.
1125      * @since     1.1
1126      */
1127     public abstract Image createImage(byte[] imagedata,
1128                                       int imageoffset,
1129                                       int imagelength);
1130 
1131     /**
1132      * Gets a <code>PrintJob</code> object which is the result of initiating
1133      * a print operation on the toolkit's platform.
1134      * <p>
1135      * Each actual implementation of this method should first check if there
1136      * is a security manager installed. If there is, the method should call
1137      * the security manager's <code>checkPrintJobAccess</code> method to
1138      * ensure initiation of a print operation is allowed. If the default
1139      * implementation of <code>checkPrintJobAccess</code> is used (that is,
1140      * that method is not overriden), then this results in a call to the
1141      * security manager's <code>checkPermission</code> method with a <code>
1142      * RuntimePermission("queuePrintJob")</code> permission.
1143      *
1144      * @param   frame the parent of the print dialog. May not be null.
1145      * @param   jobtitle the title of the PrintJob. A null title is equivalent
1146      *          to "".
1147      * @param   props a Properties object containing zero or more properties.
1148      *          Properties are not standardized and are not consistent across
1149      *          implementations. Because of this, PrintJobs which require job
1150      *          and page control should use the version of this function which
1151      *          takes JobAttributes and PageAttributes objects. This object
1152      *          may be updated to reflect the user's job choices on exit. May
1153      *          be null.
1154      * @return  a <code>PrintJob</code> object, or <code>null</code> if the
1155      *          user cancelled the print job.
1156      * @throws  NullPointerException if frame is null
1157      * @throws  SecurityException if this thread is not allowed to initiate a
1158      *          print job request
1159      * @see     java.awt.GraphicsEnvironment#isHeadless
1160      * @see     java.awt.PrintJob
1161      * @see     java.lang.RuntimePermission
1162      * @since   1.1
1163      */
1164     public abstract PrintJob getPrintJob(Frame frame, String jobtitle,
1165                                          Properties props);
1166 
1167     /**
1168      * Gets a <code>PrintJob</code> object which is the result of initiating
1169      * a print operation on the toolkit's platform.
1170      * <p>
1171      * Each actual implementation of this method should first check if there
1172      * is a security manager installed. If there is, the method should call
1173      * the security manager's <code>checkPrintJobAccess</code> method to
1174      * ensure initiation of a print operation is allowed. If the default
1175      * implementation of <code>checkPrintJobAccess</code> is used (that is,
1176      * that method is not overriden), then this results in a call to the
1177      * security manager's <code>checkPermission</code> method with a <code>
1178      * RuntimePermission("queuePrintJob")</code> permission.
1179      *
1180      * @param   frame the parent of the print dialog. May not be null.
1181      * @param   jobtitle the title of the PrintJob. A null title is equivalent
1182      *          to "".
1183      * @param   jobAttributes a set of job attributes which will control the
1184      *          PrintJob. The attributes will be updated to reflect the user's
1185      *          choices as outlined in the JobAttributes documentation. May be
1186      *          null.
1187      * @param   pageAttributes a set of page attributes which will control the
1188      *          PrintJob. The attributes will be applied to every page in the
1189      *          job. The attributes will be updated to reflect the user's
1190      *          choices as outlined in the PageAttributes documentation. May be
1191      *          null.
1192      * @return  a <code>PrintJob</code> object, or <code>null</code> if the
1193      *          user cancelled the print job.
1194      * @throws  NullPointerException if frame is null
1195      * @throws  IllegalArgumentException if pageAttributes specifies differing
1196      *          cross feed and feed resolutions. Also if this thread has
1197      *          access to the file system and jobAttributes specifies
1198      *          print to file, and the specified destination file exists but
1199      *          is a directory rather than a regular file, does not exist but
1200      *          cannot be created, or cannot be opened for any other reason.
1201      *          However in the case of print to file, if a dialog is also
1202      *          requested to be displayed then the user will be given an
1203      *          opportunity to select a file and proceed with printing.
1204      *          The dialog will ensure that the selected output file
1205      *          is valid before returning from this method.
1206      * @throws  SecurityException if this thread is not allowed to initiate a
1207      *          print job request, or if jobAttributes specifies print to file,
1208      *          and this thread is not allowed to access the file system
1209      * @see     java.awt.PrintJob
1210      * @see     java.awt.GraphicsEnvironment#isHeadless
1211      * @see     java.lang.RuntimePermission
1212      * @see     java.awt.JobAttributes
1213      * @see     java.awt.PageAttributes
1214      * @since   1.3
1215      */
1216     public PrintJob getPrintJob(Frame frame, String jobtitle,
1217                                 JobAttributes jobAttributes,
1218                                 PageAttributes pageAttributes) {
1219         // Override to add printing support with new job/page control classes
1220 
1221         if (this != Toolkit.getDefaultToolkit()) {
1222             return Toolkit.getDefaultToolkit().getPrintJob(frame, jobtitle,
1223                                                            jobAttributes,
1224                                                            pageAttributes);
1225         } else {
1226             return getPrintJob(frame, jobtitle, null);
1227         }
1228     }
1229 
1230     /**
1231      * Emits an audio beep depending on native system settings and hardware
1232      * capabilities.
1233      * @since     1.1
1234      */
1235     public abstract void beep();
1236 
1237     /**
1238      * Gets the singleton instance of the system Clipboard which interfaces
1239      * with clipboard facilities provided by the native platform. This
1240      * clipboard enables data transfer between Java programs and native
1241      * applications which use native clipboard facilities.
1242      * <p>
1243      * In addition to any and all default formats text returned by the system
1244      * Clipboard's <code>getTransferData()</code> method is available in the
1245      * following flavors:
1246      * <ul>
1247      * <li>DataFlavor.stringFlavor</li>
1248      * <li>DataFlavor.plainTextFlavor (<b>deprecated</b>)</li>
1249      * </ul>
1250      * As with <code>java.awt.datatransfer.StringSelection</code>, if the
1251      * requested flavor is <code>DataFlavor.plainTextFlavor</code>, or an
1252      * equivalent flavor, a Reader is returned. <b>Note:</b> The behavior of
1253      * the system Clipboard's <code>getTransferData()</code> method for <code>
1254      * DataFlavor.plainTextFlavor</code>, and equivalent DataFlavors, is
1255      * inconsistent with the definition of <code>DataFlavor.plainTextFlavor
1256      * </code>. Because of this, support for <code>
1257      * DataFlavor.plainTextFlavor</code>, and equivalent flavors, is
1258      * <b>deprecated</b>.
1259      * <p>
1260      * Each actual implementation of this method should first check if there
1261      * is a security manager installed. If there is, the method should call
1262      * the security manager's {@link SecurityManager#checkPermission
1263      * checkPermission} method to check {@code AWTPermission("accessClipboard")}.
1264      *
1265      * @return    the system Clipboard
1266      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
1267      * returns true
1268      * @see       java.awt.GraphicsEnvironment#isHeadless
1269      * @see       java.awt.datatransfer.Clipboard
1270      * @see       java.awt.datatransfer.StringSelection
1271      * @see       java.awt.datatransfer.DataFlavor#stringFlavor
1272      * @see       java.awt.datatransfer.DataFlavor#plainTextFlavor
1273      * @see       java.io.Reader
1274      * @see       java.awt.AWTPermission
1275      * @since     1.1
1276      */
1277     public abstract Clipboard getSystemClipboard()
1278         throws HeadlessException;
1279 
1280     /**
1281      * Gets the singleton instance of the system selection as a
1282      * <code>Clipboard</code> object. This allows an application to read and
1283      * modify the current, system-wide selection.
1284      * <p>
1285      * An application is responsible for updating the system selection whenever
1286      * the user selects text, using either the mouse or the keyboard.
1287      * Typically, this is implemented by installing a
1288      * <code>FocusListener</code> on all <code>Component</code>s which support
1289      * text selection, and, between <code>FOCUS_GAINED</code> and
1290      * <code>FOCUS_LOST</code> events delivered to that <code>Component</code>,
1291      * updating the system selection <code>Clipboard</code> when the selection
1292      * changes inside the <code>Component</code>. Properly updating the system
1293      * selection ensures that a Java application will interact correctly with
1294      * native applications and other Java applications running simultaneously
1295      * on the system. Note that <code>java.awt.TextComponent</code> and
1296      * <code>javax.swing.text.JTextComponent</code> already adhere to this
1297      * policy. When using these classes, and their subclasses, developers need
1298      * not write any additional code.
1299      * <p>
1300      * Some platforms do not support a system selection <code>Clipboard</code>.
1301      * On those platforms, this method will return <code>null</code>. In such a
1302      * case, an application is absolved from its responsibility to update the
1303      * system selection <code>Clipboard</code> as described above.
1304      * <p>
1305      * Each actual implementation of this method should first check if there
1306      * is a security manager installed. If there is, the method should call
1307      * the security manager's {@link SecurityManager#checkPermission
1308      * checkPermission} method to check {@code AWTPermission("accessClipboard")}.
1309      *
1310      * @return the system selection as a <code>Clipboard</code>, or
1311      *         <code>null</code> if the native platform does not support a
1312      *         system selection <code>Clipboard</code>
1313      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
1314      *            returns true
1315      *
1316      * @see java.awt.datatransfer.Clipboard
1317      * @see java.awt.event.FocusListener
1318      * @see java.awt.event.FocusEvent#FOCUS_GAINED
1319      * @see java.awt.event.FocusEvent#FOCUS_LOST
1320      * @see TextComponent
1321      * @see javax.swing.text.JTextComponent
1322      * @see AWTPermission
1323      * @see GraphicsEnvironment#isHeadless
1324      * @since 1.4
1325      */
1326     public Clipboard getSystemSelection() throws HeadlessException {
1327         GraphicsEnvironment.checkHeadless();
1328 
1329         if (this != Toolkit.getDefaultToolkit()) {
1330             return Toolkit.getDefaultToolkit().getSystemSelection();
1331         } else {
1332             GraphicsEnvironment.checkHeadless();
1333             return null;
1334         }
1335     }
1336 
1337     /**
1338      * Determines which modifier key is the appropriate accelerator
1339      * key for menu shortcuts.
1340      * <p>
1341      * Menu shortcuts, which are embodied in the
1342      * <code>MenuShortcut</code> class, are handled by the
1343      * <code>MenuBar</code> class.
1344      * <p>
1345      * By default, this method returns <code>Event.CTRL_MASK</code>.
1346      * Toolkit implementations should override this method if the
1347      * <b>Control</b> key isn't the correct key for accelerators.
1348      * @return    the modifier mask on the <code>Event</code> class
1349      *                 that is used for menu shortcuts on this toolkit.
1350      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
1351      * returns true
1352      * @see       java.awt.GraphicsEnvironment#isHeadless
1353      * @see       java.awt.MenuBar
1354      * @see       java.awt.MenuShortcut
1355      * @since     1.1
1356      */
1357     public int getMenuShortcutKeyMask() throws HeadlessException {
1358         GraphicsEnvironment.checkHeadless();
1359 
1360         return Event.CTRL_MASK;
1361     }
1362 
1363     /**
1364      * Returns whether the given locking key on the keyboard is currently in
1365      * its "on" state.
1366      * Valid key codes are
1367      * {@link java.awt.event.KeyEvent#VK_CAPS_LOCK VK_CAPS_LOCK},
1368      * {@link java.awt.event.KeyEvent#VK_NUM_LOCK VK_NUM_LOCK},
1369      * {@link java.awt.event.KeyEvent#VK_SCROLL_LOCK VK_SCROLL_LOCK}, and
1370      * {@link java.awt.event.KeyEvent#VK_KANA_LOCK VK_KANA_LOCK}.
1371      *
1372      * @exception java.lang.IllegalArgumentException if <code>keyCode</code>
1373      * is not one of the valid key codes
1374      * @exception java.lang.UnsupportedOperationException if the host system doesn't
1375      * allow getting the state of this key programmatically, or if the keyboard
1376      * doesn't have this key
1377      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
1378      * returns true
1379      * @see       java.awt.GraphicsEnvironment#isHeadless
1380      * @since 1.3
1381      */
1382     public boolean getLockingKeyState(int keyCode)
1383         throws UnsupportedOperationException
1384     {
1385         GraphicsEnvironment.checkHeadless();
1386 
1387         if (! (keyCode == KeyEvent.VK_CAPS_LOCK || keyCode == KeyEvent.VK_NUM_LOCK ||
1388                keyCode == KeyEvent.VK_SCROLL_LOCK || keyCode == KeyEvent.VK_KANA_LOCK)) {
1389             throw new IllegalArgumentException("invalid key for Toolkit.getLockingKeyState");
1390         }
1391         throw new UnsupportedOperationException("Toolkit.getLockingKeyState");
1392     }
1393 
1394     /**
1395      * Sets the state of the given locking key on the keyboard.
1396      * Valid key codes are
1397      * {@link java.awt.event.KeyEvent#VK_CAPS_LOCK VK_CAPS_LOCK},
1398      * {@link java.awt.event.KeyEvent#VK_NUM_LOCK VK_NUM_LOCK},
1399      * {@link java.awt.event.KeyEvent#VK_SCROLL_LOCK VK_SCROLL_LOCK}, and
1400      * {@link java.awt.event.KeyEvent#VK_KANA_LOCK VK_KANA_LOCK}.
1401      * <p>
1402      * Depending on the platform, setting the state of a locking key may
1403      * involve event processing and therefore may not be immediately
1404      * observable through getLockingKeyState.
1405      *
1406      * @exception java.lang.IllegalArgumentException if <code>keyCode</code>
1407      * is not one of the valid key codes
1408      * @exception java.lang.UnsupportedOperationException if the host system doesn't
1409      * allow setting the state of this key programmatically, or if the keyboard
1410      * doesn't have this key
1411      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
1412      * returns true
1413      * @see       java.awt.GraphicsEnvironment#isHeadless
1414      * @since 1.3
1415      */
1416     public void setLockingKeyState(int keyCode, boolean on)
1417         throws UnsupportedOperationException
1418     {
1419         GraphicsEnvironment.checkHeadless();
1420 
1421         if (! (keyCode == KeyEvent.VK_CAPS_LOCK || keyCode == KeyEvent.VK_NUM_LOCK ||
1422                keyCode == KeyEvent.VK_SCROLL_LOCK || keyCode == KeyEvent.VK_KANA_LOCK)) {
1423             throw new IllegalArgumentException("invalid key for Toolkit.setLockingKeyState");
1424         }
1425         throw new UnsupportedOperationException("Toolkit.setLockingKeyState");
1426     }
1427 
1428     /**
1429      * Give native peers the ability to query the native container
1430      * given a native component (eg the direct parent may be lightweight).
1431      */
1432     protected static Container getNativeContainer(Component c) {
1433         return c.getNativeContainer();
1434     }
1435 
1436     /**
1437      * Creates a new custom cursor object.
1438      * If the image to display is invalid, the cursor will be hidden (made
1439      * completely transparent), and the hotspot will be set to (0, 0).
1440      *
1441      * <p>Note that multi-frame images are invalid and may cause this
1442      * method to hang.
1443      *
1444      * @param cursor the image to display when the cursor is activated
1445      * @param hotSpot the X and Y of the large cursor's hot spot; the
1446      *   hotSpot values must be less than the Dimension returned by
1447      *   <code>getBestCursorSize</code>
1448      * @param     name a localized description of the cursor, for Java Accessibility use
1449      * @exception IndexOutOfBoundsException if the hotSpot values are outside
1450      *   the bounds of the cursor
1451      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
1452      * returns true
1453      * @see       java.awt.GraphicsEnvironment#isHeadless
1454      * @since     1.2
1455      */
1456     public Cursor createCustomCursor(Image cursor, Point hotSpot, String name)
1457         throws IndexOutOfBoundsException, HeadlessException
1458     {
1459         // Override to implement custom cursor support.
1460         if (this != Toolkit.getDefaultToolkit()) {
1461             return Toolkit.getDefaultToolkit().
1462                 createCustomCursor(cursor, hotSpot, name);
1463         } else {
1464             return new Cursor(Cursor.DEFAULT_CURSOR);
1465         }
1466     }
1467 
1468     /**
1469      * Returns the supported cursor dimension which is closest to the desired
1470      * sizes.  Systems which only support a single cursor size will return that
1471      * size regardless of the desired sizes.  Systems which don't support custom
1472      * cursors will return a dimension of 0, 0. <p>
1473      * Note:  if an image is used whose dimensions don't match a supported size
1474      * (as returned by this method), the Toolkit implementation will attempt to
1475      * resize the image to a supported size.
1476      * Since converting low-resolution images is difficult,
1477      * no guarantees are made as to the quality of a cursor image which isn't a
1478      * supported size.  It is therefore recommended that this method
1479      * be called and an appropriate image used so no image conversion is made.
1480      *
1481      * @param     preferredWidth the preferred cursor width the component would like
1482      * to use.
1483      * @param     preferredHeight the preferred cursor height the component would like
1484      * to use.
1485      * @return    the closest matching supported cursor size, or a dimension of 0,0 if
1486      * the Toolkit implementation doesn't support custom cursors.
1487      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
1488      * returns true
1489      * @see       java.awt.GraphicsEnvironment#isHeadless
1490      * @since     1.2
1491      */
1492     public Dimension getBestCursorSize(int preferredWidth,
1493         int preferredHeight) throws HeadlessException {
1494         GraphicsEnvironment.checkHeadless();
1495 
1496         // Override to implement custom cursor support.
1497         if (this != Toolkit.getDefaultToolkit()) {
1498             return Toolkit.getDefaultToolkit().
1499                 getBestCursorSize(preferredWidth, preferredHeight);
1500         } else {
1501             return new Dimension(0, 0);
1502         }
1503     }
1504 
1505     /**
1506      * Returns the maximum number of colors the Toolkit supports in a custom cursor
1507      * palette.<p>
1508      * Note: if an image is used which has more colors in its palette than
1509      * the supported maximum, the Toolkit implementation will attempt to flatten the
1510      * palette to the maximum.  Since converting low-resolution images is difficult,
1511      * no guarantees are made as to the quality of a cursor image which has more
1512      * colors than the system supports.  It is therefore recommended that this method
1513      * be called and an appropriate image used so no image conversion is made.
1514      *
1515      * @return    the maximum number of colors, or zero if custom cursors are not
1516      * supported by this Toolkit implementation.
1517      * @exception HeadlessException if GraphicsEnvironment.isHeadless()
1518      * returns true
1519      * @see       java.awt.GraphicsEnvironment#isHeadless
1520      * @since     1.2
1521      */
1522     public int getMaximumCursorColors() throws HeadlessException {
1523         GraphicsEnvironment.checkHeadless();
1524 
1525         // Override to implement custom cursor support.
1526         if (this != Toolkit.getDefaultToolkit()) {
1527             return Toolkit.getDefaultToolkit().getMaximumCursorColors();
1528         } else {
1529             return 0;
1530         }
1531     }
1532 
1533     /**
1534      * Returns whether Toolkit supports this state for
1535      * <code>Frame</code>s.  This method tells whether the <em>UI
1536      * concept</em> of, say, maximization or iconification is
1537      * supported.  It will always return false for "compound" states
1538      * like <code>Frame.ICONIFIED|Frame.MAXIMIZED_VERT</code>.
1539      * In other words, the rule of thumb is that only queries with a
1540      * single frame state constant as an argument are meaningful.
1541      * <p>Note that supporting a given concept is a platform-
1542      * dependent feature. Due to native limitations the Toolkit
1543      * object may report a particular state as supported, however at
1544      * the same time the Toolkit object will be unable to apply the
1545      * state to a given frame.  This circumstance has two following
1546      * consequences:
1547      * <ul>
1548      * <li>Only the return value of {@code false} for the present
1549      * method actually indicates that the given state is not
1550      * supported. If the method returns {@code true} the given state
1551      * may still be unsupported and/or unavailable for a particular
1552      * frame.
1553      * <li>The developer should consider examining the value of the
1554      * {@link java.awt.event.WindowEvent#getNewState} method of the
1555      * {@code WindowEvent} received through the {@link
1556      * java.awt.event.WindowStateListener}, rather than assuming
1557      * that the state given to the {@code setExtendedState()} method
1558      * will be definitely applied. For more information see the
1559      * documentation for the {@link Frame#setExtendedState} method.
1560      * </ul>
1561      *
1562      * @param state one of named frame state constants.
1563      * @return <code>true</code> is this frame state is supported by
1564      *     this Toolkit implementation, <code>false</code> otherwise.
1565      * @exception HeadlessException
1566      *     if <code>GraphicsEnvironment.isHeadless()</code>
1567      *     returns <code>true</code>.
1568      * @see java.awt.Window#addWindowStateListener
1569      * @since   1.4
1570      */
1571     public boolean isFrameStateSupported(int state)
1572         throws HeadlessException
1573     {
1574         GraphicsEnvironment.checkHeadless();
1575 
1576         if (this != Toolkit.getDefaultToolkit()) {
1577             return Toolkit.getDefaultToolkit().
1578                 isFrameStateSupported(state);
1579         } else {
1580             return (state == Frame.NORMAL); // others are not guaranteed
1581         }
1582     }
1583 
1584     /**
1585      * Support for I18N: any visible strings should be stored in
1586      * sun.awt.resources.awt.properties.  The ResourceBundle is stored
1587      * here, so that only one copy is maintained.
1588      */
1589     private static ResourceBundle resources;
1590     private static ResourceBundle platformResources;
1591 
1592     // called by platform toolkit
1593     private static void setPlatformResources(ResourceBundle bundle) {
1594         platformResources = bundle;
1595     }
1596 
1597     /**
1598      * Initialize JNI field and method ids
1599      */
1600     private static native void initIDs();
1601 
1602     /**
1603      * WARNING: This is a temporary workaround for a problem in the
1604      * way the AWT loads native libraries. A number of classes in the
1605      * AWT package have a native method, initIDs(), which initializes
1606      * the JNI field and method ids used in the native portion of
1607      * their implementation.
1608      *
1609      * Since the use and storage of these ids is done by the
1610      * implementation libraries, the implementation of these method is
1611      * provided by the particular AWT implementations (for example,
1612      * "Toolkit"s/Peer), such as Motif, Microsoft Windows, or Tiny. The
1613      * problem is that this means that the native libraries must be
1614      * loaded by the java.* classes, which do not necessarily know the
1615      * names of the libraries to load. A better way of doing this
1616      * would be to provide a separate library which defines java.awt.*
1617      * initIDs, and exports the relevant symbols out to the
1618      * implementation libraries.
1619      *
1620      * For now, we know it's done by the implementation, and we assume
1621      * that the name of the library is "awt".  -br.
1622      *
1623      * If you change loadLibraries(), please add the change to
1624      * java.awt.image.ColorModel.loadLibraries(). Unfortunately,
1625      * classes can be loaded in java.awt.image that depend on
1626      * libawt and there is no way to call Toolkit.loadLibraries()
1627      * directly.  -hung
1628      */
1629     private static boolean loaded = false;
1630     static void loadLibraries() {
1631         if (!loaded) {
1632             java.security.AccessController.doPrivileged(
1633                 new java.security.PrivilegedAction<Void>() {
1634                     public Void run() {
1635                         System.loadLibrary("awt");
1636                         return null;
1637                     }
1638                 });
1639             loaded = true;
1640         }
1641     }
1642 
1643     static {
1644         AWTAccessor.setToolkitAccessor(
1645                 new AWTAccessor.ToolkitAccessor() {
1646                     @Override
1647                     public void setPlatformResources(ResourceBundle bundle) {
1648                         Toolkit.setPlatformResources(bundle);
1649                     }
1650                 });
1651 
1652         java.security.AccessController.doPrivileged(
1653                                  new java.security.PrivilegedAction<Void>() {
1654             public Void run() {
1655                 try {
1656                     resources =
1657                         ResourceBundle.getBundle("sun.awt.resources.awt",
1658                                                  CoreResourceBundleControl.getRBControlInstance());
1659                 } catch (MissingResourceException e) {
1660                     // No resource file; defaults will be used.
1661                 }
1662                 return null;
1663             }
1664         });
1665 
1666         // ensure that the proper libraries are loaded
1667         loadLibraries();
1668         initAssistiveTechnologies();
1669         if (!GraphicsEnvironment.isHeadless()) {
1670             initIDs();
1671         }
1672     }
1673 
1674     /**
1675      * Gets a property with the specified key and default.
1676      * This method returns defaultValue if the property is not found.
1677      */
1678     public static String getProperty(String key, String defaultValue) {
1679         // first try platform specific bundle
1680         if (platformResources != null) {
1681             try {
1682                 return platformResources.getString(key);
1683             }
1684             catch (MissingResourceException e) {}
1685         }
1686 
1687         // then shared one
1688         if (resources != null) {
1689             try {
1690                 return resources.getString(key);
1691             }
1692             catch (MissingResourceException e) {}
1693         }
1694 
1695         return defaultValue;
1696     }
1697 
1698     /**
1699      * Get the application's or applet's EventQueue instance.
1700      * Depending on the Toolkit implementation, different EventQueues
1701      * may be returned for different applets.  Applets should
1702      * therefore not assume that the EventQueue instance returned
1703      * by this method will be shared by other applets or the system.
1704      *
1705      * <p> If there is a security manager then its
1706      * {@link SecurityManager#checkPermission checkPermission} method
1707      * is called to check {@code AWTPermission("accessEventQueue")}.
1708      *
1709      * @return    the <code>EventQueue</code> object
1710      * @throws  SecurityException
1711      *          if a security manager is set and it denies access to
1712      *          the {@code EventQueue}
1713      * @see     java.awt.AWTPermission
1714     */
1715     public final EventQueue getSystemEventQueue() {
1716         SecurityManager security = System.getSecurityManager();
1717         if (security != null) {
1718             security.checkPermission(AWTPermissions.CHECK_AWT_EVENTQUEUE_PERMISSION);
1719         }
1720         return getSystemEventQueueImpl();
1721     }
1722 
1723     /**
1724      * Gets the application's or applet's <code>EventQueue</code>
1725      * instance, without checking access.  For security reasons,
1726      * this can only be called from a <code>Toolkit</code> subclass.
1727      * @return the <code>EventQueue</code> object
1728      */
1729     protected abstract EventQueue getSystemEventQueueImpl();
1730 
1731     /* Accessor method for use by AWT package routines. */
1732     static EventQueue getEventQueue() {
1733         return getDefaultToolkit().getSystemEventQueueImpl();
1734     }
1735 
1736     /**
1737      * Creates the peer for a DragSourceContext.
1738      * Always throws InvalidDndOperationException if
1739      * GraphicsEnvironment.isHeadless() returns true.
1740      * @see java.awt.GraphicsEnvironment#isHeadless
1741      */
1742     public abstract DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge) throws InvalidDnDOperationException;
1743 
1744     /**
1745      * Creates a concrete, platform dependent, subclass of the abstract
1746      * DragGestureRecognizer class requested, and associates it with the
1747      * DragSource, Component and DragGestureListener specified.
1748      *
1749      * subclasses should override this to provide their own implementation
1750      *
1751      * @param abstractRecognizerClass The abstract class of the required recognizer
1752      * @param ds                      The DragSource
1753      * @param c                       The Component target for the DragGestureRecognizer
1754      * @param srcActions              The actions permitted for the gesture
1755      * @param dgl                     The DragGestureListener
1756      *
1757      * @return the new object or null.  Always returns null if
1758      * GraphicsEnvironment.isHeadless() returns true.
1759      * @see java.awt.GraphicsEnvironment#isHeadless
1760      */
1761     public <T extends DragGestureRecognizer> T
1762         createDragGestureRecognizer(Class<T> abstractRecognizerClass,
1763                                     DragSource ds, Component c, int srcActions,
1764                                     DragGestureListener dgl)
1765     {
1766         return null;
1767     }
1768 
1769     /**
1770      * Obtains a value for the specified desktop property.
1771      *
1772      * A desktop property is a uniquely named value for a resource that
1773      * is Toolkit global in nature. Usually it also is an abstract
1774      * representation for an underlying platform dependent desktop setting.
1775      * For more information on desktop properties supported by the AWT see
1776      * <a href="doc-files/DesktopProperties.html">AWT Desktop Properties</a>.
1777      */
1778     public final synchronized Object getDesktopProperty(String propertyName) {
1779         // This is a workaround for headless toolkits.  It would be
1780         // better to override this method but it is declared final.
1781         // "this instanceof" syntax defeats polymorphism.
1782         // --mm, 03/03/00
1783         if (this instanceof HeadlessToolkit) {
1784             return ((HeadlessToolkit)this).getUnderlyingToolkit()
1785                 .getDesktopProperty(propertyName);
1786         }
1787 
1788         if (desktopProperties.isEmpty()) {
1789             initializeDesktopProperties();
1790         }
1791 
1792         Object value;
1793 
1794         // This property should never be cached
1795         if (propertyName.equals("awt.dynamicLayoutSupported")) {
1796             return getDefaultToolkit().lazilyLoadDesktopProperty(propertyName);
1797         }
1798 
1799         value = desktopProperties.get(propertyName);
1800 
1801         if (value == null) {
1802             value = lazilyLoadDesktopProperty(propertyName);
1803 
1804             if (value != null) {
1805                 setDesktopProperty(propertyName, value);
1806             }
1807         }
1808 
1809         /* for property "awt.font.desktophints" */
1810         if (value instanceof RenderingHints) {
1811             value = ((RenderingHints)value).clone();
1812         }
1813 
1814         return value;
1815     }
1816 
1817     /**
1818      * Sets the named desktop property to the specified value and fires a
1819      * property change event to notify any listeners that the value has changed.
1820      */
1821     protected final void setDesktopProperty(String name, Object newValue) {
1822         // This is a workaround for headless toolkits.  It would be
1823         // better to override this method but it is declared final.
1824         // "this instanceof" syntax defeats polymorphism.
1825         // --mm, 03/03/00
1826         if (this instanceof HeadlessToolkit) {
1827             ((HeadlessToolkit)this).getUnderlyingToolkit()
1828                 .setDesktopProperty(name, newValue);
1829             return;
1830         }
1831         Object oldValue;
1832 
1833         synchronized (this) {
1834             oldValue = desktopProperties.get(name);
1835             desktopProperties.put(name, newValue);
1836         }
1837 
1838         // Don't fire change event if old and new values are null.
1839         // It helps to avoid recursive resending of WM_THEMECHANGED
1840         if (oldValue != null || newValue != null) {
1841             desktopPropsSupport.firePropertyChange(name, oldValue, newValue);
1842         }
1843     }
1844 
1845     /**
1846      * an opportunity to lazily evaluate desktop property values.
1847      */
1848     protected Object lazilyLoadDesktopProperty(String name) {
1849         return null;
1850     }
1851 
1852     /**
1853      * initializeDesktopProperties
1854      */
1855     protected void initializeDesktopProperties() {
1856     }
1857 
1858     /**
1859      * Adds the specified property change listener for the named desktop
1860      * property. When a {@link java.beans.PropertyChangeListenerProxy} object is added,
1861      * its property name is ignored, and the wrapped listener is added.
1862      * If {@code name} is {@code null} or {@code pcl} is {@code null},
1863      * no exception is thrown and no action is performed.
1864      *
1865      * @param   name The name of the property to listen for
1866      * @param   pcl The property change listener
1867      * @see PropertyChangeSupport#addPropertyChangeListener(String,
1868                 PropertyChangeListener)
1869      * @since   1.2
1870      */
1871     public void addPropertyChangeListener(String name, PropertyChangeListener pcl) {
1872         desktopPropsSupport.addPropertyChangeListener(name, pcl);
1873     }
1874 
1875     /**
1876      * Removes the specified property change listener for the named
1877      * desktop property. When a {@link java.beans.PropertyChangeListenerProxy} object
1878      * is removed, its property name is ignored, and
1879      * the wrapped listener is removed.
1880      * If {@code name} is {@code null} or {@code pcl} is {@code null},
1881      * no exception is thrown and no action is performed.
1882      *
1883      * @param   name The name of the property to remove
1884      * @param   pcl The property change listener
1885      * @see PropertyChangeSupport#removePropertyChangeListener(String,
1886                 PropertyChangeListener)
1887      * @since   1.2
1888      */
1889     public void removePropertyChangeListener(String name, PropertyChangeListener pcl) {
1890         desktopPropsSupport.removePropertyChangeListener(name, pcl);
1891     }
1892 
1893     /**
1894      * Returns an array of all the property change listeners
1895      * registered on this toolkit. The returned array
1896      * contains {@link java.beans.PropertyChangeListenerProxy} objects
1897      * that associate listeners with the names of desktop properties.
1898      *
1899      * @return all of this toolkit's {@link PropertyChangeListener}
1900      *         objects wrapped in {@code java.beans.PropertyChangeListenerProxy} objects
1901      *         or an empty array  if no listeners are added
1902      *
1903      * @see PropertyChangeSupport#getPropertyChangeListeners()
1904      * @since 1.4
1905      */
1906     public PropertyChangeListener[] getPropertyChangeListeners() {
1907         return desktopPropsSupport.getPropertyChangeListeners();
1908     }
1909 
1910     /**
1911      * Returns an array of all property change listeners
1912      * associated with the specified name of a desktop property.
1913      *
1914      * @param  propertyName the named property
1915      * @return all of the {@code PropertyChangeListener} objects
1916      *         associated with the specified name of a desktop property
1917      *         or an empty array if no such listeners are added
1918      *
1919      * @see PropertyChangeSupport#getPropertyChangeListeners(String)
1920      * @since 1.4
1921      */
1922     public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
1923         return desktopPropsSupport.getPropertyChangeListeners(propertyName);
1924     }
1925 
1926     protected final Map<String,Object> desktopProperties =
1927             new HashMap<String,Object>();
1928     protected final PropertyChangeSupport desktopPropsSupport =
1929             Toolkit.createPropertyChangeSupport(this);
1930 
1931     /**
1932      * Returns whether the always-on-top mode is supported by this toolkit.
1933      * To detect whether the always-on-top mode is supported for a
1934      * particular Window, use {@link Window#isAlwaysOnTopSupported}.
1935      * @return <code>true</code>, if current toolkit supports the always-on-top mode,
1936      *     otherwise returns <code>false</code>
1937      * @see Window#isAlwaysOnTopSupported
1938      * @see Window#setAlwaysOnTop(boolean)
1939      * @since 1.6
1940      */
1941     public boolean isAlwaysOnTopSupported() {
1942         return true;
1943     }
1944 
1945     /**
1946      * Returns whether the given modality type is supported by this toolkit. If
1947      * a dialog with unsupported modality type is created, then
1948      * <code>Dialog.ModalityType.MODELESS</code> is used instead.
1949      *
1950      * @param modalityType modality type to be checked for support by this toolkit
1951      *
1952      * @return <code>true</code>, if current toolkit supports given modality
1953      *     type, <code>false</code> otherwise
1954      *
1955      * @see java.awt.Dialog.ModalityType
1956      * @see java.awt.Dialog#getModalityType
1957      * @see java.awt.Dialog#setModalityType
1958      *
1959      * @since 1.6
1960      */
1961     public abstract boolean isModalityTypeSupported(Dialog.ModalityType modalityType);
1962 
1963     /**
1964      * Returns whether the given modal exclusion type is supported by this
1965      * toolkit. If an unsupported modal exclusion type property is set on a window,
1966      * then <code>Dialog.ModalExclusionType.NO_EXCLUDE</code> is used instead.
1967      *
1968      * @param modalExclusionType modal exclusion type to be checked for support by this toolkit
1969      *
1970      * @return <code>true</code>, if current toolkit supports given modal exclusion
1971      *     type, <code>false</code> otherwise
1972      *
1973      * @see java.awt.Dialog.ModalExclusionType
1974      * @see java.awt.Window#getModalExclusionType
1975      * @see java.awt.Window#setModalExclusionType
1976      *
1977      * @since 1.6
1978      */
1979     public abstract boolean isModalExclusionTypeSupported(Dialog.ModalExclusionType modalExclusionType);
1980 
1981     // 8014718: logging has been removed from SunToolkit
1982 
1983     private static final int LONG_BITS = 64;
1984     private int[] calls = new int[LONG_BITS];
1985     private static volatile long enabledOnToolkitMask;
1986     private AWTEventListener eventListener = null;
1987     private WeakHashMap<AWTEventListener, SelectiveAWTEventListener> listener2SelectiveListener = new WeakHashMap<>();
1988 
1989     /*
1990      * Extracts a "pure" AWTEventListener from a AWTEventListenerProxy,
1991      * if the listener is proxied.
1992      */
1993     static private AWTEventListener deProxyAWTEventListener(AWTEventListener l)
1994     {
1995         AWTEventListener localL = l;
1996 
1997         if (localL == null) {
1998             return null;
1999         }
2000         // if user passed in a AWTEventListenerProxy object, extract
2001         // the listener
2002         if (l instanceof AWTEventListenerProxy) {
2003             localL = ((AWTEventListenerProxy)l).getListener();
2004         }
2005         return localL;
2006     }
2007 
2008     /**
2009      * Adds an AWTEventListener to receive all AWTEvents dispatched
2010      * system-wide that conform to the given <code>eventMask</code>.
2011      * <p>
2012      * First, if there is a security manager, its <code>checkPermission</code>
2013      * method is called with an
2014      * <code>AWTPermission("listenToAllAWTEvents")</code> permission.
2015      * This may result in a SecurityException.
2016      * <p>
2017      * <code>eventMask</code> is a bitmask of event types to receive.
2018      * It is constructed by bitwise OR-ing together the event masks
2019      * defined in <code>AWTEvent</code>.
2020      * <p>
2021      * Note:  event listener use is not recommended for normal
2022      * application use, but are intended solely to support special
2023      * purpose facilities including support for accessibility,
2024      * event record/playback, and diagnostic tracing.
2025      *
2026      * If listener is null, no exception is thrown and no action is performed.
2027      *
2028      * @param    listener   the event listener.
2029      * @param    eventMask  the bitmask of event types to receive
2030      * @throws SecurityException
2031      *        if a security manager exists and its
2032      *        <code>checkPermission</code> method doesn't allow the operation.
2033      * @see      #removeAWTEventListener
2034      * @see      #getAWTEventListeners
2035      * @see      SecurityManager#checkPermission
2036      * @see      java.awt.AWTEvent
2037      * @see      java.awt.AWTPermission
2038      * @see      java.awt.event.AWTEventListener
2039      * @see      java.awt.event.AWTEventListenerProxy
2040      * @since    1.2
2041      */
2042     public void addAWTEventListener(AWTEventListener listener, long eventMask) {
2043         AWTEventListener localL = deProxyAWTEventListener(listener);
2044 
2045         if (localL == null) {
2046             return;
2047         }
2048         SecurityManager security = System.getSecurityManager();
2049         if (security != null) {
2050           security.checkPermission(AWTPermissions.ALL_AWT_EVENTS_PERMISSION);
2051         }
2052         synchronized (this) {
2053             SelectiveAWTEventListener selectiveListener =
2054                 listener2SelectiveListener.get(localL);
2055 
2056             if (selectiveListener == null) {
2057                 // Create a new selectiveListener.
2058                 selectiveListener = new SelectiveAWTEventListener(localL,
2059                                                                  eventMask);
2060                 listener2SelectiveListener.put(localL, selectiveListener);
2061                 eventListener = ToolkitEventMulticaster.add(eventListener,
2062                                                             selectiveListener);
2063             }
2064             // OR the eventMask into the selectiveListener's event mask.
2065             selectiveListener.orEventMasks(eventMask);
2066 
2067             enabledOnToolkitMask |= eventMask;
2068 
2069             long mask = eventMask;
2070             for (int i=0; i<LONG_BITS; i++) {
2071                 // If no bits are set, break out of loop.
2072                 if (mask == 0) {
2073                     break;
2074                 }
2075                 if ((mask & 1L) != 0) {  // Always test bit 0.
2076                     calls[i]++;
2077                 }
2078                 mask >>>= 1;  // Right shift, fill with zeros on left.
2079             }
2080         }
2081     }
2082 
2083     /**
2084      * Removes an AWTEventListener from receiving dispatched AWTEvents.
2085      * <p>
2086      * First, if there is a security manager, its <code>checkPermission</code>
2087      * method is called with an
2088      * <code>AWTPermission("listenToAllAWTEvents")</code> permission.
2089      * This may result in a SecurityException.
2090      * <p>
2091      * Note:  event listener use is not recommended for normal
2092      * application use, but are intended solely to support special
2093      * purpose facilities including support for accessibility,
2094      * event record/playback, and diagnostic tracing.
2095      *
2096      * If listener is null, no exception is thrown and no action is performed.
2097      *
2098      * @param    listener   the event listener.
2099      * @throws SecurityException
2100      *        if a security manager exists and its
2101      *        <code>checkPermission</code> method doesn't allow the operation.
2102      * @see      #addAWTEventListener
2103      * @see      #getAWTEventListeners
2104      * @see      SecurityManager#checkPermission
2105      * @see      java.awt.AWTEvent
2106      * @see      java.awt.AWTPermission
2107      * @see      java.awt.event.AWTEventListener
2108      * @see      java.awt.event.AWTEventListenerProxy
2109      * @since    1.2
2110      */
2111     public void removeAWTEventListener(AWTEventListener listener) {
2112         AWTEventListener localL = deProxyAWTEventListener(listener);
2113 
2114         if (listener == null) {
2115             return;
2116         }
2117         SecurityManager security = System.getSecurityManager();
2118         if (security != null) {
2119             security.checkPermission(AWTPermissions.ALL_AWT_EVENTS_PERMISSION);
2120         }
2121 
2122         synchronized (this) {
2123             SelectiveAWTEventListener selectiveListener =
2124                 listener2SelectiveListener.get(localL);
2125 
2126             if (selectiveListener != null) {
2127                 listener2SelectiveListener.remove(localL);
2128                 int[] listenerCalls = selectiveListener.getCalls();
2129                 for (int i=0; i<LONG_BITS; i++) {
2130                     calls[i] -= listenerCalls[i];
2131                     assert calls[i] >= 0: "Negative Listeners count";
2132 
2133                     if (calls[i] == 0) {
2134                         enabledOnToolkitMask &= ~(1L<<i);
2135                     }
2136                 }
2137             }
2138             eventListener = ToolkitEventMulticaster.remove(eventListener,
2139             (selectiveListener == null) ? localL : selectiveListener);
2140         }
2141     }
2142 
2143     static boolean enabledOnToolkit(long eventMask) {
2144         return (enabledOnToolkitMask & eventMask) != 0;
2145         }
2146 
2147     synchronized int countAWTEventListeners(long eventMask) {
2148         int ci = 0;
2149         for (; eventMask != 0; eventMask >>>= 1, ci++) {
2150         }
2151         ci--;
2152         return calls[ci];
2153     }
2154     /**
2155      * Returns an array of all the <code>AWTEventListener</code>s
2156      * registered on this toolkit.
2157      * If there is a security manager, its {@code checkPermission}
2158      * method is called with an
2159      * {@code AWTPermission("listenToAllAWTEvents")} permission.
2160      * This may result in a SecurityException.
2161      * Listeners can be returned
2162      * within <code>AWTEventListenerProxy</code> objects, which also contain
2163      * the event mask for the given listener.
2164      * Note that listener objects
2165      * added multiple times appear only once in the returned array.
2166      *
2167      * @return all of the <code>AWTEventListener</code>s or an empty
2168      *         array if no listeners are currently registered
2169      * @throws SecurityException
2170      *        if a security manager exists and its
2171      *        <code>checkPermission</code> method doesn't allow the operation.
2172      * @see      #addAWTEventListener
2173      * @see      #removeAWTEventListener
2174      * @see      SecurityManager#checkPermission
2175      * @see      java.awt.AWTEvent
2176      * @see      java.awt.AWTPermission
2177      * @see      java.awt.event.AWTEventListener
2178      * @see      java.awt.event.AWTEventListenerProxy
2179      * @since 1.4
2180      */
2181     public AWTEventListener[] getAWTEventListeners() {
2182         SecurityManager security = System.getSecurityManager();
2183         if (security != null) {
2184             security.checkPermission(AWTPermissions.ALL_AWT_EVENTS_PERMISSION);
2185         }
2186         synchronized (this) {
2187             EventListener[] la = ToolkitEventMulticaster.getListeners(eventListener,AWTEventListener.class);
2188 
2189             AWTEventListener[] ret = new AWTEventListener[la.length];
2190             for (int i = 0; i < la.length; i++) {
2191                 SelectiveAWTEventListener sael = (SelectiveAWTEventListener)la[i];
2192                 AWTEventListener tempL = sael.getListener();
2193                 //assert tempL is not an AWTEventListenerProxy - we should
2194                 // have weeded them all out
2195                 // don't want to wrap a proxy inside a proxy
2196                 ret[i] = new AWTEventListenerProxy(sael.getEventMask(), tempL);
2197             }
2198             return ret;
2199         }
2200     }
2201 
2202     /**
2203      * Returns an array of all the <code>AWTEventListener</code>s
2204      * registered on this toolkit which listen to all of the event
2205      * types specified in the {@code eventMask} argument.
2206      * If there is a security manager, its {@code checkPermission}
2207      * method is called with an
2208      * {@code AWTPermission("listenToAllAWTEvents")} permission.
2209      * This may result in a SecurityException.
2210      * Listeners can be returned
2211      * within <code>AWTEventListenerProxy</code> objects, which also contain
2212      * the event mask for the given listener.
2213      * Note that listener objects
2214      * added multiple times appear only once in the returned array.
2215      *
2216      * @param  eventMask the bitmask of event types to listen for
2217      * @return all of the <code>AWTEventListener</code>s registered
2218      *         on this toolkit for the specified
2219      *         event types, or an empty array if no such listeners
2220      *         are currently registered
2221      * @throws SecurityException
2222      *        if a security manager exists and its
2223      *        <code>checkPermission</code> method doesn't allow the operation.
2224      * @see      #addAWTEventListener
2225      * @see      #removeAWTEventListener
2226      * @see      SecurityManager#checkPermission
2227      * @see      java.awt.AWTEvent
2228      * @see      java.awt.AWTPermission
2229      * @see      java.awt.event.AWTEventListener
2230      * @see      java.awt.event.AWTEventListenerProxy
2231      * @since 1.4
2232      */
2233     public AWTEventListener[] getAWTEventListeners(long eventMask) {
2234         SecurityManager security = System.getSecurityManager();
2235         if (security != null) {
2236             security.checkPermission(AWTPermissions.ALL_AWT_EVENTS_PERMISSION);
2237         }
2238         synchronized (this) {
2239             EventListener[] la = ToolkitEventMulticaster.getListeners(eventListener,AWTEventListener.class);
2240 
2241             java.util.List<AWTEventListenerProxy> list = new ArrayList<>(la.length);
2242 
2243             for (int i = 0; i < la.length; i++) {
2244                 SelectiveAWTEventListener sael = (SelectiveAWTEventListener)la[i];
2245                 if ((sael.getEventMask() & eventMask) == eventMask) {
2246                     //AWTEventListener tempL = sael.getListener();
2247                     list.add(new AWTEventListenerProxy(sael.getEventMask(),
2248                                                        sael.getListener()));
2249                 }
2250             }
2251             return list.toArray(new AWTEventListener[0]);
2252         }
2253     }
2254 
2255     /*
2256      * This method notifies any AWTEventListeners that an event
2257      * is about to be dispatched.
2258      *
2259      * @param theEvent the event which will be dispatched.
2260      */
2261     void notifyAWTEventListeners(AWTEvent theEvent) {
2262         // This is a workaround for headless toolkits.  It would be
2263         // better to override this method but it is declared package private.
2264         // "this instanceof" syntax defeats polymorphism.
2265         // --mm, 03/03/00
2266         if (this instanceof HeadlessToolkit) {
2267             ((HeadlessToolkit)this).getUnderlyingToolkit()
2268                 .notifyAWTEventListeners(theEvent);
2269             return;
2270         }
2271 
2272         AWTEventListener eventListener = this.eventListener;
2273         if (eventListener != null) {
2274             eventListener.eventDispatched(theEvent);
2275         }
2276     }
2277 
2278     static private class ToolkitEventMulticaster extends AWTEventMulticaster
2279         implements AWTEventListener {
2280         // Implementation cloned from AWTEventMulticaster.
2281 
2282         ToolkitEventMulticaster(AWTEventListener a, AWTEventListener b) {
2283             super(a, b);
2284         }
2285 
2286         @SuppressWarnings("overloads")
2287         static AWTEventListener add(AWTEventListener a,
2288                                     AWTEventListener b) {
2289             if (a == null)  return b;
2290             if (b == null)  return a;
2291             return new ToolkitEventMulticaster(a, b);
2292         }
2293 
2294         @SuppressWarnings("overloads")
2295         static AWTEventListener remove(AWTEventListener l,
2296                                        AWTEventListener oldl) {
2297             return (AWTEventListener) removeInternal(l, oldl);
2298         }
2299 
2300         // #4178589: must overload remove(EventListener) to call our add()
2301         // instead of the static addInternal() so we allocate a
2302         // ToolkitEventMulticaster instead of an AWTEventMulticaster.
2303         // Note: this method is called by AWTEventListener.removeInternal(),
2304         // so its method signature must match AWTEventListener.remove().
2305         protected EventListener remove(EventListener oldl) {
2306             if (oldl == a)  return b;
2307             if (oldl == b)  return a;
2308             AWTEventListener a2 = (AWTEventListener)removeInternal(a, oldl);
2309             AWTEventListener b2 = (AWTEventListener)removeInternal(b, oldl);
2310             if (a2 == a && b2 == b) {
2311                 return this;    // it's not here
2312             }
2313             return add(a2, b2);
2314         }
2315 
2316         public void eventDispatched(AWTEvent event) {
2317             ((AWTEventListener)a).eventDispatched(event);
2318             ((AWTEventListener)b).eventDispatched(event);
2319         }
2320     }
2321 
2322     private class SelectiveAWTEventListener implements AWTEventListener {
2323         AWTEventListener listener;
2324         private long eventMask;
2325         // This array contains the number of times to call the eventlistener
2326         // for each event type.
2327         int[] calls = new int[Toolkit.LONG_BITS];
2328 
2329         public AWTEventListener getListener() {return listener;}
2330         public long getEventMask() {return eventMask;}
2331         public int[] getCalls() {return calls;}
2332 
2333         public void orEventMasks(long mask) {
2334             eventMask |= mask;
2335             // For each event bit set in mask, increment its call count.
2336             for (int i=0; i<Toolkit.LONG_BITS; i++) {
2337                 // If no bits are set, break out of loop.
2338                 if (mask == 0) {
2339                     break;
2340                 }
2341                 if ((mask & 1L) != 0) {  // Always test bit 0.
2342                     calls[i]++;
2343                 }
2344                 mask >>>= 1;  // Right shift, fill with zeros on left.
2345             }
2346         }
2347 
2348         SelectiveAWTEventListener(AWTEventListener l, long mask) {
2349             listener = l;
2350             eventMask = mask;
2351         }
2352 
2353         public void eventDispatched(AWTEvent event) {
2354             long eventBit = 0; // Used to save the bit of the event type.
2355             if (((eventBit = eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 &&
2356                  event.id >= ComponentEvent.COMPONENT_FIRST &&
2357                  event.id <= ComponentEvent.COMPONENT_LAST)
2358              || ((eventBit = eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 &&
2359                  event.id >= ContainerEvent.CONTAINER_FIRST &&
2360                  event.id <= ContainerEvent.CONTAINER_LAST)
2361              || ((eventBit = eventMask & AWTEvent.FOCUS_EVENT_MASK) != 0 &&
2362                  event.id >= FocusEvent.FOCUS_FIRST &&
2363                  event.id <= FocusEvent.FOCUS_LAST)
2364              || ((eventBit = eventMask & AWTEvent.KEY_EVENT_MASK) != 0 &&
2365                  event.id >= KeyEvent.KEY_FIRST &&
2366                  event.id <= KeyEvent.KEY_LAST)
2367              || ((eventBit = eventMask & AWTEvent.MOUSE_WHEEL_EVENT_MASK) != 0 &&
2368                  event.id == MouseEvent.MOUSE_WHEEL)
2369              || ((eventBit = eventMask & AWTEvent.MOUSE_MOTION_EVENT_MASK) != 0 &&
2370                  (event.id == MouseEvent.MOUSE_MOVED ||
2371                   event.id == MouseEvent.MOUSE_DRAGGED))
2372              || ((eventBit = eventMask & AWTEvent.MOUSE_EVENT_MASK) != 0 &&
2373                  event.id != MouseEvent.MOUSE_MOVED &&
2374                  event.id != MouseEvent.MOUSE_DRAGGED &&
2375                  event.id != MouseEvent.MOUSE_WHEEL &&
2376                  event.id >= MouseEvent.MOUSE_FIRST &&
2377                  event.id <= MouseEvent.MOUSE_LAST)
2378              || ((eventBit = eventMask & AWTEvent.WINDOW_EVENT_MASK) != 0 &&
2379                  (event.id >= WindowEvent.WINDOW_FIRST &&
2380                  event.id <= WindowEvent.WINDOW_LAST))
2381              || ((eventBit = eventMask & AWTEvent.ACTION_EVENT_MASK) != 0 &&
2382                  event.id >= ActionEvent.ACTION_FIRST &&
2383                  event.id <= ActionEvent.ACTION_LAST)
2384              || ((eventBit = eventMask & AWTEvent.ADJUSTMENT_EVENT_MASK) != 0 &&
2385                  event.id >= AdjustmentEvent.ADJUSTMENT_FIRST &&
2386                  event.id <= AdjustmentEvent.ADJUSTMENT_LAST)
2387              || ((eventBit = eventMask & AWTEvent.ITEM_EVENT_MASK) != 0 &&
2388                  event.id >= ItemEvent.ITEM_FIRST &&
2389                  event.id <= ItemEvent.ITEM_LAST)
2390              || ((eventBit = eventMask & AWTEvent.TEXT_EVENT_MASK) != 0 &&
2391                  event.id >= TextEvent.TEXT_FIRST &&
2392                  event.id <= TextEvent.TEXT_LAST)
2393              || ((eventBit = eventMask & AWTEvent.INPUT_METHOD_EVENT_MASK) != 0 &&
2394                  event.id >= InputMethodEvent.INPUT_METHOD_FIRST &&
2395                  event.id <= InputMethodEvent.INPUT_METHOD_LAST)
2396              || ((eventBit = eventMask & AWTEvent.PAINT_EVENT_MASK) != 0 &&
2397                  event.id >= PaintEvent.PAINT_FIRST &&
2398                  event.id <= PaintEvent.PAINT_LAST)
2399              || ((eventBit = eventMask & AWTEvent.INVOCATION_EVENT_MASK) != 0 &&
2400                  event.id >= InvocationEvent.INVOCATION_FIRST &&
2401                  event.id <= InvocationEvent.INVOCATION_LAST)
2402              || ((eventBit = eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0 &&
2403                  event.id == HierarchyEvent.HIERARCHY_CHANGED)
2404              || ((eventBit = eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0 &&
2405                  (event.id == HierarchyEvent.ANCESTOR_MOVED ||
2406                   event.id == HierarchyEvent.ANCESTOR_RESIZED))
2407              || ((eventBit = eventMask & AWTEvent.WINDOW_STATE_EVENT_MASK) != 0 &&
2408                  event.id == WindowEvent.WINDOW_STATE_CHANGED)
2409              || ((eventBit = eventMask & AWTEvent.WINDOW_FOCUS_EVENT_MASK) != 0 &&
2410                  (event.id == WindowEvent.WINDOW_GAINED_FOCUS ||
2411                   event.id == WindowEvent.WINDOW_LOST_FOCUS))
2412                 || ((eventBit = eventMask & sun.awt.SunToolkit.GRAB_EVENT_MASK) != 0 &&
2413                     (event instanceof sun.awt.UngrabEvent))) {
2414                 // Get the index of the call count for this event type.
2415                 // Instead of using Math.log(...) we will calculate it with
2416                 // bit shifts. That's what previous implementation looked like:
2417                 //
2418                 // int ci = (int) (Math.log(eventBit)/Math.log(2));
2419                 int ci = 0;
2420                 for (long eMask = eventBit; eMask != 0; eMask >>>= 1, ci++) {
2421                 }
2422                 ci--;
2423                 // Call the listener as many times as it was added for this
2424                 // event type.
2425                 for (int i=0; i<calls[ci]; i++) {
2426                     listener.eventDispatched(event);
2427                 }
2428             }
2429         }
2430     }
2431 
2432     /**
2433      * Returns a map of visual attributes for the abstract level description
2434      * of the given input method highlight, or null if no mapping is found.
2435      * The style field of the input method highlight is ignored. The map
2436      * returned is unmodifiable.
2437      * @param highlight input method highlight
2438      * @return style attribute map, or <code>null</code>
2439      * @exception HeadlessException if
2440      *     <code>GraphicsEnvironment.isHeadless</code> returns true
2441      * @see       java.awt.GraphicsEnvironment#isHeadless
2442      * @since 1.3
2443      */
2444     public abstract Map<java.awt.font.TextAttribute,?>
2445         mapInputMethodHighlight(InputMethodHighlight highlight)
2446         throws HeadlessException;
2447 
2448     private static PropertyChangeSupport createPropertyChangeSupport(Toolkit toolkit) {
2449         if (toolkit instanceof SunToolkit || toolkit instanceof HeadlessToolkit) {
2450             return new DesktopPropertyChangeSupport(toolkit);
2451         } else {
2452             return new PropertyChangeSupport(toolkit);
2453         }
2454     }
2455 
2456     @SuppressWarnings("serial")
2457     private static class DesktopPropertyChangeSupport extends PropertyChangeSupport {
2458 
2459         private static final StringBuilder PROP_CHANGE_SUPPORT_KEY =
2460                 new StringBuilder("desktop property change support key");
2461         private final Object source;
2462 
2463         public DesktopPropertyChangeSupport(Object sourceBean) {
2464             super(sourceBean);
2465             source = sourceBean;
2466         }
2467 
2468         @Override
2469         public synchronized void addPropertyChangeListener(
2470                 String propertyName,
2471                 PropertyChangeListener listener)
2472         {
2473             PropertyChangeSupport pcs = (PropertyChangeSupport)
2474                     AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
2475             if (null == pcs) {
2476                 pcs = new PropertyChangeSupport(source);
2477                 AppContext.getAppContext().put(PROP_CHANGE_SUPPORT_KEY, pcs);
2478             }
2479             pcs.addPropertyChangeListener(propertyName, listener);
2480         }
2481 
2482         @Override
2483         public synchronized void removePropertyChangeListener(
2484                 String propertyName,
2485                 PropertyChangeListener listener)
2486         {
2487             PropertyChangeSupport pcs = (PropertyChangeSupport)
2488                     AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
2489             if (null != pcs) {
2490                 pcs.removePropertyChangeListener(propertyName, listener);
2491             }
2492         }
2493 
2494         @Override
2495         public synchronized PropertyChangeListener[] getPropertyChangeListeners()
2496         {
2497             PropertyChangeSupport pcs = (PropertyChangeSupport)
2498                     AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
2499             if (null != pcs) {
2500                 return pcs.getPropertyChangeListeners();
2501             } else {
2502                 return new PropertyChangeListener[0];
2503             }
2504         }
2505 
2506         @Override
2507         public synchronized PropertyChangeListener[] getPropertyChangeListeners(String propertyName)
2508         {
2509             PropertyChangeSupport pcs = (PropertyChangeSupport)
2510                     AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
2511             if (null != pcs) {
2512                 return pcs.getPropertyChangeListeners(propertyName);
2513             } else {
2514                 return new PropertyChangeListener[0];
2515             }
2516         }
2517 
2518         @Override
2519         public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {
2520             PropertyChangeSupport pcs = (PropertyChangeSupport)
2521                     AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
2522             if (null == pcs) {
2523                 pcs = new PropertyChangeSupport(source);
2524                 AppContext.getAppContext().put(PROP_CHANGE_SUPPORT_KEY, pcs);
2525             }
2526             pcs.addPropertyChangeListener(listener);
2527         }
2528 
2529         @Override
2530         public synchronized void removePropertyChangeListener(PropertyChangeListener listener) {
2531             PropertyChangeSupport pcs = (PropertyChangeSupport)
2532                     AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
2533             if (null != pcs) {
2534                 pcs.removePropertyChangeListener(listener);
2535             }
2536         }
2537 
2538         /*
2539          * we do expect that all other fireXXX() methods of java.beans.PropertyChangeSupport
2540          * use this method.  If this will be changed we will need to change this class.
2541          */
2542         @Override
2543         public void firePropertyChange(final PropertyChangeEvent evt) {
2544             Object oldValue = evt.getOldValue();
2545             Object newValue = evt.getNewValue();
2546             String propertyName = evt.getPropertyName();
2547             if (oldValue != null && newValue != null && oldValue.equals(newValue)) {
2548                 return;
2549             }
2550             Runnable updater = new Runnable() {
2551                 public void run() {
2552                     PropertyChangeSupport pcs = (PropertyChangeSupport)
2553                             AppContext.getAppContext().get(PROP_CHANGE_SUPPORT_KEY);
2554                     if (null != pcs) {
2555                         pcs.firePropertyChange(evt);
2556                     }
2557                 }
2558             };
2559             final AppContext currentAppContext = AppContext.getAppContext();
2560             for (AppContext appContext : AppContext.getAppContexts()) {
2561                 if (null == appContext || appContext.isDisposed()) {
2562                     continue;
2563                 }
2564                 if (currentAppContext == appContext) {
2565                     updater.run();
2566                 } else {
2567                     final PeerEvent e = new PeerEvent(source, updater, PeerEvent.ULTIMATE_PRIORITY_EVENT);
2568                     SunToolkit.postEvent(appContext, e);
2569                 }
2570             }
2571         }
2572     }
2573 
2574     /**
2575     * Reports whether events from extra mouse buttons are allowed to be processed and posted into
2576     * {@code EventQueue}.
2577     * <br>
2578     * To change the returned value it is necessary to set the {@code sun.awt.enableExtraMouseButtons}
2579     * property before the {@code Toolkit} class initialization. This setting could be done on the application
2580     * startup by the following command:
2581     * <pre>
2582     * java -Dsun.awt.enableExtraMouseButtons=false Application
2583     * </pre>
2584     * Alternatively, the property could be set in the application by using the following code:
2585     * <pre>
2586     * System.setProperty("sun.awt.enableExtraMouseButtons", "true");
2587     * </pre>
2588     * before the {@code Toolkit} class initialization.
2589     * If not set by the time of the {@code Toolkit} class initialization, this property will be
2590     * initialized with {@code true}.
2591     * Changing this value after the {@code Toolkit} class initialization will have no effect.
2592     *
2593     * @exception HeadlessException if GraphicsEnvironment.isHeadless() returns true
2594     * @return {@code true} if events from extra mouse buttons are allowed to be processed and posted;
2595     *         {@code false} otherwise
2596     * @see System#getProperty(String propertyName)
2597     * @see System#setProperty(String propertyName, String value)
2598     * @see java.awt.EventQueue
2599     * @since 1.7
2600      */
2601     public boolean areExtraMouseButtonsEnabled() throws HeadlessException {
2602         GraphicsEnvironment.checkHeadless();
2603 
2604         return Toolkit.getDefaultToolkit().areExtraMouseButtonsEnabled();
2605     }
2606 }