1290 lines
38 KiB
Java
1290 lines
38 KiB
Java
/*
|
|
* Copyright (c) 2008, 2014, 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 javax.accessibility.AccessibleContext;
|
|
import java.awt.*;
|
|
import java.awt.KeyboardFocusManager;
|
|
import java.awt.DefaultKeyboardFocusManager;
|
|
import java.awt.event.InputEvent;
|
|
import java.awt.event.InvocationEvent;
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.event.MouseEvent;
|
|
import java.awt.geom.Point2D;
|
|
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;
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* Revalidates the component synchronously.
|
|
*/
|
|
void revalidateSynchronously(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);
|
|
}
|
|
|
|
/*
|
|
* 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();
|
|
}
|
|
|
|
/**
|
|
* An accessor for the MouseEvent class.
|
|
*/
|
|
public interface MouseEventAccessor {
|
|
/**
|
|
* Indicates whether the event is a result of a touch event.
|
|
*/
|
|
boolean isCausedByTouchEvent(MouseEvent ev);
|
|
|
|
/**
|
|
* Sets whether the event is a result of a touch event.
|
|
*/
|
|
void setCausedByTouchEvent(MouseEvent ev, boolean causedByTouchEvent);
|
|
}
|
|
|
|
/*
|
|
* 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);
|
|
|
|
/**
|
|
* Returns the peer of the menu component.
|
|
*/
|
|
<T extends MenuComponentPeer> T getPeer(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 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);
|
|
}
|
|
|
|
/*
|
|
* 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);
|
|
}
|
|
|
|
/*
|
|
* 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 MouseEventAccessor mouseEventAccessor;
|
|
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;
|
|
|
|
/*
|
|
* 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.event.MouseEvent class.
|
|
*/
|
|
public static void setMouseEventAccessor(MouseEventAccessor mea) {
|
|
mouseEventAccessor = mea;
|
|
}
|
|
|
|
/*
|
|
* Retrieve the accessor object for the java.awt.event.MouseEvent class.
|
|
*/
|
|
public static MouseEventAccessor getMouseEventAccessor() {
|
|
if (mouseEventAccessor == null) {
|
|
unsafe.ensureClassInitialized(MouseEvent.class);
|
|
}
|
|
return mouseEventAccessor;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
|
|
/*
|
|
* 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.AccessibleContext class.
|
|
*/
|
|
public static void setAccessibleContextAccessor(AccessibleContextAccessor accessor) {
|
|
AWTAccessor.accessibleContextAccessor = accessor;
|
|
}
|
|
}
|