rev 12972 : 8140606: Update library code to use internal Unsafe
Reviewed-by: duke
1 /*
2 * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.awt;
27
28 import sun.misc.Unsafe;
29
30 import javax.accessibility.AccessibleContext;
31 import java.awt.*;
32 import java.awt.dnd.DragSourceContext;
33 import java.awt.dnd.DropTargetContext;
34 import java.awt.dnd.peer.DragSourceContextPeer;
35 import java.awt.dnd.peer.DropTargetContextPeer;
36 import java.awt.event.InputEvent;
37 import java.awt.event.InvocationEvent;
38 import java.awt.event.KeyEvent;
39 import java.awt.geom.Point2D;
40 import java.awt.image.BufferStrategy;
41 import java.awt.peer.ComponentPeer;
42
43 import java.awt.peer.MenuComponentPeer;
44 import java.lang.reflect.InvocationTargetException;
45 import java.security.AccessControlContext;
46
47 import java.io.File;
48 import java.util.ResourceBundle;
49 import java.util.Vector;
50
51 /**
52 * The AWTAccessor utility class.
53 * The main purpose of this class is to enable accessing
54 * private and package-private fields of classes from
55 * different classes/packages. See sun.misc.SharedSecretes
56 * for another example.
57 */
58 public final class AWTAccessor {
59
60 private static final Unsafe unsafe = Unsafe.getUnsafe();
61
62 /*
63 * We don't need any objects of this class.
64 * It's rather a collection of static methods
65 * and interfaces.
66 */
67 private AWTAccessor() {
68 }
69
70 /*
71 * An interface of accessor for the java.awt.Component class.
72 */
73 public interface ComponentAccessor {
74 /*
75 * Sets whether the native background erase for a component
76 * has been disabled via SunToolkit.disableBackgroundErase().
77 */
78 void setBackgroundEraseDisabled(Component comp, boolean disabled);
79 /*
80 * Indicates whether the native background erase for a
81 * component has been disabled via
82 * SunToolkit.disableBackgroundErase().
83 */
84 boolean getBackgroundEraseDisabled(Component comp);
85 /*
86 *
87 * Gets the bounds of this component in the form of a
88 * <code>Rectangle</code> object. The bounds specify this
89 * component's width, height, and location relative to
90 * its parent.
91 */
92 Rectangle getBounds(Component comp);
93 /*
94 * Sets the shape of a lw component to cut out from hw components.
95 *
96 * See 6797587, 6776743, 6768307, and 6768332 for details
97 */
98 void setMixingCutoutShape(Component comp, Shape shape);
99
100 /**
101 * Sets GraphicsConfiguration value for the component.
102 */
103 void setGraphicsConfiguration(Component comp, GraphicsConfiguration gc);
104 /*
105 * Requests focus to the component.
106 */
107 boolean requestFocus(Component comp, CausedFocusEvent.Cause cause);
108 /*
109 * Determines if the component can gain focus.
110 */
111 boolean canBeFocusOwner(Component comp);
112
113 /**
114 * Returns whether the component is visible without invoking
115 * any client code.
116 */
117 boolean isVisible(Component comp);
118
119 /**
120 * Sets the RequestFocusController.
121 */
122 void setRequestFocusController(RequestFocusController requestController);
123
124 /**
125 * Returns the appContext of the component.
126 */
127 AppContext getAppContext(Component comp);
128
129 /**
130 * Sets the appContext of the component.
131 */
132 void setAppContext(Component comp, AppContext appContext);
133
134 /**
135 * Returns the parent of the component.
136 */
137 Container getParent(Component comp);
138
139 /**
140 * Sets the parent of the component to the specified parent.
141 */
142 void setParent(Component comp, Container parent);
143
144 /**
145 * Resizes the component to the specified width and height.
146 */
147 void setSize(Component comp, int width, int height);
148
149 /**
150 * Returns the location of the component.
151 */
152 Point getLocation(Component comp);
153
154 /**
155 * Moves the component to the new location.
156 */
157 void setLocation(Component comp, int x, int y);
158
159 /**
160 * Determines whether this component is enabled.
161 */
162 boolean isEnabled(Component comp);
163
164 /**
165 * Determines whether this component is displayable.
166 */
167 boolean isDisplayable(Component comp);
168
169 /**
170 * Gets the cursor set in the component.
171 */
172 Cursor getCursor(Component comp);
173
174 /**
175 * Returns the peer of the component.
176 */
177 <T extends ComponentPeer> T getPeer(Component comp);
178
179 /**
180 * Sets the peer of the component to the specified peer.
181 */
182 void setPeer(Component comp, ComponentPeer peer);
183
184 /**
185 * Determines whether this component is lightweight.
186 */
187 boolean isLightweight(Component comp);
188
189 /**
190 * Returns whether or not paint messages received from
191 * the operating system should be ignored.
192 */
193 boolean getIgnoreRepaint(Component comp);
194
195 /**
196 * Returns the width of the component.
197 */
198 int getWidth(Component comp);
199
200 /**
201 * Returns the height of the component.
202 */
203 int getHeight(Component comp);
204
205 /**
206 * Returns the x coordinate of the component.
207 */
208 int getX(Component comp);
209
210 /**
211 * Returns the y coordinate of the component.
212 */
213 int getY(Component comp);
214
215 /**
216 * Gets the foreground color of this component.
217 */
218 Color getForeground(Component comp);
219
220 /**
221 * Gets the background color of this component.
222 */
223 Color getBackground(Component comp);
224
225 /**
226 * Sets the background of this component to the specified color.
227 */
228 void setBackground(Component comp, Color background);
229
230 /**
231 * Gets the font of the component.
232 */
233 Font getFont(Component comp);
234
235 /**
236 * Processes events occurring on this component.
237 */
238 void processEvent(Component comp, AWTEvent e);
239
240
241 /*
242 * Returns the acc this component was constructed with.
243 */
244 AccessControlContext getAccessControlContext(Component comp);
245
246 /**
247 * Revalidates the component synchronously.
248 */
249 void revalidateSynchronously(Component comp);
250
251 /**
252 * Creates a new strategy for multi-buffering on this component.
253 */
254 void createBufferStrategy(Component comp, int numBuffers,
255 BufferCapabilities caps) throws AWTException;
256
257 /**
258 * returns the buffer strategy used by this component.
259 */
260 BufferStrategy getBufferStrategy(Component comp);
261 }
262
263 /*
264 * An interface of accessor for the java.awt.Container class.
265 */
266 public interface ContainerAccessor {
267 /**
268 * Validates the container unconditionally.
269 */
270 void validateUnconditionally(Container cont);
271
272 /**
273 *
274 * Access to the private version of findComponentAt method which has
275 * a controllable behavior. Setting 'ignoreEnabled' to 'false'
276 * bypasses disabled Components during the search.
277 */
278 Component findComponentAt(Container cont, int x, int y, boolean ignoreEnabled);
279
280 /**
281 * Starts LW Modal.
282 */
283 void startLWModal(Container cont);
284
285 /**
286 * Starts LW Modal.
287 */
288 void stopLWModal(Container cont);
289 }
290
291 /*
292 * An interface of accessor for java.awt.Window class.
293 */
294 public interface WindowAccessor {
295 /*
296 * Get opacity level of the given window.
297 */
298 float getOpacity(Window window);
299 /*
300 * Set opacity level to the given window.
301 */
302 void setOpacity(Window window, float opacity);
303 /*
304 * Get a shape assigned to the given window.
305 */
306 Shape getShape(Window window);
307 /*
308 * Set a shape to the given window.
309 */
310 void setShape(Window window, Shape shape);
311 /*
312 * Set the opaque preoperty to the given window.
313 */
314 void setOpaque(Window window, boolean isOpaque);
315 /*
316 * Update the image of a non-opaque (translucent) window.
317 */
318 void updateWindow(Window window);
319
320 /** Get the size of the security warning.
321 */
322 Dimension getSecurityWarningSize(Window w);
323
324 /**
325 * Set the size of the security warning.
326 */
327 void setSecurityWarningSize(Window w, int width, int height);
328
329 /** Set the position of the security warning.
330 */
331 void setSecurityWarningPosition(Window w, Point2D point,
332 float alignmentX, float alignmentY);
333
334 /** Request to recalculate the new position of the security warning for
335 * the given window size/location as reported by the native system.
336 */
337 Point2D calculateSecurityWarningPosition(Window window,
338 double x, double y, double w, double h);
339
340 /** Sets the synchronous status of focus requests on lightweight
341 * components in the specified window to the specified value.
342 */
343 void setLWRequestStatus(Window changed, boolean status);
344
345 /**
346 * Indicates whether this window should receive focus on subsequently
347 * being shown, or being moved to the front.
348 */
349 boolean isAutoRequestFocus(Window w);
350
351 /**
352 * Indicates whether the specified window is an utility window for TrayIcon.
353 */
354 boolean isTrayIconWindow(Window w);
355
356 /**
357 * Marks the specified window as an utility window for TrayIcon.
358 */
359 void setTrayIconWindow(Window w, boolean isTrayIconWindow);
360 }
361
362 /**
363 * An accessor for the AWTEvent class.
364 */
365 public interface AWTEventAccessor {
366 /**
367 * Marks the event as posted.
368 */
369 void setPosted(AWTEvent ev);
370
371 /**
372 * Sets the flag on this AWTEvent indicating that it was
373 * generated by the system.
374 */
375 void setSystemGenerated(AWTEvent ev);
376
377 /**
378 * Indicates whether this AWTEvent was generated by the system.
379 */
380 boolean isSystemGenerated(AWTEvent ev);
381
382 /**
383 * Returns the acc this event was constructed with.
384 */
385 AccessControlContext getAccessControlContext(AWTEvent ev);
386
387 /**
388 * Returns binary data associated with this event;
389 */
390 byte[] getBData(AWTEvent ev);
391
392 /**
393 * Associates binary data with this event;
394 */
395 void setBData(AWTEvent ev, byte[] bdata);
396 }
397
398 public interface InputEventAccessor {
399 /*
400 * Accessor for InputEvent.getButtonDownMasks()
401 */
402 int[] getButtonDownMasks();
403
404 /*
405 * Accessor for InputEvent.canAccessSystemClipboard field
406 */
407 boolean canAccessSystemClipboard(InputEvent event);
408 }
409
410 /*
411 * An accessor for the java.awt.Frame class.
412 */
413 public interface FrameAccessor {
414 /*
415 * Sets the state of this frame.
416 */
417 void setExtendedState(Frame frame, int state);
418 /*
419 * Gets the state of this frame.
420 */
421 int getExtendedState(Frame frame);
422 /*
423 * Gets the maximized bounds of this frame.
424 */
425 Rectangle getMaximizedBounds(Frame frame);
426 }
427
428 /**
429 * An interface of accessor for the java.awt.KeyboardFocusManager class.
430 */
431 public interface KeyboardFocusManagerAccessor {
432 /**
433 * Indicates whether the native implementation should
434 * proceed with a pending focus request for the heavyweight.
435 */
436 int shouldNativelyFocusHeavyweight(Component heavyweight,
437 Component descendant,
438 boolean temporary,
439 boolean focusedWindowChangeAllowed,
440 long time,
441 CausedFocusEvent.Cause cause);
442 /**
443 * Delivers focus for the lightweight descendant of the heavyweight
444 * synchronously.
445 */
446 boolean processSynchronousLightweightTransfer(Component heavyweight,
447 Component descendant,
448 boolean temporary,
449 boolean focusedWindowChangeAllowed,
450 long time);
451 /**
452 * Removes the last focus request for the heavyweight from the queue.
453 */
454 void removeLastFocusRequest(Component heavyweight);
455
456 /**
457 * Sets the most recent focus owner in the window.
458 */
459 void setMostRecentFocusOwner(Window window, Component component);
460
461 /**
462 * Returns current KFM of the specified AppContext.
463 */
464 KeyboardFocusManager getCurrentKeyboardFocusManager(AppContext ctx);
465
466 /**
467 * Return the current focus cycle root
468 */
469 Container getCurrentFocusCycleRoot();
470 }
471
472 /**
473 * An accessor for the MenuComponent class.
474 */
475 public interface MenuComponentAccessor {
476 /**
477 * Returns the appContext of the menu component.
478 */
479 AppContext getAppContext(MenuComponent menuComp);
480
481 /**
482 * Sets the appContext of the menu component.
483 */
484 void setAppContext(MenuComponent menuComp, AppContext appContext);
485
486 /**
487 * Returns the peer of the menu component.
488 */
489 <T extends MenuComponentPeer> T getPeer(MenuComponent menuComp);
490
491 /**
492 * Returns the menu container of the menu component.
493 */
494 MenuContainer getParent(MenuComponent menuComp);
495
496 /**
497 * Sets the menu container of the menu component.
498 */
499 void setParent(MenuComponent menuComp, MenuContainer menuContainer);
500
501 /**
502 * Gets the font used for this menu component.
503 */
504 Font getFont_NoClientCode(MenuComponent menuComp);
505 }
506
507 /**
508 * An accessor for the EventQueue class
509 */
510 public interface EventQueueAccessor {
511 /**
512 * Gets the event dispatch thread.
513 */
514 Thread getDispatchThread(EventQueue eventQueue);
515
516 /**
517 * Checks if the current thread is EDT for the given EQ.
518 */
519 public boolean isDispatchThreadImpl(EventQueue eventQueue);
520
521 /**
522 * Removes any pending events for the specified source object.
523 */
524 void removeSourceEvents(EventQueue eventQueue, Object source, boolean removeAllEvents);
525
526 /**
527 * Returns whether an event is pending on any of the separate Queues.
528 */
529 boolean noEvents(EventQueue eventQueue);
530
531 /**
532 * Called from PostEventQueue.postEvent to notify that a new event
533 * appeared.
534 */
535 void wakeup(EventQueue eventQueue, boolean isShutdown);
536
537 /**
538 * Static in EventQueue
539 */
540 void invokeAndWait(Object source, Runnable r)
541 throws InterruptedException, InvocationTargetException;
542
543 /**
544 * Sets the delegate for the EventQueue used by FX/AWT single threaded mode
545 */
546 void setFwDispatcher(EventQueue eventQueue, FwDispatcher dispatcher);
547
548 /**
549 * Gets most recent event time in the EventQueue
550 */
551 long getMostRecentEventTime(EventQueue eventQueue);
552 }
553
554 /*
555 * An accessor for the PopupMenu class
556 */
557 public interface PopupMenuAccessor {
558 /*
559 * Returns whether the popup menu is attached to a tray
560 */
561 boolean isTrayIconPopup(PopupMenu popupMenu);
562 }
563
564 /*
565 * An accessor for the FileDialog class
566 */
567 public interface FileDialogAccessor {
568 /*
569 * Sets the files the user selects
570 */
571 void setFiles(FileDialog fileDialog, File files[]);
572
573 /*
574 * Sets the file the user selects
575 */
576 void setFile(FileDialog fileDialog, String file);
577
578 /*
579 * Sets the directory the user selects
580 */
581 void setDirectory(FileDialog fileDialog, String directory);
582
583 /*
584 * Returns whether the file dialog allows the multiple file selection.
585 */
586 boolean isMultipleMode(FileDialog fileDialog);
587 }
588
589 /*
590 * An accessor for the ScrollPaneAdjustable class.
591 */
592 public interface ScrollPaneAdjustableAccessor {
593 /*
594 * Sets the value of this scrollbar to the specified value.
595 */
596 void setTypedValue(final ScrollPaneAdjustable adj, final int v,
597 final int type);
598 }
599
600 /**
601 * An accessor for the CheckboxMenuItem class
602 */
603 public interface CheckboxMenuItemAccessor {
604 /**
605 * Returns whether menu item is checked
606 */
607 boolean getState(CheckboxMenuItem cmi);
608 }
609
610 /**
611 * An accessor for the Cursor class
612 */
613 public interface CursorAccessor {
614 /**
615 * Returns pData of the Cursor class
616 */
617 long getPData(Cursor cursor);
618
619 /**
620 * Sets pData to the Cursor class
621 */
622 void setPData(Cursor cursor, long pData);
623
624 /**
625 * Return type of the Cursor class
626 */
627 int getType(Cursor cursor);
628 }
629
630 /**
631 * An accessor for the MenuBar class
632 */
633 public interface MenuBarAccessor {
634 /**
635 * Returns help menu
636 */
637 Menu getHelpMenu(MenuBar menuBar);
638
639 /**
640 * Returns menus
641 */
642 Vector<Menu> getMenus(MenuBar menuBar);
643 }
644
645 /**
646 * An accessor for the MenuItem class
647 */
648 public interface MenuItemAccessor {
649 /**
650 * Returns whether menu item is enabled
651 */
652 boolean isEnabled(MenuItem item);
653
654 /**
655 * Gets the command name of the action event that is fired
656 * by this menu item.
657 */
658 String getActionCommandImpl(MenuItem item);
659
660 /**
661 * Returns true if the item and all its ancestors are
662 * enabled, false otherwise
663 */
664 boolean isItemEnabled(MenuItem item);
665
666 /**
667 * Returns label
668 */
669 String getLabel(MenuItem item);
670
671 /**
672 * Returns shortcut
673 */
674 MenuShortcut getShortcut(MenuItem item);
675 }
676
677 /**
678 * An accessor for the Menu class
679 */
680 public interface MenuAccessor {
681 /**
682 * Returns vector of the items that are part of the Menu
683 */
684 Vector<MenuItem> getItems(Menu menu);
685 }
686
687 /**
688 * An accessor for the KeyEvent class
689 */
690 public interface KeyEventAccessor {
691 /**
692 * Sets rawCode field for KeyEvent
693 */
694 void setRawCode(KeyEvent ev, long rawCode);
695
696 /**
697 * Sets primaryLevelUnicode field for KeyEvent
698 */
699 void setPrimaryLevelUnicode(KeyEvent ev, long primaryLevelUnicode);
700
701 /**
702 * Sets extendedKeyCode field for KeyEvent
703 */
704 void setExtendedKeyCode(KeyEvent ev, long extendedKeyCode);
705
706 /**
707 * Gets original source for KeyEvent
708 */
709 Component getOriginalSource(KeyEvent ev);
710 }
711
712 /**
713 * An accessor for the ClientPropertyKey class
714 */
715 public interface ClientPropertyKeyAccessor {
716 /**
717 * Retrieves JComponent_TRANSFER_HANDLER enum object
718 */
719 Object getJComponent_TRANSFER_HANDLER();
720 }
721
722 /**
723 * An accessor for the SystemTray class
724 */
725 public interface SystemTrayAccessor {
726 /**
727 * Support for reporting bound property changes for Object properties.
728 */
729 void firePropertyChange(SystemTray tray, String propertyName, Object oldValue, Object newValue);
730 }
731
732 /**
733 * An accessor for the TrayIcon class
734 */
735 public interface TrayIconAccessor {
736 void addNotify(TrayIcon trayIcon) throws AWTException;
737 void removeNotify(TrayIcon trayIcon);
738 }
739
740 /**
741 * An accessor for the DefaultKeyboardFocusManager class
742 */
743 public interface DefaultKeyboardFocusManagerAccessor {
744 public void consumeNextKeyTyped(DefaultKeyboardFocusManager dkfm, KeyEvent e);
745 }
746
747 /*
748 * An accessor for the SequencedEventAccessor class
749 */
750 public interface SequencedEventAccessor {
751 /*
752 * Returns the nested event.
753 */
754 AWTEvent getNested(AWTEvent sequencedEvent);
755
756 /*
757 * Returns true if the event is an instances of SequencedEvent.
758 */
759 boolean isSequencedEvent(AWTEvent event);
760 }
761
762 /*
763 * An accessor for the Toolkit class
764 */
765 public interface ToolkitAccessor {
766 void setPlatformResources(ResourceBundle bundle);
767 }
768
769 /*
770 * An accessor object for the InvocationEvent class
771 */
772 public interface InvocationEventAccessor {
773 void dispose(InvocationEvent event);
774 }
775
776 /*
777 * An accessor object for the SystemColor class
778 */
779 public interface SystemColorAccessor {
780 void updateSystemColors();
781 }
782
783 /*
784 * An accessor object for the AccessibleContext class
785 */
786 public interface AccessibleContextAccessor {
787 void setAppContext(AccessibleContext accessibleContext, AppContext appContext);
788 AppContext getAppContext(AccessibleContext accessibleContext);
789 }
790
791 /*
792 * An accessor object for the DragSourceContext class
793 */
794 public interface DragSourceContextAccessor {
795 /**
796 * Returns the peer of the DragSourceContext.
797 */
798 DragSourceContextPeer getPeer(DragSourceContext dsc);
799 }
800
801 /*
802 * An accessor object for the DropTargetContext class
803 */
804 public interface DropTargetContextAccessor {
805 /**
806 * Resets the DropTargetContext.
807 */
808 void reset(DropTargetContext dtc);
809 /**
810 * Sets the {@code DropTargetContextPeer}
811 */
812 void setDropTargetContextPeer(DropTargetContext dtc,
813 DropTargetContextPeer dtcp);
814 }
815
816 /*
817 * Accessor instances are initialized in the static initializers of
818 * corresponding AWT classes by using setters defined below.
819 */
820 private static ComponentAccessor componentAccessor;
821 private static ContainerAccessor containerAccessor;
822 private static WindowAccessor windowAccessor;
823 private static AWTEventAccessor awtEventAccessor;
824 private static InputEventAccessor inputEventAccessor;
825 private static FrameAccessor frameAccessor;
826 private static KeyboardFocusManagerAccessor kfmAccessor;
827 private static MenuComponentAccessor menuComponentAccessor;
828 private static EventQueueAccessor eventQueueAccessor;
829 private static PopupMenuAccessor popupMenuAccessor;
830 private static FileDialogAccessor fileDialogAccessor;
831 private static ScrollPaneAdjustableAccessor scrollPaneAdjustableAccessor;
832 private static CheckboxMenuItemAccessor checkboxMenuItemAccessor;
833 private static CursorAccessor cursorAccessor;
834 private static MenuBarAccessor menuBarAccessor;
835 private static MenuItemAccessor menuItemAccessor;
836 private static MenuAccessor menuAccessor;
837 private static KeyEventAccessor keyEventAccessor;
838 private static ClientPropertyKeyAccessor clientPropertyKeyAccessor;
839 private static SystemTrayAccessor systemTrayAccessor;
840 private static TrayIconAccessor trayIconAccessor;
841 private static DefaultKeyboardFocusManagerAccessor defaultKeyboardFocusManagerAccessor;
842 private static SequencedEventAccessor sequencedEventAccessor;
843 private static ToolkitAccessor toolkitAccessor;
844 private static InvocationEventAccessor invocationEventAccessor;
845 private static SystemColorAccessor systemColorAccessor;
846 private static AccessibleContextAccessor accessibleContextAccessor;
847 private static DragSourceContextAccessor dragSourceContextAccessor;
848 private static DropTargetContextAccessor dropTargetContextAccessor;
849
850 /*
851 * Set an accessor object for the java.awt.Component class.
852 */
853 public static void setComponentAccessor(ComponentAccessor ca) {
854 componentAccessor = ca;
855 }
856
857 /*
858 * Retrieve the accessor object for the java.awt.Component class.
859 */
860 public static ComponentAccessor getComponentAccessor() {
861 if (componentAccessor == null) {
862 unsafe.ensureClassInitialized(Component.class);
863 }
864
865 return componentAccessor;
866 }
867
868 /*
869 * Set an accessor object for the java.awt.Container class.
870 */
871 public static void setContainerAccessor(ContainerAccessor ca) {
872 containerAccessor = ca;
873 }
874
875 /*
876 * Retrieve the accessor object for the java.awt.Container class.
877 */
878 public static ContainerAccessor getContainerAccessor() {
879 if (containerAccessor == null) {
880 unsafe.ensureClassInitialized(Container.class);
881 }
882
883 return containerAccessor;
884 }
885
886 /*
887 * Set an accessor object for the java.awt.Window class.
888 */
889 public static void setWindowAccessor(WindowAccessor wa) {
890 windowAccessor = wa;
891 }
892
893 /*
894 * Retrieve the accessor object for the java.awt.Window class.
895 */
896 public static WindowAccessor getWindowAccessor() {
897 if (windowAccessor == null) {
898 unsafe.ensureClassInitialized(Window.class);
899 }
900 return windowAccessor;
901 }
902
903 /*
904 * Set an accessor object for the java.awt.AWTEvent class.
905 */
906 public static void setAWTEventAccessor(AWTEventAccessor aea) {
907 awtEventAccessor = aea;
908 }
909
910 /*
911 * Retrieve the accessor object for the java.awt.AWTEvent class.
912 */
913 public static AWTEventAccessor getAWTEventAccessor() {
914 if (awtEventAccessor == null) {
915 unsafe.ensureClassInitialized(AWTEvent.class);
916 }
917 return awtEventAccessor;
918 }
919
920 /*
921 * Set an accessor object for the java.awt.event.InputEvent class.
922 */
923 public static void setInputEventAccessor(InputEventAccessor iea) {
924 inputEventAccessor = iea;
925 }
926
927 /*
928 * Retrieve the accessor object for the java.awt.event.InputEvent class.
929 */
930 public static InputEventAccessor getInputEventAccessor() {
931 if (inputEventAccessor == null) {
932 unsafe.ensureClassInitialized(InputEvent.class);
933 }
934 return inputEventAccessor;
935 }
936
937 /*
938 * Set an accessor object for the java.awt.Frame class.
939 */
940 public static void setFrameAccessor(FrameAccessor fa) {
941 frameAccessor = fa;
942 }
943
944 /*
945 * Retrieve the accessor object for the java.awt.Frame class.
946 */
947 public static FrameAccessor getFrameAccessor() {
948 if (frameAccessor == null) {
949 unsafe.ensureClassInitialized(Frame.class);
950 }
951 return frameAccessor;
952 }
953
954 /*
955 * Set an accessor object for the java.awt.KeyboardFocusManager class.
956 */
957 public static void setKeyboardFocusManagerAccessor(KeyboardFocusManagerAccessor kfma) {
958 kfmAccessor = kfma;
959 }
960
961 /*
962 * Retrieve the accessor object for the java.awt.KeyboardFocusManager class.
963 */
964 public static KeyboardFocusManagerAccessor getKeyboardFocusManagerAccessor() {
965 if (kfmAccessor == null) {
966 unsafe.ensureClassInitialized(KeyboardFocusManager.class);
967 }
968 return kfmAccessor;
969 }
970
971 /*
972 * Set an accessor object for the java.awt.MenuComponent class.
973 */
974 public static void setMenuComponentAccessor(MenuComponentAccessor mca) {
975 menuComponentAccessor = mca;
976 }
977
978 /*
979 * Retrieve the accessor object for the java.awt.MenuComponent class.
980 */
981 public static MenuComponentAccessor getMenuComponentAccessor() {
982 if (menuComponentAccessor == null) {
983 unsafe.ensureClassInitialized(MenuComponent.class);
984 }
985 return menuComponentAccessor;
986 }
987
988 /*
989 * Set an accessor object for the java.awt.EventQueue class.
990 */
991 public static void setEventQueueAccessor(EventQueueAccessor eqa) {
992 eventQueueAccessor = eqa;
993 }
994
995 /*
996 * Retrieve the accessor object for the java.awt.EventQueue class.
997 */
998 public static EventQueueAccessor getEventQueueAccessor() {
999 if (eventQueueAccessor == null) {
1000 unsafe.ensureClassInitialized(EventQueue.class);
1001 }
1002 return eventQueueAccessor;
1003 }
1004
1005 /*
1006 * Set an accessor object for the java.awt.PopupMenu class.
1007 */
1008 public static void setPopupMenuAccessor(PopupMenuAccessor pma) {
1009 popupMenuAccessor = pma;
1010 }
1011
1012 /*
1013 * Retrieve the accessor object for the java.awt.PopupMenu class.
1014 */
1015 public static PopupMenuAccessor getPopupMenuAccessor() {
1016 if (popupMenuAccessor == null) {
1017 unsafe.ensureClassInitialized(PopupMenu.class);
1018 }
1019 return popupMenuAccessor;
1020 }
1021
1022 /*
1023 * Set an accessor object for the java.awt.FileDialog class.
1024 */
1025 public static void setFileDialogAccessor(FileDialogAccessor fda) {
1026 fileDialogAccessor = fda;
1027 }
1028
1029 /*
1030 * Retrieve the accessor object for the java.awt.FileDialog class.
1031 */
1032 public static FileDialogAccessor getFileDialogAccessor() {
1033 if (fileDialogAccessor == null) {
1034 unsafe.ensureClassInitialized(FileDialog.class);
1035 }
1036 return fileDialogAccessor;
1037 }
1038
1039 /*
1040 * Set an accessor object for the java.awt.ScrollPaneAdjustable class.
1041 */
1042 public static void setScrollPaneAdjustableAccessor(ScrollPaneAdjustableAccessor adj) {
1043 scrollPaneAdjustableAccessor = adj;
1044 }
1045
1046 /*
1047 * Retrieve the accessor object for the java.awt.ScrollPaneAdjustable
1048 * class.
1049 */
1050 public static ScrollPaneAdjustableAccessor getScrollPaneAdjustableAccessor() {
1051 if (scrollPaneAdjustableAccessor == null) {
1052 unsafe.ensureClassInitialized(ScrollPaneAdjustable.class);
1053 }
1054 return scrollPaneAdjustableAccessor;
1055 }
1056
1057 /**
1058 * Set an accessor object for the java.awt.CheckboxMenuItem class.
1059 */
1060 public static void setCheckboxMenuItemAccessor(CheckboxMenuItemAccessor cmia) {
1061 checkboxMenuItemAccessor = cmia;
1062 }
1063
1064 /**
1065 * Retrieve the accessor object for the java.awt.CheckboxMenuItem class.
1066 */
1067 public static CheckboxMenuItemAccessor getCheckboxMenuItemAccessor() {
1068 if (checkboxMenuItemAccessor == null) {
1069 unsafe.ensureClassInitialized(CheckboxMenuItemAccessor.class);
1070 }
1071 return checkboxMenuItemAccessor;
1072 }
1073
1074 /**
1075 * Set an accessor object for the java.awt.Cursor class.
1076 */
1077 public static void setCursorAccessor(CursorAccessor ca) {
1078 cursorAccessor = ca;
1079 }
1080
1081 /**
1082 * Retrieve the accessor object for the java.awt.Cursor class.
1083 */
1084 public static CursorAccessor getCursorAccessor() {
1085 if (cursorAccessor == null) {
1086 unsafe.ensureClassInitialized(CursorAccessor.class);
1087 }
1088 return cursorAccessor;
1089 }
1090
1091 /**
1092 * Set an accessor object for the java.awt.MenuBar class.
1093 */
1094 public static void setMenuBarAccessor(MenuBarAccessor mba) {
1095 menuBarAccessor = mba;
1096 }
1097
1098 /**
1099 * Retrieve the accessor object for the java.awt.MenuBar class.
1100 */
1101 public static MenuBarAccessor getMenuBarAccessor() {
1102 if (menuBarAccessor == null) {
1103 unsafe.ensureClassInitialized(MenuBarAccessor.class);
1104 }
1105 return menuBarAccessor;
1106 }
1107
1108 /**
1109 * Set an accessor object for the java.awt.MenuItem class.
1110 */
1111 public static void setMenuItemAccessor(MenuItemAccessor mia) {
1112 menuItemAccessor = mia;
1113 }
1114
1115 /**
1116 * Retrieve the accessor object for the java.awt.MenuItem class.
1117 */
1118 public static MenuItemAccessor getMenuItemAccessor() {
1119 if (menuItemAccessor == null) {
1120 unsafe.ensureClassInitialized(MenuItemAccessor.class);
1121 }
1122 return menuItemAccessor;
1123 }
1124
1125 /**
1126 * Set an accessor object for the java.awt.Menu class.
1127 */
1128 public static void setMenuAccessor(MenuAccessor ma) {
1129 menuAccessor = ma;
1130 }
1131
1132 /**
1133 * Retrieve the accessor object for the java.awt.Menu class.
1134 */
1135 public static MenuAccessor getMenuAccessor() {
1136 if (menuAccessor == null) {
1137 unsafe.ensureClassInitialized(MenuAccessor.class);
1138 }
1139 return menuAccessor;
1140 }
1141
1142 /**
1143 * Set an accessor object for the java.awt.event.KeyEvent class.
1144 */
1145 public static void setKeyEventAccessor(KeyEventAccessor kea) {
1146 keyEventAccessor = kea;
1147 }
1148
1149 /**
1150 * Retrieve the accessor object for the java.awt.event.KeyEvent class.
1151 */
1152 public static KeyEventAccessor getKeyEventAccessor() {
1153 if (keyEventAccessor == null) {
1154 unsafe.ensureClassInitialized(KeyEventAccessor.class);
1155 }
1156 return keyEventAccessor;
1157 }
1158
1159 /**
1160 * Set an accessor object for the javax.swing.ClientPropertyKey class.
1161 */
1162 public static void setClientPropertyKeyAccessor(ClientPropertyKeyAccessor cpka) {
1163 clientPropertyKeyAccessor = cpka;
1164 }
1165
1166 /**
1167 * Retrieve the accessor object for the javax.swing.ClientPropertyKey class.
1168 */
1169 public static ClientPropertyKeyAccessor getClientPropertyKeyAccessor() {
1170 if (clientPropertyKeyAccessor == null) {
1171 unsafe.ensureClassInitialized(ClientPropertyKeyAccessor.class);
1172 }
1173 return clientPropertyKeyAccessor;
1174 }
1175
1176 /**
1177 * Set an accessor object for the java.awt.SystemTray class.
1178 */
1179 public static void setSystemTrayAccessor(SystemTrayAccessor sta) {
1180 systemTrayAccessor = sta;
1181 }
1182
1183 /**
1184 * Retrieve the accessor object for the java.awt.SystemTray class.
1185 */
1186 public static SystemTrayAccessor getSystemTrayAccessor() {
1187 if (systemTrayAccessor == null) {
1188 unsafe.ensureClassInitialized(SystemTrayAccessor.class);
1189 }
1190 return systemTrayAccessor;
1191 }
1192
1193 /**
1194 * Set an accessor object for the java.awt.TrayIcon class.
1195 */
1196 public static void setTrayIconAccessor(TrayIconAccessor tia) {
1197 trayIconAccessor = tia;
1198 }
1199
1200 /**
1201 * Retrieve the accessor object for the java.awt.TrayIcon class.
1202 */
1203 public static TrayIconAccessor getTrayIconAccessor() {
1204 if (trayIconAccessor == null) {
1205 unsafe.ensureClassInitialized(TrayIconAccessor.class);
1206 }
1207 return trayIconAccessor;
1208 }
1209
1210 /**
1211 * Set an accessor object for the java.awt.DefaultKeyboardFocusManager class.
1212 */
1213 public static void setDefaultKeyboardFocusManagerAccessor(DefaultKeyboardFocusManagerAccessor dkfma) {
1214 defaultKeyboardFocusManagerAccessor = dkfma;
1215 }
1216
1217 /**
1218 * Retrieve the accessor object for the java.awt.DefaultKeyboardFocusManager class.
1219 */
1220 public static DefaultKeyboardFocusManagerAccessor getDefaultKeyboardFocusManagerAccessor() {
1221 if (defaultKeyboardFocusManagerAccessor == null) {
1222 unsafe.ensureClassInitialized(DefaultKeyboardFocusManagerAccessor.class);
1223 }
1224 return defaultKeyboardFocusManagerAccessor;
1225 }
1226 /*
1227 * Set an accessor object for the java.awt.SequencedEvent class.
1228 */
1229 public static void setSequencedEventAccessor(SequencedEventAccessor sea) {
1230 sequencedEventAccessor = sea;
1231 }
1232
1233 /*
1234 * Get the accessor object for the java.awt.SequencedEvent class.
1235 */
1236 public static SequencedEventAccessor getSequencedEventAccessor() {
1237 // The class is not public. So we can't ensure it's initialized.
1238 // Null returned value means it's not initialized
1239 // (so not a single instance of the event has been created).
1240 return sequencedEventAccessor;
1241 }
1242
1243 /*
1244 * Set an accessor object for the java.awt.Toolkit class.
1245 */
1246 public static void setToolkitAccessor(ToolkitAccessor ta) {
1247 toolkitAccessor = ta;
1248 }
1249
1250 /*
1251 * Get the accessor object for the java.awt.Toolkit class.
1252 */
1253 public static ToolkitAccessor getToolkitAccessor() {
1254 if (toolkitAccessor == null) {
1255 unsafe.ensureClassInitialized(Toolkit.class);
1256 }
1257
1258 return toolkitAccessor;
1259 }
1260
1261 /*
1262 * Get the accessor object for the java.awt.event.InvocationEvent class.
1263 */
1264 public static void setInvocationEventAccessor(InvocationEventAccessor invocationEventAccessor) {
1265 AWTAccessor.invocationEventAccessor = invocationEventAccessor;
1266 }
1267
1268 /*
1269 * Set the accessor object for the java.awt.event.InvocationEvent class.
1270 */
1271 public static InvocationEventAccessor getInvocationEventAccessor() {
1272 return invocationEventAccessor;
1273 }
1274
1275 /*
1276 * Get the accessor object for the java.awt.SystemColor class.
1277 */
1278 public static SystemColorAccessor getSystemColorAccessor() {
1279 if (systemColorAccessor == null) {
1280 unsafe.ensureClassInitialized(SystemColor.class);
1281 }
1282
1283 return systemColorAccessor;
1284 }
1285
1286 /*
1287 * Set the accessor object for the java.awt.SystemColor class.
1288 */
1289 public static void setSystemColorAccessor(SystemColorAccessor systemColorAccessor) {
1290 AWTAccessor.systemColorAccessor = systemColorAccessor;
1291 }
1292
1293 /*
1294 * Get the accessor object for the javax.accessibility.AccessibleContext class.
1295 */
1296 public static AccessibleContextAccessor getAccessibleContextAccessor() {
1297 if (accessibleContextAccessor == null) {
1298 unsafe.ensureClassInitialized(AccessibleContext.class);
1299 }
1300 return accessibleContextAccessor;
1301 }
1302
1303 /*
1304 * Set the accessor object for the javax.accessibility.AccessibleContext class.
1305 */
1306 public static void setAccessibleContextAccessor(AccessibleContextAccessor accessor) {
1307 AWTAccessor.accessibleContextAccessor = accessor;
1308 }
1309
1310 /*
1311 * Get the accessor object for the java.awt.dnd.DragSourceContext class.
1312 */
1313 public static DragSourceContextAccessor getDragSourceContextAccessor() {
1314 if (dragSourceContextAccessor == null) {
1315 unsafe.ensureClassInitialized(DragSourceContext.class);
1316 }
1317 return dragSourceContextAccessor;
1318 }
1319
1320 /*
1321 * Set the accessor object for the java.awt.dnd.DragSourceContext class.
1322 */
1323 public static void setDragSourceContextAccessor(DragSourceContextAccessor accessor) {
1324 AWTAccessor.dragSourceContextAccessor = accessor;
1325 }
1326
1327 /*
1328 * Get the accessor object for the java.awt.dnd.DropTargetContext class.
1329 */
1330 public static DropTargetContextAccessor getDropTargetContextAccessor() {
1331 if (dropTargetContextAccessor == null) {
1332 unsafe.ensureClassInitialized(DropTargetContext.class);
1333 }
1334 return dropTargetContextAccessor;
1335 }
1336
1337 /*
1338 * Set the accessor object for the java.awt.dnd.DropTargetContext class.
1339 */
1340 public static void setDropTargetContextAccessor(DropTargetContextAccessor accessor) {
1341 AWTAccessor.dropTargetContextAccessor = accessor;
1342 }
1343
1344 }
--- EOF ---