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