diff options
Diffstat (limited to 'widget/windows/nsWindow.h')
| -rw-r--r-- | widget/windows/nsWindow.h | 671 |
1 files changed, 671 insertions, 0 deletions
diff --git a/widget/windows/nsWindow.h b/widget/windows/nsWindow.h new file mode 100644 index 0000000000..248978bd79 --- /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__ |