--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.desktop/share/classes/sun/awt/AWTAccessor.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,1395 @@
+/*
+ * Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.awt;
+
+import jdk.internal.misc.Unsafe;
+
+import javax.accessibility.AccessibleContext;
+import java.awt.*;
+import java.awt.event.FocusEvent.Cause;
+import java.awt.dnd.DragSourceContext;
+import java.awt.dnd.DropTargetContext;
+import java.awt.dnd.peer.DragSourceContextPeer;
+import java.awt.dnd.peer.DropTargetContextPeer;
+import java.awt.event.AWTEventListener;
+import java.awt.event.InputEvent;
+import java.awt.event.InvocationEvent;
+import java.awt.event.KeyEvent;
+import java.awt.geom.Point2D;
+import java.awt.image.BufferStrategy;
+import java.awt.peer.ComponentPeer;
+
+import java.awt.peer.MenuComponentPeer;
+import java.lang.reflect.InvocationTargetException;
+import java.security.AccessControlContext;
+
+import java.io.File;
+import java.util.ResourceBundle;
+import java.util.Vector;
+import javax.accessibility.AccessibleBundle;
+
+/**
+ * The AWTAccessor utility class.
+ * The main purpose of this class is to enable accessing
+ * private and package-private fields of classes from
+ * different classes/packages. See sun.misc.SharedSecretes
+ * for another example.
+ */
+public final class AWTAccessor {
+
+ private static final Unsafe unsafe = Unsafe.getUnsafe();
+
+ /*
+ * We don't need any objects of this class.
+ * It's rather a collection of static methods
+ * and interfaces.
+ */
+ private AWTAccessor() {
+ }
+
+ /*
+ * An interface of accessor for the java.awt.Component class.
+ */
+ public interface ComponentAccessor {
+ /*
+ * Sets whether the native background erase for a component
+ * has been disabled via SunToolkit.disableBackgroundErase().
+ */
+ void setBackgroundEraseDisabled(Component comp, boolean disabled);
+ /*
+ * Indicates whether the native background erase for a
+ * component has been disabled via
+ * SunToolkit.disableBackgroundErase().
+ */
+ boolean getBackgroundEraseDisabled(Component comp);
+ /*
+ *
+ * Gets the bounds of this component in the form of a
+ * {@code Rectangle} object. The bounds specify this
+ * component's width, height, and location relative to
+ * its parent.
+ */
+ Rectangle getBounds(Component comp);
+
+ /**
+ * Sets GraphicsConfiguration value for the component.
+ */
+ void setGraphicsConfiguration(Component comp, GraphicsConfiguration gc);
+ /*
+ * Requests focus to the component.
+ */
+ void requestFocus(Component comp, Cause cause);
+ /*
+ * Determines if the component can gain focus.
+ */
+ boolean canBeFocusOwner(Component comp);
+
+ /**
+ * Returns whether the component is visible without invoking
+ * any client code.
+ */
+ boolean isVisible(Component comp);
+
+ /**
+ * Sets the RequestFocusController.
+ */
+ void setRequestFocusController(RequestFocusController requestController);
+
+ /**
+ * Returns the appContext of the component.
+ */
+ AppContext getAppContext(Component comp);
+
+ /**
+ * Sets the appContext of the component.
+ */
+ void setAppContext(Component comp, AppContext appContext);
+
+ /**
+ * Returns the parent of the component.
+ */
+ Container getParent(Component comp);
+
+ /**
+ * Sets the parent of the component to the specified parent.
+ */
+ void setParent(Component comp, Container parent);
+
+ /**
+ * Resizes the component to the specified width and height.
+ */
+ void setSize(Component comp, int width, int height);
+
+ /**
+ * Returns the location of the component.
+ */
+ Point getLocation(Component comp);
+
+ /**
+ * Moves the component to the new location.
+ */
+ void setLocation(Component comp, int x, int y);
+
+ /**
+ * Determines whether this component is enabled.
+ */
+ boolean isEnabled(Component comp);
+
+ /**
+ * Determines whether this component is displayable.
+ */
+ boolean isDisplayable(Component comp);
+
+ /**
+ * Gets the cursor set in the component.
+ */
+ Cursor getCursor(Component comp);
+
+ /**
+ * Returns the peer of the component.
+ */
+ <T extends ComponentPeer> T getPeer(Component comp);
+
+ /**
+ * Sets the peer of the component to the specified peer.
+ */
+ void setPeer(Component comp, ComponentPeer peer);
+
+ /**
+ * Determines whether this component is lightweight.
+ */
+ boolean isLightweight(Component comp);
+
+ /**
+ * Returns whether or not paint messages received from
+ * the operating system should be ignored.
+ */
+ boolean getIgnoreRepaint(Component comp);
+
+ /**
+ * Returns the width of the component.
+ */
+ int getWidth(Component comp);
+
+ /**
+ * Returns the height of the component.
+ */
+ int getHeight(Component comp);
+
+ /**
+ * Returns the x coordinate of the component.
+ */
+ int getX(Component comp);
+
+ /**
+ * Returns the y coordinate of the component.
+ */
+ int getY(Component comp);
+
+ /**
+ * Gets the foreground color of this component.
+ */
+ Color getForeground(Component comp);
+
+ /**
+ * Gets the background color of this component.
+ */
+ Color getBackground(Component comp);
+
+ /**
+ * Sets the background of this component to the specified color.
+ */
+ void setBackground(Component comp, Color background);
+
+ /**
+ * Gets the font of the component.
+ */
+ Font getFont(Component comp);
+
+ /**
+ * Processes events occurring on this component.
+ */
+ void processEvent(Component comp, AWTEvent e);
+
+
+ /*
+ * Returns the acc this component was constructed with.
+ */
+ AccessControlContext getAccessControlContext(Component comp);
+
+ /**
+ * Revalidates the component synchronously.
+ */
+ void revalidateSynchronously(Component comp);
+
+ /**
+ * Creates a new strategy for multi-buffering on this component.
+ */
+ void createBufferStrategy(Component comp, int numBuffers,
+ BufferCapabilities caps) throws AWTException;
+
+ /**
+ * returns the buffer strategy used by this component.
+ */
+ BufferStrategy getBufferStrategy(Component comp);
+ }
+
+ /*
+ * An interface of accessor for the java.awt.Container class.
+ */
+ public interface ContainerAccessor {
+ /**
+ * Validates the container unconditionally.
+ */
+ void validateUnconditionally(Container cont);
+
+ /**
+ *
+ * Access to the private version of findComponentAt method which has
+ * a controllable behavior. Setting 'ignoreEnabled' to 'false'
+ * bypasses disabled Components during the search.
+ */
+ Component findComponentAt(Container cont, int x, int y, boolean ignoreEnabled);
+
+ /**
+ * Starts LW Modal.
+ */
+ void startLWModal(Container cont);
+
+ /**
+ * Starts LW Modal.
+ */
+ void stopLWModal(Container cont);
+ }
+
+ /*
+ * An interface of accessor for java.awt.Window class.
+ */
+ public interface WindowAccessor {
+ /*
+ * Get opacity level of the given window.
+ */
+ float getOpacity(Window window);
+ /*
+ * Set opacity level to the given window.
+ */
+ void setOpacity(Window window, float opacity);
+ /*
+ * Get a shape assigned to the given window.
+ */
+ Shape getShape(Window window);
+ /*
+ * Set a shape to the given window.
+ */
+ void setShape(Window window, Shape shape);
+ /*
+ * Set the opaque preoperty to the given window.
+ */
+ void setOpaque(Window window, boolean isOpaque);
+ /*
+ * Update the image of a non-opaque (translucent) window.
+ */
+ void updateWindow(Window window);
+
+ /** Get the size of the security warning.
+ */
+ Dimension getSecurityWarningSize(Window w);
+
+ /**
+ * Set the size of the security warning.
+ */
+ void setSecurityWarningSize(Window w, int width, int height);
+
+ /** Set the position of the security warning.
+ */
+ void setSecurityWarningPosition(Window w, Point2D point,
+ float alignmentX, float alignmentY);
+
+ /** Request to recalculate the new position of the security warning for
+ * the given window size/location as reported by the native system.
+ */
+ Point2D calculateSecurityWarningPosition(Window window,
+ double x, double y, double w, double h);
+
+ /** Sets the synchronous status of focus requests on lightweight
+ * components in the specified window to the specified value.
+ */
+ void setLWRequestStatus(Window changed, boolean status);
+
+ /**
+ * Indicates whether this window should receive focus on subsequently
+ * being shown, or being moved to the front.
+ */
+ boolean isAutoRequestFocus(Window w);
+
+ /**
+ * Indicates whether the specified window is an utility window for TrayIcon.
+ */
+ boolean isTrayIconWindow(Window w);
+
+ /**
+ * Marks the specified window as an utility window for TrayIcon.
+ */
+ void setTrayIconWindow(Window w, boolean isTrayIconWindow);
+
+ /**
+ * Return an array containing all the windows this
+ * window currently owns.
+ */
+ Window[] getOwnedWindows(Window w);
+ }
+
+ /**
+ * An accessor for the AWTEvent class.
+ */
+ public interface AWTEventAccessor {
+ /**
+ * Marks the event as posted.
+ */
+ void setPosted(AWTEvent ev);
+
+ /**
+ * Sets the flag on this AWTEvent indicating that it was
+ * generated by the system.
+ */
+ void setSystemGenerated(AWTEvent ev);
+
+ /**
+ * Indicates whether this AWTEvent was generated by the system.
+ */
+ boolean isSystemGenerated(AWTEvent ev);
+
+ /**
+ * Returns the acc this event was constructed with.
+ */
+ AccessControlContext getAccessControlContext(AWTEvent ev);
+
+ /**
+ * Returns binary data associated with this event;
+ */
+ byte[] getBData(AWTEvent ev);
+
+ /**
+ * Associates binary data with this event;
+ */
+ void setBData(AWTEvent ev, byte[] bdata);
+ }
+
+ public interface InputEventAccessor {
+ /*
+ * Accessor for InputEvent.getButtonDownMasks()
+ */
+ int[] getButtonDownMasks();
+
+ /*
+ * Accessor for InputEvent.canAccessSystemClipboard field
+ */
+ boolean canAccessSystemClipboard(InputEvent event);
+ void setCanAccessSystemClipboard(InputEvent event,
+ boolean canAccessSystemClipboard);
+ }
+
+ /*
+ * An accessor for the java.awt.Frame class.
+ */
+ public interface FrameAccessor {
+ /*
+ * Sets the state of this frame.
+ */
+ void setExtendedState(Frame frame, int state);
+ /*
+ * Gets the state of this frame.
+ */
+ int getExtendedState(Frame frame);
+ /*
+ * Gets the maximized bounds of this frame.
+ */
+ Rectangle getMaximizedBounds(Frame frame);
+ }
+
+ /**
+ * An interface of accessor for the java.awt.KeyboardFocusManager class.
+ */
+ public interface KeyboardFocusManagerAccessor {
+ /**
+ * Indicates whether the native implementation should
+ * proceed with a pending focus request for the heavyweight.
+ */
+ int shouldNativelyFocusHeavyweight(Component heavyweight,
+ Component descendant,
+ boolean temporary,
+ boolean focusedWindowChangeAllowed,
+ long time,
+ Cause cause);
+ /**
+ * Delivers focus for the lightweight descendant of the heavyweight
+ * synchronously.
+ */
+ boolean processSynchronousLightweightTransfer(Component heavyweight,
+ Component descendant,
+ boolean temporary,
+ boolean focusedWindowChangeAllowed,
+ long time);
+ /**
+ * Removes the last focus request for the heavyweight from the queue.
+ */
+ void removeLastFocusRequest(Component heavyweight);
+
+ /**
+ * Gets the most recent focus owner in the window.
+ */
+ Component getMostRecentFocusOwner(Window window);
+
+ /**
+ * Sets the most recent focus owner in the window.
+ */
+ void setMostRecentFocusOwner(Window window, Component component);
+
+ /**
+ * Returns current KFM of the specified AppContext.
+ */
+ KeyboardFocusManager getCurrentKeyboardFocusManager(AppContext ctx);
+
+ /**
+ * Return the current focus cycle root
+ */
+ Container getCurrentFocusCycleRoot();
+ }
+
+ /**
+ * An accessor for the MenuComponent class.
+ */
+ public interface MenuComponentAccessor {
+ /**
+ * Returns the appContext of the menu component.
+ */
+ AppContext getAppContext(MenuComponent menuComp);
+
+ /**
+ * Sets the appContext of the menu component.
+ */
+ void setAppContext(MenuComponent menuComp, AppContext appContext);
+
+ /**
+ * Returns the peer of the menu component.
+ */
+ <T extends MenuComponentPeer> T getPeer(MenuComponent menuComp);
+
+ /**
+ * Returns the menu container of the menu component.
+ */
+ MenuContainer getParent(MenuComponent menuComp);
+
+ /**
+ * Sets the menu container of the menu component.
+ */
+ void setParent(MenuComponent menuComp, MenuContainer menuContainer);
+
+ /**
+ * Gets the font used for this menu component.
+ */
+ Font getFont_NoClientCode(MenuComponent menuComp);
+ }
+
+ /**
+ * An accessor for the EventQueue class
+ */
+ public interface EventQueueAccessor {
+ /**
+ * Gets the event dispatch thread.
+ */
+ Thread getDispatchThread(EventQueue eventQueue);
+
+ /**
+ * Checks if the current thread is EDT for the given EQ.
+ */
+ public boolean isDispatchThreadImpl(EventQueue eventQueue);
+
+ /**
+ * Removes any pending events for the specified source object.
+ */
+ void removeSourceEvents(EventQueue eventQueue, Object source, boolean removeAllEvents);
+
+ /**
+ * Returns whether an event is pending on any of the separate Queues.
+ */
+ boolean noEvents(EventQueue eventQueue);
+
+ /**
+ * Called from PostEventQueue.postEvent to notify that a new event
+ * appeared.
+ */
+ void wakeup(EventQueue eventQueue, boolean isShutdown);
+
+ /**
+ * Static in EventQueue
+ */
+ void invokeAndWait(Object source, Runnable r)
+ throws InterruptedException, InvocationTargetException;
+
+ /**
+ * Sets the delegate for the EventQueue used by FX/AWT single threaded mode
+ */
+ void setFwDispatcher(EventQueue eventQueue, FwDispatcher dispatcher);
+
+ /**
+ * Gets most recent event time in the EventQueue
+ */
+ long getMostRecentEventTime(EventQueue eventQueue);
+ }
+
+ /*
+ * An accessor for the PopupMenu class
+ */
+ public interface PopupMenuAccessor {
+ /*
+ * Returns whether the popup menu is attached to a tray
+ */
+ boolean isTrayIconPopup(PopupMenu popupMenu);
+ }
+
+ /*
+ * An accessor for the FileDialog class
+ */
+ public interface FileDialogAccessor {
+ /*
+ * Sets the files the user selects
+ */
+ void setFiles(FileDialog fileDialog, File files[]);
+
+ /*
+ * Sets the file the user selects
+ */
+ void setFile(FileDialog fileDialog, String file);
+
+ /*
+ * Sets the directory the user selects
+ */
+ void setDirectory(FileDialog fileDialog, String directory);
+
+ /*
+ * Returns whether the file dialog allows the multiple file selection.
+ */
+ boolean isMultipleMode(FileDialog fileDialog);
+ }
+
+ /*
+ * An accessor for the ScrollPaneAdjustable class.
+ */
+ public interface ScrollPaneAdjustableAccessor {
+ /*
+ * Sets the value of this scrollbar to the specified value.
+ */
+ void setTypedValue(final ScrollPaneAdjustable adj, final int v,
+ final int type);
+ }
+
+ /**
+ * An accessor for the CheckboxMenuItem class
+ */
+ public interface CheckboxMenuItemAccessor {
+ /**
+ * Returns whether menu item is checked
+ */
+ boolean getState(CheckboxMenuItem cmi);
+ }
+
+ /**
+ * An accessor for the Cursor class
+ */
+ public interface CursorAccessor {
+ /**
+ * Returns pData of the Cursor class
+ */
+ long getPData(Cursor cursor);
+
+ /**
+ * Sets pData to the Cursor class
+ */
+ void setPData(Cursor cursor, long pData);
+
+ /**
+ * Return type of the Cursor class
+ */
+ int getType(Cursor cursor);
+ }
+
+ /**
+ * An accessor for the MenuBar class
+ */
+ public interface MenuBarAccessor {
+ /**
+ * Returns help menu
+ */
+ Menu getHelpMenu(MenuBar menuBar);
+
+ /**
+ * Returns menus
+ */
+ Vector<Menu> getMenus(MenuBar menuBar);
+ }
+
+ /**
+ * An accessor for the MenuItem class
+ */
+ public interface MenuItemAccessor {
+ /**
+ * Returns whether menu item is enabled
+ */
+ boolean isEnabled(MenuItem item);
+
+ /**
+ * Gets the command name of the action event that is fired
+ * by this menu item.
+ */
+ String getActionCommandImpl(MenuItem item);
+
+ /**
+ * Returns true if the item and all its ancestors are
+ * enabled, false otherwise
+ */
+ boolean isItemEnabled(MenuItem item);
+
+ /**
+ * Returns label
+ */
+ String getLabel(MenuItem item);
+
+ /**
+ * Returns shortcut
+ */
+ MenuShortcut getShortcut(MenuItem item);
+ }
+
+ /**
+ * An accessor for the Menu class
+ */
+ public interface MenuAccessor {
+ /**
+ * Returns vector of the items that are part of the Menu
+ */
+ Vector<MenuItem> getItems(Menu menu);
+ }
+
+ /**
+ * An accessor for the KeyEvent class
+ */
+ public interface KeyEventAccessor {
+ /**
+ * Sets rawCode field for KeyEvent
+ */
+ void setRawCode(KeyEvent ev, long rawCode);
+
+ /**
+ * Sets primaryLevelUnicode field for KeyEvent
+ */
+ void setPrimaryLevelUnicode(KeyEvent ev, long primaryLevelUnicode);
+
+ /**
+ * Sets extendedKeyCode field for KeyEvent
+ */
+ void setExtendedKeyCode(KeyEvent ev, long extendedKeyCode);
+
+ /**
+ * Gets original source for KeyEvent
+ */
+ Component getOriginalSource(KeyEvent ev);
+
+ /**
+ * Gets isProxyActive field for KeyEvent
+ */
+ boolean isProxyActive(KeyEvent ev);
+ }
+
+ /**
+ * An accessor for the ClientPropertyKey class
+ */
+ public interface ClientPropertyKeyAccessor {
+ /**
+ * Retrieves JComponent_TRANSFER_HANDLER enum object
+ */
+ Object getJComponent_TRANSFER_HANDLER();
+ }
+
+ /**
+ * An accessor for the SystemTray class
+ */
+ public interface SystemTrayAccessor {
+ /**
+ * Support for reporting bound property changes for Object properties.
+ */
+ void firePropertyChange(SystemTray tray, String propertyName, Object oldValue, Object newValue);
+ }
+
+ /**
+ * An accessor for the TrayIcon class
+ */
+ public interface TrayIconAccessor {
+ void addNotify(TrayIcon trayIcon) throws AWTException;
+ void removeNotify(TrayIcon trayIcon);
+ }
+
+ /**
+ * An accessor for the DefaultKeyboardFocusManager class
+ */
+ public interface DefaultKeyboardFocusManagerAccessor {
+ public void consumeNextKeyTyped(DefaultKeyboardFocusManager dkfm, KeyEvent e);
+ }
+
+ /*
+ * An accessor for the SequencedEventAccessor class
+ */
+ public interface SequencedEventAccessor {
+ /*
+ * Returns the nested event.
+ */
+ AWTEvent getNested(AWTEvent sequencedEvent);
+
+ /*
+ * Returns true if the event is an instances of SequencedEvent.
+ */
+ boolean isSequencedEvent(AWTEvent event);
+
+ /*
+ * Creates SequencedEvent with the given nested event
+ */
+ AWTEvent create(AWTEvent event);
+ }
+
+ /*
+ * An accessor for the Toolkit class
+ */
+ public interface ToolkitAccessor {
+ void setPlatformResources(ResourceBundle bundle);
+ }
+
+ /*
+ * An accessor object for the InvocationEvent class
+ */
+ public interface InvocationEventAccessor {
+ void dispose(InvocationEvent event);
+ }
+
+ /*
+ * An accessor object for the SystemColor class
+ */
+ public interface SystemColorAccessor {
+ void updateSystemColors();
+ }
+
+ /*
+ * An accessor object for the AccessibleContext class
+ */
+ public interface AccessibleContextAccessor {
+ void setAppContext(AccessibleContext accessibleContext, AppContext appContext);
+ AppContext getAppContext(AccessibleContext accessibleContext);
+ Object getNativeAXResource(AccessibleContext accessibleContext);
+ void setNativeAXResource(AccessibleContext accessibleContext, Object value);
+ }
+
+ /*
+ * An accessor object for the AccessibleContext class
+ */
+ public interface AccessibleBundleAccessor {
+ String getKey(AccessibleBundle accessibleBundle);
+ }
+
+ /*
+ * An accessor object for the DragSourceContext class
+ */
+ public interface DragSourceContextAccessor {
+ /**
+ * Returns the peer of the DragSourceContext.
+ */
+ DragSourceContextPeer getPeer(DragSourceContext dsc);
+ }
+
+ /*
+ * An accessor object for the DropTargetContext class
+ */
+ public interface DropTargetContextAccessor {
+ /**
+ * Resets the DropTargetContext.
+ */
+ void reset(DropTargetContext dtc);
+ /**
+ * Sets the {@code DropTargetContextPeer}
+ */
+ void setDropTargetContextPeer(DropTargetContext dtc,
+ DropTargetContextPeer dtcp);
+ }
+
+ /*
+ * Accessor instances are initialized in the static initializers of
+ * corresponding AWT classes by using setters defined below.
+ */
+ private static ComponentAccessor componentAccessor;
+ private static ContainerAccessor containerAccessor;
+ private static WindowAccessor windowAccessor;
+ private static AWTEventAccessor awtEventAccessor;
+ private static InputEventAccessor inputEventAccessor;
+ private static FrameAccessor frameAccessor;
+ private static KeyboardFocusManagerAccessor kfmAccessor;
+ private static MenuComponentAccessor menuComponentAccessor;
+ private static EventQueueAccessor eventQueueAccessor;
+ private static PopupMenuAccessor popupMenuAccessor;
+ private static FileDialogAccessor fileDialogAccessor;
+ private static ScrollPaneAdjustableAccessor scrollPaneAdjustableAccessor;
+ private static CheckboxMenuItemAccessor checkboxMenuItemAccessor;
+ private static CursorAccessor cursorAccessor;
+ private static MenuBarAccessor menuBarAccessor;
+ private static MenuItemAccessor menuItemAccessor;
+ private static MenuAccessor menuAccessor;
+ private static KeyEventAccessor keyEventAccessor;
+ private static ClientPropertyKeyAccessor clientPropertyKeyAccessor;
+ private static SystemTrayAccessor systemTrayAccessor;
+ private static TrayIconAccessor trayIconAccessor;
+ private static DefaultKeyboardFocusManagerAccessor defaultKeyboardFocusManagerAccessor;
+ private static SequencedEventAccessor sequencedEventAccessor;
+ private static ToolkitAccessor toolkitAccessor;
+ private static InvocationEventAccessor invocationEventAccessor;
+ private static SystemColorAccessor systemColorAccessor;
+ private static AccessibleContextAccessor accessibleContextAccessor;
+ private static AccessibleBundleAccessor accessibleBundleAccessor;
+ private static DragSourceContextAccessor dragSourceContextAccessor;
+ private static DropTargetContextAccessor dropTargetContextAccessor;
+
+ /*
+ * Set an accessor object for the java.awt.Component class.
+ */
+ public static void setComponentAccessor(ComponentAccessor ca) {
+ componentAccessor = ca;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.Component class.
+ */
+ public static ComponentAccessor getComponentAccessor() {
+ if (componentAccessor == null) {
+ unsafe.ensureClassInitialized(Component.class);
+ }
+
+ return componentAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.Container class.
+ */
+ public static void setContainerAccessor(ContainerAccessor ca) {
+ containerAccessor = ca;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.Container class.
+ */
+ public static ContainerAccessor getContainerAccessor() {
+ if (containerAccessor == null) {
+ unsafe.ensureClassInitialized(Container.class);
+ }
+
+ return containerAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.Window class.
+ */
+ public static void setWindowAccessor(WindowAccessor wa) {
+ windowAccessor = wa;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.Window class.
+ */
+ public static WindowAccessor getWindowAccessor() {
+ if (windowAccessor == null) {
+ unsafe.ensureClassInitialized(Window.class);
+ }
+ return windowAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.AWTEvent class.
+ */
+ public static void setAWTEventAccessor(AWTEventAccessor aea) {
+ awtEventAccessor = aea;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.AWTEvent class.
+ */
+ public static AWTEventAccessor getAWTEventAccessor() {
+ if (awtEventAccessor == null) {
+ unsafe.ensureClassInitialized(AWTEvent.class);
+ }
+ return awtEventAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.event.InputEvent class.
+ */
+ public static void setInputEventAccessor(InputEventAccessor iea) {
+ inputEventAccessor = iea;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.event.InputEvent class.
+ */
+ public static InputEventAccessor getInputEventAccessor() {
+ if (inputEventAccessor == null) {
+ unsafe.ensureClassInitialized(InputEvent.class);
+ }
+ return inputEventAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.Frame class.
+ */
+ public static void setFrameAccessor(FrameAccessor fa) {
+ frameAccessor = fa;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.Frame class.
+ */
+ public static FrameAccessor getFrameAccessor() {
+ if (frameAccessor == null) {
+ unsafe.ensureClassInitialized(Frame.class);
+ }
+ return frameAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.KeyboardFocusManager class.
+ */
+ public static void setKeyboardFocusManagerAccessor(KeyboardFocusManagerAccessor kfma) {
+ kfmAccessor = kfma;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.KeyboardFocusManager class.
+ */
+ public static KeyboardFocusManagerAccessor getKeyboardFocusManagerAccessor() {
+ if (kfmAccessor == null) {
+ unsafe.ensureClassInitialized(KeyboardFocusManager.class);
+ }
+ return kfmAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.MenuComponent class.
+ */
+ public static void setMenuComponentAccessor(MenuComponentAccessor mca) {
+ menuComponentAccessor = mca;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.MenuComponent class.
+ */
+ public static MenuComponentAccessor getMenuComponentAccessor() {
+ if (menuComponentAccessor == null) {
+ unsafe.ensureClassInitialized(MenuComponent.class);
+ }
+ return menuComponentAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.EventQueue class.
+ */
+ public static void setEventQueueAccessor(EventQueueAccessor eqa) {
+ eventQueueAccessor = eqa;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.EventQueue class.
+ */
+ public static EventQueueAccessor getEventQueueAccessor() {
+ if (eventQueueAccessor == null) {
+ unsafe.ensureClassInitialized(EventQueue.class);
+ }
+ return eventQueueAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.PopupMenu class.
+ */
+ public static void setPopupMenuAccessor(PopupMenuAccessor pma) {
+ popupMenuAccessor = pma;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.PopupMenu class.
+ */
+ public static PopupMenuAccessor getPopupMenuAccessor() {
+ if (popupMenuAccessor == null) {
+ unsafe.ensureClassInitialized(PopupMenu.class);
+ }
+ return popupMenuAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.FileDialog class.
+ */
+ public static void setFileDialogAccessor(FileDialogAccessor fda) {
+ fileDialogAccessor = fda;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.FileDialog class.
+ */
+ public static FileDialogAccessor getFileDialogAccessor() {
+ if (fileDialogAccessor == null) {
+ unsafe.ensureClassInitialized(FileDialog.class);
+ }
+ return fileDialogAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.ScrollPaneAdjustable class.
+ */
+ public static void setScrollPaneAdjustableAccessor(ScrollPaneAdjustableAccessor adj) {
+ scrollPaneAdjustableAccessor = adj;
+ }
+
+ /*
+ * Retrieve the accessor object for the java.awt.ScrollPaneAdjustable
+ * class.
+ */
+ public static ScrollPaneAdjustableAccessor getScrollPaneAdjustableAccessor() {
+ if (scrollPaneAdjustableAccessor == null) {
+ unsafe.ensureClassInitialized(ScrollPaneAdjustable.class);
+ }
+ return scrollPaneAdjustableAccessor;
+ }
+
+ /**
+ * Set an accessor object for the java.awt.CheckboxMenuItem class.
+ */
+ public static void setCheckboxMenuItemAccessor(CheckboxMenuItemAccessor cmia) {
+ checkboxMenuItemAccessor = cmia;
+ }
+
+ /**
+ * Retrieve the accessor object for the java.awt.CheckboxMenuItem class.
+ */
+ public static CheckboxMenuItemAccessor getCheckboxMenuItemAccessor() {
+ if (checkboxMenuItemAccessor == null) {
+ unsafe.ensureClassInitialized(CheckboxMenuItemAccessor.class);
+ }
+ return checkboxMenuItemAccessor;
+ }
+
+ /**
+ * Set an accessor object for the java.awt.Cursor class.
+ */
+ public static void setCursorAccessor(CursorAccessor ca) {
+ cursorAccessor = ca;
+ }
+
+ /**
+ * Retrieve the accessor object for the java.awt.Cursor class.
+ */
+ public static CursorAccessor getCursorAccessor() {
+ if (cursorAccessor == null) {
+ unsafe.ensureClassInitialized(CursorAccessor.class);
+ }
+ return cursorAccessor;
+ }
+
+ /**
+ * Set an accessor object for the java.awt.MenuBar class.
+ */
+ public static void setMenuBarAccessor(MenuBarAccessor mba) {
+ menuBarAccessor = mba;
+ }
+
+ /**
+ * Retrieve the accessor object for the java.awt.MenuBar class.
+ */
+ public static MenuBarAccessor getMenuBarAccessor() {
+ if (menuBarAccessor == null) {
+ unsafe.ensureClassInitialized(MenuBarAccessor.class);
+ }
+ return menuBarAccessor;
+ }
+
+ /**
+ * Set an accessor object for the java.awt.MenuItem class.
+ */
+ public static void setMenuItemAccessor(MenuItemAccessor mia) {
+ menuItemAccessor = mia;
+ }
+
+ /**
+ * Retrieve the accessor object for the java.awt.MenuItem class.
+ */
+ public static MenuItemAccessor getMenuItemAccessor() {
+ if (menuItemAccessor == null) {
+ unsafe.ensureClassInitialized(MenuItemAccessor.class);
+ }
+ return menuItemAccessor;
+ }
+
+ /**
+ * Set an accessor object for the java.awt.Menu class.
+ */
+ public static void setMenuAccessor(MenuAccessor ma) {
+ menuAccessor = ma;
+ }
+
+ /**
+ * Retrieve the accessor object for the java.awt.Menu class.
+ */
+ public static MenuAccessor getMenuAccessor() {
+ if (menuAccessor == null) {
+ unsafe.ensureClassInitialized(MenuAccessor.class);
+ }
+ return menuAccessor;
+ }
+
+ /**
+ * Set an accessor object for the java.awt.event.KeyEvent class.
+ */
+ public static void setKeyEventAccessor(KeyEventAccessor kea) {
+ keyEventAccessor = kea;
+ }
+
+ /**
+ * Retrieve the accessor object for the java.awt.event.KeyEvent class.
+ */
+ public static KeyEventAccessor getKeyEventAccessor() {
+ if (keyEventAccessor == null) {
+ unsafe.ensureClassInitialized(KeyEventAccessor.class);
+ }
+ return keyEventAccessor;
+ }
+
+ /**
+ * Set an accessor object for the javax.swing.ClientPropertyKey class.
+ */
+ public static void setClientPropertyKeyAccessor(ClientPropertyKeyAccessor cpka) {
+ clientPropertyKeyAccessor = cpka;
+ }
+
+ /**
+ * Retrieve the accessor object for the javax.swing.ClientPropertyKey class.
+ */
+ public static ClientPropertyKeyAccessor getClientPropertyKeyAccessor() {
+ if (clientPropertyKeyAccessor == null) {
+ unsafe.ensureClassInitialized(ClientPropertyKeyAccessor.class);
+ }
+ return clientPropertyKeyAccessor;
+ }
+
+ /**
+ * Set an accessor object for the java.awt.SystemTray class.
+ */
+ public static void setSystemTrayAccessor(SystemTrayAccessor sta) {
+ systemTrayAccessor = sta;
+ }
+
+ /**
+ * Retrieve the accessor object for the java.awt.SystemTray class.
+ */
+ public static SystemTrayAccessor getSystemTrayAccessor() {
+ if (systemTrayAccessor == null) {
+ unsafe.ensureClassInitialized(SystemTrayAccessor.class);
+ }
+ return systemTrayAccessor;
+ }
+
+ /**
+ * Set an accessor object for the java.awt.TrayIcon class.
+ */
+ public static void setTrayIconAccessor(TrayIconAccessor tia) {
+ trayIconAccessor = tia;
+ }
+
+ /**
+ * Retrieve the accessor object for the java.awt.TrayIcon class.
+ */
+ public static TrayIconAccessor getTrayIconAccessor() {
+ if (trayIconAccessor == null) {
+ unsafe.ensureClassInitialized(TrayIconAccessor.class);
+ }
+ return trayIconAccessor;
+ }
+
+ /**
+ * Set an accessor object for the java.awt.DefaultKeyboardFocusManager class.
+ */
+ public static void setDefaultKeyboardFocusManagerAccessor(DefaultKeyboardFocusManagerAccessor dkfma) {
+ defaultKeyboardFocusManagerAccessor = dkfma;
+ }
+
+ /**
+ * Retrieve the accessor object for the java.awt.DefaultKeyboardFocusManager class.
+ */
+ public static DefaultKeyboardFocusManagerAccessor getDefaultKeyboardFocusManagerAccessor() {
+ if (defaultKeyboardFocusManagerAccessor == null) {
+ unsafe.ensureClassInitialized(DefaultKeyboardFocusManagerAccessor.class);
+ }
+ return defaultKeyboardFocusManagerAccessor;
+ }
+ /*
+ * Set an accessor object for the java.awt.SequencedEvent class.
+ */
+ public static void setSequencedEventAccessor(SequencedEventAccessor sea) {
+ sequencedEventAccessor = sea;
+ }
+
+ /*
+ * Get the accessor object for the java.awt.SequencedEvent class.
+ */
+ public static SequencedEventAccessor getSequencedEventAccessor() {
+ if (sequencedEventAccessor == null) {
+ try {
+ unsafe.ensureClassInitialized(
+ Class.forName("java.awt.SequencedEvent"));
+ } catch (ClassNotFoundException ignore) {
+ }
+ }
+ return sequencedEventAccessor;
+ }
+
+ /*
+ * Set an accessor object for the java.awt.Toolkit class.
+ */
+ public static void setToolkitAccessor(ToolkitAccessor ta) {
+ toolkitAccessor = ta;
+ }
+
+ /*
+ * Get the accessor object for the java.awt.Toolkit class.
+ */
+ public static ToolkitAccessor getToolkitAccessor() {
+ if (toolkitAccessor == null) {
+ unsafe.ensureClassInitialized(Toolkit.class);
+ }
+
+ return toolkitAccessor;
+ }
+
+ /*
+ * Get the accessor object for the java.awt.event.InvocationEvent class.
+ */
+ public static void setInvocationEventAccessor(InvocationEventAccessor invocationEventAccessor) {
+ AWTAccessor.invocationEventAccessor = invocationEventAccessor;
+ }
+
+ /*
+ * Set the accessor object for the java.awt.event.InvocationEvent class.
+ */
+ public static InvocationEventAccessor getInvocationEventAccessor() {
+ return invocationEventAccessor;
+ }
+
+ /*
+ * Get the accessor object for the java.awt.SystemColor class.
+ */
+ public static SystemColorAccessor getSystemColorAccessor() {
+ if (systemColorAccessor == null) {
+ unsafe.ensureClassInitialized(SystemColor.class);
+ }
+
+ return systemColorAccessor;
+ }
+
+ /*
+ * Set the accessor object for the java.awt.SystemColor class.
+ */
+ public static void setSystemColorAccessor(SystemColorAccessor systemColorAccessor) {
+ AWTAccessor.systemColorAccessor = systemColorAccessor;
+ }
+
+ /*
+ * Get the accessor object for the javax.accessibility.AccessibleContext class.
+ */
+ public static AccessibleContextAccessor getAccessibleContextAccessor() {
+ if (accessibleContextAccessor == null) {
+ unsafe.ensureClassInitialized(AccessibleContext.class);
+ }
+ return accessibleContextAccessor;
+ }
+
+ /*
+ * Set the accessor object for the javax.accessibility.AccessibleBundle class.
+ */
+ public static void setAccessibleBundleAccessor(AccessibleBundleAccessor accessor) {
+ AWTAccessor.accessibleBundleAccessor = accessor;
+ }
+
+ /*
+ * Get the accessor object for the javax.accessibility.AccessibleBundle class.
+ */
+ public static AccessibleBundleAccessor getAccessibleBundleAccessor() {
+ if (accessibleBundleAccessor == null) {
+ unsafe.ensureClassInitialized(AccessibleBundle.class);
+ }
+ return accessibleBundleAccessor;
+ }
+
+ /*
+ * Set the accessor object for the javax.accessibility.AccessibleContext class.
+ */
+ public static void setAccessibleContextAccessor(AccessibleContextAccessor accessor) {
+ AWTAccessor.accessibleContextAccessor = accessor;
+ }
+
+ /*
+ * Get the accessor object for the java.awt.dnd.DragSourceContext class.
+ */
+ public static DragSourceContextAccessor getDragSourceContextAccessor() {
+ if (dragSourceContextAccessor == null) {
+ unsafe.ensureClassInitialized(DragSourceContext.class);
+ }
+ return dragSourceContextAccessor;
+ }
+
+ /*
+ * Set the accessor object for the java.awt.dnd.DragSourceContext class.
+ */
+ public static void setDragSourceContextAccessor(DragSourceContextAccessor accessor) {
+ AWTAccessor.dragSourceContextAccessor = accessor;
+ }
+
+ /*
+ * Get the accessor object for the java.awt.dnd.DropTargetContext class.
+ */
+ public static DropTargetContextAccessor getDropTargetContextAccessor() {
+ if (dropTargetContextAccessor == null) {
+ unsafe.ensureClassInitialized(DropTargetContext.class);
+ }
+ return dropTargetContextAccessor;
+ }
+
+ /*
+ * Set the accessor object for the java.awt.dnd.DropTargetContext class.
+ */
+ public static void setDropTargetContextAccessor(DropTargetContextAccessor accessor) {
+ AWTAccessor.dropTargetContextAccessor = accessor;
+ }
+
+}