diff options
Diffstat (limited to 'widget/windows/nsWindow.h')
| -rw-r--r-- | widget/windows/nsWindow.h | 747 |
1 files changed, 747 insertions, 0 deletions
diff --git a/widget/windows/nsWindow.h b/widget/windows/nsWindow.h new file mode 100644 index 0000000000..20e8447c0a --- /dev/null +++ b/widget/windows/nsWindow.h @@ -0,0 +1,747 @@ +/* -*- 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 "CompositorWidget.h" +#include "nsWindowBase.h" +#include "nsdefs.h" +#include "nsUserIdleService.h" +#include "nsToolkit.h" +#include "nsString.h" +#include "nsTArray.h" +#include "gfxWindowsPlatform.h" +#include "gfxWindowsSurface.h" +#include "nsWindowDbg.h" +#include "cairo.h" +#include "nsRegion.h" +#include "mozilla/EventForwards.h" +#include "mozilla/Maybe.h" +#include "mozilla/MouseEvents.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/webrender/WebRenderTypes.h" +#include "mozilla/dom/MouseEventBinding.h" +#include "mozilla/UniquePtr.h" +#include "nsMargin.h" +#include "nsRegionFwd.h" + +#include "nsWinGesture.h" +#include "WinPointerEvents.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 "nsIUserIdleServiceInternal.h" + +#include "IMMHandler.h" + +/** + * Forward class definitions + */ + +class nsNativeDragTarget; +class nsIRollupListener; +class imgIContainer; + +namespace mozilla { +namespace widget { +class NativeKey; +class InProcessWinCompositorWidget; +struct MSGResult; +class DirectManipulationOwner; +} // namespace widget +} // namespace mozilla + +/** + * Forward Windows-internal definitions of otherwise incomplete ones provided by + * the SDK. + */ +const CLSID CLSID_ImmersiveShell = { + 0xC2F03A33, + 0x21F5, + 0x47FA, + {0xB4, 0xBB, 0x15, 0x63, 0x62, 0xA2, 0xF2, 0x39}}; + +// Virtual Desktop. + +EXTERN_C const IID IID_IVirtualDesktopManager; +MIDL_INTERFACE("a5cd92ff-29be-454c-8d04-d82879fb3f1b") +IVirtualDesktopManager : public IUnknown { + public: + virtual HRESULT STDMETHODCALLTYPE GetWindowDesktopId( + __RPC__in HWND topLevelWindow, __RPC__out GUID * desktopId) = 0; + virtual HRESULT STDMETHODCALLTYPE MoveWindowToDesktop( + __RPC__in HWND topLevelWindow, __RPC__in REFGUID desktopId) = 0; +}; + +/** + * Native WIN32 window wrapper. + */ + +class nsWindow final : 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; + typedef mozilla::widget::PlatformCompositorWidgetDelegate + PlatformCompositorWidgetDelegate; + + public: + explicit nsWindow(bool aIsChildWindow = false); + + NS_INLINE_DECL_REFCOUNTING_INHERITED(nsWindow, nsWindowBase) + + friend class nsWindowGfx; + + void SendAnAPZEvent(mozilla::InputData& aEvent); + + // 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 + [[nodiscard]] virtual nsresult Create( + nsIWidget* aParent, nsNativeWidget aNativeParent, + const LayoutDeviceIntRect& aRect, + nsWidgetInitData* aInitData = nullptr) override; + virtual void Destroy() override; + virtual void 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()); + } + } + + virtual void Show(bool aState) 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 void LockAspectRatio(bool aShouldLock) override; + virtual const SizeConstraints GetSizeConstraints() override; + virtual void SetWindowMouseTransparent(bool aIsTransparent) override; + virtual void Move(double aX, double aY) override; + virtual void Resize(double aWidth, double aHeight, bool aRepaint) override; + virtual void Resize(double aX, double aY, double aWidth, double aHeight, + bool aRepaint) override; + virtual mozilla::Maybe<bool> IsResizingNativeWidget() override; + [[nodiscard]] virtual nsresult 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; + virtual void GetWorkspaceID(nsAString& workspaceID) override; + virtual void MoveToWorkspace(const nsAString& workspaceID) override; + virtual void SuppressAnimation(bool aSuppress) override; + virtual void Enable(bool aState) override; + virtual bool IsEnabled() const override; + virtual void SetFocus(Raise, mozilla::dom::CallerType aCallerType) override; + virtual LayoutDeviceIntRect GetBounds() override; + virtual LayoutDeviceIntRect GetScreenBounds() override; + [[nodiscard]] virtual nsresult GetRestoredBounds( + LayoutDeviceIntRect& aRect) override; + virtual LayoutDeviceIntRect GetClientBounds() override; + virtual LayoutDeviceIntPoint GetClientOffset() override; + void SetBackgroundColor(const nscolor& aColor) override; + virtual void SetCursor(nsCursor aDefaultCursor, imgIContainer* aCursorImage, + uint32_t aHotspotX, uint32_t aHotspotY) 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 void CleanupFullscreenTransition() override; + virtual nsresult MakeFullScreen(bool aFullScreen, + nsIScreen* aScreen = nullptr) override; + virtual void HideWindowChrome(bool aShouldHide) override; + virtual void Invalidate(bool aEraseBackground = false, + bool aUpdateNCArea = false, + bool aIncludeChildren = false); + virtual void 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; + virtual nsresult SetTitle(const nsAString& aTitle) override; + virtual void SetIcon(const nsAString& aIconSpec) override; + virtual LayoutDeviceIntPoint WidgetToScreenOffset() override; + virtual LayoutDeviceIntSize ClientToWindowSize( + const LayoutDeviceIntSize& aClientSize) override; + virtual nsresult 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; + [[nodiscard]] virtual nsresult 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; + void SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) override; + [[nodiscard]] virtual nsresult 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; + virtual void SetInputContext(const InputContext& aContext, + const InputContextAction& aAction) override; + virtual InputContext GetInputContext() override; + virtual 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 nsresult 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; + virtual void SetWindowClass(const nsAString& xulWinType) override; + + /** + * Event helpers + */ + virtual bool DispatchMouseEvent( + mozilla::EventMessage aEventMessage, WPARAM wParam, LPARAM lParam, + bool aIsContextMenuKey = false, + int16_t aButton = mozilla::MouseButton::ePrimary, + uint16_t aInputSource = + mozilla::dom::MouseEvent_Binding::MOZ_SOURCE_MOUSE, + WinPointerInfo* aPointerInfo = nullptr); + virtual bool DispatchWindowEvent(mozilla::WidgetGUIEvent* aEvent, + nsEventStatus& aStatus); + void DispatchPendingEvents(); + bool DispatchPluginEvent(UINT aMessage, WPARAM aWParam, LPARAM aLParam, + bool aDispatchPendingEvents); + void DispatchCustomEvent(const nsString& eventName); + +#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. + static nsTArray<nsWindow*> EnumAllWindows(); + + /** + * Misc. + */ + virtual bool AutoErase(HDC dc); + bool WidgetTypeSupportsAcceleration() override; + + void ForcePresent(); + bool TouchEventShouldStartDrag(mozilla::EventMessage aEventMessage, + LayoutDeviceIntPoint aEventPoint); + + void SetSmallIcon(HICON aIcon); + void SetBigIcon(HICON aIcon); + + static void SetIsRestoringSession(const bool aIsRestoringSession) { + sIsRestoringSession = aIsRestoringSession; + } + + /** + * 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 nsresult OnWindowedPluginKeyEvent( + const mozilla::NativeEventData& aKeyEventData, + nsIKeyEventInPluginCallback* aCallback) override; + + void GetCompositorWidgetInitData( + mozilla::widget::CompositorWidgetInitData* aInitData) override; + bool IsTouchWindow() const { return mTouchWindow; } + bool SynchronouslyRepaintOnResize() override; + virtual void MaybeDispatchInitialFocusEvent() override; + + 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 + */ + HWND GetTopLevelForFocus(HWND aCurWnd); + 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); + 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, + mozilla::Maybe<POINT> aEventPoint = mozilla::Nothing()); + // 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); + nsIntPoint GetTouchCoordinates(WPARAM wParam, LPARAM lParam); + mozilla::Maybe<mozilla::PanGestureInput> ConvertTouchToPanGesture( + const mozilla::MultiTouchInput& aTouchInput, PTOUCHINPUT aOriginalEvent); + void DispatchTouchOrPanGestureInput(mozilla::MultiTouchInput& aTouchInput, + PTOUCHINPUT aOSEvent); + + /** + * Event handlers + */ + virtual void OnDestroy() override; + bool OnResize(const LayoutDeviceIntSize& aSize); + void OnSizeModeChange(nsSizeMode aSizeMode); + 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); + bool OnPointerEvents(UINT msg, WPARAM wParam, LPARAM lParam); + + /** + * 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, + mozilla::Maybe<POINT> aEventPoint = mozilla::Nothing()); + 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(); + bool WithinDraggableRegion(int32_t clientX, int32_t clientY); + + protected: +#endif // MOZ_XUL + + static bool IsAsyncResponseEvent(UINT aMsg, LRESULT& aResult); + void IPCWindowProcHandler(UINT& msg, WPARAM& wParam, LPARAM& lParam); + + /** + * Misc. + */ + void StopFlashing(); + static HWND WindowAtMouse(); + static bool IsTopLevelMouseExit(HWND aWnd); + virtual nsresult SetWindowClipRegion( + const nsTArray<LayoutDeviceIntRect>& aRects, + bool aIntersectWithExisting) override; + LayoutDeviceIntRegion GetRegionToPaint(bool aForceFullRepaint, PAINTSTRUCT ps, + HDC aDC); + void ClearCachedResources(); + nsIWidgetListener* GetPaintListener(); + + virtual void AddWindowOverlayWebRenderCommands( + mozilla::layers::WebRenderBridgeChild* aWrBridge, + mozilla::wr::DisplayListBuilder& aBuilder, + mozilla::wr::IpcResourceUpdateQueue& aResourceUpdates) override; + + 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); + + void CreateCompositor() override; + void RequestFxrOutput(); + + void RecreateDirectManipulationIfNeeded(); + void ResizeDirectManipulationViewport(); + void DestroyDirectManipulation(); + + protected: + nsCOMPtr<nsIWidget> mParent; + nsIntSize mLastSize; + nsIntPoint mLastPoint; + HWND mWnd; + HWND mTransitionWnd; + WNDPROC mPrevWndProc; + HBRUSH mBrush; + IMEContext mDefaultIMC; + HDEVNOTIFY mDeviceNotifyHandle; + bool mIsTopWidgetWindow; + bool mInDtor; + bool mIsVisible; + bool mPainting; + bool mTouchWindow; + bool mDisplayPanFeedback; + bool mHideChrome; + bool mIsRTL; + bool mFullscreenMode; + bool mMousePresent; + bool mMouseInDraggableArea; + bool mDestroyCalled; + bool mOpeningAnimationSuppressed; + bool mAlwaysOnTop; + bool mIsEarlyBlankWindow; + bool mIsShowingPreXULSkeletonUI; + bool mResizable; + DWORD_PTR mOldStyle; + DWORD_PTR mOldExStyle; + nsNativeDragTarget* mNativeDragTarget; + HKL mLastKeyboardLayout; + nsSizeMode mOldSizeMode; + nsSizeMode mLastSizeMode; + WindowHook mWindowHook; + uint32_t mPickerDisplayCount; + HICON mIconSmall; + HICON mIconBig; + HWND mLastKillFocusWindow; + 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 bool sHaveInitializedPrefs; + static bool sIsRestoringSession; + + PlatformCompositorWidgetDelegate* mCompositorWidgetDelegate; + + // 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; + + float mAspectRatio; + + nsCOMPtr<nsIUserIdleServiceInternal> 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; + + // Whether we we're created as a child window (aka ChildWindow) or not. + bool mIsChildWindow : 1; + + int32_t mCachedHitTestResult; + + // 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; + + // The location of the window buttons in the window. + mozilla::Maybe<LayoutDeviceIntRect> mWindowButtonsRect; + + // Caching for hit test results + POINT mCachedHitTestPoint; + TimeStamp mCachedHitTestTime; + + RefPtr<mozilla::widget::InProcessWinCompositorWidget> mBasicLayersSurface; + + static bool sNeedsToInitMouseWheelSettings; + static void InitMouseWheelScrollData(); + + double mSizeConstraintsScale; // scale in effect when setting constraints + int32_t mMaxTextureSize; + + // Pointer events processing and management + WinPointerEvents mPointerEvents; + + ScreenPoint mLastPanGestureFocus; + + // When true, used to indicate an async call to RequestFxrOutput to the GPU + // process after the Compositor is created + bool mRequestFxrOutputPending; + + mozilla::UniquePtr<mozilla::widget::DirectManipulationOwner> mDmOwner; +}; + +#endif // Window_h__ |