/*
* Copyright (c) 2008, 2012, 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 sun.misc.Unsafe;
import java.awt.*;
import java.awt.KeyboardFocusManager;
import java.awt.DefaultKeyboardFocusManager;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.geom.Point2D;
import java.awt.peer.ComponentPeer;
import java.lang.reflect.InvocationTargetException;
import java.security.AccessControlContext;
import java.io.File;
import java.util.Vector;
/**
* 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</code> object. The bounds specify this
* component's width, height, and location relative to
* its parent.
*/
Rectangle getBounds(Component comp);
/*
* Sets the shape of a lw component to cut out from hw components.
*
* See 6797587, 6776743, 6768307, and 6768332 for details
*/
void setMixingCutoutShape(Component comp, Shape shape);
/**
* Sets GraphicsConfiguration value for the component.
*/
void setGraphicsConfiguration(Component comp, GraphicsConfiguration gc);
/*
* Requests focus to the component.
*/
boolean requestFocus(Component comp, CausedFocusEvent.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.
*/
ComponentPeer 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);
}
/*
* An interface of accessor for the java.awt.Container class.
*/
public interface ContainerAccessor {
/**
* Validates the container unconditionally.
*/
void validateUnconditionally(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);
}
/**
* 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();
}
/*
* 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,
CausedFocusEvent.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);
/**
* 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 menu container of the menu component
*/
MenuContainer getParent(MenuComponent menuComp);
/**
* 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
*/
public void setFwDispatcher(EventQueue eventQueue, FwDispatcher dispatcher);
}
/*
* 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 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 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);
}
/**
* 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);
}
/*
* 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;
/*
* 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() {
// The class is not public. So we can't ensure it's initialized.
// Null returned value means it's not initialized
// (so not a single instance of the event has been created).
return sequencedEventAccessor;
}
}