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

   1 /*
   2  * Copyright (c) 1996, 2017, 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 #ifndef AWT_WINDOW_H
  27 #define AWT_WINDOW_H
  28 
  29 #include "awt_Canvas.h"
  30 
  31 #include "java_awt_Window.h"
  32 #include "sun_awt_windows_WWindowPeer.h"
  33 
  34 // property name tagging windows disabled by modality
  35 static LPCTSTR ModalBlockerProp = TEXT("SunAwtModalBlockerProp");
  36 static LPCTSTR ModalDialogPeerProp = TEXT("SunAwtModalDialogPeerProp");
  37 static LPCTSTR NativeDialogWndProcProp = TEXT("SunAwtNativeDialogWndProcProp");
  38 
  39 #ifndef WH_MOUSE_LL
  40 #define WH_MOUSE_LL 14
  41 #endif
  42 
  43 class AwtFrame;
  44 
  45 /************************************************************************
  46  * AwtWindow class
  47  */
  48 
  49 class AwtWindow : public AwtCanvas {
  50 public:
  51 
  52     /* java.awt.Window field ids */
  53     static jfieldID warningStringID;
  54     static jfieldID locationByPlatformID;
  55     static jfieldID screenID; /* screen number passed over from WindowPeer */
  56     static jfieldID autoRequestFocusID;
  57     static jfieldID securityWarningWidthID;
  58     static jfieldID securityWarningHeightID;
  59 
  60     // The coordinates at the peer.
  61     static jfieldID sysXID;
  62     static jfieldID sysYID;
  63     static jfieldID sysWID;
  64     static jfieldID sysHID;
  65 
  66     static jfieldID windowTypeID;
  67 
  68     static jmethodID getWarningStringMID;
  69     static jmethodID calculateSecurityWarningPositionMID;
  70     static jmethodID windowTypeNameMID;
  71 
  72     AwtWindow();
  73     virtual ~AwtWindow();
  74 
  75     virtual void Dispose();
  76 
  77     virtual LPCTSTR GetClassName();
  78     virtual void FillClassInfo(WNDCLASSEX *lpwc);
  79 
  80     static AwtWindow* Create(jobject self, jobject parent);
  81 
  82     // Returns TRUE if this Window is equal to or one of owners of wnd
  83     BOOL IsOneOfOwnersOf(AwtWindow * wnd);
  84 
  85     /* Update the insets for this Window (container), its peer &
  86      * optional other
  87      */
  88     BOOL UpdateInsets(jobject insets = 0);
  89     BOOL HasValidRect();
  90 
  91     static BOOL CALLBACK UpdateOwnedIconCallback(HWND hwnd, LPARAM param);
  92 
  93     INLINE AwtFrame * GetOwningFrameOrDialog() { return m_owningFrameDialog; }
  94 
  95     HWND GetTopLevelHWnd();
  96 
  97     /* Subtract inset values from a window origin. */
  98     INLINE void SubtractInsetPoint(int& x, int& y) {
  99         x -= m_insets.left;
 100         y -= m_insets.top;
 101     }
 102 
 103     virtual void GetInsets(RECT* rect) {
 104         VERIFY(::CopyRect(rect, &m_insets));
 105     }
 106 
 107     /* to make embedded frames easier */
 108     virtual BOOL IsEmbeddedFrame() { return FALSE;}
 109 
 110     /* We can hold children */
 111     virtual BOOL IsContainer() { return TRUE;}
 112 
 113     virtual BOOL IsUndecorated() { return TRUE; }
 114 
 115     INLINE virtual BOOL IsSimpleWindow() { return TRUE; }
 116 
 117     INLINE BOOL IsRetainingHierarchyZOrder() { return m_isRetainingHierarchyZOrder; }
 118 
 119     /* WARNING: don't invoke on Toolkit thread! */
 120     INLINE BOOL IsAutoRequestFocus() {
 121         JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
 122         return env->GetBooleanField(GetTarget(env), AwtWindow::autoRequestFocusID);
 123     }
 124 
 125     INLINE virtual BOOL IsFocusedWindowModalBlocker() {
 126         return FALSE;
 127     }
 128 

 129     virtual void Invalidate(RECT* r);
 130     virtual void Show();
 131     virtual void SetResizable(BOOL isResizable);
 132     BOOL IsResizable();
 133     virtual void RecalcNonClient();
 134     virtual void RedrawNonClient();
 135     virtual int  GetScreenImOn();
 136     virtual void CheckIfOnNewScreen();
 137     virtual void Grab();
 138     virtual void Ungrab();
 139     virtual void Ungrab(BOOL doPost);
 140     virtual void SetIconData(JNIEnv* env, jintArray iconData, jint w, jint h,
 141                              jintArray smallIconData, jint smw, jint smh);
 142     virtual void DoUpdateIcon();
 143     INLINE HICON GetHIcon() {return m_hIcon;};
 144     INLINE HICON GetHIconSm() {return m_hIconSm;};
 145     INLINE BOOL IsIconInherited() {return m_iconInherited;};
 146     INLINE virtual BOOL IsLightweightFrame() {return FALSE;}
 147 
 148     /* Post events to the EventQueue */
 149     void SendComponentEvent(jint eventId);
 150     void SendWindowEvent(jint id, HWND opposite = NULL,
 151                          jint oldState = 0, jint newState = 0);
 152 
 153     BOOL IsFocusableWindow();
 154 
 155     /* some helper methods about blocking windows by modal dialogs */
 156     INLINE static HWND GetModalBlocker(HWND window) {
 157         return reinterpret_cast<HWND>(::GetProp(window, ModalBlockerProp));
 158     }
 159     static void SetModalBlocker(HWND window, HWND blocker);
 160     static void SetAndActivateModalBlocker(HWND window, HWND blocker);
 161 
 162     static HWND GetTopmostModalBlocker(HWND window);
 163 
 164     /*
 165      * Windows message handler functions
 166      */
 167     virtual MsgRouting WmActivate(UINT nState, BOOL fMinimized, HWND opposite);
 168     virtual MsgRouting WmCreate();
 169     virtual MsgRouting WmClose();
 170     virtual MsgRouting WmDestroy();
 171     virtual MsgRouting WmShowWindow(BOOL show, UINT status);
 172     virtual MsgRouting WmGetMinMaxInfo(LPMINMAXINFO lpmmi);
 173     virtual MsgRouting WmMove(int x, int y);
 174     virtual MsgRouting WmSize(UINT type, int w, int h);
 175     virtual MsgRouting WmSizing();
 176     virtual MsgRouting WmEnterSizeMove();
 177     virtual MsgRouting WmExitSizeMove();
 178     virtual MsgRouting WmPaint(HDC hDC);
 179     virtual MsgRouting WmSettingChange(UINT wFlag, LPCTSTR pszSection);
 180     virtual MsgRouting WmNcCalcSize(BOOL fCalcValidRects,
 181                                     LPNCCALCSIZE_PARAMS lpncsp, LRESULT& retVal);
 182     virtual MsgRouting WmNcHitTest(UINT x, UINT y, LRESULT& retVal);
 183     virtual MsgRouting WmNcMouseDown(WPARAM hitTest, int x, int y, int button);
 184     virtual MsgRouting WmGetIcon(WPARAM iconType, LRESULT& retVal);
 185     virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
 186     virtual MsgRouting WmWindowPosChanging(LPARAM windowPos);
 187     virtual MsgRouting WmWindowPosChanged(LPARAM windowPos);
 188     virtual MsgRouting WmTimer(UINT_PTR timerID);
 189 
 190     virtual MsgRouting HandleEvent(MSG *msg, BOOL synthetic);
 191     virtual void WindowResized();
 192 
 193     static jboolean _RequestWindowFocus(void *param);
 194 
 195     virtual BOOL AwtSetActiveWindow(BOOL isMouseEventCause = FALSE, UINT hittest = HTCLIENT);
 196 
 197     // Execute on Toolkit only.
 198     INLINE static LRESULT SynthesizeWmActivate(BOOL doActivate, HWND targetHWnd, HWND oppositeHWnd) {
 199         AwtWindow *win = static_cast<AwtWindow*>(AwtComponent::GetComponent(targetHWnd));
 200         if (doActivate &&
 201             (!::IsWindowVisible(targetHWnd) || ::IsIconic(::GetAncestor(targetHWnd, GA_ROOT))) &&
 202             (win == NULL || !win->IsLightweightFrame()))
 203         {
 204             // The activation is rejected if either:
 205             // - The toplevel is not visible
 206             // - The toplevel (or its embedder) is minimised
 207             return 1;
 208         }
 209         return ::SendMessage(targetHWnd, WM_ACTIVATE,
 210                              MAKEWPARAM(doActivate ? WA_ACTIVE : WA_INACTIVE, FALSE),
 211                              (LPARAM) oppositeHWnd);
 212     }
 213 
 214     void moveToDefaultLocation(); /* moves Window to X,Y specified by Window Manger */
 215 
 216     void UpdateWindow(JNIEnv* env, jintArray data, int width, int height,
 217                       HBITMAP hNewBitmap = NULL);
 218 
 219     INLINE virtual BOOL IsTopLevel() { return TRUE; }
 220     static AwtWindow * GetGrabbedWindow() { return m_grabbedWindow; }
 221 
 222     static void FlashWindowEx(HWND hWnd, UINT count, DWORD timeout, DWORD flags);
 223 
 224     // some methods invoked on Toolkit thread
 225     static void _ToFront(void *param);
 226     static void _ToBack(void *param);
 227     static void _Grab(void *param);
 228     static void _Ungrab(void *param);
 229     static void _SetAlwaysOnTop(void *param);
 230     static void _SetTitle(void *param);
 231     static void _SetResizable(void *param);
 232     static void _UpdateInsets(void *param);
 233     static void _ReshapeFrame(void *param);
 234     static void _SetIconImagesData(void * param);
 235     static void _SetMinSize(void* param);
 236     static jint _GetScreenImOn(void *param);
 237     static void _SetFocusableWindow(void *param);
 238     static void _SetModalExcludedNativeProp(void *param);
 239     static void _ModalDisable(void *param);
 240     static void _ModalEnable(void *param);
 241     static void _SetOpacity(void* param);
 242     static void _SetOpaque(void* param);
 243     static void _UpdateWindow(void* param);
 244     static void _RepositionSecurityWarning(void* param);
 245     static void _SetFullScreenExclusiveModeState(void* param);
 246     static void _GetNativeWindowSize(void* param);
 247     static void _WindowDPIChange(void* param);
 248     static void _OverrideHandle(void *param);
 249 
 250     inline static BOOL IsResizing() {
 251         return sm_resizing;
 252     }
 253 
 254     virtual void CreateHWnd(JNIEnv *env, LPCWSTR title,
 255             DWORD windowStyle, DWORD windowExStyle,
 256             int x, int y, int w, int h,
 257             HWND hWndParent, HMENU hMenu,
 258             COLORREF colorForeground, COLORREF colorBackground,
 259             jobject peer);
 260     virtual void DestroyHWnd();
 261 
 262     static void FocusedWindowChanged(HWND from, HWND to);
 263 
 264     inline HWND GetOverriddenHWnd() { return m_overriddenHwnd; }
 265     inline void OverrideHWnd(HWND hwnd) { m_overriddenHwnd = hwnd; }
 266 
 267 private:
 268     static int ms_instanceCounter;
 269     static HHOOK ms_hCBTFilter;
 270     static LRESULT CALLBACK CBTFilter(int nCode, WPARAM wParam, LPARAM lParam);
 271     static BOOL sm_resizing;        /* in the middle of a resizing operation */
 272 
 273     RECT m_insets;          /* a cache of the insets being used */
 274     RECT m_old_insets;      /* help determine if insets change */
 275     POINT m_sizePt;         /* the last value of WM_SIZE */
 276     RECT m_warningRect;     /* The window's warning banner area, if any. */
 277     AwtFrame *m_owningFrameDialog; /* The nearest Frame/Dialog which owns us */
 278     BOOL m_isFocusableWindow; /* a cache of Window.isFocusableWindow() return value */
 279     POINT m_minSize;          /* Minimum size of the window for WM_GETMINMAXINFO message */
 280     BOOL m_grabbed; // Whether the current window is grabbed
 281     BOOL m_isRetainingHierarchyZOrder; // Is this a window that shouldn't change z-order of any window
 282                                        // from its hierarchy when shown. Currently applied to instances of
 283                                        // javax/swing/Popup$HeavyWeightWindow class.
 284 
 285     // SetTranslucency() is the setter for the following two fields
 286     BYTE m_opacity;         // The opacity level. == 0xff by default (when opacity mode is disabled)
 287     BOOL m_opaque;          // Whether the window uses the perpixel translucency (false), or not (true).
 288 
 289     inline BYTE getOpacity() {
 290         return m_opacity;
 291     }
 292 
 293     inline BOOL isOpaque() {
 294         return m_opaque;
 295     }
 296 
 297     CRITICAL_SECTION contentBitmapCS;
 298     HBITMAP hContentBitmap;
 299     UINT contentWidth;
 300     UINT contentHeight;
 301 
 302     void SetTranslucency(BYTE opacity, BOOL opaque, BOOL setValues = TRUE,
 303             BOOL useDefaultForOldValues = FALSE);
 304     void UpdateWindow(int width, int height, HBITMAP hBitmap);
 305     void UpdateWindowImpl(int width, int height, HBITMAP hBitmap);
 306     void RedrawWindow();
 307     void DeleteContentBitmap();
 308 
 309     static UINT untrustedWindowsCounter;
 310 
 311     WCHAR * warningString;
 312 
 313     // The warning icon
 314     HWND warningWindow;
 315     // The tooltip that appears when hovering the icon
 316     HWND securityTooltipWindow;
 317 
 318     //Allows substitute parent window with JavaFX stage to make it below a dialog
 319     HWND m_overriddenHwnd;
 320 
 321     UINT warningWindowWidth;
 322     UINT warningWindowHeight;
 323     void InitSecurityWarningSize(JNIEnv *env);
 324     HICON GetSecurityWarningIcon();
 325 
 326     void CreateWarningWindow(JNIEnv *env);
 327     void DestroyWarningWindow();
 328     static LPCTSTR GetWarningWindowClassName();
 329     void FillWarningWindowClassInfo(WNDCLASS *lpwc);
 330     void RegisterWarningWindowClass();
 331     void UnregisterWarningWindowClass();
 332     static LRESULT CALLBACK WarningWindowProc(
 333             HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 334 
 335     static void PaintWarningWindow(HWND warningWindow);
 336     static void PaintWarningWindow(HWND warningWindow, HDC hdc);
 337     void RepaintWarningWindow();
 338     void CalculateWarningWindowBounds(JNIEnv *env, LPRECT rect);
 339 
 340     void AnimateSecurityWarning(bool enable);
 341     UINT securityWarningAnimationStage;
 342 
 343     enum AnimationKind {
 344         akNone, akShow, akPreHide, akHide
 345     };
 346 
 347     AnimationKind securityAnimationKind;
 348 
 349     void StartSecurityAnimation(AnimationKind kind);
 350     void StopSecurityAnimation();
 351 
 352     void RepositionSecurityWarning(JNIEnv *env);
 353 
 354     static void SetLayered(HWND window, bool layered);
 355     static bool IsLayered(HWND window);
 356 
 357     BOOL fullScreenExclusiveModeState;
 358     inline void setFullScreenExclusiveModeState(BOOL isEntered) {
 359         fullScreenExclusiveModeState = isEntered;
 360         UpdateSecurityWarningVisibility();
 361     }
 362     inline BOOL isFullScreenExclusiveMode() {
 363         return fullScreenExclusiveModeState;
 364     }
 365 
 366 
 367 public:
 368     void UpdateSecurityWarningVisibility();
 369     static bool IsWarningWindow(HWND hWnd);
 370 
 371 protected:
 372     BOOL m_isResizable;
 373     static AwtWindow* m_grabbedWindow; // Current grabbing window
 374     HICON m_hIcon;            /* Icon for this window. It can be set explicitely or inherited from the owner */
 375     HICON m_hIconSm;          /* Small icon for this window. It can be set explicitely or inherited from the owner */
 376     BOOL m_iconInherited;     /* TRUE if icon is inherited from the owner */
 377     BOOL m_filterFocusAndActivation; /* Used in the WH_CBT hook */
 378 
 379     inline BOOL IsUntrusted() {
 380         return warningString != NULL;
 381     }
 382 
 383     UINT currentWmSizeState;
 384 
 385     void EnableTranslucency(BOOL enable);
 386 
 387     // Native representation of the java.awt.Window.Type enum
 388     enum Type {
 389         NORMAL, UTILITY, POPUP
 390     };
 391 
 392     inline Type GetType() { return m_windowType; }
 393 
 394 private:
 395     int m_screenNum;
 396 
 397     typedef struct {
 398         jint screen;
 399         jfloat scaleX;
 400         jfloat scaleY;
 401     } ScaleRec;
 402 
 403     BOOL m_winSizeMove;
 404     ScaleRec prevScaleRec;
 405 
 406     void InitOwner(AwtWindow *owner);
 407     void CheckWindowDPIChange();
 408     void WindowDPIChange(int prevScreen, float prevScaleX, float prevScaleY,
 409                          int newScreen, float scaleX, float scaleY);
 410 
 411     Type m_windowType;
 412     void InitType(JNIEnv *env, jobject peer);
 413 
 414     // Tweak the style according to the type of the window
 415     void TweakStyle(DWORD & style, DWORD & exStyle);
 416 
 417     // Set in _SetAlwaysOnTop()
 418     bool m_alwaysOnTop;
 419 public:
 420     inline bool IsAlwaysOnTop() { return m_alwaysOnTop; }
 421 };
 422 
 423 HICON CreateIconFromRaster(JNIEnv* env, jintArray iconRaster, jint w, jint h);
 424 
 425 #endif /* AWT_WINDOW_H */
--- EOF ---