summaryrefslogtreecommitdiffstats
path: root/widget/windows/nsWindow.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'widget/windows/nsWindow.cpp')
-rw-r--r--widget/windows/nsWindow.cpp8139
1 files changed, 8139 insertions, 0 deletions
diff --git a/widget/windows/nsWindow.cpp b/widget/windows/nsWindow.cpp
new file mode 100644
index 000000000..2172f2aa0
--- /dev/null
+++ b/widget/windows/nsWindow.cpp
@@ -0,0 +1,8139 @@
+/* -*- 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 "gfx2DGlue.h"
+#include "gfxEnv.h"
+#include "gfxPlatform.h"
+#include "gfxPrefs.h"
+#include "mozilla/Logging.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/MiscEvents.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TouchEvents.h"
+
+#include "mozilla/ipc/MessageChannel.h"
+#include <algorithm>
+#include <limits>
+
+#include "nsWindow.h"
+
+#include <shellapi.h>
+#include <windows.h>
+#include <wtsapi32.h>
+#include <process.h>
+#include <commctrl.h>
+#include <unknwn.h>
+#include <psapi.h>
+
+#include "mozilla/Logging.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 "nsIKeyEventInPluginCallback.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 "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 "SystemTimeConverter.h"
+#include "WinTaskbar.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 "mozilla/TextEvents.h" // For WidgetKeyboardEvent
+#include "mozilla/TextEventDispatcherListener.h"
+#include "mozilla/widget/WinNativeEventData.h"
+#include "mozilla/widget/PlatformWidgetTypes.h"
+#include "nsThemeConstants.h"
+#include "nsBidiKeyboard.h"
+#include "nsThemeConstants.h"
+#include "gfxConfig.h"
+#include "InProcessWinCompositorWidget.h"
+
+#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 "nsIWindowsUIUtils.h"
+
+#include "nsWindowDefs.h"
+
+#include "nsCrashOnException.h"
+#include "nsIXULRuntime.h"
+
+#include "nsIContent.h"
+
+#include "mozilla/HangMonitor.h"
+#include "WinIMEHandler.h"
+
+#include "npapi.h"
+
+#include <d3d11.h>
+
+#include "InkCollector.h"
+
+// ERROR from wingdi.h (below) gets undefined by some code.
+// #define ERROR 0
+// #define RGN_ERROR ERROR
+#define ERROR 0
+
+#if !defined(SM_CONVERTIBLESLATEMODE)
+#define SM_CONVERTIBLESLATEMODE 0x2003
+#endif
+
+#if !defined(WM_DPICHANGED)
+#define WM_DPICHANGED 0x02E0
+#endif
+
+#include "mozilla/gfx/DeviceManagerDx.h"
+#include "mozilla/layers/APZCTreeManager.h"
+#include "mozilla/layers/InputAPZContext.h"
+#include "mozilla/layers/ScrollInputMethods.h"
+#include "ClientLayerManager.h"
+#include "InputData.h"
+
+#include "mozilla/Telemetry.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+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;
+
+TriStateBool nsWindow::sHasBogusPopupsDropShadowOnMultiMonitor = TRI_UNKNOWN;
+
+WPARAM nsWindow::sMouseExitwParam = 0;
+LPARAM nsWindow::sMouseExitlParamScreen = 0;
+
+static SystemTimeConverter<DWORD>&
+TimeConverter() {
+ static SystemTimeConverter<DWORD> timeConverterSingleton;
+ return timeConverterSingleton;
+}
+
+namespace mozilla {
+
+class CurrentWindowsTimeGetter {
+public:
+ CurrentWindowsTimeGetter(HWND aWnd)
+ : mWnd(aWnd)
+ {
+ }
+
+ DWORD GetCurrentTime() const
+ {
+ return ::GetTickCount();
+ }
+
+ void GetTimeAsyncForPossibleBackwardsSkew(const TimeStamp& aNow)
+ {
+ DWORD currentTime = GetCurrentTime();
+ if (sBackwardsSkewStamp && currentTime == sLastPostTime) {
+ // There's already one inflight with this timestamp. Don't
+ // send a duplicate.
+ return;
+ }
+ sBackwardsSkewStamp = Some(aNow);
+ sLastPostTime = currentTime;
+ static_assert(sizeof(WPARAM) >= sizeof(DWORD), "Can't fit a DWORD in a WPARAM");
+ ::PostMessage(mWnd, MOZ_WM_SKEWFIX, sLastPostTime, 0);
+ }
+
+ static bool GetAndClearBackwardsSkewStamp(DWORD aPostTime, TimeStamp* aOutSkewStamp)
+ {
+ if (aPostTime != sLastPostTime) {
+ // The SKEWFIX message is stale; we've sent a new one since then.
+ // Ignore this one.
+ return false;
+ }
+ MOZ_ASSERT(sBackwardsSkewStamp);
+ *aOutSkewStamp = sBackwardsSkewStamp.value();
+ sBackwardsSkewStamp = Nothing();
+ return true;
+ }
+
+private:
+ static Maybe<TimeStamp> sBackwardsSkewStamp;
+ static DWORD sLastPostTime;
+ HWND mWnd;
+};
+
+Maybe<TimeStamp> CurrentWindowsTimeGetter::sBackwardsSkewStamp;
+DWORD CurrentWindowsTimeGetter::sLastPostTime = 0;
+
+} // namespace mozilla
+
+/**************************************************************
+ *
+ * SECTION: globals variables
+ *
+ **************************************************************/
+
+static const char *sScreenManagerContractID = "@mozilla.org/gfx/screenmanager;1";
+
+extern mozilla::LazyLogModule gWindowsLog;
+
+// 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
+
+#if defined(ACCESSIBILITY) && defined(_M_IX86)
+
+namespace mozilla {
+
+/**
+ * Windows touchscreen code works by setting a global WH_GETMESSAGE hook and
+ * injecting tiptsf.dll. The touchscreen process then posts registered messages
+ * to our main thread. The tiptsf hook picks up those registered messages and
+ * uses them as commands, some of which call into UIA, which then calls into
+ * MSAA, which then sends WM_GETOBJECT to us.
+ *
+ * We can get ahead of this by installing our own thread-local WH_GETMESSAGE
+ * hook. Since thread-local hooks are called ahead of global hooks, we will
+ * see these registered messages before tiptsf does. At this point we can then
+ * raise a flag that blocks a11y before invoking CallNextHookEx which will then
+ * invoke the global tiptsf hook. Then when we see WM_GETOBJECT, we check the
+ * flag by calling TIPMessageHandler::IsA11yBlocked().
+ *
+ * For Windows 8, we also hook tiptsf!ProcessCaretEvents, which is an a11y hook
+ * function that also calls into UIA.
+ */
+class TIPMessageHandler
+{
+public:
+ ~TIPMessageHandler()
+ {
+ if (mHook) {
+ ::UnhookWindowsHookEx(mHook);
+ }
+ }
+
+ static void Initialize()
+ {
+ if (!IsWin8OrLater()) {
+ return;
+ }
+
+ if (sInstance) {
+ return;
+ }
+
+ sInstance = new TIPMessageHandler();
+ ClearOnShutdown(&sInstance);
+ }
+
+ static bool IsA11yBlocked()
+ {
+ if (!sInstance) {
+ return false;
+ }
+
+ return sInstance->mA11yBlockCount > 0;
+ }
+
+private:
+ TIPMessageHandler()
+ : mHook(nullptr)
+ , mA11yBlockCount(0)
+ {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ // Registered messages used by tiptsf
+ mMessages[0] = ::RegisterWindowMessage(L"ImmersiveFocusNotification");
+ mMessages[1] = ::RegisterWindowMessage(L"TipCloseMenus");
+ mMessages[2] = ::RegisterWindowMessage(L"TabletInputPanelOpening");
+ mMessages[3] = ::RegisterWindowMessage(L"IHM Pen or Touch Event noticed");
+ mMessages[4] = ::RegisterWindowMessage(L"ProgrammabilityCaretVisibility");
+ mMessages[5] = ::RegisterWindowMessage(L"CaretTrackingUpdateIPHidden");
+ mMessages[6] = ::RegisterWindowMessage(L"CaretTrackingUpdateIPInfo");
+
+ mHook = ::SetWindowsHookEx(WH_GETMESSAGE, &TIPHook, nullptr,
+ ::GetCurrentThreadId());
+ MOZ_ASSERT(mHook);
+
+ // On touchscreen devices, tiptsf.dll will have been loaded when STA COM was
+ // first initialized.
+ if (!IsWin10OrLater() && GetModuleHandle(L"tiptsf.dll") &&
+ !sProcessCaretEventsStub) {
+ sTipTsfInterceptor.Init("tiptsf.dll");
+ DebugOnly<bool> ok = sTipTsfInterceptor.AddHook("ProcessCaretEvents",
+ reinterpret_cast<intptr_t>(&ProcessCaretEventsHook),
+ (void**) &sProcessCaretEventsStub);
+ MOZ_ASSERT(ok);
+ }
+
+ if (!sSendMessageTimeoutWStub) {
+ sUser32Intercept.Init("user32.dll");
+ DebugOnly<bool> hooked = sUser32Intercept.AddHook("SendMessageTimeoutW",
+ reinterpret_cast<intptr_t>(&SendMessageTimeoutWHook),
+ (void**) &sSendMessageTimeoutWStub);
+ MOZ_ASSERT(hooked);
+ }
+ }
+
+ class MOZ_RAII A11yInstantiationBlocker
+ {
+ public:
+ A11yInstantiationBlocker()
+ {
+ if (!TIPMessageHandler::sInstance) {
+ return;
+ }
+ ++TIPMessageHandler::sInstance->mA11yBlockCount;
+ }
+
+ ~A11yInstantiationBlocker()
+ {
+ if (!TIPMessageHandler::sInstance) {
+ return;
+ }
+ MOZ_ASSERT(TIPMessageHandler::sInstance->mA11yBlockCount > 0);
+ --TIPMessageHandler::sInstance->mA11yBlockCount;
+ }
+ };
+
+ friend class A11yInstantiationBlocker;
+
+ static LRESULT CALLBACK TIPHook(int aCode, WPARAM aWParam, LPARAM aLParam)
+ {
+ if (aCode < 0 || !sInstance) {
+ return ::CallNextHookEx(nullptr, aCode, aWParam, aLParam);
+ }
+
+ MSG* msg = reinterpret_cast<MSG*>(aLParam);
+ UINT& msgCode = msg->message;
+
+ for (uint32_t i = 0; i < ArrayLength(sInstance->mMessages); ++i) {
+ if (msgCode == sInstance->mMessages[i]) {
+ A11yInstantiationBlocker block;
+ return ::CallNextHookEx(nullptr, aCode, aWParam, aLParam);
+ }
+ }
+
+ return ::CallNextHookEx(nullptr, aCode, aWParam, aLParam);
+ }
+
+ static void CALLBACK ProcessCaretEventsHook(HWINEVENTHOOK aWinEventHook,
+ DWORD aEvent, HWND aHwnd,
+ LONG aObjectId, LONG aChildId,
+ DWORD aGeneratingTid,
+ DWORD aEventTime)
+ {
+ A11yInstantiationBlocker block;
+ sProcessCaretEventsStub(aWinEventHook, aEvent, aHwnd, aObjectId, aChildId,
+ aGeneratingTid, aEventTime);
+ }
+
+ static LRESULT WINAPI SendMessageTimeoutWHook(HWND aHwnd, UINT aMsgCode,
+ WPARAM aWParam, LPARAM aLParam,
+ UINT aFlags, UINT aTimeout,
+ PDWORD_PTR aMsgResult)
+ {
+ // We don't want to handle this unless the message is a WM_GETOBJECT that we
+ // want to block, and the aHwnd is a nsWindow that belongs to the current
+ // thread.
+ if (!aMsgResult || aMsgCode != WM_GETOBJECT || aLParam != OBJID_CLIENT ||
+ !WinUtils::GetNSWindowPtr(aHwnd) ||
+ ::GetWindowThreadProcessId(aHwnd, nullptr) != ::GetCurrentThreadId() ||
+ !IsA11yBlocked()) {
+ return sSendMessageTimeoutWStub(aHwnd, aMsgCode, aWParam, aLParam,
+ aFlags, aTimeout, aMsgResult);
+ }
+
+ // In this case we want to fake the result that would happen if we had
+ // decided not to handle WM_GETOBJECT in our WndProc. We hand the message
+ // off to DefWindowProc to accomplish this.
+ *aMsgResult = static_cast<DWORD_PTR>(::DefWindowProcW(aHwnd, aMsgCode,
+ aWParam, aLParam));
+
+ return static_cast<LRESULT>(TRUE);
+ }
+
+ static WindowsDllInterceptor sTipTsfInterceptor;
+ static WINEVENTPROC sProcessCaretEventsStub;
+ static decltype(&SendMessageTimeoutW) sSendMessageTimeoutWStub;
+ static StaticAutoPtr<TIPMessageHandler> sInstance;
+
+ HHOOK mHook;
+ UINT mMessages[7];
+ uint32_t mA11yBlockCount;
+};
+
+WindowsDllInterceptor TIPMessageHandler::sTipTsfInterceptor;
+WINEVENTPROC TIPMessageHandler::sProcessCaretEventsStub;
+decltype(&SendMessageTimeoutW) TIPMessageHandler::sSendMessageTimeoutWStub;
+StaticAutoPtr<TIPMessageHandler> TIPMessageHandler::sInstance;
+
+} // namespace mozilla
+
+#endif // defined(ACCESSIBILITY) && defined(_M_IX86)
+
+/**************************************************************
+ **************************************************************
+ **
+ ** BLOCK: nsIWidget impl.
+ **
+ ** nsIWidget interface implementation, broken down into
+ ** sections.
+ **
+ **************************************************************
+ **************************************************************/
+
+/**************************************************************
+ *
+ * SECTION: nsWindow construction and destruction
+ *
+ **************************************************************/
+
+nsWindow::nsWindow()
+ : nsWindowBase()
+ , mResizeState(NOT_RESIZING)
+{
+ mIconSmall = nullptr;
+ mIconBig = nullptr;
+ mWnd = nullptr;
+ mTransitionWnd = nullptr;
+ mPaintDC = nullptr;
+ mPrevWndProc = nullptr;
+ mNativeDragTarget = nullptr;
+ mInDtor = false;
+ mIsVisible = false;
+ mIsTopWidgetWindow = false;
+ mUnicodeWidget = true;
+ mDisplayPanFeedback = false;
+ mTouchWindow = false;
+ mFutureMarginsToUse = 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
+ mTransparencyMode = eTransparencyOpaque;
+ memset(&mGlassMargins, 0, sizeof mGlassMargins);
+#endif
+ DWORD background = ::GetSysColor(COLOR_BTNFACE);
+ mBrush = ::CreateSolidBrush(NSRGB_2_COLOREF(background));
+ mSendingSetText = false;
+ mDefaultScale = -1.0; // not yet set, will be calculated on first use
+
+ 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));
+#if defined(ACCESSIBILITY) && defined(_M_IX86)
+ mozilla::TIPMessageHandler::Initialize();
+#endif // defined(ACCESSIBILITY) && defined(_M_IX86)
+ 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();
+ InkCollector::sInkCollector = new InkCollector();
+
+ Preferences::AddBoolVarCache(&gIsPointerEventsEnabled,
+ "dom.w3c_pointer_events.enabled",
+ gIsPointerEventsEnabled);
+ } // !sInstanceCount
+
+ mIdleService = nullptr;
+
+ mSizeConstraintsScale = GetDefaultScale().scale;
+
+ 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.
+ // Destroy() will early-return if it was already called. In any case it is important
+ // to call it before destroying mPresentLock (cf. 1156182).
+ 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) {
+ InkCollector::sInkCollector->Shutdown();
+ InkCollector::sInkCollector = nullptr;
+ 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;
+}
+
+static bool
+ShouldCacheTitleBarInfo(nsWindowType aWindowType, nsBorderStyle aBorderStyle)
+{
+ return (aWindowType == eWindowType_toplevel) &&
+ (aBorderStyle == eBorderStyle_default ||
+ aBorderStyle == eBorderStyle_all) &&
+ (!nsUXThemeData::sTitlebarInfoPopulatedThemed ||
+ !nsUXThemeData::sTitlebarInfoPopulatedAero);
+}
+
+// Create the proper widget
+nsresult
+nsWindow::Create(nsIWidget* aParent,
+ nsNativeWidget aNativeParent,
+ const LayoutDeviceIntRect& aRect,
+ 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, 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;
+ }
+ }
+
+ const wchar_t* className;
+ if (aInitData->mDropShadow) {
+ className = GetWindowPopupClass();
+ } else {
+ className = GetWindowClass();
+ }
+ // 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 ||
+ aInitData->mWindowType == eWindowType_plugin_ipc_chrome ||
+ aInitData->mWindowType == eWindowType_plugin_ipc_content) {
+ style |= WS_DISABLED;
+ }
+ mWnd = ::CreateWindowExW(extendedStyle,
+ className,
+ 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 (!IsPlugin() &&
+ 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, L"FAKETRACKPOINTSCROLLCONTAINER",
+ WS_CHILD | WS_VISIBLE,
+ 0, 0, 0, 0, mWnd, nullptr, nsToolkit::mDllInstance, nullptr);
+ HWND scrollableWnd = ::CreateWindowW
+ (className, L"FAKETRACKPOINTSCROLLABLE",
+ WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_TABSTOP | 0x30,
+ 0, 0, 0, 0, scrollContainerWnd, nullptr, nsToolkit::mDllInstance,
+ nullptr);
+
+ // Give the FAKETRACKPOINTSCROLLABLE window a specific ID so that
+ // WindowProcInternal can distinguish it from the top-level window
+ // easily.
+ ::SetWindowLongPtrW(scrollableWnd, GWLP_ID, eFakeTrackPointScrollableID);
+
+ // Make FAKETRACKPOINTSCROLLABLE use nsWindow::WindowProc, and store the
+ // old window procedure in its "user data".
+ WNDPROC oldWndProc;
+ if (mUnicodeWidget)
+ oldWndProc = (WNDPROC)::SetWindowLongPtrW(scrollableWnd, GWLP_WNDPROC,
+ (LONG_PTR)nsWindow::WindowProc);
+ else
+ oldWndProc = (WNDPROC)::SetWindowLongPtrA(scrollableWnd, GWLP_WNDPROC,
+ (LONG_PTR)nsWindow::WindowProc);
+ ::SetWindowLongPtrW(scrollableWnd, GWLP_USERDATA, (LONG_PTR)oldWndProc);
+ }
+
+ SubclassWindow(TRUE);
+
+ // Starting with Windows XP, a process always runs within a terminal services
+ // session. In order to play nicely with RDP, fast user switching, and the
+ // lock screen, we should be handling WM_WTSSESSION_CHANGE. We must register
+ // our HWND in order to receive this message.
+ DebugOnly<BOOL> wtsRegistered = ::WTSRegisterSessionNotification(mWnd,
+ NOTIFY_FOR_THIS_SESSION);
+ NS_ASSERTION(wtsRegistered, "WTSRegisterSessionNotification failed!\n");
+
+ mDefaultIMC.Init(this);
+ 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 that has an actual titlebar
+ if (ShouldCacheTitleBarInfo(mWindowType, mBorderStyle)) {
+ nsUXThemeData::UpdateTitlebarInfo(mWnd);
+ }
+
+ return NS_OK;
+}
+
+// Close this nsWindow
+void nsWindow::Destroy()
+{
+ // WM_DESTROY has already fired, avoid calling it twice
+ if (mOnDestroyCalled)
+ return;
+
+ // 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;
+
+ // 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.
+ */
+ DestroyLayerManager();
+
+ /* 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();
+ }
+}
+
+/**************************************************************
+ *
+ * SECTION: Window class utilities
+ *
+ * Utilities for calculating the proper window class name for
+ * Create window.
+ *
+ **************************************************************/
+
+const wchar_t*
+nsWindow::RegisterWindowClass(const wchar_t* aClassName,
+ UINT aExtraStyle, LPWSTR aIconID) const
+{
+ WNDCLASSW wc;
+ if (::GetClassInfoW(nsToolkit::mDllInstance, aClassName, &wc)) {
+ // already registered
+ return aClassName;
+ }
+
+ wc.style = CS_DBLCLKS | aExtraStyle;
+ wc.lpfnWndProc = WinUtils::NonClientDpiScalingDefWindowProcW;
+ 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;
+
+ 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);
+ }
+ return aClassName;
+}
+
+static LPWSTR const gStockApplicationIcon = MAKEINTRESOURCEW(32512);
+
+// Return the proper window class for everything except popups.
+const wchar_t*
+nsWindow::GetWindowClass() const
+{
+ switch (mWindowType) {
+ case eWindowType_invisible:
+ return RegisterWindowClass(kClassNameHidden, 0, gStockApplicationIcon);
+ case eWindowType_dialog:
+ return RegisterWindowClass(kClassNameDialog, 0, 0);
+ default:
+ return RegisterWindowClass(GetMainWindowClass(), 0, gStockApplicationIcon);
+ }
+}
+
+// Return the proper popup window class
+const wchar_t*
+nsWindow::GetWindowPopupClass() const
+{
+ return RegisterWindowClass(kClassNameDropShadow,
+ 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_plugin_ipc_chrome:
+ case eWindowType_plugin_ipc_content:
+ 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_plugin_ipc_chrome:
+ case eWindowType_plugin_ipc_content:
+ 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)
+{
+ nsCOMPtr<nsIWidget> kungFuDeathGrip(this);
+ nsIWidget* parent = GetParent();
+ if (parent) {
+ parent->RemoveChild(this);
+ }
+
+ mParent = aNewParent;
+
+ 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;
+}
+
+void
+nsWindow::ReparentNativeWidget(nsIWidget* aNewParent)
+{
+ NS_PRECONDITION(aNewParent, "");
+
+ mParent = aNewParent;
+ if (mWindowType == eWindowType_popup) {
+ return;
+ }
+ 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);
+ }
+}
+
+nsIWidget* nsWindow::GetParent(void)
+{
+ return GetParentWindow(false);
+}
+
+static int32_t RoundDown(double aDouble)
+{
+ return aDouble > 0 ? static_cast<int32_t>(floor(aDouble)) :
+ static_cast<int32_t>(ceil(aDouble));
+}
+
+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()
+{
+ if (mDefaultScale <= 0.0) {
+ mDefaultScale = WinUtils::LogToPhysFactor(mWnd);
+ }
+ return mDefaultScale;
+}
+
+int32_t nsWindow::LogToPhys(double aValue)
+{
+ return WinUtils::LogToPhys(::MonitorFromWindow(mWnd,
+ MONITOR_DEFAULTTOPRIMARY),
+ aValue);
+}
+
+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);
+}
+
+static already_AddRefed<SourceSurface>
+CreateSourceSurfaceForGfxSurface(gfxASurface* aSurface)
+{
+ MOZ_ASSERT(aSurface);
+ return Factory::CreateSourceSurfaceForCairoSurface(
+ aSurface->CairoSurface(), aSurface->GetSize(),
+ aSurface->GetSurfaceFormat());
+}
+
+nsWindow::ScrollSnapshot*
+nsWindow::EnsureSnapshotSurface(ScrollSnapshot& aSnapshotData,
+ const mozilla::gfx::IntSize& aSize)
+{
+ // If the surface doesn't exist or is the wrong size then create new one.
+ if (!aSnapshotData.surface || aSnapshotData.surface->GetSize() != aSize) {
+ aSnapshotData.surface = new gfxWindowsSurface(aSize, kScrollCaptureFormat);
+ aSnapshotData.surfaceHasSnapshot = false;
+ }
+
+ return &aSnapshotData;
+}
+
+already_AddRefed<SourceSurface>
+nsWindow::CreateScrollSnapshot()
+{
+ RECT clip = { 0 };
+ int rgnType = ::GetWindowRgnBox(mWnd, &clip);
+ if (rgnType == RGN_ERROR) {
+ // We failed to get the clip assume that we need a full fallback.
+ clip.left = 0;
+ clip.top = 0;
+ clip.right = mBounds.width;
+ clip.bottom = mBounds.height;
+ return GetFallbackScrollSnapshot(clip);
+ }
+
+ // Check that the window is in a position to snapshot. We don't check for
+ // clipped width as that doesn't currently matter for APZ scrolling.
+ if (clip.top || clip.bottom != mBounds.height) {
+ return GetFallbackScrollSnapshot(clip);
+ }
+
+ HDC windowDC = ::GetDC(mWnd);
+ if (!windowDC) {
+ return GetFallbackScrollSnapshot(clip);
+ }
+ auto releaseDC = MakeScopeExit([&] {
+ ::ReleaseDC(mWnd, windowDC);
+ });
+
+ gfx::IntSize snapshotSize(mBounds.width, mBounds.height);
+ ScrollSnapshot* snapshot;
+ if (clip.left || clip.right != mBounds.width) {
+ // Can't do a full snapshot, so use the partial snapshot.
+ snapshot = EnsureSnapshotSurface(mPartialSnapshot, snapshotSize);
+ } else {
+ snapshot = EnsureSnapshotSurface(mFullSnapshot, snapshotSize);
+ }
+
+ // Note that we know that the clip is full height.
+ if (!::BitBlt(snapshot->surface->GetDC(), clip.left, 0, clip.right - clip.left,
+ clip.bottom, windowDC, clip.left, 0, SRCCOPY)) {
+ return GetFallbackScrollSnapshot(clip);
+ }
+ ::GdiFlush();
+ snapshot->surface->Flush();
+ snapshot->surfaceHasSnapshot = true;
+ snapshot->clip = clip;
+ mCurrentSnapshot = snapshot;
+
+ return CreateSourceSurfaceForGfxSurface(mCurrentSnapshot->surface);
+}
+
+already_AddRefed<SourceSurface>
+nsWindow::GetFallbackScrollSnapshot(const RECT& aRequiredClip)
+{
+ gfx::IntSize snapshotSize(mBounds.width, mBounds.height);
+
+ // If the current snapshot is the correct size and covers the required clip,
+ // just keep that by returning null.
+ // Note: we know the clip is always full height.
+ if (mCurrentSnapshot &&
+ mCurrentSnapshot->surface->GetSize() == snapshotSize &&
+ mCurrentSnapshot->clip.left <= aRequiredClip.left &&
+ mCurrentSnapshot->clip.right >= aRequiredClip.right) {
+ return nullptr;
+ }
+
+ // Otherwise we'll use the full snapshot, making sure it is big enough first.
+ mCurrentSnapshot = EnsureSnapshotSurface(mFullSnapshot, snapshotSize);
+
+ // If there is no snapshot, create a default.
+ if (!mCurrentSnapshot->surfaceHasSnapshot) {
+ gfx::SurfaceFormat format = mCurrentSnapshot->surface->GetSurfaceFormat();
+ RefPtr<DrawTarget> dt = Factory::CreateDrawTargetForCairoSurface(
+ mCurrentSnapshot->surface->CairoSurface(),
+ mCurrentSnapshot->surface->GetSize(), &format);
+
+ DefaultFillScrollCapture(dt);
+ }
+
+ return CreateSourceSurfaceForGfxSurface(mCurrentSnapshot->surface);
+}
+
+/**************************************************************
+ *
+ * SECTION: nsIWidget::Show
+ *
+ * Hide or show this component.
+ *
+ **************************************************************/
+
+NS_IMETHODIMP 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 {
+ ::ShowWindow(mWnd, SW_SHOWNOACTIVATE);
+ 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) {
+ if (mCompositorWidgetDelegate) {
+ mCompositorWidgetDelegate->ClearTransparentWindow();
+ }
+ }
+ 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: Touch and APZ-related functions
+ *
+ **************************************************************/
+
+void nsWindow::RegisterTouchWindow() {
+ mTouchWindow = true;
+ mGesture.RegisterTouchWindow(mWnd);
+ ::EnumChildWindows(mWnd, nsWindow::RegisterTouchForDescendants, 0);
+}
+
+BOOL CALLBACK nsWindow::RegisterTouchForDescendants(HWND aWnd, LPARAM aMsg) {
+ nsWindow* win = WinUtils::GetNSWindowPtr(aWnd);
+ if (win)
+ win->mGesture.RegisterTouchWindow(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);
+ }
+ ClientLayerManager *clientLayerManager = GetLayerManager()->AsClientLayerManager();
+
+ if (clientLayerManager) {
+ int32_t maxSize = clientLayerManager->GetMaxTextureSize();
+ // We can't make ThebesLayers bigger than this anyway.. no point it letting
+ // a window grow bigger as we won't be able to draw content there in
+ // general.
+ c.mMaxSize.width = std::min(c.mMaxSize.width, maxSize);
+ c.mMaxSize.height = std::min(c.mMaxSize.height, maxSize);
+ }
+
+ mSizeConstraintsScale = GetDefaultScale().scale;
+
+ nsBaseWidget::SetSizeConstraints(c);
+}
+
+const SizeConstraints
+nsWindow::GetSizeConstraints()
+{
+ double scale = GetDefaultScale().scale;
+ if (mSizeConstraintsScale == scale || mSizeConstraintsScale == 0.0) {
+ return mSizeConstraints;
+ }
+ scale /= mSizeConstraintsScale;
+ SizeConstraints c = mSizeConstraints;
+ if (c.mMinSize.width != NS_MAXSIZE) {
+ c.mMinSize.width = NSToIntRound(c.mMinSize.width * scale);
+ }
+ if (c.mMinSize.height != NS_MAXSIZE) {
+ c.mMinSize.height = NSToIntRound(c.mMinSize.height * scale);
+ }
+ if (c.mMaxSize.width != NS_MAXSIZE) {
+ c.mMaxSize.width = NSToIntRound(c.mMaxSize.width * scale);
+ }
+ if (c.mMaxSize.height != NS_MAXSIZE) {
+ c.mMaxSize.height = NSToIntRound(c.mMaxSize.height * scale);
+ }
+ return c;
+}
+
+// Move this component
+NS_IMETHODIMP nsWindow::Move(double aX, double aY)
+{
+ if (mWindowType == eWindowType_toplevel ||
+ mWindowType == eWindowType_dialog) {
+ SetSizeMode(nsSizeMode_Normal);
+ }
+
+ // for top-level windows only, convert coordinates from desktop pixels
+ // (the "parent" coordinate space) to the window's device pixel space
+ double scale = BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0;
+ int32_t x = NSToIntRound(aX * scale);
+ int32_t y = NSToIntRound(aY * 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) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("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 (IsPlugin() &&
+ (!mLayerManager || mLayerManager->GetBackendType() == LayersBackend::LAYERS_D3D9) &&
+ mClipRects &&
+ (mClipRectCount != 1 || !mClipRects[0].IsEqualInterior(LayoutDeviceIntRect(0, 0, mBounds.width, mBounds.height)))) {
+ flags |= SWP_NOCOPYBITS;
+ }
+ double oldScale = mDefaultScale;
+ mResizeState = IN_SIZEMOVE;
+ VERIFY(::SetWindowPos(mWnd, nullptr, x, y, 0, 0, flags));
+ mResizeState = NOT_RESIZING;
+ if (WinUtils::LogToPhysFactor(mWnd) != oldScale) {
+ ChangedDPI();
+ }
+
+ SetThemeRegion();
+ }
+ NotifyRollupGeometryChange();
+ return NS_OK;
+}
+
+// Resize this component
+NS_IMETHODIMP nsWindow::Resize(double aWidth, double aHeight, bool aRepaint)
+{
+ // for top-level windows only, convert coordinates from desktop pixels
+ // (the "parent" coordinate space) to the window's device pixel space
+ double scale = BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0;
+ int32_t width = NSToIntRound(aWidth * scale);
+ int32_t height = NSToIntRound(aHeight * 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;
+ }
+
+ // 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();
+ double oldScale = mDefaultScale;
+ VERIFY(::SetWindowPos(mWnd, nullptr, 0, 0,
+ width, GetHeight(height), flags));
+ if (WinUtils::LogToPhysFactor(mWnd) != oldScale) {
+ ChangedDPI();
+ }
+ SetThemeRegion();
+ }
+
+ if (aRepaint)
+ Invalidate();
+
+ NotifyRollupGeometryChange();
+ return NS_OK;
+}
+
+// Resize this component
+NS_IMETHODIMP nsWindow::Resize(double aX, double aY, double aWidth,
+ double aHeight, bool aRepaint)
+{
+ // for top-level windows only, convert coordinates from desktop pixels
+ // (the "parent" coordinate space) to the window's device pixel space
+ double scale = BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0;
+ int32_t x = NSToIntRound(aX * scale);
+ int32_t y = NSToIntRound(aY * scale);
+ int32_t width = NSToIntRound(aWidth * scale);
+ int32_t height = NSToIntRound(aHeight * 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;
+ }
+
+ // 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();
+ double oldScale = mDefaultScale;
+ VERIFY(::SetWindowPos(mWnd, nullptr, x, y,
+ width, GetHeight(height), flags));
+ if (WinUtils::LogToPhysFactor(mWnd) != oldScale) {
+ ChangedDPI();
+ }
+ if (mTransitionWnd) {
+ // If we have a fullscreen transition window, we need to make
+ // it topmost again, otherwise the taskbar may be raised by
+ // the system unexpectedly when we leave fullscreen state.
+ ::SetWindowPos(mTransitionWnd, HWND_TOPMOST, 0, 0, 0, 0,
+ SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+ // Every transition window is only used once.
+ mTransitionWnd = nullptr;
+ }
+ 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->mClass != eMouseEventClass) {
+ // 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->mRefPoint));
+
+ 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
+void
+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);
+}
+
+static UINT
+GetCurrentShowCmd(HWND aWnd)
+{
+ WINDOWPLACEMENT pl;
+ pl.length = sizeof(pl);
+ ::GetWindowPlacement(aWnd, &pl);
+ return pl.showCmd;
+}
+
+// Maximize, minimize or restore the window.
+void
+nsWindow::SetSizeMode(nsSizeMode aMode)
+{
+ // 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;
+
+ // save the requested state
+ mLastSizeMode = mSizeMode;
+ nsBaseWidget::SetSizeMode(aMode);
+ if (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;
+ }
+
+ // 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(!(GetCurrentShowCmd(mWnd) == 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);
+ }
+}
+
+// Constrain a potential move to fit onscreen
+// Position (aX, aY) is specified in Windows screen (logical) pixels,
+// except when using per-monitor DPI, in which case it's device pixels.
+void
+nsWindow::ConstrainPosition(bool aAllowSlop, int32_t *aX, int32_t *aY)
+{
+ if (!mIsTopWidgetWindow) // only a problem for top-level windows
+ return;
+
+ double dpiScale = GetDesktopToDeviceScale().scale;
+
+ // We need to use the window size in the kind of pixels used for window-
+ // manipulation APIs.
+ int32_t logWidth = std::max<int32_t>(NSToIntRound(mBounds.width / dpiScale), 1);
+ int32_t logHeight = std::max<int32_t>(NSToIntRound(mBounds.height / dpiScale), 1);
+
+ /* 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) {
+ return;
+ }
+ nsCOMPtr<nsIScreen> screen;
+ int32_t left, top, width, height;
+
+ screenmgr->ScreenForRect(*aX, *aY, logWidth, logHeight,
+ getter_AddRefs(screen));
+ if (mSizeMode != nsSizeMode_Fullscreen) {
+ // For normalized windows, use the desktop work area.
+ nsresult rv = screen->GetAvailRectDisplayPix(&left, &top, &width, &height);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ } else {
+ // For full screen windows, use the desktop.
+ nsresult rv = screen->GetRectDisplayPix(&left, &top, &width, &height);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+ }
+ screenRect.left = left;
+ screenRect.right = left + width;
+ screenRect.top = top;
+ screenRect.bottom = top + height;
+
+ 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;
+ }
+}
+
+/**************************************************************
+ *
+ * SECTION: nsIWidget::Enable, nsIWidget::IsEnabled
+ *
+ * Enabling and disabling the widget.
+ *
+ **************************************************************/
+
+// Enable/disable this component
+NS_IMETHODIMP 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_IMETHODIMP nsWindow::SetFocus(bool aRaise)
+{
+ if (mWnd) {
+#ifdef WINSTATE_DEBUG_OUTPUT
+ if (mWnd == WinUtils::GetTopLevelHWND(mWnd)) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("*** SetFocus: [ top] raise=%d\n", aRaise));
+ } else {
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("*** 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,
+ * GetRestoredBounds, GetClientOffset
+ * SetDrawsInTitlebar, 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.
+LayoutDeviceIntRect
+nsWindow::GetBounds()
+{
+ if (!mWnd) {
+ return mBounds;
+ }
+
+ RECT r;
+ VERIFY(::GetWindowRect(mWnd, &r));
+
+ LayoutDeviceIntRect rect;
+
+ // assign size
+ rect.width = r.right - r.left;
+ rect.height = r.bottom - r.top;
+
+ // popup window bounds' are in screen coordinates, not relative to parent
+ // window
+ if (mWindowType == eWindowType_popup) {
+ rect.x = r.left;
+ rect.y = r.top;
+ return rect;
+ }
+
+ // 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()) {
+ LayoutDeviceIntPoint clientOffset = pWidget->GetClientOffset();
+ r.left -= clientOffset.x;
+ r.top -= clientOffset.y;
+ }
+ }
+ rect.x = r.left;
+ rect.y = r.top;
+ return rect;
+}
+
+// Get this component dimension
+LayoutDeviceIntRect
+nsWindow::GetClientBounds()
+{
+ if (!mWnd) {
+ return LayoutDeviceIntRect(0, 0, 0, 0);
+ }
+
+ RECT r;
+ VERIFY(::GetClientRect(mWnd, &r));
+
+ LayoutDeviceIntRect bounds = GetBounds();
+ LayoutDeviceIntRect rect;
+ rect.MoveTo(bounds.TopLeft() + GetClientOffset());
+ rect.width = r.right - r.left;
+ rect.height = r.bottom - r.top;
+ return rect;
+}
+
+// Like GetBounds, but don't offset by the parent
+LayoutDeviceIntRect
+nsWindow::GetScreenBounds()
+{
+ if (!mWnd) {
+ return mBounds;
+ }
+
+ RECT r;
+ VERIFY(::GetWindowRect(mWnd, &r));
+
+ LayoutDeviceIntRect rect;
+ rect.x = r.left;
+ rect.y = r.top;
+ rect.width = r.right - r.left;
+ rect.height = r.bottom - r.top;
+ return rect;
+}
+
+nsresult
+nsWindow::GetRestoredBounds(LayoutDeviceIntRect &aRect)
+{
+ if (SizeMode() == nsSizeMode_Normal) {
+ aRect = GetScreenBounds();
+ return NS_OK;
+ }
+ if (!mWnd) {
+ return NS_ERROR_FAILURE;
+ }
+
+ WINDOWPLACEMENT pl = { sizeof(WINDOWPLACEMENT) };
+ VERIFY(::GetWindowPlacement(mWnd, &pl));
+ const RECT& r = pl.rcNormalPosition;
+
+ HMONITOR monitor = ::MonitorFromWindow(mWnd, MONITOR_DEFAULTTONULL);
+ if (!monitor) {
+ return NS_ERROR_FAILURE;
+ }
+ MONITORINFO mi = { sizeof(MONITORINFO) };
+ VERIFY(::GetMonitorInfo(monitor, &mi));
+
+ aRect.SetRect(r.left, r.top, r.right - r.left, r.bottom - r.top);
+ aRect.MoveBy(mi.rcWork.left - mi.rcMonitor.left,
+ mi.rcWork.top - mi.rcMonitor.top);
+ 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).
+LayoutDeviceIntPoint
+nsWindow::GetClientOffset()
+{
+ if (!mWnd) {
+ return LayoutDeviceIntPoint(0, 0);
+ }
+
+ RECT r1;
+ GetWindowRect(mWnd, &r1);
+ LayoutDeviceIntPoint pt = WidgetToScreenOffset();
+ return LayoutDeviceIntPoint(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
+ LayoutDeviceIntMargin margins(0, -1, -1, -1);
+ SetNonClientMargins(margins);
+ }
+ else {
+ LayoutDeviceIntMargin margins(-1, -1, -1, -1);
+ SetNonClientMargins(margins);
+ }
+}
+
+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_PTR>(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(LayoutDeviceIntMargin &margins)
+{
+ if (!mIsTopWidgetWindow ||
+ mBorderStyle == eBorderStyle_none)
+ return NS_ERROR_INVALID_ARG;
+
+ if (mHideChrome) {
+ mFutureMarginsOnceChromeShows = margins;
+ mFutureMarginsToUse = true;
+ return NS_OK;
+ }
+ mFutureMarginsToUse = false;
+
+ // 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_IMETHODIMP 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;
+ double scale = GetDefaultScale().scale;
+ IntSize size = RoundedToInt(Size(width * scale, height * scale));
+ 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);
+}
+
+void nsWindow::UpdateOpaqueRegion(const LayoutDeviceIntRegion& 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()) {
+ LayoutDeviceIntRect pluginBounds;
+ for (nsIWidget* child = GetFirstChild(); child; child = child->GetNextSibling()) {
+ if (child->IsPlugin()) {
+ // Collect the bounds of all plugins for GetLargestRectangle.
+ LayoutDeviceIntRect childBounds = child->GetBounds();
+ pluginBounds.UnionRect(pluginBounds, childBounds);
+ }
+ }
+
+ LayoutDeviceIntRect clientBounds = GetClientBounds();
+
+ // Find the largest rectangle and use that to calculate the inset. Our top
+ // priority is to include the bounds of all plugins.
+ LayoutDeviceIntRect 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();
+ }
+}
+
+/**************************************************************
+*
+* SECTION: nsIWidget::UpdateWindowDraggingRegion
+*
+* For setting the draggable titlebar region from CSS
+* with -moz-window-dragging: drag.
+*
+**************************************************************/
+
+void
+nsWindow::UpdateWindowDraggingRegion(const LayoutDeviceIntRegion& aRegion)
+{
+ if (mDraggableRegion != aRegion) {
+ mDraggableRegion = aRegion;
+ }
+}
+
+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;
+ default:
+ break;
+ }
+
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("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;
+ if (mFutureMarginsToUse) {
+ SetNonClientMargins(mFutureMarginsOnceChromeShows);
+ }
+ }
+
+ 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_IMETHODIMP nsWindow::Invalidate(bool aEraseBackground,
+ bool aUpdateNCArea,
+ bool aIncludeChildren)
+{
+ if (!mWnd) {
+ return NS_OK;
+ }
+
+#ifdef WIDGET_DEBUG_OUTPUT
+ debug_DumpInvalidate(stdout,
+ this,
+ nullptr,
+ "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_IMETHODIMP nsWindow::Invalidate(const LayoutDeviceIntRect& aRect)
+{
+ if (mWnd) {
+#ifdef WIDGET_DEBUG_OUTPUT
+ debug_DumpInvalidate(stdout,
+ this,
+ &aRect,
+ "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;
+}
+
+static LRESULT CALLBACK
+FullscreenTransitionWindowProc(HWND hWnd, UINT uMsg,
+ WPARAM wParam, LPARAM lParam)
+{
+ switch (uMsg) {
+ case WM_FULLSCREEN_TRANSITION_BEFORE:
+ case WM_FULLSCREEN_TRANSITION_AFTER: {
+ DWORD duration = (DWORD)lParam;
+ DWORD flags = AW_BLEND;
+ if (uMsg == WM_FULLSCREEN_TRANSITION_AFTER) {
+ flags |= AW_HIDE;
+ }
+ ::AnimateWindow(hWnd, duration, flags);
+ // The message sender should have added ref for us.
+ NS_DispatchToMainThread(
+ already_AddRefed<nsIRunnable>((nsIRunnable*)wParam));
+ break;
+ }
+ case WM_DESTROY:
+ ::PostQuitMessage(0);
+ break;
+ default:
+ return ::DefWindowProcW(hWnd, uMsg, wParam, lParam);
+ }
+ return 0;
+}
+
+struct FullscreenTransitionInitData
+{
+ nsIntRect mBounds;
+ HANDLE mSemaphore;
+ HANDLE mThread;
+ HWND mWnd;
+
+ FullscreenTransitionInitData()
+ : mSemaphore(nullptr)
+ , mThread(nullptr)
+ , mWnd(nullptr) { }
+
+ ~FullscreenTransitionInitData()
+ {
+ if (mSemaphore) {
+ ::CloseHandle(mSemaphore);
+ }
+ if (mThread) {
+ ::CloseHandle(mThread);
+ }
+ }
+};
+
+static DWORD WINAPI
+FullscreenTransitionThreadProc(LPVOID lpParam)
+{
+ // Initialize window class
+ static bool sInitialized = false;
+ if (!sInitialized) {
+ WNDCLASSW wc = {};
+ wc.lpfnWndProc = ::FullscreenTransitionWindowProc;
+ wc.hInstance = nsToolkit::mDllInstance;
+ wc.hbrBackground = ::CreateSolidBrush(RGB(0, 0, 0));
+ wc.lpszClassName = kClassNameTransition;
+ ::RegisterClassW(&wc);
+ sInitialized = true;
+ }
+
+ auto data = static_cast<FullscreenTransitionInitData*>(lpParam);
+ HWND wnd = ::CreateWindowW(
+ kClassNameTransition, L"", 0, 0, 0, 0, 0,
+ nullptr, nullptr, nsToolkit::mDllInstance, nullptr);
+ if (!wnd) {
+ ::ReleaseSemaphore(data->mSemaphore, 1, nullptr);
+ return 0;
+ }
+
+ // Since AnimateWindow blocks the thread of the transition window,
+ // we need to hide the cursor for that window, otherwise the system
+ // would show the busy pointer to the user.
+ ::ShowCursor(false);
+ ::SetWindowLongW(wnd, GWL_STYLE, 0);
+ ::SetWindowLongW(wnd, GWL_EXSTYLE, WS_EX_LAYERED |
+ WS_EX_TRANSPARENT | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE);
+ ::SetWindowPos(wnd, HWND_TOPMOST, data->mBounds.x, data->mBounds.y,
+ data->mBounds.width, data->mBounds.height, 0);
+ data->mWnd = wnd;
+ ::ReleaseSemaphore(data->mSemaphore, 1, nullptr);
+ // The initialization data may no longer be valid
+ // after we release the semaphore.
+ data = nullptr;
+
+ MSG msg;
+ while (::GetMessageW(&msg, nullptr, 0, 0)) {
+ ::TranslateMessage(&msg);
+ ::DispatchMessage(&msg);
+ }
+ ::ShowCursor(true);
+ ::DestroyWindow(wnd);
+ return 0;
+}
+
+class FullscreenTransitionData final : public nsISupports
+{
+public:
+ NS_DECL_ISUPPORTS
+
+ explicit FullscreenTransitionData(HWND aWnd)
+ : mWnd(aWnd)
+ {
+ MOZ_ASSERT(NS_IsMainThread(), "FullscreenTransitionData "
+ "should be constructed in the main thread");
+ }
+
+ const HWND mWnd;
+
+private:
+ ~FullscreenTransitionData()
+ {
+ MOZ_ASSERT(NS_IsMainThread(), "FullscreenTransitionData "
+ "should be deconstructed in the main thread");
+ ::PostMessageW(mWnd, WM_DESTROY, 0, 0);
+ }
+};
+
+NS_IMPL_ISUPPORTS0(FullscreenTransitionData)
+
+/* virtual */ bool
+nsWindow::PrepareForFullscreenTransition(nsISupports** aData)
+{
+ // We don't support fullscreen transition when composition is not
+ // enabled, which could make the transition broken and annoying.
+ // See bug 1184201.
+ if (!nsUXThemeData::CheckForCompositor()) {
+ return false;
+ }
+
+ FullscreenTransitionInitData initData;
+ nsCOMPtr<nsIScreen> screen = GetWidgetScreen();
+ int32_t x, y, width, height;
+ screen->GetRectDisplayPix(&x, &y, &width, &height);
+ MOZ_ASSERT(BoundsUseDesktopPixels(),
+ "Should only be called on top-level window");
+ double scale = GetDesktopToDeviceScale().scale; // XXX or GetDefaultScale() ?
+ initData.mBounds.x = NSToIntRound(x * scale);
+ initData.mBounds.y = NSToIntRound(y * scale);
+ initData.mBounds.width = NSToIntRound(width * scale);
+ initData.mBounds.height = NSToIntRound(height * scale);
+
+ // Create a semaphore for synchronizing the window handle which will
+ // be created by the transition thread and used by the main thread for
+ // posting the transition messages.
+ initData.mSemaphore = ::CreateSemaphore(nullptr, 0, 1, nullptr);
+ if (initData.mSemaphore) {
+ initData.mThread = ::CreateThread(
+ nullptr, 0, FullscreenTransitionThreadProc, &initData, 0, nullptr);
+ if (initData.mThread) {
+ ::WaitForSingleObject(initData.mSemaphore, INFINITE);
+ }
+ }
+ if (!initData.mWnd) {
+ return false;
+ }
+
+ mTransitionWnd = initData.mWnd;
+ auto data = new FullscreenTransitionData(initData.mWnd);
+ *aData = data;
+ NS_ADDREF(data);
+ return true;
+}
+
+/* virtual */ void
+nsWindow::PerformFullscreenTransition(FullscreenTransitionStage aStage,
+ uint16_t aDuration, nsISupports* aData,
+ nsIRunnable* aCallback)
+{
+ auto data = static_cast<FullscreenTransitionData*>(aData);
+ nsCOMPtr<nsIRunnable> callback = aCallback;
+ UINT msg = aStage == eBeforeFullscreenToggle ?
+ WM_FULLSCREEN_TRANSITION_BEFORE : WM_FULLSCREEN_TRANSITION_AFTER;
+ WPARAM wparam = (WPARAM)callback.forget().take();
+ ::PostMessage(data->mWnd, msg, wparam, (LPARAM)aDuration);
+}
+
+nsresult
+nsWindow::MakeFullScreen(bool aFullScreen, nsIScreen* aTargetScreen)
+{
+ // 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 {
+ if (mSizeMode != nsSizeMode_Fullscreen)
+ return NS_OK;
+ SetSizeMode(mOldSizeMode);
+ }
+
+ // If we are going fullscreen, the window size continues to change
+ // and the window will be reflow again then.
+ UpdateNonClientMargins(mSizeMode, /* Reflow */ !aFullScreen);
+
+ // Will call hide chrome, reposition window. Note this will
+ // also cache dimensions for restoration, so it should only
+ // be called once per fullscreen request.
+ nsBaseWidget::InfallibleMakeFullScreen(aFullScreen, aTargetScreen);
+
+ if (mIsVisible && !aFullScreen && mOldSizeMode == nsSizeMode_Normal) {
+ // Ensure the window exiting fullscreen get activated. Window
+ // activation might be bypassed in SetSizeMode.
+ DispatchFocusToTopLevelWindow(true);
+ }
+
+ // Notify the taskbar that we have exited full screen mode.
+ if (!aFullScreen && taskbarInfo) {
+ taskbarInfo->PrepareFullScreenHWND(mWnd, FALSE);
+ }
+
+ if (mWidgetListener) {
+ mWidgetListener->SizeModeChanged(mSizeMode);
+ mWidgetListener->FullscreenChanged(aFullScreen);
+ }
+
+ // Send a eMouseEnterIntoWidget event since Windows has already sent
+ // a WM_MOUSELEAVE that caused us to send a eMouseExitFromWidget event.
+ if (aFullScreen && !sCurrentWindow) {
+ sCurrentWindow = this;
+ LPARAM pos = sCurrentWindow->lParamToClient(sMouseExitlParamScreen);
+ sCurrentWindow->DispatchMouseEvent(eMouseEnterIntoWidget,
+ sMouseExitwParam, pos, false,
+ WidgetMouseEvent::eLeftButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ }
+
+ return NS_OK;
+}
+
+/**************************************************************
+ *
+ * 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)
+{
+ switch (aDataType) {
+ case NS_NATIVE_TMP_WINDOW:
+ return (void*)::CreateWindowExW(mIsRTL ? WS_EX_LAYOUTRTL : 0,
+ GetWindowClass(),
+ L"",
+ WS_CHILD,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ CW_USEDEFAULT,
+ mWnd,
+ nullptr,
+ nsToolkit::mDllInstance,
+ nullptr);
+ case NS_NATIVE_PLUGIN_ID:
+ case NS_NATIVE_PLUGIN_PORT:
+ case NS_NATIVE_WIDGET:
+ case NS_NATIVE_WINDOW:
+ return (void*)mWnd;
+ case NS_NATIVE_SHAREABLE_WINDOW:
+ return (void*) WinUtils::GetTopLevelHWND(mWnd);
+ case NS_NATIVE_GRAPHIC:
+ MOZ_ASSERT_UNREACHABLE("Not supported on Windows:");
+ return nullptr;
+ case NS_RAW_NATIVE_IME_CONTEXT: {
+ void* pseudoIMEContext = GetPseudoIMEContext();
+ if (pseudoIMEContext) {
+ return pseudoIMEContext;
+ }
+ MOZ_FALLTHROUGH;
+ }
+ case NS_NATIVE_TSF_THREAD_MGR:
+ case NS_NATIVE_TSF_CATEGORY_MGR:
+ case NS_NATIVE_TSF_DISPLAY_ATTR_MGR:
+ return IMEHandler::GetNativeData(this, aDataType);
+
+ default:
+ break;
+ }
+
+ return nullptr;
+}
+
+static void
+SetChildStyleAndParent(HWND aChildWindow, HWND aParentWindow)
+{
+ // Make sure the window is styled to be a child window.
+ LONG_PTR style = GetWindowLongPtr(aChildWindow, GWL_STYLE);
+ style |= WS_CHILD;
+ style &= ~WS_POPUP;
+ SetWindowLongPtr(aChildWindow, GWL_STYLE, style);
+
+ // Do the reparenting. Note that this call will probably cause a sync native
+ // message to the process that owns the child window.
+ ::SetParent(aChildWindow, aParentWindow);
+}
+
+void
+nsWindow::SetNativeData(uint32_t aDataType, uintptr_t aVal)
+{
+ switch (aDataType) {
+ case NS_NATIVE_CHILD_WINDOW:
+ SetChildStyleAndParent(reinterpret_cast<HWND>(aVal), mWnd);
+ break;
+ case NS_NATIVE_CHILD_OF_SHAREABLE_WINDOW:
+ SetChildStyleAndParent(reinterpret_cast<HWND>(aVal),
+ WinUtils::GetTopLevelHWND(mWnd));
+ break;
+ default:
+ NS_ERROR("SetNativeData called with unsupported data type.");
+ }
+}
+
+// Free some native data according to aDataType
+void nsWindow::FreeNativeData(void * data, uint32_t aDataType)
+{
+ switch (aDataType)
+ {
+ case NS_NATIVE_GRAPHIC:
+ 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_IMETHODIMP nsWindow::SetTitle(const nsAString& aTitle)
+{
+ const nsString& strTitle = PromiseFlatString(aTitle);
+ AutoRestore<bool> sendingText(mSendingSetText);
+ mSendingSetText = true;
+ ::SendMessageW(mWnd, WM_SETTEXT, (WPARAM)0, (LPARAM)(LPCWSTR)strTitle.get());
+ return NS_OK;
+}
+
+/**************************************************************
+ *
+ * SECTION: nsIWidget::SetIcon
+ *
+ * Set the main windows icon.
+ *
+ **************************************************************/
+
+NS_IMETHODIMP 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);
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("\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);
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("\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.
+ *
+ **************************************************************/
+
+LayoutDeviceIntPoint nsWindow::WidgetToScreenOffset()
+{
+ POINT point;
+ point.x = 0;
+ point.y = 0;
+ ::ClientToScreen(mWnd, &point);
+ return LayoutDeviceIntPoint(point.x, point.y);
+}
+
+LayoutDeviceIntSize
+nsWindow::ClientToWindowSize(const LayoutDeviceIntSize& 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 LayoutDeviceIntSize(r.right - r.left, r.bottom - r.top);
+}
+
+/**************************************************************
+ *
+ * SECTION: nsIWidget::EnableDragDrop
+ *
+ * Enables/Disables drag and drop of files on this widget.
+ *
+ **************************************************************/
+
+void
+nsWindow::EnableDragDrop(bool aEnable)
+{
+ NS_ASSERTION(mWnd, "nsWindow::EnableDragDrop() called after Destroy()");
+
+ nsresult rv = NS_ERROR_FAILURE;
+ if (aEnable) {
+ if (!mNativeDragTarget) {
+ mNativeDragTarget = new nsNativeDragTarget(this);
+ mNativeDragTarget->AddRef();
+ if (SUCCEEDED(::CoLockObjectExternal((LPUNKNOWN)mNativeDragTarget,
+ TRUE, FALSE))) {
+ ::RegisterDragDrop(mWnd, (LPDROPTARGET)mNativeDragTarget);
+ }
+ }
+ } else {
+ if (mWnd && mNativeDragTarget) {
+ ::RevokeDragDrop(mWnd);
+ ::CoLockObjectExternal((LPUNKNOWN)mNativeDragTarget, FALSE, TRUE);
+ mNativeDragTarget->DragCancel();
+ NS_RELEASE(mNativeDragTarget);
+ }
+ }
+}
+
+/**************************************************************
+ *
+ * SECTION: nsIWidget::CaptureMouse
+ *
+ * Enables/Disables system mouse capture.
+ *
+ **************************************************************/
+
+void nsWindow::CaptureMouse(bool aCapture)
+{
+ TRACKMOUSEEVENT mTrack;
+ mTrack.cbSize = sizeof(TRACKMOUSEEVENT);
+ mTrack.dwHoverTime = 0;
+ mTrack.hwndTrack = mWnd;
+ if (aCapture) {
+ mTrack.dwFlags = TME_CANCEL | TME_LEAVE;
+ ::SetCapture(mWnd);
+ } else {
+ mTrack.dwFlags = TME_LEAVE;
+ ::ReleaseCapture();
+ }
+ sIsInMouseCapture = aCapture;
+ TrackMouseEvent(&mTrack);
+}
+
+/**************************************************************
+ *
+ * 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.
+ *
+ **************************************************************/
+
+void
+nsWindow::CaptureRollupEvents(nsIRollupListener* aListener, bool aDoCapture)
+{
+ if (aDoCapture) {
+ gRollupListener = aListener;
+ if (!sMsgFilterHook && !sCallProcHook && !sCallMouseHook) {
+ RegisterSpecialDropdownHooks();
+ }
+ sProcessHook = true;
+ } else {
+ gRollupListener = nullptr;
+ sProcessHook = false;
+ UnregisterSpecialDropdownHooks();
+ }
+}
+
+/**************************************************************
+ *
+ * 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.
+ *
+ **************************************************************/
+
+LayerManager*
+nsWindow::GetLayerManager(PLayerTransactionChild* aShadowManager,
+ LayersBackend aBackendHint,
+ LayerManagerPersistence aPersistence)
+{
+ RECT windowRect;
+ ::GetClientRect(mWnd, &windowRect);
+
+ // Try OMTC first.
+ if (!mLayerManager && ShouldUseOffMainThreadCompositing()) {
+ gfxWindowsPlatform::GetPlatform()->UpdateRenderMode();
+
+ // 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) {
+ MOZ_ASSERT(!mCompositorSession && !mCompositorBridgeChild);
+ MOZ_ASSERT(!mCompositorWidgetDelegate);
+
+ // Ensure we have a widget proxy even if we're not using the compositor,
+ // since all our transparent window handling lives there.
+ CompositorWidgetInitData initData(
+ reinterpret_cast<uintptr_t>(mWnd),
+ reinterpret_cast<uintptr_t>(static_cast<nsIWidget*>(this)),
+ mTransparencyMode);
+ mBasicLayersSurface = new InProcessWinCompositorWidget(initData, this);
+ mCompositorWidgetDelegate = mBasicLayersSurface;
+ mLayerManager = CreateBasicLayerManager();
+ }
+
+ NS_ASSERTION(mLayerManager, "Couldn't provide a valid layer manager.");
+
+ return mLayerManager;
+}
+
+/**************************************************************
+ *
+ * SECTION: nsIWidget::OnDefaultButtonLoaded
+ *
+ * Called after the dialog is loaded and it has a default button.
+ *
+ **************************************************************/
+
+NS_IMETHODIMP
+nsWindow::OnDefaultButtonLoaded(const LayoutDeviceIntRect& 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;
+ }
+
+ LayoutDeviceIntRect widgetRect = GetScreenBounds();
+ LayoutDeviceIntRect buttonRect(aButtonRect + widgetRect.TopLeft());
+
+ LayoutDeviceIntPoint 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;
+}
+
+void
+nsWindow::UpdateThemeGeometries(const nsTArray<ThemeGeometry>& aThemeGeometries)
+{
+ RefPtr<LayerManager> layerManager = GetLayerManager();
+ if (!layerManager) {
+ return;
+ }
+
+ nsIntRegion clearRegion;
+ if (!HasGlass() || !nsUXThemeData::CheckForCompositor()) {
+ // Make sure and clear old regions we've set previously. Note HasGlass can be false
+ // for glass desktops if the window we are rendering to doesn't make use of glass
+ // (e.g. fullscreen browsing).
+ layerManager->SetRegionToClear(clearRegion);
+ return;
+ }
+
+ // On Win10, force show the top border:
+ if (IsWin10OrLater() && mCustomNonClient && mSizeMode == nsSizeMode_Normal) {
+ RECT rect;
+ ::GetWindowRect(mWnd, &rect);
+ // We want 1 pixel of border for every whole 100% of scaling
+ double borderSize = std::min(1, RoundDown(GetDesktopToDeviceScale().scale));
+ clearRegion.Or(clearRegion, gfx::IntRect::Truncate(0, 0, rect.right - rect.left, borderSize));
+ }
+
+ if (!IsWin10OrLater()) {
+ for (size_t i = 0; i < aThemeGeometries.Length(); i++) {
+ if (aThemeGeometries[i].mType == nsNativeThemeWin::eThemeGeometryTypeWindowButtons) {
+ LayoutDeviceIntRect bounds = aThemeGeometries[i].mRect;
+ clearRegion.Or(clearRegion, gfx::IntRect::Truncate(bounds.X(), bounds.Y(), bounds.Width(), bounds.Height() - 2.0));
+ clearRegion.Or(clearRegion, gfx::IntRect::Truncate(bounds.X() + 1.0, bounds.YMost() - 2.0, bounds.Width() - 1.0, 1.0));
+ clearRegion.Or(clearRegion, gfx::IntRect::Truncate(bounds.X() + 2.0, bounds.YMost() - 1.0, bounds.Width() - 3.0, 1.0));
+ }
+ }
+ }
+
+ layerManager->SetRegionToClear(clearRegion);
+}
+
+uint32_t
+nsWindow::GetMaxTouchPoints() const
+{
+ return WinUtils::GetMaxTouchPoints();
+}
+
+/**************************************************************
+ **************************************************************
+ **
+ ** BLOCK: Moz Events
+ **
+ ** Moz GUI event management.
+ **
+ **************************************************************
+ **************************************************************/
+
+/**************************************************************
+ *
+ * SECTION: Mozilla event initialization
+ *
+ * Helpers for initializing moz events.
+ *
+ **************************************************************/
+
+// Event initialization
+void nsWindow::InitEvent(WidgetGUIEvent& event, LayoutDeviceIntPoint* 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.mRefPoint = LayoutDeviceIntPoint(cpos.x, cpos.y);
+ } else {
+ event.mRefPoint = LayoutDeviceIntPoint(0, 0);
+ }
+ } else {
+ // use the point override if provided
+ event.mRefPoint = *aPoint;
+ }
+
+ event.AssignEventTime(CurrentMessageWidgetEventTime());
+}
+
+WidgetEventTime
+nsWindow::CurrentMessageWidgetEventTime() const
+{
+ LONG messageTime = ::GetMessageTime();
+ return WidgetEventTime(messageTime, GetMessageTimeStamp(messageTime));
+}
+
+/**************************************************************
+ *
+ * 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->mWidget,
+ event,
+ "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(EventMessage aMsg)
+{
+ WidgetGUIEvent event(true, aMsg, this);
+ InitEvent(event);
+
+ bool result = DispatchWindowEvent(&event);
+ return result;
+}
+
+bool nsWindow::DispatchKeyboardEvent(WidgetKeyboardEvent* event)
+{
+ nsEventStatus status = DispatchInputEvent(event);
+ return ConvertStatus(status);
+}
+
+bool nsWindow::DispatchContentCommandEvent(WidgetContentCommandEvent* aEvent)
+{
+ nsEventStatus status;
+ DispatchEvent(aEvent, status);
+ return ConvertStatus(status);
+}
+
+bool nsWindow::DispatchWheelEvent(WidgetWheelEvent* aEvent)
+{
+ nsEventStatus status = DispatchInputEvent(aEvent->AsInputEvent());
+ 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(EventMessage aEventMessage, WPARAM wParam,
+ LPARAM lParam, bool aIsContextMenuKey,
+ int16_t aButton, uint16_t aInputSource,
+ uint16_t aPointerId)
+{
+ bool result = false;
+
+ UserActivity();
+
+ if (!mWidgetListener) {
+ return result;
+ }
+
+ LayoutDeviceIntPoint eventPoint(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam));
+ LayoutDeviceIntPoint mpScreen = eventPoint + WidgetToScreenOffset();
+
+ // Suppress mouse moves caused by widget creation. Make sure to do this early
+ // so that we update sLastMouseMovePoint even for touch-induced mousemove events.
+ if (aEventMessage == eMouseMove) {
+ if ((sLastMouseMovePoint.x == mpScreen.x) && (sLastMouseMovePoint.y == mpScreen.y)) {
+ return result;
+ }
+ sLastMouseMovePoint.x = mpScreen.x;
+ sLastMouseMovePoint.y = mpScreen.y;
+ }
+
+ if (WinUtils::GetIsMouseFromTouch(aEventMessage)) {
+ if (aEventMessage == eMouseDown) {
+ Telemetry::Accumulate(Telemetry::FX_TOUCH_USED, 1);
+ }
+
+ if (mTouchWindow) {
+ // If mTouchWindow is true, then we must have APZ enabled and be
+ // feeding it raw touch events. In that case we don't need to
+ // send touch-generated mouse events to content. The only exception is
+ // the touch-generated mouse double-click, which is used to start off the
+ // touch-based drag-and-drop gesture.
+ MOZ_ASSERT(mAPZC);
+ if (aEventMessage == eMouseDoubleClick) {
+ aEventMessage = eMouseTouchDrag;
+ } else {
+ return result;
+ }
+ }
+ }
+
+ // Since it is unclear whether a user will use the digitizer,
+ // Postpone initialization until first PEN message will be found.
+ if (nsIDOMMouseEvent::MOZ_SOURCE_PEN == aInputSource
+ // Messages should be only at topLevel window.
+ && nsWindowType::eWindowType_toplevel == mWindowType
+ // Currently this scheme is used only when pointer events is enabled.
+ && gfxPrefs::PointerEventsEnabled()) {
+ InkCollector::sInkCollector->SetTarget(mWnd);
+ InkCollector::sInkCollector->SetPointerId(aPointerId);
+ }
+
+ switch (aEventMessage) {
+ case eMouseDown:
+ CaptureMouse(true);
+ break;
+
+ // eMouseMove and eMouseExitFromWidget 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 eMouseUp:
+ case eMouseMove:
+ case eMouseExitFromWidget:
+ if (!(wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) && sIsInMouseCapture)
+ CaptureMouse(false);
+ break;
+
+ default:
+ break;
+
+ } // switch
+
+ WidgetMouseEvent event(true, aEventMessage, this, WidgetMouseEvent::eReal,
+ aIsContextMenuKey ? WidgetMouseEvent::eContextMenuKey :
+ WidgetMouseEvent::eNormal);
+ if (aEventMessage == eContextMenu && aIsContextMenuKey) {
+ LayoutDeviceIntPoint zero(0, 0);
+ InitEvent(event, &zero);
+ } else {
+ InitEvent(event, &eventPoint);
+ }
+
+ ModifierKeyState modifierKeyState;
+ modifierKeyState.InitInputEvent(event);
+ event.button = aButton;
+ event.inputSource = aInputSource;
+ event.pointerId = aPointerId;
+ // If we get here the mouse events must be from non-touch sources, so
+ // convert it to pointer events as well
+ event.convertToPointer = true;
+
+ 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();
+
+ switch (aEventMessage) {
+ case eMouseDoubleClick:
+ event.mMessage = eMouseDown;
+ event.button = aButton;
+ sLastClickCount = 2;
+ sLastMouseDownTime = curMsgTime;
+ break;
+ case eMouseUp:
+ // remember when this happened for the next mouse down
+ sLastMousePoint.x = eventPoint.x;
+ sLastMousePoint.y = eventPoint.y;
+ sLastMouseButton = eventButton;
+ break;
+ case eMouseDown:
+ // 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;
+ break;
+ case eMouseMove:
+ if (!insideMovementThreshold) {
+ sLastClickCount = 0;
+ }
+ break;
+ case eMouseExitFromWidget:
+ event.mExitFrom =
+ IsTopLevelMouseExit(mWnd) ? WidgetMouseEvent::eTopLevel :
+ WidgetMouseEvent::eChild;
+ break;
+ default:
+ break;
+ }
+ event.mClickCount = sLastClickCount;
+
+#ifdef NS_DEBUG_XX
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("Msg Time: %d Click Count: %d\n", curMsgTime, event.mClickCount));
+#endif
+
+ NPEvent pluginEvent;
+
+ switch (aEventMessage) {
+ case eMouseDown:
+ 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 eMouseUp:
+ 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 eMouseDoubleClick:
+ 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 eMouseMove:
+ pluginEvent.event = WM_MOUSEMOVE;
+ break;
+ case eMouseExitFromWidget:
+ pluginEvent.event = WM_MOUSELEAVE;
+ break;
+ default:
+ pluginEvent.event = WM_NULL;
+ break;
+ }
+
+ pluginEvent.wParam = wParam; // plugins NEED raw OS event flags!
+ pluginEvent.lParam = lParam;
+
+ event.mPluginEvent.Copy(pluginEvent);
+
+ // call the event callback
+ if (mWidgetListener) {
+ if (aEventMessage == eMouseMove) {
+ LayoutDeviceIntRect rect = GetBounds();
+ rect.x = 0;
+ rect.y = 0;
+
+ if (rect.Contains(event.mRefPoint)) {
+ if (sCurrentWindow == nullptr || sCurrentWindow != this) {
+ if ((nullptr != sCurrentWindow) && (!sCurrentWindow->mInDtor)) {
+ LPARAM pos = sCurrentWindow->lParamToClient(lParamToScreen(lParam));
+ sCurrentWindow->DispatchMouseEvent(eMouseExitFromWidget,
+ wParam, pos, false,
+ WidgetMouseEvent::eLeftButton,
+ aInputSource, aPointerId);
+ }
+ sCurrentWindow = this;
+ if (!mInDtor) {
+ LPARAM pos = sCurrentWindow->lParamToClient(lParamToScreen(lParam));
+ sCurrentWindow->DispatchMouseEvent(eMouseEnterIntoWidget,
+ wParam, pos, false,
+ WidgetMouseEvent::eLeftButton,
+ aInputSource, aPointerId);
+ }
+ }
+ }
+ } else if (aEventMessage == eMouseExitFromWidget) {
+ sMouseExitwParam = wParam;
+ sMouseExitlParamScreen = lParamToScreen(lParam);
+ if (sCurrentWindow == this) {
+ sCurrentWindow = nullptr;
+ }
+ }
+
+ result = ConvertStatus(DispatchInputEvent(&event));
+
+ // 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)
+{
+ MOZ_ASSERT_IF(msg != WM_GETOBJECT,
+ !mozilla::ipc::MessageChannel::IsPumpingMessages() ||
+ mozilla::ipc::SuppressedNeuteringRegion::IsNeuteringSuppressed());
+
+ // 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:
+ // 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)
+{
+ mozilla::ipc::CancelCPOWs();
+
+ 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<nsIWidget> kungFuDeathGrip;
+ if (!targetWindow->mInDtor)
+ kungFuDeathGrip = 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() &&
+ /* We don't do this for win10 glass with a custom titlebar,
+ * in order to avoid the caption buttons breaking. */
+ !(IsWin10OrLater() && HasGlass()) &&
+ 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");
+ NS_NAMED_LITERAL_STRING(syncShutdown, "syncShutdown");
+ obsServ->NotifyObservers(nullptr, "quit-application-granted", syncShutdown.get());
+ 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-change-qm", context.get());
+ obsServ->NotifyObservers(nullptr, "profile-before-change-telemetry", 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_WTSSESSION_CHANGE:
+ {
+ switch (wParam) {
+ case WTS_CONSOLE_CONNECT:
+ case WTS_REMOTE_CONNECT:
+ case WTS_SESSION_UNLOCK:
+ // When a session becomes visible, we should invalidate.
+ Invalidate(true, true, true);
+ break;
+ default:
+ break;
+ }
+ }
+ 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_SETTINGCHANGE:
+ {
+ if (IsWin10OrLater() && mWindowType == eWindowType_invisible && lParam) {
+ auto lParamString = reinterpret_cast<const wchar_t*>(lParam);
+ if (!wcscmp(lParamString, L"UserInteractionMode")) {
+ nsCOMPtr<nsIWindowsUIUtils> uiUtils(do_GetService("@mozilla.org/windows-ui-utils;1"));
+ if (uiUtils) {
+ uiUtils->UpdateTabletModeState();
+ }
+ }
+ }
+ }
+ 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));
+ double scale = WinUtils::IsPerMonitorDPIAware()
+ ? WinUtils::LogToPhysFactor(mWnd) / WinUtils::SystemScaleFactor()
+ : 1.0;
+ clientRect->top +=
+ NSToIntRound((mCaptionHeight - mNonClientOffset.top) * scale);
+ clientRect->left +=
+ NSToIntRound((mHorResizeMargin - mNonClientOffset.left) * scale);
+ clientRect->right -=
+ NSToIntRound((mHorResizeMargin - mNonClientOffset.right) * scale);
+ clientRect->bottom -=
+ NSToIntRound((mVertResizeMargin - mNonClientOffset.bottom) * scale);
+
+ 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, or if we're the ones
+ * sending the message with an updated title
+ */
+
+ if ((mSendingSetText && nsUXThemeData::CheckForCompositor()) ||
+ !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. However, we need to make sure that we don't
+ // do this at the same time that a Present is happening.
+ //
+ // To do this we take mPresentLock in nsWindow::PreRender and
+ // if that lock is taken we wait before doing WM_SETTEXT
+ if (mCompositorWidgetDelegate) {
+ mCompositorWidgetDelegate->EnterPresentLock();
+ }
+ 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);
+ if (mCompositorWidgetDelegate) {
+ mCompositorWidgetDelegate->LeavePresentLock();
+ }
+
+ 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;
+
+ // There is a case that rendered result is not kept. Bug 1237617
+ if (wParam == TRUE &&
+ !gfxEnv::DisableForcePresent() &&
+ gfxWindowsPlatform::GetPlatform()->DwmCompositionEnabled()) {
+ NS_DispatchToMainThread(NewRunnableMethod(this, &nsWindow::ForcePresent));
+ }
+
+ // let the dwm handle nc painting on glass
+ // Never allow native painting if we are on fullscreen
+ if(mSizeMode != nsSizeMode_Fullscreen &&
+ 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:
+ {
+ if (!mMousePresent && !sIsInMouseCapture) {
+ // First MOUSEMOVE over the client area. Ask for MOUSELEAVE
+ TRACKMOUSEEVENT mTrack;
+ mTrack.cbSize = sizeof(TRACKMOUSEEVENT);
+ mTrack.dwFlags = TME_LEAVE;
+ mTrack.dwHoverTime = 0;
+ mTrack.hwndTrack = mWnd;
+ TrackMouseEvent(&mTrack);
+ }
+ 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(eMouseMove, wParam, lParam,
+ false, WidgetMouseEvent::eLeftButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ if (userMovedMouse) {
+ DispatchPendingEvents();
+ }
+ }
+ break;
+
+ case WM_NCMOUSEMOVE:
+ // If we receive a mouse move event on non-client chrome, make sure and
+ // send an eMouseExitFromWidget event as well.
+ if (mMousePresent && !sIsInMouseCapture)
+ SendMessage(mWnd, WM_MOUSELEAVE, 0, 0);
+ break;
+
+ case WM_LBUTTONDOWN:
+ {
+ result = DispatchMouseEvent(eMouseDown, wParam, lParam,
+ false, WidgetMouseEvent::eLeftButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ }
+ break;
+
+ case WM_LBUTTONUP:
+ {
+ result = DispatchMouseEvent(eMouseUp, wParam, lParam,
+ false, WidgetMouseEvent::eLeftButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ 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(eMouseExitFromWidget, mouseState, pos, false,
+ WidgetMouseEvent::eLeftButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ }
+ break;
+
+ case MOZ_WM_PEN_LEAVES_HOVER_OF_DIGITIZER:
+ {
+ LPARAM pos = lParamToClient(::GetMessagePos());
+ uint16_t pointerId = InkCollector::sInkCollector->GetPointerId();
+ if (pointerId != 0) {
+ DispatchMouseEvent(eMouseExitFromWidget, wParam, pos, false,
+ WidgetMouseEvent::eLeftButton,
+ nsIDOMMouseEvent::MOZ_SOURCE_PEN, pointerId);
+ InkCollector::sInkCollector->ClearTarget();
+ InkCollector::sInkCollector->ClearPointerId();
+ }
+ }
+ break;
+
+ case WM_CONTEXTMENU:
+ {
+ // If the context menu is brought up by a touch long-press, then
+ // the APZ code is responsible for dealing with this, so we don't
+ // need to do anything.
+ if (mTouchWindow && MOUSE_INPUT_SOURCE() == nsIDOMMouseEvent::MOZ_SOURCE_TOUCH) {
+ MOZ_ASSERT(mAPZC); // since mTouchWindow is true, APZ must be enabled
+ result = true;
+ break;
+ }
+
+ // 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(eContextMenu, wParam, pos, contextMenukey,
+ contextMenukey ?
+ WidgetMouseEvent::eLeftButton :
+ WidgetMouseEvent::eRightButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ if (lParam != -1 && !result && mCustomNonClient &&
+ mDraggableRegion.Contains(GET_X_LPARAM(pos), GET_Y_LPARAM(pos))) {
+ // 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(eMouseDoubleClick, wParam,
+ lParam, false,
+ WidgetMouseEvent::eLeftButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_MBUTTONDOWN:
+ result = DispatchMouseEvent(eMouseDown, wParam,
+ lParam, false,
+ WidgetMouseEvent::eMiddleButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_MBUTTONUP:
+ result = DispatchMouseEvent(eMouseUp, wParam,
+ lParam, false,
+ WidgetMouseEvent::eMiddleButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_MBUTTONDBLCLK:
+ result = DispatchMouseEvent(eMouseDoubleClick, wParam,
+ lParam, false,
+ WidgetMouseEvent::eMiddleButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_NCMBUTTONDOWN:
+ result = DispatchMouseEvent(eMouseDown, 0,
+ lParamToClient(lParam), false,
+ WidgetMouseEvent::eMiddleButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_NCMBUTTONUP:
+ result = DispatchMouseEvent(eMouseUp, 0,
+ lParamToClient(lParam), false,
+ WidgetMouseEvent::eMiddleButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_NCMBUTTONDBLCLK:
+ result = DispatchMouseEvent(eMouseDoubleClick, 0,
+ lParamToClient(lParam), false,
+ WidgetMouseEvent::eMiddleButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_RBUTTONDOWN:
+ result = DispatchMouseEvent(eMouseDown, wParam,
+ lParam, false,
+ WidgetMouseEvent::eRightButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_RBUTTONUP:
+ result = DispatchMouseEvent(eMouseUp, wParam,
+ lParam, false,
+ WidgetMouseEvent::eRightButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_RBUTTONDBLCLK:
+ result = DispatchMouseEvent(eMouseDoubleClick, wParam,
+ lParam, false,
+ WidgetMouseEvent::eRightButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_NCRBUTTONDOWN:
+ result = DispatchMouseEvent(eMouseDown, 0,
+ lParamToClient(lParam), false,
+ WidgetMouseEvent::eRightButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_NCRBUTTONUP:
+ result = DispatchMouseEvent(eMouseUp, 0,
+ lParamToClient(lParam), false,
+ WidgetMouseEvent::eRightButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_NCRBUTTONDBLCLK:
+ result = DispatchMouseEvent(eMouseDoubleClick, 0,
+ lParamToClient(lParam), false,
+ WidgetMouseEvent::eRightButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ // Windows doesn't provide to customize the behavior of 4th nor 5th button
+ // of mouse. If 5-button mouse works with standard mouse deriver of
+ // Windows, users cannot disable 4th button (browser back) nor 5th button
+ // (browser forward). We should allow to do it with our prefs since we can
+ // prevent Windows to generate WM_APPCOMMAND message if WM_XBUTTONUP
+ // messages are not sent to DefWindowProc.
+ case WM_XBUTTONDOWN:
+ case WM_XBUTTONUP:
+ case WM_NCXBUTTONDOWN:
+ case WM_NCXBUTTONUP:
+ *aRetValue = TRUE;
+ switch (GET_XBUTTON_WPARAM(wParam)) {
+ case XBUTTON1:
+ result = !Preferences::GetBool("mousebutton.4th.enabled", true);
+ break;
+ case XBUTTON2:
+ result = !Preferences::GetBool("mousebutton.5th.enabled", true);
+ break;
+ default:
+ break;
+ }
+ break;
+
+ case WM_SIZING:
+ {
+ // When we get WM_ENTERSIZEMOVE we don't know yet if we're in a live
+ // resize or move event. Instead we wait for first VM_SIZING message
+ // within a ENTERSIZEMOVE to consider this a live resize event.
+ if (mResizeState == IN_SIZEMOVE) {
+ mResizeState = RESIZING;
+ nsCOMPtr<nsIObserverService> observerService =
+ mozilla::services::GetObserverService();
+
+ if (observerService) {
+ observerService->NotifyObservers(nullptr, "live-resize-start",
+ nullptr);
+ }
+ }
+ break;
+ }
+
+ case WM_MOVING:
+ FinishLiveResizing(MOVING);
+ if (WinUtils::IsPerMonitorDPIAware()) {
+ // Sometimes, we appear to miss a WM_DPICHANGED message while moving
+ // a window around. Therefore, call ChangedDPI and ResetLayout here,
+ // which causes the prescontext and appshell window management code to
+ // check the appUnitsPerDevPixel value and current widget size, and
+ // refresh them if necessary. If nothing has changed, these calls will
+ // return without actually triggering any extra reflow or painting.
+ ChangedDPI();
+ ResetLayout();
+ }
+ break;
+
+ case WM_ENTERSIZEMOVE:
+ {
+ if (mResizeState == NOT_RESIZING) {
+ mResizeState = IN_SIZEMOVE;
+ }
+ break;
+ }
+
+ case WM_EXITSIZEMOVE:
+ {
+ FinishLiveResizing(NOT_RESIZING);
+
+ if (!sIsInMouseCapture) {
+ NotifySizeMoveDone();
+ }
+
+ break;
+ }
+
+ case WM_NCLBUTTONDBLCLK:
+ DispatchMouseEvent(eMouseDoubleClick, 0, lParamToClient(lParam),
+ false, WidgetMouseEvent::eLeftButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ result =
+ DispatchMouseEvent(eMouseUp, 0, lParamToClient(lParam),
+ false, WidgetMouseEvent::eLeftButton,
+ MOUSE_INPUT_SOURCE(), MOUSE_POINTERID());
+ DispatchPendingEvents();
+ break;
+
+ case WM_APPCOMMAND:
+ {
+ MSG nativeMsg = WinUtils::InitMSG(msg, wParam, lParam, mWnd);
+ result = HandleAppCommandMsg(nativeMsg, 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, eMouseActivate, this,
+ WidgetMouseEvent::eReal);
+ InitEvent(event);
+ ModifierKeyState modifierKeyState;
+ modifierKeyState.InitInputEvent(event);
+ DispatchInputEvent(&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));
+ nsBidiKeyboard::OnLayoutChange();
+ 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).
+ int32_t 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
+ }
+ }
+ }
+ }
+ break;
+#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;
+ }
+
+ if (mSizeMode == nsSizeMode_Fullscreen &&
+ filteredWParam == SC_RESTORE &&
+ GetCurrentShowCmd(mWnd) != SW_SHOWMINIMIZED) {
+ MakeFullScreen(false);
+ 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_DPICHANGED:
+ {
+ LPRECT rect = (LPRECT) lParam;
+ OnDPIChanged(rect->left, rect->top, rect->right - rect->left,
+ rect->bottom - rect->top);
+ 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.
+ if (mWindowType == eWindowType_toplevel ||
+ mWindowType == eWindowType_dialog) {
+ 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 &&
+ !IsPlugin()) {
+ // 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.
+
+ GESTURENOTIFYSTRUCT * gestureinfo = (GESTURENOTIFYSTRUCT*)lParam;
+ nsPointWin touchPoint;
+ touchPoint = gestureinfo->ptsLocation;
+ touchPoint.ScreenToClient(mWnd);
+ WidgetGestureNotifyEvent gestureNotifyEvent(true, eGestureNotify, this);
+ gestureNotifyEvent.mRefPoint =
+ LayoutDeviceIntPoint::FromUnknownPoint(touchPoint);
+ nsEventStatus status;
+ DispatchEvent(&gestureNotifyEvent, status);
+ mDisplayPanFeedback = gestureNotifyEvent.mDisplayPanFeedback;
+ if (!mTouchWindow)
+ mGesture.SetWinGestureSupport(mWnd, gestureNotifyEvent.mPanDirection);
+ }
+ result = false; //should always bubble to DefWindowProc
+ }
+ break;
+
+ case WM_CLEAR:
+ {
+ WidgetContentCommandEvent command(true, eContentCommandDelete, this);
+ DispatchWindowEvent(&command);
+ result = true;
+ }
+ break;
+
+ case WM_CUT:
+ {
+ WidgetContentCommandEvent command(true, eContentCommandCut, this);
+ DispatchWindowEvent(&command);
+ result = true;
+ }
+ break;
+
+ case WM_COPY:
+ {
+ WidgetContentCommandEvent command(true, eContentCommandCopy, this);
+ DispatchWindowEvent(&command);
+ result = true;
+ }
+ break;
+
+ case WM_PASTE:
+ {
+ WidgetContentCommandEvent command(true, eContentCommandPaste, this);
+ DispatchWindowEvent(&command);
+ result = true;
+ }
+ break;
+
+ case EM_UNDO:
+ {
+ WidgetContentCommandEvent command(true, eContentCommandUndo, this);
+ DispatchWindowEvent(&command);
+ *aRetValue = (LRESULT)(command.mSucceeded && command.mIsEnabled);
+ result = true;
+ }
+ break;
+
+ case EM_REDO:
+ {
+ WidgetContentCommandEvent command(true, eContentCommandRedo, 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, eContentCommandPaste,
+ this, true);
+ DispatchWindowEvent(&command);
+ *aRetValue = (LRESULT)(command.mSucceeded && command.mIsEnabled);
+ result = true;
+ }
+ }
+ break;
+
+ case EM_CANUNDO:
+ {
+ WidgetContentCommandEvent command(true, eContentCommandUndo, this, true);
+ DispatchWindowEvent(&command);
+ *aRetValue = (LRESULT)(command.mSucceeded && command.mIsEnabled);
+ result = true;
+ }
+ break;
+
+ case EM_CANREDO:
+ {
+ WidgetContentCommandEvent command(true, eContentCommandRedo, this, true);
+ DispatchWindowEvent(&command);
+ *aRetValue = (LRESULT)(command.mSucceeded && command.mIsEnabled);
+ result = true;
+ }
+ break;
+
+ case MOZ_WM_SKEWFIX:
+ {
+ TimeStamp skewStamp;
+ if (CurrentWindowsTimeGetter::GetAndClearBackwardsSkewStamp(wParam, &skewStamp)) {
+ TimeConverter().CompensateForBackwardsSkew(::GetMessageTime(), skewStamp);
+ }
+ }
+ break;
+
+ default:
+ {
+ if (msg == nsAppShell::GetTaskbarButtonCreatedMessage()) {
+ SetHasTaskbarIconBeenCreated();
+ }
+ }
+ 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;
+ }
+}
+
+void
+nsWindow::FinishLiveResizing(ResizeState aNewState)
+{
+ if (mResizeState == RESIZING) {
+ nsCOMPtr<nsIObserverService> observerService = mozilla::services::GetObserverService();
+ if (observerService) {
+ observerService->NotifyObservers(nullptr, "live-resize-end", nullptr);
+ }
+ }
+ mResizeState = aNewState;
+ ForcePresent();
+}
+
+/**************************************************************
+ *
+ * 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)) {
+ return mCachedHitTestResult;
+ }
+ if (mDraggableRegion.Contains(pt.x, pt.y)) {
+ testResult = HTCAPTION;
+ } else {
+ testResult = HTCLIENT;
+ }
+ mCachedHitTestPoint = pt;
+ mCachedHitTestTime = TimeStamp::Now();
+ mCachedHitTestResult = testResult;
+ }
+
+ return testResult;
+}
+
+TimeStamp
+nsWindow::GetMessageTimeStamp(LONG aEventTime) const
+{
+ CurrentWindowsTimeGetter getCurrentTime(mWnd);
+ return TimeConverter().GetTimeStampFromSystemTime(aEventTime,
+ getCurrentTime);
+}
+
+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(aEventDispatched));
+}
+
+LRESULT nsWindow::ProcessKeyUpMessage(const MSG &aMsg, bool *aEventDispatched)
+{
+ 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;
+
+ NativeKey nativeKey(this, aMsg, modKeyState);
+ LRESULT 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,
+ nsIObserver* aObserver)
+{
+ AutoObserverNotifier notifier(aObserver, "keyevent");
+
+ KeyboardLayout* keyboardLayout = KeyboardLayout::GetInstance();
+ return keyboardLayout->SynthesizeNativeKeyEvent(
+ this, aNativeKeyboardLayout, aNativeKeyCode, aModifierFlags,
+ aCharacters, aUnmodifiedCharacters);
+}
+
+nsresult
+nsWindow::SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
+ uint32_t aNativeMessage,
+ uint32_t aModifierFlags,
+ nsIObserver* aObserver)
+{
+ AutoObserverNotifier notifier(aObserver, "mouseevent");
+
+ if (aNativeMessage == MOUSEEVENTF_MOVE) {
+ // Reset sLastMouseMovePoint so that even if we're moving the mouse
+ // to the position it's already at, we still dispatch a mousemove
+ // event, because the callers of this function expect that.
+ sLastMouseMovePoint = {0};
+ }
+ ::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(LayoutDeviceIntPoint aPoint,
+ uint32_t aNativeMessage,
+ double aDeltaX,
+ double aDeltaY,
+ double aDeltaZ,
+ uint32_t aModifierFlags,
+ uint32_t aAdditionalFlags,
+ nsIObserver* aObserver)
+{
+ AutoObserverNotifier notifier(aObserver, "mousescrollevent");
+ 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)) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("*** OnWindowPosChanged: [ top] "));
+ } else {
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("*** OnWindowPosChanged: [child] "));
+ }
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("WINDOWPOS flags:"));
+ if (wp->flags & SWP_FRAMECHANGED) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("SWP_FRAMECHANGED "));
+ }
+ if (wp->flags & SWP_SHOWWINDOW) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("SWP_SHOWWINDOW "));
+ }
+ if (wp->flags & SWP_NOSIZE) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("SWP_NOSIZE "));
+ }
+ if (wp->flags & SWP_HIDEWINDOW) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("SWP_HIDEWINDOW "));
+ }
+ if (wp->flags & SWP_NOZORDER) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("SWP_NOZORDER "));
+ }
+ if (wp->flags & SWP_NOACTIVATE) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("SWP_NOACTIVATE "));
+ }
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("\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);
+
+ nsSizeMode previousSizeMode = mSizeMode;
+
+ // 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:
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("*** mSizeMode: nsSizeMode_Normal\n"));
+ break;
+ case nsSizeMode_Minimized:
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("*** mSizeMode: nsSizeMode_Minimized\n"));
+ break;
+ case nsSizeMode_Maximized:
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("*** mSizeMode: nsSizeMode_Maximized\n"));
+ break;
+ default:
+ MOZ_LOG(gWindowsLog, LogLevel::Info, ("*** mSizeMode: ??????\n"));
+ break;
+ }
+#endif
+
+ if (mWidgetListener && mSizeMode != previousSizeMode)
+ 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);
+
+ mLastSizeMode = mSizeMode;
+
+ // 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);
+
+ 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
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("*** 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)) {
+ MultiTouchInput touchInput, touchEndInput;
+
+ // Walk across the touch point array processing each contact point.
+ for (uint32_t i = 0; i < cInputs; i++) {
+ bool addToEvent = false, addToEndEvent = false;
+
+ // N.B.: According with MS documentation
+ // https://msdn.microsoft.com/en-us/library/windows/desktop/dd317334(v=vs.85).aspx
+ // TOUCHEVENTF_DOWN cannot be combined with TOUCHEVENTF_MOVE or TOUCHEVENTF_UP.
+ // Possibly, it means that TOUCHEVENTF_MOVE and TOUCHEVENTF_UP can be combined together.
+
+ if (pInputs[i].dwFlags & (TOUCHEVENTF_DOWN | TOUCHEVENTF_MOVE)) {
+ if (touchInput.mTimeStamp.IsNull()) {
+ // Initialize a touch event to send.
+ touchInput.mType = MultiTouchInput::MULTITOUCH_MOVE;
+ touchInput.mTime = ::GetMessageTime();
+ touchInput.mTimeStamp = GetMessageTimeStamp(touchInput.mTime);
+ ModifierKeyState modifierKeyState;
+ touchInput.modifiers = modifierKeyState.GetModifiers();
+ }
+ // Pres shell expects this event to be a eTouchStart
+ // if any new contact points have been added since the last event sent.
+ if (pInputs[i].dwFlags & TOUCHEVENTF_DOWN) {
+ touchInput.mType = MultiTouchInput::MULTITOUCH_START;
+ }
+ addToEvent = true;
+ }
+ if (pInputs[i].dwFlags & TOUCHEVENTF_UP) {
+ // Pres shell expects removed contacts points to be delivered in a separate
+ // eTouchEnd event containing only the contact points that were removed.
+ if (touchEndInput.mTimeStamp.IsNull()) {
+ // Initialize a touch event to send.
+ touchEndInput.mType = MultiTouchInput::MULTITOUCH_END;
+ touchEndInput.mTime = ::GetMessageTime();
+ touchEndInput.mTimeStamp = GetMessageTimeStamp(touchEndInput.mTime);
+ ModifierKeyState modifierKeyState;
+ touchEndInput.modifiers = modifierKeyState.GetModifiers();
+ }
+ addToEndEvent = true;
+ }
+ if (!addToEvent && !addToEndEvent) {
+ // 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);
+
+ // Initialize the touch data.
+ SingleTouchData touchData(pInputs[i].dwID, // aIdentifier
+ ScreenIntPoint::FromUnknownPoint(touchPoint), // aScreenPoint
+ /* radius, if known */
+ pInputs[i].dwFlags & TOUCHINPUTMASKF_CONTACTAREA
+ ? ScreenSize(
+ TOUCH_COORD_TO_PIXEL(pInputs[i].cxContact) / 2,
+ TOUCH_COORD_TO_PIXEL(pInputs[i].cyContact) / 2)
+ : ScreenSize(1, 1), // aRadius
+ 0.0f, // aRotationAngle
+ 0.0f); // aForce
+
+ // Append touch data to the appropriate event.
+ if (addToEvent) {
+ touchInput.mTouches.AppendElement(touchData);
+ }
+ if (addToEndEvent) {
+ touchEndInput.mTouches.AppendElement(touchData);
+ }
+ }
+
+ // Dispatch touch start and touch move event if we have one.
+ if (!touchInput.mTimeStamp.IsNull()) {
+ DispatchTouchInput(touchInput);
+ }
+ // Dispatch touch end event if we have one.
+ if (!touchEndInput.mTimeStamp.IsNull()) {
+ DispatchTouchInput(touchEndInput);
+ }
+ }
+
+ delete [] pInputs;
+ mGesture.CloseTouchInputHandle((HTOUCHINPUT)lParam);
+ return true;
+}
+
+// Gesture event processing. Handles WM_GESTURE events.
+bool nsWindow::OnGesture(WPARAM wParam, LPARAM lParam)
+{
+ // 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, eWheel, this);
+
+ ModifierKeyState modifierKeyState;
+ modifierKeyState.InitInputEvent(wheelEvent);
+
+ wheelEvent.button = 0;
+ wheelEvent.mTime = ::GetMessageTime();
+ wheelEvent.mTimeStamp = GetMessageTimeStamp(wheelEvent.mTime);
+ wheelEvent.inputSource = nsIDOMMouseEvent::MOZ_SOURCE_TOUCH;
+
+ bool endFeedback = true;
+
+ if (mGesture.PanDeltaToPixelScroll(wheelEvent)) {
+ mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS,
+ (uint32_t) ScrollInputMethod::MainThreadTouch);
+ DispatchEvent(&wheelEvent, status);
+ }
+
+ if (mDisplayPanFeedback) {
+ mGesture.UpdatePanFeedbackX(
+ mWnd,
+ DeprecatedAbs(RoundDown(wheelEvent.mOverflowDeltaX)),
+ endFeedback);
+ mGesture.UpdatePanFeedbackY(
+ mWnd,
+ DeprecatedAbs(RoundDown(wheelEvent.mOverflowDeltaY)),
+ endFeedback);
+ mGesture.PanFeedbackFinalize(mWnd, endFeedback);
+ }
+
+ mGesture.CloseGestureInfoHandle((HGESTUREINFO)lParam);
+
+ return true;
+ }
+
+ // Other gestures translate into simple gesture events:
+ WidgetSimpleGestureEvent event(true, eVoidEvent, 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.mTime = ::GetMessageTime();
+ event.mTimeStamp = GetMessageTimeStamp(event.mTime);
+ 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
+}
+
+nsresult
+nsWindow::ConfigureChildren(const nsTArray<Configuration>& aConfigurations)
+{
+ // If this is a remotely updated widget we receive clipping, position, and
+ // size information from a source other than our owner. Don't let our parent
+ // update this information.
+ if (mWindowType == eWindowType_plugin_ipc_chrome) {
+ return NS_OK;
+ }
+
+ // 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.get());
+ NS_ASSERTION(w->GetParent() == this,
+ "Configured widget is not a child");
+ nsresult rv = w->SetWindowClipRegion(configuration.mClipRegion, true);
+ NS_ENSURE_SUCCESS(rv, rv);
+ LayoutDeviceIntRect bounds = w->GetBounds();
+ 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()->IsDirect2DBackend() ||
+ 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!
+ LayoutDeviceIntRegion r;
+ r.Sub(bounds, configuration.mBounds);
+ r.MoveBy(-bounds.x,
+ -bounds.y);
+ LayoutDeviceIntRect toInvalidate = r.GetBounds();
+
+ WinUtils::InvalidatePluginAsWorkaround(w, toInvalidate);
+ }
+ }
+ rv = w->SetWindowClipRegion(configuration.mClipRegion, false);
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+ return NS_OK;
+}
+
+static HRGN
+CreateHRGNFromArray(const nsTArray<LayoutDeviceIntRect>& aRects)
+{
+ int32_t size = sizeof(RGNDATAHEADER) + sizeof(RECT)*aRects.Length();
+ AutoTArray<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();
+ LayoutDeviceIntRect bounds;
+ for (uint32_t i = 0; i < aRects.Length(); ++i) {
+ const LayoutDeviceIntRect& 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);
+}
+
+nsresult
+nsWindow::SetWindowClipRegion(const nsTArray<LayoutDeviceIntRect>& aRects,
+ bool aIntersectWithExisting)
+{
+ if (IsWindowClipRegionEqual(aRects)) {
+ return NS_OK;
+ }
+
+ nsBaseWidget::SetWindowClipRegion(aRects, aIntersectWithExisting);
+
+ 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 (IsPlugin()) {
+ 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;
+
+ // Unregister notifications from terminal services
+ ::WTSUnRegisterSessionNotification(mWnd);
+
+ // 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, false, nullptr, nullptr);
+ CaptureRollupEvents(nullptr, false);
+ }
+
+ IMEHandler::OnDestroyWindow(this);
+
+ // Free GDI window class objects
+ if (mBrush) {
+ VERIFY(::DeleteObject(mBrush));
+ mBrush = nullptr;
+ }
+
+ // Destroy any custom cursor resources.
+ if (mCursor == -1)
+ SetCursor(eCursor_standard);
+
+ if (mCompositorWidgetDelegate) {
+ mCompositorWidgetDelegate->OnDestroyWindow();
+ }
+ mBasicLayersSurface = nullptr;
+
+ // 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;
+}
+
+bool
+nsWindow::IsPopup()
+{
+ return mWindowType == eWindowType_popup;
+}
+
+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::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_WARNING_ASSERTION(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()->IsDirect2DBackend() ? TRI_TRUE : TRI_FALSE;
+ if (!sHasBogusPopupsDropShadowOnMultiMonitor) {
+ // Otherwise check if Direct3D 9 may be used.
+ if (gfxConfig::IsEnabled(Feature::HW_COMPOSITING) &&
+ !gfxConfig::IsEnabled(Feature::OPENGL_COMPOSITING))
+ {
+ nsCOMPtr<nsIGfxInfo> gfxInfo = services::GetGfxInfo();
+ if (gfxInfo) {
+ int32_t status;
+ nsCString discardFailureId;
+ if (NS_SUCCEEDED(gfxInfo->GetFeatureStatus(nsIGfxInfo::FEATURE_DIRECT3D_9_LAYERS,
+ discardFailureId, &status))) {
+ if (status == nsIGfxInfo::FEATURE_STATUS_OK ||
+ gfxConfig::IsForcedOnByUser(Feature::HW_COMPOSITING))
+ {
+ 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();
+ }
+}
+
+void
+nsWindow::OnDPIChanged(int32_t x, int32_t y, int32_t width, int32_t height)
+{
+ // Don't try to handle WM_DPICHANGED for popup windows (see bug 1239353);
+ // they remain tied to their original parent's resolution.
+ if (mWindowType == eWindowType_popup) {
+ return;
+ }
+ if (DefaultScaleOverride() > 0.0) {
+ return;
+ }
+ double oldScale = mDefaultScale;
+ mDefaultScale = -1.0; // force recomputation of scale factor
+ double newScale = GetDefaultScaleInternal();
+
+ if (mResizeState != RESIZING && mSizeMode == nsSizeMode_Normal) {
+ // Limit the position (if not in the middle of a drag-move) & size,
+ // if it would overflow the destination screen
+ nsCOMPtr<nsIScreenManager> sm = do_GetService(sScreenManagerContractID);
+ if (sm) {
+ nsCOMPtr<nsIScreen> screen;
+ sm->ScreenForRect(x, y, width, height, getter_AddRefs(screen));
+ if (screen) {
+ int32_t availLeft, availTop, availWidth, availHeight;
+ screen->GetAvailRect(&availLeft, &availTop, &availWidth, &availHeight);
+ if (mResizeState != MOVING) {
+ x = std::max(x, availLeft);
+ y = std::max(y, availTop);
+ }
+ width = std::min(width, availWidth);
+ height = std::min(height, availHeight);
+ }
+ }
+
+ Resize(x, y, width, height, true);
+ }
+ ChangedDPI();
+ ResetLayout();
+}
+
+/**************************************************************
+ **************************************************************
+ **
+ ** BLOCK: IME management and accessibility
+ **
+ ** Handles managing IME input and accessibility.
+ **
+ **************************************************************
+ **************************************************************/
+
+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;
+}
+
+nsIMEUpdatePreference
+nsWindow::GetIMEUpdatePreference()
+{
+ return IMEHandler::GetUpdatePreference();
+}
+
+NS_IMETHODIMP_(TextEventDispatcherListener*)
+nsWindow::GetNativeTextEventDispatcherListener()
+{
+ return IMEHandler::GetNativeTextEventDispatcherListener();
+}
+
+#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: %p, parent HWND: %p, 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)) {
+ nsAccessibilityService* accService = GetOrCreateAccService();
+ 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::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;
+
+ if (mCompositorWidgetDelegate) {
+ mCompositorWidgetDelegate->UpdateTransparency(aMode);
+ }
+ UpdateGlass();
+}
+
+#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
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("MozSpecialMessageProc - code: 0x%X - %s hw: %p\n",
+ code, gMSGFEvents[inx].mStr, pMsg->hwnd));
+#endif
+ } else {
+#ifdef DEBUG
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("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)->IsPlugin())
+ 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) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("***** 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) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("***** 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) {
+ MOZ_LOG(gWindowsLog, LogLevel::Info,
+ ("***** 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;
+ AutoTArray<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
+IsTouchSupportEnabled(HWND aWnd)
+{
+ nsWindow* topWindow = WinUtils::GetNSWindowPtr(WinUtils::GetTopLevelHWND(aWnd, true));
+ return topWindow ? topWindow->IsTouchWindow() : false;
+}
+
+// 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;
+
+ bool consumeRollupEvent = false;
+
+ nsWindow* popupWindow = static_cast<nsWindow*>(popup.get());
+ UINT nativeMessage = WinUtils::GetNativeMessage(aMessage);
+ switch (nativeMessage) {
+ case WM_TOUCH:
+ if (!IsTouchSupportEnabled(aWnd)) {
+ // If APZ is disabled, don't allow touch inputs to dismiss popups. The
+ // compatibility mouse events will do it instead.
+ return false;
+ }
+ MOZ_FALLTHROUGH;
+ case WM_LBUTTONDOWN:
+ case WM_RBUTTONDOWN:
+ case WM_MBUTTONDOWN:
+ case WM_NCLBUTTONDOWN:
+ case WM_NCRBUTTONDOWN:
+ case WM_NCMBUTTONDOWN:
+ if (nativeMessage != WM_TOUCH &&
+ IsTouchSupportEnabled(aWnd) &&
+ MOUSE_INPUT_SOURCE() == nsIDOMMouseEvent::MOZ_SOURCE_TOUCH) {
+ // If any of these mouse events are really compatibility events that
+ // Windows is sending for touch inputs, then don't allow them to dismiss
+ // popups when APZ is enabled (instead we do the dismissing as part of
+ // WM_TOUCH handling which is more correct).
+ // If we don't do this, then when the user lifts their finger after a
+ // long-press, the WM_RBUTTONDOWN compatibility event that Windows sends
+ // us will dismiss the contextmenu popup that we displayed as part of
+ // handling the long-tap-up.
+ return false;
+ }
+ 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)) {
+ // Check if we should consume this event even if we don't roll-up:
+ consumeRollupEvent =
+ rollupListener->ShouldConsumeOnMouseWheelEvent();
+ *aResult = MA_ACTIVATE;
+ if (rollupListener->ShouldRollupOnMouseWheelEvent() &&
+ GetPopupsToRollup(rollupListener, &popupsToRollup)) {
+ break;
+ }
+ }
+ return consumeRollupEvent;
+
+ 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_SHOWWINDOW:
+ // If the window is being minimized, close popups.
+ if (aLParam == SW_PARENTCLOSING) {
+ break;
+ }
+ return false;
+
+ 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_MENUSELECT:
+ break;
+
+ default:
+ return false;
+ }
+
+ // Only need to deal with the last rollup for left mouse down events.
+ NS_ASSERTION(!mLastRollup, "mLastRollup is null");
+
+ 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, true, &pos, &mLastRollup);
+ NS_IF_ADDREF(mLastRollup);
+ } else {
+ consumeRollupEvent =
+ rollupListener->Rollup(popupsToRollup, true, 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;
+}
+
+/* static */ const wchar_t*
+nsWindow::GetMainWindowClass()
+{
+ static const wchar_t* sMainWindowClass = nullptr;
+ if (!sMainWindowClass) {
+ nsAdoptingString className =
+ Preferences::GetString("ui.window_class_override");
+ if (!className.IsEmpty()) {
+ sMainWindowClass = wcsdup(className.get());
+ } else {
+ sMainWindowClass = kClassNameGeneral;
+ }
+ }
+ return sMainWindowClass;
+}
+
+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();
+ }
+}
+
+bool
+nsWindow::WidgetTypeSupportsAcceleration()
+{
+ // 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.
+ //
+ // Also see bug 1150376, D3D11 composition can cause issues on some devices
+ // on Windows 7 where presentation fails randomly for windows with drop
+ // shadows.
+ return mTransparencyMode != eTransparencyTransparent &&
+ !(IsPopup() && DeviceManagerDx::Get()->IsWARP());
+}
+
+void
+nsWindow::SetCandidateWindowForPlugin(const CandidateWindowPosition& aPosition)
+{
+ CANDIDATEFORM form;
+ form.dwIndex = 0;
+ if (aPosition.mExcludeRect) {
+ form.dwStyle = CFS_EXCLUDE;
+ form.rcArea.left = aPosition.mRect.x;
+ form.rcArea.top = aPosition.mRect.y;
+ form.rcArea.right = aPosition.mRect.x + aPosition.mRect.width;
+ form.rcArea.bottom = aPosition.mRect.y + aPosition.mRect.height;
+ } else {
+ form.dwStyle = CFS_CANDIDATEPOS;
+ }
+ form.ptCurrentPos.x = aPosition.mPoint.x;
+ form.ptCurrentPos.y = aPosition.mPoint.y;
+
+ IMEHandler::SetCandidateWindow(this, &form);
+}
+
+void
+nsWindow::DefaultProcOfPluginEvent(const WidgetPluginEvent& aEvent)
+{
+ const NPEvent* pPluginEvent =
+ static_cast<const NPEvent*>(aEvent.mPluginEvent);
+
+ if (NS_WARN_IF(!pPluginEvent)) {
+ return;
+ }
+
+ if (!mWnd) {
+ return;
+ }
+
+ // For WM_IME_*COMPOSITION
+ IMEHandler::DefaultProcOfPluginEvent(this, pPluginEvent);
+
+ CallWindowProcW(GetPrevWindowProc(), mWnd, pPluginEvent->event,
+ pPluginEvent->wParam, pPluginEvent->lParam);
+}
+
+nsresult
+nsWindow::OnWindowedPluginKeyEvent(const NativeEventData& aKeyEventData,
+ nsIKeyEventInPluginCallback* aCallback)
+{
+ if (NS_WARN_IF(!mWnd)) {
+ return NS_OK;
+ }
+ const WinNativeKeyEventData* eventData =
+ static_cast<const WinNativeKeyEventData*>(aKeyEventData);
+ switch (eventData->mMessage) {
+ case WM_KEYDOWN:
+ case WM_SYSKEYDOWN: {
+ MSG mozMsg =
+ WinUtils::InitMSG(MOZ_WM_KEYDOWN, eventData->mWParam,
+ eventData->mLParam, mWnd);
+ ModifierKeyState modifierKeyState(eventData->mModifiers);
+ NativeKey nativeKey(this, mozMsg, modifierKeyState,
+ eventData->GetKeyboardLayout());
+ return nativeKey.HandleKeyDownMessage() ? NS_SUCCESS_EVENT_CONSUMED :
+ NS_OK;
+ }
+ case WM_KEYUP:
+ case WM_SYSKEYUP: {
+ MSG mozMsg =
+ WinUtils::InitMSG(MOZ_WM_KEYUP, eventData->mWParam,
+ eventData->mLParam, mWnd);
+ ModifierKeyState modifierKeyState(eventData->mModifiers);
+ NativeKey nativeKey(this, mozMsg, modifierKeyState,
+ eventData->GetKeyboardLayout());
+ return nativeKey.HandleKeyUpMessage() ? NS_SUCCESS_EVENT_CONSUMED : NS_OK;
+ }
+ default:
+ // We shouldn't consume WM_*CHAR messages here even if the preceding
+ // keydown or keyup event on the plugin is consumed. It should be
+ // managed in each plugin window rather than top level window.
+ return NS_OK;
+ }
+}
+
+/**************************************************************
+ **************************************************************
+ **
+ ** 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;
+}
+
+void
+nsWindow::GetCompositorWidgetInitData(mozilla::widget::CompositorWidgetInitData* aInitData)
+{
+ aInitData->hWnd() = reinterpret_cast<uintptr_t>(mWnd);
+ aInitData->widgetKey() = reinterpret_cast<uintptr_t>(static_cast<nsIWidget*>(this));
+ aInitData->transparencyMode() = mTransparencyMode;
+}