1 /*
2 * Copyright (c) 2008, 2012, 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 java.awt.*;
31 import java.awt.KeyboardFocusManager;
32 import java.awt.DefaultKeyboardFocusManager;
33 import java.awt.event.InputEvent;
34 import java.awt.event.KeyEvent;
35 import java.awt.geom.Point2D;
36 import java.awt.peer.ComponentPeer;
37 import java.security.AccessControlContext;
38
39 import java.io.File;
40 import java.util.Vector;
41
42 /**
43 * The AWTAccessor utility class.
44 * The main purpose of this class is to enable accessing
45 * private and package-private fields of classes from
46 * different classes/packages. See sun.misc.SharedSecretes
47 * for another example.
48 */
49 public final class AWTAccessor {
50
51 private static final Unsafe unsafe = Unsafe.getUnsafe();
52
53 /*
54 * We don't need any objects of this class.
55 * It's rather a collection of static methods
56 * and interfaces.
57 */
58 private AWTAccessor() {
59 }
60
61 /*
62 * An interface of accessor for the java.awt.Component class.
63 */
64 public interface ComponentAccessor {
65 /*
66 * Sets whether the native background erase for a component
67 * has been disabled via SunToolkit.disableBackgroundErase().
68 */
69 void setBackgroundEraseDisabled(Component comp, boolean disabled);
70 /*
71 * Indicates whether the native background erase for a
72 * component has been disabled via
73 * SunToolkit.disableBackgroundErase().
74 */
75 boolean getBackgroundEraseDisabled(Component comp);
76 /*
77 *
78 * Gets the bounds of this component in the form of a
79 * <code>Rectangle</code> object. The bounds specify this
80 * component's width, height, and location relative to
81 * its parent.
82 */
83 Rectangle getBounds(Component comp);
84 /*
85 * Sets the shape of a lw component to cut out from hw components.
86 *
87 * See 6797587, 6776743, 6768307, and 6768332 for details
88 */
89 void setMixingCutoutShape(Component comp, Shape shape);
90
91 /**
92 * Sets GraphicsConfiguration value for the component.
93 */
94 void setGraphicsConfiguration(Component comp, GraphicsConfiguration gc);
95 /*
96 * Requests focus to the component.
97 */
98 boolean requestFocus(Component comp, CausedFocusEvent.Cause cause);
99 /*
100 * Determines if the component can gain focus.
101 */
102 boolean canBeFocusOwner(Component comp);
103
104 /**
105 * Returns whether the component is visible without invoking
106 * any client code.
107 */
108 boolean isVisible(Component comp);
109
110 /**
111 * Sets the RequestFocusController.
112 */
113 void setRequestFocusController(RequestFocusController requestController);
114
115 /**
116 * Returns the appContext of the component.
117 */
118 AppContext getAppContext(Component comp);
119
120 /**
121 * Sets the appContext of the component.
122 */
123 void setAppContext(Component comp, AppContext appContext);
124
125 /**
126 * Returns the parent of the component.
127 */
128 Container getParent(Component comp);
129
130 /**
131 * Sets the parent of the component to the specified parent.
132 */
133 void setParent(Component comp, Container parent);
134
135 /**
136 * Resizes the component to the specified width and height.
137 */
138 void setSize(Component comp, int width, int height);
139
140 /**
141 * Returns the location of the component.
142 */
143 Point getLocation(Component comp);
144
145 /**
146 * Moves the component to the new location.
147 */
148 void setLocation(Component comp, int x, int y);
149
150 /**
151 * Determines whether this component is enabled.
152 */
153 boolean isEnabled(Component comp);
154
155 /**
156 * Determines whether this component is displayable.
157 */
158 boolean isDisplayable(Component comp);
159
160 /**
161 * Gets the cursor set in the component.
162 */
163 Cursor getCursor(Component comp);
164
165 /**
166 * Returns the peer of the component.
167 */
168 ComponentPeer getPeer(Component comp);
169
170 /**
171 * Sets the peer of the component to the specified peer.
172 */
173 void setPeer(Component comp, ComponentPeer peer);
174
175 /**
176 * Determines whether this component is lightweight.
177 */
178 boolean isLightweight(Component comp);
179
180 /**
181 * Returns whether or not paint messages received from
182 * the operating system should be ignored.
183 */
184 boolean getIgnoreRepaint(Component comp);
185
186 /**
187 * Returns the width of the component.
188 */
189 int getWidth(Component comp);
190
191 /**
192 * Returns the height of the component.
193 */
194 int getHeight(Component comp);
195
196 /**
197 * Returns the x coordinate of the component.
198 */
199 int getX(Component comp);
200
201 /**
202 * Returns the y coordinate of the component.
203 */
204 int getY(Component comp);
205
206 /**
207 * Gets the foreground color of this component.
208 */
209 Color getForeground(Component comp);
210
211 /**
212 * Gets the background color of this component.
213 */
214 Color getBackground(Component comp);
215
216 /**
217 * Sets the background of this component to the specified color.
218 */
219 void setBackground(Component comp, Color background);
220
221 /**
222 * Gets the font of the component.
223 */
224 Font getFont(Component comp);
225
226 /**
227 * Processes events occurring on this component.
228 */
229 void processEvent(Component comp, AWTEvent e);
230
231
232 /*
233 * Returns the acc this component was constructed with.
234 */
235 AccessControlContext getAccessControlContext(Component comp);
236
237 }
238
239 /*
240 * An interface of accessor for the java.awt.Container class.
241 */
242 public interface ContainerAccessor {
243 /**
244 * Validates the container unconditionally.
245 */
246 void validateUnconditionally(Container cont);
247 }
248
249 /*
250 * An interface of accessor for java.awt.Window class.
251 */
252 public interface WindowAccessor {
253 /*
254 * Get opacity level of the given window.
255 */
256 float getOpacity(Window window);
257 /*
258 * Set opacity level to the given window.
259 */
260 void setOpacity(Window window, float opacity);
261 /*
262 * Get a shape assigned to the given window.
263 */
264 Shape getShape(Window window);
265 /*
266 * Set a shape to the given window.
267 */
268 void setShape(Window window, Shape shape);
269 /*
270 * Set the opaque preoperty to the given window.
271 */
272 void setOpaque(Window window, boolean isOpaque);
273 /*
274 * Update the image of a non-opaque (translucent) window.
275 */
276 void updateWindow(Window window);
277
278 /** Get the size of the security warning.
279 */
280 Dimension getSecurityWarningSize(Window w);
281
282 /**
283 * Set the size of the security warning.
284 */
285 void setSecurityWarningSize(Window w, int width, int height);
286
287 /** Set the position of the security warning.
288 */
289 void setSecurityWarningPosition(Window w, Point2D point,
290 float alignmentX, float alignmentY);
291
292 /** Request to recalculate the new position of the security warning for
293 * the given window size/location as reported by the native system.
294 */
295 Point2D calculateSecurityWarningPosition(Window window,
296 double x, double y, double w, double h);
297
298 /** Sets the synchronous status of focus requests on lightweight
299 * components in the specified window to the specified value.
300 */
301 void setLWRequestStatus(Window changed, boolean status);
302
303 /**
304 * Indicates whether this window should receive focus on subsequently
305 * being shown, or being moved to the front.
306 */
307 boolean isAutoRequestFocus(Window w);
308
309 /**
310 * Indicates whether the specified window is an utility window for TrayIcon.
311 */
312 boolean isTrayIconWindow(Window w);
313
314 /**
315 * Marks the specified window as an utility window for TrayIcon.
316 */
317 void setTrayIconWindow(Window w, boolean isTrayIconWindow);
318 }
319
320 /**
321 * An accessor for the AWTEvent class.
322 */
323 public interface AWTEventAccessor {
324 /**
325 * Marks the event as posted.
326 */
327 void setPosted(AWTEvent ev);
328
329 /**
330 * Sets the flag on this AWTEvent indicating that it was
331 * generated by the system.
332 */
333 void setSystemGenerated(AWTEvent ev);
334
335 /**
336 * Indicates whether this AWTEvent was generated by the system.
337 */
338 boolean isSystemGenerated(AWTEvent ev);
339
340 /**
341 * Returns the acc this event was constructed with.
342 */
343 AccessControlContext getAccessControlContext(AWTEvent ev);
344
345 /**
346 * Returns binary data associated with this event;
347 */
348 byte[] getBData(AWTEvent ev);
349
350 /**
351 * Associates binary data with this event;
352 */
353 void setBData(AWTEvent ev, byte[] bdata);
354 }
355
356 public interface InputEventAccessor {
357 /*
358 * Accessor for InputEvent.getButtonDownMasks()
359 */
360 int[] getButtonDownMasks();
361 }
362
363 /*
364 * An accessor for the java.awt.Frame class.
365 */
366 public interface FrameAccessor {
367 /*
368 * Sets the state of this frame.
369 */
370 void setExtendedState(Frame frame, int state);
371 /*
372 * Gets the state of this frame.
373 */
374 int getExtendedState(Frame frame);
375 /*
376 * Gets the maximized bounds of this frame.
377 */
378 Rectangle getMaximizedBounds(Frame frame);
379 }
380
381 /**
382 * An interface of accessor for the java.awt.KeyboardFocusManager class.
383 */
384 public interface KeyboardFocusManagerAccessor {
385 /**
386 * Indicates whether the native implementation should
387 * proceed with a pending focus request for the heavyweight.
388 */
389 int shouldNativelyFocusHeavyweight(Component heavyweight,
390 Component descendant,
391 boolean temporary,
392 boolean focusedWindowChangeAllowed,
393 long time,
394 CausedFocusEvent.Cause cause);
395 /**
396 * Delivers focus for the lightweight descendant of the heavyweight
397 * synchronously.
398 */
399 boolean processSynchronousLightweightTransfer(Component heavyweight,
400 Component descendant,
401 boolean temporary,
402 boolean focusedWindowChangeAllowed,
403 long time);
404 /**
405 * Removes the last focus request for the heavyweight from the queue.
406 */
407 void removeLastFocusRequest(Component heavyweight);
408
409 /**
410 * Sets the most recent focus owner in the window.
411 */
412 void setMostRecentFocusOwner(Window window, Component component);
413
414 /**
415 * Returns current KFM of the specified AppContext.
416 */
417 KeyboardFocusManager getCurrentKeyboardFocusManager(AppContext ctx);
418
419 /**
420 * Return the current focus cycle root
421 */
422 Container getCurrentFocusCycleRoot();
423 }
424
425 /**
426 * An accessor for the MenuComponent class.
427 */
428 public interface MenuComponentAccessor {
429 /**
430 * Returns the appContext of the menu component.
431 */
432 AppContext getAppContext(MenuComponent menuComp);
433
434 /**
435 * Sets the appContext of the menu component.
436 */
437 void setAppContext(MenuComponent menuComp, AppContext appContext);
438
439 /**
440 * Returns the menu container of the menu component
441 */
442 MenuContainer getParent(MenuComponent menuComp);
443
444 /**
445 * Gets the font used for this menu component.
446 */
447 Font getFont_NoClientCode(MenuComponent menuComp);
448 }
449
450 /**
451 * An accessor for the EventQueue class
452 */
453 public interface EventQueueAccessor {
454 /**
455 * Gets the event dispatch thread.
456 */
457 Thread getDispatchThread(EventQueue eventQueue);
458
459 /**
460 * Checks if the current thread is EDT for the given EQ.
461 */
462 public boolean isDispatchThreadImpl(EventQueue eventQueue);
463
464 /**
465 * Removes any pending events for the specified source object.
466 */
467 void removeSourceEvents(EventQueue eventQueue, Object source, boolean removeAllEvents);
468
469 /**
470 * Returns whether an event is pending on any of the separate Queues.
471 */
472 boolean noEvents(EventQueue eventQueue);
473
474 /**
475 * Called from PostEventQueue.postEvent to notify that a new event
476 * appeared.
477 */
478 void wakeup(EventQueue eventQueue, boolean isShutdown);
479 }
480
481 /*
482 * An accessor for the PopupMenu class
483 */
484 public interface PopupMenuAccessor {
485 /*
486 * Returns whether the popup menu is attached to a tray
487 */
488 boolean isTrayIconPopup(PopupMenu popupMenu);
489 }
490
491 /*
492 * An accessor for the FileDialog class
493 */
494 public interface FileDialogAccessor {
495 /*
496 * Sets the files the user selects
497 */
498 void setFiles(FileDialog fileDialog, File files[]);
499
500 /*
501 * Sets the file the user selects
502 */
503 void setFile(FileDialog fileDialog, String file);
504
505 /*
506 * Sets the directory the user selects
507 */
508 void setDirectory(FileDialog fileDialog, String directory);
509
510 /*
511 * Returns whether the file dialog allows the multiple file selection.
512 */
513 boolean isMultipleMode(FileDialog fileDialog);
514 }
515
516 /*
517 * An accessor for the ScrollPaneAdjustable class.
518 */
519 public interface ScrollPaneAdjustableAccessor {
520 /*
521 * Sets the value of this scrollbar to the specified value.
522 */
523 void setTypedValue(final ScrollPaneAdjustable adj, final int v,
524 final int type);
525 }
526
527 /**
528 * An accessor for the CheckboxMenuItem class
529 */
530 public interface CheckboxMenuItemAccessor {
531 /**
532 * Returns whether menu item is checked
533 */
534 boolean getState(CheckboxMenuItem cmi);
535 }
536
537 /**
538 * An accessor for the Cursor class
539 */
540 public interface CursorAccessor {
541 /**
542 * Returns pData of the Cursor class
543 */
544 long getPData(Cursor cursor);
545
546 /**
547 * Sets pData to the Cursor class
548 */
549 void setPData(Cursor cursor, long pData);
550
551 /**
552 * Return type of the Cursor class
553 */
554 int getType(Cursor cursor);
555 }
556
557 /**
558 * An accessor for the MenuBar class
559 */
560 public interface MenuBarAccessor {
561 /**
562 * Returns help menu
563 */
564 Menu getHelpMenu(MenuBar menuBar);
565
566 /**
567 * Returns menus
568 */
569 Vector getMenus(MenuBar menuBar);
570 }
571
572 /**
573 * An accessor for the MenuItem class
574 */
575 public interface MenuItemAccessor {
576 /**
577 * Returns whether menu item is enabled
578 */
579 boolean isEnabled(MenuItem item);
580
581 /**
582 * Gets the command name of the action event that is fired
583 * by this menu item.
584 */
585 String getActionCommandImpl(MenuItem item);
586
587 /**
588 * Returns true if the item and all its ancestors are
589 * enabled, false otherwise
590 */
591 boolean isItemEnabled(MenuItem item);
592
593 /**
594 * Returns label
595 */
596 String getLabel(MenuItem item);
597
598 /**
599 * Returns shortcut
600 */
601 MenuShortcut getShortcut(MenuItem item);
602 }
603
604 /**
605 * An accessor for the Menu class
606 */
607 public interface MenuAccessor {
608 /**
609 * Returns vector of the items that are part of the Menu
610 */
611 Vector getItems(Menu menu);
612 }
613
614 /**
615 * An accessor for the KeyEvent class
616 */
617 public interface KeyEventAccessor {
618 /**
619 * Sets rawCode field for KeyEvent
620 */
621 void setRawCode(KeyEvent ev, long rawCode);
622
623 /**
624 * Sets primaryLevelUnicode field for KeyEvent
625 */
626 void setPrimaryLevelUnicode(KeyEvent ev, long primaryLevelUnicode);
627
628 /**
629 * Sets extendedKeyCode field for KeyEvent
630 */
631 void setExtendedKeyCode(KeyEvent ev, long extendedKeyCode);
632
633 /**
634 * Gets original source for KeyEvent
635 */
636 Component getOriginalSource(KeyEvent ev);
637 }
638
639 /**
640 * An accessor for the ClientPropertyKey class
641 */
642 public interface ClientPropertyKeyAccessor {
643 /**
644 * Retrieves JComponent_TRANSFER_HANDLER enum object
645 */
646 Object getJComponent_TRANSFER_HANDLER();
647 }
648
649 /**
650 * An accessor for the SystemTray class
651 */
652 public interface SystemTrayAccessor {
653 /**
654 * Support for reporting bound property changes for Object properties.
655 */
656 void firePropertyChange(SystemTray tray, String propertyName, Object oldValue, Object newValue);
657 }
658
659 /**
660 * An accessor for the TrayIcon class
661 */
662 public interface TrayIconAccessor {
663 void addNotify(TrayIcon trayIcon) throws AWTException;
664 void removeNotify(TrayIcon trayIcon);
665 }
666
667 /**
668 * An accessor for the DefaultKeyboardFocusManager class
669 */
670 public interface DefaultKeyboardFocusManagerAccessor {
671 public void consumeNextKeyTyped(DefaultKeyboardFocusManager dkfm, KeyEvent e);
672 }
673
674 /*
675 * An accessor for the SequencedEventAccessor class
676 */
677 public interface SequencedEventAccessor {
678 /*
679 * Returns the nested event.
680 */
681 AWTEvent getNested(AWTEvent sequencedEvent);
682
683 /*
684 * Returns true if the event is an instances of SequencedEvent.
685 */
686 boolean isSequencedEvent(AWTEvent event);
687 }
688
689 /*
690 * Accessor instances are initialized in the static initializers of
691 * corresponding AWT classes by using setters defined below.
692 */
693 private static ComponentAccessor componentAccessor;
694 private static ContainerAccessor containerAccessor;
695 private static WindowAccessor windowAccessor;
696 private static AWTEventAccessor awtEventAccessor;
697 private static InputEventAccessor inputEventAccessor;
698 private static FrameAccessor frameAccessor;
699 private static KeyboardFocusManagerAccessor kfmAccessor;
700 private static MenuComponentAccessor menuComponentAccessor;
701 private static EventQueueAccessor eventQueueAccessor;
702 private static PopupMenuAccessor popupMenuAccessor;
703 private static FileDialogAccessor fileDialogAccessor;
704 private static ScrollPaneAdjustableAccessor scrollPaneAdjustableAccessor;
705 private static CheckboxMenuItemAccessor checkboxMenuItemAccessor;
706 private static CursorAccessor cursorAccessor;
707 private static MenuBarAccessor menuBarAccessor;
708 private static MenuItemAccessor menuItemAccessor;
709 private static MenuAccessor menuAccessor;
710 private static KeyEventAccessor keyEventAccessor;
711 private static ClientPropertyKeyAccessor clientPropertyKeyAccessor;
712 private static SystemTrayAccessor systemTrayAccessor;
713 private static TrayIconAccessor trayIconAccessor;
714 private static DefaultKeyboardFocusManagerAccessor defaultKeyboardFocusManagerAccessor;
715 private static SequencedEventAccessor sequencedEventAccessor;
716
717 /*
718 * Set an accessor object for the java.awt.Component class.
719 */
720 public static void setComponentAccessor(ComponentAccessor ca) {
721 componentAccessor = ca;
722 }
723
724 /*
725 * Retrieve the accessor object for the java.awt.Component class.
726 */
727 public static ComponentAccessor getComponentAccessor() {
728 if (componentAccessor == null) {
729 unsafe.ensureClassInitialized(Component.class);
730 }
731
732 return componentAccessor;
733 }
734
735 /*
736 * Set an accessor object for the java.awt.Container class.
737 */
738 public static void setContainerAccessor(ContainerAccessor ca) {
739 containerAccessor = ca;
740 }
741
742 /*
743 * Retrieve the accessor object for the java.awt.Container class.
744 */
745 public static ContainerAccessor getContainerAccessor() {
746 if (containerAccessor == null) {
747 unsafe.ensureClassInitialized(Container.class);
748 }
749
750 return containerAccessor;
751 }
752
753 /*
754 * Set an accessor object for the java.awt.Window class.
755 */
756 public static void setWindowAccessor(WindowAccessor wa) {
757 windowAccessor = wa;
758 }
759
760 /*
761 * Retrieve the accessor object for the java.awt.Window class.
762 */
763 public static WindowAccessor getWindowAccessor() {
764 if (windowAccessor == null) {
765 unsafe.ensureClassInitialized(Window.class);
766 }
767 return windowAccessor;
768 }
769
770 /*
771 * Set an accessor object for the java.awt.AWTEvent class.
772 */
773 public static void setAWTEventAccessor(AWTEventAccessor aea) {
774 awtEventAccessor = aea;
775 }
776
777 /*
778 * Retrieve the accessor object for the java.awt.AWTEvent class.
779 */
780 public static AWTEventAccessor getAWTEventAccessor() {
781 if (awtEventAccessor == null) {
782 unsafe.ensureClassInitialized(AWTEvent.class);
783 }
784 return awtEventAccessor;
785 }
786
787 /*
788 * Set an accessor object for the java.awt.event.InputEvent class.
789 */
790 public static void setInputEventAccessor(InputEventAccessor iea) {
791 inputEventAccessor = iea;
792 }
793
794 /*
795 * Retrieve the accessor object for the java.awt.event.InputEvent class.
796 */
797 public static InputEventAccessor getInputEventAccessor() {
798 if (inputEventAccessor == null) {
799 unsafe.ensureClassInitialized(InputEvent.class);
800 }
801 return inputEventAccessor;
802 }
803
804 /*
805 * Set an accessor object for the java.awt.Frame class.
806 */
807 public static void setFrameAccessor(FrameAccessor fa) {
808 frameAccessor = fa;
809 }
810
811 /*
812 * Retrieve the accessor object for the java.awt.Frame class.
813 */
814 public static FrameAccessor getFrameAccessor() {
815 if (frameAccessor == null) {
816 unsafe.ensureClassInitialized(Frame.class);
817 }
818 return frameAccessor;
819 }
820
821 /*
822 * Set an accessor object for the java.awt.KeyboardFocusManager class.
823 */
824 public static void setKeyboardFocusManagerAccessor(KeyboardFocusManagerAccessor kfma) {
825 kfmAccessor = kfma;
826 }
827
828 /*
829 * Retrieve the accessor object for the java.awt.KeyboardFocusManager class.
830 */
831 public static KeyboardFocusManagerAccessor getKeyboardFocusManagerAccessor() {
832 if (kfmAccessor == null) {
833 unsafe.ensureClassInitialized(KeyboardFocusManager.class);
834 }
835 return kfmAccessor;
836 }
837
838 /*
839 * Set an accessor object for the java.awt.MenuComponent class.
840 */
841 public static void setMenuComponentAccessor(MenuComponentAccessor mca) {
842 menuComponentAccessor = mca;
843 }
844
845 /*
846 * Retrieve the accessor object for the java.awt.MenuComponent class.
847 */
848 public static MenuComponentAccessor getMenuComponentAccessor() {
849 if (menuComponentAccessor == null) {
850 unsafe.ensureClassInitialized(MenuComponent.class);
851 }
852 return menuComponentAccessor;
853 }
854
855 /*
856 * Set an accessor object for the java.awt.EventQueue class.
857 */
858 public static void setEventQueueAccessor(EventQueueAccessor eqa) {
859 eventQueueAccessor = eqa;
860 }
861
862 /*
863 * Retrieve the accessor object for the java.awt.EventQueue class.
864 */
865 public static EventQueueAccessor getEventQueueAccessor() {
866 if (eventQueueAccessor == null) {
867 unsafe.ensureClassInitialized(EventQueue.class);
868 }
869 return eventQueueAccessor;
870 }
871
872 /*
873 * Set an accessor object for the java.awt.PopupMenu class.
874 */
875 public static void setPopupMenuAccessor(PopupMenuAccessor pma) {
876 popupMenuAccessor = pma;
877 }
878
879 /*
880 * Retrieve the accessor object for the java.awt.PopupMenu class.
881 */
882 public static PopupMenuAccessor getPopupMenuAccessor() {
883 if (popupMenuAccessor == null) {
884 unsafe.ensureClassInitialized(PopupMenu.class);
885 }
886 return popupMenuAccessor;
887 }
888
889 /*
890 * Set an accessor object for the java.awt.FileDialog class.
891 */
892 public static void setFileDialogAccessor(FileDialogAccessor fda) {
893 fileDialogAccessor = fda;
894 }
895
896 /*
897 * Retrieve the accessor object for the java.awt.FileDialog class.
898 */
899 public static FileDialogAccessor getFileDialogAccessor() {
900 if (fileDialogAccessor == null) {
901 unsafe.ensureClassInitialized(FileDialog.class);
902 }
903 return fileDialogAccessor;
904 }
905
906 /*
907 * Set an accessor object for the java.awt.ScrollPaneAdjustable class.
908 */
909 public static void setScrollPaneAdjustableAccessor(ScrollPaneAdjustableAccessor adj) {
910 scrollPaneAdjustableAccessor = adj;
911 }
912
913 /*
914 * Retrieve the accessor object for the java.awt.ScrollPaneAdjustable
915 * class.
916 */
917 public static ScrollPaneAdjustableAccessor getScrollPaneAdjustableAccessor() {
918 if (scrollPaneAdjustableAccessor == null) {
919 unsafe.ensureClassInitialized(ScrollPaneAdjustable.class);
920 }
921 return scrollPaneAdjustableAccessor;
922 }
923
924 /**
925 * Set an accessor object for the java.awt.CheckboxMenuItem class.
926 */
927 public static void setCheckboxMenuItemAccessor(CheckboxMenuItemAccessor cmia) {
928 checkboxMenuItemAccessor = cmia;
929 }
930
931 /**
932 * Retrieve the accessor object for the java.awt.CheckboxMenuItem class.
933 */
934 public static CheckboxMenuItemAccessor getCheckboxMenuItemAccessor() {
935 if (checkboxMenuItemAccessor == null) {
936 unsafe.ensureClassInitialized(CheckboxMenuItemAccessor.class);
937 }
938 return checkboxMenuItemAccessor;
939 }
940
941 /**
942 * Set an accessor object for the java.awt.Cursor class.
943 */
944 public static void setCursorAccessor(CursorAccessor ca) {
945 cursorAccessor = ca;
946 }
947
948 /**
949 * Retrieve the accessor object for the java.awt.Cursor class.
950 */
951 public static CursorAccessor getCursorAccessor() {
952 if (cursorAccessor == null) {
953 unsafe.ensureClassInitialized(CursorAccessor.class);
954 }
955 return cursorAccessor;
956 }
957
958 /**
959 * Set an accessor object for the java.awt.MenuBar class.
960 */
961 public static void setMenuBarAccessor(MenuBarAccessor mba) {
962 menuBarAccessor = mba;
963 }
964
965 /**
966 * Retrieve the accessor object for the java.awt.MenuBar class.
967 */
968 public static MenuBarAccessor getMenuBarAccessor() {
969 if (menuBarAccessor == null) {
970 unsafe.ensureClassInitialized(MenuBarAccessor.class);
971 }
972 return menuBarAccessor;
973 }
974
975 /**
976 * Set an accessor object for the java.awt.MenuItem class.
977 */
978 public static void setMenuItemAccessor(MenuItemAccessor mia) {
979 menuItemAccessor = mia;
980 }
981
982 /**
983 * Retrieve the accessor object for the java.awt.MenuItem class.
984 */
985 public static MenuItemAccessor getMenuItemAccessor() {
986 if (menuItemAccessor == null) {
987 unsafe.ensureClassInitialized(MenuItemAccessor.class);
988 }
989 return menuItemAccessor;
990 }
991
992 /**
993 * Set an accessor object for the java.awt.Menu class.
994 */
995 public static void setMenuAccessor(MenuAccessor ma) {
996 menuAccessor = ma;
997 }
998
999 /**
1000 * Retrieve the accessor object for the java.awt.Menu class.
1001 */
1002 public static MenuAccessor getMenuAccessor() {
1003 if (menuAccessor == null) {
1004 unsafe.ensureClassInitialized(MenuAccessor.class);
1005 }
1006 return menuAccessor;
1007 }
1008
1009 /**
1010 * Set an accessor object for the java.awt.event.KeyEvent class.
1011 */
1012 public static void setKeyEventAccessor(KeyEventAccessor kea) {
1013 keyEventAccessor = kea;
1014 }
1015
1016 /**
1017 * Retrieve the accessor object for the java.awt.event.KeyEvent class.
1018 */
1019 public static KeyEventAccessor getKeyEventAccessor() {
1020 if (keyEventAccessor == null) {
1021 unsafe.ensureClassInitialized(KeyEventAccessor.class);
1022 }
1023 return keyEventAccessor;
1024 }
1025
1026 /**
1027 * Set an accessor object for the javax.swing.ClientPropertyKey class.
1028 */
1029 public static void setClientPropertyKeyAccessor(ClientPropertyKeyAccessor cpka) {
1030 clientPropertyKeyAccessor = cpka;
1031 }
1032
1033 /**
1034 * Retrieve the accessor object for the javax.swing.ClientPropertyKey class.
1035 */
1036 public static ClientPropertyKeyAccessor getClientPropertyKeyAccessor() {
1037 if (clientPropertyKeyAccessor == null) {
1038 unsafe.ensureClassInitialized(ClientPropertyKeyAccessor.class);
1039 }
1040 return clientPropertyKeyAccessor;
1041 }
1042
1043 /**
1044 * Set an accessor object for the java.awt.SystemTray class.
1045 */
1046 public static void setSystemTrayAccessor(SystemTrayAccessor sta) {
1047 systemTrayAccessor = sta;
1048 }
1049
1050 /**
1051 * Retrieve the accessor object for the java.awt.SystemTray class.
1052 */
1053 public static SystemTrayAccessor getSystemTrayAccessor() {
1054 if (systemTrayAccessor == null) {
1055 unsafe.ensureClassInitialized(SystemTrayAccessor.class);
1056 }
1057 return systemTrayAccessor;
1058 }
1059
1060 /**
1061 * Set an accessor object for the java.awt.TrayIcon class.
1062 */
1063 public static void setTrayIconAccessor(TrayIconAccessor tia) {
1064 trayIconAccessor = tia;
1065 }
1066
1067 /**
1068 * Retrieve the accessor object for the java.awt.TrayIcon class.
1069 */
1070 public static TrayIconAccessor getTrayIconAccessor() {
1071 if (trayIconAccessor == null) {
1072 unsafe.ensureClassInitialized(TrayIconAccessor.class);
1073 }
1074 return trayIconAccessor;
1075 }
1076
1077 /**
1078 * Set an accessor object for the java.awt.DefaultKeyboardFocusManager class.
1079 */
1080 public static void setDefaultKeyboardFocusManagerAccessor(DefaultKeyboardFocusManagerAccessor dkfma) {
1081 defaultKeyboardFocusManagerAccessor = dkfma;
1082 }
1083
1084 /**
1085 * Retrieve the accessor object for the java.awt.DefaultKeyboardFocusManager class.
1086 */
1087 public static DefaultKeyboardFocusManagerAccessor getDefaultKeyboardFocusManagerAccessor() {
1088 if (defaultKeyboardFocusManagerAccessor == null) {
1089 unsafe.ensureClassInitialized(DefaultKeyboardFocusManagerAccessor.class);
1090 }
1091 return defaultKeyboardFocusManagerAccessor;
1092 }
1093 /*
1094 * Set an accessor object for the java.awt.SequencedEvent class.
1095 */
1096 public static void setSequencedEventAccessor(SequencedEventAccessor sea) {
1097 sequencedEventAccessor = sea;
1098 }
1099
1100 /*
1101 * Get the accessor object for the java.awt.SequencedEvent class.
1102 */
1103 public static SequencedEventAccessor getSequencedEventAccessor() {
1104 // The class is not public. So we can't ensure it's initialized.
1105 // Null returned value means it's not initialized
1106 // (so not a single instance of the event has been created).
1107 return sequencedEventAccessor;
1108 }
1109 }