rev 60071 : 8211999: Window positioning bugs due to overlapping GraphicsDevice bounds (Windows/HiDPI)
Reviewed-by: XXX

   1 /*
   2  * Copyright (c) 1996, 2020, 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.windows;
  27 
  28 import java.awt.AWTEvent;
  29 import java.awt.AWTEventMulticaster;
  30 import java.awt.Color;
  31 import java.awt.Component;
  32 import java.awt.Container;
  33 import java.awt.Dialog;
  34 import java.awt.Dimension;
  35 import java.awt.Graphics;
  36 import java.awt.GraphicsConfiguration;
  37 import java.awt.GraphicsDevice;
  38 import java.awt.GraphicsEnvironment;
  39 import java.awt.Image;
  40 import java.awt.Insets;
  41 import java.awt.KeyboardFocusManager;
  42 import java.awt.Rectangle;
  43 import java.awt.Shape;
  44 import java.awt.SystemColor;
  45 import java.awt.Window;
  46 import java.awt.event.FocusEvent;
  47 import java.awt.event.WindowEvent;
  48 import java.awt.event.WindowListener;
  49 import java.awt.geom.AffineTransform;
  50 import java.awt.image.DataBufferInt;
  51 import java.awt.peer.WindowPeer;
  52 import java.beans.PropertyChangeEvent;
  53 import java.beans.PropertyChangeListener;
  54 import java.util.LinkedList;
  55 import java.util.List;
  56 
  57 import sun.awt.AWTAccessor;
  58 import sun.awt.AppContext;
  59 import sun.awt.DisplayChangedListener;
  60 import sun.awt.SunToolkit;
  61 import sun.awt.Win32GraphicsConfig;
  62 import sun.awt.Win32GraphicsDevice;
  63 import sun.awt.Win32GraphicsEnvironment;

  64 import sun.java2d.pipe.Region;
  65 import sun.util.logging.PlatformLogger;
  66 
  67 import static sun.java2d.SunGraphicsEnvironment.toUserSpace;
  68 
  69 public class WWindowPeer extends WPanelPeer implements WindowPeer,
  70        DisplayChangedListener
  71 {
  72 
  73     private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.windows.WWindowPeer");
  74     private static final PlatformLogger screenLog = PlatformLogger.getLogger("sun.awt.windows.screen.WWindowPeer");
  75 
  76     // we can't use WDialogPeer as blocker may be an instance of WPrintDialogPeer that
  77     // extends WWindowPeer, not WDialogPeer
  78     private WWindowPeer modalBlocker = null;
  79 
  80     private boolean isOpaque;
  81 
  82     private TranslucentWindowPainter painter;
  83 
  84     /*
  85      * A key used for storing a list of active windows in AppContext. The value
  86      * is a list of windows, sorted by the time of activation: later a window is
  87      * activated, greater its index is in the list.
  88      */
  89     private static final StringBuffer ACTIVE_WINDOWS_KEY =
  90         new StringBuffer("active_windows_list");
  91 
  92     /*
  93      * Listener for 'activeWindow' KFM property changes. It is added to each
  94      * AppContext KFM. See ActiveWindowListener inner class below.
  95      */
  96     private static PropertyChangeListener activeWindowListener =
  97         new ActiveWindowListener();
  98 
  99     /*
 100      * The object is a listener for the AppContext.GUI_DISPOSED property.
 101      */
 102     private static final PropertyChangeListener guiDisposedListener =
 103         new GuiDisposedListener();
 104 
 105     /*
 106      * Called (on the Toolkit thread) before the appropriate
 107      * WindowStateEvent is posted to the EventQueue.
 108      */
 109     private WindowListener windowListener;


 110 
 111     /**
 112      * Initialize JNI field IDs
 113      */
 114     private static native void initIDs();
 115     static {
 116         initIDs();
 117     }
 118 
 119     // WComponentPeer overrides
 120     @Override
 121     @SuppressWarnings("unchecked")
 122     protected void disposeImpl() {
 123         AppContext appContext = SunToolkit.targetToAppContext(target);
 124         synchronized (appContext) {
 125             List<WWindowPeer> l = (List<WWindowPeer>)appContext.get(ACTIVE_WINDOWS_KEY);
 126             if (l != null) {
 127                 l.remove(this);
 128             }
 129         }
 130 
 131         // Remove ourself from the Map of DisplayChangeListeners
 132         GraphicsConfiguration gc = getGraphicsConfiguration();
 133         ((Win32GraphicsDevice)gc.getDevice()).removeDisplayChangedListener(this);
 134 
 135         synchronized (getStateLock()) {
 136             TranslucentWindowPainter currentPainter = painter;
 137             if (currentPainter != null) {
 138                 currentPainter.flush();
 139                 // don't set the current one to null here; reduces the chances of
 140                 // MT issues (like NPEs)
 141             }
 142         }
 143 
 144         super.disposeImpl();
 145     }
 146 
 147     // WindowPeer implementation
 148 
 149     @Override
 150     public void toFront() {
 151         updateFocusableWindowState();
 152         _toFront();
 153     }
 154     private native void _toFront();
 155 
 156     @Override
 157     public native void toBack();
 158 
 159     private native void setAlwaysOnTopNative(boolean value);
 160 
 161     public void setAlwaysOnTop(boolean value) {
 162         if ((value && ((Window)target).isVisible()) || !value) {
 163             setAlwaysOnTopNative(value);
 164         }
 165     }
 166 
 167     @Override
 168     public void updateAlwaysOnTopState() {
 169         setAlwaysOnTop(((Window)target).isAlwaysOnTop());
 170     }
 171 
 172     @Override
 173     public void updateFocusableWindowState() {
 174         setFocusableWindow(((Window)target).isFocusableWindow());
 175     }
 176     native void setFocusableWindow(boolean value);
 177 
 178     // FramePeer & DialogPeer partial shared implementation
 179 
 180     public void setTitle(String title) {
 181         // allow a null title to pass as an empty string.
 182         if (title == null) {
 183             title = "";
 184         }
 185         _setTitle(title);
 186     }
 187     private native void _setTitle(String title);
 188 
 189     public void setResizable(boolean resizable) {
 190         _setResizable(resizable);
 191     }
 192 
 193     private native void _setResizable(boolean resizable);
 194 
 195     // Toolkit & peer internals
 196 
 197     WWindowPeer(Window target) {
 198         super(target);
 199     }
 200 
 201     @Override
 202     void initialize() {
 203         super.initialize();
 204 
 205         updateInsets(insets_);
 206 
 207         if (!((Window) target).isFontSet()) {
 208             ((Window) target).setFont(defaultFont);
 209             setFont(defaultFont);
 210         }
 211         if (!((Window) target).isForegroundSet()) {
 212             ((Window) target).setForeground(SystemColor.windowText);
 213         }
 214         if (!((Window) target).isBackgroundSet()) {
 215             ((Window) target).setBackground(SystemColor.window);
 216         }
 217 
 218         // Express our interest in display changes
 219         GraphicsConfiguration gc = getGraphicsConfiguration();
 220         Win32GraphicsDevice gd = (Win32GraphicsDevice) gc.getDevice();
 221         gd.addDisplayChangedListener(this);


 222 
 223         initActiveWindowsTracking((Window)target);
 224 
 225         updateIconImages();
 226 
 227         Shape shape = ((Window)target).getShape();
 228         if (shape != null) {
 229             applyShape(Region.getInstance(shape, null));
 230         }
 231 
 232         float opacity = ((Window)target).getOpacity();
 233         if (opacity < 1.0f) {
 234             setOpacity(opacity);
 235         }
 236 
 237         synchronized (getStateLock()) {
 238             // default value of a boolean field is 'false', so set isOpaque to
 239             // true here explicitly
 240             this.isOpaque = true;
 241             setOpaque(((Window)target).isOpaque());
 242         }
 243     }
 244 
 245     native void createAwtWindow(WComponentPeer parent);
 246 
 247     private volatile Window.Type windowType = Window.Type.NORMAL;
 248 
 249     // This method must be called for Window, Dialog, and Frame before creating
 250     // the hwnd
 251     void preCreate(WComponentPeer parent) {
 252         windowType = ((Window)target).getType();
 253     }
 254 
 255     @Override
 256     void create(WComponentPeer parent) {
 257         preCreate(parent);
 258         createAwtWindow(parent);
 259     }
 260 
 261     @Override
 262     final WComponentPeer getNativeParent() {
 263         final Container owner = ((Window) target).getOwner();
 264         return (WComponentPeer) WToolkit.targetToPeer(owner);
 265     }
 266 
 267     // should be overriden in WDialogPeer
 268     protected void realShow() {
 269         super.show();
 270     }
 271 
 272     @Override
 273     public void show() {
 274         updateFocusableWindowState();
 275 
 276         boolean alwaysOnTop = ((Window)target).isAlwaysOnTop();
 277 
 278         // Fix for 4868278.
 279         // If we create a window with a specific GraphicsConfig, and then move it with
 280         // setLocation() or setBounds() to another one before its peer has been created,
 281         // then calling Window.getGraphicsConfig() returns wrong config. That may lead
 282         // to some problems like wrong-placed tooltips. It is caused by calling
 283         // super.displayChanged() in WWindowPeer.displayChanged() regardless of whether
 284         // GraphicsDevice was really changed, or not. So we need to track it here.
 285         updateGC();
 286 
 287         realShow();
 288         updateMinimumSize();
 289 
 290         if (((Window)target).isAlwaysOnTopSupported() && alwaysOnTop) {
 291             setAlwaysOnTop(alwaysOnTop);
 292         }
 293 
 294         synchronized (getStateLock()) {
 295             if (!isOpaque) {
 296                 updateWindow(true);
 297             }
 298         }
 299 
 300         // See https://javafx-jira.kenai.com/browse/RT-32570
 301         WComponentPeer owner = getNativeParent();
 302         if (owner != null && owner.isLightweightFramePeer()) {
 303             Rectangle b = getBounds();
 304             handleExpose(0, 0, b.width, b.height);
 305         }
 306     }
 307 
 308     final void syncBounds(){
 309         // The Windows will take care of the top-level window/frame/dialog,
 310         // and update the location/size when DPI changes.
 311     }
 312 
 313     // Synchronize the insets members (here & in helper) with actual window
 314     // state.
 315     native void updateInsets(Insets i);
 316 
 317     static native int getSysMinWidth();
 318     static native int getSysMinHeight();
 319     static native int getSysIconWidth();
 320     static native int getSysIconHeight();
 321     static native int getSysSmIconWidth();
 322     static native int getSysSmIconHeight();
 323     /**windows/classes/sun/awt/windows/
 324      * Creates native icon from specified raster data and updates
 325      * icon for window and all descendant windows that inherit icon.
 326      * Raster data should be passed in the ARGB form.
 327      * Note that raster data format was changed to provide support
 328      * for XP icons with alpha-channel
 329      */
 330     native void setIconImagesData(int[] iconRaster, int w, int h,
 331                                   int[] smallIconRaster, int smw, int smh);
 332 
 333     synchronized native void reshapeFrame(int x, int y, int width, int height);
 334 
 335     native Dimension getNativeWindowSize();
 336 
 337     public Dimension getScaledWindowSize() {
 338         return getNativeWindowSize();
 339     }
 340 
 341     public boolean requestWindowFocus(FocusEvent.Cause cause) {
 342         if (!focusAllowedFor()) {
 343             return false;
 344         }
 345         return requestWindowFocus(cause == FocusEvent.Cause.MOUSE_EVENT);
 346     }
 347     private native boolean requestWindowFocus(boolean isMouseEventCause);
 348 
 349     public boolean focusAllowedFor() {
 350         Window window = (Window)this.target;
 351         if (!window.isVisible() ||
 352             !window.isEnabled() ||
 353             !window.isFocusableWindow())
 354         {
 355             return false;
 356         }
 357         if (isModalBlocked()) {
 358             return false;
 359         }
 360         return true;
 361     }
 362 
 363     @Override
 364     void hide() {
 365         WindowListener listener = windowListener;
 366         if (listener != null) {
 367             // We're not getting WINDOW_CLOSING from the native code when hiding
 368             // the window programmatically. So, create it and notify the listener.
 369             listener.windowClosing(new WindowEvent((Window)target, WindowEvent.WINDOW_CLOSING));
 370         }
 371         super.hide();
 372     }
 373 
 374     // WARNING: it's called on the Toolkit thread!
 375     @Override
 376     void preprocessPostEvent(AWTEvent event) {
 377         if (event instanceof WindowEvent) {
 378             WindowListener listener = windowListener;
 379             if (listener != null) {
 380                 switch(event.getID()) {
 381                     case WindowEvent.WINDOW_CLOSING:
 382                         listener.windowClosing((WindowEvent)event);
 383                         break;
 384                     case WindowEvent.WINDOW_ICONIFIED:
 385                         listener.windowIconified((WindowEvent)event);
 386                         break;
 387                 }
 388             }
 389         }
 390     }
 391 
 392     synchronized void addWindowListener(WindowListener l) {
 393         windowListener = AWTEventMulticaster.add(windowListener, l);
 394     }
 395 
 396     synchronized void removeWindowListener(WindowListener l) {
 397         windowListener = AWTEventMulticaster.remove(windowListener, l);
 398     }
 399 
 400     @Override
 401     public void updateMinimumSize() {
 402         Dimension minimumSize = null;
 403         if (((Component)target).isMinimumSizeSet()) {
 404             minimumSize = ((Component)target).getMinimumSize();
 405         }
 406         if (minimumSize != null) {
 407             Dimension sysMin = toUserSpace(getGraphicsConfiguration(),
 408                                            getSysMinWidth(), getSysMinHeight());
 409             setMinSize(Math.max(minimumSize.width, sysMin.width),
 410                        Math.max(minimumSize.height, sysMin.height));
 411         } else {
 412             setMinSize(0, 0);
 413         }
 414     }
 415 
 416     @Override
 417     public void updateIconImages() {
 418         java.util.List<Image> imageList = ((Window)target).getIconImages();
 419         if (imageList == null || imageList.size() == 0) {
 420             setIconImagesData(null, 0, 0, null, 0, 0);
 421         } else {
 422             int w = getSysIconWidth();
 423             int h = getSysIconHeight();
 424             int smw = getSysSmIconWidth();
 425             int smh = getSysSmIconHeight();
 426             AffineTransform tx = getGraphicsConfiguration().getDefaultTransform();
 427             w = Region.clipScale(w, tx.getScaleX());
 428             h = Region.clipScale(h, tx.getScaleY());
 429             smw = Region.clipScale(smw, tx.getScaleX());
 430             smh = Region.clipScale(smh, tx.getScaleY());
 431             DataBufferInt iconData = SunToolkit.getScaledIconData(imageList,
 432                                                                   w, h);
 433             DataBufferInt iconSmData = SunToolkit.getScaledIconData(imageList,
 434                                                                     smw, smh);
 435             if (iconData != null && iconSmData != null) {
 436                 setIconImagesData(iconData.getData(), w, h,
 437                                   iconSmData.getData(), smw, smh);
 438             } else {
 439                 setIconImagesData(null, 0, 0, null, 0, 0);
 440             }
 441         }
 442     }
 443 
 444     native void setMinSize(int width, int height);
 445 
 446 /*
 447  * ---- MODALITY SUPPORT ----
 448  */
 449 
 450     /**
 451      * Some modality-related code here because WFileDialogPeer, WPrintDialogPeer and
 452      *   WPageDialogPeer are descendants of WWindowPeer, not WDialogPeer
 453      */
 454 
 455     public boolean isModalBlocked() {
 456         return modalBlocker != null;
 457     }
 458 
 459      @Override
 460     public void setModalBlocked(Dialog dialog, boolean blocked) {
 461         synchronized (((Component)getTarget()).getTreeLock()) // State lock should always be after awtLock
 462         {
 463             // use WWindowPeer instead of WDialogPeer because of FileDialogs and PrintDialogs
 464             WWindowPeer blockerPeer = AWTAccessor.getComponentAccessor()
 465                                                  .getPeer(dialog);
 466             if (blocked)
 467             {
 468                 modalBlocker = blockerPeer;
 469                 // handle native dialogs separately, as they may have not
 470                 // got HWND yet; modalEnable/modalDisable is called from
 471                 // their setHWnd() methods
 472                 if (blockerPeer instanceof WFileDialogPeer) {
 473                     ((WFileDialogPeer)blockerPeer).blockWindow(this);
 474                 } else if (blockerPeer instanceof WPrintDialogPeer) {
 475                     ((WPrintDialogPeer)blockerPeer).blockWindow(this);
 476                 } else {
 477                     modalDisable(dialog, blockerPeer.getHWnd());
 478                 }
 479             } else {
 480                 modalBlocker = null;
 481                 if (blockerPeer instanceof WFileDialogPeer) {
 482                     ((WFileDialogPeer)blockerPeer).unblockWindow(this);
 483                 } else if (blockerPeer instanceof WPrintDialogPeer) {
 484                     ((WPrintDialogPeer)blockerPeer).unblockWindow(this);
 485                 } else {
 486                     modalEnable(dialog);
 487                 }
 488             }
 489         }
 490     }
 491 
 492     native void modalDisable(Dialog blocker, long blockerHWnd);
 493     native void modalEnable(Dialog blocker);
 494 
 495     /*
 496      * Returns all the ever active windows from the current AppContext.
 497      * The list is sorted by the time of activation, so the latest
 498      * active window is always at the end.
 499      */
 500     @SuppressWarnings("unchecked")
 501     public static long[] getActiveWindowHandles(Component target) {
 502         AppContext appContext = SunToolkit.targetToAppContext(target);
 503         if (appContext == null) return null;
 504         synchronized (appContext) {
 505             List<WWindowPeer> l = (List<WWindowPeer>)appContext.get(ACTIVE_WINDOWS_KEY);
 506             if (l == null) {
 507                 return null;
 508             }
 509             long[] result = new long[l.size()];
 510             for (int j = 0; j < l.size(); j++) {
 511                 result[j] = l.get(j).getHWnd();
 512             }
 513             return result;
 514         }
 515     }
 516 
 517 /*
 518  * ----DISPLAY CHANGE SUPPORT----
 519  */
 520 
 521     /*
 522      * Called from native code when we have been dragged onto another screen.
 523      */
 524     void draggedToNewScreen() {
 525         displayChanged();
 526     }
 527 
 528     public void updateGC() {
 529         int scrn = getScreenImOn();
 530         if (screenLog.isLoggable(PlatformLogger.Level.FINER)) {
 531             log.finer("Screen number: " + scrn);
 532         }
 533 
 534         // get current GD
 535         Win32GraphicsDevice oldDev = winGraphicsConfig.getDevice();
 536 
 537         Win32GraphicsDevice newDev;
 538         GraphicsDevice[] devs = GraphicsEnvironment
 539             .getLocalGraphicsEnvironment()
 540             .getScreenDevices();
 541         // Occasionally during device addition/removal getScreenImOn can return
 542         // a non-existing screen number. Use the default device in this case.
 543         if (scrn >= devs.length) {
 544             newDev = (Win32GraphicsDevice)GraphicsEnvironment
 545                 .getLocalGraphicsEnvironment().getDefaultScreenDevice();
 546         } else {
 547             newDev = (Win32GraphicsDevice)devs[scrn];
 548         }
 549 
 550         // Set winGraphicsConfig to the default GC for the monitor this Window
 551         // is now mostly on.
 552         winGraphicsConfig = (Win32GraphicsConfig)newDev
 553                             .getDefaultConfiguration();
 554         if (screenLog.isLoggable(PlatformLogger.Level.FINE)) {
 555             if (winGraphicsConfig == null) {
 556                 screenLog.fine("Assertion (winGraphicsConfig != null) failed");
 557             }
 558         }
 559 
 560         // if on a different display, take off old GD and put on new GD
 561         if (oldDev != newDev) {
 562             oldDev.removeDisplayChangedListener(this);
 563             newDev.addDisplayChangedListener(this);
 564         }
 565 
 566         AWTAccessor.getComponentAccessor().
 567             setGraphicsConfiguration((Component)target, winGraphicsConfig);















 568     }
 569 
 570     /**
 571      * From the DisplayChangedListener interface.
 572      *
 573      * This method handles a display change - either when the display settings
 574      * are changed, or when the window has been dragged onto a different
 575      * display.
 576      * Called after a change in the display mode.  This event
 577      * triggers replacing the surfaceData object (since that object
 578      * reflects the current display depth information, which has
 579      * just changed).
 580      */
 581     @Override
 582     public void displayChanged() {
 583         SunToolkit.executeOnEventHandlerThread(target, this::updateGC);
 584     }
 585 
 586     /**
 587      * Part of the DisplayChangedListener interface: components
 588      * do not need to react to this event
 589      */
 590     @Override
 591     public void paletteChanged() {
 592     }
 593 
 594     private native int getScreenImOn();
 595 
 596     // Used in Win32GraphicsDevice.
 597     public final native void setFullScreenExclusiveModeState(boolean state);
 598 
 599 /*
 600  * ----END DISPLAY CHANGE SUPPORT----
 601  */
 602 
 603      public void grab() {
 604          nativeGrab();
 605      }
 606 
 607      public void ungrab() {
 608          nativeUngrab();
 609      }
 610      private native void nativeGrab();
 611      private native void nativeUngrab();
 612 
 613      private boolean hasWarningWindow() {
 614          return ((Window)target).getWarningString() != null;
 615      }
 616 
 617      boolean isTargetUndecorated() {
 618          return true;
 619      }
 620 








 621      @Override
 622      public native void repositionSecurityWarning();
 623 
 624     @Override




























































 625     public void print(Graphics g) {
 626         // We assume we print the whole frame,
 627         // so we expect no clip was set previously
 628         Shape shape = ((Window)target).getShape();
 629         if (shape != null) {
 630             g.setClip(shape);
 631         }
 632         super.print(g);
 633     }
 634 
 635     private void replaceSurfaceDataRecursively(Component c) {
 636         if (c instanceof Container) {
 637             for (Component child : ((Container)c).getComponents()) {
 638                 replaceSurfaceDataRecursively(child);
 639             }
 640         }
 641         final Object cp = AWTAccessor.getComponentAccessor().getPeer(c);
 642         if (cp instanceof WComponentPeer) {
 643             ((WComponentPeer)cp).replaceSurfaceDataLater();
 644         }
 645     }
 646 
 647     public final Graphics getTranslucentGraphics() {
 648         synchronized (getStateLock()) {
 649             return isOpaque ? null : painter.getGraphics(false);
 650         }
 651     }
 652 
 653     @Override
 654     public void setBackground(Color c) {
 655         super.setBackground(c);
 656         synchronized (getStateLock()) {
 657             if (!isOpaque && ((Window)target).isVisible()) {
 658                 updateWindow(true);
 659             }
 660         }
 661     }
 662 
 663     private native void setOpacity(int iOpacity);
 664     private float opacity = 1.0f;
 665 
 666     @Override
 667     public void setOpacity(float opacity) {
 668         if (!((SunToolkit)((Window)target).getToolkit()).
 669             isWindowOpacitySupported())
 670         {
 671             return;
 672         }
 673 
 674         if (opacity < 0.0f || opacity > 1.0f) {
 675             throw new IllegalArgumentException(
 676                 "The value of opacity should be in the range [0.0f .. 1.0f].");
 677         }
 678 
 679         if (((this.opacity == 1.0f && opacity <  1.0f) ||
 680              (this.opacity <  1.0f && opacity == 1.0f)) &&
 681             !Win32GraphicsEnvironment.isVistaOS())
 682         {
 683             // non-Vista OS: only replace the surface data if opacity status
 684             // changed (see WComponentPeer.isAccelCapable() for more)
 685             replaceSurfaceDataRecursively((Component)getTarget());
 686         }
 687 
 688         this.opacity = opacity;
 689 
 690         final int maxOpacity = 0xff;
 691         int iOpacity = (int)(opacity * maxOpacity);
 692         if (iOpacity < 0) {
 693             iOpacity = 0;
 694         }
 695         if (iOpacity > maxOpacity) {
 696             iOpacity = maxOpacity;
 697         }
 698 
 699         setOpacity(iOpacity);
 700 
 701         synchronized (getStateLock()) {
 702             if (!isOpaque && ((Window)target).isVisible()) {
 703                 updateWindow(true);
 704             }
 705         }
 706     }
 707 
 708     private native void setOpaqueImpl(boolean isOpaque);
 709 
 710     @Override
 711     public void setOpaque(boolean isOpaque) {
 712         synchronized (getStateLock()) {
 713             if (this.isOpaque == isOpaque) {
 714                 return;
 715             }
 716         }
 717 
 718         Window target = (Window)getTarget();
 719 
 720         if (!isOpaque) {
 721             SunToolkit sunToolkit = (SunToolkit)target.getToolkit();
 722             if (!sunToolkit.isWindowTranslucencySupported() ||
 723                 !sunToolkit.isTranslucencyCapable(target.getGraphicsConfiguration()))
 724             {
 725                 return;
 726             }
 727         }
 728 
 729         boolean isVistaOS = Win32GraphicsEnvironment.isVistaOS();
 730 
 731         if (this.isOpaque != isOpaque && !isVistaOS) {
 732             // non-Vista OS: only replace the surface data if the opacity
 733             // status changed (see WComponentPeer.isAccelCapable() for more)
 734             replaceSurfaceDataRecursively(target);
 735         }
 736 
 737         synchronized (getStateLock()) {
 738             this.isOpaque = isOpaque;
 739             setOpaqueImpl(isOpaque);
 740             if (isOpaque) {
 741                 TranslucentWindowPainter currentPainter = painter;
 742                 if (currentPainter != null) {
 743                     currentPainter.flush();
 744                     painter = null;
 745                 }
 746             } else {
 747                 painter = TranslucentWindowPainter.createInstance(this);
 748             }
 749         }
 750 
 751         if (isVistaOS) {
 752             // On Vista: setting the window non-opaque makes the window look
 753             // rectangular, though still catching the mouse clicks within
 754             // its shape only. To restore the correct visual appearance
 755             // of the window (i.e. w/ the correct shape) we have to reset
 756             // the shape.
 757             Shape shape = target.getShape();
 758             if (shape != null) {
 759                 target.setShape(shape);
 760             }
 761         }
 762 
 763         if (target.isVisible()) {
 764             updateWindow(true);
 765         }
 766     }
 767 
 768     native void updateWindowImpl(int[] data, int width, int height);
 769 
 770     @Override
 771     public void updateWindow() {
 772         updateWindow(false);
 773     }
 774 
 775     private void updateWindow(boolean repaint) {
 776         Window w = (Window)target;
 777         synchronized (getStateLock()) {
 778             if (isOpaque || !w.isVisible() ||
 779                 (w.getWidth() <= 0) || (w.getHeight() <= 0))
 780             {
 781                 return;
 782             }
 783             TranslucentWindowPainter currentPainter = painter;
 784             if (currentPainter != null) {
 785                 currentPainter.updateWindow(repaint);
 786             } else if (log.isLoggable(PlatformLogger.Level.FINER)) {
 787                 log.finer("Translucent window painter is null in updateWindow");
 788             }
 789         }
 790     }



 791 
 792     /*
 793      * The method maps the list of the active windows to the window's AppContext,
 794      * then the method registers ActiveWindowListener, GuiDisposedListener listeners;
 795      * it executes the initilialization only once per AppContext.
 796      */
 797     @SuppressWarnings("unchecked")
 798     private static void initActiveWindowsTracking(Window w) {
 799         AppContext appContext = AppContext.getAppContext();
 800         synchronized (appContext) {
 801             List<WWindowPeer> l = (List<WWindowPeer>)appContext.get(ACTIVE_WINDOWS_KEY);
 802             if (l == null) {
 803                 l = new LinkedList<WWindowPeer>();
 804                 appContext.put(ACTIVE_WINDOWS_KEY, l);
 805                 appContext.addPropertyChangeListener(AppContext.GUI_DISPOSED, guiDisposedListener);
 806 
 807                 KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
 808                 kfm.addPropertyChangeListener("activeWindow", activeWindowListener);
 809             }
 810         }
 811     }
 812 
 813     /*
 814      * The GuiDisposedListener class listens for the AppContext.GUI_DISPOSED property,
 815      * it removes the list of the active windows from the disposed AppContext and
 816      * unregisters ActiveWindowListener listener.
 817      */
 818     private static class GuiDisposedListener implements PropertyChangeListener {
 819         @Override
 820         public void propertyChange(PropertyChangeEvent e) {
 821             boolean isDisposed = (Boolean)e.getNewValue();
 822             if (isDisposed != true) {
 823                 if (log.isLoggable(PlatformLogger.Level.FINE)) {
 824                     log.fine(" Assertion (newValue != true) failed for AppContext.GUI_DISPOSED ");
 825                 }
 826             }
 827             AppContext appContext = AppContext.getAppContext();
 828             synchronized (appContext) {
 829                 appContext.remove(ACTIVE_WINDOWS_KEY);
 830                 appContext.removePropertyChangeListener(AppContext.GUI_DISPOSED, this);
 831 
 832                 KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
 833                 kfm.removePropertyChangeListener("activeWindow", activeWindowListener);
 834             }
 835         }
 836     }
 837 
 838     /*
 839      * Static inner class, listens for 'activeWindow' KFM property changes and
 840      * updates the list of active windows per AppContext, so the latest active
 841      * window is always at the end of the list. The list is stored in AppContext.
 842      */
 843     @SuppressWarnings("unchecked")
 844     private static class ActiveWindowListener implements PropertyChangeListener {
 845         @Override
 846         public void propertyChange(PropertyChangeEvent e) {
 847             Window w = (Window)e.getNewValue();
 848             if (w == null) {
 849                 return;
 850             }
 851             AppContext appContext = SunToolkit.targetToAppContext(w);
 852             synchronized (appContext) {
 853                 WWindowPeer wp = AWTAccessor.getComponentAccessor().getPeer(w);
 854                 // add/move wp to the end of the list
 855                 List<WWindowPeer> l = (List<WWindowPeer>)appContext.get(ACTIVE_WINDOWS_KEY);
 856                 if (l != null) {
 857                     l.remove(wp);
 858                     l.add(wp);
 859                 }
 860             }
 861         }
 862     }
 863 }
--- EOF ---