The Tor Browser: widget/windows/nsWindow.cpp@b8a032363ba2 (annotated)

widget/windows/nsWindow.cpp@b8a032363ba2 (annotated)

widget/windows/nsWindow.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- 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, mWnd, nullptr, nsToolkit::mDllInstance, nullptr);
     HWND scrollableWnd = ::CreateWindowW
       (className.get(), L"FAKETRACKPOINTSCROLLABLE",
        WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | 0x30,
 , 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;
   switch (mTransparencyMode) {
   case eTransparencyBorderlessGlass:
     // Only adjust if there is some opaque rectangle
     if (margins.cxLeftWidth >= 0) {
       margins.cxLeftWidth += kGlassMarginAdjustment;
       margins.cyTopHeight += kGlassMarginAdjustment;
       margins.cxRightWidth += kGlassMarginAdjustment;
       margins.cyBottomHeight += kGlassMarginAdjustment;
     }
     // Fall through
   case eTransparencyGlass:
     policy = DWMNCRP_ENABLED;
     break;
   }
   PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
          ("glass margins: left:%d top:%d right:%d bottom:%d\n",
           margins.cxLeftWidth, margins.cyTopHeight,
           margins.cxRightWidth, margins.cyBottomHeight));
   // Extends the window frame behind the client area
   if (nsUXThemeData::CheckForCompositor()) {
     WinUtils::dwmExtendFrameIntoClientAreaPtr(mWnd, &margins);
     WinUtils::dwmSetWindowAttributePtr(mWnd, DWMWA_NCRENDERING_POLICY, &policy, sizeof policy);
   }
 }
 #endif
 /**************************************************************
  *
  * SECTION: nsIWidget::HideWindowChrome
  *
  * Show or hide window chrome.
  *
  **************************************************************/
 NS_IMETHODIMP nsWindow::HideWindowChrome(bool aShouldHide)
 {
   HWND hwnd = WinUtils::GetTopLevelHWND(mWnd, true);
   if (!WinUtils::GetNSWindowPtr(hwnd))
   {
     NS_WARNING("Trying to hide window decorations in an embedded context");
     return NS_ERROR_FAILURE;
   }
   if (mHideChrome == aShouldHide)
     return NS_OK;
   DWORD_PTR style, exStyle;
   mHideChrome = aShouldHide;
   if (aShouldHide) {
     DWORD_PTR tempStyle = ::GetWindowLongPtrW(hwnd, GWL_STYLE);
     DWORD_PTR tempExStyle = ::GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
     style = tempStyle & ~(WS_CAPTION | WS_THICKFRAME);
     exStyle = tempExStyle & ~(WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE |
                               WS_EX_CLIENTEDGE | WS_EX_STATICEDGE);
     mOldStyle = tempStyle;
     mOldExStyle = tempExStyle;
   }
   else {
     if (!mOldStyle || !mOldExStyle) {
       mOldStyle = ::GetWindowLongPtrW(hwnd, GWL_STYLE);
       mOldExStyle = ::GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
     }
     style = mOldStyle;
     exStyle = mOldExStyle;
   }
   VERIFY_WINDOW_STYLE(style);
   ::SetWindowLongPtrW(hwnd, GWL_STYLE, style);
   ::SetWindowLongPtrW(hwnd, GWL_EXSTYLE, exStyle);
   return NS_OK;
 }
 /**************************************************************
  *
  * SECTION: nsWindow::Invalidate
  *
  * Invalidate an area of the client for painting.
  *
  **************************************************************/
 // Invalidate this component visible area
 NS_METHOD nsWindow::Invalidate(bool aEraseBackground,
                                bool aUpdateNCArea,
                                bool aIncludeChildren)
 {
   if (!mWnd) {
     return NS_OK;
   }
 #ifdef WIDGET_DEBUG_OUTPUT
   debug_DumpInvalidate(stdout,
                        this,
                        nullptr,
                        nsAutoCString("noname"),
                        (int32_t) mWnd);
 #endif // WIDGET_DEBUG_OUTPUT
   DWORD flags = RDW_INVALIDATE;
   if (aEraseBackground) {
     flags |= RDW_ERASE;
   }
   if (aUpdateNCArea) {
     flags |= RDW_FRAME;
   }
   if (aIncludeChildren) {
     flags |= RDW_ALLCHILDREN;
   }
   VERIFY(::RedrawWindow(mWnd, nullptr, nullptr, flags));
   return NS_OK;
 }
 // Invalidate this component visible area
 NS_METHOD nsWindow::Invalidate(const nsIntRect & aRect)
 {
   if (mWnd)
   {
 #ifdef WIDGET_DEBUG_OUTPUT
     debug_DumpInvalidate(stdout,
                          this,
                          &aRect,
                          nsAutoCString("noname"),
                          (int32_t) mWnd);
 #endif // WIDGET_DEBUG_OUTPUT
     RECT rect;
     rect.left   = aRect.x;
     rect.top    = aRect.y;
     rect.right  = aRect.x + aRect.width;
     rect.bottom = aRect.y + aRect.height;
     VERIFY(::InvalidateRect(mWnd, &rect, FALSE));
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::MakeFullScreen(bool aFullScreen)
 {
   // taskbarInfo will be nullptr pre Windows 7 until Bug 680227 is resolved.
   nsCOMPtr<nsIWinTaskbar> taskbarInfo =
     do_GetService(NS_TASKBAR_CONTRACTID);
   mFullscreenMode = aFullScreen;
   if (aFullScreen) {
     if (mSizeMode == nsSizeMode_Fullscreen)
       return NS_OK;
     mOldSizeMode = mSizeMode;
     SetSizeMode(nsSizeMode_Fullscreen);
     // Notify the taskbar that we will be entering full screen mode.
     if (taskbarInfo) {
       taskbarInfo->PrepareFullScreenHWND(mWnd, TRUE);
     }
   } else {
     SetSizeMode(mOldSizeMode);
   }
   UpdateNonClientMargins();
   bool visible = mIsVisible;
   if (mOldSizeMode == nsSizeMode_Normal)
     Show(false);
   // Will call hide chrome, reposition window. Note this will
   // also cache dimensions for restoration, so it should only
   // be called once per fullscreen request.
   nsresult rv = nsBaseWidget::MakeFullScreen(aFullScreen);
   if (visible) {
     Show(true);
     Invalidate();
   }
   // Notify the taskbar that we have exited full screen mode.
   if (!aFullScreen && taskbarInfo) {
     taskbarInfo->PrepareFullScreenHWND(mWnd, FALSE);
   }
   if (mWidgetListener)
     mWidgetListener->SizeModeChanged(mSizeMode);
   return rv;
 }
 /**************************************************************
  *
  * SECTION: Native data storage
  *
  * nsIWidget::GetNativeData
  * nsIWidget::FreeNativeData
  *
  * Set or clear native data based on a constant.
  *
  **************************************************************/
 // Return some native data according to aDataType
 void* nsWindow::GetNativeData(uint32_t aDataType)
 {
   nsAutoString className;
   switch (aDataType) {
     case NS_NATIVE_TMP_WINDOW:
       GetWindowClass(className);
       return (void*)::CreateWindowExW(mIsRTL ? WS_EX_LAYOUTRTL : 0,
                                       className.get(),
                                       L"",
                                       WS_CHILD,
                                       CW_USEDEFAULT,
                                       CW_USEDEFAULT,
                                       CW_USEDEFAULT,
                                       CW_USEDEFAULT,
                                       mWnd,
                                       nullptr,
                                       nsToolkit::mDllInstance,
                                       nullptr);
     case NS_NATIVE_PLUGIN_PORT:
     case NS_NATIVE_WIDGET:
     case NS_NATIVE_WINDOW:
     case NS_NATIVE_SHAREABLE_WINDOW:
       return (void*)mWnd;
     case NS_NATIVE_GRAPHIC:
       // XXX:  This is sleezy!!  Remember to Release the DC after using it!
 #ifdef MOZ_XUL
       return (void*)(eTransparencyTransparent == mTransparencyMode) ?
         mMemoryDC : ::GetDC(mWnd);
 #else
       return (void*)::GetDC(mWnd);
 #endif
     case NS_NATIVE_TSF_THREAD_MGR:
     case NS_NATIVE_TSF_CATEGORY_MGR:
     case NS_NATIVE_TSF_DISPLAY_ATTR_MGR:
       return IMEHandler::GetNativeData(aDataType);
     default:
       break;
   }
   return nullptr;
 }
 // Free some native data according to aDataType
 void nsWindow::FreeNativeData(void * data, uint32_t aDataType)
 {
   switch (aDataType)
   {
     case NS_NATIVE_GRAPHIC:
 #ifdef MOZ_XUL
       if (eTransparencyTransparent != mTransparencyMode)
         ::ReleaseDC(mWnd, (HDC)data);
 #else
       ::ReleaseDC(mWnd, (HDC)data);
 #endif
       break;
     case NS_NATIVE_WIDGET:
     case NS_NATIVE_WINDOW:
     case NS_NATIVE_PLUGIN_PORT:
       break;
     default:
       break;
   }
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::SetTitle
  *
  * Set the main windows title text.
  *
  **************************************************************/
 NS_METHOD nsWindow::SetTitle(const nsAString& aTitle)
 {
   const nsString& strTitle = PromiseFlatString(aTitle);
   ::SendMessageW(mWnd, WM_SETTEXT, (WPARAM)0, (LPARAM)(LPCWSTR)strTitle.get());
   return NS_OK;
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::SetIcon
  *
  * Set the main windows icon.
  *
  **************************************************************/
 NS_METHOD nsWindow::SetIcon(const nsAString& aIconSpec)
 {
   // Assume the given string is a local identifier for an icon file.
   nsCOMPtr<nsIFile> iconFile;
   ResolveIconName(aIconSpec, NS_LITERAL_STRING(".ico"),
                   getter_AddRefs(iconFile));
   if (!iconFile)
     return NS_OK; // not an error if icon is not found
   nsAutoString iconPath;
   iconFile->GetPath(iconPath);
   // XXX this should use MZLU (see bug 239279)
   ::SetLastError(0);
   HICON bigIcon = (HICON)::LoadImageW(nullptr,
                                       (LPCWSTR)iconPath.get(),
                                       IMAGE_ICON,
                                       ::GetSystemMetrics(SM_CXICON),
                                       ::GetSystemMetrics(SM_CYICON),
                                       LR_LOADFROMFILE );
   HICON smallIcon = (HICON)::LoadImageW(nullptr,
                                         (LPCWSTR)iconPath.get(),
                                         IMAGE_ICON,
                                         ::GetSystemMetrics(SM_CXSMICON),
                                         ::GetSystemMetrics(SM_CYSMICON),
                                         LR_LOADFROMFILE );
   if (bigIcon) {
     HICON icon = (HICON) ::SendMessageW(mWnd, WM_SETICON, (WPARAM)ICON_BIG, (LPARAM)bigIcon);
     if (icon)
       ::DestroyIcon(icon);
     mIconBig = bigIcon;
   }
 #ifdef DEBUG_SetIcon
   else {
     NS_LossyConvertUTF16toASCII cPath(iconPath);
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
            ("\nIcon load error; icon=%s, rc=0x%08X\n\n",
             cPath.get(), ::GetLastError()));
   }
 #endif
   if (smallIcon) {
     HICON icon = (HICON) ::SendMessageW(mWnd, WM_SETICON, (WPARAM)ICON_SMALL, (LPARAM)smallIcon);
     if (icon)
       ::DestroyIcon(icon);
     mIconSmall = smallIcon;
   }
 #ifdef DEBUG_SetIcon
   else {
     NS_LossyConvertUTF16toASCII cPath(iconPath);
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
            ("\nSmall icon load error; icon=%s, rc=0x%08X\n\n",
             cPath.get(), ::GetLastError()));
   }
 #endif
   return NS_OK;
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::WidgetToScreenOffset
  *
  * Return this widget's origin in screen coordinates.
  *
  **************************************************************/
 nsIntPoint nsWindow::WidgetToScreenOffset()
 {
   POINT point;
   point.x = 0;
   point.y = 0;
   ::ClientToScreen(mWnd, &point);
   return nsIntPoint(point.x, point.y);
 }
 nsIntSize nsWindow::ClientToWindowSize(const nsIntSize& aClientSize)
 {
   if (mWindowType == eWindowType_popup && !IsPopupWithTitleBar())
     return aClientSize;
   // just use (200, 200) as the position
   RECT r;
   r.left = 200;
   r.top = 200;
   r.right = 200 + aClientSize.width;
   r.bottom = 200 + aClientSize.height;
   ::AdjustWindowRectEx(&r, WindowStyle(), false, WindowExStyle());
   return nsIntSize(r.right - r.left, r.bottom - r.top);
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::EnableDragDrop
  *
  * Enables/Disables drag and drop of files on this widget.
  *
  **************************************************************/
 NS_METHOD nsWindow::EnableDragDrop(bool aEnable)
 {
   NS_ASSERTION(mWnd, "nsWindow::EnableDragDrop() called after Destroy()");
   nsresult rv = NS_ERROR_FAILURE;
   if (aEnable) {
     if (nullptr == mNativeDragTarget) {
        mNativeDragTarget = new nsNativeDragTarget(this);
        if (nullptr != mNativeDragTarget) {
          mNativeDragTarget->AddRef();
          if (S_OK == ::CoLockObjectExternal((LPUNKNOWN)mNativeDragTarget,TRUE,FALSE)) {
            if (S_OK == ::RegisterDragDrop(mWnd, (LPDROPTARGET)mNativeDragTarget)) {
              rv = NS_OK;
            }
          }
        }
     }
   } else {
     if (nullptr != mWnd && nullptr != mNativeDragTarget) {
       ::RevokeDragDrop(mWnd);
       if (S_OK == ::CoLockObjectExternal((LPUNKNOWN)mNativeDragTarget, FALSE, TRUE)) {
         rv = NS_OK;
       }
       mNativeDragTarget->DragCancel();
       NS_RELEASE(mNativeDragTarget);
     }
   }
   return rv;
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::CaptureMouse
  *
  * Enables/Disables system mouse capture.
  *
  **************************************************************/
 NS_METHOD nsWindow::CaptureMouse(bool aCapture)
 {
   if (!nsToolkit::gMouseTrailer) {
     NS_ERROR("nsWindow::CaptureMouse called after nsToolkit destroyed");
     return NS_OK;
   }
   if (aCapture) {
     nsToolkit::gMouseTrailer->SetCaptureWindow(mWnd);
     ::SetCapture(mWnd);
   } else {
     nsToolkit::gMouseTrailer->SetCaptureWindow(nullptr);
     ::ReleaseCapture();
   }
   sIsInMouseCapture = aCapture;
   return NS_OK;
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::CaptureRollupEvents
  *
  * Dealing with event rollup on destroy for popups. Enables &
  * Disables system capture of any and all events that would
  * cause a dropdown to be rolled up.
  *
  **************************************************************/
 NS_IMETHODIMP nsWindow::CaptureRollupEvents(nsIRollupListener * aListener,
                                             bool aDoCapture)
 {
   if (aDoCapture) {
     gRollupListener = aListener;
     if (!sMsgFilterHook && !sCallProcHook && !sCallMouseHook) {
       RegisterSpecialDropdownHooks();
     }
     sProcessHook = true;
   } else {
     gRollupListener = nullptr;
     sProcessHook = false;
     UnregisterSpecialDropdownHooks();
   }
   return NS_OK;
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::GetAttention
  *
  * Bring this window to the user's attention.
  *
  **************************************************************/
 // Draw user's attention to this window until it comes to foreground.
 NS_IMETHODIMP
 nsWindow::GetAttention(int32_t aCycleCount)
 {
   // Got window?
   if (!mWnd)
     return NS_ERROR_NOT_INITIALIZED;
   HWND flashWnd = WinUtils::GetTopLevelHWND(mWnd, false, false);
   HWND fgWnd = ::GetForegroundWindow();
   // Don't flash if the flash count is 0 or if the foreground window is our
   // window handle or that of our owned-most window.
   if (aCycleCount == 0 ||
       flashWnd == fgWnd ||
       flashWnd == WinUtils::GetTopLevelHWND(fgWnd, false, false)) {
     return NS_OK;
   }
   DWORD defaultCycleCount = 0;
   ::SystemParametersInfo(SPI_GETFOREGROUNDFLASHCOUNT, 0, &defaultCycleCount, 0);
   FLASHWINFO flashInfo = { sizeof(FLASHWINFO), flashWnd,
     FLASHW_ALL, aCycleCount > 0 ? aCycleCount : defaultCycleCount, 0 };
   ::FlashWindowEx(&flashInfo);
   return NS_OK;
 }
 void nsWindow::StopFlashing()
 {
   HWND flashWnd = mWnd;
   while (HWND ownerWnd = ::GetWindow(flashWnd, GW_OWNER)) {
     flashWnd = ownerWnd;
   }
   FLASHWINFO flashInfo = { sizeof(FLASHWINFO), flashWnd,
     FLASHW_STOP, 0, 0 };
   ::FlashWindowEx(&flashInfo);
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::HasPendingInputEvent
  *
  * Ask whether there user input events pending.  All input events are
  * included, including those not targeted at this nsIwidget instance.
  *
  **************************************************************/
 bool
 nsWindow::HasPendingInputEvent()
 {
   // If there is pending input or the user is currently
   // moving the window then return true.
   // Note: When the user is moving the window WIN32 spins
   // a separate event loop and input events are not
   // reported to the application.
   if (HIWORD(GetQueueStatus(QS_INPUT)))
     return true;
   GUITHREADINFO guiInfo;
   guiInfo.cbSize = sizeof(GUITHREADINFO);
   if (!GetGUIThreadInfo(GetCurrentThreadId(), &guiInfo))
     return false;
   return GUI_INMOVESIZE == (guiInfo.flags & GUI_INMOVESIZE);
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::GetLayerManager
  *
  * Get the layer manager associated with this widget.
  *
  **************************************************************/
 struct LayerManagerPrefs {
   LayerManagerPrefs()
     : mAccelerateByDefault(true)
     , mDisableAcceleration(false)
     , mPreferOpenGL(false)
     , mPreferD3D9(false)
   {}
   bool mAccelerateByDefault;
   bool mDisableAcceleration;
   bool mForceAcceleration;
   bool mPreferOpenGL;
   bool mPreferD3D9;
 };
 static void
 GetLayerManagerPrefs(LayerManagerPrefs* aManagerPrefs)
 {
   Preferences::GetBool("layers.acceleration.disabled",
                        &aManagerPrefs->mDisableAcceleration);
   Preferences::GetBool("layers.acceleration.force-enabled",
                        &aManagerPrefs->mForceAcceleration);
   Preferences::GetBool("layers.prefer-opengl",
                        &aManagerPrefs->mPreferOpenGL);
   Preferences::GetBool("layers.prefer-d3d9",
                        &aManagerPrefs->mPreferD3D9);
   const char *acceleratedEnv = PR_GetEnv("MOZ_ACCELERATED");
   aManagerPrefs->mAccelerateByDefault =
     aManagerPrefs->mAccelerateByDefault ||
     (acceleratedEnv && (*acceleratedEnv != '0'));
   bool safeMode = false;
   nsCOMPtr<nsIXULRuntime> xr = do_GetService("@mozilla.org/xre/runtime;1");
   if (xr)
     xr->GetInSafeMode(&safeMode);
   aManagerPrefs->mDisableAcceleration =
     aManagerPrefs->mDisableAcceleration || safeMode;
 }
 LayerManager*
 nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
                           LayersBackend aBackendHint,
                           LayerManagerPersistence aPersistence,
                           bool* aAllowRetaining)
 {
   if (aAllowRetaining) {
     *aAllowRetaining = true;
   }
 #ifdef MOZ_ENABLE_D3D10_LAYER
   if (mLayerManager) {
     if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_D3D10)
     {
       LayerManagerD3D10 *layerManagerD3D10 =
         static_cast<LayerManagerD3D10*>(mLayerManager.get());
       if (layerManagerD3D10->device() !=
           gfxWindowsPlatform::GetPlatform()->GetD3D10Device())
       {
         MOZ_ASSERT(!mLayerManager->IsInTransaction());
         mLayerManager->Destroy();
         mLayerManager = nullptr;
       }
     }
   }
 #endif
   RECT windowRect;
   ::GetClientRect(mWnd, &windowRect);
   // Try OMTC first.
   if (!mLayerManager && ShouldUseOffMainThreadCompositing()) {
     // e10s uses the parameter to pass in the shadow manager from the TabChild
     // so we don't expect to see it there since this doesn't support e10s.
     NS_ASSERTION(aShadowManager == nullptr, "Async Compositor not supported with e10s");
     CreateCompositor();
   }
   if (!mLayerManager ||
       (!sAllowD3D9 && aPersistence == LAYER_MANAGER_PERSISTENT &&
         mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC &&
         !ShouldUseOffMainThreadCompositing())) {
     // If D3D9 is not currently allowed but the permanent manager is required,
     // -and- we're currently using basic layers, run through this check.
     LayerManagerPrefs prefs;
     GetLayerManagerPrefs(&prefs);
     /* We don't currently support using an accelerated layer manager with
      * transparent windows so don't even try. I'm also not sure if we even
      * want to support this case. See bug #593471 */
     if (eTransparencyTransparent == mTransparencyMode ||
         prefs.mDisableAcceleration ||
         windowRect.right - windowRect.left > MAX_ACCELERATED_DIMENSION ||
         windowRect.bottom - windowRect.top > MAX_ACCELERATED_DIMENSION)
       mUseLayersAcceleration = false;
     else if (prefs.mAccelerateByDefault)
       mUseLayersAcceleration = true;
     if (mUseLayersAcceleration) {
       if (aPersistence == LAYER_MANAGER_PERSISTENT && !sAllowD3D9) {
         MOZ_ASSERT(!mLayerManager || !mLayerManager->IsInTransaction());
         // This will clear out our existing layer manager if we have one since
         // if we hit this with a LayerManager we're always using BasicLayers.
         nsToolkit::StartAllowingD3D9();
       }
 #ifdef MOZ_ENABLE_D3D10_LAYER
       if (!prefs.mPreferD3D9 && !prefs.mPreferOpenGL) {
         nsRefPtr<LayerManagerD3D10> layerManager =
           new LayerManagerD3D10(this);
         if (layerManager->Initialize(prefs.mForceAcceleration)) {
           mLayerManager = layerManager;
         }
       }
 #endif
 #ifdef MOZ_ENABLE_D3D9_LAYER
       if (!prefs.mPreferOpenGL && !mLayerManager && sAllowD3D9) {
         nsRefPtr<LayerManagerD3D9> layerManager =
           new LayerManagerD3D9(this);
         if (layerManager->Initialize(prefs.mForceAcceleration)) {
           mLayerManager = layerManager;
         }
       }
 #endif
     }
     // Fall back to software if we couldn't use any hardware backends.
     if (!mLayerManager) {
       mLayerManager = CreateBasicLayerManager();
     }
   }
   NS_ASSERTION(mLayerManager, "Couldn't provide a valid layer manager.");
   return mLayerManager;
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::GetThebesSurface
  *
  * Get the Thebes surface associated with this widget.
  *
  **************************************************************/
 gfxASurface *nsWindow::GetThebesSurface()
 {
   if (mPaintDC)
     return (new gfxWindowsSurface(mPaintDC));
   uint32_t flags = gfxWindowsSurface::FLAG_TAKE_DC;
   if (mTransparencyMode != eTransparencyOpaque) {
       flags |= gfxWindowsSurface::FLAG_IS_TRANSPARENT;
   }
   return (new gfxWindowsSurface(mWnd, flags));
 }
 /**************************************************************
  *
  * SECTION: nsIWidget::OnDefaultButtonLoaded
  *
  * Called after the dialog is loaded and it has a default button.
  *
  **************************************************************/
 NS_IMETHODIMP
 nsWindow::OnDefaultButtonLoaded(const nsIntRect &aButtonRect)
 {
   if (aButtonRect.IsEmpty())
     return NS_OK;
   // Don't snap when we are not active.
   HWND activeWnd = ::GetActiveWindow();
   if (activeWnd != ::GetForegroundWindow() ||
       WinUtils::GetTopLevelHWND(mWnd, true) !=
         WinUtils::GetTopLevelHWND(activeWnd, true)) {
     return NS_OK;
   }
   bool isAlwaysSnapCursor =
     Preferences::GetBool("ui.cursor_snapping.always_enabled", false);
   if (!isAlwaysSnapCursor) {
     BOOL snapDefaultButton;
     if (!::SystemParametersInfo(SPI_GETSNAPTODEFBUTTON, 0,
                                 &snapDefaultButton, 0) || !snapDefaultButton)
       return NS_OK;
   }
   nsIntRect widgetRect;
   nsresult rv = GetScreenBounds(widgetRect);
   NS_ENSURE_SUCCESS(rv, rv);
   nsIntRect buttonRect(aButtonRect + widgetRect.TopLeft());
   nsIntPoint centerOfButton(buttonRect.x + buttonRect.width / 2,
                             buttonRect.y + buttonRect.height / 2);
   // The center of the button can be outside of the widget.
   // E.g., it could be hidden by scrolling.
   if (!widgetRect.Contains(centerOfButton)) {
     return NS_OK;
   }
   if (!::SetCursorPos(centerOfButton.x, centerOfButton.y)) {
     NS_ERROR("SetCursorPos failed");
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 nsWindow::OverrideSystemMouseScrollSpeed(double aOriginalDeltaX,
                                          double aOriginalDeltaY,
                                          double& aOverriddenDeltaX,
                                          double& aOverriddenDeltaY)
 {
   // The default vertical and horizontal scrolling speed is 3, this is defined
   // on the document of SystemParametersInfo in MSDN.
   const uint32_t kSystemDefaultScrollingSpeed = 3;
   double absOriginDeltaX = Abs(aOriginalDeltaX);
   double absOriginDeltaY = Abs(aOriginalDeltaY);
   // Compute the simple overridden speed.
   double absComputedOverriddenDeltaX, absComputedOverriddenDeltaY;
   nsresult rv =
     nsBaseWidget::OverrideSystemMouseScrollSpeed(absOriginDeltaX,
                                                  absOriginDeltaY,
                                                  absComputedOverriddenDeltaX,
                                                  absComputedOverriddenDeltaY);
   NS_ENSURE_SUCCESS(rv, rv);
   aOverriddenDeltaX = aOriginalDeltaX;
   aOverriddenDeltaY = aOriginalDeltaY;
   if (absComputedOverriddenDeltaX == absOriginDeltaX &&
       absComputedOverriddenDeltaY == absOriginDeltaY) {
     // We don't override now.
     return NS_OK;
   }
   // Otherwise, we should check whether the user customized the system settings
   // or not.  If the user did it, we should respect the will.
   UINT systemSpeed;
   if (!::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &systemSpeed, 0)) {
     return NS_ERROR_FAILURE;
   }
   // The default vertical scrolling speed is 3, this is defined on the document
   // of SystemParametersInfo in MSDN.
   if (systemSpeed != kSystemDefaultScrollingSpeed) {
     return NS_OK;
   }
   // Only Vista and later, Windows has the system setting of horizontal
   // scrolling by the mouse wheel.
   if (IsVistaOrLater()) {
     if (!::SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &systemSpeed, 0)) {
       return NS_ERROR_FAILURE;
     }
     // The default horizontal scrolling speed is 3, this is defined on the
     // document of SystemParametersInfo in MSDN.
     if (systemSpeed != kSystemDefaultScrollingSpeed) {
       return NS_OK;
     }
   }
   // Limit the overridden delta value from the system settings.  The mouse
   // driver might accelerate the scrolling speed already.  If so, we shouldn't
   // override the scrolling speed for preventing the unexpected high speed
   // scrolling.
   double absDeltaLimitX, absDeltaLimitY;
   rv =
     nsBaseWidget::OverrideSystemMouseScrollSpeed(kSystemDefaultScrollingSpeed,
                                                  kSystemDefaultScrollingSpeed,
                                                  absDeltaLimitX,
                                                  absDeltaLimitY);
   NS_ENSURE_SUCCESS(rv, rv);
   // If the given delta is larger than our computed limitation value, the delta
   // was accelerated by the mouse driver.  So, we should do nothing here.
   if (absDeltaLimitX <= absOriginDeltaX || absDeltaLimitY <= absOriginDeltaY) {
     return NS_OK;
   }
   aOverriddenDeltaX = std::min(absComputedOverriddenDeltaX, absDeltaLimitX);
   aOverriddenDeltaY = std::min(absComputedOverriddenDeltaY, absDeltaLimitY);
   if (aOriginalDeltaX < 0) {
     aOverriddenDeltaX *= -1;
   }
   if (aOriginalDeltaY < 0) {
     aOverriddenDeltaY *= -1;
   }
   return NS_OK;
 }
 mozilla::TemporaryRef<mozilla::gfx::DrawTarget>
 nsWindow::StartRemoteDrawing()
 {
   MOZ_ASSERT(!mCompositeDC);
   NS_ASSERTION(IsRenderMode(gfxWindowsPlatform::RENDER_DIRECT2D) ||
                IsRenderMode(gfxWindowsPlatform::RENDER_GDI),
                "Unexpected render mode for remote drawing");
   HDC dc = (HDC)GetNativeData(NS_NATIVE_GRAPHIC);
   nsRefPtr<gfxASurface> surf;
   if (mTransparencyMode == eTransparencyTransparent) {
     if (!mTransparentSurface) {
       SetupTranslucentWindowMemoryBitmap(mTransparencyMode);
     }
     if (mTransparentSurface) {
       surf = mTransparentSurface;
     }
   }
   if (!surf) {
     if (!dc) {
       return nullptr;
     }
     uint32_t flags = (mTransparencyMode == eTransparencyOpaque) ? 0 :
         gfxWindowsSurface::FLAG_IS_TRANSPARENT;
     surf = new gfxWindowsSurface(dc, flags);
   }
   mozilla::gfx::IntSize size(surf->GetSize().width, surf->GetSize().height);
   if (size.width <= 0 || size.height <= 0) {
     if (dc) {
       FreeNativeData(dc, NS_NATIVE_GRAPHIC);
     }
     return nullptr;
   }
   MOZ_ASSERT(!mCompositeDC);
   mCompositeDC = dc;
   return mozilla::gfx::Factory::CreateDrawTargetForCairoSurface(surf->CairoSurface(), size);
 }
 void
 nsWindow::EndRemoteDrawing()
 {
   if (mTransparencyMode == eTransparencyTransparent) {
     MOZ_ASSERT(IsRenderMode(gfxWindowsPlatform::RENDER_DIRECT2D)
                || mTransparentSurface);
     UpdateTranslucentWindow();
   }
   if (mCompositeDC) {
     FreeNativeData(mCompositeDC, NS_NATIVE_GRAPHIC);
   }
   mCompositeDC = nullptr;
 }
 void
 nsWindow::UpdateThemeGeometries(const nsTArray<ThemeGeometry>& aThemeGeometries)
 {
   nsIntRegion clearRegion;
   for (size_t i = 0; i < aThemeGeometries.Length(); i++) {
     if ((aThemeGeometries[i].mWidgetType == NS_THEME_WINDOW_BUTTON_BOX ||
          aThemeGeometries[i].mWidgetType == NS_THEME_WINDOW_BUTTON_BOX_MAXIMIZED) &&
         nsUXThemeData::CheckForCompositor())
     {
       nsIntRect bounds = aThemeGeometries[i].mRect;
       clearRegion = nsIntRect(bounds.X(), bounds.Y(), bounds.Width(), bounds.Height() - 2.0);
       clearRegion.Or(clearRegion, nsIntRect(bounds.X() + 1.0, bounds.YMost() - 2.0, bounds.Width() - 1.0, 1.0));
       clearRegion.Or(clearRegion, nsIntRect(bounds.X() + 2.0, bounds.YMost() - 1.0, bounds.Width() - 3.0, 1.0));
     }
   }
   nsRefPtr<LayerManager> layerManager = GetLayerManager();
   if (layerManager) {
     layerManager->SetRegionToClear(clearRegion);
   }
 }
 /**************************************************************
  **************************************************************
  **
  ** BLOCK: Moz Events
  **
  ** Moz GUI event management.
  **
  **************************************************************
  **************************************************************/
 /**************************************************************
  *
  * SECTION: Mozilla event initialization
  *
  * Helpers for initializing moz events.
  *
  **************************************************************/
 // Event intialization
 void nsWindow::InitEvent(WidgetGUIEvent& event, nsIntPoint* aPoint)
 {
   if (nullptr == aPoint) {     // use the point from the event
     // get the message position in client coordinates
     if (mWnd != nullptr) {
       DWORD pos = ::GetMessagePos();
       POINT cpos;
       cpos.x = GET_X_LPARAM(pos);
       cpos.y = GET_Y_LPARAM(pos);
       ::ScreenToClient(mWnd, &cpos);
       event.refPoint.x = cpos.x;
       event.refPoint.y = cpos.y;
     } else {
       event.refPoint.x = 0;
       event.refPoint.y = 0;
     }
   }
   else {
     // use the point override if provided
     event.refPoint.x = aPoint->x;
     event.refPoint.y = aPoint->y;
   }
   event.time = ::GetMessageTime();
 }
 /**************************************************************
  *
  * SECTION: Moz event dispatch helpers
  *
  * Helpers for dispatching different types of moz events.
  *
  **************************************************************/
 // Main event dispatch. Invokes callback and ProcessEvent method on
 // Event Listener object. Part of nsIWidget.
 NS_IMETHODIMP nsWindow::DispatchEvent(WidgetGUIEvent* event,
                                       nsEventStatus& aStatus)
 {
 #ifdef WIDGET_DEBUG_OUTPUT
   debug_DumpEvent(stdout,
                   event->widget,
                   event,
                   nsAutoCString("something"),
                   (int32_t) mWnd);
 #endif // WIDGET_DEBUG_OUTPUT
   aStatus = nsEventStatus_eIgnore;
   // Top level windows can have a view attached which requires events be sent
   // to the underlying base window and the view. Added when we combined the
   // base chrome window with the main content child for nc client area (title
   // bar) rendering.
   if (mAttachedWidgetListener) {
     aStatus = mAttachedWidgetListener->HandleEvent(event, mUseAttachedEvents);
   }
   else if (mWidgetListener) {
     aStatus = mWidgetListener->HandleEvent(event, mUseAttachedEvents);
   }
   // the window can be destroyed during processing of seemingly innocuous events like, say,
   // mousedowns due to the magic of scripting. mousedowns will return nsEventStatus_eIgnore,
   // which causes problems with the deleted window. therefore:
   if (mOnDestroyCalled)
     aStatus = nsEventStatus_eConsumeNoDefault;
   return NS_OK;
 }
 bool nsWindow::DispatchStandardEvent(uint32_t aMsg)
 {
   WidgetGUIEvent event(true, aMsg, this);
   InitEvent(event);
   bool result = DispatchWindowEvent(&event);
   return result;
 }
 bool nsWindow::DispatchKeyboardEvent(WidgetGUIEvent* event)
 {
   nsEventStatus status;
   DispatchEvent(event, status);
   return ConvertStatus(status);
 }
 bool nsWindow::DispatchScrollEvent(WidgetGUIEvent* event)
 {
   nsEventStatus status;
   DispatchEvent(event, status);
   return ConvertStatus(status);
 }
 bool nsWindow::DispatchWindowEvent(WidgetGUIEvent* event)
 {
   nsEventStatus status;
   DispatchEvent(event, status);
   return ConvertStatus(status);
 }
 bool nsWindow::DispatchWindowEvent(WidgetGUIEvent* event,
                                    nsEventStatus& aStatus)
 {
   DispatchEvent(event, aStatus);
   return ConvertStatus(aStatus);
 }
 // Recursively dispatch synchronous paints for nsIWidget
 // descendants with invalidated rectangles.
 BOOL CALLBACK nsWindow::DispatchStarvedPaints(HWND aWnd, LPARAM aMsg)
 {
   LONG_PTR proc = ::GetWindowLongPtrW(aWnd, GWLP_WNDPROC);
   if (proc == (LONG_PTR)&nsWindow::WindowProc) {
     // its one of our windows so check to see if it has a
     // invalidated rect. If it does. Dispatch a synchronous
     // paint.
     if (GetUpdateRect(aWnd, nullptr, FALSE))
       VERIFY(::UpdateWindow(aWnd));
   }
   return TRUE;
 }
 // Check for pending paints and dispatch any pending paint
 // messages for any nsIWidget which is a descendant of the
 // top-level window that *this* window is embedded within.
 //
 // Note: We do not dispatch pending paint messages for non
 // nsIWidget managed windows.
 void nsWindow::DispatchPendingEvents()
 {
   if (mPainting) {
     NS_WARNING("We were asked to dispatch pending events during painting, "
                "denying since that's unsafe.");
     return;
   }
   // We need to ensure that reflow events do not get starved.
   // At the same time, we don't want to recurse through here
   // as that would prevent us from dispatching starved paints.
   static int recursionBlocker = 0;
   if (recursionBlocker++ == 0) {
     NS_ProcessPendingEvents(nullptr, PR_MillisecondsToInterval(100));
     --recursionBlocker;
   }
   // Quickly check to see if there are any paint events pending,
   // but only dispatch them if it has been long enough since the
   // last paint completed.
   if (::GetQueueStatus(QS_PAINT) &&
       ((TimeStamp::Now() - mLastPaintEndTime).ToMilliseconds() >= 50)) {
     // Find the top level window.
     HWND topWnd = WinUtils::GetTopLevelHWND(mWnd);
     // Dispatch pending paints for topWnd and all its descendant windows.
     // Note: EnumChildWindows enumerates all descendant windows not just
     // the children (but not the window itself).
     nsWindow::DispatchStarvedPaints(topWnd, 0);
     ::EnumChildWindows(topWnd, nsWindow::DispatchStarvedPaints, 0);
   }
 }
 bool nsWindow::DispatchPluginEvent(UINT aMessage,
                                      WPARAM aWParam,
                                      LPARAM aLParam,
                                      bool aDispatchPendingEvents)
 {
   bool ret = nsWindowBase::DispatchPluginEvent(
                WinUtils::InitMSG(aMessage, aWParam, aLParam, mWnd));
   if (aDispatchPendingEvents && !Destroyed()) {
     DispatchPendingEvents();
   }
   return ret;
 }
 // Deal with all sort of mouse event
 bool nsWindow::DispatchMouseEvent(uint32_t aEventType, WPARAM wParam,
                                     LPARAM lParam, bool aIsContextMenuKey,
                                     int16_t aButton, uint16_t aInputSource)
 {
   bool result = false;
   UserActivity();
   if (!mWidgetListener) {
     return result;
   }
   switch (aEventType) {
     case NS_MOUSE_BUTTON_DOWN:
       CaptureMouse(true);
       break;
     // NS_MOUSE_MOVE and NS_MOUSE_EXIT are here because we need to make sure capture flag
     // isn't left on after a drag where we wouldn't see a button up message (see bug 324131).
     case NS_MOUSE_BUTTON_UP:
     case NS_MOUSE_MOVE:
     case NS_MOUSE_EXIT:
       if (!(wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) && sIsInMouseCapture)
         CaptureMouse(false);
       break;
     default:
       break;
   } // switch
   nsIntPoint eventPoint;
   eventPoint.x = GET_X_LPARAM(lParam);
   eventPoint.y = GET_Y_LPARAM(lParam);
   WidgetMouseEvent event(true, aEventType, this, WidgetMouseEvent::eReal,
                          aIsContextMenuKey ? WidgetMouseEvent::eContextMenuKey :
                                              WidgetMouseEvent::eNormal);
   if (aEventType == NS_CONTEXTMENU && aIsContextMenuKey) {
     nsIntPoint zero(0, 0);
     InitEvent(event, &zero);
   } else {
     InitEvent(event, &eventPoint);
   }
   ModifierKeyState modifierKeyState;
   modifierKeyState.InitInputEvent(event);
   event.button    = aButton;
   event.inputSource = aInputSource;
   // Convert Mouse events generated by pen device or if mouse not generated from touch
   event.convertToPointer =
     aInputSource == nsIDOMMouseEvent::MOZ_SOURCE_PEN ||
     !(WinUtils::GetIsMouseFromTouch(aEventType) && mTouchWindow);
   nsIntPoint mpScreen = eventPoint + WidgetToScreenOffset();
   // Suppress mouse moves caused by widget creation
   if (aEventType == NS_MOUSE_MOVE)
   {
     if ((sLastMouseMovePoint.x == mpScreen.x) && (sLastMouseMovePoint.y == mpScreen.y))
       return result;
     sLastMouseMovePoint.x = mpScreen.x;
     sLastMouseMovePoint.y = mpScreen.y;
   }
   bool insideMovementThreshold = (DeprecatedAbs(sLastMousePoint.x - eventPoint.x) < (short)::GetSystemMetrics(SM_CXDOUBLECLK)) &&
                                    (DeprecatedAbs(sLastMousePoint.y - eventPoint.y) < (short)::GetSystemMetrics(SM_CYDOUBLECLK));
   BYTE eventButton;
   switch (aButton) {
     case WidgetMouseEvent::eLeftButton:
       eventButton = VK_LBUTTON;
       break;
     case WidgetMouseEvent::eMiddleButton:
       eventButton = VK_MBUTTON;
       break;
     case WidgetMouseEvent::eRightButton:
       eventButton = VK_RBUTTON;
       break;
     default:
       eventButton = 0;
       break;
   }
   // Doubleclicks are used to set the click count, then changed to mousedowns
   // We're going to time double-clicks from mouse *up* to next mouse *down*
   LONG curMsgTime = ::GetMessageTime();
   if (aEventType == NS_MOUSE_DOUBLECLICK) {
     event.message = NS_MOUSE_BUTTON_DOWN;
     event.button = aButton;
     sLastClickCount = 2;
   }
   else if (aEventType == NS_MOUSE_BUTTON_UP) {
     // remember when this happened for the next mouse down
     sLastMousePoint.x = eventPoint.x;
     sLastMousePoint.y = eventPoint.y;
     sLastMouseButton = eventButton;
   }
   else if (aEventType == NS_MOUSE_BUTTON_DOWN) {
     // now look to see if we want to convert this to a double- or triple-click
     if (((curMsgTime - sLastMouseDownTime) < (LONG)::GetDoubleClickTime()) && insideMovementThreshold &&
         eventButton == sLastMouseButton) {
       sLastClickCount ++;
     } else {
       // reset the click count, to count *this* click
       sLastClickCount = 1;
     }
     // Set last Click time on MouseDown only
     sLastMouseDownTime = curMsgTime;
   }
   else if (aEventType == NS_MOUSE_MOVE && !insideMovementThreshold) {
     sLastClickCount = 0;
   }
   else if (aEventType == NS_MOUSE_EXIT) {
     event.exit = IsTopLevelMouseExit(mWnd) ?
                    WidgetMouseEvent::eTopLevel : WidgetMouseEvent::eChild;
   }
   event.clickCount = sLastClickCount;
 #ifdef NS_DEBUG_XX
   PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
          ("Msg Time: %d Click Count: %d\n", curMsgTime, event.clickCount));
 #endif
   NPEvent pluginEvent;
   switch (aEventType)
   {
     case NS_MOUSE_BUTTON_DOWN:
       switch (aButton) {
         case WidgetMouseEvent::eLeftButton:
           pluginEvent.event = WM_LBUTTONDOWN;
           break;
         case WidgetMouseEvent::eMiddleButton:
           pluginEvent.event = WM_MBUTTONDOWN;
           break;
         case WidgetMouseEvent::eRightButton:
           pluginEvent.event = WM_RBUTTONDOWN;
           break;
         default:
           break;
       }
       break;
     case NS_MOUSE_BUTTON_UP:
       switch (aButton) {
         case WidgetMouseEvent::eLeftButton:
           pluginEvent.event = WM_LBUTTONUP;
           break;
         case WidgetMouseEvent::eMiddleButton:
           pluginEvent.event = WM_MBUTTONUP;
           break;
         case WidgetMouseEvent::eRightButton:
           pluginEvent.event = WM_RBUTTONUP;
           break;
         default:
           break;
       }
       break;
     case NS_MOUSE_DOUBLECLICK:
       switch (aButton) {
         case WidgetMouseEvent::eLeftButton:
           pluginEvent.event = WM_LBUTTONDBLCLK;
           break;
         case WidgetMouseEvent::eMiddleButton:
           pluginEvent.event = WM_MBUTTONDBLCLK;
           break;
         case WidgetMouseEvent::eRightButton:
           pluginEvent.event = WM_RBUTTONDBLCLK;
           break;
         default:
           break;
       }
       break;
     case NS_MOUSE_MOVE:
       pluginEvent.event = WM_MOUSEMOVE;
       break;
     case NS_MOUSE_EXIT:
       pluginEvent.event = WM_MOUSELEAVE;
       break;
     default:
       pluginEvent.event = WM_NULL;
       break;
   }
   pluginEvent.wParam = wParam;     // plugins NEED raw OS event flags!
   pluginEvent.lParam = lParam;
   event.pluginEvent = (void *)&pluginEvent;
   // call the event callback
   if (mWidgetListener) {
     if (nsToolkit::gMouseTrailer)
       nsToolkit::gMouseTrailer->Disable();
     if (aEventType == NS_MOUSE_MOVE) {
       if (nsToolkit::gMouseTrailer && !sIsInMouseCapture) {
         nsToolkit::gMouseTrailer->SetMouseTrailerWindow(mWnd);
       }
       nsIntRect rect;
       GetBounds(rect);
       rect.x = 0;
       rect.y = 0;
       if (rect.Contains(LayoutDeviceIntPoint::ToUntyped(event.refPoint))) {
         if (sCurrentWindow == nullptr || sCurrentWindow != this) {
           if ((nullptr != sCurrentWindow) && (!sCurrentWindow->mInDtor)) {
             LPARAM pos = sCurrentWindow->lParamToClient(lParamToScreen(lParam));
             sCurrentWindow->DispatchMouseEvent(NS_MOUSE_EXIT, wParam, pos, false,
                                                WidgetMouseEvent::eLeftButton,
                                                aInputSource);
           }
           sCurrentWindow = this;
           if (!mInDtor) {
             LPARAM pos = sCurrentWindow->lParamToClient(lParamToScreen(lParam));
             sCurrentWindow->DispatchMouseEvent(NS_MOUSE_ENTER, wParam, pos, false,
                                                WidgetMouseEvent::eLeftButton,
                                                aInputSource);
           }
         }
       }
     } else if (aEventType == NS_MOUSE_EXIT) {
       if (sCurrentWindow == this) {
         sCurrentWindow = nullptr;
       }
     }
     result = DispatchWindowEvent(&event);
     if (nsToolkit::gMouseTrailer)
       nsToolkit::gMouseTrailer->Enable();
     // Release the widget with NS_IF_RELEASE() just in case
     // the context menu key code in EventListenerManager::HandleEvent()
     // released it already.
     return result;
   }
   return result;
 }
 void nsWindow::DispatchFocusToTopLevelWindow(bool aIsActivate)
 {
   if (aIsActivate)
     sJustGotActivate = false;
   sJustGotDeactivate = false;
   // retrive the toplevel window or dialog
   HWND curWnd = mWnd;
   HWND toplevelWnd = nullptr;
   while (curWnd) {
     toplevelWnd = curWnd;
     nsWindow *win = WinUtils::GetNSWindowPtr(curWnd);
     if (win) {
       nsWindowType wintype = win->WindowType();
       if (wintype == eWindowType_toplevel || wintype == eWindowType_dialog)
         break;
     }
     curWnd = ::GetParent(curWnd); // Parent or owner (if has no parent)
   }
   if (toplevelWnd) {
     nsWindow *win = WinUtils::GetNSWindowPtr(toplevelWnd);
     if (win && win->mWidgetListener) {
       if (aIsActivate) {
         win->mWidgetListener->WindowActivated();
       } else {
         if (!win->BlurEventsSuppressed()) {
           win->mWidgetListener->WindowDeactivated();
         }
       }
     }
   }
 }
 bool nsWindow::IsTopLevelMouseExit(HWND aWnd)
 {
   DWORD pos = ::GetMessagePos();
   POINT mp;
   mp.x = GET_X_LPARAM(pos);
   mp.y = GET_Y_LPARAM(pos);
   HWND mouseWnd = ::WindowFromPoint(mp);
   // WinUtils::GetTopLevelHWND() will return a HWND for the window frame
   // (which includes the non-client area).  If the mouse has moved into
   // the non-client area, we should treat it as a top-level exit.
   HWND mouseTopLevel = WinUtils::GetTopLevelHWND(mouseWnd);
   if (mouseWnd == mouseTopLevel)
     return true;
   return WinUtils::GetTopLevelHWND(aWnd) != mouseTopLevel;
 }
 bool nsWindow::BlurEventsSuppressed()
 {
   // are they suppressed in this window?
   if (mBlurSuppressLevel > 0)
     return true;
   // are they suppressed by any container widget?
   HWND parentWnd = ::GetParent(mWnd);
   if (parentWnd) {
     nsWindow *parent = WinUtils::GetNSWindowPtr(parentWnd);
     if (parent)
       return parent->BlurEventsSuppressed();
   }
   return false;
 }
 // In some circumstances (opening dependent windows) it makes more sense
 // (and fixes a crash bug) to not blur the parent window. Called from
 // nsFilePicker.
 void nsWindow::SuppressBlurEvents(bool aSuppress)
 {
   if (aSuppress)
     ++mBlurSuppressLevel; // for this widget
   else {
     NS_ASSERTION(mBlurSuppressLevel > 0, "unbalanced blur event suppression");
     if (mBlurSuppressLevel > 0)
       --mBlurSuppressLevel;
   }
 }
 bool nsWindow::ConvertStatus(nsEventStatus aStatus)
 {
   return aStatus == nsEventStatus_eConsumeNoDefault;
 }
 /**************************************************************
  *
  * SECTION: IPC
  *
  * IPC related helpers.
  *
  **************************************************************/
 // static
 bool
 nsWindow::IsAsyncResponseEvent(UINT aMsg, LRESULT& aResult)
 {
   switch(aMsg) {
     case WM_SETFOCUS:
     case WM_KILLFOCUS:
     case WM_ENABLE:
     case WM_WINDOWPOSCHANGING:
     case WM_WINDOWPOSCHANGED:
     case WM_PARENTNOTIFY:
     case WM_ACTIVATEAPP:
     case WM_NCACTIVATE:
     case WM_ACTIVATE:
     case WM_CHILDACTIVATE:
     case WM_IME_SETCONTEXT:
     case WM_IME_NOTIFY:
     case WM_SHOWWINDOW:
     case WM_CANCELMODE:
     case WM_MOUSEACTIVATE:
     case WM_CONTEXTMENU:
       aResult = 0;
     return true;
     case WM_SETTINGCHANGE:
     case WM_SETCURSOR:
     return false;
   }
 #ifdef DEBUG
   char szBuf[200];
   sprintf(szBuf,
     "An unhandled ISMEX_SEND message was received during spin loop! (%X)", aMsg);
   NS_WARNING(szBuf);
 #endif
   return false;
 }
 void
 nsWindow::IPCWindowProcHandler(UINT& msg, WPARAM& wParam, LPARAM& lParam)
 {
   NS_ASSERTION(!mozilla::ipc::MessageChannel::IsPumpingMessages(),
                "Failed to prevent a nonqueued message from running!");
   // Modal UI being displayed in windowless plugins.
   if (mozilla::ipc::MessageChannel::IsSpinLoopActive() &&
       (InSendMessageEx(nullptr) & (ISMEX_REPLIED|ISMEX_SEND)) == ISMEX_SEND) {
     LRESULT res;
     if (IsAsyncResponseEvent(msg, res)) {
       ReplyMessage(res);
     }
     return;
   }
   // Handle certain sync plugin events sent to the parent which
   // trigger ipc calls that result in deadlocks.
   DWORD dwResult = 0;
   bool handled = false;
   switch(msg) {
     // Windowless flash sending WM_ACTIVATE events to the main window
     // via calls to ShowWindow.
     case WM_ACTIVATE:
       if (lParam != 0 && LOWORD(wParam) == WA_ACTIVE &&
           IsWindow((HWND)lParam)) {
         // Check for Adobe Reader X sync activate message from their
         // helper window and ignore. Fixes an annoying focus problem.
         if ((InSendMessageEx(nullptr) & (ISMEX_REPLIED|ISMEX_SEND)) == ISMEX_SEND) {
           wchar_t szClass[10];
           HWND focusWnd = (HWND)lParam;
           if (IsWindowVisible(focusWnd) &&
               GetClassNameW(focusWnd, szClass,
                             sizeof(szClass)/sizeof(char16_t)) &&
               !wcscmp(szClass, L"Edit") &&
               !WinUtils::IsOurProcessWindow(focusWnd)) {
             break;
           }
         }
         handled = true;
       }
     break;
     // Plugins taking or losing focus triggering focus app messages.
     case WM_SETFOCUS:
     case WM_KILLFOCUS:
     // Windowed plugins that pass sys key events to defwndproc generate
     // WM_SYSCOMMAND events to the main window.
     case WM_SYSCOMMAND:
     // Windowed plugins that fire context menu selection events to parent
     // windows.
     case WM_CONTEXTMENU:
     // IME events fired as a result of synchronous focus changes
     case WM_IME_SETCONTEXT:
       handled = true;
     break;
   }
   if (handled &&
       (InSendMessageEx(nullptr) & (ISMEX_REPLIED|ISMEX_SEND)) == ISMEX_SEND) {
     ReplyMessage(dwResult);
   }
 }
 /**************************************************************
  **************************************************************
  **
  ** BLOCK: Native events
  **
  ** Main Windows message handlers and OnXXX handlers for
  ** Windows event handling.
  **
  **************************************************************
  **************************************************************/
 /**************************************************************
  *
  * SECTION: Wind proc.
  *
  * The main Windows event procedures and associated
  * message processing methods.
  *
  **************************************************************/
 static bool
 DisplaySystemMenu(HWND hWnd, nsSizeMode sizeMode, bool isRtl, int32_t x, int32_t y)
 {
   HMENU hMenu = GetSystemMenu(hWnd, FALSE);
   if (hMenu) {
     MENUITEMINFO mii;
     mii.cbSize = sizeof(MENUITEMINFO);
     mii.fMask = MIIM_STATE;
     mii.fType = 0;
     // update the options
     mii.fState = MF_ENABLED;
     SetMenuItemInfo(hMenu, SC_RESTORE, FALSE, &mii);
     SetMenuItemInfo(hMenu, SC_SIZE, FALSE, &mii);
     SetMenuItemInfo(hMenu, SC_MOVE, FALSE, &mii);
     SetMenuItemInfo(hMenu, SC_MAXIMIZE, FALSE, &mii);
     SetMenuItemInfo(hMenu, SC_MINIMIZE, FALSE, &mii);
     mii.fState = MF_GRAYED;
     switch(sizeMode) {
       case nsSizeMode_Fullscreen:
         SetMenuItemInfo(hMenu, SC_RESTORE, FALSE, &mii);
         // intentional fall through
       case nsSizeMode_Maximized:
         SetMenuItemInfo(hMenu, SC_SIZE, FALSE, &mii);
         SetMenuItemInfo(hMenu, SC_MOVE, FALSE, &mii);
         SetMenuItemInfo(hMenu, SC_MAXIMIZE, FALSE, &mii);
         break;
       case nsSizeMode_Minimized:
         SetMenuItemInfo(hMenu, SC_MINIMIZE, FALSE, &mii);
         break;
       case nsSizeMode_Normal:
         SetMenuItemInfo(hMenu, SC_RESTORE, FALSE, &mii);
         break;
     }
     LPARAM cmd =
       TrackPopupMenu(hMenu,
                      (TPM_LEFTBUTTON|TPM_RIGHTBUTTON|
                       TPM_RETURNCMD|TPM_TOPALIGN|
                       (isRtl ? TPM_RIGHTALIGN : TPM_LEFTALIGN)),
                      x, y, 0, hWnd, nullptr);
     if (cmd) {
       PostMessage(hWnd, WM_SYSCOMMAND, cmd, 0);
       return true;
     }
   }
   return false;
 }
 inline static mozilla::HangMonitor::ActivityType ActivityTypeForMessage(UINT msg)
 {
   if ((msg >= WM_KEYFIRST && msg <= WM_IME_KEYLAST) ||
       (msg >= WM_MOUSEFIRST && msg <= WM_MOUSELAST) ||
       (msg >= MOZ_WM_MOUSEWHEEL_FIRST && msg <= MOZ_WM_MOUSEWHEEL_LAST) ||
       (msg >= NS_WM_IMEFIRST && msg <= NS_WM_IMELAST)) {
     return mozilla::HangMonitor::kUIActivity;
   }
   // This may not actually be right, but we don't want to reset the timer if
   // we're not actually processing a UI message.
   return mozilla::HangMonitor::kActivityUIAVail;
 }
 // The WndProc procedure for all nsWindows in this toolkit. This merely catches
 // exceptions and passes the real work to WindowProcInternal. See bug 587406
 // and http://msdn.microsoft.com/en-us/library/ms633573%28VS.85%29.aspx
 LRESULT CALLBACK nsWindow::WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
   HangMonitor::NotifyActivity(ActivityTypeForMessage(msg));
   return mozilla::CallWindowProcCrashProtected(WindowProcInternal, hWnd, msg, wParam, lParam);
 }
 LRESULT CALLBACK nsWindow::WindowProcInternal(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
   if (::GetWindowLongPtrW(hWnd, GWLP_ID) == eFakeTrackPointScrollableID) {
     // This message was sent to the FAKETRACKPOINTSCROLLABLE.
     if (msg == WM_HSCROLL) {
       // Route WM_HSCROLL messages to the main window.
       hWnd = ::GetParent(::GetParent(hWnd));
     } else {
       // Handle all other messages with its original window procedure.
       WNDPROC prevWindowProc = (WNDPROC)::GetWindowLongPtr(hWnd, GWLP_USERDATA);
       return ::CallWindowProcW(prevWindowProc, hWnd, msg, wParam, lParam);
     }
   }
   if (msg == MOZ_WM_TRACE) {
     // This is a tracer event for measuring event loop latency.
     // See WidgetTraceEvent.cpp for more details.
     mozilla::SignalTracerThread();
     return 0;
   }
   // Get the window which caused the event and ask it to process the message
   nsWindow *targetWindow = WinUtils::GetNSWindowPtr(hWnd);
   NS_ASSERTION(targetWindow, "nsWindow* is null!");
   if (!targetWindow)
     return ::DefWindowProcW(hWnd, msg, wParam, lParam);
   // Hold the window for the life of this method, in case it gets
   // destroyed during processing, unless we're in the dtor already.
   nsCOMPtr<nsISupports> kungFuDeathGrip;
   if (!targetWindow->mInDtor)
     kungFuDeathGrip = do_QueryInterface((nsBaseWidget*)targetWindow);
   targetWindow->IPCWindowProcHandler(msg, wParam, lParam);
   // Create this here so that we store the last rolled up popup until after
   // the event has been processed.
   nsAutoRollup autoRollup;
   LRESULT popupHandlingResult;
   if (DealWithPopups(hWnd, msg, wParam, lParam, &popupHandlingResult))
     return popupHandlingResult;
   // Call ProcessMessage
   LRESULT retValue;
   if (targetWindow->ProcessMessage(msg, wParam, lParam, &retValue)) {
     return retValue;
   }
   LRESULT res = ::CallWindowProcW(targetWindow->GetPrevWindowProc(),
                                   hWnd, msg, wParam, lParam);
   return res;
 }
 // The main windows message processing method for plugins.
 // The result means whether this method processed the native
 // event for plugin. If false, the native event should be
 // processed by the caller self.
 bool
 nsWindow::ProcessMessageForPlugin(const MSG &aMsg,
                                   MSGResult& aResult)
 {
   aResult.mResult = 0;
   aResult.mConsumed = true;
   bool eventDispatched = false;
   switch (aMsg.message) {
     case WM_CHAR:
     case WM_SYSCHAR:
       aResult.mResult = ProcessCharMessage(aMsg, &eventDispatched);
       break;
     case WM_KEYUP:
     case WM_SYSKEYUP:
       aResult.mResult = ProcessKeyUpMessage(aMsg, &eventDispatched);
       break;
     case WM_KEYDOWN:
     case WM_SYSKEYDOWN:
       aResult.mResult = ProcessKeyDownMessage(aMsg, &eventDispatched);
       break;
     case WM_DEADCHAR:
     case WM_SYSDEADCHAR:
     case WM_CUT:
     case WM_COPY:
     case WM_PASTE:
     case WM_CLEAR:
     case WM_UNDO:
       break;
     default:
       return false;
   }
   if (!eventDispatched) {
     aResult.mConsumed = nsWindowBase::DispatchPluginEvent(aMsg);
   }
   if (!Destroyed()) {
     DispatchPendingEvents();
   }
   return true;
 }
 static void ForceFontUpdate()
 {
   // update device context font cache
   // Dirty but easiest way:
   // Changing nsIPrefBranch entry which triggers callbacks
   // and flows into calling mDeviceContext->FlushFontCache()
   // to update the font cache in all the instance of Browsers
   static const char kPrefName[] = "font.internaluseonly.changed";
   bool fontInternalChange =
     Preferences::GetBool(kPrefName, false);
   Preferences::SetBool(kPrefName, !fontInternalChange);
 }
 static bool CleartypeSettingChanged()
 {
   static int currentQuality = -1;
   BYTE quality = cairo_win32_get_system_text_quality();
   if (currentQuality == quality)
     return false;
   if (currentQuality < 0) {
     currentQuality = quality;
     return false;
   }
   currentQuality = quality;
   return true;
 }
 bool
 nsWindow::ExternalHandlerProcessMessage(UINT aMessage,
                                         WPARAM& aWParam,
                                         LPARAM& aLParam,
                                         MSGResult& aResult)
 {
   if (mWindowHook.Notify(mWnd, aMessage, aWParam, aLParam, aResult)) {
     return true;
   }
   if (IMEHandler::ProcessMessage(this, aMessage, aWParam, aLParam, aResult)) {
     return true;
   }
   if (MouseScrollHandler::ProcessMessage(this, aMessage, aWParam, aLParam,
                                          aResult)) {
     return true;
   }
   if (PluginHasFocus()) {
     MSG nativeMsg = WinUtils::InitMSG(aMessage, aWParam, aLParam, mWnd);
     if (ProcessMessageForPlugin(nativeMsg, aResult)) {
       return true;
     }
   }
   return false;
 }
 // The main windows message processing method.
 bool
 nsWindow::ProcessMessage(UINT msg, WPARAM& wParam, LPARAM& lParam,
                          LRESULT *aRetValue)
 {
 #if defined(EVENT_DEBUG_OUTPUT)
   // First param shows all events, second param indicates whether
   // to show mouse move events. See nsWindowDbg for details.
   PrintEvent(msg, SHOW_REPEAT_EVENTS, SHOW_MOUSEMOVE_EVENTS);
 #endif
   MSGResult msgResult(aRetValue);
   if (ExternalHandlerProcessMessage(msg, wParam, lParam, msgResult)) {
     return (msgResult.mConsumed || !mWnd);
   }
   bool result = false;    // call the default nsWindow proc
   *aRetValue = 0;
   // Glass hit testing w/custom transparent margins
   LRESULT dwmHitResult;
   if (mCustomNonClient &&
       nsUXThemeData::CheckForCompositor() &&
       WinUtils::dwmDwmDefWindowProcPtr(mWnd, msg, wParam, lParam, &dwmHitResult)) {
     *aRetValue = dwmHitResult;
     return true;
   }
   // (Large blocks of code should be broken out into OnEvent handlers.)
   switch (msg) {
     // WM_QUERYENDSESSION must be handled by all windows.
     // Otherwise Windows thinks the window can just be killed at will.
     case WM_QUERYENDSESSION:
       if (sCanQuit == TRI_UNKNOWN)
       {
         // Ask if it's ok to quit, and store the answer until we
         // get WM_ENDSESSION signaling the round is complete.
         nsCOMPtr<nsIObserverService> obsServ =
           mozilla::services::GetObserverService();
         nsCOMPtr<nsISupportsPRBool> cancelQuit =
           do_CreateInstance(NS_SUPPORTS_PRBOOL_CONTRACTID);
         cancelQuit->SetData(false);
         obsServ->NotifyObservers(cancelQuit, "quit-application-requested", nullptr);
         bool abortQuit;
         cancelQuit->GetData(&abortQuit);
         sCanQuit = abortQuit ? TRI_FALSE : TRI_TRUE;
       }
       *aRetValue = sCanQuit ? TRUE : FALSE;
       result = true;
       break;
     case WM_ENDSESSION:
     case MOZ_WM_APP_QUIT:
       if (msg == MOZ_WM_APP_QUIT || (wParam == TRUE && sCanQuit == TRI_TRUE))
       {
         // Let's fake a shutdown sequence without actually closing windows etc.
         // to avoid Windows killing us in the middle. A proper shutdown would
         // require having a chance to pump some messages. Unfortunately
         // Windows won't let us do that. Bug 212316.
         nsCOMPtr<nsIObserverService> obsServ =
           mozilla::services::GetObserverService();
         NS_NAMED_LITERAL_STRING(context, "shutdown-persist");
         obsServ->NotifyObservers(nullptr, "quit-application-granted", nullptr);
         obsServ->NotifyObservers(nullptr, "quit-application-forced", nullptr);
         obsServ->NotifyObservers(nullptr, "quit-application", nullptr);
         obsServ->NotifyObservers(nullptr, "profile-change-net-teardown", context.get());
         obsServ->NotifyObservers(nullptr, "profile-change-teardown", context.get());
         obsServ->NotifyObservers(nullptr, "profile-before-change", context.get());
         obsServ->NotifyObservers(nullptr, "profile-before-change2", context.get());
         // Then a controlled but very quick exit.
         _exit(0);
       }
       sCanQuit = TRI_UNKNOWN;
       result = true;
       break;
     case WM_SYSCOLORCHANGE:
       OnSysColorChanged();
       break;
     case WM_THEMECHANGED:
     {
       // Update non-client margin offsets
       UpdateNonClientMargins();
       nsUXThemeData::InitTitlebarInfo();
       nsUXThemeData::UpdateNativeThemeInfo();
       NotifyThemeChanged();
       // Invalidate the window so that the repaint will
       // pick up the new theme.
       Invalidate(true, true, true);
     }
     break;
     case WM_FONTCHANGE:
     {
       // We only handle this message for the hidden window,
       // as we only need to update the (global) font list once
       // for any given change, not once per window!
       if (mWindowType != eWindowType_invisible) {
         break;
       }
       nsresult rv;
       bool didChange = false;
       // update the global font list
       nsCOMPtr<nsIFontEnumerator> fontEnum = do_GetService("@mozilla.org/gfx/fontenumerator;1", &rv);
       if (NS_SUCCEEDED(rv)) {
         fontEnum->UpdateFontList(&didChange);
         ForceFontUpdate();
       } //if (NS_SUCCEEDED(rv))
     }
     break;
     case WM_NCCALCSIZE:
     {
       if (mCustomNonClient) {
         // If `wParam` is `FALSE`, `lParam` points to a `RECT` that contains
         // the proposed window rectangle for our window.  During our
         // processing of the `WM_NCCALCSIZE` message, we are expected to
         // modify the `RECT` that `lParam` points to, so that its value upon
         // our return is the new client area.  We must return 0 if `wParam`
         // is `FALSE`.
         //
         // If `wParam` is `TRUE`, `lParam` points to a `NCCALCSIZE_PARAMS`
         // struct.  This struct contains an array of 3 `RECT`s, the first of
         // which has the exact same meaning as the `RECT` that is pointed to
         // by `lParam` when `wParam` is `FALSE`.  The remaining `RECT`s, in
         // conjunction with our return value, can
         // be used to specify portions of the source and destination window
         // rectangles that are valid and should be preserved.  We opt not to
         // implement an elaborate client-area preservation technique, and
         // simply return 0, which means "preserve the entire old client area
         // and align it with the upper-left corner of our new client area".
         RECT *clientRect = wParam
                          ? &(reinterpret_cast<NCCALCSIZE_PARAMS*>(lParam))->rgrc[0]
                          : (reinterpret_cast<RECT*>(lParam));
         clientRect->top      += (mCaptionHeight - mNonClientOffset.top);
         clientRect->left     += (mHorResizeMargin - mNonClientOffset.left);
         clientRect->right    -= (mHorResizeMargin - mNonClientOffset.right);
         clientRect->bottom   -= (mVertResizeMargin - mNonClientOffset.bottom);
         result = true;
         *aRetValue = 0;
       }
       break;
     }
     case WM_NCHITTEST:
     {
       if (mMouseTransparent) {
         // Treat this window as transparent.
         *aRetValue = HTTRANSPARENT;
         result = true;
         break;
       }
       /*
        * If an nc client area margin has been moved, we are responsible
        * for calculating where the resize margins are and returning the
        * appropriate set of hit test constants. DwmDefWindowProc (above)
        * will handle hit testing on it's command buttons if we are on a
        * composited desktop.
        */
       if (!mCustomNonClient)
         break;
       *aRetValue =
         ClientMarginHitTestPoint(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
       result = true;
       break;
     }
     case WM_SETTEXT:
       /*
        * WM_SETTEXT paints the titlebar area. Avoid this if we have a
        * custom titlebar we paint ourselves.
        */
       if (!mCustomNonClient || mNonClientMargins.top == -1)
         break;
       {
         // From msdn, the way around this is to disable the visible state
         // temporarily. We need the text to be set but we don't want the
         // redraw to occur.
         DWORD style = GetWindowLong(mWnd, GWL_STYLE);
         SetWindowLong(mWnd, GWL_STYLE, style & ~WS_VISIBLE);
         *aRetValue = CallWindowProcW(GetPrevWindowProc(), mWnd,
                                      msg, wParam, lParam);
         SetWindowLong(mWnd, GWL_STYLE, style);
         return true;
       }
     case WM_NCACTIVATE:
     {
       /*
        * WM_NCACTIVATE paints nc areas. Avoid this and re-route painting
        * through WM_NCPAINT via InvalidateNonClientRegion.
        */
       UpdateGetWindowInfoCaptionStatus(FALSE != wParam);
       if (!mCustomNonClient)
         break;
       // let the dwm handle nc painting on glass
       if(nsUXThemeData::CheckForCompositor())
         break;
       if (wParam == TRUE) {
         // going active
         *aRetValue = FALSE; // ignored
         result = true;
         // invalidate to trigger a paint
         InvalidateNonClientRegion();
         break;
       } else {
         // going inactive
         *aRetValue = TRUE; // go ahead and deactive
         result = true;
         // invalidate to trigger a paint
         InvalidateNonClientRegion();
         break;
       }
     }
     case WM_NCPAINT:
     {
       /*
        * Reset the non-client paint region so that it excludes the
        * non-client areas we paint manually. Then call defwndproc
        * to do the actual painting.
        */
       if (!mCustomNonClient)
         break;
       // let the dwm handle nc painting on glass
       if(nsUXThemeData::CheckForCompositor())
         break;
       HRGN paintRgn = ExcludeNonClientFromPaintRegion((HRGN)wParam);
       LRESULT res = CallWindowProcW(GetPrevWindowProc(), mWnd,
                                     msg, (WPARAM)paintRgn, lParam);
       if (paintRgn != (HRGN)wParam)
         DeleteObject(paintRgn);
       *aRetValue = res;
       result = true;
     }
     break;
     case WM_POWERBROADCAST:
       switch (wParam)
       {
         case PBT_APMSUSPEND:
           PostSleepWakeNotification(true);
           break;
         case PBT_APMRESUMEAUTOMATIC:
         case PBT_APMRESUMECRITICAL:
         case PBT_APMRESUMESUSPEND:
           PostSleepWakeNotification(false);
           break;
       }
       break;
     case WM_CLOSE: // close request
       if (mWidgetListener)
         mWidgetListener->RequestWindowClose(this);
       result = true; // abort window closure
       break;
     case WM_DESTROY:
       // clean up.
       OnDestroy();
       result = true;
       break;
     case WM_PAINT:
       if (CleartypeSettingChanged()) {
         ForceFontUpdate();
         gfxFontCache *fc = gfxFontCache::GetCache();
         if (fc) {
           fc->Flush();
         }
       }
       *aRetValue = (int) OnPaint(nullptr, 0);
       result = true;
       break;
     case WM_PRINTCLIENT:
       result = OnPaint((HDC) wParam, 0);
       break;
     case WM_HOTKEY:
       result = OnHotKey(wParam, lParam);
       break;
     case WM_SYSCHAR:
     case WM_CHAR:
     {
       MSG nativeMsg = WinUtils::InitMSG(msg, wParam, lParam, mWnd);
       result = ProcessCharMessage(nativeMsg, nullptr);
       DispatchPendingEvents();
     }
     break;
     case WM_SYSKEYUP:
     case WM_KEYUP:
     {
       MSG nativeMsg = WinUtils::InitMSG(msg, wParam, lParam, mWnd);
       nativeMsg.time = ::GetMessageTime();
       result = ProcessKeyUpMessage(nativeMsg, nullptr);
       DispatchPendingEvents();
     }
     break;
     case WM_SYSKEYDOWN:
     case WM_KEYDOWN:
     {
       MSG nativeMsg = WinUtils::InitMSG(msg, wParam, lParam, mWnd);
       result = ProcessKeyDownMessage(nativeMsg, nullptr);
       DispatchPendingEvents();
     }
     break;
     // say we've dealt with erase background if widget does
     // not need auto-erasing
     case WM_ERASEBKGND:
       if (!AutoErase((HDC)wParam)) {
         *aRetValue = 1;
         result = true;
       }
       break;
     case WM_MOUSEMOVE:
     {
       mMousePresent = true;
       // Suppress dispatch of pending events
       // when mouse moves are generated by widget
       // creation instead of user input.
       LPARAM lParamScreen = lParamToScreen(lParam);
       POINT mp;
       mp.x      = GET_X_LPARAM(lParamScreen);
       mp.y      = GET_Y_LPARAM(lParamScreen);
       bool userMovedMouse = false;
       if ((sLastMouseMovePoint.x != mp.x) || (sLastMouseMovePoint.y != mp.y)) {
         userMovedMouse = true;
       }
       result = DispatchMouseEvent(NS_MOUSE_MOVE, wParam, lParam,
                                   false, WidgetMouseEvent::eLeftButton,
                                   MOUSE_INPUT_SOURCE());
       if (userMovedMouse) {
         DispatchPendingEvents();
       }
     }
     break;
     case WM_NCMOUSEMOVE:
       // If we receive a mouse move event on non-client chrome, make sure and
       // send an NS_MOUSE_EXIT event as well.
       if (mMousePresent && !sIsInMouseCapture)
         SendMessage(mWnd, WM_MOUSELEAVE, 0, 0);
     break;
     case WM_LBUTTONDOWN:
     {
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_DOWN, wParam, lParam,
                                   false, WidgetMouseEvent::eLeftButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
     }
     break;
     case WM_LBUTTONUP:
     {
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_UP, wParam, lParam,
                                   false, WidgetMouseEvent::eLeftButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
     }
     break;
     case WM_MOUSELEAVE:
     {
       if (!mMousePresent)
         break;
       mMousePresent = false;
       // We need to check mouse button states and put them in for
       // wParam.
       WPARAM mouseState = (GetKeyState(VK_LBUTTON) ? MK_LBUTTON : 0)
         | (GetKeyState(VK_MBUTTON) ? MK_MBUTTON : 0)
         | (GetKeyState(VK_RBUTTON) ? MK_RBUTTON : 0);
       // Synthesize an event position because we don't get one from
       // WM_MOUSELEAVE.
       LPARAM pos = lParamToClient(::GetMessagePos());
       DispatchMouseEvent(NS_MOUSE_EXIT, mouseState, pos, false,
                          WidgetMouseEvent::eLeftButton, MOUSE_INPUT_SOURCE());
     }
     break;
     case WM_CONTEXTMENU:
     {
       // if the context menu is brought up from the keyboard, |lParam|
       // will be -1.
       LPARAM pos;
       bool contextMenukey = false;
       if (lParam == -1)
       {
         contextMenukey = true;
         pos = lParamToClient(GetMessagePos());
       }
       else
       {
         pos = lParamToClient(lParam);
       }
       result = DispatchMouseEvent(NS_CONTEXTMENU, wParam, pos, contextMenukey,
                                   contextMenukey ?
                                     WidgetMouseEvent::eLeftButton :
                                     WidgetMouseEvent::eRightButton,
                                   MOUSE_INPUT_SOURCE());
       if (lParam != -1 && !result && mCustomNonClient) {
         WidgetMouseEvent event(true, NS_MOUSE_MOZHITTEST, this,
                                WidgetMouseEvent::eReal,
                                WidgetMouseEvent::eNormal);
         event.refPoint = LayoutDeviceIntPoint(GET_X_LPARAM(pos), GET_Y_LPARAM(pos));
         event.inputSource = MOUSE_INPUT_SOURCE();
         event.mFlags.mOnlyChromeDispatch = true;
         if (DispatchWindowEvent(&event)) {
           // Blank area hit, throw up the system menu.
           DisplaySystemMenu(mWnd, mSizeMode, mIsRTL, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
           result = true;
         }
       }
     }
     break;
     case WM_LBUTTONDBLCLK:
       result = DispatchMouseEvent(NS_MOUSE_DOUBLECLICK, wParam,
                                   lParam, false,
                                   WidgetMouseEvent::eLeftButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_MBUTTONDOWN:
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_DOWN, wParam,
                                   lParam, false,
                                   WidgetMouseEvent::eMiddleButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_MBUTTONUP:
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_UP, wParam,
                                   lParam, false,
                                   WidgetMouseEvent::eMiddleButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_MBUTTONDBLCLK:
       result = DispatchMouseEvent(NS_MOUSE_DOUBLECLICK, wParam,
                                   lParam, false,
                                   WidgetMouseEvent::eMiddleButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_NCMBUTTONDOWN:
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_DOWN, 0,
                                   lParamToClient(lParam), false,
                                   WidgetMouseEvent::eMiddleButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_NCMBUTTONUP:
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_UP, 0,
                                   lParamToClient(lParam), false,
                                   WidgetMouseEvent::eMiddleButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_NCMBUTTONDBLCLK:
       result = DispatchMouseEvent(NS_MOUSE_DOUBLECLICK, 0,
                                   lParamToClient(lParam), false,
                                   WidgetMouseEvent::eMiddleButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_RBUTTONDOWN:
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_DOWN, wParam,
                                   lParam, false,
                                   WidgetMouseEvent::eRightButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_RBUTTONUP:
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_UP, wParam,
                                   lParam, false,
                                   WidgetMouseEvent::eRightButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_RBUTTONDBLCLK:
       result = DispatchMouseEvent(NS_MOUSE_DOUBLECLICK, wParam,
                                   lParam, false,
                                   WidgetMouseEvent::eRightButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_NCRBUTTONDOWN:
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_DOWN, 0,
                                   lParamToClient(lParam), false,
                                   WidgetMouseEvent::eRightButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_NCRBUTTONUP:
       result = DispatchMouseEvent(NS_MOUSE_BUTTON_UP, 0,
                                   lParamToClient(lParam), false,
                                   WidgetMouseEvent::eRightButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_NCRBUTTONDBLCLK:
       result = DispatchMouseEvent(NS_MOUSE_DOUBLECLICK, 0,
                                   lParamToClient(lParam), false,
                                   WidgetMouseEvent::eRightButton,
                                   MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_EXITSIZEMOVE:
       if (!sIsInMouseCapture) {
         NotifySizeMoveDone();
       }
       break;
     case WM_NCLBUTTONDBLCLK:
       DispatchMouseEvent(NS_MOUSE_DOUBLECLICK, 0, lParamToClient(lParam),
                          false, WidgetMouseEvent::eLeftButton,
                          MOUSE_INPUT_SOURCE());
       result =
         DispatchMouseEvent(NS_MOUSE_BUTTON_UP, 0, lParamToClient(lParam),
                            false, WidgetMouseEvent::eLeftButton,
                            MOUSE_INPUT_SOURCE());
       DispatchPendingEvents();
       break;
     case WM_APPCOMMAND:
       result = HandleAppCommandMsg(wParam, lParam, aRetValue);
       break;
     // The WM_ACTIVATE event is fired when a window is raised or lowered,
     // and the loword of wParam specifies which. But we don't want to tell
     // the focus system about this until the WM_SETFOCUS or WM_KILLFOCUS
     // events are fired. Instead, set either the sJustGotActivate or
     // gJustGotDeactivate flags and activate/deactivate once the focus
     // events arrive.
     case WM_ACTIVATE:
       if (mWidgetListener) {
         int32_t fActive = LOWORD(wParam);
         if (WA_INACTIVE == fActive) {
           // when minimizing a window, the deactivation and focus events will
           // be fired in the reverse order. Instead, just deactivate right away.
           if (HIWORD(wParam))
             DispatchFocusToTopLevelWindow(false);
           else
             sJustGotDeactivate = true;
           if (mIsTopWidgetWindow)
             mLastKeyboardLayout = KeyboardLayout::GetInstance()->GetLayout();
         } else {
           StopFlashing();
           sJustGotActivate = true;
           WidgetMouseEvent event(true, NS_MOUSE_ACTIVATE, this,
                                  WidgetMouseEvent::eReal);
           InitEvent(event);
           ModifierKeyState modifierKeyState;
           modifierKeyState.InitInputEvent(event);
           DispatchWindowEvent(&event);
           if (sSwitchKeyboardLayout && mLastKeyboardLayout)
             ActivateKeyboardLayout(mLastKeyboardLayout, 0);
         }
       }
       break;
     case WM_MOUSEACTIVATE:
       // A popup with a parent owner should not be activated when clicked but
       // should still allow the mouse event to be fired, so the return value
       // is set to MA_NOACTIVATE. But if the owner isn't the frontmost window,
       // just use default processing so that the window is activated.
       if (IsPopup() && IsOwnerForegroundWindow()) {
         *aRetValue = MA_NOACTIVATE;
         result = true;
       }
       break;
     case WM_WINDOWPOSCHANGING:
     {
       LPWINDOWPOS info = (LPWINDOWPOS)lParam;
       OnWindowPosChanging(info);
       result = true;
     }
     break;
     case WM_GETMINMAXINFO:
     {
       MINMAXINFO* mmi = (MINMAXINFO*)lParam;
       // Set the constraints. The minimum size should also be constrained to the
       // default window maximum size so that it fits on screen.
       mmi->ptMinTrackSize.x =
         std::min((int32_t)mmi->ptMaxTrackSize.x,
                std::max((int32_t)mmi->ptMinTrackSize.x, mSizeConstraints.mMinSize.width));
       mmi->ptMinTrackSize.y =
         std::min((int32_t)mmi->ptMaxTrackSize.y,
         std::max((int32_t)mmi->ptMinTrackSize.y, mSizeConstraints.mMinSize.height));
       mmi->ptMaxTrackSize.x = std::min((int32_t)mmi->ptMaxTrackSize.x, mSizeConstraints.mMaxSize.width);
       mmi->ptMaxTrackSize.y = std::min((int32_t)mmi->ptMaxTrackSize.y, mSizeConstraints.mMaxSize.height);
     }
     break;
     case WM_SETFOCUS:
       // If previous focused window isn't ours, it must have received the
       // redirected message.  So, we should forget it.
       if (!WinUtils::IsOurProcessWindow(HWND(wParam))) {
         RedirectedKeyDownMessageManager::Forget();
       }
       if (sJustGotActivate) {
         DispatchFocusToTopLevelWindow(true);
       }
       break;
     case WM_KILLFOCUS:
       if (sJustGotDeactivate) {
         DispatchFocusToTopLevelWindow(false);
       }
       break;
     case WM_WINDOWPOSCHANGED:
     {
       WINDOWPOS* wp = (LPWINDOWPOS)lParam;
       OnWindowPosChanged(wp);
       result = true;
     }
     break;
     case WM_INPUTLANGCHANGEREQUEST:
       *aRetValue = TRUE;
       result = false;
       break;
     case WM_INPUTLANGCHANGE:
       KeyboardLayout::GetInstance()->
         OnLayoutChange(reinterpret_cast<HKL>(lParam));
       result = false; // always pass to child window
       break;
     case WM_DESTROYCLIPBOARD:
     {
       nsIClipboard* clipboard;
       nsresult rv = CallGetService(kCClipboardCID, &clipboard);
       if(NS_SUCCEEDED(rv)) {
         clipboard->EmptyClipboard(nsIClipboard::kGlobalClipboard);
         NS_RELEASE(clipboard);
       }
     }
     break;
 #ifdef ACCESSIBILITY
     case WM_GETOBJECT:
     {
       *aRetValue = 0;
       // Do explicit casting to make it working on 64bit systems (see bug 649236
       // for details).
       DWORD objId = static_cast<DWORD>(lParam);
       if (objId == OBJID_CLIENT) { // oleacc.dll will be loaded dynamically
         a11y::Accessible* rootAccessible = GetAccessible(); // Held by a11y cache
         if (rootAccessible) {
           IAccessible *msaaAccessible = nullptr;
           rootAccessible->GetNativeInterface((void**)&msaaAccessible); // does an addref
           if (msaaAccessible) {
             *aRetValue = LresultFromObject(IID_IAccessible, wParam, msaaAccessible); // does an addref
             msaaAccessible->Release(); // release extra addref
             result = true;  // We handled the WM_GETOBJECT message
           }
         }
       }
     }
 #endif
     case WM_SYSCOMMAND:
     {
       WPARAM filteredWParam = (wParam &0xFFF0);
       // prevent Windows from trimming the working set. bug 76831
       if (!sTrimOnMinimize && filteredWParam == SC_MINIMIZE) {
         ::ShowWindow(mWnd, SW_SHOWMINIMIZED);
         result = true;
       }
       // Handle the system menu manually when we're in full screen mode
       // so we can set the appropriate options.
       if (filteredWParam == SC_KEYMENU && lParam == VK_SPACE &&
           mSizeMode == nsSizeMode_Fullscreen) {
         DisplaySystemMenu(mWnd, mSizeMode, mIsRTL,
                           MOZ_SYSCONTEXT_X_POS,
                           MOZ_SYSCONTEXT_Y_POS);
         result = true;
       }
     }
     break;
   case WM_DWMCOMPOSITIONCHANGED:
     // First, update the compositor state to latest one. All other methods
     // should use same state as here for consistency painting.
     nsUXThemeData::CheckForCompositor(true);
     UpdateNonClientMargins();
     BroadcastMsg(mWnd, WM_DWMCOMPOSITIONCHANGED);
     NotifyThemeChanged();
     UpdateGlass();
     Invalidate(true, true, true);
     break;
   case WM_UPDATEUISTATE:
   {
     // If the UI state has changed, fire an event so the UI updates the
     // keyboard cues based on the system setting and how the window was
     // opened. For example, a dialog opened via a keyboard press on a button
     // should enable cues, whereas the same dialog opened via a mouse click of
     // the button should not.
     int32_t action = LOWORD(wParam);
     if (action == UIS_SET || action == UIS_CLEAR) {
       int32_t flags = HIWORD(wParam);
       UIStateChangeType showAccelerators = UIStateChangeType_NoChange;
       UIStateChangeType showFocusRings = UIStateChangeType_NoChange;
       if (flags & UISF_HIDEACCEL)
         showAccelerators = (action == UIS_SET) ? UIStateChangeType_Clear : UIStateChangeType_Set;
       if (flags & UISF_HIDEFOCUS)
         showFocusRings = (action == UIS_SET) ? UIStateChangeType_Clear : UIStateChangeType_Set;
       NotifyUIStateChanged(showAccelerators, showFocusRings);
     }
     break;
   }
   /* Gesture support events */
   case WM_TABLET_QUERYSYSTEMGESTURESTATUS:
     // According to MS samples, this must be handled to enable
     // rotational support in multi-touch drivers.
     result = true;
     *aRetValue = TABLET_ROTATE_GESTURE_ENABLE;
     break;
   case WM_TOUCH:
     result = OnTouch(wParam, lParam);
     if (result) {
       *aRetValue = 0;
     }
     break;
   case WM_GESTURE:
     result = OnGesture(wParam, lParam);
     break;
   case WM_GESTURENOTIFY:
     {
       if (mWindowType != eWindowType_invisible &&
           mWindowType != eWindowType_plugin) {
         // A GestureNotify event is dispatched to decide which single-finger panning
         // direction should be active (including none) and if pan feedback should
         // be displayed. Java and plugin windows can make their own calls.
         if (gIsPointerEventsEnabled) {
           result = false;
           break;
         }
         GESTURENOTIFYSTRUCT * gestureinfo = (GESTURENOTIFYSTRUCT*)lParam;
         nsPointWin touchPoint;
         touchPoint = gestureinfo->ptsLocation;
         touchPoint.ScreenToClient(mWnd);
         WidgetGestureNotifyEvent gestureNotifyEvent(true,
                                    NS_GESTURENOTIFY_EVENT_START, this);
         gestureNotifyEvent.refPoint = LayoutDeviceIntPoint::FromUntyped(touchPoint);
         nsEventStatus status;
         DispatchEvent(&gestureNotifyEvent, status);
         mDisplayPanFeedback = gestureNotifyEvent.displayPanFeedback;
         if (!mTouchWindow)
           mGesture.SetWinGestureSupport(mWnd, gestureNotifyEvent.panDirection);
       }
       result = false; //should always bubble to DefWindowProc
     }
     break;
     case WM_CLEAR:
     {
       WidgetContentCommandEvent command(true, NS_CONTENT_COMMAND_DELETE, this);
       DispatchWindowEvent(&command);
       result = true;
     }
     break;
     case WM_CUT:
     {
       WidgetContentCommandEvent command(true, NS_CONTENT_COMMAND_CUT, this);
       DispatchWindowEvent(&command);
       result = true;
     }
     break;
     case WM_COPY:
     {
       WidgetContentCommandEvent command(true, NS_CONTENT_COMMAND_COPY, this);
       DispatchWindowEvent(&command);
       result = true;
     }
     break;
     case WM_PASTE:
     {
       WidgetContentCommandEvent command(true, NS_CONTENT_COMMAND_PASTE, this);
       DispatchWindowEvent(&command);
       result = true;
     }
     break;
     case EM_UNDO:
     {
       WidgetContentCommandEvent command(true, NS_CONTENT_COMMAND_UNDO, this);
       DispatchWindowEvent(&command);
       *aRetValue = (LRESULT)(command.mSucceeded && command.mIsEnabled);
       result = true;
     }
     break;
     case EM_REDO:
     {
       WidgetContentCommandEvent command(true, NS_CONTENT_COMMAND_REDO, this);
       DispatchWindowEvent(&command);
       *aRetValue = (LRESULT)(command.mSucceeded && command.mIsEnabled);
       result = true;
     }
     break;
     case EM_CANPASTE:
     {
       // Support EM_CANPASTE message only when wParam isn't specified or
       // is plain text format.
       if (wParam == 0 || wParam == CF_TEXT || wParam == CF_UNICODETEXT) {
         WidgetContentCommandEvent command(true, NS_CONTENT_COMMAND_PASTE,
                                           this, true);
         DispatchWindowEvent(&command);
         *aRetValue = (LRESULT)(command.mSucceeded && command.mIsEnabled);
         result = true;
       }
     }
     break;
     case EM_CANUNDO:
     {
       WidgetContentCommandEvent command(true, NS_CONTENT_COMMAND_UNDO,
                                         this, true);
       DispatchWindowEvent(&command);
       *aRetValue = (LRESULT)(command.mSucceeded && command.mIsEnabled);
       result = true;
     }
     break;
     case EM_CANREDO:
     {
       WidgetContentCommandEvent command(true, NS_CONTENT_COMMAND_REDO,
                                         this, true);
       DispatchWindowEvent(&command);
       *aRetValue = (LRESULT)(command.mSucceeded && command.mIsEnabled);
       result = true;
     }
     break;
     default:
     {
       if (msg == nsAppShell::GetTaskbarButtonCreatedMessage())
         SetHasTaskbarIconBeenCreated();
       if (msg == sOOPPPluginFocusEvent) {
         if (wParam == 1) {
           // With OOPP, the plugin window exists in another process and is a child of
           // this window. This window is a placeholder plugin window for the dom. We
           // receive this event when the child window receives focus. (sent from
           // PluginInstanceParent.cpp)
           ::SendMessage(mWnd, WM_MOUSEACTIVATE, 0, 0); // See nsPluginNativeWindowWin.cpp
         } else {
           // WM_KILLFOCUS was received by the child process.
           if (sJustGotDeactivate) {
             DispatchFocusToTopLevelWindow(false);
           }
         }
       }
     }
     break;
     case WM_SETTINGCHANGE:
       if (IsWin8OrLater() && lParam &&
           !wcsicmp(L"ConvertibleSlateMode", (wchar_t*)lParam)) {
         // If we're switching into slate mode, switch to Metro for hardware
         // that supports this feature if the pref is set.
         if (GetSystemMetrics(SM_CONVERTIBLESLATEMODE) == 0 &&
             Preferences::GetBool("browser.shell.desktop-auto-switch-enabled",
                                  false)) {
           nsCOMPtr<nsIAppStartup> appStartup(do_GetService(NS_APPSTARTUP_CONTRACTID));
           if (appStartup) {
             appStartup->Quit(nsIAppStartup::eForceQuit |
                              nsIAppStartup::eRestartTouchEnvironment);
           }
         }
       }
     break;
   }
   //*aRetValue = result;
   if (mWnd) {
     return result;
   }
   else {
     //Events which caused mWnd destruction and aren't consumed
     //will crash during the Windows default processing.
     return true;
   }
 }
 /**************************************************************
  *
  * SECTION: Broadcast messaging
  *
  * Broadcast messages to all windows.
  *
  **************************************************************/
 // Enumerate all child windows sending aMsg to each of them
 BOOL CALLBACK nsWindow::BroadcastMsgToChildren(HWND aWnd, LPARAM aMsg)
 {
   WNDPROC winProc = (WNDPROC)::GetWindowLongPtrW(aWnd, GWLP_WNDPROC);
   if (winProc == &nsWindow::WindowProc) {
     // it's one of our windows so go ahead and send a message to it
     ::CallWindowProcW(winProc, aWnd, aMsg, 0, 0);
   }
   return TRUE;
 }
 // Enumerate all top level windows specifying that the children of each
 // top level window should be enumerated. Do *not* send the message to
 // each top level window since it is assumed that the toolkit will send
 // aMsg to them directly.
 BOOL CALLBACK nsWindow::BroadcastMsg(HWND aTopWindow, LPARAM aMsg)
 {
   // Iterate each of aTopWindows child windows sending the aMsg
   // to each of them.
   ::EnumChildWindows(aTopWindow, nsWindow::BroadcastMsgToChildren, aMsg);
   return TRUE;
 }
 /**************************************************************
  *
  * SECTION: Event processing helpers
  *
  * Special processing for certain event types and
  * synthesized events.
  *
  **************************************************************/
 int32_t
 nsWindow::ClientMarginHitTestPoint(int32_t mx, int32_t my)
 {
   if (mSizeMode == nsSizeMode_Minimized ||
       mSizeMode == nsSizeMode_Fullscreen) {
     return HTCLIENT;
   }
   // Calculations are done in screen coords
   RECT winRect;
   GetWindowRect(mWnd, &winRect);
   // hit return constants:
   // HTBORDER                     - non-resizable border
   // HTBOTTOM, HTLEFT, HTRIGHT, HTTOP - resizable border
   // HTBOTTOMLEFT, HTBOTTOMRIGHT  - resizable corner
   // HTTOPLEFT, HTTOPRIGHT        - resizable corner
   // HTCAPTION                    - general title bar area
   // HTCLIENT                     - area considered the client
   // HTCLOSE                      - hovering over the close button
   // HTMAXBUTTON                  - maximize button
   // HTMINBUTTON                  - minimize button
   int32_t testResult = HTCLIENT;
   bool isResizable = (mBorderStyle & (eBorderStyle_all |
                                       eBorderStyle_resizeh |
                                       eBorderStyle_default)) > 0 ? true : false;
   if (mSizeMode == nsSizeMode_Maximized)
     isResizable = false;
   // Ensure being accessible to borders of window.  Even if contents are in
   // this area, the area must behave as border.
   nsIntMargin nonClientSize(std::max(mCaptionHeight - mNonClientOffset.top,
                                      kResizableBorderMinSize),
                             std::max(mHorResizeMargin - mNonClientOffset.right,
                                      kResizableBorderMinSize),
                             std::max(mVertResizeMargin - mNonClientOffset.bottom,
                                      kResizableBorderMinSize),
                             std::max(mHorResizeMargin - mNonClientOffset.left,
                                      kResizableBorderMinSize));
   bool allowContentOverride = mSizeMode == nsSizeMode_Maximized ||
                               (mx >= winRect.left + nonClientSize.left &&
                                mx <= winRect.right - nonClientSize.right &&
                                my >= winRect.top + nonClientSize.top &&
                                my <= winRect.bottom - nonClientSize.bottom);
   // The border size.  If there is no content under mouse cursor, the border
   // size should be larger than the values in system settings.  Otherwise,
   // contents under the mouse cursor should be able to override the behavior.
   // E.g., user must expect that Firefox button always opens the popup menu
   // even when the user clicks on the above edge of it.
   nsIntMargin borderSize(std::max(nonClientSize.top,    mVertResizeMargin),
                          std::max(nonClientSize.right,  mHorResizeMargin),
                          std::max(nonClientSize.bottom, mVertResizeMargin),
                          std::max(nonClientSize.left,   mHorResizeMargin));
   bool top    = false;
   bool bottom = false;
   bool left   = false;
   bool right  = false;
   if (my >= winRect.top && my < winRect.top + borderSize.top) {
     top = true;
   } else if (my <= winRect.bottom && my > winRect.bottom - borderSize.bottom) {
     bottom = true;
   }
   // (the 2x case here doubles the resize area for corners)
   int multiplier = (top || bottom) ? 2 : 1;
   if (mx >= winRect.left &&
       mx < winRect.left + (multiplier * borderSize.left)) {
     left = true;
   } else if (mx <= winRect.right &&
              mx > winRect.right - (multiplier * borderSize.right)) {
     right = true;
   }
   if (isResizable) {
     if (top) {
       testResult = HTTOP;
       if (left)
         testResult = HTTOPLEFT;
       else if (right)
         testResult = HTTOPRIGHT;
     } else if (bottom) {
       testResult = HTBOTTOM;
       if (left)
         testResult = HTBOTTOMLEFT;
       else if (right)
         testResult = HTBOTTOMRIGHT;
     } else {
       if (left)
         testResult = HTLEFT;
       if (right)
         testResult = HTRIGHT;
     }
   } else {
     if (top)
       testResult = HTCAPTION;
     else if (bottom || left || right)
       testResult = HTBORDER;
   }
   if (!sIsInMouseCapture && allowContentOverride) {
     POINT pt = { mx, my };
     ::ScreenToClient(mWnd, &pt);
     if (pt.x == mCachedHitTestPoint.x && pt.y == mCachedHitTestPoint.y &&
         TimeStamp::Now() - mCachedHitTestTime < TimeDuration::FromMilliseconds(HITTEST_CACHE_LIFETIME_MS)) {
       testResult = mCachedHitTestResult;
     } else {
       WidgetMouseEvent event(true, NS_MOUSE_MOZHITTEST, this,
                              WidgetMouseEvent::eReal,
                              WidgetMouseEvent::eNormal);
       event.refPoint = LayoutDeviceIntPoint(pt.x, pt.y);
       event.inputSource = MOUSE_INPUT_SOURCE();
       event.mFlags.mOnlyChromeDispatch = true;
       bool result = DispatchWindowEvent(&event);
       if (result) {
         // The mouse is over a blank area
         testResult = testResult == HTCLIENT ? HTCAPTION : testResult;
       } else {
         // There's content over the mouse pointer. Set HTCLIENT
         // to possibly override a resizer border.
         testResult = HTCLIENT;
       }
       mCachedHitTestPoint = pt;
       mCachedHitTestTime = TimeStamp::Now();
       mCachedHitTestResult = testResult;
     }
   }
   return testResult;
 }
 void nsWindow::PostSleepWakeNotification(const bool aIsSleepMode)
 {
   if (aIsSleepMode == gIsSleepMode)
     return;
   gIsSleepMode = aIsSleepMode;
   nsCOMPtr<nsIObserverService> observerService =
     mozilla::services::GetObserverService();
   if (observerService)
     observerService->NotifyObservers(nullptr,
       aIsSleepMode ? NS_WIDGET_SLEEP_OBSERVER_TOPIC :
                      NS_WIDGET_WAKE_OBSERVER_TOPIC, nullptr);
 }
 LRESULT nsWindow::ProcessCharMessage(const MSG &aMsg, bool *aEventDispatched)
 {
   if (IMEHandler::IsComposingOn(this)) {
     IMEHandler::NotifyIME(this, REQUEST_TO_COMMIT_COMPOSITION);
   }
   // These must be checked here too as a lone WM_CHAR could be received
   // if a child window didn't handle it (for example Alt+Space in a content
   // window)
   ModifierKeyState modKeyState;
   NativeKey nativeKey(this, aMsg, modKeyState);
   return static_cast<LRESULT>(nativeKey.HandleCharMessage(aMsg,
                                                           aEventDispatched));
 }
 LRESULT nsWindow::ProcessKeyUpMessage(const MSG &aMsg, bool *aEventDispatched)
 {
   if (IMEHandler::IsComposingOn(this)) {
     return 0;
   }
   ModifierKeyState modKeyState;
   NativeKey nativeKey(this, aMsg, modKeyState);
   return static_cast<LRESULT>(nativeKey.HandleKeyUpMessage(aEventDispatched));
 }
 LRESULT nsWindow::ProcessKeyDownMessage(const MSG &aMsg,
                                         bool *aEventDispatched)
 {
   // If this method doesn't call NativeKey::HandleKeyDownMessage(), this method
   // must clean up the redirected message information itself.  For more
   // information, see above comment of
   // RedirectedKeyDownMessageManager::AutoFlusher class definition in
   // KeyboardLayout.h.
   RedirectedKeyDownMessageManager::AutoFlusher redirectedMsgFlusher(this, aMsg);
   ModifierKeyState modKeyState;
   LRESULT result = 0;
   if (!IMEHandler::IsComposingOn(this)) {
     NativeKey nativeKey(this, aMsg, modKeyState);
     result =
       static_cast<LRESULT>(nativeKey.HandleKeyDownMessage(aEventDispatched));
     // HandleKeyDownMessage cleaned up the redirected message information
     // itself, so, we should do nothing.
     redirectedMsgFlusher.Cancel();
   }
   if (aMsg.wParam == VK_MENU ||
       (aMsg.wParam == VK_F10 && !modKeyState.IsShift())) {
     // We need to let Windows handle this keypress,
     // by returning false, if there's a native menu
     // bar somewhere in our containing window hierarchy.
     // Otherwise we handle the keypress and don't pass
     // it on to Windows, by returning true.
     bool hasNativeMenu = false;
     HWND hWnd = mWnd;
     while (hWnd) {
       if (::GetMenu(hWnd)) {
         hasNativeMenu = true;
         break;
       }
       hWnd = ::GetParent(hWnd);
     }
     result = !hasNativeMenu;
   }
   return result;
 }
 nsresult
 nsWindow::SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
                                    int32_t aNativeKeyCode,
                                    uint32_t aModifierFlags,
                                    const nsAString& aCharacters,
                                    const nsAString& aUnmodifiedCharacters)
 {
   KeyboardLayout* keyboardLayout = KeyboardLayout::GetInstance();
   return keyboardLayout->SynthesizeNativeKeyEvent(
            this, aNativeKeyboardLayout, aNativeKeyCode, aModifierFlags,
            aCharacters, aUnmodifiedCharacters);
 }
 nsresult
 nsWindow::SynthesizeNativeMouseEvent(nsIntPoint aPoint,
                                      uint32_t aNativeMessage,
                                      uint32_t aModifierFlags)
 {
   ::SetCursorPos(aPoint.x, aPoint.y);
   INPUT input;
   memset(&input, 0, sizeof(input));
   input.type = INPUT_MOUSE;
   input.mi.dwFlags = aNativeMessage;
   ::SendInput(1, &input, sizeof(INPUT));
   return NS_OK;
 }
 nsresult
 nsWindow::SynthesizeNativeMouseScrollEvent(nsIntPoint aPoint,
                                            uint32_t aNativeMessage,
                                            double aDeltaX,
                                            double aDeltaY,
                                            double aDeltaZ,
                                            uint32_t aModifierFlags,
                                            uint32_t aAdditionalFlags)
 {
   return MouseScrollHandler::SynthesizeNativeMouseScrollEvent(
            this, aPoint, aNativeMessage,
            (aNativeMessage == WM_MOUSEWHEEL || aNativeMessage == WM_VSCROLL) ?
              static_cast<int32_t>(aDeltaY) : static_cast<int32_t>(aDeltaX),
            aModifierFlags, aAdditionalFlags);
 }
 /**************************************************************
  *
  * SECTION: OnXXX message handlers
  *
  * For message handlers that need to be broken out or
  * implemented in specific platform code.
  *
  **************************************************************/
 void nsWindow::OnWindowPosChanged(WINDOWPOS* wp)
 {
   if (wp == nullptr)
     return;
 #ifdef WINSTATE_DEBUG_OUTPUT
   if (mWnd == WinUtils::GetTopLevelHWND(mWnd)) {
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("*** OnWindowPosChanged: [  top] "));
   } else {
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("*** OnWindowPosChanged: [child] "));
   }
   PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("WINDOWPOS flags:"));
   if (wp->flags & SWP_FRAMECHANGED) {
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("SWP_FRAMECHANGED "));
   }
   if (wp->flags & SWP_SHOWWINDOW) {
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("SWP_SHOWWINDOW "));
   }
   if (wp->flags & SWP_NOSIZE) {
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("SWP_NOSIZE "));
   }
   if (wp->flags & SWP_HIDEWINDOW) {
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("SWP_HIDEWINDOW "));
   }
   if (wp->flags & SWP_NOZORDER) {
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("SWP_NOZORDER "));
   }
   if (wp->flags & SWP_NOACTIVATE) {
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("SWP_NOACTIVATE "));
   }
   PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("\n"));
 #endif
   // Handle window size mode changes
   if (wp->flags & SWP_FRAMECHANGED && mSizeMode != nsSizeMode_Fullscreen) {
     // Bug 566135 - Windows theme code calls show window on SW_SHOWMINIMIZED
     // windows when fullscreen games disable desktop composition. If we're
     // minimized and not being activated, ignore the event and let windows
     // handle it.
     if (mSizeMode == nsSizeMode_Minimized && (wp->flags & SWP_NOACTIVATE))
       return;
     WINDOWPLACEMENT pl;
     pl.length = sizeof(pl);
     ::GetWindowPlacement(mWnd, &pl);
     // Windows has just changed the size mode of this window. The call to
     // SizeModeChanged will trigger a call into SetSizeMode where we will
     // set the min/max window state again or for nsSizeMode_Normal, call
     // SetWindow with a parameter of SW_RESTORE. There's no need however as
     // this window's mode has already changed. Updating mSizeMode here
     // insures the SetSizeMode call is a no-op. Addresses a bug on Win7 related
     // to window docking. (bug 489258)
     if (pl.showCmd == SW_SHOWMAXIMIZED)
       mSizeMode = (mFullscreenMode ? nsSizeMode_Fullscreen : nsSizeMode_Maximized);
     else if (pl.showCmd == SW_SHOWMINIMIZED)
       mSizeMode = nsSizeMode_Minimized;
     else if (mFullscreenMode)
       mSizeMode = nsSizeMode_Fullscreen;
     else
       mSizeMode = nsSizeMode_Normal;
     // If !sTrimOnMinimize, we minimize windows using SW_SHOWMINIMIZED (See
     // SetSizeMode for internal calls, and WM_SYSCOMMAND for external). This
     // prevents the working set from being trimmed but keeps the window active.
     // After the window is minimized, we need to do some touch up work on the
     // active window. (bugs 76831 & 499816)
     if (!sTrimOnMinimize && nsSizeMode_Minimized == mSizeMode)
       ActivateOtherWindowHelper(mWnd);
 #ifdef WINSTATE_DEBUG_OUTPUT
     switch (mSizeMode) {
       case nsSizeMode_Normal:
           PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
                  ("*** mSizeMode: nsSizeMode_Normal\n"));
         break;
       case nsSizeMode_Minimized:
         PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
                ("*** mSizeMode: nsSizeMode_Minimized\n"));
         break;
       case nsSizeMode_Maximized:
           PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
                  ("*** mSizeMode: nsSizeMode_Maximized\n"));
         break;
       default:
           PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("*** mSizeMode: ??????\n"));
         break;
     };
 #endif
     if (mWidgetListener)
       mWidgetListener->SizeModeChanged(mSizeMode);
     // If window was restored, window activation was bypassed during the
     // SetSizeMode call originating from OnWindowPosChanging to avoid saving
     // pre-restore attributes. Force activation now to get correct attributes.
     if (mLastSizeMode != nsSizeMode_Normal && mSizeMode == nsSizeMode_Normal)
       DispatchFocusToTopLevelWindow(true);
     // Skip window size change events below on minimization.
     if (mSizeMode == nsSizeMode_Minimized)
       return;
   }
   // Handle window position changes
   if (!(wp->flags & SWP_NOMOVE)) {
     mBounds.x = wp->x;
     mBounds.y = wp->y;
     NotifyWindowMoved(wp->x, wp->y);
   }
   // Handle window size changes
   if (!(wp->flags & SWP_NOSIZE)) {
     RECT r;
     int32_t newWidth, newHeight;
     ::GetWindowRect(mWnd, &r);
     newWidth  = r.right - r.left;
     newHeight = r.bottom - r.top;
     nsIntRect rect(wp->x, wp->y, newWidth, newHeight);
 #ifdef MOZ_XUL
     if (eTransparencyTransparent == mTransparencyMode)
       ResizeTranslucentWindow(newWidth, newHeight);
 #endif
     if (newWidth > mLastSize.width)
     {
       RECT drect;
       // getting wider
       drect.left   = wp->x + mLastSize.width;
       drect.top    = wp->y;
       drect.right  = drect.left + (newWidth - mLastSize.width);
       drect.bottom = drect.top + newHeight;
       ::RedrawWindow(mWnd, &drect, nullptr,
                      RDW_INVALIDATE |
                      RDW_NOERASE |
                      RDW_NOINTERNALPAINT |
                      RDW_ERASENOW |
                      RDW_ALLCHILDREN);
     }
     if (newHeight > mLastSize.height)
     {
       RECT drect;
       // getting taller
       drect.left   = wp->x;
       drect.top    = wp->y + mLastSize.height;
       drect.right  = drect.left + newWidth;
       drect.bottom = drect.top + (newHeight - mLastSize.height);
       ::RedrawWindow(mWnd, &drect, nullptr,
                      RDW_INVALIDATE |
                      RDW_NOERASE |
                      RDW_NOINTERNALPAINT |
                      RDW_ERASENOW |
                      RDW_ALLCHILDREN);
     }
     mBounds.width    = newWidth;
     mBounds.height   = newHeight;
     mLastSize.width  = newWidth;
     mLastSize.height = newHeight;
 #ifdef WINSTATE_DEBUG_OUTPUT
     PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
            ("*** Resize window: %d x %d x %d x %d\n", wp->x, wp->y,
             newWidth, newHeight));
 #endif
     // If a maximized window is resized, recalculate the non-client margins.
     if (mSizeMode == nsSizeMode_Maximized) {
       if (UpdateNonClientMargins(nsSizeMode_Maximized, true)) {
         // gecko resize event already sent by UpdateNonClientMargins.
         return;
       }
     }
     // Recalculate the width and height based on the client area for gecko events.
     if (::GetClientRect(mWnd, &r)) {
       rect.width  = r.right - r.left;
       rect.height = r.bottom - r.top;
     }
     // Send a gecko resize event
     OnResize(rect);
   }
 }
 // static
 void nsWindow::ActivateOtherWindowHelper(HWND aWnd)
 {
   // Find the next window that is enabled, visible, and not minimized.
   HWND hwndBelow = ::GetNextWindow(aWnd, GW_HWNDNEXT);
   while (hwndBelow && (!::IsWindowEnabled(hwndBelow) || !::IsWindowVisible(hwndBelow) ||
                        ::IsIconic(hwndBelow))) {
     hwndBelow = ::GetNextWindow(hwndBelow, GW_HWNDNEXT);
   }
   // Push ourselves to the bottom of the stack, then activate the
   // next window.
   ::SetWindowPos(aWnd, HWND_BOTTOM, 0, 0, 0, 0,
                  SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
   if (hwndBelow)
     ::SetForegroundWindow(hwndBelow);
   // Play the minimize sound while we're here, since that is also
   // forgotten when we use SW_SHOWMINIMIZED.
   nsCOMPtr<nsISound> sound(do_CreateInstance("@mozilla.org/sound;1"));
   if (sound) {
     sound->PlaySystemSound(NS_LITERAL_STRING("Minimize"));
   }
 }
 void nsWindow::OnWindowPosChanging(LPWINDOWPOS& info)
 {
   // Update non-client margins if the frame size is changing, and let the
   // browser know we are changing size modes, so alternative css can kick in.
   // If we're going into fullscreen mode, ignore this, since it'll reset
   // margins to normal mode.
   if ((info->flags & SWP_FRAMECHANGED && !(info->flags & SWP_NOSIZE)) &&
       mSizeMode != nsSizeMode_Fullscreen) {
     WINDOWPLACEMENT pl;
     pl.length = sizeof(pl);
     ::GetWindowPlacement(mWnd, &pl);
     nsSizeMode sizeMode;
     if (pl.showCmd == SW_SHOWMAXIMIZED)
       sizeMode = (mFullscreenMode ? nsSizeMode_Fullscreen : nsSizeMode_Maximized);
     else if (pl.showCmd == SW_SHOWMINIMIZED)
       sizeMode = nsSizeMode_Minimized;
     else if (mFullscreenMode)
       sizeMode = nsSizeMode_Fullscreen;
     else
       sizeMode = nsSizeMode_Normal;
     if (mWidgetListener)
       mWidgetListener->SizeModeChanged(sizeMode);
     UpdateNonClientMargins(sizeMode, false);
   }
   // enforce local z-order rules
   if (!(info->flags & SWP_NOZORDER)) {
     HWND hwndAfter = info->hwndInsertAfter;
     nsWindow *aboveWindow = 0;
     nsWindowZ placement;
     if (hwndAfter == HWND_BOTTOM)
       placement = nsWindowZBottom;
     else if (hwndAfter == HWND_TOP || hwndAfter == HWND_TOPMOST || hwndAfter == HWND_NOTOPMOST)
       placement = nsWindowZTop;
     else {
       placement = nsWindowZRelative;
       aboveWindow = WinUtils::GetNSWindowPtr(hwndAfter);
     }
     if (mWidgetListener) {
       nsCOMPtr<nsIWidget> actualBelow = nullptr;
       if (mWidgetListener->ZLevelChanged(false, &placement,
                                          aboveWindow, getter_AddRefs(actualBelow))) {
         if (placement == nsWindowZBottom)
           info->hwndInsertAfter = HWND_BOTTOM;
         else if (placement == nsWindowZTop)
           info->hwndInsertAfter = HWND_TOP;
         else {
           info->hwndInsertAfter = (HWND)actualBelow->GetNativeData(NS_NATIVE_WINDOW);
         }
       }
     }
   }
   // prevent rude external programs from making hidden window visible
   if (mWindowType == eWindowType_invisible)
     info->flags &= ~SWP_SHOWWINDOW;
 }
 void nsWindow::UserActivity()
 {
   // Check if we have the idle service, if not we try to get it.
   if (!mIdleService) {
     mIdleService = do_GetService("@mozilla.org/widget/idleservice;1");
   }
   // Check that we now have the idle service.
   if (mIdleService) {
     mIdleService->ResetIdleTimeOut(0);
   }
 }
 bool nsWindow::OnTouch(WPARAM wParam, LPARAM lParam)
 {
   uint32_t cInputs = LOWORD(wParam);
   PTOUCHINPUT pInputs = new TOUCHINPUT[cInputs];
   if (mGesture.GetTouchInputInfo((HTOUCHINPUT)lParam, cInputs, pInputs)) {
     WidgetTouchEvent* touchEventToSend = nullptr;
     WidgetTouchEvent* touchEndEventToSend = nullptr;
     nsEventStatus status;
     // Walk across the touch point array processing each contact point
     for (uint32_t i = 0; i < cInputs; i++) {
       uint32_t msg;
       if (pInputs[i].dwFlags & (TOUCHEVENTF_DOWN | TOUCHEVENTF_MOVE)) {
         // Create a standard touch event to send
         if (!touchEventToSend) {
           touchEventToSend = new WidgetTouchEvent(true, NS_TOUCH_MOVE, this);
           touchEventToSend->time = ::GetMessageTime();
           ModifierKeyState modifierKeyState;
           modifierKeyState.InitInputEvent(*touchEventToSend);
         }
         // Pres shell expects this event to be a NS_TOUCH_START if new contact
         // points have been added since the last event sent.
         if (pInputs[i].dwFlags & TOUCHEVENTF_DOWN) {
           touchEventToSend->message = msg = NS_TOUCH_START;
         } else {
           msg = NS_TOUCH_MOVE;
         }
       } else if (pInputs[i].dwFlags & TOUCHEVENTF_UP) {
         // Pres shell expects removed contacts points to be delivered in a
         // separate NS_TOUCH_END event containing only the contact points
         // that were removed.
         if (!touchEndEventToSend) {
           touchEndEventToSend = new WidgetTouchEvent(true, NS_TOUCH_END, this);
           touchEndEventToSend->time = ::GetMessageTime();
           ModifierKeyState modifierKeyState;
           modifierKeyState.InitInputEvent(*touchEndEventToSend);
         }
         msg = NS_TOUCH_END;
       } else {
         // Filter out spurious Windows events we don't understand, like palm
         // contact.
         continue;
       }
       // Setup the touch point we'll append to the touch event array
       nsPointWin touchPoint;
       touchPoint.x = TOUCH_COORD_TO_PIXEL(pInputs[i].x);
       touchPoint.y = TOUCH_COORD_TO_PIXEL(pInputs[i].y);
       touchPoint.ScreenToClient(mWnd);
       nsRefPtr<Touch> touch =
         new Touch(pInputs[i].dwID,
                   touchPoint,
                   /* radius, if known */
                   pInputs[i].dwFlags & TOUCHINPUTMASKF_CONTACTAREA ?
                     nsIntPoint(
                       TOUCH_COORD_TO_PIXEL(pInputs[i].cxContact) / 2,
                       TOUCH_COORD_TO_PIXEL(pInputs[i].cyContact) / 2) :
                     nsIntPoint(1,1),
                   /* rotation angle and force */
 .0f, 0.0f);
       // Append to the appropriate event
       if (msg == NS_TOUCH_START || msg == NS_TOUCH_MOVE) {
         touchEventToSend->touches.AppendElement(touch);
       } else {
         touchEndEventToSend->touches.AppendElement(touch);
       }
     }
     // Dispatch touch start and move event if we have one.
     if (touchEventToSend) {
       DispatchEvent(touchEventToSend, status);
       delete touchEventToSend;
     }
     // Dispatch touch end event if we have one.
     if (touchEndEventToSend) {
       DispatchEvent(touchEndEventToSend, status);
       delete touchEndEventToSend;
     }
   }
   delete [] pInputs;
   mGesture.CloseTouchInputHandle((HTOUCHINPUT)lParam);
   return true;
 }
 static int32_t RoundDown(double aDouble)
 {
   return aDouble > 0 ? static_cast<int32_t>(floor(aDouble)) :
                        static_cast<int32_t>(ceil(aDouble));
 }
 // Gesture event processing. Handles WM_GESTURE events.
 bool nsWindow::OnGesture(WPARAM wParam, LPARAM lParam)
 {
   if (gIsPointerEventsEnabled) {
     return false;
   }
   // Treatment for pan events which translate into scroll events:
   if (mGesture.IsPanEvent(lParam)) {
     if ( !mGesture.ProcessPanMessage(mWnd, wParam, lParam) )
       return false; // ignore
     nsEventStatus status;
     WidgetWheelEvent wheelEvent(true, NS_WHEEL_WHEEL, this);
     ModifierKeyState modifierKeyState;
     modifierKeyState.InitInputEvent(wheelEvent);
     wheelEvent.button      = 0;
     wheelEvent.time        = ::GetMessageTime();
     wheelEvent.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
     bool endFeedback = true;
     if (mGesture.PanDeltaToPixelScroll(wheelEvent)) {
       DispatchEvent(&wheelEvent, status);
     }
     if (mDisplayPanFeedback) {
       mGesture.UpdatePanFeedbackX(mWnd,
                                   DeprecatedAbs(RoundDown(wheelEvent.overflowDeltaX)),
                                   endFeedback);
       mGesture.UpdatePanFeedbackY(mWnd,
                                   DeprecatedAbs(RoundDown(wheelEvent.overflowDeltaY)),
                                   endFeedback);
       mGesture.PanFeedbackFinalize(mWnd, endFeedback);
     }
     mGesture.CloseGestureInfoHandle((HGESTUREINFO)lParam);
     return true;
   }
   // Other gestures translate into simple gesture events:
   WidgetSimpleGestureEvent event(true, 0, this);
   if ( !mGesture.ProcessGestureMessage(mWnd, wParam, lParam, event) ) {
     return false; // fall through to DefWndProc
   }
   // Polish up and send off the new event
   ModifierKeyState modifierKeyState;
   modifierKeyState.InitInputEvent(event);
   event.button    = 0;
   event.time      = ::GetMessageTime();
   event.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
   nsEventStatus status;
   DispatchEvent(&event, status);
   if (status == nsEventStatus_eIgnore) {
     return false; // Ignored, fall through
   }
   // Only close this if we process and return true.
   mGesture.CloseGestureInfoHandle((HGESTUREINFO)lParam);
   return true; // Handled
 }
 static BOOL WINAPI EnumFirstChild(HWND hwnd, LPARAM lParam)
 {
   *((HWND*)lParam) = hwnd;
   return FALSE;
 }
 static void InvalidatePluginAsWorkaround(nsWindow *aWindow, const nsIntRect &aRect)
 {
   aWindow->Invalidate(aRect);
   // XXX - Even more evil workaround!! See bug 762948, flash's bottom
   // level sandboxed window doesn't seem to get our invalidate. We send
   // an invalidate to it manually. This is totally specialized for this
   // bug, for other child window structures this will just be a more or
   // less bogus invalidate but since that should not have any bad
   // side-effects this will have to do for now.
   HWND current = (HWND)aWindow->GetNativeData(NS_NATIVE_WINDOW);
   RECT windowRect;
   RECT parentRect;
   ::GetWindowRect(current, &parentRect);
   HWND next = current;
   do {
     current = next;
     ::EnumChildWindows(current, &EnumFirstChild, (LPARAM)&next);
     ::GetWindowRect(next, &windowRect);
     // This is relative to the screen, adjust it to be relative to the
     // window we're reconfiguring.
     windowRect.left -= parentRect.left;
     windowRect.top -= parentRect.top;
   } while (next != current && windowRect.top == 0 && windowRect.left == 0);
   if (windowRect.top == 0 && windowRect.left == 0) {
     RECT rect;
     rect.left   = aRect.x;
     rect.top    = aRect.y;
     rect.right  = aRect.XMost();
     rect.bottom = aRect.YMost();
     ::InvalidateRect(next, &rect, FALSE);
   }
 }
 nsresult
 nsWindow::ConfigureChildren(const nsTArray<Configuration>& aConfigurations)
 {
   // XXXroc we could use BeginDeferWindowPos/DeferWindowPos/EndDeferWindowPos
   // here, if that helps in some situations. So far I haven't seen a
   // need.
   for (uint32_t i = 0; i < aConfigurations.Length(); ++i) {
     const Configuration& configuration = aConfigurations[i];
     nsWindow* w = static_cast<nsWindow*>(configuration.mChild);
     NS_ASSERTION(w->GetParent() == this,
                  "Configured widget is not a child");
     nsresult rv = w->SetWindowClipRegion(configuration.mClipRegion, true);
     NS_ENSURE_SUCCESS(rv, rv);
     nsIntRect bounds;
     w->GetBounds(bounds);
     if (bounds.Size() != configuration.mBounds.Size()) {
       w->Resize(configuration.mBounds.x, configuration.mBounds.y,
                 configuration.mBounds.width, configuration.mBounds.height,
                 true);
     } else if (bounds.TopLeft() != configuration.mBounds.TopLeft()) {
       w->Move(configuration.mBounds.x, configuration.mBounds.y);
       if (gfxWindowsPlatform::GetPlatform()->GetRenderMode() ==
           gfxWindowsPlatform::RENDER_DIRECT2D ||
           GetLayerManager()->GetBackendType() != LayersBackend::LAYERS_BASIC) {
         // XXX - Workaround for Bug 587508. This will invalidate the part of the
         // plugin window that might be touched by moving content somehow. The
         // underlying problem should be found and fixed!
         nsIntRegion r;
         r.Sub(bounds, configuration.mBounds);
         r.MoveBy(-bounds.x,
                  -bounds.y);
         nsIntRect toInvalidate = r.GetBounds();
         InvalidatePluginAsWorkaround(w, toInvalidate);
       }
     }
     rv = w->SetWindowClipRegion(configuration.mClipRegion, false);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   return NS_OK;
 }
 static HRGN
 CreateHRGNFromArray(const nsTArray<nsIntRect>& aRects)
 {
   int32_t size = sizeof(RGNDATAHEADER) + sizeof(RECT)*aRects.Length();
   nsAutoTArray<uint8_t,100> buf;
   buf.SetLength(size);
   RGNDATA* data = reinterpret_cast<RGNDATA*>(buf.Elements());
   RECT* rects = reinterpret_cast<RECT*>(data->Buffer);
   data->rdh.dwSize = sizeof(data->rdh);
   data->rdh.iType = RDH_RECTANGLES;
   data->rdh.nCount = aRects.Length();
   nsIntRect bounds;
   for (uint32_t i = 0; i < aRects.Length(); ++i) {
     const nsIntRect& r = aRects[i];
     bounds.UnionRect(bounds, r);
     ::SetRect(&rects[i], r.x, r.y, r.XMost(), r.YMost());
   }
   ::SetRect(&data->rdh.rcBound, bounds.x, bounds.y, bounds.XMost(), bounds.YMost());
   return ::ExtCreateRegion(nullptr, buf.Length(), data);
 }
 static void
 ArrayFromRegion(const nsIntRegion& aRegion, nsTArray<nsIntRect>& aRects)
 {
   const nsIntRect* r;
   for (nsIntRegionRectIterator iter(aRegion); (r = iter.Next());) {
     aRects.AppendElement(*r);
   }
 }
 nsresult
 nsWindow::SetWindowClipRegion(const nsTArray<nsIntRect>& aRects,
                               bool aIntersectWithExisting)
 {
   if (!aIntersectWithExisting) {
     if (!StoreWindowClipRegion(aRects))
       return NS_OK;
   } else {
     // In this case still early return if nothing changed.
     if (mClipRects && mClipRectCount == aRects.Length() &&
         memcmp(mClipRects,
                aRects.Elements(),
                sizeof(nsIntRect)*mClipRectCount) == 0) {
       return NS_OK;
     }
     // get current rects
     nsTArray<nsIntRect> currentRects;
     GetWindowClipRegion(&currentRects);
     // create region from them
     nsIntRegion currentRegion = RegionFromArray(currentRects);
     // create region from new rects
     nsIntRegion newRegion = RegionFromArray(aRects);
     // intersect regions
     nsIntRegion intersection;
     intersection.And(currentRegion, newRegion);
     // create int rect array from intersection
     nsTArray<nsIntRect> rects;
     ArrayFromRegion(intersection, rects);
     // store
     if (!StoreWindowClipRegion(rects))
       return NS_OK;
   }
   HRGN dest = CreateHRGNFromArray(aRects);
   if (!dest)
     return NS_ERROR_OUT_OF_MEMORY;
   if (aIntersectWithExisting) {
     HRGN current = ::CreateRectRgn(0, 0, 0, 0);
     if (current) {
       if (::GetWindowRgn(mWnd, current) != 0 /*ERROR*/) {
         ::CombineRgn(dest, dest, current, RGN_AND);
       }
       ::DeleteObject(current);
     }
   }
   // If a plugin is not visible, especially if it is in a background tab,
   // it should not be able to steal keyboard focus.  This code checks whether
   // the region that the plugin is being clipped to is NULLREGION.  If it is,
   // the plugin window gets disabled.
   if(mWindowType == eWindowType_plugin) {
     if(NULLREGION == ::CombineRgn(dest, dest, dest, RGN_OR)) {
       ::ShowWindow(mWnd, SW_HIDE);
       ::EnableWindow(mWnd, FALSE);
     } else {
       ::EnableWindow(mWnd, TRUE);
       ::ShowWindow(mWnd, SW_SHOW);
     }
   }
   if (!::SetWindowRgn(mWnd, dest, TRUE)) {
     ::DeleteObject(dest);
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 // WM_DESTROY event handler
 void nsWindow::OnDestroy()
 {
   mOnDestroyCalled = true;
   // Make sure we don't get destroyed in the process of tearing down.
   nsCOMPtr<nsIWidget> kungFuDeathGrip(this);
   // Dispatch the destroy notification.
   if (!mInDtor)
     NotifyWindowDestroyed();
   // Prevent the widget from sending additional events.
   mWidgetListener = nullptr;
   mAttachedWidgetListener = nullptr;
   // Free our subclass and clear |this| stored in the window props. We will no longer
   // receive events from Windows after this point.
   SubclassWindow(FALSE);
   // Once mWidgetListener is cleared and the subclass is reset, sCurrentWindow can be
   // cleared. (It's used in tracking windows for mouse events.)
   if (sCurrentWindow == this)
     sCurrentWindow = nullptr;
   // Disconnects us from our parent, will call our GetParent().
   nsBaseWidget::Destroy();
   // Release references to children, device context, toolkit, and app shell.
   nsBaseWidget::OnDestroy();
   // Clear our native parent handle.
   // XXX Windows will take care of this in the proper order, and SetParent(nullptr)'s
   // remove child on the parent already took place in nsBaseWidget's Destroy call above.
   //SetParent(nullptr);
   mParent = nullptr;
   // We have to destroy the native drag target before we null out our window pointer.
   EnableDragDrop(false);
   // If we're going away and for some reason we're still the rollup widget, rollup and
   // turn off capture.
   nsIRollupListener* rollupListener = nsBaseWidget::GetActiveRollupListener();
   nsCOMPtr<nsIWidget> rollupWidget;
   if (rollupListener) {
     rollupWidget = rollupListener->GetRollupWidget();
   }
   if (this == rollupWidget) {
     if ( rollupListener )
       rollupListener->Rollup(0, nullptr, nullptr);
     CaptureRollupEvents(nullptr, false);
   }
   IMEHandler::OnDestroyWindow(this);
   // Turn off mouse trails if enabled.
   MouseTrailer* mtrailer = nsToolkit::gMouseTrailer;
   if (mtrailer) {
     if (mtrailer->GetMouseTrailerWindow() == mWnd)
       mtrailer->DestroyTimer();
     if (mtrailer->GetCaptureWindow() == mWnd)
       mtrailer->SetCaptureWindow(nullptr);
   }
   // Free GDI window class objects
   if (mBrush) {
     VERIFY(::DeleteObject(mBrush));
     mBrush = nullptr;
   }
   // Destroy any custom cursor resources.
   if (mCursor == -1)
     SetCursor(eCursor_standard);
 #ifdef MOZ_XUL
   // Reset transparency
   if (eTransparencyTransparent == mTransparencyMode)
     SetupTranslucentWindowMemoryBitmap(eTransparencyOpaque);
 #endif
   // Finalize panning feedback to possibly restore window displacement
   mGesture.PanFeedbackFinalize(mWnd, true);
   // Clear the main HWND.
   mWnd = nullptr;
 }
 // Send a resize message to the listener
 bool nsWindow::OnResize(nsIntRect &aWindowRect)
 {
   bool result = mWidgetListener ?
                 mWidgetListener->WindowResized(this, aWindowRect.width, aWindowRect.height) : false;
   // If there is an attached view, inform it as well as the normal widget listener.
   if (mAttachedWidgetListener) {
     return mAttachedWidgetListener->WindowResized(this, aWindowRect.width, aWindowRect.height);
   }
   return result;
 }
 bool nsWindow::OnHotKey(WPARAM wParam, LPARAM lParam)
 {
   return true;
 }
 // Can be overriden. Controls auto-erase of background.
 bool nsWindow::AutoErase(HDC dc)
 {
   return false;
 }
 void
 nsWindow::AllowD3D9Callback(nsWindow *aWindow)
 {
   if (aWindow->mLayerManager && !aWindow->ShouldUseOffMainThreadCompositing()) {
     aWindow->mLayerManager->Destroy();
     aWindow->mLayerManager = nullptr;
   }
 }
 void
 nsWindow::AllowD3D9WithReinitializeCallback(nsWindow *aWindow)
 {
   if (aWindow->mLayerManager && !aWindow->ShouldUseOffMainThreadCompositing()) {
     aWindow->mLayerManager->Destroy();
     aWindow->mLayerManager = nullptr;
     (void) aWindow->GetLayerManager();
   }
 }
 void
 nsWindow::StartAllowingD3D9(bool aReinitialize)
 {
   sAllowD3D9 = true;
   LayerManagerPrefs prefs;
   GetLayerManagerPrefs(&prefs);
   if (prefs.mDisableAcceleration) {
     // The guarantee here is, if there's *any* chance that after we
     // throw out our layer managers we'd create at least one new,
     // accelerated one, we *will* throw out all the current layer
     // managers.  We early-return here because currently, if
     // |disableAcceleration|, we will always use basic managers and
     // it's a waste to recreate them. If we're using OMTC we don't want to
     // recreate out layer manager and its compositor either. This is even
     // more wasteful.
     //
     // NB: the above implies that it's eminently possible for us to
     // skip this early return but still recreate basic managers.
     // That's OK.  It's *not* OK to take this early return when we
     // *might* have created an accelerated manager.
     return;
   }
   if (aReinitialize) {
     EnumAllWindows(AllowD3D9WithReinitializeCallback);
   } else {
     EnumAllWindows(AllowD3D9Callback);
   }
 }
 bool
 nsWindow::ShouldUseOffMainThreadCompositing()
 {
   // We don't currently support using an accelerated layer manager with
   // transparent windows so don't even try. I'm also not sure if we even
   // want to support this case. See bug 593471
   if (mTransparencyMode == eTransparencyTransparent) {
     return false;
   }
   return nsBaseWidget::ShouldUseOffMainThreadCompositing();
 }
 void
 nsWindow::GetPreferredCompositorBackends(nsTArray<LayersBackend>& aHints)
 {
   LayerManagerPrefs prefs;
   GetLayerManagerPrefs(&prefs);
   // We don't currently support using an accelerated layer manager with
   // transparent windows so don't even try. I'm also not sure if we even
   // want to support this case. See bug 593471
   if (!(prefs.mDisableAcceleration ||
         mTransparencyMode == eTransparencyTransparent)) {
     if (prefs.mPreferOpenGL) {
       aHints.AppendElement(LayersBackend::LAYERS_OPENGL);
     }
     if (!prefs.mPreferD3D9) {
       aHints.AppendElement(LayersBackend::LAYERS_D3D11);
     }
     aHints.AppendElement(LayersBackend::LAYERS_D3D9);
   }
   aHints.AppendElement(LayersBackend::LAYERS_BASIC);
 }
 void
 nsWindow::WindowUsesOMTC()
 {
   ULONG_PTR style = ::GetClassLongPtr(mWnd, GCL_STYLE);
   if (!style) {
     NS_WARNING("Could not get window class style");
     return;
   }
   style |= CS_HREDRAW | CS_VREDRAW;
   DebugOnly<ULONG_PTR> result = ::SetClassLongPtr(mWnd, GCL_STYLE, style);
   NS_WARN_IF_FALSE(result, "Could not reset window class style");
 }
 bool
 nsWindow::HasBogusPopupsDropShadowOnMultiMonitor() {
   if (sHasBogusPopupsDropShadowOnMultiMonitor == TRI_UNKNOWN) {
     // Since any change in the preferences requires a restart, this can be
     // done just once.
     // Check for Direct2D first.
     sHasBogusPopupsDropShadowOnMultiMonitor =
       gfxWindowsPlatform::GetPlatform()->GetRenderMode() ==
         gfxWindowsPlatform::RENDER_DIRECT2D ? TRI_TRUE : TRI_FALSE;
     if (!sHasBogusPopupsDropShadowOnMultiMonitor) {
       // Otherwise check if Direct3D 9 may be used.
       LayerManagerPrefs prefs;
       GetLayerManagerPrefs(&prefs);
       if (!prefs.mDisableAcceleration && !prefs.mPreferOpenGL) {
         nsCOMPtr<nsIGfxInfo> gfxInfo = do_GetService("@mozilla.org/gfx/info;1");
         if (gfxInfo) {
           int32_t status;
           if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS, &status))) {
             if (status == nsIGfxInfo::FEATURE_NO_INFO || prefs.mForceAcceleration)
             {
               sHasBogusPopupsDropShadowOnMultiMonitor = TRI_TRUE;
             }
           }
         }
       }
     }
   }
   return !!sHasBogusPopupsDropShadowOnMultiMonitor;
 }
 void
 nsWindow::OnSysColorChanged()
 {
   if (mWindowType == eWindowType_invisible) {
     ::EnumThreadWindows(GetCurrentThreadId(), nsWindow::BroadcastMsg, WM_SYSCOLORCHANGE);
   }
   else {
     // Note: This is sent for child windows as well as top-level windows.
     // The Win32 toolkit normally only sends these events to top-level windows.
     // But we cycle through all of the childwindows and send it to them as well
     // so all presentations get notified properly.
     // See nsWindow::GlobalMsgWindowProc.
     NotifySysColorChanged();
   }
 }
 /**************************************************************
  **************************************************************
  **
  ** BLOCK: IME management and accessibility
  **
  ** Handles managing IME input and accessibility.
  **
  **************************************************************
  **************************************************************/
 NS_IMETHODIMP
 nsWindow::NotifyIME(const IMENotification& aIMENotification)
 {
   return IMEHandler::NotifyIME(this, aIMENotification);
 }
 NS_IMETHODIMP_(void)
 nsWindow::SetInputContext(const InputContext& aContext,
                           const InputContextAction& aAction)
 {
   InputContext newInputContext = aContext;
   IMEHandler::SetInputContext(this, newInputContext, aAction);
   mInputContext = newInputContext;
 }
 NS_IMETHODIMP_(InputContext)
 nsWindow::GetInputContext()
 {
   mInputContext.mIMEState.mOpen = IMEState::CLOSED;
   if (WinUtils::IsIMEEnabled(mInputContext) && IMEHandler::GetOpenState(this)) {
     mInputContext.mIMEState.mOpen = IMEState::OPEN;
   } else {
     mInputContext.mIMEState.mOpen = IMEState::CLOSED;
   }
   return mInputContext;
 }
 NS_IMETHODIMP
 nsWindow::GetToggledKeyState(uint32_t aKeyCode, bool* aLEDState)
 {
 #ifdef DEBUG_KBSTATE
   PR_LOG(gWindowsLog, PR_LOG_ALWAYS, ("GetToggledKeyState\n"));
 #endif
   NS_ENSURE_ARG_POINTER(aLEDState);
   *aLEDState = (::GetKeyState(aKeyCode) & 1) != 0;
   return NS_OK;
 }
 nsIMEUpdatePreference
 nsWindow::GetIMEUpdatePreference()
 {
   return IMEHandler::GetUpdatePreference();
 }
 #ifdef ACCESSIBILITY
 #ifdef DEBUG
 #define NS_LOG_WMGETOBJECT(aWnd, aHwnd, aAcc)                                  \
   if (a11y::logging::IsEnabled(a11y::logging::ePlatforms)) {                   \
     printf("Get the window:\n  {\n     HWND: %d, parent HWND: %d, wndobj: %p,\n",\
            aHwnd, ::GetParent(aHwnd), aWnd);                                   \
     printf("     acc: %p", aAcc);                                              \
     if (aAcc) {                                                                \
       nsAutoString name;                                                       \
       aAcc->Name(name);                                                        \
       printf(", accname: %s", NS_ConvertUTF16toUTF8(name).get());              \
     }                                                                          \
     printf("\n }\n");                                                          \
   }
 #else
 #define NS_LOG_WMGETOBJECT(aWnd, aHwnd, aAcc)
 #endif
 a11y::Accessible*
 nsWindow::GetAccessible()
 {
   // If the pref was ePlatformIsDisabled, return null here, disabling a11y.
   if (a11y::PlatformDisabledState() == a11y::ePlatformIsDisabled)
     return nullptr;
   if (mInDtor || mOnDestroyCalled || mWindowType == eWindowType_invisible) {
     return nullptr;
   }
   // In case of popup window return a popup accessible.
   nsView* view = nsView::GetViewFor(this);
   if (view) {
     nsIFrame* frame = view->GetFrame();
     if (frame && nsLayoutUtils::IsPopup(frame)) {
       nsCOMPtr<nsIAccessibilityService> accService =
         services::GetAccessibilityService();
       if (accService) {
         a11y::DocAccessible* docAcc =
           GetAccService()->GetDocAccessible(frame->PresContext()->PresShell());
         if (docAcc) {
           NS_LOG_WMGETOBJECT(this, mWnd,
                              docAcc->GetAccessibleOrDescendant(frame->GetContent()));
           return docAcc->GetAccessibleOrDescendant(frame->GetContent());
         }
       }
     }
   }
   // otherwise root document accessible.
   NS_LOG_WMGETOBJECT(this, mWnd, GetRootAccessible());
   return GetRootAccessible();
 }
 #endif
 /**************************************************************
  **************************************************************
  **
  ** BLOCK: Transparency
  **
  ** Window transparency helpers.
  **
  **************************************************************
  **************************************************************/
 #ifdef MOZ_XUL
 void nsWindow::ResizeTranslucentWindow(int32_t aNewWidth, int32_t aNewHeight, bool force)
 {
   if (!force && aNewWidth == mBounds.width && aNewHeight == mBounds.height)
     return;
   nsRefPtr<gfxWindowsSurface> newSurface =
     new gfxWindowsSurface(gfxIntSize(aNewWidth, aNewHeight), gfxImageFormat::ARGB32);
   mTransparentSurface = newSurface;
   mMemoryDC = newSurface->GetDC();
 }
 void nsWindow::SetWindowTranslucencyInner(nsTransparencyMode aMode)
 {
   if (aMode == mTransparencyMode)
     return;
   // stop on dialogs and popups!
   HWND hWnd = WinUtils::GetTopLevelHWND(mWnd, true);
   nsWindow* parent = WinUtils::GetNSWindowPtr(hWnd);
   if (!parent)
   {
     NS_WARNING("Trying to use transparent chrome in an embedded context");
     return;
   }
   if (parent != this) {
     NS_WARNING("Setting SetWindowTranslucencyInner on a parent this is not us!");
   }
   if (aMode == eTransparencyTransparent) {
     // If we're switching to the use of a transparent window, hide the chrome
     // on our parent.
     HideWindowChrome(true);
   } else if (mHideChrome && mTransparencyMode == eTransparencyTransparent) {
     // if we're switching out of transparent, re-enable our parent's chrome.
     HideWindowChrome(false);
   }
   LONG_PTR style = ::GetWindowLongPtrW(hWnd, GWL_STYLE),
     exStyle = ::GetWindowLongPtr(hWnd, GWL_EXSTYLE);
    if (parent->mIsVisible)
      style |= WS_VISIBLE;
    if (parent->mSizeMode == nsSizeMode_Maximized)
      style |= WS_MAXIMIZE;
    else if (parent->mSizeMode == nsSizeMode_Minimized)
      style |= WS_MINIMIZE;
    if (aMode == eTransparencyTransparent)
      exStyle |= WS_EX_LAYERED;
    else
      exStyle &= ~WS_EX_LAYERED;
   VERIFY_WINDOW_STYLE(style);
   ::SetWindowLongPtrW(hWnd, GWL_STYLE, style);
   ::SetWindowLongPtrW(hWnd, GWL_EXSTYLE, exStyle);
   if (HasGlass())
     memset(&mGlassMargins, 0, sizeof mGlassMargins);
   mTransparencyMode = aMode;
   SetupTranslucentWindowMemoryBitmap(aMode);
   UpdateGlass();
 }
 void nsWindow::SetupTranslucentWindowMemoryBitmap(nsTransparencyMode aMode)
 {
   if (eTransparencyTransparent == aMode) {
     ResizeTranslucentWindow(mBounds.width, mBounds.height, true);
   } else {
     mTransparentSurface = nullptr;
     mMemoryDC = nullptr;
   }
 }
 void nsWindow::ClearTranslucentWindow()
 {
   if (mTransparentSurface) {
     nsRefPtr<gfxContext> thebesContext = new gfxContext(mTransparentSurface);
     thebesContext->SetOperator(gfxContext::OPERATOR_CLEAR);
     thebesContext->Paint();
     UpdateTranslucentWindow();
  }
 }
 nsresult nsWindow::UpdateTranslucentWindow()
 {
   if (mBounds.IsEmpty())
     return NS_OK;
   ::GdiFlush();
   BLENDFUNCTION bf = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
   SIZE winSize = { mBounds.width, mBounds.height };
   POINT srcPos = { 0, 0 };
   HWND hWnd = WinUtils::GetTopLevelHWND(mWnd, true);
   RECT winRect;
   ::GetWindowRect(hWnd, &winRect);
   // perform the alpha blend
   bool updateSuccesful =
     ::UpdateLayeredWindow(hWnd, nullptr, (POINT*)&winRect, &winSize, mMemoryDC,
                           &srcPos, 0, &bf, ULW_ALPHA);
   if (!updateSuccesful) {
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 #endif //MOZ_XUL
 /**************************************************************
  **************************************************************
  **
  ** BLOCK: Popup rollup hooks
  **
  ** Deals with CaptureRollup on popup windows.
  **
  **************************************************************
  **************************************************************/
 // Schedules a timer for a window, so we can rollup after processing the hook event
 void nsWindow::ScheduleHookTimer(HWND aWnd, UINT aMsgId)
 {
   // In some cases multiple hooks may be scheduled
   // so ignore any other requests once one timer is scheduled
   if (sHookTimerId == 0) {
     // Remember the window handle and the message ID to be used later
     sRollupMsgId = aMsgId;
     sRollupMsgWnd = aWnd;
     // Schedule native timer for doing the rollup after
     // this event is done being processed
     sHookTimerId = ::SetTimer(nullptr, 0, 0, (TIMERPROC)HookTimerForPopups);
     NS_ASSERTION(sHookTimerId, "Timer couldn't be created.");
   }
 }
 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
 int gLastMsgCode = 0;
 extern MSGFEventMsgInfo gMSGFEvents[];
 #endif
 // Process Menu messages, rollup when popup is clicked.
 LRESULT CALLBACK nsWindow::MozSpecialMsgFilter(int code, WPARAM wParam, LPARAM lParam)
 {
 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
   if (sProcessHook) {
     MSG* pMsg = (MSG*)lParam;
     int inx = 0;
     while (gMSGFEvents[inx].mId != code && gMSGFEvents[inx].mStr != nullptr) {
       inx++;
     }
     if (code != gLastMsgCode) {
       if (gMSGFEvents[inx].mId == code) {
 #ifdef DEBUG
         PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
                ("MozSpecialMessageProc - code: 0x%X  - %s  hw: %p\n",
                 code, gMSGFEvents[inx].mStr, pMsg->hwnd));
 #endif
       } else {
 #ifdef DEBUG
         PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
                ("MozSpecialMessageProc - code: 0x%X  - %d  hw: %p\n",
                 code, gMSGFEvents[inx].mId, pMsg->hwnd));
 #endif
       }
       gLastMsgCode = code;
     }
     PrintEvent(pMsg->message, FALSE, FALSE);
   }
 #endif // #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
   if (sProcessHook && code == MSGF_MENU) {
     MSG* pMsg = (MSG*)lParam;
     ScheduleHookTimer( pMsg->hwnd, pMsg->message);
   }
   return ::CallNextHookEx(sMsgFilterHook, code, wParam, lParam);
 }
 // Process all mouse messages. Roll up when a click is in a native window
 // that doesn't have an nsIWidget.
 LRESULT CALLBACK nsWindow::MozSpecialMouseProc(int code, WPARAM wParam, LPARAM lParam)
 {
   if (sProcessHook) {
     switch (WinUtils::GetNativeMessage(wParam)) {
       case WM_LBUTTONDOWN:
       case WM_RBUTTONDOWN:
       case WM_MBUTTONDOWN:
       case WM_MOUSEWHEEL:
       case WM_MOUSEHWHEEL:
       {
         MOUSEHOOKSTRUCT* ms = (MOUSEHOOKSTRUCT*)lParam;
         nsIWidget* mozWin = WinUtils::GetNSWindowPtr(ms->hwnd);
         if (mozWin) {
           // If this window is windowed plugin window, the mouse events are not
           // sent to us.
           if (static_cast<nsWindow*>(mozWin)->mWindowType == eWindowType_plugin)
             ScheduleHookTimer(ms->hwnd, (UINT)wParam);
         } else {
           ScheduleHookTimer(ms->hwnd, (UINT)wParam);
         }
         break;
       }
     }
   }
   return ::CallNextHookEx(sCallMouseHook, code, wParam, lParam);
 }
 // Process all messages. Roll up when the window is moving, or
 // is resizing or when maximized or mininized.
 LRESULT CALLBACK nsWindow::MozSpecialWndProc(int code, WPARAM wParam, LPARAM lParam)
 {
 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
   if (sProcessHook) {
     CWPSTRUCT* cwpt = (CWPSTRUCT*)lParam;
     PrintEvent(cwpt->message, FALSE, FALSE);
   }
 #endif
   if (sProcessHook) {
     CWPSTRUCT* cwpt = (CWPSTRUCT*)lParam;
     if (cwpt->message == WM_MOVING ||
         cwpt->message == WM_SIZING ||
         cwpt->message == WM_GETMINMAXINFO) {
       ScheduleHookTimer(cwpt->hwnd, (UINT)cwpt->message);
     }
   }
   return ::CallNextHookEx(sCallProcHook, code, wParam, lParam);
 }
 // Register the special "hooks" for dropdown processing.
 void nsWindow::RegisterSpecialDropdownHooks()
 {
   NS_ASSERTION(!sMsgFilterHook, "sMsgFilterHook must be NULL!");
   NS_ASSERTION(!sCallProcHook,  "sCallProcHook must be NULL!");
   DISPLAY_NMM_PRT("***************** Installing Msg Hooks ***************\n");
   // Install msg hook for moving the window and resizing
   if (!sMsgFilterHook) {
     DISPLAY_NMM_PRT("***** Hooking sMsgFilterHook!\n");
     sMsgFilterHook = SetWindowsHookEx(WH_MSGFILTER, MozSpecialMsgFilter,
                                       nullptr, GetCurrentThreadId());
 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
     if (!sMsgFilterHook) {
       PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
              ("***** SetWindowsHookEx is NOT installed for WH_MSGFILTER!\n"));
     }
 #endif
   }
   // Install msg hook for menus
   if (!sCallProcHook) {
     DISPLAY_NMM_PRT("***** Hooking sCallProcHook!\n");
     sCallProcHook  = SetWindowsHookEx(WH_CALLWNDPROC, MozSpecialWndProc,
                                       nullptr, GetCurrentThreadId());
 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
     if (!sCallProcHook) {
       PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
              ("***** SetWindowsHookEx is NOT installed for WH_CALLWNDPROC!\n"));
     }
 #endif
   }
   // Install msg hook for the mouse
   if (!sCallMouseHook) {
     DISPLAY_NMM_PRT("***** Hooking sCallMouseHook!\n");
     sCallMouseHook  = SetWindowsHookEx(WH_MOUSE, MozSpecialMouseProc,
                                        nullptr, GetCurrentThreadId());
 #ifdef POPUP_ROLLUP_DEBUG_OUTPUT
     if (!sCallMouseHook) {
       PR_LOG(gWindowsLog, PR_LOG_ALWAYS,
              ("***** SetWindowsHookEx is NOT installed for WH_MOUSE!\n"));
     }
 #endif
   }
 }
 // Unhook special message hooks for dropdowns.
 void nsWindow::UnregisterSpecialDropdownHooks()
 {
   DISPLAY_NMM_PRT("***************** De-installing Msg Hooks ***************\n");
   if (sCallProcHook) {
     DISPLAY_NMM_PRT("***** Unhooking sCallProcHook!\n");
     if (!::UnhookWindowsHookEx(sCallProcHook)) {
       DISPLAY_NMM_PRT("***** UnhookWindowsHookEx failed for sCallProcHook!\n");
     }
     sCallProcHook = nullptr;
   }
   if (sMsgFilterHook) {
     DISPLAY_NMM_PRT("***** Unhooking sMsgFilterHook!\n");
     if (!::UnhookWindowsHookEx(sMsgFilterHook)) {
       DISPLAY_NMM_PRT("***** UnhookWindowsHookEx failed for sMsgFilterHook!\n");
     }
     sMsgFilterHook = nullptr;
   }
   if (sCallMouseHook) {
     DISPLAY_NMM_PRT("***** Unhooking sCallMouseHook!\n");
     if (!::UnhookWindowsHookEx(sCallMouseHook)) {
       DISPLAY_NMM_PRT("***** UnhookWindowsHookEx failed for sCallMouseHook!\n");
     }
     sCallMouseHook = nullptr;
   }
 }
 // This timer is designed to only fire one time at most each time a "hook" function
 // is used to rollup the dropdown. In some cases, the timer may be scheduled from the
 // hook, but that hook event or a subsequent event may roll up the dropdown before
 // this timer function is executed.
 //
 // For example, if an MFC control takes focus, the combobox will lose focus and rollup
 // before this function fires.
 VOID CALLBACK nsWindow::HookTimerForPopups(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)
 {
   if (sHookTimerId != 0) {
     // if the window is nullptr then we need to use the ID to kill the timer
     BOOL status = ::KillTimer(nullptr, sHookTimerId);
     NS_ASSERTION(status, "Hook Timer was not killed.");
     sHookTimerId = 0;
   }
   if (sRollupMsgId != 0) {
     // Note: DealWithPopups does the check to make sure that the rollup widget is set.
     LRESULT popupHandlingResult;
     nsAutoRollup autoRollup;
     DealWithPopups(sRollupMsgWnd, sRollupMsgId, 0, 0, &popupHandlingResult);
     sRollupMsgId = 0;
     sRollupMsgWnd = nullptr;
   }
 }
 BOOL CALLBACK nsWindow::ClearResourcesCallback(HWND aWnd, LPARAM aMsg)
 {
     nsWindow *window = WinUtils::GetNSWindowPtr(aWnd);
     if (window) {
         window->ClearCachedResources();
     }
     return TRUE;
 }
 void
 nsWindow::ClearCachedResources()
 {
     if (mLayerManager &&
         mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC) {
       mLayerManager->ClearCachedResources();
     }
     ::EnumChildWindows(mWnd, nsWindow::ClearResourcesCallback, 0);
 }
 static bool IsDifferentThreadWindow(HWND aWnd)
 {
   return ::GetCurrentThreadId() != ::GetWindowThreadProcessId(aWnd, nullptr);
 }
 // static
 bool
 nsWindow::EventIsInsideWindow(nsWindow* aWindow)
 {
   RECT r;
   ::GetWindowRect(aWindow->mWnd, &r);
   DWORD pos = ::GetMessagePos();
   POINT mp;
   mp.x = GET_X_LPARAM(pos);
   mp.y = GET_Y_LPARAM(pos);
   // was the event inside this window?
   return static_cast<bool>(::PtInRect(&r, mp));
 }
 // static
 bool
 nsWindow::GetPopupsToRollup(nsIRollupListener* aRollupListener,
                             uint32_t* aPopupsToRollup)
 {
   // If we're dealing with menus, we probably have submenus and we don't want
   // to rollup some of them if the click is in a parent menu of the current
   // submenu.
   *aPopupsToRollup = UINT32_MAX;
   nsAutoTArray<nsIWidget*, 5> widgetChain;
   uint32_t sameTypeCount =
     aRollupListener->GetSubmenuWidgetChain(&widgetChain);
   for (uint32_t i = 0; i < widgetChain.Length(); ++i) {
     nsIWidget* widget = widgetChain[i];
     if (EventIsInsideWindow(static_cast<nsWindow*>(widget))) {
       // Don't roll up if the mouse event occurred within a menu of the
       // same type. If the mouse event occurred in a menu higher than that,
       // roll up, but pass the number of popups to Rollup so that only those
       // of the same type close up.
       if (i < sameTypeCount) {
         return false;
       }
       *aPopupsToRollup = sameTypeCount;
       break;
     }
   }
   return true;
 }
 // static
 bool
 nsWindow::NeedsToHandleNCActivateDelayed(HWND aWnd)
 {
   // While popup is open, popup window might be activated by other application.
   // At this time, we need to take back focus to the previous window but it
   // causes flickering its nonclient area because WM_NCACTIVATE comes before
   // WM_ACTIVATE and we cannot know which window will take focus at receiving
   // WM_NCACTIVATE. Therefore, we need a hack for preventing the flickerling.
   //
   // If non-popup window receives WM_NCACTIVATE at deactivating, default
   // wndproc shouldn't handle it as deactivating. Instead, at receiving
   // WM_ACTIVIATE after that, WM_NCACTIVATE should be sent again manually.
   // This returns true if the window needs to handle WM_NCACTIVATE later.
   nsWindow* window = WinUtils::GetNSWindowPtr(aWnd);
   return window && !window->IsPopup();
 }
 // static
 bool
 nsWindow::DealWithPopups(HWND aWnd, UINT aMessage,
                          WPARAM aWParam, LPARAM aLParam, LRESULT* aResult)
 {
   NS_ASSERTION(aResult, "Bad outResult");
   // XXX Why do we use the return value of WM_MOUSEACTIVATE for all messages?
   *aResult = MA_NOACTIVATE;
   if (!::IsWindowVisible(aWnd)) {
     return false;
   }
   nsIRollupListener* rollupListener = nsBaseWidget::GetActiveRollupListener();
   NS_ENSURE_TRUE(rollupListener, false);
   nsCOMPtr<nsIWidget> popup = rollupListener->GetRollupWidget();
   if (!popup) {
     return false;
   }
   static bool sSendingNCACTIVATE = false;
   static bool sPendingNCACTIVATE = false;
   uint32_t popupsToRollup = UINT32_MAX;
   nsWindow* popupWindow = static_cast<nsWindow*>(popup.get());
   UINT nativeMessage = WinUtils::GetNativeMessage(aMessage);
   switch (nativeMessage) {
     case WM_LBUTTONDOWN:
     case WM_RBUTTONDOWN:
     case WM_MBUTTONDOWN:
     case WM_NCLBUTTONDOWN:
     case WM_NCRBUTTONDOWN:
     case WM_NCMBUTTONDOWN:
       if (!EventIsInsideWindow(popupWindow) &&
           GetPopupsToRollup(rollupListener, &popupsToRollup)) {
         break;
       }
       return false;
     case WM_MOUSEWHEEL:
     case WM_MOUSEHWHEEL:
       // We need to check if the popup thinks that it should cause closing
       // itself when mouse wheel events are fired outside the rollup widget.
       if (!EventIsInsideWindow(popupWindow)) {
         *aResult = MA_ACTIVATE;
         if (rollupListener->ShouldRollupOnMouseWheelEvent() &&
             GetPopupsToRollup(rollupListener, &popupsToRollup)) {
           break;
         }
       }
       return false;
     case WM_ACTIVATEAPP:
       break;
     case WM_ACTIVATE:
       // NOTE: Don't handle WA_INACTIVE for preventing popup taking focus
       // because we cannot distinguish it's caused by mouse or not.
       if (LOWORD(aWParam) == WA_ACTIVE && aLParam) {
         nsWindow* window = WinUtils::GetNSWindowPtr(aWnd);
         if (window && window->IsPopup()) {
           // Cancel notifying widget listeners of deactivating the previous
           // active window (see WM_KILLFOCUS case in ProcessMessage()).
           sJustGotDeactivate = false;
           // Reactivate the window later.
           ::PostMessageW(aWnd, MOZ_WM_REACTIVATE, aWParam, aLParam);
           return true;
         }
         // Don't rollup the popup when focus moves back to the parent window
         // from a popup because such case is caused by strange mouse drivers.
         nsWindow* prevWindow =
           WinUtils::GetNSWindowPtr(reinterpret_cast<HWND>(aLParam));
         if (prevWindow && prevWindow->IsPopup()) {
           return false;
         }
       } else if (LOWORD(aWParam) == WA_INACTIVE) {
         nsWindow* activeWindow =
           WinUtils::GetNSWindowPtr(reinterpret_cast<HWND>(aLParam));
         if (sPendingNCACTIVATE && NeedsToHandleNCActivateDelayed(aWnd)) {
           // If focus moves to non-popup widget or focusable popup, the window
           // needs to update its nonclient area.
           if (!activeWindow || !activeWindow->IsPopup()) {
             sSendingNCACTIVATE = true;
             ::SendMessageW(aWnd, WM_NCACTIVATE, false, 0);
             sSendingNCACTIVATE = false;
           }
           sPendingNCACTIVATE = false;
         }
         // If focus moves from/to popup, we don't need to rollup the popup
         // because such case is caused by strange mouse drivers.
         if (activeWindow) {
           if (activeWindow->IsPopup()) {
             return false;
           }
           nsWindow* deactiveWindow = WinUtils::GetNSWindowPtr(aWnd);
           if (deactiveWindow && deactiveWindow->IsPopup()) {
             return false;
           }
         }
       } else if (LOWORD(aWParam) == WA_CLICKACTIVE) {
         // If the WM_ACTIVATE message is caused by a click in a popup,
         // we should not rollup any popups.
         if (EventIsInsideWindow(popupWindow) ||
             !GetPopupsToRollup(rollupListener, &popupsToRollup)) {
           return false;
         }
       }
       break;
     case MOZ_WM_REACTIVATE:
       // The previous active window should take back focus.
       if (::IsWindow(reinterpret_cast<HWND>(aLParam))) {
         ::SetForegroundWindow(reinterpret_cast<HWND>(aLParam));
       }
       return true;
     case WM_NCACTIVATE:
       if (!aWParam && !sSendingNCACTIVATE &&
           NeedsToHandleNCActivateDelayed(aWnd)) {
         // Don't just consume WM_NCACTIVATE. It doesn't handle only the
         // nonclient area state change.
         ::DefWindowProcW(aWnd, aMessage, TRUE, aLParam);
         // Accept the deactivating because it's necessary to receive following
         // WM_ACTIVATE.
         *aResult = TRUE;
         sPendingNCACTIVATE = true;
         return true;
       }
       return false;
     case WM_MOUSEACTIVATE:
       if (!EventIsInsideWindow(popupWindow) &&
           GetPopupsToRollup(rollupListener, &popupsToRollup)) {
         // WM_MOUSEACTIVATE may be caused by moving the mouse (e.g., X-mouse
         // of TweakUI is enabled. Then, check if the popup should be rolled up
         // with rollup listener. If not, just consume the message.
         if (HIWORD(aLParam) == WM_MOUSEMOVE &&
             !rollupListener->ShouldRollupOnMouseActivate()) {
           return true;
         }
         // Otherwise, it should be handled by wndproc.
         return false;
       }
       // Prevent the click inside the popup from causing a change in window
       // activation. Since the popup is shown non-activated, we need to eat any
       // requests to activate the window while it is displayed. Windows will
       // automatically activate the popup on the mousedown otherwise.
       return true;
     case WM_KILLFOCUS:
       // If focus moves to other window created in different process/thread,
       // e.g., a plugin window, popups should be rolled up.
       if (IsDifferentThreadWindow(reinterpret_cast<HWND>(aWParam))) {
         break;
       }
       return false;
     case WM_MOVING:
     case WM_SIZING:
     case WM_MENUSELECT:
       break;
     default:
       return false;
   }
   // Only need to deal with the last rollup for left mouse down events.
   NS_ASSERTION(!mLastRollup, "mLastRollup is null");
   bool consumeRollupEvent;
   if (nativeMessage == WM_LBUTTONDOWN) {
     POINT pt;
     pt.x = GET_X_LPARAM(aLParam);
     pt.y = GET_Y_LPARAM(aLParam);
     ::ClientToScreen(aWnd, &pt);
     nsIntPoint pos(pt.x, pt.y);
     consumeRollupEvent =
       rollupListener->Rollup(popupsToRollup, &pos, &mLastRollup);
     NS_IF_ADDREF(mLastRollup);
   } else {
     consumeRollupEvent =
       rollupListener->Rollup(popupsToRollup, nullptr, nullptr);
   }
   // Tell hook to stop processing messages
   sProcessHook = false;
   sRollupMsgId = 0;
   sRollupMsgWnd = nullptr;
   // If we are NOT supposed to be consuming events, let it go through
   if (consumeRollupEvent && nativeMessage != WM_RBUTTONDOWN) {
     *aResult = MA_ACTIVATE;
     return true;
   }
   return false;
 }
 /**************************************************************
  **************************************************************
  **
  ** BLOCK: Misc. utility methods and functions.
  **
  ** General use.
  **
  **************************************************************
  **************************************************************/
 // Note that the result of GetTopLevelWindow method can be different from the
 // result of WinUtils::GetTopLevelHWND().  The result can be non-floating
 // window.  Because our top level window may be contained in another window
 // which is not managed by us.
 nsWindow* nsWindow::GetTopLevelWindow(bool aStopOnDialogOrPopup)
 {
   nsWindow* curWindow = this;
   while (true) {
     if (aStopOnDialogOrPopup) {
       switch (curWindow->mWindowType) {
         case eWindowType_dialog:
         case eWindowType_popup:
           return curWindow;
         default:
           break;
       }
     }
     // Retrieve the top level parent or owner window
     nsWindow* parentWindow = curWindow->GetParentWindow(true);
     if (!parentWindow)
       return curWindow;
     curWindow = parentWindow;
   }
 }
 static BOOL CALLBACK gEnumWindowsProc(HWND hwnd, LPARAM lParam)
 {
   DWORD pid;
   ::GetWindowThreadProcessId(hwnd, &pid);
   if (pid == GetCurrentProcessId() && ::IsWindowVisible(hwnd))
   {
     gWindowsVisible = true;
     return FALSE;
   }
   return TRUE;
 }
 bool nsWindow::CanTakeFocus()
 {
   gWindowsVisible = false;
   EnumWindows(gEnumWindowsProc, 0);
   if (!gWindowsVisible) {
     return true;
   } else {
     HWND fgWnd = ::GetForegroundWindow();
     if (!fgWnd) {
       return true;
     }
     DWORD pid;
     GetWindowThreadProcessId(fgWnd, &pid);
     if (pid == GetCurrentProcessId()) {
       return true;
     }
   }
   return false;
 }
 void nsWindow::GetMainWindowClass(nsAString& aClass)
 {
   NS_PRECONDITION(aClass.IsEmpty(), "aClass should be empty string");
   nsresult rv = Preferences::GetString("ui.window_class_override", &aClass);
   if (NS_FAILED(rv) || aClass.IsEmpty()) {
     aClass.AssignASCII(sDefaultMainWindowClass);
   }
 }
 LPARAM nsWindow::lParamToScreen(LPARAM lParam)
 {
   POINT pt;
   pt.x = GET_X_LPARAM(lParam);
   pt.y = GET_Y_LPARAM(lParam);
   ::ClientToScreen(mWnd, &pt);
   return MAKELPARAM(pt.x, pt.y);
 }
 LPARAM nsWindow::lParamToClient(LPARAM lParam)
 {
   POINT pt;
   pt.x = GET_X_LPARAM(lParam);
   pt.y = GET_Y_LPARAM(lParam);
   ::ScreenToClient(mWnd, &pt);
   return MAKELPARAM(pt.x, pt.y);
 }
 void nsWindow::PickerOpen()
 {
   mPickerDisplayCount++;
 }
 void nsWindow::PickerClosed()
 {
   NS_ASSERTION(mPickerDisplayCount > 0, "mPickerDisplayCount out of sync!");
   if (!mPickerDisplayCount)
     return;
   mPickerDisplayCount--;
   if (!mPickerDisplayCount && mDestroyCalled) {
     Destroy();
   }
 }
 /**************************************************************
  **************************************************************
  **
  ** BLOCK: ChildWindow impl.
  **
  ** Child window overrides.
  **
  **************************************************************
  **************************************************************/
 // return the style for a child nsWindow
 DWORD ChildWindow::WindowStyle()
 {
   DWORD style = WS_CLIPCHILDREN | nsWindow::WindowStyle();
   if (!(style & WS_POPUP))
     style |= WS_CHILD; // WS_POPUP and WS_CHILD are mutually exclusive.
   VERIFY_WINDOW_STYLE(style);
   return style;
 }

The Tor Browser / annotate

widget/windows/nsWindow.cpp@b8a032363ba2 (annotated)

widget/windows/nsWindow.cpp