stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

7163201: Simplify toolkit internals references

Browse Source 
Reviewed-by: art, anthony, ahgross
This commit is contained in:
Oleg Pekhovskiy 2012-08-30 13:11:23 -07:00
parent 5f51412783
commit ffc9ae1245
38 changed files with 634 additions and 610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
jdk/src/macosx/classes/sun/lwawt/macosx/LWCToolkit.java
View File

@ -81,14 +81,6 @@ public class LWCToolkit extends LWToolkit {
}
}
static String getSystemProperty(final String name, final String deflt) {
return AccessController.doPrivileged (new PrivilegedAction<String>() {
public String run() {
return System.getProperty(name, deflt);
}
});
}
public LWCToolkit() {
SunToolkit.setDataTransfererClassName("sun.lwawt.macosx.CDataTransferer");
@ -700,8 +692,8 @@ public class LWCToolkit extends LWToolkit {
*/
public synchronized static boolean getSunAwtDisableCALayers() {
if (sunAwtDisableCALayers == null) {
sunAwtDisableCALayers =
getBooleanSystemProperty("sun.awt.disableCALayers");
sunAwtDisableCALayers = AccessController.doPrivileged(
new GetBooleanAction("sun.awt.disableCALayers")));
}
return sunAwtDisableCALayers.booleanValue();
}

13
jdk/src/share/classes/java/awt/AWTEvent.java
View File

@ -35,8 +35,6 @@ import sun.util.logging.PlatformLogger;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.io.ObjectInputStream;
import java.io.IOException;
/**
* The root event class for all AWT events.
@ -262,9 +260,11 @@ public abstract class AWTEvent extends EventObject {
public void setPosted(AWTEvent ev) {
ev.isPosted = true;
}
public void setSystemGenerated(AWTEvent ev) {
ev.isSystemGenerated = true;
}
public boolean isSystemGenerated(AWTEvent ev) {
return ev.isSystemGenerated;
}
@ -272,6 +272,15 @@ public abstract class AWTEvent extends EventObject {
public AccessControlContext getAccessControlContext(AWTEvent ev) {
return ev.getAccessControlContext();
}
public byte[] getBData(AWTEvent ev) {
return ev.bdata;
}
public void setBData(AWTEvent ev, byte[] bdata) {
ev.bdata = bdata;
}
});
}

8
jdk/src/share/classes/java/awt/CheckboxMenuItem.java
View File

@ -31,6 +31,7 @@ import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import javax.accessibility.*;
import sun.awt.AWTAccessor;
/**
@ -68,6 +69,13 @@ public class CheckboxMenuItem extends MenuItem implements ItemSelectable, Access
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
AWTAccessor.setCheckboxMenuItemAccessor(
new AWTAccessor.CheckboxMenuItemAccessor() {
public boolean getState(CheckboxMenuItem cmi) {
return cmi.state;
}
});
}
/**

20
jdk/src/share/classes/java/awt/Cursor.java
View File

@ -24,10 +24,6 @@
*/
package java.awt;
import java.awt.AWTException;
import java.awt.Point;
import java.awt.Toolkit;
import java.io.File;
import java.io.FileInputStream;
@ -39,6 +35,7 @@ import java.util.StringTokenizer;
import java.security.AccessController;
import sun.util.logging.PlatformLogger;
import sun.awt.AWTAccessor;
/**
* A class to encapsulate the bitmap representation of the mouse cursor.
@ -199,6 +196,21 @@ public class Cursor implements java.io.Serializable {
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
AWTAccessor.setCursorAccessor(
new AWTAccessor.CursorAccessor() {
public long getPData(Cursor cursor) {
return cursor.pData;
}
public void setPData(Cursor cursor, long pData) {
cursor.pData = pData;
}
public int getType(Cursor cursor) {
return cursor.type;
}
});
}
/**

10
jdk/src/share/classes/java/awt/DefaultKeyboardFocusManager.java
View File

@ -39,6 +39,7 @@ import sun.util.logging.PlatformLogger;
import sun.awt.AppContext;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
import sun.awt.CausedFocusEvent;
/**
@ -75,6 +76,15 @@ public class DefaultKeyboardFocusManager extends KeyboardFocusManager {
typeAheadMarkers = new LinkedList();
private boolean consumeNextKeyTyped;
static {
AWTAccessor.setDefaultKeyboardFocusManagerAccessor(
new AWTAccessor.DefaultKeyboardFocusManagerAccessor() {
public void consumeNextKeyTyped(DefaultKeyboardFocusManager dkfm, KeyEvent e) {
dkfm.consumeNextKeyTyped(e);
}
});
}
private static class TypeAheadMarker {
long after;
Component untilFocused;

12
jdk/src/share/classes/java/awt/EventQueue.java
View File

@ -50,7 +50,6 @@ import java.util.concurrent.locks.Lock;
import java.util.concurrent.atomic.AtomicInteger;
import java.security.AccessControlContext;
import java.security.ProtectionDomain;
import sun.misc.SharedSecrets;
import sun.misc.JavaSecurityAccess;
@ -186,6 +185,17 @@ public class EventQueue {
public boolean isDispatchThreadImpl(EventQueue eventQueue) {
return eventQueue.isDispatchThreadImpl();
}
public void removeSourceEvents(EventQueue eventQueue,
Object source,
boolean removeAllEvents) {
eventQueue.removeSourceEvents(source, removeAllEvents);
}
public boolean noEvents(EventQueue eventQueue) {
return eventQueue.noEvents();
}
public void wakeup(EventQueue eventQueue, boolean isShutdown) {
eventQueue.wakeup(isShutdown);
}
});
}

4
jdk/src/share/classes/java/awt/KeyboardFocusManager.java
View File

@ -56,7 +56,6 @@ import java.util.WeakHashMap;
import sun.util.logging.PlatformLogger;
import sun.awt.AppContext;
import sun.awt.HeadlessToolkit;
import sun.awt.SunToolkit;
import sun.awt.CausedFocusEvent;
import sun.awt.KeyboardFocusManagerPeerProvider;
@ -148,6 +147,9 @@ public abstract class KeyboardFocusManager
public KeyboardFocusManager getCurrentKeyboardFocusManager(AppContext ctx) {
return KeyboardFocusManager.getCurrentKeyboardFocusManager(ctx);
}
public Container getCurrentFocusCycleRoot() {
return KeyboardFocusManager.currentFocusCycleRoot;
}
}
);
}

8
jdk/src/share/classes/java/awt/Menu.java
View File

@ -31,6 +31,7 @@ import java.util.Enumeration;
import java.awt.peer.MenuPeer;
import java.awt.event.KeyEvent;
import javax.accessibility.*;
import sun.awt.AWTAccessor;
/**
* A <code>Menu</code> object is a pull-down menu component
@ -62,6 +63,13 @@ public class Menu extends MenuItem implements MenuContainer, Accessible {
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
AWTAccessor.setMenuAccessor(
new AWTAccessor.MenuAccessor() {
public Vector getItems(Menu menu) {
return menu.items;
}
});
}
/**

11
jdk/src/share/classes/java/awt/MenuBar.java
View File

@ -28,6 +28,7 @@ import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Vector;
import java.util.Enumeration;
import sun.awt.AWTAccessor;
import java.awt.peer.MenuBarPeer;
import java.awt.event.KeyEvent;
import javax.accessibility.*;
@ -74,6 +75,16 @@ public class MenuBar extends MenuComponent implements MenuContainer, Accessible
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
AWTAccessor.setMenuBarAccessor(
new AWTAccessor.MenuBarAccessor() {
public Menu getHelpMenu(MenuBar menuBar) {
return menuBar.helpMenu;
}
public Vector getMenus(MenuBar menuBar) {
return menuBar.menus;
}
});
}
/**

4
jdk/src/share/classes/java/awt/MenuComponent.java
View File

@ -29,7 +29,6 @@ import java.awt.event.ActionEvent;
import java.io.IOException;
import java.io.ObjectInputStream;
import sun.awt.AppContext;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
import javax.accessibility.*;
@ -143,6 +142,9 @@ public abstract class MenuComponent implements java.io.Serializable {
public MenuContainer getParent(MenuComponent menuComp) {
return menuComp.parent;
}
public Font getFont_NoClientCode(MenuComponent menuComp) {
return menuComp.getFont_NoClientCode();
}
});
}

25
jdk/src/share/classes/java/awt/MenuItem.java
View File

@ -31,7 +31,7 @@ import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.io.IOException;
import javax.accessibility.*;
import sun.awt.AWTAccessor;
/**
* All items in a menu must belong to the class
@ -76,6 +76,29 @@ public class MenuItem extends MenuComponent implements Accessible {
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
AWTAccessor.setMenuItemAccessor(
new AWTAccessor.MenuItemAccessor() {
public boolean isEnabled(MenuItem item) {
return item.enabled;
}
public String getLabel(MenuItem item) {
return item.label;
}
public MenuShortcut getShortcut(MenuItem item) {
return item.shortcut;
}
public String getActionCommandImpl(MenuItem item) {
return item.getActionCommandImpl();
}
public boolean isItemEnabled(MenuItem item) {
return item.isItemEnabled();
}
});
}
/**

13
jdk/src/share/classes/java/awt/SystemTray.java
View File

@ -33,6 +33,7 @@ import sun.awt.AppContext;
import sun.awt.SunToolkit;
import sun.awt.HeadlessToolkit;
import sun.security.util.SecurityConstants;
import sun.awt.AWTAccessor;
/**
* The <code>SystemTray</code> class represents the system tray for a
@ -127,6 +128,18 @@ public class SystemTray {
private static final TrayIcon[] EMPTY_TRAY_ARRAY = new TrayIcon[0];
static {
AWTAccessor.setSystemTrayAccessor(
new AWTAccessor.SystemTrayAccessor() {
public void firePropertyChange(SystemTray tray,
String propertyName,
Object oldValue,
Object newValue) {
tray.firePropertyChange(propertyName, oldValue, newValue);
}
});
}
/**
* Private <code>SystemTray</code> constructor.
*

20
jdk/src/share/classes/java/awt/TrayIcon.java
View File

@ -25,19 +25,11 @@
package java.awt;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.GraphicsEnvironment;
import java.awt.event.*;
import java.awt.AWTEvent;
import java.awt.AWTEventMulticaster;
import java.awt.EventQueue;
import java.awt.PopupMenu;
import java.awt.Image;
import java.util.EventListener;
import java.awt.peer.TrayIconPeer;
import sun.awt.AppContext;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
import sun.awt.HeadlessToolkit;
import java.util.EventObject;
import java.security.AccessControlContext;
@ -129,6 +121,16 @@ public class TrayIcon {
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
AWTAccessor.setTrayIconAccessor(
new AWTAccessor.TrayIconAccessor() {
public void addNotify(TrayIcon trayIcon) throws AWTException {
trayIcon.addNotify();
}
public void removeNotify(TrayIcon trayIcon) {
trayIcon.removeNotify();
}
});
}
private TrayIcon()

19
jdk/src/share/classes/java/awt/event/KeyEvent.java
View File

@ -25,12 +25,12 @@
package java.awt.event;
import java.awt.Event;
import java.awt.Component;
import java.awt.GraphicsEnvironment;
import java.awt.Toolkit;
import java.io.IOException;
import java.io.ObjectInputStream;
import sun.awt.AWTAccessor;
/**
* An event which indicates that a keystroke occurred in a component.
@ -914,6 +914,23 @@ public class KeyEvent extends InputEvent {
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
AWTAccessor.setKeyEventAccessor(
new AWTAccessor.KeyEventAccessor() {
public void setRawCode(KeyEvent ev, long rawCode) {
ev.rawCode = rawCode;
}
public void setPrimaryLevelUnicode(KeyEvent ev,
long primaryLevelUnicode) {
ev.primaryLevelUnicode = primaryLevelUnicode;
}
public void setExtendedKeyCode(KeyEvent ev,
long extendedKeyCode) {
ev.extendedKeyCode = extendedKeyCode;
}
});
}
/**

11
jdk/src/share/classes/javax/swing/ClientPropertyKey.java
View File

@ -25,6 +25,8 @@
package javax.swing;
import sun.awt.AWTAccessor;
/**
* An enumeration for keys used as client properties within the Swing
* implementation.
@ -86,6 +88,15 @@ enum ClientPropertyKey {
*/
private final boolean reportValueNotSerializable;
static {
AWTAccessor.setClientPropertyKeyAccessor(
new AWTAccessor.ClientPropertyKeyAccessor() {
public Object getJComponent_TRANSFER_HANDLER() {
return JComponent_TRANSFER_HANDLER;
}
});
}
/**
* Constructs a key with the {@code reportValueNotSerializable} property
* set to {@code false}.

388
jdk/src/share/classes/sun/awt/AWTAccessor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
* 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
@ -29,12 +29,15 @@ 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.security.AccessControlContext;
import java.io.File;
import java.util.Vector;
/**
* The AWTAccessor utility class.
@ -314,7 +317,7 @@ public final class AWTAccessor {
void setTrayIconWindow(Window w, boolean isTrayIconWindow);
}
/*
/**
* An accessor for the AWTEvent class.
*/
public interface AWTEventAccessor {
@ -334,12 +337,20 @@ public final class AWTAccessor {
*/
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 {
@ -367,11 +378,11 @@ public final class AWTAccessor {
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.
*/
@ -381,7 +392,7 @@ public final class AWTAccessor {
boolean focusedWindowChangeAllowed,
long time,
CausedFocusEvent.Cause cause);
/*
/**
* Delivers focus for the lightweight descendant of the heavyweight
* synchronously.
*/
@ -390,23 +401,28 @@ public final class AWTAccessor {
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 {
@ -424,20 +440,42 @@ public final class AWTAccessor {
* 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);
}
/*
@ -486,6 +524,148 @@ public final class AWTAccessor {
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);
}
/**
* 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);
}
/*
* Accessor instances are initialized in the static initializers of
* corresponding AWT classes by using setters defined below.
@ -502,6 +682,16 @@ public final class AWTAccessor {
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;
/*
* Set an accessor object for the java.awt.Component class.
@ -709,4 +899,174 @@ public final class AWTAccessor {
}
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;
}
}

71
jdk/src/share/classes/sun/awt/EmbeddedFrame.java
View File

@ -29,12 +29,6 @@ import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.awt.peer.*;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;
import java.lang.reflect.Field;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeEvent;
import java.util.Set;
@ -66,8 +60,6 @@ public abstract class EmbeddedFrame extends Frame
implements KeyEventDispatcher, PropertyChangeListener {
private boolean isCursorAllowed = true;
private static Field fieldPeer;
private static Field currentCycleRoot;
private boolean supportsXEmbed = false;
private KeyboardFocusManager appletKFM;
// JDK 1.1 compatibility
@ -213,39 +205,8 @@ public abstract class EmbeddedFrame extends Frame
*/
public boolean dispatchKeyEvent(KeyEvent e) {
// We can't guarantee that this is called on the same AppContext as EmbeddedFrame
// belongs to. That's why we can't use public methods to find current focus cycle
// root. Instead, we access KFM's private field directly.
if (currentCycleRoot == null) {
currentCycleRoot = AccessController.doPrivileged(new PrivilegedAction<Field>() {
public Field run() {
try {
Field unaccessibleRoot = KeyboardFocusManager.class.
getDeclaredField("currentFocusCycleRoot");
if (unaccessibleRoot != null) {
unaccessibleRoot.setAccessible(true);
}
return unaccessibleRoot;
} catch (NoSuchFieldException e1) {
assert false;
} catch (SecurityException e2) {
assert false;
}
return null;
}
});
}
Container currentRoot = null;
if (currentCycleRoot != null) {
try {
// The field is static, so we can pass null to Field.get() as the argument.
currentRoot = (Container)currentCycleRoot.get(null);
} catch (IllegalAccessException e3) {
// This is impossible: currentCycleRoot would be null if setAccessible failed.
assert false;
}
}
Container currentRoot = AWTAccessor.getKeyboardFocusManagerAccessor()
.getCurrentFocusCycleRoot();
// if we are not in EmbeddedFrame's cycle, we should not try to leave.
if (this != currentRoot) {
@ -389,32 +350,8 @@ public abstract class EmbeddedFrame extends Frame
@SuppressWarnings("deprecation")
protected void setPeer(final ComponentPeer p){
if (fieldPeer == null) {
fieldPeer = AccessController.doPrivileged(new PrivilegedAction<Field>() {
public Field run() {
try {
Field lnkPeer = Component.class.getDeclaredField("peer");
if (lnkPeer != null) {
lnkPeer.setAccessible(true);
}
return lnkPeer;
} catch (NoSuchFieldException e) {
assert false;
} catch (SecurityException e) {
assert false;
}
return null;
}//run
});
}
try{
if (fieldPeer != null){
fieldPeer.set(EmbeddedFrame.this, p);
}
} catch (IllegalAccessException e) {
assert false;
}
}; //setPeer method ends
AWTAccessor.getComponentAccessor().setPeer(EmbeddedFrame.this, p);
};
/**
* Synthesize native message to activate or deactivate EmbeddedFrame window

122
jdk/src/share/classes/sun/awt/SunToolkit.java
View File

@ -51,14 +51,8 @@ import sun.awt.im.InputContext;
import sun.awt.image.*;
import sun.security.action.GetPropertyAction;
import sun.security.action.GetBooleanAction;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
public abstract class SunToolkit extends Toolkit
implements WindowClosingSupport, WindowClosingListener,
@ -80,7 +74,6 @@ public abstract class SunToolkit extends Toolkit
*/
public static final int GRAB_EVENT_MASK = 0x80000000;
private static Method wakeupMethod;
/* The key to put()/get() the PostEventQueue into/from the AppContext.
*/
private static final String POST_EVENT_QUEUE_KEY = "PostEventQueue";
@ -295,52 +288,8 @@ public abstract class SunToolkit extends Toolkit
return appContext;
}
public static Field getField(final Class<?> klass, final String fieldName) {
return AccessController.doPrivileged(new PrivilegedAction<Field>() {
public Field run() {
try {
Field field = klass.getDeclaredField(fieldName);
assert (field != null);
field.setAccessible(true);
return field;
} catch (SecurityException e) {
assert false;
} catch (NoSuchFieldException e) {
assert false;
}
return null;
}//run
});
}
static void wakeupEventQueue(EventQueue q, boolean isShutdown){
if (wakeupMethod == null){
wakeupMethod = AccessController.doPrivileged(new PrivilegedAction<Method>() {
public Method run() {
try {
Method method = EventQueue.class.getDeclaredMethod("wakeup",new Class [] {Boolean.TYPE} );
if (method != null) {
method.setAccessible(true);
}
return method;
} catch (NoSuchMethodException e) {
assert false;
} catch (SecurityException e) {
assert false;
}
return null;
}//run
});
}
try{
if (wakeupMethod != null){
wakeupMethod.invoke(q, new Object[]{Boolean.valueOf(isShutdown)});
}
} catch (InvocationTargetException e){
assert false;
} catch (IllegalAccessException e) {
assert false;
}
AWTAccessor.getEventQueueAccessor().wakeup(q, isShutdown);
}
/*
@ -1460,22 +1409,6 @@ public abstract class SunToolkit extends Toolkit
|| comp instanceof Window);
}
public static Method getMethod(final Class<?> clz, final String methodName, final Class[] params) {
Method res = null;
try {
res = AccessController.doPrivileged(new PrivilegedExceptionAction<Method>() {
public Method run() throws Exception {
Method m = clz.getDeclaredMethod(methodName, params);
m.setAccessible(true);
return m;
}
});
} catch (PrivilegedActionException ex) {
ex.printStackTrace();
}
return res;
}
@SuppressWarnings("serial")
public static class OperationTimedOut extends RuntimeException {
public OperationTimedOut(String msg) {
@ -1622,21 +1555,9 @@ public abstract class SunToolkit extends Toolkit
private boolean queueEmpty = false;
private final Object waitLock = "Wait Lock";
static Method eqNoEvents;
private boolean isEQEmpty() {
EventQueue queue = getSystemEventQueueImpl();
synchronized(SunToolkit.class) {
if (eqNoEvents == null) {
eqNoEvents = getMethod(java.awt.EventQueue.class, "noEvents", null);
}
}
try {
return (Boolean)eqNoEvents.invoke(queue);
} catch (Exception e) {
e.printStackTrace();
return false;
}
return AWTAccessor.getEventQueueAccessor().noEvents(queue);
}
/**
@ -1892,20 +1813,14 @@ public abstract class SunToolkit extends Toolkit
* consumeNextKeyTyped() method is not currently used,
* however Swing could use it in the future.
*/
private static Method consumeNextKeyTypedMethod = null;
public static synchronized void consumeNextKeyTyped(KeyEvent keyEvent) {
if (consumeNextKeyTypedMethod == null) {
consumeNextKeyTypedMethod = getMethod(DefaultKeyboardFocusManager.class,
"consumeNextKeyTyped",
new Class<?>[] {KeyEvent.class});
}
try {
consumeNextKeyTypedMethod.invoke(KeyboardFocusManager.getCurrentKeyboardFocusManager(),
keyEvent);
} catch (IllegalAccessException iae) {
iae.printStackTrace();
} catch (InvocationTargetException ite) {
ite.printStackTrace();
AWTAccessor.getDefaultKeyboardFocusManagerAccessor().consumeNextKeyTyped(
(DefaultKeyboardFocusManager)KeyboardFocusManager.
getCurrentKeyboardFocusManager(),
keyEvent);
} catch (ClassCastException cce) {
cce.printStackTrace();
}
}
@ -1925,24 +1840,6 @@ public abstract class SunToolkit extends Toolkit
return (Window)comp;
}
/**
* Returns the value of the system property indicated by the specified key.
*/
public static String getSystemProperty(final String key) {
return AccessController.doPrivileged(new PrivilegedAction<String>() {
public String run() {
return System.getProperty(key);
}
});
}
/**
* Returns the boolean value of the system property indicated by the specified key.
*/
protected static Boolean getBooleanSystemProperty(String key) {
return AccessController.doPrivileged(new GetBooleanAction(key));
}
private static Boolean sunAwtDisableMixing = null;
/**
@ -1951,7 +1848,8 @@ public abstract class SunToolkit extends Toolkit
*/
public synchronized static boolean getSunAwtDisableMixing() {
if (sunAwtDisableMixing == null) {
sunAwtDisableMixing = getBooleanSystemProperty("sun.awt.disableMixing");
sunAwtDisableMixing = AccessController.doPrivileged(
new GetBooleanAction("sun.awt.disableMixing"));
}
return sunAwtDisableMixing.booleanValue();
}

29
jdk/src/solaris/classes/sun/awt/X11/XCheckboxMenuItemPeer.java
View File

@ -29,25 +29,10 @@ import java.awt.*;
import java.awt.peer.*;
import java.awt.event.*;
import java.lang.reflect.Field;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
class XCheckboxMenuItemPeer extends XMenuItemPeer implements CheckboxMenuItemPeer {
/************************************************
*
* Data members
*
************************************************/
/*
* CheckboxMenuItem's fields
*/
private final static Field f_state;
static {
f_state = SunToolkit.getField(CheckboxMenuItem.class, "state");
}
/************************************************
*
* Construction
@ -74,16 +59,8 @@ class XCheckboxMenuItemPeer extends XMenuItemPeer implements CheckboxMenuItemPee
*
************************************************/
boolean getTargetState() {
MenuItem target = getTarget();
if (target == null) {
return false;
}
try {
return f_state.getBoolean(target);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return false;
return AWTAccessor.getCheckboxMenuItemAccessor()
.getState((CheckboxMenuItem)getTarget());
}
/************************************************

17
jdk/src/solaris/classes/sun/awt/X11/XEmbedCanvasPeer.java
View File

@ -29,13 +29,8 @@ import java.awt.*;
import java.awt.dnd.DropTarget;
import java.awt.dnd.DropTargetListener;
import java.awt.event.*;
import java.awt.image.ColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.image.VolatileImage;
import java.awt.peer.*;
import sun.awt.*;
import java.lang.reflect.*;
import sun.awt.AWTAccessor;
import sun.util.logging.PlatformLogger;
import java.util.*;
import static sun.awt.X11.XEmbedHelper.*;
@ -454,16 +449,8 @@ public class XEmbedCanvasPeer extends XCanvasPeer implements WindowFocusListener
}
}
static Field bdataField;
static byte[] getBData(KeyEvent e) {
try {
if (bdataField == null) {
bdataField = SunToolkit.getField(java.awt.AWTEvent.class, "bdata");
}
return (byte[])bdataField.get(e);
} catch (IllegalAccessException ex) {
return null;
}
return AWTAccessor.getAWTEventAccessor().getBData(e);
}
void forwardKeyEvent(KeyEvent e) {

16
jdk/src/solaris/classes/sun/awt/X11/XEmbeddingContainer.java
View File

@ -29,7 +29,7 @@ import java.awt.*;
import java.util.HashMap;
import java.awt.event.KeyEvent;
import java.lang.reflect.*;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
public class XEmbeddingContainer extends XEmbedHelper implements XEventDispatcher {
HashMap children = new HashMap();
@ -127,20 +127,8 @@ public class XEmbeddingContainer extends XEmbedHelper implements XEventDispatche
}
}
static Field bdata;
byte[] getBData(KeyEvent e) {
try {
if (bdata == null) {
bdata = SunToolkit.getField(java.awt.AWTEvent.class, "bdata");
}
return (byte[])bdata.get(e);
} catch (IllegalAccessException ex) {
return null;
}
}
void forwardKeyEvent(long child, KeyEvent e) {
byte[] bdata = getBData(e);
byte[] bdata = AWTAccessor.getAWTEventAccessor().getBData(e);
long data = Native.toData(bdata);
if (data == 0) {
return;

26
jdk/src/solaris/classes/sun/awt/X11/XGlobalCursorManager.java
View File

@ -27,10 +27,7 @@ package sun.awt.X11;
import java.awt.*;
import java.awt.peer.ComponentPeer;
import java.awt.peer.LightweightPeer;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import sun.awt.AWTAccessor;
import sun.awt.GlobalCursorManager;
@ -38,23 +35,6 @@ import sun.awt.SunToolkit;
public final class XGlobalCursorManager extends GlobalCursorManager {
private static Field field_pData;
private static Field field_type;
private static Class cursorClass;
private static Method method_setPData;
static {
cursorClass = java.awt.Cursor.class;
field_pData = SunToolkit.getField(cursorClass, "pData");
field_type = SunToolkit.getField(cursorClass, "type");
method_setPData = SunToolkit.getMethod(cursorClass, "setPData", new Class[] {long.class});
if (field_pData == null || field_type == null || method_setPData == null) {
System.out.println("Unable to initialize XGlobalCursorManager: ");
Thread.dumpStack();
}
}
// cached nativeContainer
private WeakReference<Component> nativeContainer;
@ -213,8 +193,8 @@ public final class XGlobalCursorManager extends GlobalCursorManager {
long pData = 0;
int type = 0;
try {
pData = field_pData.getLong(c);
type = field_type.getInt(c);
pData = AWTAccessor.getCursorAccessor().getPData(c);
type = AWTAccessor.getCursorAccessor().getType(c);
}
catch (Exception e)
{
@ -284,7 +264,7 @@ public final class XGlobalCursorManager extends GlobalCursorManager {
static void setPData(Cursor c, long pData) {
try {
method_setPData.invoke(c, pData);
AWTAccessor.getCursorAccessor().setPData(c, pData);
}
catch (Exception e)
{

28
jdk/src/solaris/classes/sun/awt/X11/XMenuBarPeer.java
View File

@ -28,10 +28,9 @@ import java.awt.*;
import java.awt.peer.*;
import java.awt.event.*;
import java.lang.reflect.Field;
import java.util.Vector;
import sun.util.logging.PlatformLogger;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
public class XMenuBarPeer extends XBaseMenuWindow implements MenuBarPeer {
@ -67,15 +66,6 @@ public class XMenuBarPeer extends XBaseMenuWindow implements MenuBarPeer {
private final static int BAR_ITEM_MARGIN_TOP = 2;
private final static int BAR_ITEM_MARGIN_BOTTOM = 2;
//fields
private static Field f_helpMenu;
private static Field f_menus;
static {
f_helpMenu = SunToolkit.getField(MenuBar.class, "helpMenu");
f_menus = SunToolkit.getField(MenuBar.class, "menus");
}
/************************************************
*
* Mapping data
@ -204,16 +194,12 @@ public class XMenuBarPeer extends XBaseMenuWindow implements MenuBarPeer {
*/
void postInit(XCreateWindowParams params) {
super.postInit(params);
Vector targetMenuVector = null;
Menu targetHelpMenu = null;
try {
// Get menus from the target.
targetMenuVector = (Vector)f_menus.get(menuBarTarget);
targetHelpMenu = (Menu)f_helpMenu.get(menuBarTarget);
reloadItems(targetMenuVector);
} catch (IllegalAccessException iae) {
iae.printStackTrace();
}
// Get menus from the target.
Vector targetMenuVector = AWTAccessor.getMenuBarAccessor()
.getMenus(menuBarTarget);
Menu targetHelpMenu = AWTAccessor.getMenuBarAccessor()
.getHelpMenu(menuBarTarget);
reloadItems(targetMenuVector);
if (targetHelpMenu != null) {
addHelpMenu(targetHelpMenu);
}

72
jdk/src/solaris/classes/sun/awt/X11/XMenuItemPeer.java
View File

@ -28,10 +28,7 @@ import java.awt.*;
import java.awt.peer.*;
import java.awt.event.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
public class XMenuItemPeer implements MenuItemPeer {
@ -81,24 +78,6 @@ public class XMenuItemPeer implements MenuItemPeer {
private final static int SEPARATOR_WIDTH = 20;
private final static int SEPARATOR_HEIGHT = 5;
/*
* MenuItem's fields & methods
*/
private final static Field f_enabled;
private final static Field f_label;
private final static Field f_shortcut;
private final static Method m_getFont;
private final static Method m_isItemEnabled;
private final static Method m_getActionCommand;
static {
f_enabled = SunToolkit.getField(MenuItem.class, "enabled");
f_label = SunToolkit.getField(MenuItem.class, "label");
f_shortcut = SunToolkit.getField(MenuItem.class, "shortcut");
m_getFont = SunToolkit.getMethod(MenuComponent.class, "getFont_NoClientCode", null);
m_getActionCommand = SunToolkit.getMethod(MenuItem.class, "getActionCommandImpl", null);
m_isItemEnabled = SunToolkit.getMethod(MenuItem.class, "isItemEnabled", null);
}
/************************************************
*
* Text Metrics
@ -216,39 +195,21 @@ public class XMenuItemPeer implements MenuItemPeer {
if (target == null) {
return XWindow.getDefaultFont();
}
try {
return (Font)m_getFont.invoke(target, new Object[0]);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return XWindow.getDefaultFont();
return AWTAccessor.getMenuComponentAccessor().getFont_NoClientCode(target);
}
String getTargetLabel() {
if (target == null) {
return "";
}
try {
String label = (String)f_label.get(target);
return (label == null) ? "" : label;
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return "";
return AWTAccessor.getMenuItemAccessor().getLabel(target);
}
boolean isTargetEnabled() {
if (target == null) {
return false;
}
try {
return f_enabled.getBoolean(target);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return false;
return AWTAccessor.getMenuItemAccessor().isEnabled(target);
}
/**
@ -260,40 +221,21 @@ public class XMenuItemPeer implements MenuItemPeer {
if (target == null) {
return false;
}
try {
return ((Boolean)m_isItemEnabled.invoke(target, new Object[0])).booleanValue();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return false;
return AWTAccessor.getMenuItemAccessor().isItemEnabled(target);
}
String getTargetActionCommand() {
if (target == null) {
return "";
}
try {
return (String) m_getActionCommand.invoke(target,(Object[]) null);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return "";
return AWTAccessor.getMenuItemAccessor().getActionCommandImpl(target);
}
MenuShortcut getTargetShortcut() {
if (target == null) {
return null;
}
try {
return (MenuShortcut)f_shortcut.get(target);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
return AWTAccessor.getMenuItemAccessor().getShortcut(target);
}
String getShortcutText() {

20
jdk/src/solaris/classes/sun/awt/X11/XMenuPeer.java
View File

@ -27,10 +27,9 @@ package sun.awt.X11;
import java.awt.*;
import java.awt.peer.*;
import java.lang.reflect.Field;
import java.util.Vector;
import sun.util.logging.PlatformLogger;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
public class XMenuPeer extends XMenuItemPeer implements MenuPeer {
@ -46,16 +45,6 @@ public class XMenuPeer extends XMenuItemPeer implements MenuPeer {
*/
XMenuWindow menuWindow;
/*
* Menu's fields & methods
*/
private final static Field f_items;
static {
f_items = SunToolkit.getField(Menu.class, "items");
}
/************************************************
*
* Construction
@ -153,12 +142,7 @@ public class XMenuPeer extends XMenuItemPeer implements MenuPeer {
*
************************************************/
Vector getTargetItems() {
try {
return (Vector)f_items.get(getTarget());
} catch (IllegalAccessException iae) {
iae.printStackTrace();
return null;
}
return AWTAccessor.getMenuAccessor().getItems((Menu)getTarget());
}
/************************************************

59
jdk/src/solaris/classes/sun/awt/X11/XPopupMenuPeer.java
View File

@ -28,15 +28,10 @@ import java.awt.*;
import java.awt.peer.*;
import java.awt.event.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import java.util.Vector;
import sun.awt.AWTAccessor;
import sun.util.logging.PlatformLogger;
import sun.awt.SunToolkit;
public class XPopupMenuPeer extends XMenuWindow implements PopupMenuPeer {
/************************************************
@ -66,24 +61,6 @@ public class XPopupMenuPeer extends XMenuWindow implements PopupMenuPeer {
private final static int CAPTION_MARGIN_TOP = 4;
private final static int CAPTION_SEPARATOR_HEIGHT = 6;
/*
* Menu's fields & methods
*/
//Fix for 6184485: Popup menu is not disabled on XToolkit even when calling setEnabled (false)
private final static Field f_enabled;
//Fix for 6267144: PIT: Popup menu label is not shown, XToolkit
private final static Field f_label;
private final static Method m_getFont;
private final static Field f_items;
static {
f_enabled = SunToolkit.getField(MenuItem.class, "enabled");
f_label = SunToolkit.getField(MenuItem.class, "label");
f_items = SunToolkit.getField(Menu.class, "items");
m_getFont = SunToolkit.getMethod(MenuComponent.class, "getFont_NoClientCode", null);
}
/************************************************
*
* Construction
@ -96,7 +73,7 @@ public class XPopupMenuPeer extends XMenuWindow implements PopupMenuPeer {
/************************************************
*
* Implementaion of interface methods
* Implementation of interface methods
*
************************************************/
/*
@ -189,27 +166,16 @@ public class XPopupMenuPeer extends XMenuWindow implements PopupMenuPeer {
if (popupMenuTarget == null) {
return XWindow.getDefaultFont();
}
try {
return (Font)m_getFont.invoke(popupMenuTarget, new Object[0]);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return XWindow.getDefaultFont();
return AWTAccessor.getMenuComponentAccessor()
.getFont_NoClientCode(popupMenuTarget);
}
//Fix for 6267144: PIT: Popup menu label is not shown, XToolkit
String getTargetLabel() {
if (target == null) {
return "";
}
try {
String label = (String)f_label.get(popupMenuTarget);
return (label == null) ? "" : label;
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return "";
return AWTAccessor.getMenuItemAccessor().getLabel(popupMenuTarget);
}
//Fix for 6184485: Popup menu is not disabled on XToolkit even when calling setEnabled (false)
@ -217,21 +183,14 @@ public class XPopupMenuPeer extends XMenuWindow implements PopupMenuPeer {
if (popupMenuTarget == null) {
return false;
}
try {
return f_enabled.getBoolean(popupMenuTarget);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return false;
return AWTAccessor.getMenuItemAccessor().isEnabled(popupMenuTarget);
}
Vector getMenuTargetItems() {
try {
return (Vector)f_items.get(popupMenuTarget);
} catch (IllegalAccessException iae) {
iae.printStackTrace();
if (popupMenuTarget == null) {
return null;
}
return AWTAccessor.getMenuAccessor().getItems(popupMenuTarget);
}
/************************************************

1
jdk/src/solaris/classes/sun/awt/X11/XScrollPanePeer.java
View File

@ -31,7 +31,6 @@ import java.awt.peer.*;
import java.lang.reflect.*;
import sun.awt.AWTAccessor;
import sun.awt.SunToolkit;
class XScrollPanePeer extends XComponentPeer implements ScrollPanePeer, XScrollbarClient {

49
jdk/src/solaris/classes/sun/awt/X11/XSystemTrayPeer.java
View File

@ -27,10 +27,9 @@ package sun.awt.X11;
import java.awt.*;
import java.awt.peer.SystemTrayPeer;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
import sun.awt.SunToolkit;
import sun.awt.AppContext;
import sun.awt.AWTAccessor;
import sun.util.logging.PlatformLogger;
public class XSystemTrayPeer implements SystemTrayPeer, XMSelectionListener {
@ -42,11 +41,6 @@ public class XSystemTrayPeer implements SystemTrayPeer, XMSelectionListener {
private volatile boolean available;
private final XMSelection selection = new XMSelection("_NET_SYSTEM_TRAY");
private static final Method firePropertyChangeMethod =
XToolkit.getMethod(SystemTray.class, "firePropertyChange", new Class[] {String.class, Object.class, Object.class});
private static final Method addNotifyMethod = XToolkit.getMethod(TrayIcon.class, "addNotify", null);
private static final Method removeNotifyMethod = XToolkit.getMethod(TrayIcon.class, "removeNotify", null);
private static final int SCREEN = 0;
private static final String SYSTEM_TRAY_PROPERTY_NAME = "systemTray";
private static final XAtom _NET_SYSTEM_TRAY = XAtom.get("_NET_SYSTEM_TRAY_S" + SCREEN);
@ -157,44 +151,43 @@ public class XSystemTrayPeer implements SystemTrayPeer, XMSelectionListener {
return peerInstance;
}
private void firePropertyChange(final String propertyName, final Object oldValue, final Object newValue) {
private void firePropertyChange(final String propertyName,
final Object oldValue,
final Object newValue) {
Runnable runnable = new Runnable() {
public void run() {
Object[] args = new Object[] {propertyName, oldValue, newValue};
invokeMethod(firePropertyChangeMethod, target, args);
AWTAccessor.getSystemTrayAccessor()
.firePropertyChange(target, propertyName, oldValue, newValue);
}
};
invokeOnEachAppContext(runnable);
}
private void createTrayPeers() {
invokeOnEachTrayIcon(addNotifyMethod);
}
private void removeTrayPeers() {
invokeOnEachTrayIcon(removeNotifyMethod);
}
private void invokeOnEachTrayIcon(final Method method) {
Runnable runnable = new Runnable() {
public void run() {
TrayIcon[] icons = target.getTrayIcons();
for (TrayIcon ti : icons) {
invokeMethod(method, ti, (Object[]) null);
try {
for (TrayIcon ti : icons) {
AWTAccessor.getTrayIconAccessor().addNotify(ti);
}
} catch (AWTException e) {
}
}
};
invokeOnEachAppContext(runnable);
}
private void invokeMethod(Method method, Object obj, Object[] args) {
try{
method.invoke(obj, args);
} catch (InvocationTargetException e){
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
private void removeTrayPeers() {
Runnable runnable = new Runnable() {
public void run() {
TrayIcon[] icons = target.getTrayIcons();
for (TrayIcon ti : icons) {
AWTAccessor.getTrayIconAccessor().removeNotify(ti);
}
}
};
invokeOnEachAppContext(runnable);
}
private void invokeOnEachAppContext(Runnable runnable) {

6
jdk/src/solaris/classes/sun/awt/X11/XTextAreaPeer.java
View File

@ -1008,8 +1008,10 @@ class XTextAreaPeer extends XComponentPeer implements TextAreaPeer {
// loading SystemFlavorMap and associated classes.
public void setTransferHandler(TransferHandler newHandler) {
TransferHandler oldHandler = (TransferHandler)
getClientProperty(XTextTransferHelper.getTransferHandlerKey());
putClientProperty(XTextTransferHelper.getTransferHandlerKey(),
getClientProperty(AWTAccessor.getClientPropertyKeyAccessor()
.getJComponent_TRANSFER_HANDLER());
putClientProperty(AWTAccessor.getClientPropertyKeyAccessor()
.getJComponent_TRANSFER_HANDLER(),
newHandler);
firePropertyChange("transferHandler", oldHandler, newHandler);

6
jdk/src/solaris/classes/sun/awt/X11/XTextFieldPeer.java
View File

@ -691,8 +691,10 @@ public class XTextFieldPeer extends XComponentPeer implements TextFieldPeer {
// loading SystemFlavorMap and associated classes.
public void setTransferHandler(TransferHandler newHandler) {
TransferHandler oldHandler = (TransferHandler)
getClientProperty(XTextTransferHelper.getTransferHandlerKey());
putClientProperty(XTextTransferHelper.getTransferHandlerKey(),
getClientProperty(AWTAccessor.getClientPropertyKeyAccessor()
.getJComponent_TRANSFER_HANDLER());
putClientProperty(AWTAccessor.getClientPropertyKeyAccessor()
.getJComponent_TRANSFER_HANDLER(),
newHandler);
firePropertyChange("transferHandler", oldHandler, newHandler);

47
jdk/src/solaris/classes/sun/awt/X11/XTextTransferHelper.java
View File

@ -1,47 +0,0 @@
/*
* Copyright (c) 2003, 2007, 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.X11;
import java.lang.reflect.Field;
import sun.awt.SunToolkit;
class XTextTransferHelper {
private static Object transferHandlerKey = null;
static Object getTransferHandlerKey() {
if (transferHandlerKey == null) {
try {
Class clazz = Class.forName("javax.swing.ClientPropertyKey");
Field field = SunToolkit.getField(clazz, "JComponent_TRANSFER_HANDLER");
transferHandlerKey = field.get(null);
} catch (IllegalAccessException ex) {
return null;
} catch (ClassNotFoundException cnfe) {
cnfe.printStackTrace();
}
}
return transferHandlerKey;
}
}

30
jdk/src/solaris/classes/sun/awt/X11/XToolkit.java
View File

@ -41,8 +41,6 @@ import java.awt.im.spi.InputMethodDescriptor;
import java.awt.image.ColorModel;
import java.awt.peer.*;
import java.beans.PropertyChangeListener;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.*;
@ -50,10 +48,10 @@ import javax.swing.LookAndFeel;
import javax.swing.UIDefaults;
import sun.awt.*;
import sun.font.FontConfigManager;
import sun.font.FontManager;
import sun.java2d.SunGraphicsEnvironment;
import sun.misc.PerformanceLogger;
import sun.print.PrintJob2D;
import sun.security.action.GetPropertyAction;
import sun.security.action.GetBooleanAction;
import sun.util.logging.PlatformLogger;
@ -113,7 +111,6 @@ public final class XToolkit extends UNIXToolkit implements Runnable {
private static volatile int screenWidth = -1, screenHeight = -1; // Dimensions of default screen
static long awt_defaultFg; // Pixel
private static XMouseInfoPeer xPeer;
private static Method m_removeSourceEvents;
static {
initSecurityWarning();
@ -131,8 +128,6 @@ public final class XToolkit extends UNIXToolkit implements Runnable {
initIDs();
setBackingStoreType();
}
m_removeSourceEvents = SunToolkit.getMethod(EventQueue.class, "removeSourceEvents", new Class[] {Object.class, Boolean.TYPE}) ;
noisyAwtHandler = AccessController.doPrivileged(new GetBooleanAction("sun.awt.noisyerrorhandler"));
}
@ -223,7 +218,8 @@ public final class XToolkit extends UNIXToolkit implements Runnable {
static void initSecurityWarning() {
// Enable warning only for internal builds
String runtime = getSystemProperty("java.runtime.version");
String runtime = AccessController.doPrivileged(
new GetPropertyAction("java.runtime.version"));
securityWarningEnabled = (runtime != null && runtime.contains("internal"));
}
@ -1101,8 +1097,8 @@ public final class XToolkit extends UNIXToolkit implements Runnable {
*/
public synchronized static boolean getSunAwtDisableGtkFileDialogs() {
if (sunAwtDisableGtkFileDialogs == null) {
sunAwtDisableGtkFileDialogs =
getBooleanSystemProperty("sun.awt.disableGtkFileDialogs");
sunAwtDisableGtkFileDialogs = AccessController.doPrivileged(
new GetBooleanAction("sun.awt.disableGtkFileDialogs"));
}
return sunAwtDisableGtkFileDialogs.booleanValue();
}
@ -2090,17 +2086,11 @@ public final class XToolkit extends UNIXToolkit implements Runnable {
return null;
}
static void removeSourceEvents(EventQueue queue, Object source, boolean removeAllEvents) {
try {
m_removeSourceEvents.invoke(queue, source, removeAllEvents);
}
catch (IllegalAccessException e)
{
e.printStackTrace();
}
catch (InvocationTargetException e) {
e.printStackTrace();
}
static void removeSourceEvents(EventQueue queue,
Object source,
boolean removeAllEvents) {
AWTAccessor.getEventQueueAccessor()
.removeSourceEvents(queue, source, removeAllEvents);
}
public boolean isAlwaysOnTopSupported() {

48
jdk/src/solaris/classes/sun/awt/X11/XWindow.java
View File

@ -126,10 +126,6 @@ public class XWindow extends XBaseWindow implements X11ComponentPeer {
native void getWindowBounds(long window, long x, long y, long width, long height);
private native static void initIDs();
private static Field isPostedField;
private static Field rawCodeField;
private static Field primaryLevelUnicodeField;
private static Field extendedKeyCodeField;
static {
initIDs();
}
@ -398,20 +394,11 @@ public class XWindow extends XBaseWindow implements X11ComponentPeer {
static Method m_sendMessage;
static void sendEvent(final AWTEvent e) {
if (isPostedField == null) {
isPostedField = SunToolkit.getField(AWTEvent.class, "isPosted");
}
// The uses of this method imply that the incoming event is system-generated
SunToolkit.setSystemGenerated(e);
PeerEvent pe = new PeerEvent(Toolkit.getDefaultToolkit(), new Runnable() {
public void run() {
try {
isPostedField.setBoolean(e, true);
} catch (IllegalArgumentException e) {
assert(false);
} catch (IllegalAccessException e) {
assert(false);
}
AWTAccessor.getAWTEventAccessor().setPosted(e);
((Component)e.getSource()).dispatchEvent(e);
}
}, PeerEvent.ULTIMATE_PRIORITY_EVENT);
@ -1428,16 +1415,8 @@ public class XWindow extends XBaseWindow implements X11ComponentPeer {
}
static Field bdata;
static void setBData(KeyEvent e, byte[] data) {
try {
if (bdata == null) {
bdata = SunToolkit.getField(java.awt.AWTEvent.class, "bdata");
}
bdata.set(e, data);
} catch (IllegalAccessException ex) {
assert false;
}
AWTAccessor.getAWTEventAccessor().setBData(e, data);
}
public void postKeyEvent(int id, long when, int keyCode, int keyChar,
@ -1447,15 +1426,6 @@ public class XWindow extends XBaseWindow implements X11ComponentPeer {
{
long jWhen = XToolkit.nowMillisUTC_offset(when);
int modifiers = getModifiers(state, 0, keyCode);
if (rawCodeField == null) {
rawCodeField = XToolkit.getField(KeyEvent.class, "rawCode");
}
if (primaryLevelUnicodeField == null) {
primaryLevelUnicodeField = XToolkit.getField(KeyEvent.class, "primaryLevelUnicode");
}
if (extendedKeyCodeField == null) {
extendedKeyCodeField = XToolkit.getField(KeyEvent.class, "extendedKeyCode");
}
KeyEvent ke = new KeyEvent((Component)getEventSource(), id, jWhen,
modifiers, keyCode, (char)keyChar, keyLocation);
@ -1463,15 +1433,11 @@ public class XWindow extends XBaseWindow implements X11ComponentPeer {
byte[] data = Native.toBytes(event, eventSize);
setBData(ke, data);
}
try {
rawCodeField.set(ke, rawCode);
primaryLevelUnicodeField.set(ke, (long)unicodeFromPrimaryKeysym);
extendedKeyCodeField.set(ke, (long)extendedKeyCode);
} catch (IllegalArgumentException e) {
assert(false);
} catch (IllegalAccessException e) {
assert(false);
}
AWTAccessor.KeyEventAccessor kea = AWTAccessor.getKeyEventAccessor();
kea.setRawCode(ke, rawCode);
kea.setPrimaryLevelUnicode(ke, (long)unicodeFromPrimaryKeysym);
kea.setExtendedKeyCode(ke, (long)extendedKeyCode);
postEventToEventQueue(ke);
}

12
jdk/src/solaris/classes/sun/awt/X11/XlibWrapper.java
View File

@ -27,6 +27,7 @@ package sun.awt.X11;
import java.security.AccessController;
import java.security.PrivilegedAction;
import sun.security.action.GetPropertyAction;
import sun.misc.*;
final public class XlibWrapper
@ -590,12 +591,8 @@ static native String XSetLocaleModifiers(String modifier_list);
static final boolean isBuildInternal;
static {
String dataModelProp = (String)AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
return System.getProperty("sun.arch.data.model");
}
});
String dataModelProp = AccessController.doPrivileged(
new GetPropertyAction("sun.arch.data.model"));
try {
dataModel = Integer.parseInt(dataModelProp);
} catch (Exception e) {
@ -647,7 +644,8 @@ static native String XSetLocaleModifiers(String modifier_list);
}
private static boolean getBuildInternal() {
String javaVersion = XToolkit.getSystemProperty("java.version");
String javaVersion = AccessController.doPrivileged(
new GetPropertyAction("java.version"));
return javaVersion != null && javaVersion.contains("internal");
}

1
jdk/src/windows/classes/sun/awt/windows/WCanvasPeer.java
View File

@ -27,7 +27,6 @@ package sun.awt.windows;
import java.awt.*;
import java.awt.peer.*;
import java.lang.ref.WeakReference;
import java.lang.reflect.Method;
import sun.awt.SunToolkit;
import sun.awt.Win32GraphicsDevice;
import sun.awt.PaintEventDispatcher;

2
jdk/src/windows/classes/sun/awt/windows/WMouseDragGestureRecognizer.java
View File

@ -39,8 +39,6 @@ import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.lang.reflect.*;
import sun.awt.dnd.SunDragSourceContextPeer;
/**

2
jdk/src/windows/classes/sun/awt/windows/WPopupMenuPeer.java
View File

@ -26,9 +26,7 @@ package sun.awt.windows;
import java.awt.*;
import java.awt.peer.*;
import java.lang.reflect.Field;
import sun.awt.SunToolkit;
import sun.awt.AWTAccessor;
public class WPopupMenuPeer extends WMenuPeer implements PopupMenuPeer {

2
jdk/src/windows/classes/sun/awt/windows/WWindowPeer.java
View File

@ -31,8 +31,6 @@ import java.awt.peer.*;
import java.beans.*;
import java.lang.reflect.*;
import java.util.*;
import java.util.List;
import sun.util.logging.PlatformLogger;