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