1 /*
   2  * Copyright (c) 2008, 2011, 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 java.awt.*;
  29 import java.awt.KeyboardFocusManager;
  30 import java.awt.event.InputEvent;
  31 import java.awt.geom.Point2D;
  32 import java.awt.image.BufferedImage;
  33 
  34 import sun.misc.Unsafe;
  35 import java.awt.peer.ComponentPeer;
  36 
  37 import java.security.AccessController;
  38 import java.security.AccessControlContext;
  39 
  40 import java.io.File;
  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         /*
 342          * Returns the acc this event was constructed with.
 343          */
 344         AccessControlContext getAccessControlContext(AWTEvent ev);
 345 
 346     }
 347 
 348     public interface InputEventAccessor {
 349         /*
 350          * Accessor for InputEvent.getButtonDownMasks()
 351          */
 352         int[] getButtonDownMasks();
 353     }
 354 
 355     /*
 356      * An accessor for the java.awt.Frame class.
 357      */
 358     public interface FrameAccessor {
 359         /*
 360          * Sets the state of this frame.
 361          */
 362         void setExtendedState(Frame frame, int state);
 363         /*
 364          * Gets the state of this frame.
 365          */
 366        int getExtendedState(Frame frame);
 367         /*
 368          * Gets the maximized bounds of this frame.
 369          */
 370        Rectangle getMaximizedBounds(Frame frame);
 371     }
 372 
 373     /*
 374      * An interface of accessor for the java.awt.KeyboardFocusManager class.
 375      */
 376     public interface KeyboardFocusManagerAccessor {
 377         /*
 378          * Indicates whether the native implementation should
 379          * proceed with a pending focus request for the heavyweight.
 380          */
 381         int shouldNativelyFocusHeavyweight(Component heavyweight,
 382                                            Component descendant,
 383                                            boolean temporary,
 384                                            boolean focusedWindowChangeAllowed,
 385                                            long time,
 386                                            CausedFocusEvent.Cause cause);
 387         /*
 388          * Delivers focus for the lightweight descendant of the heavyweight
 389          * synchronously.
 390          */
 391         boolean processSynchronousLightweightTransfer(Component heavyweight,
 392                                                       Component descendant,
 393                                                       boolean temporary,
 394                                                       boolean focusedWindowChangeAllowed,
 395                                                       long time);
 396         /*
 397          * Removes the last focus request for the heavyweight from the queue.
 398          */
 399         void removeLastFocusRequest(Component heavyweight);
 400 
 401         /*
 402          * Sets the most recent focus owner in the window.
 403          */
 404         void setMostRecentFocusOwner(Window window, Component component);
 405 
 406         /*
 407          * Returns current KFM of the specified AppContext.
 408          */
 409         KeyboardFocusManager getCurrentKeyboardFocusManager(AppContext ctx);
 410     }
 411 
 412     /*
 413      * An accessor for the MenuComponent class.
 414      */
 415     public interface MenuComponentAccessor {
 416         /**
 417          * Returns the appContext of the menu component.
 418          */
 419         AppContext getAppContext(MenuComponent menuComp);
 420 
 421         /**
 422          * Sets the appContext of the menu component.
 423          */
 424         void setAppContext(MenuComponent menuComp, AppContext appContext);
 425 
 426         /**
 427          * Returns the menu container of the menu component
 428          */
 429         MenuContainer getParent(MenuComponent menuComp);
 430     }
 431 
 432     /*
 433      * An accessor for the EventQueue class
 434      */
 435     public interface EventQueueAccessor {
 436         /*
 437          * Gets the event dispatch thread.
 438          */
 439         Thread getDispatchThread(EventQueue eventQueue);
 440         /*
 441          * Checks if the current thread is EDT for the given EQ.
 442          */
 443         public boolean isDispatchThreadImpl(EventQueue eventQueue);
 444     }
 445 
 446     /*
 447      * An accessor for the PopupMenu class
 448      */
 449     public interface PopupMenuAccessor {
 450         /*
 451          * Returns whether the popup menu is attached to a tray
 452          */
 453         boolean isTrayIconPopup(PopupMenu popupMenu);
 454     }
 455 
 456     /*
 457      * An accessor for the FileDialog class
 458      */
 459     public interface FileDialogAccessor {
 460         /*
 461          * Sets the files the user selects
 462          */
 463         void setFiles(FileDialog fileDialog, File files[]);
 464 
 465         /*
 466          * Sets the file the user selects
 467          */
 468         void setFile(FileDialog fileDialog, String file);
 469 
 470         /*
 471          * Sets the directory the user selects
 472          */
 473         void setDirectory(FileDialog fileDialog, String directory);
 474 
 475         /*
 476          * Returns whether the file dialog allows the multiple file selection.
 477          */
 478         boolean isMultipleMode(FileDialog fileDialog);
 479     }
 480 










 481     /*
 482      * Accessor instances are initialized in the static initializers of
 483      * corresponding AWT classes by using setters defined below.
 484      */
 485     private static ComponentAccessor componentAccessor;
 486     private static ContainerAccessor containerAccessor;
 487     private static WindowAccessor windowAccessor;
 488     private static AWTEventAccessor awtEventAccessor;
 489     private static InputEventAccessor inputEventAccessor;
 490     private static FrameAccessor frameAccessor;
 491     private static KeyboardFocusManagerAccessor kfmAccessor;
 492     private static MenuComponentAccessor menuComponentAccessor;
 493     private static EventQueueAccessor eventQueueAccessor;
 494     private static PopupMenuAccessor popupMenuAccessor;
 495     private static FileDialogAccessor fileDialogAccessor;

 496 
 497     /*
 498      * Set an accessor object for the java.awt.Component class.
 499      */
 500     public static void setComponentAccessor(ComponentAccessor ca) {
 501         componentAccessor = ca;
 502     }
 503 
 504     /*
 505      * Retrieve the accessor object for the java.awt.Component class.
 506      */
 507     public static ComponentAccessor getComponentAccessor() {
 508         if (componentAccessor == null) {
 509             unsafe.ensureClassInitialized(Component.class);
 510         }
 511 
 512         return componentAccessor;
 513     }
 514 
 515     /*
 516      * Set an accessor object for the java.awt.Container class.
 517      */
 518     public static void setContainerAccessor(ContainerAccessor ca) {
 519         containerAccessor = ca;
 520     }
 521 
 522     /*
 523      * Retrieve the accessor object for the java.awt.Container class.
 524      */
 525     public static ContainerAccessor getContainerAccessor() {
 526         if (containerAccessor == null) {
 527             unsafe.ensureClassInitialized(Container.class);
 528         }
 529 
 530         return containerAccessor;
 531     }
 532 
 533     /*
 534      * Set an accessor object for the java.awt.Window class.
 535      */
 536     public static void setWindowAccessor(WindowAccessor wa) {
 537         windowAccessor = wa;
 538     }
 539 
 540     /*
 541      * Retrieve the accessor object for the java.awt.Window class.
 542      */
 543     public static WindowAccessor getWindowAccessor() {
 544         if (windowAccessor == null) {
 545             unsafe.ensureClassInitialized(Window.class);
 546         }
 547         return windowAccessor;
 548     }
 549 
 550     /*
 551      * Set an accessor object for the java.awt.AWTEvent class.
 552      */
 553     public static void setAWTEventAccessor(AWTEventAccessor aea) {
 554         awtEventAccessor = aea;
 555     }
 556 
 557     /*
 558      * Retrieve the accessor object for the java.awt.AWTEvent class.
 559      */
 560     public static AWTEventAccessor getAWTEventAccessor() {
 561         if (awtEventAccessor == null) {
 562             unsafe.ensureClassInitialized(AWTEvent.class);
 563         }
 564         return awtEventAccessor;
 565     }
 566 
 567     /*
 568      * Set an accessor object for the java.awt.event.InputEvent class.
 569      */
 570     public static void setInputEventAccessor(InputEventAccessor iea) {
 571         inputEventAccessor = iea;
 572     }
 573 
 574     /*
 575      * Retrieve the accessor object for the java.awt.event.InputEvent class.
 576      */
 577     public static InputEventAccessor getInputEventAccessor() {
 578         if (inputEventAccessor == null) {
 579             unsafe.ensureClassInitialized(InputEvent.class);
 580         }
 581         return inputEventAccessor;
 582     }
 583 
 584     /*
 585      * Set an accessor object for the java.awt.Frame class.
 586      */
 587     public static void setFrameAccessor(FrameAccessor fa) {
 588         frameAccessor = fa;
 589     }
 590 
 591     /*
 592      * Retrieve the accessor object for the java.awt.Frame class.
 593      */
 594     public static FrameAccessor getFrameAccessor() {
 595         if (frameAccessor == null) {
 596             unsafe.ensureClassInitialized(Frame.class);
 597         }
 598         return frameAccessor;
 599     }
 600 
 601     /*
 602      * Set an accessor object for the java.awt.KeyboardFocusManager class.
 603      */
 604     public static void setKeyboardFocusManagerAccessor(KeyboardFocusManagerAccessor kfma) {
 605         kfmAccessor = kfma;
 606     }
 607 
 608     /*
 609      * Retrieve the accessor object for the java.awt.KeyboardFocusManager class.
 610      */
 611     public static KeyboardFocusManagerAccessor getKeyboardFocusManagerAccessor() {
 612         if (kfmAccessor == null) {
 613             unsafe.ensureClassInitialized(KeyboardFocusManager.class);
 614         }
 615         return kfmAccessor;
 616     }
 617 
 618     /*
 619      * Set an accessor object for the java.awt.MenuComponent class.
 620      */
 621     public static void setMenuComponentAccessor(MenuComponentAccessor mca) {
 622         menuComponentAccessor = mca;
 623     }
 624 
 625     /*
 626      * Retrieve the accessor object for the java.awt.MenuComponent class.
 627      */
 628     public static MenuComponentAccessor getMenuComponentAccessor() {
 629         if (menuComponentAccessor == null) {
 630             unsafe.ensureClassInitialized(MenuComponent.class);
 631         }
 632         return menuComponentAccessor;
 633     }
 634 
 635     /*
 636      * Set an accessor object for the java.awt.EventQueue class.
 637      */
 638     public static void setEventQueueAccessor(EventQueueAccessor eqa) {
 639         eventQueueAccessor = eqa;
 640     }
 641 
 642     /*
 643      * Retrieve the accessor object for the java.awt.EventQueue class.
 644      */
 645     public static EventQueueAccessor getEventQueueAccessor() {
 646         if (eventQueueAccessor == null) {
 647             unsafe.ensureClassInitialized(EventQueue.class);
 648         }
 649         return eventQueueAccessor;
 650     }
 651 
 652     /*
 653      * Set an accessor object for the java.awt.PopupMenu class.
 654      */
 655     public static void setPopupMenuAccessor(PopupMenuAccessor pma) {
 656         popupMenuAccessor = pma;
 657     }
 658 
 659     /*
 660      * Retrieve the accessor object for the java.awt.PopupMenu class.
 661      */
 662     public static PopupMenuAccessor getPopupMenuAccessor() {
 663         if (popupMenuAccessor == null) {
 664             unsafe.ensureClassInitialized(PopupMenu.class);
 665         }
 666         return popupMenuAccessor;
 667     }
 668 
 669     /*
 670      * Set an accessor object for the java.awt.FileDialog class.
 671      */
 672     public static void setFileDialogAccessor(FileDialogAccessor fda) {
 673         fileDialogAccessor = fda;
 674     }
 675 
 676     /*
 677      * Retrieve the accessor object for the java.awt.FileDialog class.
 678      */
 679     public static FileDialogAccessor getFileDialogAccessor() {
 680         if (fileDialogAccessor == null) {
 681             unsafe.ensureClassInitialized(FileDialog.class);
 682         }
 683         return fileDialogAccessor;

















 684     }
 685 
 686 }
--- EOF ---