1 /*
2 * Copyright (c) 2011, 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.lwawt;
27
28 import java.awt.*;
29 import java.awt.event.*;
30 import java.awt.image.BufferedImage;
31 import java.awt.peer.*;
32 import java.util.List;
33
34 import javax.swing.*;
35
36 import sun.awt.*;
37 import sun.java2d.*;
38 import sun.java2d.loops.Blit;
39 import sun.java2d.loops.CompositeType;
40 import sun.util.logging.PlatformLogger;
41
42 public class LWWindowPeer
43 extends LWContainerPeer<Window, JComponent>
44 implements WindowPeer, FramePeer, DialogPeer, FullScreenCapable
45 {
46 public static enum PeerType {
47 SIMPLEWINDOW,
48 FRAME,
49 DIALOG,
50 EMBEDDEDFRAME
51 }
52
53 private static final sun.util.logging.PlatformLogger focusLog = PlatformLogger.getLogger("sun.lwawt.focus.LWWindowPeer");
54
55 private PlatformWindow platformWindow;
56
57 // Window bounds reported by the native system (as opposed to
58 // regular bounds inherited from LWComponentPeer which are
59 // requested by user and may haven't been applied yet because
60 // of asynchronous requests to the windowing system)
61 private int sysX;
62 private int sysY;
63 private int sysW;
64 private int sysH;
65
66 private static final int MINIMUM_WIDTH = 1;
67 private static final int MINIMUM_HEIGHT = 1;
68
69 private Insets insets = new Insets(0, 0, 0, 0);
70
71 private int screenOn = -1;
72 private GraphicsConfiguration graphicsConfig;
73
74 private SurfaceData surfaceData;
75 private final Object surfaceDataLock = new Object();
76
77 private int backBufferCount;
78 private BufferCapabilities backBufferCaps;
79
80 // The back buffer is used for two purposes:
81 // 1. To render all the lightweight peers
82 // 2. To provide user with a BufferStrategy
83 // Need to check if a single back buffer can be used for both
84 // TODO: VolatileImage
85 // private VolatileImage backBuffer;
86 private volatile BufferedImage backBuffer;
87
88 private volatile int windowState = Frame.NORMAL;
89
90 // A peer where the last mouse event came to. Used to generate
91 // MOUSE_ENTERED/EXITED notifications and by cursor manager to
92 // find the component under cursor
93 private static volatile LWComponentPeer lastMouseEventPeer = null;
94
95 // Peers where all dragged/released events should come to,
96 // depending on what mouse button is being dragged according to Cocoa
97 private static LWComponentPeer mouseDownTarget[] = new LWComponentPeer[3];
98
99 // A bitmask that indicates what mouse buttons produce MOUSE_CLICKED events
100 // on MOUSE_RELEASE. Click events are only generated if there were no drag
101 // events between MOUSE_PRESSED and MOUSE_RELEASED for particular button
102 private static int mouseClickButtons = 0;
103
104 private volatile boolean cachedFocusableWindow;
105
106 private volatile boolean isOpaque = true;
107
108 private static final Font DEFAULT_FONT = new Font("Lucida Grande", Font.PLAIN, 13);
109
110 private static LWWindowPeer grabbingWindow;
111
112 private volatile boolean skipNextFocusChange;
113
114 /**
115 * Current modal blocker or null.
116 *
117 * Synchronization: peerTreeLock.
118 */
119 private LWWindowPeer blocker;
120
121 public LWWindowPeer(Window target, PlatformComponent platformComponent,
122 PlatformWindow platformWindow)
123 {
124 super(target, platformComponent);
125 this.platformWindow = platformWindow;
126
127 Window owner = target.getOwner();
128 LWWindowPeer ownerPeer = (owner != null) ? (LWWindowPeer)owner.getPeer() : null;
129 PlatformWindow ownerDelegate = (ownerPeer != null) ? ownerPeer.getPlatformWindow() : null;
130
131 // The delegate.initialize() needs a non-null GC on X11.
132 GraphicsConfiguration gc = getTarget().getGraphicsConfiguration();
133 synchronized (getStateLock()) {
134 // graphicsConfig should be updated according to the real window
135 // bounds when the window is shown, see 4868278
136 this.graphicsConfig = gc;
137 }
138
139 if (!target.isFontSet()) {
140 target.setFont(DEFAULT_FONT);
141 }
142
143 if (!target.isBackgroundSet()) {
144 target.setBackground(SystemColor.window);
145 } else {
146 // first we check if user provided alpha for background. This is
147 // similar to what Apple's Java do.
148 // Since JDK7 we should rely on setOpacity() only.
149 // this.opacity = c.getAlpha();
150 // System.out.println("Delegate assigns alpha (we ignore setOpacity()):"
151 // +this.opacity);
152 }
153
154 if (!target.isForegroundSet()) {
155 target.setForeground(SystemColor.windowText);
156 // we should not call setForeground because it will call a repaint
157 // which the peer may not be ready to do yet.
158 }
159
160 platformWindow.initialize(target, this, ownerDelegate);
161 }
162
163 @Override
164 public void initialize() {
165 if (getTarget() instanceof Frame) {
166 setTitle(((Frame)getTarget()).getTitle());
167 setState(((Frame)getTarget()).getExtendedState());
168 } else if (getTarget() instanceof Dialog) {
169 setTitle(((Dialog)getTarget()).getTitle());
170 }
171
172 setAlwaysOnTop(getTarget().isAlwaysOnTop());
173 updateMinimumSize();
174
175 cachedFocusableWindow = getTarget().isFocusableWindow();
176
177 setOpacity(getTarget().getOpacity());
178 setOpaque(getTarget().isOpaque());
179
180 super.initialize();
181
182 updateInsets(platformWindow.getInsets());
183 }
184
185 // Just a helper method
186 public PlatformWindow getPlatformWindow() {
187 return platformWindow;
188 }
189
190 @Override
191 protected LWWindowPeer getWindowPeerOrSelf() {
192 return this;
193 }
194
195 @Override
196 protected void initializeContainerPeer() {
197 // No-op as LWWindowPeer doesn't have any containerPeer
198 }
199
200 // ---- PEER METHODS ---- //
201
202 @Override
203 protected void disposeImpl() {
204 SurfaceData oldData = getSurfaceData();
205 synchronized (surfaceDataLock){
206 surfaceData = null;
207 }
208 if (oldData != null) {
209 oldData.invalidate();
210 }
211 if (isGrabbing()) {
212 ungrab();
213 }
214 destroyBuffers();
215 platformWindow.dispose();
216 super.disposeImpl();
217 }
218
219 @Override
220 public void setVisible(final boolean visible) {
221 if (getSurfaceData() == null) {
222 replaceSurfaceData();
223 }
224
225 if (isVisible() == visible) {
226 return;
227 }
228 super.setVisible(visible);
229
230 // TODO: update graphicsConfig, see 4868278
231 // TODO: don't notify the delegate if our visibility is unchanged
232
233 // it is important to call this method on EDT
234 // to prevent the deadlocks during the painting of the lightweight delegates
235 //TODO: WHY? This is a native-system related call. Perhaps NOT calling
236 // the painting procedure right from the setVisible(), but rather relying
237 // on the native Expose event (or, scheduling the repainting asynchronously)
238 // is better?
239 SwingUtilities.invokeLater(new Runnable() {
240 @Override
241 public void run() {
242 platformWindow.setVisible(visible);
243 if (isSimpleWindow()) {
244 LWKeyboardFocusManagerPeer manager = LWKeyboardFocusManagerPeer.
245 getInstance(getAppContext());
246
247 if (visible) {
248 updateFocusableWindowState();
249 changeFocusedWindow(true, true);
250
251 // Focus the owner in case this window is focused.
252 } else if (manager.getCurrentFocusedWindow() == getTarget()) {
253 LWWindowPeer owner = getOwnerFrameDialog(LWWindowPeer.this);
254 if (owner != null) {
255 // KFM will do all the rest.
256 owner.changeFocusedWindow(true, false);
257 }
258 }
259 }
260 }
261 });
262 }
263
264 @Override
265 public GraphicsConfiguration getGraphicsConfiguration() {
266 return graphicsConfig;
267 }
268
269 @Override
270 public boolean updateGraphicsData(GraphicsConfiguration gc) {
271 setGraphicsConfig(gc);
272 return false;
273 }
274
275 protected final Graphics getOnscreenGraphics(Color fg, Color bg, Font f) {
276 if (getSurfaceData() == null) {
277 return null;
278 }
279 if (fg == null) {
280 fg = SystemColor.windowText;
281 }
282 if (bg == null) {
283 bg = SystemColor.window;
284 }
285 if (f == null) {
286 f = DEFAULT_FONT;
287 }
288 return platformWindow.transformGraphics(new SunGraphics2D(getSurfaceData(), fg, bg, f));
289 }
290
291 @Override
292 public void createBuffers(int numBuffers, BufferCapabilities caps)
293 throws AWTException
294 {
295 try {
296 // Assume this method is never called with numBuffers <= 1, as 0 is
297 // unsupported, and 1 corresponds to a SingleBufferStrategy which
298 // doesn't depend on the peer. Screen is considered as a separate
299 // "buffer", that's why numBuffers - 1
300 assert numBuffers > 1;
301
302 replaceSurfaceData(numBuffers - 1, caps);
303 } catch (InvalidPipeException z) {
304 throw new AWTException(z.toString());
305 }
306 }
307
308 @Override
309 public final Image getBackBuffer() {
310 synchronized (getStateLock()) {
311 return backBuffer;
312 }
313 }
314
315 @Override
316 public void flip(int x1, int y1, int x2, int y2,
317 BufferCapabilities.FlipContents flipAction)
318 {
319 //Note: constraints must be applied. see applyConstrain().
320 platformWindow.flip(x1, y1, x2, y2, flipAction);
321 }
322
323 @Override
324 public final void destroyBuffers() {
325 final Image oldBB = getBackBuffer();
326 synchronized (getStateLock()) {
327 backBuffer = null;
328 }
329 if (oldBB != null) {
330 oldBB.flush();
331 }
332 }
333
334 @Override
335 public void setBounds(int x, int y, int w, int h, int op) {
336 if ((op & SET_CLIENT_SIZE) != 0) {
337 // SET_CLIENT_SIZE is only applicable to window peers, so handle it here
338 // instead of pulling 'insets' field up to LWComponentPeer
339 // no need to add insets since Window's notion of width and height includes insets.
340 op &= ~SET_CLIENT_SIZE;
341 op |= SET_SIZE;
342 }
343
344 if (w < MINIMUM_WIDTH) {
345 w = MINIMUM_WIDTH;
346 }
347 if (h < MINIMUM_HEIGHT) {
348 h = MINIMUM_HEIGHT;
349 }
350
351 // Don't post ComponentMoved/Resized and Paint events
352 // until we've got a notification from the delegate
353 setBounds(x, y, w, h, op, false, false);
354 // Get updated bounds, so we don't have to handle 'op' here manually
355 Rectangle r = getBounds();
356 platformWindow.setBounds(r.x, r.y, r.width, r.height);
357 }
358
359 @Override
360 public Point getLocationOnScreen() {
361 return platformWindow.getLocationOnScreen();
362 }
363
364 /**
365 * Overridden from LWContainerPeer to return the correct insets.
366 * Insets are queried from the delegate and are kept up to date by
367 * requiering when needed (i.e. when the window geometry is changed).
368 */
369 @Override
370 public Insets getInsets() {
371 synchronized (getStateLock()) {
372 return insets;
373 }
374 }
375
376 @Override
377 public FontMetrics getFontMetrics(Font f) {
378 // TODO: check for "use platform metrics" settings
379 return platformWindow.getFontMetrics(f);
380 }
381
382 @Override
383 public void toFront() {
384 platformWindow.toFront();
385 }
386
387 @Override
388 public void toBack() {
389 platformWindow.toBack();
390 }
391
392 @Override
393 public void setZOrder(ComponentPeer above) {
394 throw new RuntimeException("not implemented");
395 }
396
397 @Override
398 public void setAlwaysOnTop(boolean value) {
399 platformWindow.setAlwaysOnTop(value);
400 }
401
402 @Override
403 public void updateFocusableWindowState() {
404 cachedFocusableWindow = getTarget().isFocusableWindow();
405 platformWindow.updateFocusableWindowState();
406 }
407
408 @Override
409 public void setModalBlocked(Dialog blocker, boolean blocked) {
410 synchronized (getPeerTreeLock()) {
411 if(blocked && blocker.getPeer() instanceof LWWindowPeer) {
412 this.blocker = (LWWindowPeer)blocker.getPeer();
413 } else {
414 this.blocker = null;
415 }
416 }
417 }
418
419 @Override
420 public void updateMinimumSize() {
421 Dimension d = null;
422 if (getTarget().isMinimumSizeSet()) {
423 d = getTarget().getMinimumSize();
424 }
425 if (d == null) {
426 d = new Dimension(MINIMUM_WIDTH, MINIMUM_HEIGHT);
427 }
428 platformWindow.setMinimumSize(d.width, d.height);
429 }
430
431 @Override
432 public void updateIconImages() {
433 getPlatformWindow().updateIconImages();
434 }
435
436 @Override
437 public void setOpacity(float opacity) {
438 getPlatformWindow().setOpacity(opacity);
439 repaintPeer();
440 }
441
442 @Override
443 public final void setOpaque(final boolean isOpaque) {
444 if (this.isOpaque != isOpaque) {
445 this.isOpaque = isOpaque;
446 getPlatformWindow().setOpaque(isOpaque);
447 replaceSurfaceData();
448 repaintPeer();
449 }
450 }
451
452 public final boolean isOpaque() {
453 return isOpaque;
454 }
455
456 @Override
457 public void updateWindow() {
458 flushOffscreenGraphics();
459 }
460
461 @Override
462 public void repositionSecurityWarning() {
463 throw new RuntimeException("not implemented");
464 }
465
466 // ---- FRAME PEER METHODS ---- //
467
468 @Override // FramePeer and DialogPeer
469 public void setTitle(String title) {
470 platformWindow.setTitle(title == null ? "" : title);
471 }
472
473 @Override
474 public void setMenuBar(MenuBar mb) {
475 platformWindow.setMenuBar(mb);
476 }
477
478 @Override // FramePeer and DialogPeer
479 public void setResizable(boolean resizable) {
480 platformWindow.setResizable(resizable);
481 }
482
483 @Override
484 public void setState(int state) {
485 platformWindow.setWindowState(state);
486 }
487
488 @Override
489 public int getState() {
490 return windowState;
491 }
492
493 @Override
494 public void setMaximizedBounds(Rectangle bounds) {
495 // TODO: not implemented
496 }
497
498 @Override
499 public void setBoundsPrivate(int x, int y, int width, int height) {
500 setBounds(x, y, width, height, SET_BOUNDS | NO_EMBEDDED_CHECK);
501 }
502
503 @Override
504 public Rectangle getBoundsPrivate() {
505 throw new RuntimeException("not implemented");
506 }
507
508 // ---- DIALOG PEER METHODS ---- //
509
510 @Override
511 public void blockWindows(List<Window> windows) {
512 //TODO: LWX will probably need some collectJavaToplevels to speed this up
513 for (Window w : windows) {
514 WindowPeer wp = (WindowPeer)w.getPeer();
515 if (wp != null) {
516 wp.setModalBlocked((Dialog)getTarget(), true);
517 }
518 }
519 }
520
521 // ---- PEER NOTIFICATIONS ---- //
522
523 public void notifyIconify(boolean iconify) {
524 //The toplevel target is Frame and states are applicable to it.
525 //Otherwise, the target is Window and it don't have state property.
526 //Hopefully, no such events are posted in the queue so consider the
527 //target as Frame in all cases.
528
529 // REMIND: should we send it anyway if the state not changed since last
530 // time?
531 WindowEvent iconifyEvent = new WindowEvent(getTarget(),
532 iconify ? WindowEvent.WINDOW_ICONIFIED
533 : WindowEvent.WINDOW_DEICONIFIED);
534 postEvent(iconifyEvent);
535
536 int newWindowState = iconify ? Frame.ICONIFIED : Frame.NORMAL;
537 postWindowStateChangedEvent(newWindowState);
538
539 // REMIND: RepaintManager doesn't repaint iconified windows and
540 // hence ignores any repaint request during deiconification.
541 // So, we need to repaint window explicitly when it becomes normal.
542 if (!iconify) {
543 repaintPeer();
544 }
545 }
546
547 public void notifyZoom(boolean isZoomed) {
548 int newWindowState = isZoomed ? Frame.MAXIMIZED_BOTH : Frame.NORMAL;
549 postWindowStateChangedEvent(newWindowState);
550 }
551
552 /**
553 * Called by the delegate when any part of the window should be repainted.
554 */
555 public void notifyExpose(final int x, final int y, final int w, final int h) {
556 // TODO: there's a serious problem with Swing here: it handles
557 // the exposition internally, so SwingPaintEventDispatcher always
558 // return null from createPaintEvent(). However, we flush the
559 // back buffer here unconditionally, so some flickering may appear.
560 // A possible solution is to split postPaintEvent() into two parts,
561 // and override that part which is only called after if
562 // createPaintEvent() returned non-null value and flush the buffer
563 // from the overridden method
564 flushOnscreenGraphics();
565 repaintPeer(new Rectangle(x, y, w, h));
566 }
567
568 /**
569 * Called by the delegate when this window is moved/resized by user.
570 * There's no notifyReshape() in LWComponentPeer as the only
571 * components which could be resized by user are top-level windows.
572 */
573 public final void notifyReshape(int x, int y, int w, int h) {
574 boolean moved = false;
575 boolean resized = false;
576 synchronized (getStateLock()) {
577 moved = (x != sysX) || (y != sysY);
578 resized = (w != sysW) || (h != sysH);
579 sysX = x;
580 sysY = y;
581 sysW = w;
582 sysH = h;
583 }
584
585 // Check if anything changed
586 if (!moved && !resized) {
587 return;
588 }
589 // First, update peer's bounds
590 setBounds(x, y, w, h, SET_BOUNDS, false, false);
591
592 // Second, update the graphics config and surface data
593 checkIfOnNewScreen();
594 if (resized) {
595 replaceSurfaceData();
596 flushOnscreenGraphics();
597 }
598
599 // Third, COMPONENT_MOVED/COMPONENT_RESIZED events
600 if (moved) {
601 handleMove(x, y, true);
602 }
603 if (resized) {
604 handleResize(w, h,true);
605 }
606 }
607
608 private void clearBackground(final int w, final int h) {
609 final Graphics g = getOnscreenGraphics(getForeground(), getBackground(),
610 getFont());
611 if (g != null) {
612 try {
613 g.clearRect(0, 0, w, h);
614 } finally {
615 g.dispose();
616 }
617 }
618 }
619
620 public void notifyUpdateCursor() {
621 getLWToolkit().getCursorManager().updateCursorLater(this);
622 }
623
624 public void notifyActivation(boolean activation) {
625 changeFocusedWindow(activation, false);
626 }
627
628 // MouseDown in non-client area
629 public void notifyNCMouseDown() {
630 // Ungrab except for a click on a Dialog with the grabbing owner
631 if (grabbingWindow != null &&
632 grabbingWindow != getOwnerFrameDialog(this))
633 {
634 grabbingWindow.ungrab();
635 }
636 }
637
638 // ---- EVENTS ---- //
639
640 /*
641 * Called by the delegate to dispatch the event to Java. Event
642 * coordinates are relative to non-client window are, i.e. the top-left
643 * point of the client area is (insets.top, insets.left).
644 */
645 public void dispatchMouseEvent(int id, long when, int button,
646 int x, int y, int screenX, int screenY,
647 int modifiers, int clickCount, boolean popupTrigger,
648 byte[] bdata)
649 {
650 // TODO: fill "bdata" member of AWTEvent
651 Rectangle r = getBounds();
652 // findPeerAt() expects parent coordinates
653 LWComponentPeer targetPeer = findPeerAt(r.x + x, r.y + y);
654 LWWindowPeer lastWindowPeer =
655 (lastMouseEventPeer != null) ? lastMouseEventPeer.getWindowPeerOrSelf() : null;
656 LWWindowPeer curWindowPeer =
657 (targetPeer != null) ? targetPeer.getWindowPeerOrSelf() : null;
658
659 if (id == MouseEvent.MOUSE_EXITED) {
660 // Sometimes we may get MOUSE_EXITED after lastMouseEventPeer is switched
661 // to a peer from another window. So we must first check if this peer is
662 // the same as lastWindowPeer
663 if (lastWindowPeer == this) {
664 if (isEnabled()) {
665 Point lp = lastMouseEventPeer.windowToLocal(x, y,
666 lastWindowPeer);
667 postEvent(new MouseEvent(lastMouseEventPeer.getTarget(),
668 MouseEvent.MOUSE_EXITED, when,
669 modifiers, lp.x, lp.y, screenX,
670 screenY, clickCount, popupTrigger,
671 button));
672 }
673 lastMouseEventPeer = null;
674 }
675 } else {
676 if (targetPeer != lastMouseEventPeer) {
677 // lastMouseEventPeer may be null if mouse was out of Java windows
678 if (lastMouseEventPeer != null && lastMouseEventPeer.isEnabled()) {
679 // Sometimes, MOUSE_EXITED is not sent by delegate (or is sent a bit
680 // later), in which case lastWindowPeer is another window
681 if (lastWindowPeer != this) {
682 Point oldp = lastMouseEventPeer.windowToLocal(x, y, lastWindowPeer);
683 // Additionally translate from this to lastWindowPeer coordinates
684 Rectangle lr = lastWindowPeer.getBounds();
685 oldp.x += r.x - lr.x;
686 oldp.y += r.y - lr.y;
687 postEvent(new MouseEvent(lastMouseEventPeer.getTarget(),
688 MouseEvent.MOUSE_EXITED,
689 when, modifiers,
690 oldp.x, oldp.y, screenX, screenY,
691 clickCount, popupTrigger, button));
692 } else {
693 Point oldp = lastMouseEventPeer.windowToLocal(x, y, this);
694 postEvent(new MouseEvent(lastMouseEventPeer.getTarget(),
695 MouseEvent.MOUSE_EXITED,
696 when, modifiers,
697 oldp.x, oldp.y, screenX, screenY,
698 clickCount, popupTrigger, button));
699 }
700 }
701 lastMouseEventPeer = targetPeer;
702 if (targetPeer != null && targetPeer.isEnabled() && id != MouseEvent.MOUSE_ENTERED) {
703 Point newp = targetPeer.windowToLocal(x, y, curWindowPeer);
704 postEvent(new MouseEvent(targetPeer.getTarget(),
705 MouseEvent.MOUSE_ENTERED,
706 when, modifiers,
707 newp.x, newp.y, screenX, screenY,
708 clickCount, popupTrigger, button));
709 }
710 }
711 // TODO: fill "bdata" member of AWTEvent
712
713 int eventButtonMask = (button > 0)? MouseEvent.getMaskForButton(button) : 0;
714 int otherButtonsPressed = modifiers & ~eventButtonMask;
715
716 // For pressed/dragged/released events OS X treats other
717 // mouse buttons as if they were BUTTON2, so we do the same
718 int targetIdx = (button > 3) ? MouseEvent.BUTTON2 - 1 : button - 1;
719
720 // MOUSE_ENTERED/EXITED are generated for the components strictly under
721 // mouse even when dragging. That's why we first update lastMouseEventPeer
722 // based on initial targetPeer value and only then recalculate targetPeer
723 // for MOUSE_DRAGGED/RELEASED events
724 if (id == MouseEvent.MOUSE_PRESSED) {
725
726 // Ungrab only if this window is not an owned window of the grabbing one.
727 if (!isGrabbing() && grabbingWindow != null &&
728 grabbingWindow != getOwnerFrameDialog(this))
729 {
730 grabbingWindow.ungrab();
731 }
732 if (otherButtonsPressed == 0) {
733 mouseClickButtons = eventButtonMask;
734 } else {
735 mouseClickButtons |= eventButtonMask;
736 }
737
738 mouseDownTarget[targetIdx] = targetPeer;
739 } else if (id == MouseEvent.MOUSE_DRAGGED) {
740 // Cocoa dragged event has the information about which mouse
741 // button is being dragged. Use it to determine the peer that
742 // should receive the dragged event.
743 targetPeer = mouseDownTarget[targetIdx];
744 mouseClickButtons &= ~modifiers;
745 } else if (id == MouseEvent.MOUSE_RELEASED) {
746 // TODO: currently, mouse released event goes to the same component
747 // that received corresponding mouse pressed event. For most cases,
748 // it's OK, however, we need to make sure that our behavior is consistent
749 // with 1.6 for cases where component in question have been
750 // hidden/removed in between of mouse pressed/released events.
751 targetPeer = mouseDownTarget[targetIdx];
752
753 if ((modifiers & eventButtonMask) == 0) {
754 mouseDownTarget[targetIdx] = null;
755 }
756
757 // mouseClickButtons is updated below, after MOUSE_CLICK is sent
758 }
759
760 // check if we receive mouseEvent from outside the window's bounds
761 // it can be either mouseDragged or mouseReleased
762 if (curWindowPeer == null) {
763 //TODO This can happen if this window is invisible. this is correct behavior in this case?
764 curWindowPeer = this;
765 }
766 if (targetPeer == null) {
767 //TODO This can happen if this window is invisible. this is correct behavior in this case?
768 targetPeer = this;
769 }
770
771
772 Point lp = targetPeer.windowToLocal(x, y, curWindowPeer);
773 if (targetPeer.isEnabled()) {
774 MouseEvent event = new MouseEvent(targetPeer.getTarget(), id,
775 when, modifiers, lp.x, lp.y,
776 screenX, screenY, clickCount,
777 popupTrigger, button);
778 postEvent(event);
779 }
780
781 if (id == MouseEvent.MOUSE_RELEASED) {
782 if ((mouseClickButtons & eventButtonMask) != 0
783 && targetPeer.isEnabled()) {
784 postEvent(new MouseEvent(targetPeer.getTarget(),
785 MouseEvent.MOUSE_CLICKED,
786 when, modifiers,
787 lp.x, lp.y, screenX, screenY,
788 clickCount, popupTrigger, button));
789 }
790 mouseClickButtons &= ~eventButtonMask;
791 }
792
793 notifyUpdateCursor();
794 }
795 }
796
797 public void dispatchMouseWheelEvent(long when, int x, int y, int modifiers,
798 int scrollType, int scrollAmount,
799 int wheelRotation, double preciseWheelRotation,
800 byte[] bdata)
801 {
802 // TODO: could we just use the last mouse event target here?
803 Rectangle r = getBounds();
804 // findPeerAt() expects parent coordinates
805 final LWComponentPeer targetPeer = findPeerAt(r.x + x, r.y + y);
806 if (targetPeer == null || !targetPeer.isEnabled()) {
807 return;
808 }
809
810 Point lp = targetPeer.windowToLocal(x, y, this);
811 // TODO: fill "bdata" member of AWTEvent
812 // TODO: screenX/screenY
813 postEvent(new MouseWheelEvent(targetPeer.getTarget(),
814 MouseEvent.MOUSE_WHEEL,
815 when, modifiers,
816 lp.x, lp.y,
817 0, 0, /* screenX, Y */
818 0 /* clickCount */, false /* popupTrigger */,
819 scrollType, scrollAmount,
820 wheelRotation, preciseWheelRotation));
821 }
822
823 /*
824 * Called by the delegate when a key is pressed.
825 */
826 public void dispatchKeyEvent(int id, long when, int modifiers,
827 int keyCode, char keyChar, int keyLocation)
828 {
829 LWComponentPeer focusOwner =
830 LWKeyboardFocusManagerPeer.getInstance(getAppContext()).
831 getFocusOwner();
832
833 // Null focus owner may receive key event when
834 // application hides the focused window upon ESC press
835 // (AWT transfers/clears the focus owner) and pending ESC release
836 // may come to already hidden window. This check eliminates NPE.
837 if (focusOwner != null) {
838 KeyEvent event =
839 new KeyEvent(focusOwner.getTarget(), id, when, modifiers,
840 keyCode, keyChar, keyLocation);
841 focusOwner.postEvent(event);
842 }
843 }
844
845
846 // ---- UTILITY METHODS ---- //
847
848 private void postWindowStateChangedEvent(int newWindowState) {
849 if (getTarget() instanceof Frame) {
850 AWTAccessor.getFrameAccessor().setExtendedState(
851 (Frame)getTarget(), newWindowState);
852 }
853 WindowEvent stateChangedEvent = new WindowEvent(getTarget(),
854 WindowEvent.WINDOW_STATE_CHANGED,
855 windowState, newWindowState);
856 postEvent(stateChangedEvent);
857 windowState = newWindowState;
858 }
859
860 private static int getGraphicsConfigScreen(GraphicsConfiguration gc) {
861 // TODO: this method can be implemented in a more
862 // efficient way by forwarding to the delegate
863 GraphicsDevice gd = gc.getDevice();
864 GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
865 GraphicsDevice[] gds = ge.getScreenDevices();
866 for (int i = 0; i < gds.length; i++) {
867 if (gds[i] == gd) {
868 return i;
869 }
870 }
871 // Should never happen if gc is a screen device config
872 return 0;
873 }
874
875 private static GraphicsConfiguration getScreenGraphicsConfig(int screen) {
876 GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
877 GraphicsDevice[] gds = ge.getScreenDevices();
878 if (screen >= gds.length) {
879 // This could happen during device addition/removal. Use
880 // the default screen device in this case
881 return ge.getDefaultScreenDevice().getDefaultConfiguration();
882 }
883 return gds[screen].getDefaultConfiguration();
884 }
885
886 /*
887 * This method is called when window's graphics config is changed from
888 * the app code (e.g. when the window is made non-opaque) or when
889 * the window is moved to another screen by user.
890 *
891 * Returns true if the graphics config has been changed, false otherwise.
892 */
893 private boolean setGraphicsConfig(GraphicsConfiguration gc) {
894 synchronized (getStateLock()) {
895 if (graphicsConfig == gc) {
896 return false;
897 }
898 // If window's graphics config is changed from the app code, the
899 // config correspond to the same device as before; when the window
900 // is moved by user, screenOn is updated in checkIfOnNewScreen().
901 // In either case, there's nothing to do with screenOn here
902 graphicsConfig = gc;
903 }
904 // SurfaceData is replaced later in updateGraphicsData()
905 return true;
906 }
907
908 private void checkIfOnNewScreen() {
909 int windowScreen = platformWindow.getScreenImOn();
910 synchronized (getStateLock()) {
911 if (windowScreen == screenOn) {
912 return;
913 }
914 screenOn = windowScreen;
915 }
916
917 // TODO: DisplayChangedListener stuff
918 final GraphicsConfiguration newGC = getScreenGraphicsConfig(windowScreen);
919 if (!setGraphicsConfig(newGC)) return;
920
921 SunToolkit.executeOnEventHandlerThread(getTarget(), new Runnable() {
922 public void run() {
923 AWTAccessor.getComponentAccessor().setGraphicsConfiguration(getTarget(), newGC);
924 }
925 });
926 }
927
928 /**
929 * This method returns a back buffer Graphics to render all the
930 * peers to. After the peer is painted, the back buffer contents
931 * should be flushed to the screen. All the target painting
932 * (Component.paint() method) should be done directly to the screen.
933 */
934 protected final Graphics getOffscreenGraphics(Color fg, Color bg, Font f) {
935 final Image bb = getBackBuffer();
936 if (bb == null) {
937 return null;
938 }
939 if (fg == null) {
940 fg = SystemColor.windowText;
941 }
942 if (bg == null) {
943 bg = SystemColor.window;
944 }
945 if (f == null) {
946 f = DEFAULT_FONT;
947 }
948 final Graphics2D g = (Graphics2D) bb.getGraphics();
949 if (g != null) {
950 g.setColor(fg);
951 g.setBackground(bg);
952 g.setFont(f);
953 }
954 return g;
955 }
956
957 /*
958 * May be called by delegate to provide SD to Java2D code.
959 */
960 public SurfaceData getSurfaceData() {
961 synchronized (surfaceDataLock) {
962 return surfaceData;
963 }
964 }
965
966 private void replaceSurfaceData() {
967 replaceSurfaceData(backBufferCount, backBufferCaps);
968 }
969
970 private void replaceSurfaceData(int newBackBufferCount,
971 BufferCapabilities newBackBufferCaps) {
972 synchronized (surfaceDataLock) {
973 final SurfaceData oldData = getSurfaceData();
974 surfaceData = platformWindow.replaceSurfaceData();
975 // TODO: volatile image
976 // VolatileImage oldBB = backBuffer;
977 BufferedImage oldBB = backBuffer;
978 backBufferCount = newBackBufferCount;
979 backBufferCaps = newBackBufferCaps;
980 final Rectangle size = getSize();
981 if (getSurfaceData() != null && oldData != getSurfaceData()) {
982 clearBackground(size.width, size.height);
983 }
984 blitSurfaceData(oldData, getSurfaceData());
985
986 if (oldData != null && oldData != getSurfaceData()) {
987 // TODO: drop oldData for D3D/WGL pipelines
988 // This can only happen when this peer is being created
989 oldData.flush();
990 }
991
992 // TODO: volatile image
993 // backBuffer = (VolatileImage)delegate.createBackBuffer();
994 backBuffer = (BufferedImage) platformWindow.createBackBuffer();
995 if (backBuffer != null) {
996 Graphics g = backBuffer.getGraphics();
997 try {
998 Rectangle r = getBounds();
999 g.setColor(getBackground());
1000 g.fillRect(0, 0, r.width, r.height);
1001 if (oldBB != null) {
1002 // Draw the old back buffer to the new one
1003 g.drawImage(oldBB, 0, 0, null);
1004 oldBB.flush();
1005 }
1006 } finally {
1007 g.dispose();
1008 }
1009 }
1010 }
1011 }
1012
1013 private void blitSurfaceData(final SurfaceData src, final SurfaceData dst) {
1014 //TODO blit. proof-of-concept
1015 if (src != dst && src != null && dst != null
1016 && !(dst instanceof NullSurfaceData)
1017 && !(src instanceof NullSurfaceData)
1018 && src.getSurfaceType().equals(dst.getSurfaceType())) {
1019 final Rectangle size = getSize();
1020 final Blit blit = Blit.locate(src.getSurfaceType(),
1021 CompositeType.Src,
1022 dst.getSurfaceType());
1023 if (blit != null) {
1024 blit.Blit(src, dst, ((Graphics2D) getGraphics()).getComposite(),
1025 getRegion(), 0, 0, 0, 0, size.width, size.height);
1026 }
1027 }
1028 }
1029
1030 public int getBackBufferCount() {
1031 return backBufferCount;
1032 }
1033
1034 public BufferCapabilities getBackBufferCaps() {
1035 return backBufferCaps;
1036 }
1037
1038 /*
1039 * Request the window insets from the delegate and compares it
1040 * with the current one. This method is mostly called by the
1041 * delegate, e.g. when the window state is changed and insets
1042 * should be recalculated.
1043 *
1044 * This method may be called on the toolkit thread.
1045 */
1046 public boolean updateInsets(Insets newInsets) {
1047 boolean changed = false;
1048 synchronized (getStateLock()) {
1049 changed = (insets.equals(newInsets));
1050 insets = newInsets;
1051 }
1052
1053 if (changed) {
1054 replaceSurfaceData();
1055 repaintPeer();
1056 }
1057
1058 return changed;
1059 }
1060
1061 public static LWWindowPeer getWindowUnderCursor() {
1062 return lastMouseEventPeer != null ? lastMouseEventPeer.getWindowPeerOrSelf() : null;
1063 }
1064
1065 public boolean requestWindowFocus(CausedFocusEvent.Cause cause) {
1066 if (focusLog.isLoggable(PlatformLogger.FINE)) {
1067 focusLog.fine("requesting native focus to " + this);
1068 }
1069
1070 if (!focusAllowedFor()) {
1071 focusLog.fine("focus is not allowed");
1072 return false;
1073 }
1074
1075 if (platformWindow.rejectFocusRequest(cause)) {
1076 return false;
1077 }
1078
1079 Window currentActive = KeyboardFocusManager.
1080 getCurrentKeyboardFocusManager().getActiveWindow();
1081
1082 // Make the owner active window.
1083 if (isSimpleWindow()) {
1084 LWWindowPeer owner = getOwnerFrameDialog(this);
1085
1086 // If owner is not natively active, request native
1087 // activation on it w/o sending events up to java.
1088 if (owner != null && !owner.platformWindow.isActive()) {
1089 if (focusLog.isLoggable(PlatformLogger.FINE)) {
1090 focusLog.fine("requesting native focus to the owner " + owner);
1091 }
1092 LWWindowPeer currentActivePeer = (currentActive != null ?
1093 (LWWindowPeer)currentActive.getPeer() : null);
1094
1095 // Ensure the opposite is natively active and suppress sending events.
1096 if (currentActivePeer != null && currentActivePeer.platformWindow.isActive()) {
1097 if (focusLog.isLoggable(PlatformLogger.FINE)) {
1098 focusLog.fine("the opposite is " + currentActivePeer);
1099 }
1100 currentActivePeer.skipNextFocusChange = true;
1101 }
1102 owner.skipNextFocusChange = true;
1103
1104 owner.platformWindow.requestWindowFocus();
1105 }
1106
1107 // DKFM will synthesize all the focus/activation events correctly.
1108 changeFocusedWindow(true, false);
1109 return true;
1110
1111 // In case the toplevel is active but not focused, change focus directly,
1112 // as requesting native focus on it will not have effect.
1113 } else if (getTarget() == currentActive && !getTarget().hasFocus()) {
1114
1115 changeFocusedWindow(true, false);
1116 return true;
1117 }
1118 return platformWindow.requestWindowFocus();
1119 }
1120
1121 private boolean focusAllowedFor() {
1122 Window window = getTarget();
1123 // TODO: check if modal blocked
1124 return window.isVisible() && window.isEnabled() && window.isFocusableWindow();
1125 }
1126
1127 public boolean isSimpleWindow() {
1128 Window window = getTarget();
1129 return !(window instanceof Dialog || window instanceof Frame);
1130 }
1131
1132 /*
1133 * "Delegates" the responsibility of managing focus to keyboard focus manager.
1134 */
1135 private void changeFocusedWindow(boolean becomesFocused, boolean isShowing) {
1136 if (focusLog.isLoggable(PlatformLogger.FINE)) {
1137 focusLog.fine((becomesFocused?"gaining":"loosing") + " focus window: " + this);
1138 }
1139 if (isShowing && !getTarget().isAutoRequestFocus() || skipNextFocusChange) {
1140 focusLog.fine("skipping focus change");
1141 skipNextFocusChange = false;
1142 return;
1143 }
1144
1145 if (!cachedFocusableWindow) {
1146 return;
1147 }
1148 if (becomesFocused) {
1149 synchronized (getPeerTreeLock()) {
1150 if (blocker != null) {
1151 if (focusLog.isLoggable(PlatformLogger.FINEST)) {
1152 focusLog.finest("the window is blocked by " + blocker);
1153 }
1154 return;
1155 }
1156 }
1157 }
1158
1159 LWKeyboardFocusManagerPeer manager = LWKeyboardFocusManagerPeer.
1160 getInstance(getAppContext());
1161
1162 Window oppositeWindow = becomesFocused ? manager.getCurrentFocusedWindow() : null;
1163
1164 // Note, the method is not called:
1165 // - when the opposite (gaining focus) window is an owned/owner window.
1166 // - for a simple window in any case.
1167 if (!becomesFocused &&
1168 (isGrabbing() || getOwnerFrameDialog(grabbingWindow) == this))
1169 {
1170 focusLog.fine("ungrabbing on " + grabbingWindow);
1171 // ungrab a simple window if its owner looses activation.
1172 grabbingWindow.ungrab();
1173 }
1174
1175 manager.setFocusedWindow(becomesFocused ? LWWindowPeer.this : null);
1176
1177 int eventID = becomesFocused ? WindowEvent.WINDOW_GAINED_FOCUS : WindowEvent.WINDOW_LOST_FOCUS;
1178 WindowEvent windowEvent = new WindowEvent(getTarget(), eventID, oppositeWindow);
1179
1180 // TODO: wrap in SequencedEvent
1181 postEvent(windowEvent);
1182 }
1183
1184 private static LWWindowPeer getOwnerFrameDialog(LWWindowPeer peer) {
1185 Window owner = (peer != null ? peer.getTarget().getOwner() : null);
1186 while (owner != null && !(owner instanceof Frame || owner instanceof Dialog)) {
1187 owner = owner.getOwner();
1188 }
1189 return owner != null ? (LWWindowPeer)owner.getPeer() : null;
1190 }
1191
1192 /**
1193 * Returns the foremost modal blocker of this window, or null.
1194 */
1195 public LWWindowPeer getBlocker() {
1196 synchronized (getPeerTreeLock()) {
1197 LWWindowPeer blocker = this.blocker;
1198 if (blocker == null) {
1199 return null;
1200 }
1201 while (blocker.blocker != null) {
1202 blocker = blocker.blocker;
1203 }
1204 return blocker;
1205 }
1206 }
1207
1208 public void enterFullScreenMode() {
1209 platformWindow.enterFullScreenMode();
1210 }
1211
1212 public void exitFullScreenMode() {
1213 platformWindow.exitFullScreenMode();
1214 }
1215
1216 public long getLayerPtr() {
1217 return getPlatformWindow().getLayerPtr();
1218 }
1219
1220 void grab() {
1221 if (grabbingWindow != null && !isGrabbing()) {
1222 grabbingWindow.ungrab();
1223 }
1224 grabbingWindow = this;
1225 }
1226
1227 void ungrab() {
1228 if (isGrabbing()) {
1229 grabbingWindow = null;
1230 postEvent(new UngrabEvent(getTarget()));
1231 }
1232 }
1233
1234 private boolean isGrabbing() {
1235 return this == grabbingWindow;
1236 }
1237
1238 @Override
1239 public String toString() {
1240 return super.toString() + " [target is " + getTarget() + "]";
1241 }
1242 }