summaryrefslogtreecommitdiffstats
path: root/widget/windows/nsWindow.h
diff options
context:
space:
mode:
Diffstat (limited to 'widget/windows/nsWindow.h')
-rw-r--r--widget/windows/nsWindow.h671
1 files changed, 671 insertions, 0 deletions
diff --git a/widget/windows/nsWindow.h b/widget/windows/nsWindow.h
new file mode 100644
index 000000000..248978bd7
--- /dev/null
+++ b/widget/windows/nsWindow.h
@@ -0,0 +1,671 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef Window_h__
+#define Window_h__
+
+/*
+ * nsWindow - Native window management and event handling.
+ */
+
+#include "mozilla/RefPtr.h"
+#include "nsBaseWidget.h"
+#include "nsWindowBase.h"
+#include "nsdefs.h"
+#include "nsIdleService.h"
+#include "nsToolkit.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "gfxWindowsPlatform.h"
+#include "gfxWindowsSurface.h"
+#include "nsWindowDbg.h"
+#include "cairo.h"
+#include "nsITimer.h"
+#include "nsRegion.h"
+#include "mozilla/EventForwards.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/TimeStamp.h"
+#include "nsMargin.h"
+#include "nsRegionFwd.h"
+
+#include "nsWinGesture.h"
+#include "WinUtils.h"
+#include "WindowHook.h"
+#include "TaskbarWindowPreview.h"
+
+#ifdef ACCESSIBILITY
+#include "oleacc.h"
+#include "mozilla/a11y/Accessible.h"
+#endif
+
+#include "nsUXThemeData.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsIIdleServiceInternal.h"
+
+#include "IMMHandler.h"
+
+/**
+ * Forward class definitions
+ */
+
+class nsNativeDragTarget;
+class nsIRollupListener;
+class imgIContainer;
+
+namespace mozilla {
+namespace widget {
+class NativeKey;
+class WinCompositorWidget;
+struct MSGResult;
+} // namespace widget
+} // namespacw mozilla;
+
+/**
+ * Native WIN32 window wrapper.
+ */
+
+class nsWindow : public nsWindowBase
+{
+ typedef mozilla::TimeStamp TimeStamp;
+ typedef mozilla::TimeDuration TimeDuration;
+ typedef mozilla::widget::WindowHook WindowHook;
+ typedef mozilla::widget::TaskbarWindowPreview TaskbarWindowPreview;
+ typedef mozilla::widget::NativeKey NativeKey;
+ typedef mozilla::widget::MSGResult MSGResult;
+ typedef mozilla::widget::IMEContext IMEContext;
+
+public:
+ nsWindow();
+
+ NS_DECL_ISUPPORTS_INHERITED
+
+ friend class nsWindowGfx;
+
+ // nsWindowBase
+ virtual void InitEvent(mozilla::WidgetGUIEvent& aEvent,
+ LayoutDeviceIntPoint* aPoint = nullptr) override;
+ virtual WidgetEventTime CurrentMessageWidgetEventTime() const override;
+ virtual bool DispatchWindowEvent(mozilla::WidgetGUIEvent* aEvent) override;
+ virtual bool DispatchKeyboardEvent(mozilla::WidgetKeyboardEvent* aEvent) override;
+ virtual bool DispatchWheelEvent(mozilla::WidgetWheelEvent* aEvent) override;
+ virtual bool DispatchContentCommandEvent(mozilla::WidgetContentCommandEvent* aEvent) override;
+ virtual nsWindowBase* GetParentWindowBase(bool aIncludeOwner) override;
+ virtual bool IsTopLevelWidget() override { return mIsTopWidgetWindow; }
+
+ using nsWindowBase::DispatchPluginEvent;
+
+ // nsIWidget interface
+ using nsWindowBase::Create; // for Create signature not overridden here
+ virtual MOZ_MUST_USE nsresult Create(nsIWidget* aParent,
+ nsNativeWidget aNativeParent,
+ const LayoutDeviceIntRect& aRect,
+ nsWidgetInitData* aInitData = nullptr)
+ override;
+ virtual void Destroy() override;
+ NS_IMETHOD SetParent(nsIWidget *aNewParent) override;
+ virtual nsIWidget* GetParent(void) override;
+ virtual float GetDPI() override;
+ double GetDefaultScaleInternal() final;
+ int32_t LogToPhys(double aValue) final;
+ mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScale() final
+ {
+ if (mozilla::widget::WinUtils::IsPerMonitorDPIAware()) {
+ return mozilla::DesktopToLayoutDeviceScale(1.0);
+ } else {
+ return mozilla::DesktopToLayoutDeviceScale(GetDefaultScaleInternal());
+ }
+ }
+
+ NS_IMETHOD Show(bool bState) override;
+ virtual bool IsVisible() const override;
+ virtual void ConstrainPosition(bool aAllowSlop, int32_t *aX, int32_t *aY) override;
+ virtual void SetSizeConstraints(const SizeConstraints& aConstraints) override;
+ virtual const SizeConstraints GetSizeConstraints() override;
+ NS_IMETHOD Move(double aX, double aY) override;
+ NS_IMETHOD Resize(double aWidth, double aHeight, bool aRepaint) override;
+ NS_IMETHOD Resize(double aX, double aY, double aWidth, double aHeight, bool aRepaint) override;
+ NS_IMETHOD BeginResizeDrag(mozilla::WidgetGUIEvent* aEvent,
+ int32_t aHorizontal,
+ int32_t aVertical) override;
+ virtual void PlaceBehind(nsTopLevelWidgetZPlacement aPlacement, nsIWidget *aWidget, bool aActivate) override;
+ virtual void SetSizeMode(nsSizeMode aMode) override;
+ NS_IMETHOD Enable(bool aState) override;
+ virtual bool IsEnabled() const override;
+ NS_IMETHOD SetFocus(bool aRaise) override;
+ virtual LayoutDeviceIntRect GetBounds() override;
+ virtual LayoutDeviceIntRect GetScreenBounds() override;
+ virtual MOZ_MUST_USE nsresult GetRestoredBounds(LayoutDeviceIntRect& aRect) override;
+ virtual LayoutDeviceIntRect GetClientBounds() override;
+ virtual LayoutDeviceIntPoint GetClientOffset() override;
+ void SetBackgroundColor(const nscolor& aColor) override;
+ NS_IMETHOD SetCursor(imgIContainer* aCursor,
+ uint32_t aHotspotX, uint32_t aHotspotY) override;
+ NS_IMETHOD SetCursor(nsCursor aCursor) override;
+ virtual nsresult ConfigureChildren(const nsTArray<Configuration>& aConfigurations) override;
+ virtual bool PrepareForFullscreenTransition(nsISupports** aData) override;
+ virtual void PerformFullscreenTransition(FullscreenTransitionStage aStage,
+ uint16_t aDuration,
+ nsISupports* aData,
+ nsIRunnable* aCallback) override;
+ virtual nsresult MakeFullScreen(bool aFullScreen,
+ nsIScreen* aScreen = nullptr) override;
+ NS_IMETHOD HideWindowChrome(bool aShouldHide) override;
+ NS_IMETHOD Invalidate(bool aEraseBackground = false,
+ bool aUpdateNCArea = false,
+ bool aIncludeChildren = false);
+ NS_IMETHOD Invalidate(const LayoutDeviceIntRect& aRect);
+ virtual void* GetNativeData(uint32_t aDataType) override;
+ void SetNativeData(uint32_t aDataType, uintptr_t aVal) override;
+ virtual void FreeNativeData(void * data, uint32_t aDataType) override;
+ NS_IMETHOD SetTitle(const nsAString& aTitle) override;
+ NS_IMETHOD SetIcon(const nsAString& aIconSpec) override;
+ virtual LayoutDeviceIntPoint WidgetToScreenOffset() override;
+ virtual LayoutDeviceIntSize ClientToWindowSize(const LayoutDeviceIntSize& aClientSize) override;
+ NS_IMETHOD DispatchEvent(mozilla::WidgetGUIEvent* aEvent,
+ nsEventStatus& aStatus) override;
+ virtual void EnableDragDrop(bool aEnable) override;
+ virtual void CaptureMouse(bool aCapture) override;
+ virtual void CaptureRollupEvents(nsIRollupListener* aListener,
+ bool aDoCapture) override;
+ NS_IMETHOD GetAttention(int32_t aCycleCount) override;
+ virtual bool HasPendingInputEvent() override;
+ virtual LayerManager* GetLayerManager(PLayerTransactionChild* aShadowManager = nullptr,
+ LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE,
+ LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override;
+ NS_IMETHOD OnDefaultButtonLoaded(const LayoutDeviceIntRect& aButtonRect) override;
+ virtual nsresult SynthesizeNativeKeyEvent(int32_t aNativeKeyboardLayout,
+ int32_t aNativeKeyCode,
+ uint32_t aModifierFlags,
+ const nsAString& aCharacters,
+ const nsAString& aUnmodifiedCharacters,
+ nsIObserver* aObserver) override;
+ virtual nsresult SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint,
+ uint32_t aNativeMessage,
+ uint32_t aModifierFlags,
+ nsIObserver* aObserver) override;
+
+ virtual nsresult SynthesizeNativeMouseMove(LayoutDeviceIntPoint aPoint,
+ nsIObserver* aObserver) override
+ { return SynthesizeNativeMouseEvent(aPoint, MOUSEEVENTF_MOVE, 0, aObserver); }
+
+ virtual nsresult SynthesizeNativeMouseScrollEvent(LayoutDeviceIntPoint aPoint,
+ uint32_t aNativeMessage,
+ double aDeltaX,
+ double aDeltaY,
+ double aDeltaZ,
+ uint32_t aModifierFlags,
+ uint32_t aAdditionalFlags,
+ nsIObserver* aObserver) override;
+ NS_IMETHOD_(void) SetInputContext(const InputContext& aContext,
+ const InputContextAction& aAction) override;
+ NS_IMETHOD_(InputContext) GetInputContext() override;
+ NS_IMETHOD_(TextEventDispatcherListener*)
+ GetNativeTextEventDispatcherListener() override;
+#ifdef MOZ_XUL
+ virtual void SetTransparencyMode(nsTransparencyMode aMode) override;
+ virtual nsTransparencyMode GetTransparencyMode() override;
+ virtual void UpdateOpaqueRegion(const LayoutDeviceIntRegion& aOpaqueRegion) override;
+#endif // MOZ_XUL
+ virtual nsIMEUpdatePreference GetIMEUpdatePreference() override;
+ NS_IMETHOD SetNonClientMargins(LayoutDeviceIntMargin& aMargins) override;
+ void SetDrawsInTitlebar(bool aState) override;
+ virtual void UpdateWindowDraggingRegion(const LayoutDeviceIntRegion& aRegion) override;
+
+ virtual void UpdateThemeGeometries(const nsTArray<ThemeGeometry>& aThemeGeometries) override;
+ virtual uint32_t GetMaxTouchPoints() const override;
+
+ /**
+ * Event helpers
+ */
+ virtual bool DispatchMouseEvent(
+ mozilla::EventMessage aEventMessage,
+ WPARAM wParam,
+ LPARAM lParam,
+ bool aIsContextMenuKey = false,
+ int16_t aButton =
+ mozilla::WidgetMouseEvent::eLeftButton,
+ uint16_t aInputSource =
+ nsIDOMMouseEvent::MOZ_SOURCE_MOUSE,
+ uint16_t aPointerId = 0);
+ virtual bool DispatchWindowEvent(mozilla::WidgetGUIEvent* aEvent,
+ nsEventStatus& aStatus);
+ void DispatchPendingEvents();
+ bool DispatchPluginEvent(UINT aMessage,
+ WPARAM aWParam,
+ LPARAM aLParam,
+ bool aDispatchPendingEvents);
+
+ void SuppressBlurEvents(bool aSuppress); // Called from nsFilePicker
+ bool BlurEventsSuppressed();
+#ifdef ACCESSIBILITY
+ /**
+ * Return an accessible associated with the window.
+ */
+ mozilla::a11y::Accessible* GetAccessible();
+#endif // ACCESSIBILITY
+
+ /**
+ * Window utilities
+ */
+ nsWindow* GetTopLevelWindow(bool aStopOnDialogOrPopup);
+ WNDPROC GetPrevWindowProc() { return mPrevWndProc; }
+ WindowHook& GetWindowHook() { return mWindowHook; }
+ nsWindow* GetParentWindow(bool aIncludeOwner);
+ // Get an array of all nsWindow*s on the main thread.
+ typedef void (WindowEnumCallback)(nsWindow*);
+ static void EnumAllWindows(WindowEnumCallback aCallback);
+
+ /**
+ * Misc.
+ */
+ virtual bool AutoErase(HDC dc);
+ bool WidgetTypeSupportsAcceleration() override;
+
+ void ForcePresent();
+
+ /**
+ * AssociateDefaultIMC() associates or disassociates the default IMC for
+ * the window.
+ *
+ * @param aAssociate TRUE, associates the default IMC with the window.
+ * Otherwise, disassociates the default IMC from the
+ * window.
+ * @return TRUE if this method associated the default IMC with
+ * disassociated window or disassociated the default IMC
+ * from associated window.
+ * Otherwise, i.e., if this method did nothing actually,
+ * FALSE.
+ */
+ bool AssociateDefaultIMC(bool aAssociate);
+
+ bool HasTaskbarIconBeenCreated() { return mHasTaskbarIconBeenCreated; }
+ // Called when either the nsWindow or an nsITaskbarTabPreview receives the noticiation that this window
+ // has its icon placed on the taskbar.
+ void SetHasTaskbarIconBeenCreated(bool created = true) { mHasTaskbarIconBeenCreated = created; }
+
+ // Getter/setter for the nsITaskbarWindowPreview for this nsWindow
+ already_AddRefed<nsITaskbarWindowPreview> GetTaskbarPreview() {
+ nsCOMPtr<nsITaskbarWindowPreview> preview(do_QueryReferent(mTaskbarPreview));
+ return preview.forget();
+ }
+ void SetTaskbarPreview(nsITaskbarWindowPreview *preview) { mTaskbarPreview = do_GetWeakReference(preview); }
+
+ virtual void ReparentNativeWidget(nsIWidget* aNewParent) override;
+
+ // Open file picker tracking
+ void PickerOpen();
+ void PickerClosed();
+
+ bool const DestroyCalled() { return mDestroyCalled; }
+
+ bool IsPopup();
+ virtual bool ShouldUseOffMainThreadCompositing() override;
+
+ const IMEContext& DefaultIMC() const { return mDefaultIMC; }
+
+ virtual void SetCandidateWindowForPlugin(
+ const mozilla::widget::CandidateWindowPosition&
+ aPosition) override;
+ virtual void DefaultProcOfPluginEvent(
+ const mozilla::WidgetPluginEvent& aEvent) override;
+ virtual nsresult OnWindowedPluginKeyEvent(
+ const mozilla::NativeEventData& aKeyEventData,
+ nsIKeyEventInPluginCallback* aCallback) override;
+
+ void GetCompositorWidgetInitData(mozilla::widget::CompositorWidgetInitData* aInitData) override;
+ bool IsTouchWindow() const { return mTouchWindow; }
+
+protected:
+ virtual ~nsWindow();
+
+ virtual void WindowUsesOMTC() override;
+ virtual void RegisterTouchWindow() override;
+
+ // A magic number to identify the FAKETRACKPOINTSCROLLABLE window created
+ // when the trackpoint hack is enabled.
+ enum { eFakeTrackPointScrollableID = 0x46545053 };
+
+ // Used for displayport suppression during window resize
+ enum ResizeState {
+ NOT_RESIZING,
+ IN_SIZEMOVE,
+ RESIZING,
+ MOVING
+ };
+
+ /**
+ * Callbacks
+ */
+ static LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
+ static LRESULT CALLBACK WindowProcInternal(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
+
+ static BOOL CALLBACK BroadcastMsgToChildren(HWND aWnd, LPARAM aMsg);
+ static BOOL CALLBACK BroadcastMsg(HWND aTopWindow, LPARAM aMsg);
+ static BOOL CALLBACK DispatchStarvedPaints(HWND aTopWindow, LPARAM aMsg);
+ static BOOL CALLBACK RegisterTouchForDescendants(HWND aTopWindow, LPARAM aMsg);
+ static BOOL CALLBACK UnregisterTouchForDescendants(HWND aTopWindow, LPARAM aMsg);
+ static LRESULT CALLBACK MozSpecialMsgFilter(int code, WPARAM wParam, LPARAM lParam);
+ static LRESULT CALLBACK MozSpecialWndProc(int code, WPARAM wParam, LPARAM lParam);
+ static LRESULT CALLBACK MozSpecialMouseProc(int code, WPARAM wParam, LPARAM lParam);
+ static VOID CALLBACK HookTimerForPopups( HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime );
+ static BOOL CALLBACK ClearResourcesCallback(HWND aChild, LPARAM aParam);
+ static BOOL CALLBACK EnumAllChildWindProc(HWND aWnd, LPARAM aParam);
+ static BOOL CALLBACK EnumAllThreadWindowProc(HWND aWnd, LPARAM aParam);
+
+ /**
+ * Window utilities
+ */
+ LPARAM lParamToScreen(LPARAM lParam);
+ LPARAM lParamToClient(LPARAM lParam);
+ virtual void SubclassWindow(BOOL bState);
+ bool CanTakeFocus();
+ bool UpdateNonClientMargins(int32_t aSizeMode = -1, bool aReflowWindow = true);
+ void UpdateGetWindowInfoCaptionStatus(bool aActiveCaption);
+ void ResetLayout();
+ void InvalidateNonClientRegion();
+ HRGN ExcludeNonClientFromPaintRegion(HRGN aRegion);
+ static const wchar_t* GetMainWindowClass();
+ bool HasGlass() const {
+ return mTransparencyMode == eTransparencyGlass ||
+ mTransparencyMode == eTransparencyBorderlessGlass;
+ }
+ HWND GetOwnerWnd() const
+ {
+ return ::GetWindow(mWnd, GW_OWNER);
+ }
+ bool IsOwnerForegroundWindow() const
+ {
+ HWND owner = GetOwnerWnd();
+ return owner && owner == ::GetForegroundWindow();
+ }
+ bool IsPopup() const
+ {
+ return mWindowType == eWindowType_popup;
+ }
+
+
+ /**
+ * Event processing helpers
+ */
+ void DispatchFocusToTopLevelWindow(bool aIsActivate);
+ bool DispatchStandardEvent(mozilla::EventMessage aMsg);
+ void RelayMouseEvent(UINT aMsg, WPARAM wParam, LPARAM lParam);
+ virtual bool ProcessMessage(UINT msg, WPARAM &wParam,
+ LPARAM &lParam, LRESULT *aRetValue);
+ bool ExternalHandlerProcessMessage(
+ UINT aMessage, WPARAM& aWParam,
+ LPARAM& aLParam, MSGResult& aResult);
+ bool ProcessMessageForPlugin(const MSG &aMsg,
+ MSGResult& aResult);
+ LRESULT ProcessCharMessage(const MSG &aMsg,
+ bool *aEventDispatched);
+ LRESULT ProcessKeyUpMessage(const MSG &aMsg,
+ bool *aEventDispatched);
+ LRESULT ProcessKeyDownMessage(const MSG &aMsg,
+ bool *aEventDispatched);
+ static bool EventIsInsideWindow(nsWindow* aWindow);
+ // Convert nsEventStatus value to a windows boolean
+ static bool ConvertStatus(nsEventStatus aStatus);
+ static void PostSleepWakeNotification(const bool aIsSleepMode);
+ int32_t ClientMarginHitTestPoint(int32_t mx, int32_t my);
+ TimeStamp GetMessageTimeStamp(LONG aEventTime) const;
+ static void UpdateFirstEventTime(DWORD aEventTime);
+ void FinishLiveResizing(ResizeState aNewState);
+
+ /**
+ * Event handlers
+ */
+ virtual void OnDestroy() override;
+ virtual bool OnResize(nsIntRect &aWindowRect);
+ bool OnGesture(WPARAM wParam, LPARAM lParam);
+ bool OnTouch(WPARAM wParam, LPARAM lParam);
+ bool OnHotKey(WPARAM wParam, LPARAM lParam);
+ bool OnPaint(HDC aDC, uint32_t aNestingLevel);
+ void OnWindowPosChanged(WINDOWPOS* wp);
+ void OnWindowPosChanging(LPWINDOWPOS& info);
+ void OnSysColorChanged();
+ void OnDPIChanged(int32_t x, int32_t y,
+ int32_t width, int32_t height);
+
+ /**
+ * Function that registers when the user has been active (used for detecting
+ * when the user is idle).
+ */
+ void UserActivity();
+
+ int32_t GetHeight(int32_t aProposedHeight);
+ const wchar_t* GetWindowClass() const;
+ const wchar_t* GetWindowPopupClass() const;
+ virtual DWORD WindowStyle();
+ DWORD WindowExStyle();
+
+ // This method registers the given window class, and returns the class name.
+ const wchar_t* RegisterWindowClass(const wchar_t* aClassName,
+ UINT aExtraStyle,
+ LPWSTR aIconID) const;
+
+ /**
+ * XP and Vista theming support for windows with rounded edges
+ */
+ void ClearThemeRegion();
+ void SetThemeRegion();
+
+ /**
+ * Popup hooks
+ */
+ static void ScheduleHookTimer(HWND aWnd, UINT aMsgId);
+ static void RegisterSpecialDropdownHooks();
+ static void UnregisterSpecialDropdownHooks();
+ static bool GetPopupsToRollup(nsIRollupListener* aRollupListener,
+ uint32_t* aPopupsToRollup);
+ static bool NeedsToHandleNCActivateDelayed(HWND aWnd);
+ static bool DealWithPopups(HWND inWnd, UINT inMsg, WPARAM inWParam, LPARAM inLParam, LRESULT* outResult);
+
+ /**
+ * Window transparency helpers
+ */
+#ifdef MOZ_XUL
+private:
+ void SetWindowTranslucencyInner(nsTransparencyMode aMode);
+ nsTransparencyMode GetWindowTranslucencyInner() const { return mTransparencyMode; }
+ void UpdateGlass();
+protected:
+#endif // MOZ_XUL
+
+ static bool IsAsyncResponseEvent(UINT aMsg, LRESULT& aResult);
+ void IPCWindowProcHandler(UINT& msg, WPARAM& wParam, LPARAM& lParam);
+
+ /**
+ * Misc.
+ */
+ void StopFlashing();
+ static bool IsTopLevelMouseExit(HWND aWnd);
+ virtual nsresult SetWindowClipRegion(const nsTArray<LayoutDeviceIntRect>& aRects,
+ bool aIntersectWithExisting) override;
+ nsIntRegion GetRegionToPaint(bool aForceFullRepaint,
+ PAINTSTRUCT ps, HDC aDC);
+ static void ActivateOtherWindowHelper(HWND aWnd);
+ void ClearCachedResources();
+ nsIWidgetListener* GetPaintListener();
+
+ already_AddRefed<SourceSurface> CreateScrollSnapshot() override;
+
+ struct ScrollSnapshot
+ {
+ RefPtr<gfxWindowsSurface> surface;
+ bool surfaceHasSnapshot = false;
+ RECT clip;
+ };
+
+ ScrollSnapshot* EnsureSnapshotSurface(ScrollSnapshot& aSnapshotData,
+ const mozilla::gfx::IntSize& aSize);
+
+ ScrollSnapshot mFullSnapshot;
+ ScrollSnapshot mPartialSnapshot;
+ ScrollSnapshot* mCurrentSnapshot = nullptr;
+
+ already_AddRefed<SourceSurface>
+ GetFallbackScrollSnapshot(const RECT& aRequiredClip);
+
+protected:
+ nsCOMPtr<nsIWidget> mParent;
+ nsIntSize mLastSize;
+ nsIntPoint mLastPoint;
+ HWND mWnd;
+ HWND mTransitionWnd;
+ WNDPROC mPrevWndProc;
+ HBRUSH mBrush;
+ IMEContext mDefaultIMC;
+ bool mIsTopWidgetWindow;
+ bool mInDtor;
+ bool mIsVisible;
+ bool mUnicodeWidget;
+ bool mPainting;
+ bool mTouchWindow;
+ bool mDisplayPanFeedback;
+ bool mHideChrome;
+ bool mIsRTL;
+ bool mFullscreenMode;
+ bool mMousePresent;
+ bool mDestroyCalled;
+ uint32_t mBlurSuppressLevel;
+ DWORD_PTR mOldStyle;
+ DWORD_PTR mOldExStyle;
+ nsNativeDragTarget* mNativeDragTarget;
+ HKL mLastKeyboardLayout;
+ nsSizeMode mOldSizeMode;
+ nsSizeMode mLastSizeMode;
+ WindowHook mWindowHook;
+ uint32_t mPickerDisplayCount;
+ HICON mIconSmall;
+ HICON mIconBig;
+ static bool sDropShadowEnabled;
+ static uint32_t sInstanceCount;
+ static TriStateBool sCanQuit;
+ static nsWindow* sCurrentWindow;
+ static BOOL sIsOleInitialized;
+ static HCURSOR sHCursor;
+ static imgIContainer* sCursorImgContainer;
+ static bool sSwitchKeyboardLayout;
+ static bool sJustGotDeactivate;
+ static bool sJustGotActivate;
+ static bool sIsInMouseCapture;
+ static int sTrimOnMinimize;
+
+ // Always use the helper method to read this property. See bug 603793.
+ static TriStateBool sHasBogusPopupsDropShadowOnMultiMonitor;
+ static bool HasBogusPopupsDropShadowOnMultiMonitor();
+
+ // Non-client margin settings
+ // Pre-calculated outward offset applied to default frames
+ LayoutDeviceIntMargin mNonClientOffset;
+ // Margins set by the owner
+ LayoutDeviceIntMargin mNonClientMargins;
+ // Margins we'd like to set once chrome is reshown:
+ LayoutDeviceIntMargin mFutureMarginsOnceChromeShows;
+ // Indicates we need to apply margins once toggling chrome into showing:
+ bool mFutureMarginsToUse;
+
+ // Indicates custom frames are enabled
+ bool mCustomNonClient;
+ // Cached copy of L&F's resize border
+ int32_t mHorResizeMargin;
+ int32_t mVertResizeMargin;
+ // Height of the caption plus border
+ int32_t mCaptionHeight;
+
+ double mDefaultScale;
+
+ nsCOMPtr<nsIIdleServiceInternal> mIdleService;
+
+ // Draggable titlebar region maintained by UpdateWindowDraggingRegion
+ LayoutDeviceIntRegion mDraggableRegion;
+
+ // Hook Data Memebers for Dropdowns. sProcessHook Tells the
+ // hook methods whether they should be processing the hook
+ // messages.
+ static HHOOK sMsgFilterHook;
+ static HHOOK sCallProcHook;
+ static HHOOK sCallMouseHook;
+ static bool sProcessHook;
+ static UINT sRollupMsgId;
+ static HWND sRollupMsgWnd;
+ static UINT sHookTimerId;
+
+ // Mouse Clicks - static variable definitions for figuring
+ // out 1 - 3 Clicks.
+ static POINT sLastMousePoint;
+ static POINT sLastMouseMovePoint;
+ static LONG sLastMouseDownTime;
+ static LONG sLastClickCount;
+ static BYTE sLastMouseButton;
+
+ // Graphics
+ HDC mPaintDC; // only set during painting
+
+ LayoutDeviceIntRect mLastPaintBounds;
+
+ ResizeState mResizeState;
+
+ // Transparency
+#ifdef MOZ_XUL
+ nsTransparencyMode mTransparencyMode;
+ nsIntRegion mPossiblyTransparentRegion;
+ MARGINS mGlassMargins;
+#endif // MOZ_XUL
+
+ // Win7 Gesture processing and management
+ nsWinGesture mGesture;
+
+ // Weak ref to the nsITaskbarWindowPreview associated with this window
+ nsWeakPtr mTaskbarPreview;
+ // True if the taskbar (possibly through the tab preview) tells us that the
+ // icon has been created on the taskbar.
+ bool mHasTaskbarIconBeenCreated;
+
+ // Indicates that mouse events should be ignored and pass through to the
+ // window below. This is currently only used for popups.
+ bool mMouseTransparent;
+
+ // Whether we're in the process of sending a WM_SETTEXT ourselves
+ bool mSendingSetText;
+
+ // The point in time at which the last paint completed. We use this to avoid
+ // painting too rapidly in response to frequent input events.
+ TimeStamp mLastPaintEndTime;
+
+ // Caching for hit test results
+ POINT mCachedHitTestPoint;
+ TimeStamp mCachedHitTestTime;
+ int32_t mCachedHitTestResult;
+
+ RefPtr<mozilla::widget::WinCompositorWidget> mBasicLayersSurface;
+
+ static bool sNeedsToInitMouseWheelSettings;
+ static void InitMouseWheelScrollData();
+
+ double mSizeConstraintsScale; // scale in effect when setting constraints
+
+ // Used to remember the wParam (i.e. currently pressed modifier keys)
+ // and lParam (i.e. last mouse position) in screen coordinates from
+ // the previous mouse-exit. Static since it is not
+ // associated with a particular widget (since we exited the widget).
+ static WPARAM sMouseExitwParam;
+ static LPARAM sMouseExitlParamScreen;
+};
+
+/**
+ * A child window is a window with different style.
+ */
+class ChildWindow : public nsWindow {
+
+public:
+ ChildWindow() {}
+
+protected:
+ virtual DWORD WindowStyle();
+};
+
+#endif // Window_h__