1 /*
   2  * Copyright (c) 1996, 2015, 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 package sun.awt.windows;
  26 
  27 import java.awt.*;
  28 import java.awt.event.*;
  29 import java.awt.image.*;
  30 import java.awt.peer.*;
  31 
  32 import java.beans.*;
  33 
  34 import java.util.*;
  35 import java.util.List;
  36 import sun.util.logging.PlatformLogger;
  37 
  38 import sun.awt.*;
  39 
  40 import sun.java2d.pipe.Region;
  41 
  42 public class WWindowPeer extends WPanelPeer implements WindowPeer,
  43        DisplayChangedListener
  44 {
  45 
  46     private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.windows.WWindowPeer");
  47     private static final PlatformLogger screenLog = PlatformLogger.getLogger("sun.awt.windows.screen.WWindowPeer");
  48 
  49     // we can't use WDialogPeer as blocker may be an instance of WPrintDialogPeer that
  50     // extends WWindowPeer, not WDialogPeer
  51     private WWindowPeer modalBlocker = null;
  52 
  53     private boolean isOpaque;
  54 
  55     private TranslucentWindowPainter painter;
  56 
  57     /*
  58      * A key used for storing a list of active windows in AppContext. The value
  59      * is a list of windows, sorted by the time of activation: later a window is
  60      * activated, greater its index is in the list.
  61      */
  62     private static final StringBuffer ACTIVE_WINDOWS_KEY =
  63         new StringBuffer("active_windows_list");
  64 
  65     /*
  66      * Listener for 'activeWindow' KFM property changes. It is added to each
  67      * AppContext KFM. See ActiveWindowListener inner class below.
  68      */
  69     private static PropertyChangeListener activeWindowListener =
  70         new ActiveWindowListener();
  71 
  72     /*
  73      * The object is a listener for the AppContext.GUI_DISPOSED property.
  74      */
  75     private static final PropertyChangeListener guiDisposedListener =
  76         new GuiDisposedListener();
  77 
  78     /*
  79      * Called (on the Toolkit thread) before the appropriate
  80      * WindowStateEvent is posted to the EventQueue.
  81      */
  82     private WindowListener windowListener;
  83 
  84     /**
  85      * Initialize JNI field IDs
  86      */
  87     private static native void initIDs();
  88     static {
  89         initIDs();
  90     }
  91 
  92     // WComponentPeer overrides
  93     @Override
  94     @SuppressWarnings("unchecked")
  95     protected void disposeImpl() {
  96         AppContext appContext = SunToolkit.targetToAppContext(target);
  97         synchronized (appContext) {
  98             List<WWindowPeer> l = (List<WWindowPeer>)appContext.get(ACTIVE_WINDOWS_KEY);
  99             if (l != null) {
 100                 l.remove(this);
 101             }
 102         }
 103 
 104         // Remove ourself from the Map of DisplayChangeListeners
 105         GraphicsConfiguration gc = getGraphicsConfiguration();
 106         ((Win32GraphicsDevice)gc.getDevice()).removeDisplayChangedListener(this);
 107 
 108         synchronized (getStateLock()) {
 109             TranslucentWindowPainter currentPainter = painter;
 110             if (currentPainter != null) {
 111                 currentPainter.flush();
 112                 // don't set the current one to null here; reduces the chances of
 113                 // MT issues (like NPEs)
 114             }
 115         }
 116 
 117         super.disposeImpl();
 118     }
 119 
 120     // WindowPeer implementation
 121 
 122     @Override
 123     public void toFront() {
 124         updateFocusableWindowState();
 125         _toFront();
 126     }
 127     private native void _toFront();
 128 
 129     @Override
 130     public native void toBack();
 131 
 132     private native void setAlwaysOnTopNative(boolean value);
 133 
 134     public void setAlwaysOnTop(boolean value) {
 135         if ((value && ((Window)target).isVisible()) || !value) {
 136             setAlwaysOnTopNative(value);
 137         }
 138     }
 139 
 140     @Override
 141     public void updateAlwaysOnTopState() {
 142         setAlwaysOnTop(((Window)target).isAlwaysOnTop());
 143     }
 144 
 145     @Override
 146     public void updateFocusableWindowState() {
 147         setFocusableWindow(((Window)target).isFocusableWindow());
 148     }
 149     native void setFocusableWindow(boolean value);
 150 
 151     // FramePeer & DialogPeer partial shared implementation
 152 
 153     public void setTitle(String title) {
 154         // allow a null title to pass as an empty string.
 155         if (title == null) {
 156             title = "";
 157         }
 158         _setTitle(title);
 159     }
 160     private native void _setTitle(String title);
 161 
 162     public void setResizable(boolean resizable) {
 163         _setResizable(resizable);
 164     }
 165 
 166     private native void _setResizable(boolean resizable);
 167 
 168     // Toolkit & peer internals
 169 
 170     WWindowPeer(Window target) {
 171         super(target);
 172     }
 173 
 174     @Override
 175     void initialize() {
 176         super.initialize();
 177 
 178         updateInsets(insets_);
 179 
 180         Font f = ((Window)target).getFont();
 181         if (f == null) {
 182             f = defaultFont;
 183             ((Window)target).setFont(f);
 184             setFont(f);
 185         }







 186         // Express our interest in display changes
 187         GraphicsConfiguration gc = getGraphicsConfiguration();
 188         ((Win32GraphicsDevice)gc.getDevice()).addDisplayChangedListener(this);
 189 
 190         initActiveWindowsTracking((Window)target);
 191 
 192         updateIconImages();
 193 
 194         Shape shape = ((Window)target).getShape();
 195         if (shape != null) {
 196             applyShape(Region.getInstance(shape, null));
 197         }
 198 
 199         float opacity = ((Window)target).getOpacity();
 200         if (opacity < 1.0f) {
 201             setOpacity(opacity);
 202         }
 203 
 204         synchronized (getStateLock()) {
 205             // default value of a boolean field is 'false', so set isOpaque to
 206             // true here explicitly
 207             this.isOpaque = true;
 208             setOpaque(((Window)target).isOpaque());
 209         }
 210     }
 211 
 212     native void createAwtWindow(WComponentPeer parent);
 213 
 214     private volatile Window.Type windowType = Window.Type.NORMAL;
 215 
 216     // This method must be called for Window, Dialog, and Frame before creating
 217     // the hwnd
 218     void preCreate(WComponentPeer parent) {
 219         windowType = ((Window)target).getType();
 220     }
 221 
 222     @Override
 223     void create(WComponentPeer parent) {
 224         preCreate(parent);
 225         createAwtWindow(parent);
 226     }
 227 
 228     @Override
 229     final WComponentPeer getNativeParent() {
 230         final Container owner = ((Window) target).getOwner();
 231         return (WComponentPeer) WToolkit.targetToPeer(owner);
 232     }
 233 
 234     // should be overriden in WDialogPeer
 235     protected void realShow() {
 236         super.show();
 237     }
 238 
 239     @Override
 240     public void show() {
 241         updateFocusableWindowState();
 242 
 243         boolean alwaysOnTop = ((Window)target).isAlwaysOnTop();
 244 
 245         // Fix for 4868278.
 246         // If we create a window with a specific GraphicsConfig, and then move it with
 247         // setLocation() or setBounds() to another one before its peer has been created,
 248         // then calling Window.getGraphicsConfig() returns wrong config. That may lead
 249         // to some problems like wrong-placed tooltips. It is caused by calling
 250         // super.displayChanged() in WWindowPeer.displayChanged() regardless of whether
 251         // GraphicsDevice was really changed, or not. So we need to track it here.
 252         updateGC();
 253 
 254         realShow();
 255         updateMinimumSize();
 256 
 257         if (((Window)target).isAlwaysOnTopSupported() && alwaysOnTop) {
 258             setAlwaysOnTop(alwaysOnTop);
 259         }
 260 
 261         synchronized (getStateLock()) {
 262             if (!isOpaque) {
 263                 updateWindow(true);
 264             }
 265         }
 266 
 267         // See https://javafx-jira.kenai.com/browse/RT-32570
 268         WComponentPeer owner = getNativeParent();
 269         if (owner != null && owner.isLightweightFramePeer()) {
 270             Rectangle b = getBounds();
 271             handleExpose(0, 0, b.width, b.height);
 272         }
 273     }
 274 
 275     // Synchronize the insets members (here & in helper) with actual window
 276     // state.
 277     native void updateInsets(Insets i);
 278 
 279     static native int getSysMinWidth();
 280     static native int getSysMinHeight();
 281     static native int getSysIconWidth();
 282     static native int getSysIconHeight();
 283     static native int getSysSmIconWidth();
 284     static native int getSysSmIconHeight();
 285     /**windows/classes/sun/awt/windows/
 286      * Creates native icon from specified raster data and updates
 287      * icon for window and all descendant windows that inherit icon.
 288      * Raster data should be passed in the ARGB form.
 289      * Note that raster data format was changed to provide support
 290      * for XP icons with alpha-channel
 291      */
 292     native void setIconImagesData(int[] iconRaster, int w, int h,
 293                                   int[] smallIconRaster, int smw, int smh);
 294 
 295     synchronized native void reshapeFrame(int x, int y, int width, int height);
 296 
 297     native Dimension getNativeWindowSize();
 298 
 299     public Dimension getScaledWindowSize() {
 300         return getNativeWindowSize();
 301     }
 302 
 303     public boolean requestWindowFocus(CausedFocusEvent.Cause cause) {
 304         if (!focusAllowedFor()) {
 305             return false;
 306         }
 307         return requestWindowFocus(cause == CausedFocusEvent.Cause.MOUSE_EVENT);
 308     }
 309     private native boolean requestWindowFocus(boolean isMouseEventCause);
 310 
 311     public boolean focusAllowedFor() {
 312         Window window = (Window)this.target;
 313         if (!window.isVisible() ||
 314             !window.isEnabled() ||
 315             !window.isFocusableWindow())
 316         {
 317             return false;
 318         }
 319         if (isModalBlocked()) {
 320             return false;
 321         }
 322         return true;
 323     }
 324 
 325     @Override
 326     void hide() {
 327         WindowListener listener = windowListener;
 328         if (listener != null) {
 329             // We're not getting WINDOW_CLOSING from the native code when hiding
 330             // the window programmatically. So, create it and notify the listener.
 331             listener.windowClosing(new WindowEvent((Window)target, WindowEvent.WINDOW_CLOSING));
 332         }
 333         super.hide();
 334     }
 335 
 336     // WARNING: it's called on the Toolkit thread!
 337     @Override
 338     void preprocessPostEvent(AWTEvent event) {
 339         if (event instanceof WindowEvent) {
 340             WindowListener listener = windowListener;
 341             if (listener != null) {
 342                 switch(event.getID()) {
 343                     case WindowEvent.WINDOW_CLOSING:
 344                         listener.windowClosing((WindowEvent)event);
 345                         break;
 346                     case WindowEvent.WINDOW_ICONIFIED:
 347                         listener.windowIconified((WindowEvent)event);
 348                         break;
 349                 }
 350             }
 351         }
 352     }
 353 
 354     synchronized void addWindowListener(WindowListener l) {
 355         windowListener = AWTEventMulticaster.add(windowListener, l);
 356     }
 357 
 358     synchronized void removeWindowListener(WindowListener l) {
 359         windowListener = AWTEventMulticaster.remove(windowListener, l);
 360     }
 361 
 362     @Override
 363     public void updateMinimumSize() {
 364         Dimension minimumSize = null;
 365         if (((Component)target).isMinimumSizeSet()) {
 366             minimumSize = ((Component)target).getMinimumSize();
 367         }
 368         if (minimumSize != null) {
 369             int msw = getSysMinWidth();
 370             int msh = getSysMinHeight();
 371             int w = (minimumSize.width >= msw) ? minimumSize.width : msw;
 372             int h = (minimumSize.height >= msh) ? minimumSize.height : msh;
 373             setMinSize(w, h);
 374         } else {
 375             setMinSize(0, 0);
 376         }
 377     }
 378 
 379     @Override
 380     public void updateIconImages() {
 381         java.util.List<Image> imageList = ((Window)target).getIconImages();
 382         if (imageList == null || imageList.size() == 0) {
 383             setIconImagesData(null, 0, 0, null, 0, 0);
 384         } else {
 385             int w = getSysIconWidth();
 386             int h = getSysIconHeight();
 387             int smw = getSysSmIconWidth();
 388             int smh = getSysSmIconHeight();
 389             DataBufferInt iconData = SunToolkit.getScaledIconData(imageList,
 390                                                                   w, h);
 391             DataBufferInt iconSmData = SunToolkit.getScaledIconData(imageList,
 392                                                                     smw, smh);
 393             if (iconData != null && iconSmData != null) {
 394                 setIconImagesData(iconData.getData(), w, h,
 395                                   iconSmData.getData(), smw, smh);
 396             } else {
 397                 setIconImagesData(null, 0, 0, null, 0, 0);
 398             }
 399         }
 400     }
 401 
 402     native void setMinSize(int width, int height);
 403 
 404 /*
 405  * ---- MODALITY SUPPORT ----
 406  */
 407 
 408     /**
 409      * Some modality-related code here because WFileDialogPeer, WPrintDialogPeer and
 410      *   WPageDialogPeer are descendants of WWindowPeer, not WDialogPeer
 411      */
 412 
 413     public boolean isModalBlocked() {
 414         return modalBlocker != null;
 415     }
 416 
 417      @Override
 418     public void setModalBlocked(Dialog dialog, boolean blocked) {
 419         synchronized (((Component)getTarget()).getTreeLock()) // State lock should always be after awtLock
 420         {
 421             // use WWindowPeer instead of WDialogPeer because of FileDialogs and PrintDialogs
 422             WWindowPeer blockerPeer = AWTAccessor.getComponentAccessor()
 423                                                  .getPeer(dialog);
 424             if (blocked)
 425             {
 426                 modalBlocker = blockerPeer;
 427                 // handle native dialogs separately, as they may have not
 428                 // got HWND yet; modalEnable/modalDisable is called from
 429                 // their setHWnd() methods
 430                 if (blockerPeer instanceof WFileDialogPeer) {
 431                     ((WFileDialogPeer)blockerPeer).blockWindow(this);
 432                 } else if (blockerPeer instanceof WPrintDialogPeer) {
 433                     ((WPrintDialogPeer)blockerPeer).blockWindow(this);
 434                 } else {
 435                     modalDisable(dialog, blockerPeer.getHWnd());
 436                 }
 437             } else {
 438                 modalBlocker = null;
 439                 if (blockerPeer instanceof WFileDialogPeer) {
 440                     ((WFileDialogPeer)blockerPeer).unblockWindow(this);
 441                 } else if (blockerPeer instanceof WPrintDialogPeer) {
 442                     ((WPrintDialogPeer)blockerPeer).unblockWindow(this);
 443                 } else {
 444                     modalEnable(dialog);
 445                 }
 446             }
 447         }
 448     }
 449 
 450     native void modalDisable(Dialog blocker, long blockerHWnd);
 451     native void modalEnable(Dialog blocker);
 452 
 453     /*
 454      * Returns all the ever active windows from the current AppContext.
 455      * The list is sorted by the time of activation, so the latest
 456      * active window is always at the end.
 457      */
 458     @SuppressWarnings("unchecked")
 459     public static long[] getActiveWindowHandles(Component target) {
 460         AppContext appContext = SunToolkit.targetToAppContext(target);
 461         if (appContext == null) return null;
 462         synchronized (appContext) {
 463             List<WWindowPeer> l = (List<WWindowPeer>)appContext.get(ACTIVE_WINDOWS_KEY);
 464             if (l == null) {
 465                 return null;
 466             }
 467             long[] result = new long[l.size()];
 468             for (int j = 0; j < l.size(); j++) {
 469                 result[j] = l.get(j).getHWnd();
 470             }
 471             return result;
 472         }
 473     }
 474 
 475 /*
 476  * ----DISPLAY CHANGE SUPPORT----
 477  */
 478 
 479     /*
 480      * Called from native code when we have been dragged onto another screen.
 481      */
 482     void draggedToNewScreen() {
 483         SunToolkit.executeOnEventHandlerThread((Component)target,new Runnable()
 484         {
 485             @Override
 486             public void run() {
 487                 displayChanged();
 488             }
 489         });
 490     }
 491 
 492     public void updateGC() {
 493         int scrn = getScreenImOn();
 494         if (screenLog.isLoggable(PlatformLogger.Level.FINER)) {
 495             log.finer("Screen number: " + scrn);
 496         }
 497 
 498         // get current GD
 499         Win32GraphicsDevice oldDev = winGraphicsConfig.getDevice();
 500 
 501         Win32GraphicsDevice newDev;
 502         GraphicsDevice devs[] = GraphicsEnvironment
 503             .getLocalGraphicsEnvironment()
 504             .getScreenDevices();
 505         // Occasionally during device addition/removal getScreenImOn can return
 506         // a non-existing screen number. Use the default device in this case.
 507         if (scrn >= devs.length) {
 508             newDev = (Win32GraphicsDevice)GraphicsEnvironment
 509                 .getLocalGraphicsEnvironment().getDefaultScreenDevice();
 510         } else {
 511             newDev = (Win32GraphicsDevice)devs[scrn];
 512         }
 513 
 514         // Set winGraphicsConfig to the default GC for the monitor this Window
 515         // is now mostly on.
 516         winGraphicsConfig = (Win32GraphicsConfig)newDev
 517                             .getDefaultConfiguration();
 518         if (screenLog.isLoggable(PlatformLogger.Level.FINE)) {
 519             if (winGraphicsConfig == null) {
 520                 screenLog.fine("Assertion (winGraphicsConfig != null) failed");
 521             }
 522         }
 523 
 524         // if on a different display, take off old GD and put on new GD
 525         if (oldDev != newDev) {
 526             oldDev.removeDisplayChangedListener(this);
 527             newDev.addDisplayChangedListener(this);
 528         }
 529 
 530         AWTAccessor.getComponentAccessor().
 531             setGraphicsConfiguration((Component)target, winGraphicsConfig);
 532     }
 533 
 534     /**
 535      * From the DisplayChangedListener interface.
 536      *
 537      * This method handles a display change - either when the display settings
 538      * are changed, or when the window has been dragged onto a different
 539      * display.
 540      * Called after a change in the display mode.  This event
 541      * triggers replacing the surfaceData object (since that object
 542      * reflects the current display depth information, which has
 543      * just changed).
 544      */
 545     @Override
 546     public void displayChanged() {
 547         updateGC();
 548     }
 549 
 550     /**
 551      * Part of the DisplayChangedListener interface: components
 552      * do not need to react to this event
 553      */
 554     @Override
 555     public void paletteChanged() {
 556     }
 557 
 558     private native int getScreenImOn();
 559 
 560     // Used in Win32GraphicsDevice.
 561     public final native void setFullScreenExclusiveModeState(boolean state);
 562 
 563 /*
 564  * ----END DISPLAY CHANGE SUPPORT----
 565  */
 566 
 567      public void grab() {
 568          nativeGrab();
 569      }
 570 
 571      public void ungrab() {
 572          nativeUngrab();
 573      }
 574      private native void nativeGrab();
 575      private native void nativeUngrab();
 576 
 577      private final boolean hasWarningWindow() {
 578          return ((Window)target).getWarningString() != null;
 579      }
 580 
 581      boolean isTargetUndecorated() {
 582          return true;
 583      }
 584 
 585      // These are the peer bounds. They get updated at:
 586      //    1. the WWindowPeer.setBounds() method.
 587      //    2. the native code (on WM_SIZE/WM_MOVE)
 588      private volatile int sysX = 0;
 589      private volatile int sysY = 0;
 590      private volatile int sysW = 0;
 591      private volatile int sysH = 0;
 592 
 593      @Override
 594      public native void repositionSecurityWarning();
 595 
 596      @Override
 597      public void setBounds(int x, int y, int width, int height, int op) {
 598          sysX = x;
 599          sysY = y;
 600          sysW = width;
 601          sysH = height;
 602 
 603          super.setBounds(x, y, width, height, op);
 604      }
 605 
 606     @Override
 607     public void print(Graphics g) {
 608         // We assume we print the whole frame,
 609         // so we expect no clip was set previously
 610         Shape shape = AWTAccessor.getWindowAccessor().getShape((Window)target);
 611         if (shape != null) {
 612             g.setClip(shape);
 613         }
 614         super.print(g);
 615     }
 616 
 617     private void replaceSurfaceDataRecursively(Component c) {
 618         if (c instanceof Container) {
 619             for (Component child : ((Container)c).getComponents()) {
 620                 replaceSurfaceDataRecursively(child);
 621             }
 622         }
 623         final Object cp = AWTAccessor.getComponentAccessor().getPeer(c);
 624         if (cp instanceof WComponentPeer) {
 625             ((WComponentPeer)cp).replaceSurfaceDataLater();
 626         }
 627     }
 628 
 629     public final Graphics getTranslucentGraphics() {
 630         synchronized (getStateLock()) {
 631             return isOpaque ? null : painter.getBackBuffer(false).getGraphics();
 632         }
 633     }
 634 
 635     @Override
 636     public void setBackground(Color c) {
 637         super.setBackground(c);
 638         synchronized (getStateLock()) {
 639             if (!isOpaque && ((Window)target).isVisible()) {
 640                 updateWindow(true);
 641             }
 642         }
 643     }
 644 
 645     private native void setOpacity(int iOpacity);
 646     private float opacity = 1.0f;
 647 
 648     @Override
 649     public void setOpacity(float opacity) {
 650         if (!((SunToolkit)((Window)target).getToolkit()).
 651             isWindowOpacitySupported())
 652         {
 653             return;
 654         }
 655 
 656         if (opacity < 0.0f || opacity > 1.0f) {
 657             throw new IllegalArgumentException(
 658                 "The value of opacity should be in the range [0.0f .. 1.0f].");
 659         }
 660 
 661         if (((this.opacity == 1.0f && opacity <  1.0f) ||
 662              (this.opacity <  1.0f && opacity == 1.0f)) &&
 663             !Win32GraphicsEnvironment.isVistaOS())
 664         {
 665             // non-Vista OS: only replace the surface data if opacity status
 666             // changed (see WComponentPeer.isAccelCapable() for more)
 667             replaceSurfaceDataRecursively((Component)getTarget());
 668         }
 669 
 670         this.opacity = opacity;
 671 
 672         final int maxOpacity = 0xff;
 673         int iOpacity = (int)(opacity * maxOpacity);
 674         if (iOpacity < 0) {
 675             iOpacity = 0;
 676         }
 677         if (iOpacity > maxOpacity) {
 678             iOpacity = maxOpacity;
 679         }
 680 
 681         setOpacity(iOpacity);
 682 
 683         synchronized (getStateLock()) {
 684             if (!isOpaque && ((Window)target).isVisible()) {
 685                 updateWindow(true);
 686             }
 687         }
 688     }
 689 
 690     private native void setOpaqueImpl(boolean isOpaque);
 691 
 692     @Override
 693     public void setOpaque(boolean isOpaque) {
 694         synchronized (getStateLock()) {
 695             if (this.isOpaque == isOpaque) {
 696                 return;
 697             }
 698         }
 699 
 700         Window target = (Window)getTarget();
 701 
 702         if (!isOpaque) {
 703             SunToolkit sunToolkit = (SunToolkit)target.getToolkit();
 704             if (!sunToolkit.isWindowTranslucencySupported() ||
 705                 !sunToolkit.isTranslucencyCapable(target.getGraphicsConfiguration()))
 706             {
 707                 return;
 708             }
 709         }
 710 
 711         boolean isVistaOS = Win32GraphicsEnvironment.isVistaOS();
 712 
 713         if (this.isOpaque != isOpaque && !isVistaOS) {
 714             // non-Vista OS: only replace the surface data if the opacity
 715             // status changed (see WComponentPeer.isAccelCapable() for more)
 716             replaceSurfaceDataRecursively(target);
 717         }
 718 
 719         synchronized (getStateLock()) {
 720             this.isOpaque = isOpaque;
 721             setOpaqueImpl(isOpaque);
 722             if (isOpaque) {
 723                 TranslucentWindowPainter currentPainter = painter;
 724                 if (currentPainter != null) {
 725                     currentPainter.flush();
 726                     painter = null;
 727                 }
 728             } else {
 729                 painter = TranslucentWindowPainter.createInstance(this);
 730             }
 731         }
 732 
 733         if (isVistaOS) {
 734             // On Vista: setting the window non-opaque makes the window look
 735             // rectangular, though still catching the mouse clicks within
 736             // its shape only. To restore the correct visual appearance
 737             // of the window (i.e. w/ the correct shape) we have to reset
 738             // the shape.
 739             Shape shape = target.getShape();
 740             if (shape != null) {
 741                 target.setShape(shape);
 742             }
 743         }
 744 
 745         if (target.isVisible()) {
 746             updateWindow(true);
 747         }
 748     }
 749 
 750     native void updateWindowImpl(int[] data, int width, int height);
 751 
 752     @Override
 753     public void updateWindow() {
 754         updateWindow(false);
 755     }
 756 
 757     private void updateWindow(boolean repaint) {
 758         Window w = (Window)target;
 759         synchronized (getStateLock()) {
 760             if (isOpaque || !w.isVisible() ||
 761                 (w.getWidth() <= 0) || (w.getHeight() <= 0))
 762             {
 763                 return;
 764             }
 765             TranslucentWindowPainter currentPainter = painter;
 766             if (currentPainter != null) {
 767                 currentPainter.updateWindow(repaint);
 768             } else if (log.isLoggable(PlatformLogger.Level.FINER)) {
 769                 log.finer("Translucent window painter is null in updateWindow");
 770             }
 771         }
 772     }
 773 
 774     /*
 775      * The method maps the list of the active windows to the window's AppContext,
 776      * then the method registers ActiveWindowListener, GuiDisposedListener listeners;
 777      * it executes the initilialization only once per AppContext.
 778      */
 779     @SuppressWarnings("unchecked")
 780     private static void initActiveWindowsTracking(Window w) {
 781         AppContext appContext = AppContext.getAppContext();
 782         synchronized (appContext) {
 783             List<WWindowPeer> l = (List<WWindowPeer>)appContext.get(ACTIVE_WINDOWS_KEY);
 784             if (l == null) {
 785                 l = new LinkedList<WWindowPeer>();
 786                 appContext.put(ACTIVE_WINDOWS_KEY, l);
 787                 appContext.addPropertyChangeListener(AppContext.GUI_DISPOSED, guiDisposedListener);
 788 
 789                 KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
 790                 kfm.addPropertyChangeListener("activeWindow", activeWindowListener);
 791             }
 792         }
 793     }
 794 
 795     /*
 796      * The GuiDisposedListener class listens for the AppContext.GUI_DISPOSED property,
 797      * it removes the list of the active windows from the disposed AppContext and
 798      * unregisters ActiveWindowListener listener.
 799      */
 800     private static class GuiDisposedListener implements PropertyChangeListener {
 801         @Override
 802         public void propertyChange(PropertyChangeEvent e) {
 803             boolean isDisposed = (Boolean)e.getNewValue();
 804             if (isDisposed != true) {
 805                 if (log.isLoggable(PlatformLogger.Level.FINE)) {
 806                     log.fine(" Assertion (newValue != true) failed for AppContext.GUI_DISPOSED ");
 807                 }
 808             }
 809             AppContext appContext = AppContext.getAppContext();
 810             synchronized (appContext) {
 811                 appContext.remove(ACTIVE_WINDOWS_KEY);
 812                 appContext.removePropertyChangeListener(AppContext.GUI_DISPOSED, this);
 813 
 814                 KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
 815                 kfm.removePropertyChangeListener("activeWindow", activeWindowListener);
 816             }
 817         }
 818     }
 819 
 820     /*
 821      * Static inner class, listens for 'activeWindow' KFM property changes and
 822      * updates the list of active windows per AppContext, so the latest active
 823      * window is always at the end of the list. The list is stored in AppContext.
 824      */
 825     @SuppressWarnings("unchecked")
 826     private static class ActiveWindowListener implements PropertyChangeListener {
 827         @Override
 828         public void propertyChange(PropertyChangeEvent e) {
 829             Window w = (Window)e.getNewValue();
 830             if (w == null) {
 831                 return;
 832             }
 833             AppContext appContext = SunToolkit.targetToAppContext(w);
 834             synchronized (appContext) {
 835                 WWindowPeer wp = AWTAccessor.getComponentAccessor().getPeer(w);
 836                 // add/move wp to the end of the list
 837                 List<WWindowPeer> l = (List<WWindowPeer>)appContext.get(ACTIVE_WINDOWS_KEY);
 838                 if (l != null) {
 839                     l.remove(wp);
 840                     l.add(wp);
 841                 }
 842             }
 843         }
 844     }
 845 }
--- EOF ---