The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* vim:set ts=2 sts=2 sw=2 et cin: */

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this

  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

 /*

  * nsWindow - Native window management and event handling.

  * 

  * nsWindow is organized into a set of major blocks and

  * block subsections. The layout is as follows:

  *

  *  Includes

  *  Variables

  *  nsIWidget impl.

  *     nsIWidget methods and utilities

  *  nsSwitchToUIThread impl.

  *     nsSwitchToUIThread methods and utilities

  *  Moz events

  *     Event initialization

  *     Event dispatching

  *  Native events

  *     Wndproc(s)

  *     Event processing

  *     OnEvent event handlers

  *  IME management and accessibility

  *  Transparency

  *  Popup hook handling

  *  Misc. utilities

  *  Child window impl.

  *

  * Search for "BLOCK:" to find major blocks.

  * Search for "SECTION:" to find specific sections.

  *

  * Blocks should be split out into separate files if they

  * become unmanageable.

  *

  * Related source:

  *

  *  nsWindowDefs.h     - Definitions, macros, structs, enums

  *                       and general setup.

  *  nsWindowDbg.h/.cpp - Debug related code and directives.

  *  nsWindowGfx.h/.cpp - Graphics and painting.

  *

  */

 /**************************************************************

  **************************************************************

  **

  ** BLOCK: Includes

  **

  ** Include headers.

  **

  **************************************************************

  **************************************************************/

 #include "mozilla/MathAlgorithms.h"

 #include "mozilla/MiscEvents.h"

 #include "mozilla/MouseEvents.h"

 #include "mozilla/TouchEvents.h"

 #include "mozilla/ipc/MessageChannel.h"

 #include <algorithm>

 #include "nsWindow.h"

 #include <shellapi.h>

 #include <windows.h>

 #include <process.h>

 #include <commctrl.h>

 #include <unknwn.h>

 #include <psapi.h>

 #include "prlog.h"

 #include "prtime.h"

 #include "prprf.h"

 #include "prmem.h"

 #include "prenv.h"

 #include "mozilla/WidgetTraceEvent.h"

 #include "nsIAppShell.h"

 #include "nsISupportsPrimitives.h"

 #include "nsIDOMMouseEvent.h"

 #include "nsITheme.h"

 #include "nsIObserverService.h"

 #include "nsIScreenManager.h"

 #include "imgIContainer.h"

 #include "nsIFile.h"

 #include "nsIRollupListener.h"

 #include "nsIServiceManager.h"

 #include "nsIClipboard.h"

 #include "nsIMM32Handler.h"

 #include "WinMouseScrollHandler.h"

 #include "nsFontMetrics.h"

 #include "nsIFontEnumerator.h"

 #include "nsFont.h"

 #include "nsRect.h"

 #include "nsThreadUtils.h"

 #include "nsNativeCharsetUtils.h"

 #include "nsGkAtoms.h"

 #include "nsCRT.h"

 #include "nsAppDirectoryServiceDefs.h"

 #include "nsXPIDLString.h"

 #include "nsWidgetsCID.h"

 #include "nsTHashtable.h"

 #include "nsHashKeys.h"

 #include "nsString.h"

 #include "mozilla/Services.h"

 #include "nsNativeThemeWin.h"

 #include "nsWindowsDllInterceptor.h"

 #include "nsLayoutUtils.h"

 #include "nsView.h"

 #include "nsIWindowMediator.h"

 #include "nsIServiceManager.h"

 #include "nsWindowGfx.h"

 #include "gfxWindowsPlatform.h"

 #include "Layers.h"

 #include "nsPrintfCString.h"

 #include "mozilla/Preferences.h"

 #include "nsISound.h"

 #include "WinTaskbar.h"

 #include "WinUtils.h"

 #include "WidgetUtils.h"

 #include "nsIWidgetListener.h"

 #include "mozilla/dom/Touch.h"

 #include "mozilla/gfx/2D.h"

 #include "nsToolkitCompsCID.h"

 #include "nsIAppStartup.h"

 #include "mozilla/WindowsVersion.h"

 #include "nsThemeConstants.h"

 #ifdef MOZ_ENABLE_D3D9_LAYER

 #include "LayerManagerD3D9.h"

 #endif

 #ifdef MOZ_ENABLE_D3D10_LAYER

 #include "LayerManagerD3D10.h"

 #endif

 #include "nsIGfxInfo.h"

 #include "nsUXThemeConstants.h"

 #include "KeyboardLayout.h"

 #include "nsNativeDragTarget.h"

 #include <mmsystem.h> // needed for WIN32_LEAN_AND_MEAN

 #include <zmouse.h>

 #include <richedit.h>

 #if defined(ACCESSIBILITY)

 #ifdef DEBUG

 #include "mozilla/a11y/Logging.h"

 #endif

 #include "oleidl.h"

 #include <winuser.h>

 #include "nsAccessibilityService.h"

 #include "mozilla/a11y/DocAccessible.h"

 #include "mozilla/a11y/Platform.h"

 #if !defined(WINABLEAPI)

 #include <winable.h>

 #endif // !defined(WINABLEAPI)

 #endif // defined(ACCESSIBILITY)

 #include "nsIWinTaskbar.h"

 #define NS_TASKBAR_CONTRACTID "@mozilla.org/windows-taskbar;1"

 #include "nsWindowDefs.h"

 #include "nsCrashOnException.h"

 #include "nsIXULRuntime.h"

 #include "nsIContent.h"

 #include "mozilla/HangMonitor.h"

 #include "WinIMEHandler.h"

 #include "npapi.h"

 #if !defined(SM_CONVERTIBLESLATEMODE)

 #define SM_CONVERTIBLESLATEMODE 0x2003

 #endif

 using namespace mozilla;

 using namespace mozilla::dom;

 using namespace mozilla::layers;

 using namespace mozilla::widget;

 /**************************************************************

  **************************************************************

  **

  ** BLOCK: Variables

  **

  ** nsWindow Class static initializations and global variables. 

  **

  **************************************************************

  **************************************************************/

 /**************************************************************

  *

  * SECTION: nsWindow statics

  *

  **************************************************************/

 bool            nsWindow::sDropShadowEnabled      = true;

 uint32_t        nsWindow::sInstanceCount          = 0;

 bool            nsWindow::sSwitchKeyboardLayout   = false;

 BOOL            nsWindow::sIsOleInitialized       = FALSE;

 HCURSOR         nsWindow::sHCursor                = nullptr;

 imgIContainer*  nsWindow::sCursorImgContainer     = nullptr;

 nsWindow*       nsWindow::sCurrentWindow          = nullptr;

 bool            nsWindow::sJustGotDeactivate      = false;

 bool            nsWindow::sJustGotActivate        = false;

 bool            nsWindow::sIsInMouseCapture       = false;

 // imported in nsWidgetFactory.cpp

 TriStateBool    nsWindow::sCanQuit                = TRI_UNKNOWN;

 // Hook Data Memebers for Dropdowns. sProcessHook Tells the

 // hook methods whether they should be processing the hook

 // messages.

 HHOOK           nsWindow::sMsgFilterHook          = nullptr;

 HHOOK           nsWindow::sCallProcHook           = nullptr;

 HHOOK           nsWindow::sCallMouseHook          = nullptr;

 bool            nsWindow::sProcessHook            = false;

 UINT            nsWindow::sRollupMsgId            = 0;

 HWND            nsWindow::sRollupMsgWnd           = nullptr;

 UINT            nsWindow::sHookTimerId            = 0;

 // Mouse Clicks - static variable definitions for figuring

 // out 1 - 3 Clicks.

 POINT           nsWindow::sLastMousePoint         = {0};

 POINT           nsWindow::sLastMouseMovePoint     = {0};

 LONG            nsWindow::sLastMouseDownTime      = 0L;

 LONG            nsWindow::sLastClickCount         = 0L;

 BYTE            nsWindow::sLastMouseButton        = 0;

 // Trim heap on minimize. (initialized, but still true.)

 int             nsWindow::sTrimOnMinimize         = 2;

 // Default value for general window class (used when the pref is the empty string).

 const char*     nsWindow::sDefaultMainWindowClass = kClassNameGeneral;

 // If we're using D3D9, this will not be allowed during initial 5 seconds.

 bool            nsWindow::sAllowD3D9              = false;

 TriStateBool nsWindow::sHasBogusPopupsDropShadowOnMultiMonitor = TRI_UNKNOWN;

 // Used in OOPP plugin focus processing.

 const wchar_t* kOOPPPluginFocusEventId   = L"OOPP Plugin Focus Widget Event";

 uint32_t        nsWindow::sOOPPPluginFocusEvent   =

                   RegisterWindowMessageW(kOOPPPluginFocusEventId);

 /**************************************************************

  *

  * SECTION: globals variables

  *

  **************************************************************/

 static const char *sScreenManagerContractID       = "@mozilla.org/gfx/screenmanager;1";

 #ifdef PR_LOGGING

 extern PRLogModuleInfo* gWindowsLog;

 #endif

 // Global used in Show window enumerations.

 static bool     gWindowsVisible                   = false;

 // True if we have sent a notification that we are suspending/sleeping.

 static bool     gIsSleepMode                      = false;

 static NS_DEFINE_CID(kCClipboardCID, NS_CLIPBOARD_CID);

 // General purpose user32.dll hook object

 static WindowsDllInterceptor sUser32Intercept;

 // 2 pixel offset for eTransparencyBorderlessGlass which equals the size of

 // the default window border Windows paints. Glass will be extended inward

 // this distance to remove the border.

 static const int32_t kGlassMarginAdjustment = 2;

 // When the client area is extended out into the default window frame area,

 // this is the minimum amount of space along the edge of resizable windows

 // we will always display a resize cursor in, regardless of the underlying

 // content.

 static const int32_t kResizableBorderMinSize = 3;

 // Cached pointer events enabler value, True if pointer events are enabled.

 static bool gIsPointerEventsEnabled = false;

 // We should never really try to accelerate windows bigger than this. In some

 // cases this might lead to no D3D9 acceleration where we could have had it

 // but D3D9 does not reliably report when it supports bigger windows. 8192

 // is as safe as we can get, we know at least D3D10 hardware always supports

 // this, other hardware we expect to report correctly in D3D9.

 #define MAX_ACCELERATED_DIMENSION 8192

 // On window open (as well as after), Windows has an unfortunate habit of

 // sending rather a lot of WM_NCHITTEST messages. Because we have to do point

 // to DOM target conversions for these, we cache responses for a given

 // coordinate this many milliseconds:

 #define HITTEST_CACHE_LIFETIME_MS 50

 /**************************************************************

  **************************************************************

  **

  ** BLOCK: nsIWidget impl.

  **

  ** nsIWidget interface implementation, broken down into

  ** sections.

  **

  **************************************************************

  **************************************************************/

 /**************************************************************

  *

  * SECTION: nsWindow construction and destruction

  *

  **************************************************************/

 nsWindow::nsWindow() : nsWindowBase()

 {

   mIconSmall            = nullptr;

   mIconBig              = nullptr;

   mWnd                  = nullptr;

   mPaintDC              = nullptr;

   mCompositeDC          = nullptr;

   mPrevWndProc          = nullptr;

   mNativeDragTarget     = nullptr;

   mInDtor               = false;

   mIsVisible            = false;

   mIsTopWidgetWindow    = false;

   mUnicodeWidget        = true;

   mDisplayPanFeedback   = false;

   mTouchWindow          = false;

   mCustomNonClient      = false;

   mHideChrome           = false;

   mFullscreenMode       = false;

   mMousePresent         = false;

   mDestroyCalled        = false;

   mHasTaskbarIconBeenCreated = false;

   mMouseTransparent     = false;

   mPickerDisplayCount   = 0;

   mWindowType           = eWindowType_child;

   mBorderStyle          = eBorderStyle_default;

   mOldSizeMode          = nsSizeMode_Normal;

   mLastSizeMode         = nsSizeMode_Normal;

   mLastSize.width       = 0;

   mLastSize.height      = 0;

   mOldStyle             = 0;

   mOldExStyle           = 0;

   mPainting             = 0;

   mLastKeyboardLayout   = 0;

   mBlurSuppressLevel    = 0;

   mLastPaintEndTime     = TimeStamp::Now();

   mCachedHitTestPoint.x = 0;

   mCachedHitTestPoint.y = 0;

   mCachedHitTestTime    = TimeStamp::Now();

   mCachedHitTestResult  = 0;

 #ifdef MOZ_XUL

   mTransparentSurface   = nullptr;

   mMemoryDC             = nullptr;

   mTransparencyMode     = eTransparencyOpaque;

   memset(&mGlassMargins, 0, sizeof mGlassMargins);

 #endif

   DWORD background      = ::GetSysColor(COLOR_BTNFACE);

   mBrush                = ::CreateSolidBrush(NSRGB_2_COLOREF(background));

   mTaskbarPreview = nullptr;

   // Global initialization

   if (!sInstanceCount) {

     // Global app registration id for Win7 and up. See

     // WinTaskbar.cpp for details.

     mozilla::widget::WinTaskbar::RegisterAppUserModelID();

     KeyboardLayout::GetInstance()->OnLayoutChange(::GetKeyboardLayout(0));

     IMEHandler::Initialize();

     if (SUCCEEDED(::OleInitialize(nullptr))) {

       sIsOleInitialized = TRUE;

     }

     NS_ASSERTION(sIsOleInitialized, "***** OLE is not initialized!\n");

     MouseScrollHandler::Initialize();

     // Init titlebar button info for custom frames.

     nsUXThemeData::InitTitlebarInfo();

     // Init theme data

     nsUXThemeData::UpdateNativeThemeInfo();

     RedirectedKeyDownMessageManager::Forget();

     Preferences::AddBoolVarCache(&gIsPointerEventsEnabled,

                                  "dom.w3c_pointer_events.enabled",

                                  gIsPointerEventsEnabled);

   } // !sInstanceCount

   mIdleService = nullptr;

   sInstanceCount++;

 }

 nsWindow::~nsWindow()

 {

   mInDtor = true;

   // If the widget was released without calling Destroy() then the native window still

   // exists, and we need to destroy it. This will also result in a call to OnDestroy.

   //

   // XXX How could this happen???

   if (nullptr != mWnd)

     Destroy();

   // Free app icon resources.  This must happen after `OnDestroy` (see bug 708033).

   if (mIconSmall)

     ::DestroyIcon(mIconSmall);

   if (mIconBig)

     ::DestroyIcon(mIconBig);

   sInstanceCount--;

   // Global shutdown

   if (sInstanceCount == 0) {

     IMEHandler::Terminate();

     NS_IF_RELEASE(sCursorImgContainer);

     if (sIsOleInitialized) {

       ::OleFlushClipboard();

       ::OleUninitialize();

       sIsOleInitialized = FALSE;

     }

   }

   NS_IF_RELEASE(mNativeDragTarget);

 }

 NS_IMPL_ISUPPORTS_INHERITED0(nsWindow, nsBaseWidget)

 /**************************************************************

  *

  * SECTION: nsIWidget::Create, nsIWidget::Destroy

  *

  * Creating and destroying windows for this widget.

  *

  **************************************************************/

 // Allow Derived classes to modify the height that is passed

 // when the window is created or resized.

 int32_t nsWindow::GetHeight(int32_t aProposedHeight)

 {

   return aProposedHeight;

 }

 // Create the proper widget

 nsresult

 nsWindow::Create(nsIWidget *aParent,

                  nsNativeWidget aNativeParent,

                  const nsIntRect &aRect,

                  nsDeviceContext *aContext,

                  nsWidgetInitData *aInitData)

 {

   nsWidgetInitData defaultInitData;

   if (!aInitData)

     aInitData = &defaultInitData;

   mUnicodeWidget = aInitData->mUnicode;

   nsIWidget *baseParent = aInitData->mWindowType == eWindowType_dialog ||

                           aInitData->mWindowType == eWindowType_toplevel ||

                           aInitData->mWindowType == eWindowType_invisible ?

                           nullptr : aParent;

   mIsTopWidgetWindow = (nullptr == baseParent);

   mBounds = aRect;

   // Ensure that the toolkit is created.

   nsToolkit::GetToolkit();

   BaseCreate(baseParent, aRect, aContext, aInitData);

   HWND parent;

   if (aParent) { // has a nsIWidget parent

     parent = aParent ? (HWND)aParent->GetNativeData(NS_NATIVE_WINDOW) : nullptr;

     mParent = aParent;

   } else { // has a nsNative parent

     parent = (HWND)aNativeParent;

     mParent = aNativeParent ?

       WinUtils::GetNSWindowPtr((HWND)aNativeParent) : nullptr;

   }

   mIsRTL = aInitData->mRTL;

   DWORD style = WindowStyle();

   DWORD extendedStyle = WindowExStyle();

   if (mWindowType == eWindowType_popup) {

     if (!aParent) {

       parent = nullptr;

     }

     if (IsVistaOrLater() && !IsWin8OrLater() &&

         HasBogusPopupsDropShadowOnMultiMonitor()) {

       extendedStyle |= WS_EX_COMPOSITED;

     }

     if (aInitData->mMouseTransparent) {

       // This flag makes the window transparent to mouse events

       mMouseTransparent = true;

       extendedStyle |= WS_EX_TRANSPARENT;

     }

   } else if (mWindowType == eWindowType_invisible) {

     // Make sure CreateWindowEx succeeds at creating a toplevel window

     style &= ~0x40000000; // WS_CHILDWINDOW

   } else {

     // See if the caller wants to explictly set clip children and clip siblings

     if (aInitData->clipChildren) {

       style |= WS_CLIPCHILDREN;

     } else {

       style &= ~WS_CLIPCHILDREN;

     }

     if (aInitData->clipSiblings) {

       style |= WS_CLIPSIBLINGS;

     }

   }

   nsAutoString className;

   if (aInitData->mDropShadow) {

     GetWindowPopupClass(className);

   } else {

     GetWindowClass(className);

   }

   // Plugins are created in the disabled state so that they can't

   // steal focus away from our main window.  This is especially

   // important if the plugin has loaded in a background tab.

   if(aInitData->mWindowType == eWindowType_plugin) {

     style |= WS_DISABLED;

   }

   mWnd = ::CreateWindowExW(extendedStyle,

                            className.get(),

                            L"",

                            style,

                            aRect.x,

                            aRect.y,

                            aRect.width,

                            GetHeight(aRect.height),

                            parent,

                            nullptr,

                            nsToolkit::mDllInstance,

                            nullptr);

   if (!mWnd) {

     NS_WARNING("nsWindow CreateWindowEx failed.");

     return NS_ERROR_FAILURE;

   }

   if (mIsRTL && WinUtils::dwmSetWindowAttributePtr) {

     DWORD dwAttribute = TRUE;    

     WinUtils::dwmSetWindowAttributePtr(mWnd, DWMWA_NONCLIENT_RTL_LAYOUT, &dwAttribute, sizeof dwAttribute);

   }

   if (mWindowType != eWindowType_plugin &&

       mWindowType != eWindowType_invisible &&

       MouseScrollHandler::Device::IsFakeScrollableWindowNeeded()) {

     // Ugly Thinkpad Driver Hack (Bugs 507222 and 594977)

     //

     // We create two zero-sized windows as descendants of the top-level window,

     // like so:

     //

     //   Top-level window (MozillaWindowClass)

     //     FAKETRACKPOINTSCROLLCONTAINER (MozillaWindowClass)

     //       FAKETRACKPOINTSCROLLABLE (MozillaWindowClass)

     //

     // We need to have the middle window, otherwise the Trackpoint driver

     // will fail to deliver scroll messages.  WM_MOUSEWHEEL messages are

     // sent to the FAKETRACKPOINTSCROLLABLE, which then propagate up the

     // window hierarchy until they are handled by nsWindow::WindowProc.

     // WM_HSCROLL messages are also sent to the FAKETRACKPOINTSCROLLABLE,

     // but these do not propagate automatically, so we have the window

     // procedure pretend that they were dispatched to the top-level window

     // instead.

     //

     // The FAKETRACKPOINTSCROLLABLE needs to have the specific window styles it

     // is given below so that it catches the Trackpoint driver's heuristics.

     HWND scrollContainerWnd = ::CreateWindowW

       (className.get(), L"FAKETRACKPOINTSCROLLCONTAINER",

        WS_CHILD | WS_VISIBLE,

        0, 0, 0, 0, mWnd, nullptr, nsToolkit::mDllInstance, nullptr);

     HWND scrollableWnd = ::CreateWindowW

       (className.get(), L"FAKETRACKPOINTSCROLLABLE",

        WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | 0x30,

        0, 0, 0, 0, scrollContainerWnd, nullptr, nsToolkit::mDllInstance,

        nullptr);

     // Give the FAKETRACKPOINTSCROLLABLE window a specific ID so that

     // WindowProcInternal can distinguish it from the top-level window

     // easily.

     ::SetWindowLongPtrW(scrollableWnd, GWLP_ID, eFakeTrackPointScrollableID);

     // Make FAKETRACKPOINTSCROLLABLE use nsWindow::WindowProc, and store the

     // old window procedure in its "user data".

     WNDPROC oldWndProc;

     if (mUnicodeWidget)

       oldWndProc = (WNDPROC)::SetWindowLongPtrW(scrollableWnd, GWLP_WNDPROC,

                                                 (LONG_PTR)nsWindow::WindowProc);

     else

       oldWndProc = (WNDPROC)::SetWindowLongPtrA(scrollableWnd, GWLP_WNDPROC,

                                                 (LONG_PTR)nsWindow::WindowProc);

     ::SetWindowLongPtrW(scrollableWnd, GWLP_USERDATA, (LONG_PTR)oldWndProc);

   }

   SubclassWindow(TRUE);

   IMEHandler::InitInputContext(this, mInputContext);

   // If the internal variable set by the config.trim_on_minimize pref has not

   // been initialized, and if this is the hidden window (conveniently created

   // before any visible windows, and after the profile has been initialized),

   // do some initialization work.

   if (sTrimOnMinimize == 2 && mWindowType == eWindowType_invisible) {

     // Our internal trim prevention logic is effective on 2K/XP at maintaining

     // the working set when windows are minimized, but on Vista and up it has

     // little to no effect. Since this feature has been the source of numerous

     // bugs over the years, disable it (sTrimOnMinimize=1) on Vista and up.

     sTrimOnMinimize =

       Preferences::GetBool("config.trim_on_minimize",

         IsVistaOrLater() ? 1 : 0);

     sSwitchKeyboardLayout =

       Preferences::GetBool("intl.keyboard.per_window_layout", false);

   }

   // Query for command button metric data for rendering the titlebar. We

   // only do this once on the first window.

   if (mWindowType == eWindowType_toplevel &&

       (!nsUXThemeData::sTitlebarInfoPopulatedThemed ||

        !nsUXThemeData::sTitlebarInfoPopulatedAero)) {

     nsUXThemeData::UpdateTitlebarInfo(mWnd);

   }

   return NS_OK;

 }

 // Close this nsWindow

 NS_METHOD nsWindow::Destroy()

 {

   // WM_DESTROY has already fired, avoid calling it twice

   if (mOnDestroyCalled)

     return NS_OK;

   // Don't destroy windows that have file pickers open, we'll tear these down

   // later once the picker is closed.

   mDestroyCalled = true;

   if (mPickerDisplayCount)

     return NS_OK;

   // During the destruction of all of our children, make sure we don't get deleted.

   nsCOMPtr<nsIWidget> kungFuDeathGrip(this);

   /**

    * On windows the LayerManagerOGL destructor wants the widget to be around for

    * cleanup. It also would like to have the HWND intact, so we nullptr it here.

    */

   if (mLayerManager) {

     mLayerManager->Destroy();

   }

   mLayerManager = nullptr;

   /* We should clear our cached resources now and not wait for the GC to

    * delete the nsWindow. */

   ClearCachedResources();

   // The DestroyWindow function destroys the specified window. The function sends WM_DESTROY

   // and WM_NCDESTROY messages to the window to deactivate it and remove the keyboard focus

   // from it. The function also destroys the window's menu, flushes the thread message queue,

   // destroys timers, removes clipboard ownership, and breaks the clipboard viewer chain (if

   // the window is at the top of the viewer chain).

   //

   // If the specified window is a parent or owner window, DestroyWindow automatically destroys

   // the associated child or owned windows when it destroys the parent or owner window. The

   // function first destroys child or owned windows, and then it destroys the parent or owner

   // window.

   VERIFY(::DestroyWindow(mWnd));

   // Our windows can be subclassed which may prevent us receiving WM_DESTROY. If OnDestroy()

   // didn't get called, call it now.

   if (false == mOnDestroyCalled) {

     MSGResult msgResult;

     mWindowHook.Notify(mWnd, WM_DESTROY, 0, 0, msgResult);

     OnDestroy();

   }

   return NS_OK;

 }

 /**************************************************************

  *

  * SECTION: Window class utilities

  *

  * Utilities for calculating the proper window class name for

  * Create window.

  *

  **************************************************************/

 void nsWindow::RegisterWindowClass(const nsString& aClassName, UINT aExtraStyle,

                                    LPWSTR aIconID)

 {

   WNDCLASSW wc;

   if (::GetClassInfoW(nsToolkit::mDllInstance, aClassName.get(), &wc)) {

     // already registered

     return;

   }

   wc.style         = CS_DBLCLKS | aExtraStyle;

   wc.lpfnWndProc   = ::DefWindowProcW;

   wc.cbClsExtra    = 0;

   wc.cbWndExtra    = 0;

   wc.hInstance     = nsToolkit::mDllInstance;

   wc.hIcon         = aIconID ? ::LoadIconW(::GetModuleHandleW(nullptr), aIconID) : nullptr;

   wc.hCursor       = nullptr;

   wc.hbrBackground = mBrush;

   wc.lpszMenuName  = nullptr;

   wc.lpszClassName = aClassName.get();

   if (!::RegisterClassW(&wc)) {

     // For older versions of Win32 (i.e., not XP), the registration may

     // fail with aExtraStyle, so we have to re-register without it.

     wc.style = CS_DBLCLKS;

     ::RegisterClassW(&wc);

   }

 }

 static LPWSTR const gStockApplicationIcon = MAKEINTRESOURCEW(32512);

 // Return the proper window class for everything except popups.

 void nsWindow::GetWindowClass(nsString& aWindowClass)

 {

   switch (mWindowType) {

   case eWindowType_invisible:

     aWindowClass.AssignLiteral(kClassNameHidden);

     RegisterWindowClass(aWindowClass, 0, gStockApplicationIcon);

     break;

   case eWindowType_dialog:

     aWindowClass.AssignLiteral(kClassNameDialog);

     RegisterWindowClass(aWindowClass, 0, 0);

     break;

   default:

     GetMainWindowClass(aWindowClass);

     RegisterWindowClass(aWindowClass, 0, gStockApplicationIcon);

     break;

   }

 }

 // Return the proper popup window class

 void nsWindow::GetWindowPopupClass(nsString& aWindowClass)

 {

   aWindowClass.AssignLiteral(kClassNameDropShadow);

   RegisterWindowClass(aWindowClass, CS_XP_DROPSHADOW, gStockApplicationIcon);

 }

 /**************************************************************

  *

  * SECTION: Window styles utilities

  *

  * Return the proper windows styles and extended styles.

  *

  **************************************************************/

 // Return nsWindow styles

 DWORD nsWindow::WindowStyle()

 {

   DWORD style;

   switch (mWindowType) {

     case eWindowType_plugin:

     case eWindowType_child:

       style = WS_OVERLAPPED;

       break;

     case eWindowType_dialog:

       style = WS_OVERLAPPED | WS_BORDER | WS_DLGFRAME | WS_SYSMENU | DS_3DLOOK |

               DS_MODALFRAME | WS_CLIPCHILDREN;

       if (mBorderStyle != eBorderStyle_default)

         style |= WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;

       break;

     case eWindowType_popup:

       style = WS_POPUP;

       if (!HasGlass()) {

         style |= WS_OVERLAPPED;

       }

       break;

     default:

       NS_ERROR("unknown border style");

       // fall through

     case eWindowType_toplevel:

     case eWindowType_invisible:

       style = WS_OVERLAPPED | WS_BORDER | WS_DLGFRAME | WS_SYSMENU |

               WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_CLIPCHILDREN;

       break;

   }

   if (mBorderStyle != eBorderStyle_default && mBorderStyle != eBorderStyle_all) {

     if (mBorderStyle == eBorderStyle_none || !(mBorderStyle & eBorderStyle_border))

       style &= ~WS_BORDER;

     if (mBorderStyle == eBorderStyle_none || !(mBorderStyle & eBorderStyle_title)) {

       style &= ~WS_DLGFRAME;

       style |= WS_POPUP;

       style &= ~WS_CHILD;

     }

     if (mBorderStyle == eBorderStyle_none || !(mBorderStyle & eBorderStyle_close))

       style &= ~0;

     // XXX The close box can only be removed by changing the window class,

     // as far as I know   --- roc+moz@cs.cmu.edu

     if (mBorderStyle == eBorderStyle_none ||

       !(mBorderStyle & (eBorderStyle_menu | eBorderStyle_close)))

       style &= ~WS_SYSMENU;

     // Looks like getting rid of the system menu also does away with the

     // close box. So, we only get rid of the system menu if you want neither it

     // nor the close box. How does the Windows "Dialog" window class get just

     // closebox and no sysmenu? Who knows.

     if (mBorderStyle == eBorderStyle_none || !(mBorderStyle & eBorderStyle_resizeh))

       style &= ~WS_THICKFRAME;

     if (mBorderStyle == eBorderStyle_none || !(mBorderStyle & eBorderStyle_minimize))

       style &= ~WS_MINIMIZEBOX;

     if (mBorderStyle == eBorderStyle_none || !(mBorderStyle & eBorderStyle_maximize))

       style &= ~WS_MAXIMIZEBOX;

     if (IsPopupWithTitleBar()) {

       style |= WS_CAPTION;

       if (mBorderStyle & eBorderStyle_close) {

         style |= WS_SYSMENU;

       }

     }

   }

   VERIFY_WINDOW_STYLE(style);

   return style;

 }

 // Return nsWindow extended styles

 DWORD nsWindow::WindowExStyle()

 {

   switch (mWindowType)

   {

     case eWindowType_plugin:

     case eWindowType_child:

       return 0;

     case eWindowType_dialog:

       return WS_EX_WINDOWEDGE | WS_EX_DLGMODALFRAME;

     case eWindowType_popup:

     {

       DWORD extendedStyle = WS_EX_TOOLWINDOW;

       if (mPopupLevel == ePopupLevelTop)

         extendedStyle |= WS_EX_TOPMOST;

       return extendedStyle;

     }

     default:

       NS_ERROR("unknown border style");

       // fall through

     case eWindowType_toplevel:

     case eWindowType_invisible:

       return WS_EX_WINDOWEDGE;

   }

 }

 /**************************************************************

  *

  * SECTION: Window subclassing utilities

  *

  * Set or clear window subclasses on native windows. Used in

  * Create and Destroy.

  *

  **************************************************************/

 // Subclass (or remove the subclass from) this component's nsWindow

 void nsWindow::SubclassWindow(BOOL bState)

 {

   if (bState) {

     if (!mWnd || !IsWindow(mWnd)) {

       NS_ERROR("Invalid window handle");

     }

     if (mUnicodeWidget) {

       mPrevWndProc =

         reinterpret_cast<WNDPROC>(

           SetWindowLongPtrW(mWnd,

                             GWLP_WNDPROC,

                             reinterpret_cast<LONG_PTR>(nsWindow::WindowProc)));

     } else {

       mPrevWndProc =

         reinterpret_cast<WNDPROC>(

           SetWindowLongPtrA(mWnd,

                             GWLP_WNDPROC,

                             reinterpret_cast<LONG_PTR>(nsWindow::WindowProc)));

     }

     NS_ASSERTION(mPrevWndProc, "Null standard window procedure");

     // connect the this pointer to the nsWindow handle

     WinUtils::SetNSWindowBasePtr(mWnd, this);

   } else {

     if (IsWindow(mWnd)) {

       if (mUnicodeWidget) {

         SetWindowLongPtrW(mWnd,

                           GWLP_WNDPROC,

                           reinterpret_cast<LONG_PTR>(mPrevWndProc));

       } else {

         SetWindowLongPtrA(mWnd,

                           GWLP_WNDPROC,

                           reinterpret_cast<LONG_PTR>(mPrevWndProc));

       }

     }

     WinUtils::SetNSWindowBasePtr(mWnd, nullptr);

     mPrevWndProc = nullptr;

   }

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::SetParent, nsIWidget::GetParent

  *

  * Set or clear the parent widgets using window properties, and

  * handles calculating native parent handles.

  *

  **************************************************************/

 // Get and set parent widgets

 NS_IMETHODIMP nsWindow::SetParent(nsIWidget *aNewParent)

 {

   mParent = aNewParent;

   nsCOMPtr<nsIWidget> kungFuDeathGrip(this);

   nsIWidget* parent = GetParent();

   if (parent) {

     parent->RemoveChild(this);

   }

   if (aNewParent) {

     ReparentNativeWidget(aNewParent);

     aNewParent->AddChild(this);

     return NS_OK;

   }

   if (mWnd) {

     // If we have no parent, SetParent should return the desktop.

     VERIFY(::SetParent(mWnd, nullptr));

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 nsWindow::ReparentNativeWidget(nsIWidget* aNewParent)

 {

   NS_PRECONDITION(aNewParent, "");

   mParent = aNewParent;

   if (mWindowType == eWindowType_popup) {

     return NS_OK;

   }

   HWND newParent = (HWND)aNewParent->GetNativeData(NS_NATIVE_WINDOW);

   NS_ASSERTION(newParent, "Parent widget has a null native window handle");

   if (newParent && mWnd) {

     ::SetParent(mWnd, newParent);

   }

   return NS_OK;

 }

 nsIWidget* nsWindow::GetParent(void)

 {

   return GetParentWindow(false);

 }

 float nsWindow::GetDPI()

 {

   HDC dc = ::GetDC(mWnd);

   if (!dc)

     return 96.0f;

   double heightInches = ::GetDeviceCaps(dc, VERTSIZE)/MM_PER_INCH_FLOAT;

   int heightPx = ::GetDeviceCaps(dc, VERTRES);

   ::ReleaseDC(mWnd, dc);

   if (heightInches < 0.25) {

     // Something's broken

     return 96.0f;

   }

   return float(heightPx/heightInches);

 }

 double nsWindow::GetDefaultScaleInternal()

 {

   return WinUtils::LogToPhysFactor();

 }

 nsWindow*

 nsWindow::GetParentWindow(bool aIncludeOwner)

 {

   return static_cast<nsWindow*>(GetParentWindowBase(aIncludeOwner));

 }

 nsWindowBase*

 nsWindow::GetParentWindowBase(bool aIncludeOwner)

 {

   if (mIsTopWidgetWindow) {

     // Must use a flag instead of mWindowType to tell if the window is the

     // owned by the topmost widget, because a child window can be embedded inside

     // a HWND which is not associated with a nsIWidget.

     return nullptr;

   }

   // If this widget has already been destroyed, pretend we have no parent.

   // This corresponds to code in Destroy which removes the destroyed

   // widget from its parent's child list.

   if (mInDtor || mOnDestroyCalled)

     return nullptr;

   // aIncludeOwner set to true implies walking the parent chain to retrieve the

   // root owner. aIncludeOwner set to false implies the search will stop at the

   // true parent (default).

   nsWindow* widget = nullptr;

   if (mWnd) {

     HWND parent = nullptr;

     if (aIncludeOwner)

       parent = ::GetParent(mWnd);

     else

       parent = ::GetAncestor(mWnd, GA_PARENT);

     if (parent) {

       widget = WinUtils::GetNSWindowPtr(parent);

       if (widget) {

         // If the widget is in the process of being destroyed then

         // do NOT return it

         if (widget->mInDtor) {

           widget = nullptr;

         }

       }

     }

   }

   return static_cast<nsWindowBase*>(widget);

 }

 BOOL CALLBACK

 nsWindow::EnumAllChildWindProc(HWND aWnd, LPARAM aParam)

 {

   nsWindow *wnd = WinUtils::GetNSWindowPtr(aWnd);

   if (wnd) {

     ((nsWindow::WindowEnumCallback*)aParam)(wnd);

   }

   return TRUE;

 }

 BOOL CALLBACK

 nsWindow::EnumAllThreadWindowProc(HWND aWnd, LPARAM aParam)

 {

   nsWindow *wnd = WinUtils::GetNSWindowPtr(aWnd);

   if (wnd) {

     ((nsWindow::WindowEnumCallback*)aParam)(wnd);

   }

   EnumChildWindows(aWnd, EnumAllChildWindProc, aParam);

   return TRUE;

 }

 void

 nsWindow::EnumAllWindows(WindowEnumCallback aCallback)

 {

   EnumThreadWindows(GetCurrentThreadId(),

                     EnumAllThreadWindowProc,

                     (LPARAM)aCallback);

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::Show

  *

  * Hide or show this component.

  *

  **************************************************************/

 NS_METHOD nsWindow::Show(bool bState)

 {

   if (mWindowType == eWindowType_popup) {

     // See bug 603793. When we try to draw D3D9/10 windows with a drop shadow

     // without the DWM on a secondary monitor, windows fails to composite

     // our windows correctly. We therefor switch off the drop shadow for

     // pop-up windows when the DWM is disabled and two monitors are

     // connected.

     if (HasBogusPopupsDropShadowOnMultiMonitor() &&

         WinUtils::GetMonitorCount() > 1 &&

         !nsUXThemeData::CheckForCompositor())

     {

       if (sDropShadowEnabled) {

         ::SetClassLongA(mWnd, GCL_STYLE, 0);

         sDropShadowEnabled = false;

       }

     } else {

       if (!sDropShadowEnabled) {

         ::SetClassLongA(mWnd, GCL_STYLE, CS_DROPSHADOW);

         sDropShadowEnabled = true;

       }

     }

     // WS_EX_COMPOSITED conflicts with the WS_EX_LAYERED style and causes

     // some popup menus to become invisible.

     LONG_PTR exStyle = ::GetWindowLongPtrW(mWnd, GWL_EXSTYLE);

     if (exStyle & WS_EX_LAYERED) {

       ::SetWindowLongPtrW(mWnd, GWL_EXSTYLE, exStyle & ~WS_EX_COMPOSITED);

     }

   }

   bool syncInvalidate = false;

   bool wasVisible = mIsVisible;

   // Set the status now so that anyone asking during ShowWindow or

   // SetWindowPos would get the correct answer.

   mIsVisible = bState;

   // We may have cached an out of date visible state. This can happen

   // when session restore sets the full screen mode.

   if (mIsVisible)

     mOldStyle |= WS_VISIBLE;

   else

     mOldStyle &= ~WS_VISIBLE;

   if (!mIsVisible && wasVisible) {

       ClearCachedResources();

   }

   if (mWnd) {

     if (bState) {

       if (!wasVisible && mWindowType == eWindowType_toplevel) {

         // speed up the initial paint after show for

         // top level windows:

         syncInvalidate = true;

         switch (mSizeMode) {

           case nsSizeMode_Fullscreen:

             ::ShowWindow(mWnd, SW_SHOW);

             break;

           case nsSizeMode_Maximized :

             ::ShowWindow(mWnd, SW_SHOWMAXIMIZED);

             break;

           case nsSizeMode_Minimized :

             ::ShowWindow(mWnd, SW_SHOWMINIMIZED);

             break;

           default:

             if (CanTakeFocus()) {

               ::ShowWindow(mWnd, SW_SHOWNORMAL);

             } else {

               // Place the window behind the foreground window

               // (as long as it is not topmost)

               HWND wndAfter = ::GetForegroundWindow();

               if (!wndAfter)

                 wndAfter = HWND_BOTTOM;

               else if (GetWindowLongPtrW(wndAfter, GWL_EXSTYLE) & WS_EX_TOPMOST)

                 wndAfter = HWND_TOP;

               ::SetWindowPos(mWnd, wndAfter, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | 

                              SWP_NOMOVE | SWP_NOACTIVATE);

               GetAttention(2);

             }

             break;

         }

       } else {

         DWORD flags = SWP_NOSIZE | SWP_NOMOVE | SWP_SHOWWINDOW;

         if (wasVisible)

           flags |= SWP_NOZORDER;

         if (mWindowType == eWindowType_popup) {

           // ensure popups are the topmost of the TOPMOST

           // layer. Remember not to set the SWP_NOZORDER

           // flag as that might allow the taskbar to overlap

           // the popup.

           flags |= SWP_NOACTIVATE;

           HWND owner = ::GetWindow(mWnd, GW_OWNER);

           ::SetWindowPos(mWnd, owner ? 0 : HWND_TOPMOST, 0, 0, 0, 0, flags);

         } else {

           if (mWindowType == eWindowType_dialog && !CanTakeFocus())

             flags |= SWP_NOACTIVATE;

           ::SetWindowPos(mWnd, HWND_TOP, 0, 0, 0, 0, flags);

         }

       }

       if (!wasVisible && (mWindowType == eWindowType_toplevel || mWindowType == eWindowType_dialog)) {

         // when a toplevel window or dialog is shown, initialize the UI state

         ::SendMessageW(mWnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_INITIALIZE, UISF_HIDEFOCUS | UISF_HIDEACCEL), 0);

       }

     } else {

       // Clear contents to avoid ghosting of old content if we display

       // this window again.

       if (wasVisible && mTransparencyMode == eTransparencyTransparent) {

         ClearTranslucentWindow();

       }

       if (mWindowType != eWindowType_dialog) {

         ::ShowWindow(mWnd, SW_HIDE);

       } else {

         ::SetWindowPos(mWnd, 0, 0, 0, 0, 0, SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOMOVE |

                        SWP_NOZORDER | SWP_NOACTIVATE);

       }

     }

   }

 #ifdef MOZ_XUL

   if (!wasVisible && bState) {

     Invalidate();

     if (syncInvalidate && !mInDtor && !mOnDestroyCalled) {

       ::UpdateWindow(mWnd);

     }

   }

 #endif

   return NS_OK;

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::IsVisible

  *

  * Returns the visibility state.

  *

  **************************************************************/

 // Return true if the whether the component is visible, false otherwise

 bool nsWindow::IsVisible() const

 {

   return mIsVisible;

 }

 /**************************************************************

  *

  * SECTION: Window clipping utilities

  *

  * Used in Size and Move operations for setting the proper

  * window clipping regions for window transparency.

  *

  **************************************************************/

 // XP and Vista visual styles sometimes require window clipping regions to be applied for proper

 // transparency. These routines are called on size and move operations.

 void nsWindow::ClearThemeRegion()

 {

   if (IsVistaOrLater() && !HasGlass() &&

       (mWindowType == eWindowType_popup && !IsPopupWithTitleBar() &&

        (mPopupType == ePopupTypeTooltip || mPopupType == ePopupTypePanel))) {

     SetWindowRgn(mWnd, nullptr, false);

   }

 }

 void nsWindow::SetThemeRegion()

 {

   // Popup types that have a visual styles region applied (bug 376408). This can be expanded

   // for other window types as needed. The regions are applied generically to the base window

   // so default constants are used for part and state. At some point we might need part and

   // state values from nsNativeThemeWin's GetThemePartAndState, but currently windows that

   // change shape based on state haven't come up.

   if (IsVistaOrLater() && !HasGlass() &&

       (mWindowType == eWindowType_popup && !IsPopupWithTitleBar() &&

        (mPopupType == ePopupTypeTooltip || mPopupType == ePopupTypePanel))) {

     HRGN hRgn = nullptr;

     RECT rect = {0,0,mBounds.width,mBounds.height};

     HDC dc = ::GetDC(mWnd);

     GetThemeBackgroundRegion(nsUXThemeData::GetTheme(eUXTooltip), dc, TTP_STANDARD, TS_NORMAL, &rect, &hRgn);

     if (hRgn) {

       if (!SetWindowRgn(mWnd, hRgn, false)) // do not delete or alter hRgn if accepted.

         DeleteObject(hRgn);

     }

     ::ReleaseDC(mWnd, dc);

   }

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::RegisterTouchWindow,

  * nsIWidget::UnregisterTouchWindow, and helper functions

  *

  * Used to register the native window to receive touch events

  *

  **************************************************************/

 NS_METHOD nsWindow::RegisterTouchWindow() {

   if (Preferences::GetInt("dom.w3c_touch_events.enabled", 0) ||

       gIsPointerEventsEnabled) {

     mTouchWindow = true;

     mGesture.RegisterTouchWindow(mWnd);

     ::EnumChildWindows(mWnd, nsWindow::RegisterTouchForDescendants, 0);

   }

   return NS_OK;

 }

 NS_METHOD nsWindow::UnregisterTouchWindow() {

   mTouchWindow = false;

   mGesture.UnregisterTouchWindow(mWnd);

   ::EnumChildWindows(mWnd, nsWindow::UnregisterTouchForDescendants, 0);

   return NS_OK;

 }

 BOOL CALLBACK nsWindow::RegisterTouchForDescendants(HWND aWnd, LPARAM aMsg) {

   nsWindow* win = WinUtils::GetNSWindowPtr(aWnd);

   if (win)

     win->mGesture.RegisterTouchWindow(aWnd);

   return TRUE;

 }

 BOOL CALLBACK nsWindow::UnregisterTouchForDescendants(HWND aWnd, LPARAM aMsg) {

   nsWindow* win = WinUtils::GetNSWindowPtr(aWnd);

   if (win)

     win->mGesture.UnregisterTouchWindow(aWnd);

   return TRUE;

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::Move, nsIWidget::Resize,

  * nsIWidget::Size, nsIWidget::BeginResizeDrag

  *

  * Repositioning and sizing a window.

  *

  **************************************************************/

 void

 nsWindow::SetSizeConstraints(const SizeConstraints& aConstraints)

 {

   SizeConstraints c = aConstraints;

   if (mWindowType != eWindowType_popup) {

     c.mMinSize.width = std::max(int32_t(::GetSystemMetrics(SM_CXMINTRACK)), c.mMinSize.width);

     c.mMinSize.height = std::max(int32_t(::GetSystemMetrics(SM_CYMINTRACK)), c.mMinSize.height);

   }

   nsBaseWidget::SetSizeConstraints(c);

 }

 // Move this component

 NS_METHOD nsWindow::Move(double aX, double aY)

 {

   if (mWindowType == eWindowType_toplevel ||

       mWindowType == eWindowType_dialog) {

     SetSizeMode(nsSizeMode_Normal);

   }

   // for top-level windows only, convert coordinates from global display pixels

   // (the "parent" coordinate space) to the window's device pixel space

   CSSToLayoutDeviceScale scale = BoundsUseDisplayPixels() ? GetDefaultScale()

                                     : CSSToLayoutDeviceScale(1.0);

   int32_t x = NSToIntRound(aX * scale.scale);

   int32_t y = NSToIntRound(aY * scale.scale);

   // Check to see if window needs to be moved first

   // to avoid a costly call to SetWindowPos. This check

   // can not be moved to the calling code in nsView, because

   // some platforms do not position child windows correctly

   // Only perform this check for non-popup windows, since the positioning can

   // in fact change even when the x/y do not.  We always need to perform the

   // check. See bug #97805 for details.

   if (mWindowType != eWindowType_popup && (mBounds.x == x) && (mBounds.y == y))

   {

     // Nothing to do, since it is already positioned correctly.

     return NS_OK;

   }

   mBounds.x = x;

   mBounds.y = y;

   if (mWnd) {

 #ifdef DEBUG

     // complain if a window is moved offscreen (legal, but potentially worrisome)

     if (mIsTopWidgetWindow) { // only a problem for top-level windows

       // Make sure this window is actually on the screen before we move it

       // XXX: Needs multiple monitor support

       HDC dc = ::GetDC(mWnd);

       if (dc) {

         if (::GetDeviceCaps(dc, TECHNOLOGY) == DT_RASDISPLAY) {

           RECT workArea;

           ::SystemParametersInfo(SPI_GETWORKAREA, 0, &workArea, 0);

           // no annoying assertions. just mention the issue.

           if (x < 0 || x >= workArea.right || y < 0 || y >= workArea.bottom) {

             PR_LOG(gWindowsLog, PR_LOG_ALWAYS,

                    ("window moved to offscreen position\n"));

           }

         }

       ::ReleaseDC(mWnd, dc);

       }

     }

 #endif

     ClearThemeRegion();

     UINT flags = SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE;

     // Workaround SetWindowPos bug with D3D9. If our window has a clip

     // region, some drivers or OSes may incorrectly copy into the clipped-out

     // area.

     if (mWindowType == eWindowType_plugin &&

         (!mLayerManager || mLayerManager->GetBackendType() == LayersBackend::LAYERS_D3D9) &&

         mClipRects &&

         (mClipRectCount != 1 || !mClipRects[0].IsEqualInterior(nsIntRect(0, 0, mBounds.width, mBounds.height)))) {

       flags |= SWP_NOCOPYBITS;

     }

     VERIFY(::SetWindowPos(mWnd, nullptr, x, y, 0, 0, flags));

     SetThemeRegion();

   }

   NotifyRollupGeometryChange();

   return NS_OK;

 }

 // Resize this component

 NS_METHOD nsWindow::Resize(double aWidth, double aHeight, bool aRepaint)

 {

   // for top-level windows only, convert coordinates from global display pixels

   // (the "parent" coordinate space) to the window's device pixel space

   CSSToLayoutDeviceScale scale = BoundsUseDisplayPixels() ? GetDefaultScale()

                                     : CSSToLayoutDeviceScale(1.0);

   int32_t width = NSToIntRound(aWidth * scale.scale);

   int32_t height = NSToIntRound(aHeight * scale.scale);

   NS_ASSERTION((width >= 0) , "Negative width passed to nsWindow::Resize");

   NS_ASSERTION((height >= 0), "Negative height passed to nsWindow::Resize");

   ConstrainSize(&width, &height);

   // Avoid unnecessary resizing calls

   if (mBounds.width == width && mBounds.height == height) {

     if (aRepaint) {

       Invalidate();

     }

     return NS_OK;

   }

 #ifdef MOZ_XUL

   if (eTransparencyTransparent == mTransparencyMode)

     ResizeTranslucentWindow(width, height);

 #endif

   // Set cached value for lightweight and printing

   mBounds.width  = width;

   mBounds.height = height;

   if (mWnd) {

     UINT  flags = SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE;

     if (!aRepaint) {

       flags |= SWP_NOREDRAW;

     }

     ClearThemeRegion();

     VERIFY(::SetWindowPos(mWnd, nullptr, 0, 0,

                           width, GetHeight(height), flags));

     SetThemeRegion();

   }

   if (aRepaint)

     Invalidate();

   NotifyRollupGeometryChange();

   return NS_OK;

 }

 // Resize this component

 NS_METHOD nsWindow::Resize(double aX, double aY, double aWidth, double aHeight, bool aRepaint)

 {

   // for top-level windows only, convert coordinates from global display pixels

   // (the "parent" coordinate space) to the window's device pixel space

   CSSToLayoutDeviceScale scale = BoundsUseDisplayPixels() ? GetDefaultScale()

                                     : CSSToLayoutDeviceScale(1.0);

   int32_t x = NSToIntRound(aX * scale.scale);

   int32_t y = NSToIntRound(aY * scale.scale);

   int32_t width = NSToIntRound(aWidth * scale.scale);

   int32_t height = NSToIntRound(aHeight * scale.scale);

   NS_ASSERTION((width >= 0),  "Negative width passed to nsWindow::Resize");

   NS_ASSERTION((height >= 0), "Negative height passed to nsWindow::Resize");

   ConstrainSize(&width, &height);

   // Avoid unnecessary resizing calls

   if (mBounds.x == x && mBounds.y == y &&

       mBounds.width == width && mBounds.height == height) {

     if (aRepaint) {

       Invalidate();

     }

     return NS_OK;

   }

 #ifdef MOZ_XUL

   if (eTransparencyTransparent == mTransparencyMode)

     ResizeTranslucentWindow(width, height);

 #endif

   // Set cached value for lightweight and printing

   mBounds.x      = x;

   mBounds.y      = y;

   mBounds.width  = width;

   mBounds.height = height;

   if (mWnd) {

     UINT  flags = SWP_NOZORDER | SWP_NOACTIVATE;

     if (!aRepaint) {

       flags |= SWP_NOREDRAW;

     }

     ClearThemeRegion();

     VERIFY(::SetWindowPos(mWnd, nullptr, x, y,

                           width, GetHeight(height), flags));

     SetThemeRegion();

   }

   if (aRepaint)

     Invalidate();

   NotifyRollupGeometryChange();

   return NS_OK;

 }

 NS_IMETHODIMP

 nsWindow::BeginResizeDrag(WidgetGUIEvent* aEvent,

                           int32_t aHorizontal,

                           int32_t aVertical)

 {

   NS_ENSURE_ARG_POINTER(aEvent);

   if (aEvent->eventStructType != NS_MOUSE_EVENT) {

     // you can only begin a resize drag with a mouse event

     return NS_ERROR_INVALID_ARG;

   }

   if (aEvent->AsMouseEvent()->button != WidgetMouseEvent::eLeftButton) {

     // you can only begin a resize drag with the left mouse button

     return NS_ERROR_INVALID_ARG;

   }

   // work out what sizemode we're talking about

   WPARAM syscommand;

   if (aVertical < 0) {

     if (aHorizontal < 0) {

       syscommand = SC_SIZE | WMSZ_TOPLEFT;

     } else if (aHorizontal == 0) {

       syscommand = SC_SIZE | WMSZ_TOP;

     } else {

       syscommand = SC_SIZE | WMSZ_TOPRIGHT;

     }

   } else if (aVertical == 0) {

     if (aHorizontal < 0) {

       syscommand = SC_SIZE | WMSZ_LEFT;

     } else if (aHorizontal == 0) {

       return NS_ERROR_INVALID_ARG;

     } else {

       syscommand = SC_SIZE | WMSZ_RIGHT;

     }

   } else {

     if (aHorizontal < 0) {

       syscommand = SC_SIZE | WMSZ_BOTTOMLEFT;

     } else if (aHorizontal == 0) {

       syscommand = SC_SIZE | WMSZ_BOTTOM;

     } else {

       syscommand = SC_SIZE | WMSZ_BOTTOMRIGHT;

     }

   }

   // resizing doesn't work if the mouse is already captured

   CaptureMouse(false);

   // find the top-level window

   HWND toplevelWnd = WinUtils::GetTopLevelHWND(mWnd, true);

   // tell Windows to start the resize

   ::PostMessage(toplevelWnd, WM_SYSCOMMAND, syscommand,

                 POINTTOPOINTS(aEvent->refPoint));

   return NS_OK;

 }

 /**************************************************************

  *

  * SECTION: Window Z-order and state.

  *

  * nsIWidget::PlaceBehind, nsIWidget::SetSizeMode,

  * nsIWidget::ConstrainPosition

  *

  * Z-order, positioning, restore, minimize, and maximize.

  *

  **************************************************************/

 // Position the window behind the given window

 NS_METHOD nsWindow::PlaceBehind(nsTopLevelWidgetZPlacement aPlacement,

                                 nsIWidget *aWidget, bool aActivate)

 {

   HWND behind = HWND_TOP;

   if (aPlacement == eZPlacementBottom)

     behind = HWND_BOTTOM;

   else if (aPlacement == eZPlacementBelow && aWidget)

     behind = (HWND)aWidget->GetNativeData(NS_NATIVE_WINDOW);

   UINT flags = SWP_NOMOVE | SWP_NOREPOSITION | SWP_NOSIZE;

   if (!aActivate)

     flags |= SWP_NOACTIVATE;

   if (!CanTakeFocus() && behind == HWND_TOP)

   {

     // Can't place the window to top so place it behind the foreground window

     // (as long as it is not topmost)

     HWND wndAfter = ::GetForegroundWindow();

     if (!wndAfter)

       behind = HWND_BOTTOM;

     else if (!(GetWindowLongPtrW(wndAfter, GWL_EXSTYLE) & WS_EX_TOPMOST))

       behind = wndAfter;

     flags |= SWP_NOACTIVATE;

   }

   ::SetWindowPos(mWnd, behind, 0, 0, 0, 0, flags);

   return NS_OK;

 }

 // Maximize, minimize or restore the window.

 NS_IMETHODIMP nsWindow::SetSizeMode(int32_t aMode) {

   nsresult rv;

   // Let's not try and do anything if we're already in that state.

   // (This is needed to prevent problems when calling window.minimize(), which

   // calls us directly, and then the OS triggers another call to us.)

   if (aMode == mSizeMode)

     return NS_OK;

   // save the requested state

   mLastSizeMode = mSizeMode;

   rv = nsBaseWidget::SetSizeMode(aMode);

   if (NS_SUCCEEDED(rv) && mIsVisible) {

     int mode;

     switch (aMode) {

       case nsSizeMode_Fullscreen :

         mode = SW_SHOW;

         break;

       case nsSizeMode_Maximized :

         mode = SW_MAXIMIZE;

         break;

       case nsSizeMode_Minimized :

         // Using SW_SHOWMINIMIZED prevents the working set from being trimmed but

         // keeps the window active in the tray. So after the window is minimized,

         // windows will fire WM_WINDOWPOSCHANGED (OnWindowPosChanged) at which point

         // we will do some additional processing to get the active window set right.

         // If sTrimOnMinimize is set, we let windows handle minimization normally

         // using SW_MINIMIZE.

         mode = sTrimOnMinimize ? SW_MINIMIZE : SW_SHOWMINIMIZED;

         break;

       default :

         mode = SW_RESTORE;

     }

     WINDOWPLACEMENT pl;

     pl.length = sizeof(pl);

     ::GetWindowPlacement(mWnd, &pl);

     // Don't call ::ShowWindow if we're trying to "restore" a window that is

     // already in a normal state.  Prevents a bug where snapping to one side

     // of the screen and then minimizing would cause Windows to forget our

     // window's correct restored position/size.

     if( !(pl.showCmd == SW_SHOWNORMAL && mode == SW_RESTORE) ) {

       ::ShowWindow(mWnd, mode);

     }

     // we activate here to ensure that the right child window is focused

     if (mode == SW_MAXIMIZE || mode == SW_SHOW)

       DispatchFocusToTopLevelWindow(true);

   }

   return rv;

 }

 // Constrain a potential move to fit onscreen

 // Position (aX, aY) is specified in Windows screen (logical) pixels

 NS_METHOD nsWindow::ConstrainPosition(bool aAllowSlop,

                                       int32_t *aX, int32_t *aY)

 {

   if (!mIsTopWidgetWindow) // only a problem for top-level windows

     return NS_OK;

   double dpiScale = GetDefaultScale().scale;

   // we need to use the window size in logical screen pixels

   int32_t logWidth = std::max<int32_t>(NSToIntRound(mBounds.width / dpiScale), 1);

   int32_t logHeight = std::max<int32_t>(NSToIntRound(mBounds.height / dpiScale), 1);

   bool doConstrain = false; // whether we have enough info to do anything

   /* get our playing field. use the current screen, or failing that

     for any reason, use device caps for the default screen. */

   RECT screenRect;

   nsCOMPtr<nsIScreenManager> screenmgr = do_GetService(sScreenManagerContractID);

   if (screenmgr) {

     nsCOMPtr<nsIScreen> screen;

     int32_t left, top, width, height;

     screenmgr->ScreenForRect(*aX, *aY, logWidth, logHeight,

                              getter_AddRefs(screen));

     if (screen) {

       if (mSizeMode != nsSizeMode_Fullscreen) {

         // For normalized windows, use the desktop work area.

         screen->GetAvailRectDisplayPix(&left, &top, &width, &height);

       } else {

         // For full screen windows, use the desktop.

         screen->GetRectDisplayPix(&left, &top, &width, &height);

       }

       screenRect.left = left;

       screenRect.right = left + width;

       screenRect.top = top;

       screenRect.bottom = top + height;

       doConstrain = true;

     }

   } else {

     if (mWnd) {

       HDC dc = ::GetDC(mWnd);

       if (dc) {

         if (::GetDeviceCaps(dc, TECHNOLOGY) == DT_RASDISPLAY) {

           if (mSizeMode != nsSizeMode_Fullscreen) {

             ::SystemParametersInfo(SPI_GETWORKAREA, 0, &screenRect, 0);

           } else {

             screenRect.left = screenRect.top = 0;

             screenRect.right = GetSystemMetrics(SM_CXFULLSCREEN);

             screenRect.bottom = GetSystemMetrics(SM_CYFULLSCREEN);

           }

           doConstrain = true;

         }

         ::ReleaseDC(mWnd, dc);

       }

     }

   }

   if (aAllowSlop) {

     if (*aX < screenRect.left - logWidth + kWindowPositionSlop)

       *aX = screenRect.left - logWidth + kWindowPositionSlop;

     else if (*aX >= screenRect.right - kWindowPositionSlop)

       *aX = screenRect.right - kWindowPositionSlop;

     if (*aY < screenRect.top - logHeight + kWindowPositionSlop)

       *aY = screenRect.top - logHeight + kWindowPositionSlop;

     else if (*aY >= screenRect.bottom - kWindowPositionSlop)

       *aY = screenRect.bottom - kWindowPositionSlop;

   } else {

     if (*aX < screenRect.left)

       *aX = screenRect.left;

     else if (*aX >= screenRect.right - logWidth)

       *aX = screenRect.right - logWidth;

     if (*aY < screenRect.top)

       *aY = screenRect.top;

     else if (*aY >= screenRect.bottom - logHeight)

       *aY = screenRect.bottom - logHeight;

   }

   return NS_OK;

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::Enable, nsIWidget::IsEnabled

  *

  * Enabling and disabling the widget.

  *

  **************************************************************/

 // Enable/disable this component

 NS_METHOD nsWindow::Enable(bool bState)

 {

   if (mWnd) {

     ::EnableWindow(mWnd, bState);

   }

   return NS_OK;

 }

 // Return the current enable state

 bool nsWindow::IsEnabled() const

 {

   return !mWnd ||

          (::IsWindowEnabled(mWnd) &&

           ::IsWindowEnabled(::GetAncestor(mWnd, GA_ROOT)));

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::SetFocus

  *

  * Give the focus to this widget.

  *

  **************************************************************/

 NS_METHOD nsWindow::SetFocus(bool aRaise)

 {

   if (mWnd) {

 #ifdef WINSTATE_DEBUG_OUTPUT

     if (mWnd == WinUtils::GetTopLevelHWND(mWnd)) {

       PR_LOG(gWindowsLog, PR_LOG_ALWAYS,

              ("*** SetFocus: [  top] raise=%d\n", aRaise));

     } else {

       PR_LOG(gWindowsLog, PR_LOG_ALWAYS,

              ("*** SetFocus: [child] raise=%d\n", aRaise));

     }

 #endif

     // Uniconify, if necessary

     HWND toplevelWnd = WinUtils::GetTopLevelHWND(mWnd);

     if (aRaise && ::IsIconic(toplevelWnd)) {

       ::ShowWindow(toplevelWnd, SW_RESTORE);

     }

     ::SetFocus(mWnd);

   }

   return NS_OK;

 }

 /**************************************************************

  *

  * SECTION: Bounds

  *

  * GetBounds, GetClientBounds, GetScreenBounds, GetClientOffset

  * SetDrawsInTitlebar, GetNonClientMargins, SetNonClientMargins

  *

  * Bound calculations.

  *

  **************************************************************/

 // Return the window's full dimensions in screen coordinates.

 // If the window has a parent, converts the origin to an offset

 // of the parent's screen origin.

 NS_METHOD nsWindow::GetBounds(nsIntRect &aRect)

 {

   if (mWnd) {

     RECT r;

     VERIFY(::GetWindowRect(mWnd, &r));

     // assign size

     aRect.width  = r.right - r.left;

     aRect.height = r.bottom - r.top;

     // popup window bounds' are in screen coordinates, not relative to parent

     // window

     if (mWindowType == eWindowType_popup) {

       aRect.x = r.left;

       aRect.y = r.top;

       return NS_OK;

     }

     // chrome on parent:

     //  ___      5,5   (chrome start)

     // |  ____   10,10 (client start)

     // | |  ____ 20,20 (child start)

     // | | |

     // 20,20 - 5,5 = 15,15 (??)

     // minus GetClientOffset:

     // 15,15 - 5,5 = 10,10

     //

     // no chrome on parent:

     //  ______   10,10 (win start)

     // |  ____   20,20 (child start)

     // | |

     // 20,20 - 10,10 = 10,10

     //

     // walking the chain:

     //  ___      5,5   (chrome start)

     // |  ___    10,10 (client start)

     // | |  ___  20,20 (child start)

     // | | |  __ 30,30 (child start)

     // | | | |

     // 30,30 - 20,20 = 10,10 (offset from second child to first)

     // 20,20 - 5,5 = 15,15 + 10,10 = 25,25 (??)

     // minus GetClientOffset:

     // 25,25 - 5,5 = 20,20 (offset from second child to parent client)

     // convert coordinates if parent exists

     HWND parent = ::GetParent(mWnd);

     if (parent) {

       RECT pr;

       VERIFY(::GetWindowRect(parent, &pr));

       r.left -= pr.left;

       r.top  -= pr.top;

       // adjust for chrome

       nsWindow* pWidget = static_cast<nsWindow*>(GetParent());

       if (pWidget && pWidget->IsTopLevelWidget()) {

         nsIntPoint clientOffset = pWidget->GetClientOffset();

         r.left -= clientOffset.x;

         r.top  -= clientOffset.y;

       }

     }

     aRect.x = r.left;

     aRect.y = r.top;

   } else {

     aRect = mBounds;

   }

   return NS_OK;

 }

 // Get this component dimension

 NS_METHOD nsWindow::GetClientBounds(nsIntRect &aRect)

 {

   if (mWnd) {

     RECT r;

     VERIFY(::GetClientRect(mWnd, &r));

     nsIntRect bounds;

     GetBounds(bounds);

     aRect.MoveTo(bounds.TopLeft() + GetClientOffset());

     aRect.width  = r.right - r.left;

     aRect.height = r.bottom - r.top;

   } else {

     aRect.SetRect(0,0,0,0);

   }

   return NS_OK;

 }

 // Like GetBounds, but don't offset by the parent

 NS_METHOD nsWindow::GetScreenBounds(nsIntRect &aRect)

 {

   if (mWnd) {

     RECT r;

     VERIFY(::GetWindowRect(mWnd, &r));

     aRect.width  = r.right - r.left;

     aRect.height = r.bottom - r.top;

     aRect.x = r.left;

     aRect.y = r.top;

   } else

     aRect = mBounds;

   return NS_OK;

 }

 // return the x,y offset of the client area from the origin

 // of the window. If the window is borderless returns (0,0).

 nsIntPoint nsWindow::GetClientOffset()

 {

   if (!mWnd) {

     return nsIntPoint(0, 0);

   }

   RECT r1;

   GetWindowRect(mWnd, &r1);

   nsIntPoint pt = WidgetToScreenOffset();

   return nsIntPoint(pt.x - r1.left, pt.y - r1.top);

 }

 void

 nsWindow::SetDrawsInTitlebar(bool aState)

 {

   nsWindow * window = GetTopLevelWindow(true);

   if (window && window != this) {

     return window->SetDrawsInTitlebar(aState);

   }

   if (aState) {

     // top, right, bottom, left for nsIntMargin

     nsIntMargin margins(0, -1, -1, -1);

     SetNonClientMargins(margins);

   }

   else {

     nsIntMargin margins(-1, -1, -1, -1);

     SetNonClientMargins(margins);

   }

 }

 NS_IMETHODIMP

 nsWindow::GetNonClientMargins(nsIntMargin &margins)

 {

   nsWindow * window = GetTopLevelWindow(true);

   if (window && window != this) {

     return window->GetNonClientMargins(margins);

   }

   if (mCustomNonClient) {

     margins = mNonClientMargins;

     return NS_OK;

   }

   margins.top = GetSystemMetrics(SM_CYCAPTION);

   margins.bottom = GetSystemMetrics(SM_CYFRAME);

   margins.top += margins.bottom;

   margins.left = margins.right = GetSystemMetrics(SM_CXFRAME);

   return NS_OK;

 }

 void

 nsWindow::ResetLayout()

 {

   // This will trigger a frame changed event, triggering

   // nc calc size and a sizemode gecko event.

   SetWindowPos(mWnd, 0, 0, 0, 0, 0,

                SWP_FRAMECHANGED|SWP_NOACTIVATE|SWP_NOMOVE|

                SWP_NOOWNERZORDER|SWP_NOSIZE|SWP_NOZORDER);

   // If hidden, just send the frame changed event for now.

   if (!mIsVisible)

     return;

   // Send a gecko size event to trigger reflow.

   RECT clientRc = {0};

   GetClientRect(mWnd, &clientRc);

   nsIntRect evRect(WinUtils::ToIntRect(clientRc));

   OnResize(evRect);

   // Invalidate and update

   Invalidate();

 }

 // Internally track the caption status via a window property. Required

 // due to our internal handling of WM_NCACTIVATE when custom client

 // margins are set.

 static const wchar_t kManageWindowInfoProperty[] = L"ManageWindowInfoProperty";

 typedef BOOL (WINAPI *GetWindowInfoPtr)(HWND hwnd, PWINDOWINFO pwi);

 static GetWindowInfoPtr sGetWindowInfoPtrStub = nullptr;

 BOOL WINAPI

 GetWindowInfoHook(HWND hWnd, PWINDOWINFO pwi)

 {

   if (!sGetWindowInfoPtrStub) {

     NS_ASSERTION(FALSE, "Something is horribly wrong in GetWindowInfoHook!");

     return FALSE;

   }

   int windowStatus = 

     reinterpret_cast<LONG_PTR>(GetPropW(hWnd, kManageWindowInfoProperty));

   // No property set, return the default data.

   if (!windowStatus)

     return sGetWindowInfoPtrStub(hWnd, pwi);

   // Call GetWindowInfo and update dwWindowStatus with our

   // internally tracked value. 

   BOOL result = sGetWindowInfoPtrStub(hWnd, pwi);

   if (result && pwi)

     pwi->dwWindowStatus = (windowStatus == 1 ? 0 : WS_ACTIVECAPTION);

   return result;

 }

 void

 nsWindow::UpdateGetWindowInfoCaptionStatus(bool aActiveCaption)

 {

   if (!mWnd)

     return;

   if (!sGetWindowInfoPtrStub) {

     sUser32Intercept.Init("user32.dll");

     if (!sUser32Intercept.AddHook("GetWindowInfo", reinterpret_cast<intptr_t>(GetWindowInfoHook),

                                   (void**) &sGetWindowInfoPtrStub))

       return;

   }

   // Update our internally tracked caption status

   SetPropW(mWnd, kManageWindowInfoProperty, 

     reinterpret_cast<HANDLE>(static_cast<int>(aActiveCaption) + 1));

 }

 /**

  * Called when the window layout changes: full screen mode transitions,

  * theme changes, and composition changes. Calculates the new non-client

  * margins and fires off a frame changed event, which triggers an nc calc

  * size windows event, kicking the changes in.

  *

  * The offsets calculated here are based on the value of `mNonClientMargins`

  * which is specified in the "chromemargins" attribute of the window.  For

  * each margin, the value specified has the following meaning:

  *    -1 - leave the default frame in place

  *     0 - remove the frame

  *    >0 - frame size equals min(0, (default frame size - margin value))

  *

  * This function calculates and populates `mNonClientOffset`.

  * In our processing of `WM_NCCALCSIZE`, the frame size will be calculated

  * as (default frame size - offset).  For example, if the left frame should

  * be 1 pixel narrower than the default frame size, `mNonClientOffset.left`

  * will equal 1.

  *

  * For maximized, fullscreen, and minimized windows, the values stored in

  * `mNonClientMargins` are ignored, and special processing takes place.

  *

  * For non-glass windows, we only allow frames to be their default size

  * or removed entirely.

  */

 bool

 nsWindow::UpdateNonClientMargins(int32_t aSizeMode, bool aReflowWindow)

 {

   if (!mCustomNonClient)

     return false;

   if (aSizeMode == -1) {

     aSizeMode = mSizeMode;

   }

   bool hasCaption = (mBorderStyle

                     & (eBorderStyle_all

                      | eBorderStyle_title

                      | eBorderStyle_menu

                      | eBorderStyle_default));

   // mCaptionHeight is the default size of the NC area at

   // the top of the window. If the window has a caption,

   // the size is calculated as the sum of:

   //      SM_CYFRAME        - The thickness of the sizing border

   //                          around a resizable window

   //      SM_CXPADDEDBORDER - The amount of border padding

   //                          for captioned windows

   //      SM_CYCAPTION      - The height of the caption area

   //

   // If the window does not have a caption, mCaptionHeight will be equal to

   // `GetSystemMetrics(SM_CYFRAME)`

   mCaptionHeight = GetSystemMetrics(SM_CYFRAME)

                  + (hasCaption ? GetSystemMetrics(SM_CYCAPTION)

                                  + GetSystemMetrics(SM_CXPADDEDBORDER)

                                : 0);

   // mHorResizeMargin is the size of the default NC areas on the

   // left and right sides of our window.  It is calculated as

   // the sum of:

   //      SM_CXFRAME        - The thickness of the sizing border

   //      SM_CXPADDEDBORDER - The amount of border padding

   //                          for captioned windows

   //

   // If the window does not have a caption, mHorResizeMargin will be equal to

   // `GetSystemMetrics(SM_CXFRAME)`

   mHorResizeMargin = GetSystemMetrics(SM_CXFRAME)

                    + (hasCaption ? GetSystemMetrics(SM_CXPADDEDBORDER) : 0);

   // mVertResizeMargin is the size of the default NC area at the

   // bottom of the window. It is calculated as the sum of:

   //      SM_CYFRAME        - The thickness of the sizing border

   //      SM_CXPADDEDBORDER - The amount of border padding

   //                          for captioned windows.

   //

   // If the window does not have a caption, mVertResizeMargin will be equal to

   // `GetSystemMetrics(SM_CYFRAME)`

   mVertResizeMargin = GetSystemMetrics(SM_CYFRAME)

                     + (hasCaption ? GetSystemMetrics(SM_CXPADDEDBORDER) : 0);

   if (aSizeMode == nsSizeMode_Minimized) {

     // Use default frame size for minimized windows

     mNonClientOffset.top = 0;

     mNonClientOffset.left = 0;

     mNonClientOffset.right = 0;

     mNonClientOffset.bottom = 0;

   } else if (aSizeMode == nsSizeMode_Fullscreen) {

     // Remove the default frame from the top of our fullscreen window.  This

     // makes the whole caption part of our client area, allowing us to draw

     // in the whole caption area.  Additionally remove the default frame from

     // the left, right, and bottom.

     mNonClientOffset.top = mCaptionHeight;

     mNonClientOffset.bottom = mVertResizeMargin;

     mNonClientOffset.left = mHorResizeMargin;

     mNonClientOffset.right = mHorResizeMargin;

   } else if (aSizeMode == nsSizeMode_Maximized) {

     // Remove the default frame from the top of our maximized window.  This

     // makes the whole caption part of our client area, allowing us to draw

     // in the whole caption area.  Use default frame size on left, right, and

     // bottom. The reason this works is that, for maximized windows,

     // Windows positions them so that their frames fall off the screen.

     // This gives the illusion of windows having no frames when they are

     // maximized.  If we try to mess with the frame sizes by setting these

     // offsets to positive values, our client area will fall off the screen.

     mNonClientOffset.top = mCaptionHeight;

     mNonClientOffset.bottom = 0;

     mNonClientOffset.left = 0;

     mNonClientOffset.right = 0;

     APPBARDATA appBarData;

     appBarData.cbSize = sizeof(appBarData);

     UINT taskbarState = SHAppBarMessage(ABM_GETSTATE, &appBarData);

     if (ABS_AUTOHIDE & taskbarState) {

       UINT edge = -1;

       appBarData.hWnd = FindWindow(L"Shell_TrayWnd", nullptr);

       if (appBarData.hWnd) {

         HMONITOR taskbarMonitor = ::MonitorFromWindow(appBarData.hWnd,

                                                       MONITOR_DEFAULTTOPRIMARY);

         HMONITOR windowMonitor = ::MonitorFromWindow(mWnd,

                                                      MONITOR_DEFAULTTONEAREST);

         if (taskbarMonitor == windowMonitor) {

           SHAppBarMessage(ABM_GETTASKBARPOS, &appBarData);

           edge = appBarData.uEdge;

         }

       }

       if (ABE_LEFT == edge) {

         mNonClientOffset.left -= 1;

       } else if (ABE_RIGHT == edge) {

         mNonClientOffset.right -= 1;

       } else if (ABE_BOTTOM == edge || ABE_TOP == edge) {

         mNonClientOffset.bottom -= 1;

       }

     }

   } else {

     bool glass = nsUXThemeData::CheckForCompositor();

     // We're dealing with a "normal" window (not maximized, minimized, or

     // fullscreen), so process `mNonClientMargins` and set `mNonClientOffset`

     // accordingly.

     //

     // Setting `mNonClientOffset` to 0 has the effect of leaving the default

     // frame intact.  Setting it to a value greater than 0 reduces the frame

     // size by that amount.

     if (mNonClientMargins.top > 0 && glass) {

       mNonClientOffset.top = std::min(mCaptionHeight, mNonClientMargins.top);

     } else if (mNonClientMargins.top == 0) {

       mNonClientOffset.top = mCaptionHeight;

     } else {

       mNonClientOffset.top = 0;

     }

     if (mNonClientMargins.bottom > 0 && glass) {

       mNonClientOffset.bottom = std::min(mVertResizeMargin, mNonClientMargins.bottom);

     } else if (mNonClientMargins.bottom == 0) {

       mNonClientOffset.bottom = mVertResizeMargin;

     } else {

       mNonClientOffset.bottom = 0;

     }

     if (mNonClientMargins.left > 0 && glass) {

       mNonClientOffset.left = std::min(mHorResizeMargin, mNonClientMargins.left);

     } else if (mNonClientMargins.left == 0) {

       mNonClientOffset.left = mHorResizeMargin;

     } else {

       mNonClientOffset.left = 0;

     }

     if (mNonClientMargins.right > 0 && glass) {

       mNonClientOffset.right = std::min(mHorResizeMargin, mNonClientMargins.right);

     } else if (mNonClientMargins.right == 0) {

       mNonClientOffset.right = mHorResizeMargin;

     } else {

       mNonClientOffset.right = 0;

     }

   }

   if (aReflowWindow) {

     // Force a reflow of content based on the new client

     // dimensions.

     ResetLayout();

   }

   return true;

 }

 NS_IMETHODIMP

 nsWindow::SetNonClientMargins(nsIntMargin &margins)

 {

   if (!mIsTopWidgetWindow ||

       mBorderStyle & eBorderStyle_none ||

       mHideChrome)

     return NS_ERROR_INVALID_ARG;

   // Request for a reset

   if (margins.top == -1 && margins.left == -1 &&

       margins.right == -1 && margins.bottom == -1) {

     mCustomNonClient = false;

     mNonClientMargins = margins;

     // Force a reflow of content based on the new client

     // dimensions.

     ResetLayout();

     int windowStatus =

       reinterpret_cast<LONG_PTR>(GetPropW(mWnd, kManageWindowInfoProperty));

     if (windowStatus) {

       ::SendMessageW(mWnd, WM_NCACTIVATE, 1 != windowStatus, 0);

     }

     return NS_OK;

   }

   if (margins.top < -1 || margins.bottom < -1 ||

       margins.left < -1 || margins.right < -1)

     return NS_ERROR_INVALID_ARG;

   mNonClientMargins = margins;

   mCustomNonClient = true;

   if (!UpdateNonClientMargins()) {

     NS_WARNING("UpdateNonClientMargins failed!");

     return NS_OK;

   }

   return NS_OK;

 }

 void

 nsWindow::InvalidateNonClientRegion()

 {

   // +-+-----------------------+-+

   // | | app non-client chrome | |

   // | +-----------------------+ |

   // | |   app client chrome   | | }

   // | +-----------------------+ | }

   // | |      app content      | | } area we don't want to invalidate

   // | +-----------------------+ | }

   // | |   app client chrome   | | }

   // | +-----------------------+ | 

   // +---------------------------+ <

   //  ^                         ^    windows non-client chrome

   // client area = app *

   RECT rect;

   GetWindowRect(mWnd, &rect);

   MapWindowPoints(nullptr, mWnd, (LPPOINT)&rect, 2);

   HRGN winRgn = CreateRectRgnIndirect(&rect);

   // Subtract app client chrome and app content leaving

   // windows non-client chrome and app non-client chrome

   // in winRgn.

   GetWindowRect(mWnd, &rect);

   rect.top += mCaptionHeight;

   rect.right -= mHorResizeMargin;

   rect.bottom -= mHorResizeMargin;

   rect.left += mVertResizeMargin;

   MapWindowPoints(nullptr, mWnd, (LPPOINT)&rect, 2);

   HRGN clientRgn = CreateRectRgnIndirect(&rect);

   CombineRgn(winRgn, winRgn, clientRgn, RGN_DIFF);

   DeleteObject(clientRgn);

   // triggers ncpaint and paint events for the two areas

   RedrawWindow(mWnd, nullptr, winRgn, RDW_FRAME | RDW_INVALIDATE);

   DeleteObject(winRgn);

 }

 HRGN

 nsWindow::ExcludeNonClientFromPaintRegion(HRGN aRegion)

 {

   RECT rect;

   HRGN rgn = nullptr;

   if (aRegion == (HRGN)1) { // undocumented value indicating a full refresh

     GetWindowRect(mWnd, &rect);

     rgn = CreateRectRgnIndirect(&rect);

   } else {

     rgn = aRegion;

   }

   GetClientRect(mWnd, &rect);

   MapWindowPoints(mWnd, nullptr, (LPPOINT)&rect, 2);

   HRGN nonClientRgn = CreateRectRgnIndirect(&rect);

   CombineRgn(rgn, rgn, nonClientRgn, RGN_DIFF);

   DeleteObject(nonClientRgn);

   return rgn;

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::SetBackgroundColor

  *

  * Sets the window background paint color.

  *

  **************************************************************/

 void nsWindow::SetBackgroundColor(const nscolor &aColor)

 {

   if (mBrush)

     ::DeleteObject(mBrush);

   mBrush = ::CreateSolidBrush(NSRGB_2_COLOREF(aColor));

   if (mWnd != nullptr) {

     ::SetClassLongPtrW(mWnd, GCLP_HBRBACKGROUND, (LONG_PTR)mBrush);

   }

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::SetCursor

  *

  * SetCursor and related utilities for manging cursor state.

  *

  **************************************************************/

 // Set this component cursor

 NS_METHOD nsWindow::SetCursor(nsCursor aCursor)

 {

   // Only change cursor if it's changing

   //XXX mCursor isn't always right.  Scrollbars and others change it, too.

   //XXX If we want this optimization we need a better way to do it.

   //if (aCursor != mCursor) {

   HCURSOR newCursor = nullptr;

   switch (aCursor) {

     case eCursor_select:

       newCursor = ::LoadCursor(nullptr, IDC_IBEAM);

       break;

     case eCursor_wait:

       newCursor = ::LoadCursor(nullptr, IDC_WAIT);

       break;

     case eCursor_hyperlink:

     {

       newCursor = ::LoadCursor(nullptr, IDC_HAND);

       break;

     }

     case eCursor_standard:

     case eCursor_context_menu: // XXX See bug 258960.

       newCursor = ::LoadCursor(nullptr, IDC_ARROW);

       break;

     case eCursor_n_resize:

     case eCursor_s_resize:

       newCursor = ::LoadCursor(nullptr, IDC_SIZENS);

       break;

     case eCursor_w_resize:

     case eCursor_e_resize:

       newCursor = ::LoadCursor(nullptr, IDC_SIZEWE);

       break;

     case eCursor_nw_resize:

     case eCursor_se_resize:

       newCursor = ::LoadCursor(nullptr, IDC_SIZENWSE);

       break;

     case eCursor_ne_resize:

     case eCursor_sw_resize:

       newCursor = ::LoadCursor(nullptr, IDC_SIZENESW);

       break;

     case eCursor_crosshair:

       newCursor = ::LoadCursor(nullptr, IDC_CROSS);

       break;

     case eCursor_move:

       newCursor = ::LoadCursor(nullptr, IDC_SIZEALL);

       break;

     case eCursor_help:

       newCursor = ::LoadCursor(nullptr, IDC_HELP);

       break;

     case eCursor_copy: // CSS3

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_COPY));

       break;

     case eCursor_alias:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ALIAS));

       break;

     case eCursor_cell:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_CELL));

       break;

     case eCursor_grab:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_GRAB));

       break;

     case eCursor_grabbing:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_GRABBING));

       break;

     case eCursor_spinning:

       newCursor = ::LoadCursor(nullptr, IDC_APPSTARTING);

       break;

     case eCursor_zoom_in:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ZOOMIN));

       break;

     case eCursor_zoom_out:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ZOOMOUT));

       break;

     case eCursor_not_allowed:

     case eCursor_no_drop:

       newCursor = ::LoadCursor(nullptr, IDC_NO);

       break;

     case eCursor_col_resize:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_COLRESIZE));

       break;

     case eCursor_row_resize:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_ROWRESIZE));

       break;

     case eCursor_vertical_text:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_VERTICALTEXT));

       break;

     case eCursor_all_scroll:

       // XXX not 100% appropriate perhaps

       newCursor = ::LoadCursor(nullptr, IDC_SIZEALL);

       break;

     case eCursor_nesw_resize:

       newCursor = ::LoadCursor(nullptr, IDC_SIZENESW);

       break;

     case eCursor_nwse_resize:

       newCursor = ::LoadCursor(nullptr, IDC_SIZENWSE);

       break;

     case eCursor_ns_resize:

       newCursor = ::LoadCursor(nullptr, IDC_SIZENS);

       break;

     case eCursor_ew_resize:

       newCursor = ::LoadCursor(nullptr, IDC_SIZEWE);

       break;

     case eCursor_none:

       newCursor = ::LoadCursor(nsToolkit::mDllInstance, MAKEINTRESOURCE(IDC_NONE));

       break;

     default:

       NS_ERROR("Invalid cursor type");

       break;

   }

   if (nullptr != newCursor) {

     mCursor = aCursor;

     HCURSOR oldCursor = ::SetCursor(newCursor);

     if (sHCursor == oldCursor) {

       NS_IF_RELEASE(sCursorImgContainer);

       if (sHCursor != nullptr)

         ::DestroyIcon(sHCursor);

       sHCursor = nullptr;

     }

   }

   return NS_OK;

 }

 // Setting the actual cursor

 NS_IMETHODIMP nsWindow::SetCursor(imgIContainer* aCursor,

                                   uint32_t aHotspotX, uint32_t aHotspotY)

 {

   if (sCursorImgContainer == aCursor && sHCursor) {

     ::SetCursor(sHCursor);

     return NS_OK;

   }

   int32_t width;

   int32_t height;

   nsresult rv;

   rv = aCursor->GetWidth(&width);

   NS_ENSURE_SUCCESS(rv, rv);

   rv = aCursor->GetHeight(&height);

   NS_ENSURE_SUCCESS(rv, rv);

   // Reject cursors greater than 128 pixels in either direction, to prevent

   // spoofing.

   // XXX ideally we should rescale. Also, we could modify the API to

   // allow trusted content to set larger cursors.

   if (width > 128 || height > 128)

     return NS_ERROR_NOT_AVAILABLE;

   HCURSOR cursor;

   // No scaling

   gfxIntSize size(0, 0);

   rv = nsWindowGfx::CreateIcon(aCursor, true, aHotspotX, aHotspotY, size, &cursor);

   NS_ENSURE_SUCCESS(rv, rv);

   mCursor = nsCursor(-1);

   ::SetCursor(cursor);

   NS_IF_RELEASE(sCursorImgContainer);

   sCursorImgContainer = aCursor;

   NS_ADDREF(sCursorImgContainer);

   if (sHCursor != nullptr)

     ::DestroyIcon(sHCursor);

   sHCursor = cursor;

   return NS_OK;

 }

 /**************************************************************

  *

  * SECTION: nsIWidget::Get/SetTransparencyMode

  *

  * Manage the transparency mode of the top-level window

  * containing this widget.

  *

  **************************************************************/

 #ifdef MOZ_XUL

 nsTransparencyMode nsWindow::GetTransparencyMode()

 {

   return GetTopLevelWindow(true)->GetWindowTranslucencyInner();

 }

 void nsWindow::SetTransparencyMode(nsTransparencyMode aMode)

 {

   GetTopLevelWindow(true)->SetWindowTranslucencyInner(aMode);

 }

 static const nsIntRegion

 RegionFromArray(const nsTArray<nsIntRect>& aRects)

 {

   nsIntRegion region;

   for (uint32_t i = 0; i < aRects.Length(); ++i) {

     region.Or(region, aRects[i]);

   }

   return region;

 }

 void nsWindow::UpdateOpaqueRegion(const nsIntRegion &aOpaqueRegion)

 {

   if (!HasGlass() || GetParent())

     return;

   // If there is no opaque region or hidechrome=true, set margins

   // to support a full sheet of glass. Comments in MSDN indicate

   // all values must be set to -1 to get a full sheet of glass.

   MARGINS margins = { -1, -1, -1, -1 };

   if (!aOpaqueRegion.IsEmpty()) {

     nsIntRect pluginBounds;

     for (nsIWidget* child = GetFirstChild(); child; child = child->GetNextSibling()) {

       if (child->WindowType() == eWindowType_plugin) {

         // Collect the bounds of all plugins for GetLargestRectangle.

         nsIntRect childBounds;

         child->GetBounds(childBounds);

         pluginBounds.UnionRect(pluginBounds, childBounds);

       }

     }

     nsIntRect clientBounds;

     GetClientBounds(clientBounds);

     // Find the largest rectangle and use that to calculate the inset. Our top

     // priority is to include the bounds of all plugins.

     nsIntRect largest = aOpaqueRegion.GetLargestRectangle(pluginBounds);

     margins.cxLeftWidth = largest.x;

     margins.cxRightWidth = clientBounds.width - largest.XMost();

     margins.cyBottomHeight = clientBounds.height - largest.YMost();

     if (mCustomNonClient) {

       // The minimum glass height must be the caption buttons height,

       // otherwise the buttons are drawn incorrectly.

       largest.y = std::max<uint32_t>(largest.y,

                          nsUXThemeData::sCommandButtons[CMDBUTTONIDX_BUTTONBOX].cy);

     }

     margins.cyTopHeight = largest.y;

   }

   // Only update glass area if there are changes

   if (memcmp(&mGlassMargins, &margins, sizeof mGlassMargins)) {

     mGlassMargins = margins;

     UpdateGlass();

   }

 }

 void nsWindow::UpdateGlass()

 {

   MARGINS margins = mGlassMargins;

   // DWMNCRP_USEWINDOWSTYLE - The non-client rendering area is

   //                          rendered based on the window style.

   // DWMNCRP_ENABLED        - The non-client area rendering is

   //                          enabled; the window style is ignored.

   DWMNCRENDERINGPOLICY policy = DWMNCRP_USEWINDOWSTYLE;