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 sun.misc.Unsafe;
29
30 import java.awt.*;
31 import java.awt.event.InputEvent;
32 import java.awt.geom.Point2D;
33 import java.awt.peer.ComponentPeer;
34 import java.security.AccessControlContext;
35
36 /**
37 * The AWTAccessor utility class.
38 * The main purpose of this class is to enable accessing
39 * private and package-private fields of classes from
40 * different classes/packages. See sun.misc.SharedSecretes
41 * for another example.
42 */
43 public final class AWTAccessor {
44
45 private static final Unsafe unsafe = Unsafe.getUnsafe();
46
47 /*
48 * We don't need any objects of this class.
49 * It's rather a collection of static methods
50 * and interfaces.
51 */
52 private AWTAccessor() {
53 }
54
55 /*
56 * An interface of accessor for the java.awt.Component class.
57 */
58 public interface ComponentAccessor {
59 /*
60 * Sets whether the native background erase for a component
61 * has been disabled via SunToolkit.disableBackgroundErase().
62 */
63 void setBackgroundEraseDisabled(Component comp, boolean disabled);
64 /*
65 * Indicates whether the native background erase for a
66 * component has been disabled via
67 * SunToolkit.disableBackgroundErase().
68 */
69 boolean getBackgroundEraseDisabled(Component comp);
70 /*
71 *
72 * Gets the bounds of this component in the form of a
73 * <code>Rectangle</code> object. The bounds specify this
74 * component's width, height, and location relative to
75 * its parent.
76 */
77 Rectangle getBounds(Component comp);
78 /*
79 * Sets the shape of a lw component to cut out from hw components.
80 *
81 * See 6797587, 6776743, 6768307, and 6768332 for details
82 */
83 void setMixingCutoutShape(Component comp, Shape shape);
84
85 /**
86 * Sets GraphicsConfiguration value for the component.
87 */
88 void setGraphicsConfiguration(Component comp, GraphicsConfiguration gc);
89 /*
90 * Requests focus to the component.
91 */
92 boolean requestFocus(Component comp, CausedFocusEvent.Cause cause);
93 /*
94 * Determines if the component can gain focus.
95 */
96 boolean canBeFocusOwner(Component comp);
97
98 /**
99 * Returns whether the component is visible without invoking
100 * any client code.
101 */
102 boolean isVisible(Component comp);
103
104 /**
105 * Sets the RequestFocusController.
106 */
107 void setRequestFocusController(RequestFocusController requestController);
108
109 /**
110 * Returns the appContext of the component.
111 */
112 AppContext getAppContext(Component comp);
113
114 /**
115 * Sets the appContext of the component.
116 */
117 void setAppContext(Component comp, AppContext appContext);
118
119 /**
120 * Returns the parent of the component.
121 */
122 Container getParent(Component comp);
123
124 /**
125 * Sets the parent of the component to the specified parent.
126 */
127 void setParent(Component comp, Container parent);
128
129 /**
130 * Resizes the component to the specified width and height.
131 */
132 void setSize(Component comp, int width, int height);
133
134 /**
135 * Returns the location of the component.
136 */
137 Point getLocation(Component comp);
138
139 /**
140 * Moves the component to the new location.
141 */
142 void setLocation(Component comp, int x, int y);
143
144 /**
145 * Determines whether this component is enabled.
146 */
147 boolean isEnabled(Component comp);
148
149 /**
150 * Determines whether this component is displayable.
151 */
152 boolean isDisplayable(Component comp);
153
154 /**
155 * Gets the cursor set in the component.
156 */
157 Cursor getCursor(Component comp);
158
159 /**
160 * Returns the peer of the component.
161 */
162 ComponentPeer getPeer(Component comp);
163
164 /**
165 * Sets the peer of the component to the specified peer.
166 */
167 void setPeer(Component comp, ComponentPeer peer);
168
169 /**
170 * Determines whether this component is lightweight.
171 */
172 boolean isLightweight(Component comp);
173
174 /**
175 * Returns whether or not paint messages received from
176 * the operating system should be ignored.
177 */
178 boolean getIgnoreRepaint(Component comp);
179
180 /**
181 * Returns the width of the component.
182 */
183 int getWidth(Component comp);
184
185 /**
186 * Returns the height of the component.
187 */
188 int getHeight(Component comp);
189
190 /**
191 * Returns the x coordinate of the component.
192 */
193 int getX(Component comp);
194
195 /**
196 * Returns the y coordinate of the component.
197 */
198 int getY(Component comp);
199
200 /**
201 * Gets the foreground color of this component.
202 */
203 Color getForeground(Component comp);
204
205 /**
206 * Gets the background color of this component.
207 */
208 Color getBackground(Component comp);
209
210 /**
211 * Sets the background of this component to the specified color.
212 */
213 void setBackground(Component comp, Color background);
214
215 /**
216 * Gets the font of the component.
217 */
218 Font getFont(Component comp);
219
220 /**
221 * Processes events occurring on this component.
222 */
223 void processEvent(Component comp, AWTEvent e);
224
225
226 /*
227 * Returns the acc this component was constructed with.
228 */
229 AccessControlContext getAccessControlContext(Component comp);
230
231 }
232
233 /*
234 * An interface of accessor for the java.awt.Container class.
235 */
236 public interface ContainerAccessor {
237 /**
238 * Validates the container unconditionally.
239 */
240 void validateUnconditionally(Container cont);
241 }
242
243 /*
244 * An interface of accessor for java.awt.Window class.
245 */
246 public interface WindowAccessor {
247 /*
248 * Get opacity level of the given window.
249 */
250 float getOpacity(Window window);
251 /*
252 * Set opacity level to the given window.
253 */
254 void setOpacity(Window window, float opacity);
255 /*
256 * Get a shape assigned to the given window.
257 */
258 Shape getShape(Window window);
259 /*
260 * Set a shape to the given window.
261 */
262 void setShape(Window window, Shape shape);
263 /*
264 * Set the opaque preoperty to the given window.
265 */
266 void setOpaque(Window window, boolean isOpaque);
267 /*
268 * Update the image of a non-opaque (translucent) window.
269 */
270 void updateWindow(Window window);
271
272 /** Get the size of the security warning.
273 */
274 Dimension getSecurityWarningSize(Window w);
275
276 /**
277 * Set the size of the security warning.
278 */
279 void setSecurityWarningSize(Window w, int width, int height);
280
281 /** Set the position of the security warning.
282 */
283 void setSecurityWarningPosition(Window w, Point2D point,
284 float alignmentX, float alignmentY);
285
286 /** Request to recalculate the new position of the security warning for
287 * the given window size/location as reported by the native system.
288 */
289 Point2D calculateSecurityWarningPosition(Window window,
290 double x, double y, double w, double h);
291
292 /** Sets the synchronous status of focus requests on lightweight
293 * components in the specified window to the specified value.
294 */
295 void setLWRequestStatus(Window changed, boolean status);
296
297 /**
298 * Indicates whether this window should receive focus on subsequently
299 * being shown, or being moved to the front.
300 */
301 boolean isAutoRequestFocus(Window w);
302
303 /**
304 * Indicates whether the specified window is an utility window for TrayIcon.
305 */
306 boolean isTrayIconWindow(Window w);
307
308 /**
309 * Marks the specified window as an utility window for TrayIcon.
310 */
311 void setTrayIconWindow(Window w, boolean isTrayIconWindow);
312 }
313
314 /*
315 * An accessor for the AWTEvent class.
316 */
317 public interface AWTEventAccessor {
318 /**
319 * Marks the event as posted.
320 */
321 void setPosted(AWTEvent ev);
322
323 /**
324 * Sets the flag on this AWTEvent indicating that it was
325 * generated by the system.
326 */
327 void setSystemGenerated(AWTEvent ev);
328
329 /**
330 * Indicates whether this AWTEvent was generated by the system.
331 */
332 boolean isSystemGenerated(AWTEvent ev);
333
334
335 /*
336 * Returns the acc this event was constructed with.
337 */
338 AccessControlContext getAccessControlContext(AWTEvent ev);
339
340 }
341
342 public interface InputEventAccessor {
343 /*
344 * Accessor for InputEvent.getButtonDownMasks()
345 */
346 int[] getButtonDownMasks();
347 }
348
349 /*
350 * An accessor for the java.awt.Frame class.
351 */
352 public interface FrameAccessor {
353 /*
354 * Sets the state of this frame.
355 */
356 void setExtendedState(Frame frame, int state);
357 /*
358 * Gets the state of this frame.
359 */
360 int getExtendedState(Frame frame);
361 /*
362 * Gets the maximized bounds of this frame.
363 */
364 Rectangle getMaximizedBounds(Frame frame);
365 }
366
367 /*
368 * An interface of accessor for the java.awt.KeyboardFocusManager class.
369 */
370 public interface KeyboardFocusManagerAccessor {
371 /*
372 * Indicates whether the native implementation should
373 * proceed with a pending focus request for the heavyweight.
374 */
375 int shouldNativelyFocusHeavyweight(Component heavyweight,
376 Component descendant,
377 boolean temporary,
378 boolean focusedWindowChangeAllowed,
379 long time,
380 CausedFocusEvent.Cause cause);
381 /*
382 * Delivers focus for the lightweight descendant of the heavyweight
383 * synchronously.
384 */
385 boolean processSynchronousLightweightTransfer(Component heavyweight,
386 Component descendant,
387 boolean temporary,
388 boolean focusedWindowChangeAllowed,
389 long time);
390 /*
391 * Removes the last focus request for the heavyweight from the queue.
392 */
393 void removeLastFocusRequest(Component heavyweight);
394
395 /*
396 * Sets the most recent focus owner in the window.
397 */
398 void setMostRecentFocusOwner(Window window, Component component);
399 }
400
401 /*
402 * An accessor for the MenuComponent class.
403 */
404 public interface MenuComponentAccessor {
405 /**
406 * Returns the appContext of the menu component.
407 */
408 AppContext getAppContext(MenuComponent menuComp);
409
410 /**
411 * Sets the appContext of the menu component.
412 */
413 void setAppContext(MenuComponent menuComp, AppContext appContext);
414
415 /**
416 * Returns the menu container of the menu component
417 */
418 MenuContainer getParent(MenuComponent menuComp);
419 }
420
421 /*
422 * An accessor for the EventQueue class
423 */
424 public interface EventQueueAccessor {
425 /*
426 * Gets the event dispatch thread.
427 */
428 Thread getDispatchThread(EventQueue eventQueue);
429 /*
430 * Checks if the current thread is EDT for the given EQ.
431 */
432 public boolean isDispatchThreadImpl(EventQueue eventQueue);
433 }
434
435 /*
436 * An accessor for the PopupMenu class
437 */
438 public interface PopupMenuAccessor {
439 /*
440 * Returns whether the popup menu is attached to a tray
441 */
442 boolean isTrayIconPopup(PopupMenu popupMenu);
443 }
444
445 /*
446 * An accessor for the FileDialog class
447 */
448 public interface FileDialogAccessor {
449 /*
450 * Sets the files the user selects
451 */
452 void setFiles(FileDialog fileDialog, String directory, String files[]);
453
454 /*
455 * Sets the file the user selects
456 */
457 void setFile(FileDialog fileDialog, String file);
458
459 /*
460 * Sets the directory the user selects
461 */
462 void setDirectory(FileDialog fileDialog, String directory);
463
464 /*
465 * Returns whether the file dialog allows the multiple file selection.
466 */
467 boolean isMultipleMode(FileDialog fileDialog);
468 }
469
470 /*
471 * An accessor for the ScrollPaneAdjustable class.
472 */
473 public interface ScrollPaneAdjustableAccessor {
474 /*
475 * Sets the value of this scrollbar to the specified value.
476 */
477 void setTypedValue(final ScrollPaneAdjustable adj, final int v,
478 final int type);
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 private static ScrollPaneAdjustableAccessor scrollPaneAdjustableAccessor;
497
498 /*
499 * Set an accessor object for the java.awt.Component class.
500 */
501 public static void setComponentAccessor(ComponentAccessor ca) {
502 componentAccessor = ca;
503 }
504
505 /*
506 * Retrieve the accessor object for the java.awt.Component class.
507 */
508 public static ComponentAccessor getComponentAccessor() {
509 if (componentAccessor == null) {
510 unsafe.ensureClassInitialized(Component.class);
511 }
512
513 return componentAccessor;
514 }
515
516 /*
517 * Set an accessor object for the java.awt.Container class.
518 */
519 public static void setContainerAccessor(ContainerAccessor ca) {
520 containerAccessor = ca;
521 }
522
523 /*
524 * Retrieve the accessor object for the java.awt.Container class.
525 */
526 public static ContainerAccessor getContainerAccessor() {
527 if (containerAccessor == null) {
528 unsafe.ensureClassInitialized(Container.class);
529 }
530
531 return containerAccessor;
532 }
533
534 /*
535 * Set an accessor object for the java.awt.Window class.
536 */
537 public static void setWindowAccessor(WindowAccessor wa) {
538 windowAccessor = wa;
539 }
540
541 /*
542 * Retrieve the accessor object for the java.awt.Window class.
543 */
544 public static WindowAccessor getWindowAccessor() {
545 if (windowAccessor == null) {
546 unsafe.ensureClassInitialized(Window.class);
547 }
548 return windowAccessor;
549 }
550
551 /*
552 * Set an accessor object for the java.awt.AWTEvent class.
553 */
554 public static void setAWTEventAccessor(AWTEventAccessor aea) {
555 awtEventAccessor = aea;
556 }
557
558 /*
559 * Retrieve the accessor object for the java.awt.AWTEvent class.
560 */
561 public static AWTEventAccessor getAWTEventAccessor() {
562 if (awtEventAccessor == null) {
563 unsafe.ensureClassInitialized(AWTEvent.class);
564 }
565 return awtEventAccessor;
566 }
567
568 /*
569 * Set an accessor object for the java.awt.event.InputEvent class.
570 */
571 public static void setInputEventAccessor(InputEventAccessor iea) {
572 inputEventAccessor = iea;
573 }
574
575 /*
576 * Retrieve the accessor object for the java.awt.event.InputEvent class.
577 */
578 public static InputEventAccessor getInputEventAccessor() {
579 if (inputEventAccessor == null) {
580 unsafe.ensureClassInitialized(InputEvent.class);
581 }
582 return inputEventAccessor;
583 }
584
585 /*
586 * Set an accessor object for the java.awt.Frame class.
587 */
588 public static void setFrameAccessor(FrameAccessor fa) {
589 frameAccessor = fa;
590 }
591
592 /*
593 * Retrieve the accessor object for the java.awt.Frame class.
594 */
595 public static FrameAccessor getFrameAccessor() {
596 if (frameAccessor == null) {
597 unsafe.ensureClassInitialized(Frame.class);
598 }
599 return frameAccessor;
600 }
601
602 /*
603 * Set an accessor object for the java.awt.KeyboardFocusManager class.
604 */
605 public static void setKeyboardFocusManagerAccessor(KeyboardFocusManagerAccessor kfma) {
606 kfmAccessor = kfma;
607 }
608
609 /*
610 * Retrieve the accessor object for the java.awt.KeyboardFocusManager class.
611 */
612 public static KeyboardFocusManagerAccessor getKeyboardFocusManagerAccessor() {
613 if (kfmAccessor == null) {
614 unsafe.ensureClassInitialized(KeyboardFocusManager.class);
615 }
616 return kfmAccessor;
617 }
618
619 /*
620 * Set an accessor object for the java.awt.MenuComponent class.
621 */
622 public static void setMenuComponentAccessor(MenuComponentAccessor mca) {
623 menuComponentAccessor = mca;
624 }
625
626 /*
627 * Retrieve the accessor object for the java.awt.MenuComponent class.
628 */
629 public static MenuComponentAccessor getMenuComponentAccessor() {
630 if (menuComponentAccessor == null) {
631 unsafe.ensureClassInitialized(MenuComponent.class);
632 }
633 return menuComponentAccessor;
634 }
635
636 /*
637 * Set an accessor object for the java.awt.EventQueue class.
638 */
639 public static void setEventQueueAccessor(EventQueueAccessor eqa) {
640 eventQueueAccessor = eqa;
641 }
642
643 /*
644 * Retrieve the accessor object for the java.awt.EventQueue class.
645 */
646 public static EventQueueAccessor getEventQueueAccessor() {
647 if (eventQueueAccessor == null) {
648 unsafe.ensureClassInitialized(EventQueue.class);
649 }
650 return eventQueueAccessor;
651 }
652
653 /*
654 * Set an accessor object for the java.awt.PopupMenu class.
655 */
656 public static void setPopupMenuAccessor(PopupMenuAccessor pma) {
657 popupMenuAccessor = pma;
658 }
659
660 /*
661 * Retrieve the accessor object for the java.awt.PopupMenu class.
662 */
663 public static PopupMenuAccessor getPopupMenuAccessor() {
664 if (popupMenuAccessor == null) {
665 unsafe.ensureClassInitialized(PopupMenu.class);
666 }
667 return popupMenuAccessor;
668 }
669
670 /*
671 * Set an accessor object for the java.awt.FileDialog class.
672 */
673 public static void setFileDialogAccessor(FileDialogAccessor fda) {
674 fileDialogAccessor = fda;
675 }
676
677 /*
678 * Retrieve the accessor object for the java.awt.FileDialog class.
679 */
680 public static FileDialogAccessor getFileDialogAccessor() {
681 if (fileDialogAccessor == null) {
682 unsafe.ensureClassInitialized(FileDialog.class);
683 }
684 return fileDialogAccessor;
685 }
686
687 /*
688 * Set an accessor object for the java.awt.ScrollPaneAdjustable class.
689 */
690 public static void setScrollPaneAdjustableAccessor(ScrollPaneAdjustableAccessor adj) {
691 scrollPaneAdjustableAccessor = adj;
692 }
693
694 /*
695 * Retrieve the accessor object for the java.awt.ScrollPaneAdjustable
696 * class.
697 */
698 public static ScrollPaneAdjustableAccessor getScrollPaneAdjustableAccessor() {
699 if (scrollPaneAdjustableAccessor == null) {
700 unsafe.ensureClassInitialized(ScrollPaneAdjustable.class);
701 }
702 return scrollPaneAdjustableAccessor;
703 }
704 }