1 /*
   2  * Copyright (c) 2008, 2012, 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 sun.awt;
  27 
  28 import sun.misc.Unsafe;
  29 
  30 import java.awt.*;
  31 import java.awt.KeyboardFocusManager;
  32 import java.awt.DefaultKeyboardFocusManager;
  33 import java.awt.event.InputEvent;
  34 import java.awt.event.KeyEvent;
  35 import java.awt.geom.Point2D;
  36 import java.awt.peer.ComponentPeer;
  37 
  38 import java.lang.reflect.InvocationTargetException;
  39 import java.security.AccessControlContext;
  40 
  41 import java.io.File;
  42 import java.util.Vector;
  43 
  44 /**
  45  * The AWTAccessor utility class.
  46  * The main purpose of this class is to enable accessing
  47  * private and package-private fields of classes from
  48  * different classes/packages. See sun.misc.SharedSecretes
  49  * for another example.
  50  */
  51 public final class AWTAccessor {
  52 
  53     private static final Unsafe unsafe = Unsafe.getUnsafe();
  54 
  55     /*
  56      * We don't need any objects of this class.
  57      * It's rather a collection of static methods
  58      * and interfaces.
  59      */
  60     private AWTAccessor() {
  61     }
  62 
  63     /*
  64      * An interface of accessor for the java.awt.Component class.
  65      */
  66     public interface ComponentAccessor {
  67         /*
  68          * Sets whether the native background erase for a component
  69          * has been disabled via SunToolkit.disableBackgroundErase().
  70          */
  71         void setBackgroundEraseDisabled(Component comp, boolean disabled);
  72         /*
  73          * Indicates whether the native background erase for a
  74          * component has been disabled via
  75          * SunToolkit.disableBackgroundErase().
  76          */
  77         boolean getBackgroundEraseDisabled(Component comp);
  78         /*
  79          *
  80          * Gets the bounds of this component in the form of a
  81          * <code>Rectangle</code> object. The bounds specify this
  82          * component's width, height, and location relative to
  83          * its parent.
  84          */
  85         Rectangle getBounds(Component comp);
  86         /*
  87          * Sets the shape of a lw component to cut out from hw components.
  88          *
  89          * See 6797587, 6776743, 6768307, and 6768332 for details
  90          */
  91         void setMixingCutoutShape(Component comp, Shape shape);
  92 
  93         /**
  94          * Sets GraphicsConfiguration value for the component.
  95          */
  96         void setGraphicsConfiguration(Component comp, GraphicsConfiguration gc);
  97         /*
  98          * Requests focus to the component.
  99          */
 100         boolean requestFocus(Component comp, CausedFocusEvent.Cause cause);
 101         /*
 102          * Determines if the component can gain focus.
 103          */
 104         boolean canBeFocusOwner(Component comp);
 105 
 106         /**
 107          * Returns whether the component is visible without invoking
 108          * any client code.
 109          */
 110         boolean isVisible(Component comp);
 111 
 112         /**
 113          * Sets the RequestFocusController.
 114          */
 115         void setRequestFocusController(RequestFocusController requestController);
 116 
 117         /**
 118          * Returns the appContext of the component.
 119          */
 120         AppContext getAppContext(Component comp);
 121 
 122         /**
 123          * Sets the appContext of the component.
 124          */
 125         void setAppContext(Component comp, AppContext appContext);
 126 
 127         /**
 128          * Returns the parent of the component.
 129          */
 130         Container getParent(Component comp);
 131 
 132         /**
 133          * Sets the parent of the component to the specified parent.
 134          */
 135         void setParent(Component comp, Container parent);
 136 
 137         /**
 138          * Resizes the component to the specified width and height.
 139          */
 140         void setSize(Component comp, int width, int height);
 141 
 142         /**
 143          * Returns the location of the component.
 144          */
 145         Point getLocation(Component comp);
 146 
 147         /**
 148          * Moves the component to the new location.
 149          */
 150         void setLocation(Component comp, int x, int y);
 151 
 152         /**
 153          * Determines whether this component is enabled.
 154          */
 155         boolean isEnabled(Component comp);
 156 
 157         /**
 158          * Determines whether this component is displayable.
 159          */
 160         boolean isDisplayable(Component comp);
 161 
 162         /**
 163          * Gets the cursor set in the component.
 164          */
 165         Cursor getCursor(Component comp);
 166 
 167         /**
 168          * Returns the peer of the component.
 169          */
 170         ComponentPeer getPeer(Component comp);
 171 
 172         /**
 173          * Sets the peer of the component to the specified peer.
 174          */
 175         void setPeer(Component comp, ComponentPeer peer);
 176 
 177         /**
 178          * Determines whether this component is lightweight.
 179          */
 180         boolean isLightweight(Component comp);
 181 
 182         /**
 183          * Returns whether or not paint messages received from
 184          * the operating system should be ignored.
 185          */
 186         boolean getIgnoreRepaint(Component comp);
 187 
 188         /**
 189          * Returns the width of the component.
 190          */
 191         int getWidth(Component comp);
 192 
 193         /**
 194          * Returns the height of the component.
 195          */
 196         int getHeight(Component comp);
 197 
 198         /**
 199          * Returns the x coordinate of the component.
 200          */
 201         int getX(Component comp);
 202 
 203         /**
 204          * Returns the y coordinate of the component.
 205          */
 206         int getY(Component comp);
 207 
 208         /**
 209          * Gets the foreground color of this component.
 210          */
 211         Color getForeground(Component comp);
 212 
 213         /**
 214          * Gets the background color of this component.
 215          */
 216         Color getBackground(Component comp);
 217 
 218         /**
 219          * Sets the background of this component to the specified color.
 220          */
 221         void setBackground(Component comp, Color background);
 222 
 223         /**
 224          * Gets the font of the component.
 225          */
 226         Font getFont(Component comp);
 227 
 228         /**
 229          * Processes events occurring on this component.
 230          */
 231         void processEvent(Component comp, AWTEvent e);
 232 
 233 
 234         /*
 235          * Returns the acc this component was constructed with.
 236          */
 237         AccessControlContext getAccessControlContext(Component comp);
 238 
 239     }
 240 
 241     /*
 242      * An interface of accessor for the java.awt.Container class.
 243      */
 244     public interface ContainerAccessor {
 245         /**
 246          * Validates the container unconditionally.
 247          */
 248         void validateUnconditionally(Container cont);
 249     }
 250 
 251     /*
 252      * An interface of accessor for java.awt.Window class.
 253      */
 254     public interface WindowAccessor {
 255         /*
 256          * Get opacity level of the given window.
 257          */
 258         float getOpacity(Window window);
 259         /*
 260          * Set opacity level to the given window.
 261          */
 262         void setOpacity(Window window, float opacity);
 263         /*
 264          * Get a shape assigned to the given window.
 265          */
 266         Shape getShape(Window window);
 267         /*
 268          * Set a shape to the given window.
 269          */
 270         void setShape(Window window, Shape shape);
 271         /*
 272          * Set the opaque preoperty to the given window.
 273          */
 274         void setOpaque(Window window, boolean isOpaque);
 275         /*
 276          * Update the image of a non-opaque (translucent) window.
 277          */
 278         void updateWindow(Window window);
 279 
 280         /** Get the size of the security warning.
 281          */
 282         Dimension getSecurityWarningSize(Window w);
 283 
 284         /**
 285          * Set the size of the security warning.
 286          */
 287         void setSecurityWarningSize(Window w, int width, int height);
 288 
 289         /** Set the position of the security warning.
 290          */
 291         void setSecurityWarningPosition(Window w, Point2D point,
 292                 float alignmentX, float alignmentY);
 293 
 294         /** Request to recalculate the new position of the security warning for
 295          * the given window size/location as reported by the native system.
 296          */
 297         Point2D calculateSecurityWarningPosition(Window window,
 298                 double x, double y, double w, double h);
 299 
 300         /** Sets the synchronous status of focus requests on lightweight
 301          * components in the specified window to the specified value.
 302          */
 303         void setLWRequestStatus(Window changed, boolean status);
 304 
 305         /**
 306          * Indicates whether this window should receive focus on subsequently
 307          * being shown, or being moved to the front.
 308          */
 309         boolean isAutoRequestFocus(Window w);
 310 
 311         /**
 312          * Indicates whether the specified window is an utility window for TrayIcon.
 313          */
 314         boolean isTrayIconWindow(Window w);
 315 
 316         /**
 317          * Marks the specified window as an utility window for TrayIcon.
 318          */
 319         void setTrayIconWindow(Window w, boolean isTrayIconWindow);
 320     }
 321 
 322     /**
 323      * An accessor for the AWTEvent class.
 324      */
 325     public interface AWTEventAccessor {
 326         /**
 327          * Marks the event as posted.
 328          */
 329         void setPosted(AWTEvent ev);
 330 
 331         /**
 332          * Sets the flag on this AWTEvent indicating that it was
 333          * generated by the system.
 334          */
 335         void setSystemGenerated(AWTEvent ev);
 336 
 337         /**
 338          * Indicates whether this AWTEvent was generated by the system.
 339          */
 340         boolean isSystemGenerated(AWTEvent ev);
 341 
 342         /**
 343          * Returns the acc this event was constructed with.
 344          */
 345         AccessControlContext getAccessControlContext(AWTEvent ev);
 346 
 347         /**
 348          * Returns binary data associated with this event;
 349          */
 350         byte[] getBData(AWTEvent ev);
 351 
 352         /**
 353          * Associates binary data with this event;
 354          */
 355         void setBData(AWTEvent ev, byte[] bdata);
 356     }
 357 
 358     public interface InputEventAccessor {
 359         /*
 360          * Accessor for InputEvent.getButtonDownMasks()
 361          */
 362         int[] getButtonDownMasks();
 363     }
 364 
 365     /*
 366      * An accessor for the java.awt.Frame class.
 367      */
 368     public interface FrameAccessor {
 369         /*
 370          * Sets the state of this frame.
 371          */
 372         void setExtendedState(Frame frame, int state);
 373         /*
 374          * Gets the state of this frame.
 375          */
 376        int getExtendedState(Frame frame);
 377         /*
 378          * Gets the maximized bounds of this frame.
 379          */
 380        Rectangle getMaximizedBounds(Frame frame);
 381     }
 382 
 383     /**
 384      * An interface of accessor for the java.awt.KeyboardFocusManager class.
 385      */
 386     public interface KeyboardFocusManagerAccessor {
 387         /**
 388          * Indicates whether the native implementation should
 389          * proceed with a pending focus request for the heavyweight.
 390          */
 391         int shouldNativelyFocusHeavyweight(Component heavyweight,
 392                                            Component descendant,
 393                                            boolean temporary,
 394                                            boolean focusedWindowChangeAllowed,
 395                                            long time,
 396                                            CausedFocusEvent.Cause cause);
 397         /**
 398          * Delivers focus for the lightweight descendant of the heavyweight
 399          * synchronously.
 400          */
 401         boolean processSynchronousLightweightTransfer(Component heavyweight,
 402                                                       Component descendant,
 403                                                       boolean temporary,
 404                                                       boolean focusedWindowChangeAllowed,
 405                                                       long time);
 406         /**
 407          * Removes the last focus request for the heavyweight from the queue.
 408          */
 409         void removeLastFocusRequest(Component heavyweight);
 410 
 411         /**
 412          * Sets the most recent focus owner in the window.
 413          */
 414         void setMostRecentFocusOwner(Window window, Component component);
 415 
 416         /**
 417          * Returns current KFM of the specified AppContext.
 418          */
 419         KeyboardFocusManager getCurrentKeyboardFocusManager(AppContext ctx);
 420 
 421         /**
 422          * Return the current focus cycle root
 423          */
 424         Container getCurrentFocusCycleRoot();
 425     }
 426 
 427     /**
 428      * An accessor for the MenuComponent class.
 429      */
 430     public interface MenuComponentAccessor {
 431         /**
 432          * Returns the appContext of the menu component.
 433          */
 434         AppContext getAppContext(MenuComponent menuComp);
 435 
 436         /**
 437          * Sets the appContext of the menu component.
 438          */
 439         void setAppContext(MenuComponent menuComp, AppContext appContext);
 440 
 441         /**
 442          * Returns the menu container of the menu component
 443          */
 444         MenuContainer getParent(MenuComponent menuComp);
 445 
 446         /**
 447          * Gets the font used for this menu component.
 448          */
 449         Font getFont_NoClientCode(MenuComponent menuComp);
 450     }
 451 
 452     /**
 453      * An accessor for the EventQueue class
 454      */
 455     public interface EventQueueAccessor {
 456         /**
 457          * Gets the event dispatch thread.
 458          */
 459         Thread getDispatchThread(EventQueue eventQueue);
 460 
 461         /**
 462          * Checks if the current thread is EDT for the given EQ.
 463          */
 464         public boolean isDispatchThreadImpl(EventQueue eventQueue);
 465 
 466         /**
 467          * Removes any pending events for the specified source object.
 468          */
 469         void removeSourceEvents(EventQueue eventQueue, Object source, boolean removeAllEvents);
 470 
 471         /**
 472          * Returns whether an event is pending on any of the separate Queues.
 473          */
 474         boolean noEvents(EventQueue eventQueue);
 475 
 476         /**
 477          * Called from PostEventQueue.postEvent to notify that a new event
 478          * appeared.
 479          */
 480         void wakeup(EventQueue eventQueue, boolean isShutdown);
 481 
 482         /**
 483          * Static in EventQueue
 484          */
 485         void invokeAndWait(Object source, Runnable r)
 486             throws InterruptedException, InvocationTargetException;
 487 
 488         /**
 489          * Sets the delegate for the EventQueue used by FX/AWT single threaded mode
 490          */
 491         public void setFwDispatcher(EventQueue eventQueue, FwDispatcher dispatcher);
 492     }
 493 
 494     /*
 495      * An accessor for the PopupMenu class
 496      */
 497     public interface PopupMenuAccessor {
 498         /*
 499          * Returns whether the popup menu is attached to a tray
 500          */
 501         boolean isTrayIconPopup(PopupMenu popupMenu);
 502     }
 503 
 504     /*
 505      * An accessor for the FileDialog class
 506      */
 507     public interface FileDialogAccessor {
 508         /*
 509          * Sets the files the user selects
 510          */
 511         void setFiles(FileDialog fileDialog, File files[]);
 512 
 513         /*
 514          * Sets the file the user selects
 515          */
 516         void setFile(FileDialog fileDialog, String file);
 517 
 518         /*
 519          * Sets the directory the user selects
 520          */
 521         void setDirectory(FileDialog fileDialog, String directory);
 522 
 523         /*
 524          * Returns whether the file dialog allows the multiple file selection.
 525          */
 526         boolean isMultipleMode(FileDialog fileDialog);
 527     }
 528 
 529     /*
 530      * An accessor for the ScrollPaneAdjustable class.
 531      */
 532     public interface ScrollPaneAdjustableAccessor {
 533         /*
 534          * Sets the value of this scrollbar to the specified value.
 535          */
 536         void setTypedValue(final ScrollPaneAdjustable adj, final int v,
 537                            final int type);
 538     }
 539 
 540     /**
 541      * An accessor for the CheckboxMenuItem class
 542      */
 543     public interface CheckboxMenuItemAccessor {
 544         /**
 545          * Returns whether menu item is checked
 546          */
 547         boolean getState(CheckboxMenuItem cmi);
 548     }
 549 
 550     /**
 551      * An accessor for the Cursor class
 552      */
 553     public interface CursorAccessor {
 554         /**
 555          * Returns pData of the Cursor class
 556          */
 557         long getPData(Cursor cursor);
 558 
 559         /**
 560          * Sets pData to the Cursor class
 561          */
 562         void setPData(Cursor cursor, long pData);
 563 
 564         /**
 565          * Return type of the Cursor class
 566          */
 567         int getType(Cursor cursor);
 568     }
 569 
 570     /**
 571      * An accessor for the MenuBar class
 572      */
 573     public interface MenuBarAccessor {
 574         /**
 575          * Returns help menu
 576          */
 577         Menu getHelpMenu(MenuBar menuBar);
 578 
 579         /**
 580          * Returns menus
 581          */
 582         Vector getMenus(MenuBar menuBar);
 583     }
 584 
 585     /**
 586      * An accessor for the MenuItem class
 587      */
 588     public interface MenuItemAccessor {
 589         /**
 590          * Returns whether menu item is enabled
 591          */
 592         boolean isEnabled(MenuItem item);
 593 
 594         /**
 595          * Gets the command name of the action event that is fired
 596          * by this menu item.
 597          */
 598         String getActionCommandImpl(MenuItem item);
 599 
 600         /**
 601          * Returns true if the item and all its ancestors are
 602          * enabled, false otherwise
 603          */
 604         boolean isItemEnabled(MenuItem item);
 605 
 606         /**
 607          * Returns label
 608          */
 609         String getLabel(MenuItem item);
 610 
 611         /**
 612          * Returns shortcut
 613          */
 614         MenuShortcut getShortcut(MenuItem item);
 615     }
 616 
 617     /**
 618      * An accessor for the Menu class
 619      */
 620     public interface MenuAccessor {
 621         /**
 622          * Returns vector of the items that are part of the Menu
 623          */
 624         Vector getItems(Menu menu);
 625     }
 626 
 627     /**
 628      * An accessor for the KeyEvent class
 629      */
 630     public interface KeyEventAccessor {
 631         /**
 632          * Sets rawCode field for KeyEvent
 633          */
 634         void setRawCode(KeyEvent ev, long rawCode);
 635 
 636         /**
 637          * Sets primaryLevelUnicode field for KeyEvent
 638          */
 639         void setPrimaryLevelUnicode(KeyEvent ev, long primaryLevelUnicode);
 640 
 641         /**
 642          * Sets extendedKeyCode field for KeyEvent
 643          */
 644         void setExtendedKeyCode(KeyEvent ev, long extendedKeyCode);
 645 
 646         /**
 647          * Gets original source for KeyEvent
 648          */
 649         Component getOriginalSource(KeyEvent ev);
 650     }
 651 
 652     /**
 653      * An accessor for the ClientPropertyKey class
 654      */
 655     public interface ClientPropertyKeyAccessor {
 656         /**
 657          * Retrieves JComponent_TRANSFER_HANDLER enum object
 658          */
 659         Object getJComponent_TRANSFER_HANDLER();
 660     }
 661 
 662     /**
 663      * An accessor for the SystemTray class
 664      */
 665     public interface SystemTrayAccessor {
 666         /**
 667          * Support for reporting bound property changes for Object properties.
 668          */
 669         void firePropertyChange(SystemTray tray, String propertyName, Object oldValue, Object newValue);
 670     }
 671 
 672     /**
 673      * An accessor for the TrayIcon class
 674      */
 675     public interface TrayIconAccessor {
 676         void addNotify(TrayIcon trayIcon) throws AWTException;
 677         void removeNotify(TrayIcon trayIcon);
 678     }
 679 
 680     /**
 681      * An accessor for the DefaultKeyboardFocusManager class
 682      */
 683     public interface DefaultKeyboardFocusManagerAccessor {
 684         public void consumeNextKeyTyped(DefaultKeyboardFocusManager dkfm, KeyEvent e);
 685     }
 686 
 687     /*
 688      * An accessor for the SequencedEventAccessor class
 689      */
 690     public interface SequencedEventAccessor {
 691         /*
 692          * Returns the nested event.
 693          */
 694         AWTEvent getNested(AWTEvent sequencedEvent);
 695 
 696         /*
 697          * Returns true if the event is an instances of SequencedEvent.
 698          */
 699         boolean isSequencedEvent(AWTEvent event);
 700     }
 701 
 702     /*
 703      * Accessor instances are initialized in the static initializers of
 704      * corresponding AWT classes by using setters defined below.
 705      */
 706     private static ComponentAccessor componentAccessor;
 707     private static ContainerAccessor containerAccessor;
 708     private static WindowAccessor windowAccessor;
 709     private static AWTEventAccessor awtEventAccessor;
 710     private static InputEventAccessor inputEventAccessor;
 711     private static FrameAccessor frameAccessor;
 712     private static KeyboardFocusManagerAccessor kfmAccessor;
 713     private static MenuComponentAccessor menuComponentAccessor;
 714     private static EventQueueAccessor eventQueueAccessor;
 715     private static PopupMenuAccessor popupMenuAccessor;
 716     private static FileDialogAccessor fileDialogAccessor;
 717     private static ScrollPaneAdjustableAccessor scrollPaneAdjustableAccessor;
 718     private static CheckboxMenuItemAccessor checkboxMenuItemAccessor;
 719     private static CursorAccessor cursorAccessor;
 720     private static MenuBarAccessor menuBarAccessor;
 721     private static MenuItemAccessor menuItemAccessor;
 722     private static MenuAccessor menuAccessor;
 723     private static KeyEventAccessor keyEventAccessor;
 724     private static ClientPropertyKeyAccessor clientPropertyKeyAccessor;
 725     private static SystemTrayAccessor systemTrayAccessor;
 726     private static TrayIconAccessor trayIconAccessor;
 727     private static DefaultKeyboardFocusManagerAccessor defaultKeyboardFocusManagerAccessor;
 728     private static SequencedEventAccessor sequencedEventAccessor;
 729 
 730     /*
 731      * Set an accessor object for the java.awt.Component class.
 732      */
 733     public static void setComponentAccessor(ComponentAccessor ca) {
 734         componentAccessor = ca;
 735     }
 736 
 737     /*
 738      * Retrieve the accessor object for the java.awt.Component class.
 739      */
 740     public static ComponentAccessor getComponentAccessor() {
 741         if (componentAccessor == null) {
 742             unsafe.ensureClassInitialized(Component.class);
 743         }
 744 
 745         return componentAccessor;
 746     }
 747 
 748     /*
 749      * Set an accessor object for the java.awt.Container class.
 750      */
 751     public static void setContainerAccessor(ContainerAccessor ca) {
 752         containerAccessor = ca;
 753     }
 754 
 755     /*
 756      * Retrieve the accessor object for the java.awt.Container class.
 757      */
 758     public static ContainerAccessor getContainerAccessor() {
 759         if (containerAccessor == null) {
 760             unsafe.ensureClassInitialized(Container.class);
 761         }
 762 
 763         return containerAccessor;
 764     }
 765 
 766     /*
 767      * Set an accessor object for the java.awt.Window class.
 768      */
 769     public static void setWindowAccessor(WindowAccessor wa) {
 770         windowAccessor = wa;
 771     }
 772 
 773     /*
 774      * Retrieve the accessor object for the java.awt.Window class.
 775      */
 776     public static WindowAccessor getWindowAccessor() {
 777         if (windowAccessor == null) {
 778             unsafe.ensureClassInitialized(Window.class);
 779         }
 780         return windowAccessor;
 781     }
 782 
 783     /*
 784      * Set an accessor object for the java.awt.AWTEvent class.
 785      */
 786     public static void setAWTEventAccessor(AWTEventAccessor aea) {
 787         awtEventAccessor = aea;
 788     }
 789 
 790     /*
 791      * Retrieve the accessor object for the java.awt.AWTEvent class.
 792      */
 793     public static AWTEventAccessor getAWTEventAccessor() {
 794         if (awtEventAccessor == null) {
 795             unsafe.ensureClassInitialized(AWTEvent.class);
 796         }
 797         return awtEventAccessor;
 798     }
 799 
 800     /*
 801      * Set an accessor object for the java.awt.event.InputEvent class.
 802      */
 803     public static void setInputEventAccessor(InputEventAccessor iea) {
 804         inputEventAccessor = iea;
 805     }
 806 
 807     /*
 808      * Retrieve the accessor object for the java.awt.event.InputEvent class.
 809      */
 810     public static InputEventAccessor getInputEventAccessor() {
 811         if (inputEventAccessor == null) {
 812             unsafe.ensureClassInitialized(InputEvent.class);
 813         }
 814         return inputEventAccessor;
 815     }
 816 
 817     /*
 818      * Set an accessor object for the java.awt.Frame class.
 819      */
 820     public static void setFrameAccessor(FrameAccessor fa) {
 821         frameAccessor = fa;
 822     }
 823 
 824     /*
 825      * Retrieve the accessor object for the java.awt.Frame class.
 826      */
 827     public static FrameAccessor getFrameAccessor() {
 828         if (frameAccessor == null) {
 829             unsafe.ensureClassInitialized(Frame.class);
 830         }
 831         return frameAccessor;
 832     }
 833 
 834     /*
 835      * Set an accessor object for the java.awt.KeyboardFocusManager class.
 836      */
 837     public static void setKeyboardFocusManagerAccessor(KeyboardFocusManagerAccessor kfma) {
 838         kfmAccessor = kfma;
 839     }
 840 
 841     /*
 842      * Retrieve the accessor object for the java.awt.KeyboardFocusManager class.
 843      */
 844     public static KeyboardFocusManagerAccessor getKeyboardFocusManagerAccessor() {
 845         if (kfmAccessor == null) {
 846             unsafe.ensureClassInitialized(KeyboardFocusManager.class);
 847         }
 848         return kfmAccessor;
 849     }
 850 
 851     /*
 852      * Set an accessor object for the java.awt.MenuComponent class.
 853      */
 854     public static void setMenuComponentAccessor(MenuComponentAccessor mca) {
 855         menuComponentAccessor = mca;
 856     }
 857 
 858     /*
 859      * Retrieve the accessor object for the java.awt.MenuComponent class.
 860      */
 861     public static MenuComponentAccessor getMenuComponentAccessor() {
 862         if (menuComponentAccessor == null) {
 863             unsafe.ensureClassInitialized(MenuComponent.class);
 864         }
 865         return menuComponentAccessor;
 866     }
 867 
 868     /*
 869      * Set an accessor object for the java.awt.EventQueue class.
 870      */
 871     public static void setEventQueueAccessor(EventQueueAccessor eqa) {
 872         eventQueueAccessor = eqa;
 873     }
 874 
 875     /*
 876      * Retrieve the accessor object for the java.awt.EventQueue class.
 877      */
 878     public static EventQueueAccessor getEventQueueAccessor() {
 879         if (eventQueueAccessor == null) {
 880             unsafe.ensureClassInitialized(EventQueue.class);
 881         }
 882         return eventQueueAccessor;
 883     }
 884 
 885     /*
 886      * Set an accessor object for the java.awt.PopupMenu class.
 887      */
 888     public static void setPopupMenuAccessor(PopupMenuAccessor pma) {
 889         popupMenuAccessor = pma;
 890     }
 891 
 892     /*
 893      * Retrieve the accessor object for the java.awt.PopupMenu class.
 894      */
 895     public static PopupMenuAccessor getPopupMenuAccessor() {
 896         if (popupMenuAccessor == null) {
 897             unsafe.ensureClassInitialized(PopupMenu.class);
 898         }
 899         return popupMenuAccessor;
 900     }
 901 
 902     /*
 903      * Set an accessor object for the java.awt.FileDialog class.
 904      */
 905     public static void setFileDialogAccessor(FileDialogAccessor fda) {
 906         fileDialogAccessor = fda;
 907     }
 908 
 909     /*
 910      * Retrieve the accessor object for the java.awt.FileDialog class.
 911      */
 912     public static FileDialogAccessor getFileDialogAccessor() {
 913         if (fileDialogAccessor == null) {
 914             unsafe.ensureClassInitialized(FileDialog.class);
 915         }
 916         return fileDialogAccessor;
 917     }
 918 
 919     /*
 920      * Set an accessor object for the java.awt.ScrollPaneAdjustable class.
 921      */
 922     public static void setScrollPaneAdjustableAccessor(ScrollPaneAdjustableAccessor adj) {
 923         scrollPaneAdjustableAccessor = adj;
 924     }
 925 
 926     /*
 927      * Retrieve the accessor object for the java.awt.ScrollPaneAdjustable
 928      * class.
 929      */
 930     public static ScrollPaneAdjustableAccessor getScrollPaneAdjustableAccessor() {
 931         if (scrollPaneAdjustableAccessor == null) {
 932             unsafe.ensureClassInitialized(ScrollPaneAdjustable.class);
 933         }
 934         return scrollPaneAdjustableAccessor;
 935     }
 936 
 937     /**
 938      * Set an accessor object for the java.awt.CheckboxMenuItem class.
 939      */
 940     public static void setCheckboxMenuItemAccessor(CheckboxMenuItemAccessor cmia) {
 941         checkboxMenuItemAccessor = cmia;
 942     }
 943 
 944     /**
 945      * Retrieve the accessor object for the java.awt.CheckboxMenuItem class.
 946      */
 947     public static CheckboxMenuItemAccessor getCheckboxMenuItemAccessor() {
 948         if (checkboxMenuItemAccessor == null) {
 949             unsafe.ensureClassInitialized(CheckboxMenuItemAccessor.class);
 950         }
 951         return checkboxMenuItemAccessor;
 952     }
 953 
 954     /**
 955      * Set an accessor object for the java.awt.Cursor class.
 956      */
 957     public static void setCursorAccessor(CursorAccessor ca) {
 958         cursorAccessor = ca;
 959     }
 960 
 961     /**
 962      * Retrieve the accessor object for the java.awt.Cursor class.
 963      */
 964     public static CursorAccessor getCursorAccessor() {
 965         if (cursorAccessor == null) {
 966             unsafe.ensureClassInitialized(CursorAccessor.class);
 967         }
 968         return cursorAccessor;
 969     }
 970 
 971     /**
 972      * Set an accessor object for the java.awt.MenuBar class.
 973      */
 974     public static void setMenuBarAccessor(MenuBarAccessor mba) {
 975         menuBarAccessor = mba;
 976     }
 977 
 978     /**
 979      * Retrieve the accessor object for the java.awt.MenuBar class.
 980      */
 981     public static MenuBarAccessor getMenuBarAccessor() {
 982         if (menuBarAccessor == null) {
 983             unsafe.ensureClassInitialized(MenuBarAccessor.class);
 984         }
 985         return menuBarAccessor;
 986     }
 987 
 988     /**
 989      * Set an accessor object for the java.awt.MenuItem class.
 990      */
 991     public static void setMenuItemAccessor(MenuItemAccessor mia) {
 992         menuItemAccessor = mia;
 993     }
 994 
 995     /**
 996      * Retrieve the accessor object for the java.awt.MenuItem class.
 997      */
 998     public static MenuItemAccessor getMenuItemAccessor() {
 999         if (menuItemAccessor == null) {
1000             unsafe.ensureClassInitialized(MenuItemAccessor.class);
1001         }
1002         return menuItemAccessor;
1003     }
1004 
1005     /**
1006      * Set an accessor object for the java.awt.Menu class.
1007      */
1008     public static void setMenuAccessor(MenuAccessor ma) {
1009         menuAccessor = ma;
1010     }
1011 
1012     /**
1013      * Retrieve the accessor object for the java.awt.Menu class.
1014      */
1015     public static MenuAccessor getMenuAccessor() {
1016         if (menuAccessor == null) {
1017             unsafe.ensureClassInitialized(MenuAccessor.class);
1018         }
1019         return menuAccessor;
1020     }
1021 
1022     /**
1023      * Set an accessor object for the java.awt.event.KeyEvent class.
1024      */
1025     public static void setKeyEventAccessor(KeyEventAccessor kea) {
1026         keyEventAccessor = kea;
1027     }
1028 
1029     /**
1030      * Retrieve the accessor object for the java.awt.event.KeyEvent class.
1031      */
1032     public static KeyEventAccessor getKeyEventAccessor() {
1033         if (keyEventAccessor == null) {
1034             unsafe.ensureClassInitialized(KeyEventAccessor.class);
1035         }
1036         return keyEventAccessor;
1037     }
1038 
1039     /**
1040      * Set an accessor object for the javax.swing.ClientPropertyKey class.
1041      */
1042     public static void setClientPropertyKeyAccessor(ClientPropertyKeyAccessor cpka) {
1043         clientPropertyKeyAccessor = cpka;
1044     }
1045 
1046     /**
1047      * Retrieve the accessor object for the javax.swing.ClientPropertyKey class.
1048      */
1049     public static ClientPropertyKeyAccessor getClientPropertyKeyAccessor() {
1050         if (clientPropertyKeyAccessor == null) {
1051             unsafe.ensureClassInitialized(ClientPropertyKeyAccessor.class);
1052         }
1053         return clientPropertyKeyAccessor;
1054     }
1055 
1056     /**
1057      * Set an accessor object for the java.awt.SystemTray class.
1058      */
1059     public static void setSystemTrayAccessor(SystemTrayAccessor sta) {
1060         systemTrayAccessor = sta;
1061     }
1062 
1063     /**
1064      * Retrieve the accessor object for the java.awt.SystemTray class.
1065      */
1066     public static SystemTrayAccessor getSystemTrayAccessor() {
1067         if (systemTrayAccessor == null) {
1068             unsafe.ensureClassInitialized(SystemTrayAccessor.class);
1069         }
1070         return systemTrayAccessor;
1071     }
1072 
1073     /**
1074      * Set an accessor object for the java.awt.TrayIcon class.
1075      */
1076     public static void setTrayIconAccessor(TrayIconAccessor tia) {
1077         trayIconAccessor = tia;
1078     }
1079 
1080     /**
1081      * Retrieve the accessor object for the java.awt.TrayIcon class.
1082      */
1083     public static TrayIconAccessor getTrayIconAccessor() {
1084         if (trayIconAccessor == null) {
1085             unsafe.ensureClassInitialized(TrayIconAccessor.class);
1086         }
1087         return trayIconAccessor;
1088     }
1089 
1090     /**
1091      * Set an accessor object for the java.awt.DefaultKeyboardFocusManager class.
1092      */
1093     public static void setDefaultKeyboardFocusManagerAccessor(DefaultKeyboardFocusManagerAccessor dkfma) {
1094         defaultKeyboardFocusManagerAccessor = dkfma;
1095     }
1096 
1097     /**
1098      * Retrieve the accessor object for the java.awt.DefaultKeyboardFocusManager class.
1099      */
1100     public static DefaultKeyboardFocusManagerAccessor getDefaultKeyboardFocusManagerAccessor() {
1101         if (defaultKeyboardFocusManagerAccessor == null) {
1102             unsafe.ensureClassInitialized(DefaultKeyboardFocusManagerAccessor.class);
1103         }
1104         return defaultKeyboardFocusManagerAccessor;
1105     }
1106     /*
1107      * Set an accessor object for the java.awt.SequencedEvent class.
1108      */
1109     public static void setSequencedEventAccessor(SequencedEventAccessor sea) {
1110         sequencedEventAccessor = sea;
1111     }
1112 
1113     /*
1114      * Get the accessor object for the java.awt.SequencedEvent class.
1115      */
1116     public static SequencedEventAccessor getSequencedEventAccessor() {
1117         // The class is not public. So we can't ensure it's initialized.
1118         // Null returned value means it's not initialized
1119         // (so not a single instance of the event has been created).
1120         return sequencedEventAccessor;
1121     }
1122 }