diff options
Diffstat (limited to '')
| -rw-r--r-- | widget/gtk/nsWindow.h | 719 |
1 files changed, 719 insertions, 0 deletions
diff --git a/widget/gtk/nsWindow.h b/widget/gtk/nsWindow.h new file mode 100644 index 0000000000..5bfdcd9291 --- /dev/null +++ b/widget/gtk/nsWindow.h @@ -0,0 +1,719 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:expandtab:shiftwidth=4:tabstop=4: + */ +/* 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 __nsWindow_h__ +#define __nsWindow_h__ + +#include <gdk/gdk.h> +#include <gtk/gtk.h> +#ifdef MOZ_X11 +# include <gdk/gdkx.h> +# include "X11UndefineNone.h" +#endif /* MOZ_X11 */ +#ifdef MOZ_WAYLAND +# include <gdk/gdkwayland.h> +# include "base/thread.h" +# include "WaylandVsyncSource.h" +#endif +#include "MozContainer.h" +#include "mozilla/RefPtr.h" +#include "mozilla/UniquePtr.h" +#include "nsIDragService.h" +#include "nsGkAtoms.h" +#include "nsRefPtrHashtable.h" +#include "nsBaseWidget.h" +#include "CompositorWidget.h" +#include "mozilla/widget/WindowSurface.h" +#include "mozilla/widget/WindowSurfaceProvider.h" +#include "mozilla/Maybe.h" + +#ifdef ACCESSIBILITY +# include "mozilla/a11y/Accessible.h" +#endif +#include "mozilla/EventForwards.h" +#include "mozilla/TouchEvents.h" + +#include "IMContextWrapper.h" + +#undef LOG +#ifdef MOZ_LOGGING + +# include "mozilla/Logging.h" +# include "nsTArray.h" +# include "Units.h" + +extern mozilla::LazyLogModule gWidgetLog; +extern mozilla::LazyLogModule gWidgetFocusLog; +extern mozilla::LazyLogModule gWidgetDragLog; +extern mozilla::LazyLogModule gWidgetDrawLog; + +# define LOG(args) MOZ_LOG(gWidgetLog, mozilla::LogLevel::Debug, args) +# define LOGFOCUS(args) \ + MOZ_LOG(gWidgetFocusLog, mozilla::LogLevel::Debug, args) +# define LOGDRAG(args) MOZ_LOG(gWidgetDragLog, mozilla::LogLevel::Debug, args) +# define LOGDRAW(args) MOZ_LOG(gWidgetDrawLog, mozilla::LogLevel::Debug, args) + +#else + +# define LOG(args) +# define LOGFOCUS(args) +# define LOGDRAG(args) +# define LOGDRAW(args) + +#endif /* MOZ_LOGGING */ + +#ifdef MOZ_WAYLAND +class nsWaylandDragContext; + +gboolean WindowDragMotionHandler(GtkWidget* aWidget, + GdkDragContext* aDragContext, + nsWaylandDragContext* aWaylandDragContext, + gint aX, gint aY, guint aTime); +gboolean WindowDragDropHandler(GtkWidget* aWidget, GdkDragContext* aDragContext, + nsWaylandDragContext* aWaylandDragContext, + gint aX, gint aY, guint aTime); +void WindowDragLeaveHandler(GtkWidget* aWidget); +#endif + +class gfxPattern; +class nsIFrame; +#if !GTK_CHECK_VERSION(3, 18, 0) +struct _GdkEventTouchpadPinch; +typedef struct _GdkEventTouchpadPinch GdkEventTouchpadPinch; + +#endif + +namespace mozilla { +class TimeStamp; +class CurrentX11TimeGetter; + +} // namespace mozilla + +class nsWindow final : public nsBaseWidget { + public: + typedef mozilla::gfx::DrawTarget DrawTarget; + typedef mozilla::WidgetEventTime WidgetEventTime; + typedef mozilla::WidgetKeyboardEvent WidgetKeyboardEvent; + typedef mozilla::widget::PlatformCompositorWidgetDelegate + PlatformCompositorWidgetDelegate; + + nsWindow(); + + static void ReleaseGlobals(); + + NS_INLINE_DECL_REFCOUNTING_INHERITED(nsWindow, nsBaseWidget) + + void CommonCreate(nsIWidget* aParent, bool aListenForResizes); + + virtual nsresult DispatchEvent(mozilla::WidgetGUIEvent* aEvent, + nsEventStatus& aStatus) override; + + // called when we are destroyed + virtual void OnDestroy(void) override; + + // called to check and see if a widget's dimensions are sane + bool AreBoundsSane(void); + + // nsIWidget + using nsBaseWidget::Create; // for Create signature not overridden here + [[nodiscard]] virtual nsresult Create(nsIWidget* aParent, + nsNativeWidget aNativeParent, + const LayoutDeviceIntRect& aRect, + nsWidgetInitData* aInitData) override; + virtual void Destroy() override; + virtual nsIWidget* GetParent() override; + virtual float GetDPI() override; + virtual double GetDefaultScaleInternal() override; + mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScale() override; + mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScaleByScreen() + override; + virtual void SetParent(nsIWidget* aNewParent) override; + virtual void SetModal(bool aModal) 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 void Move(double aX, double aY) override; + virtual void Show(bool aState) 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 bool IsEnabled() const override; + + void SetZIndex(int32_t aZIndex) override; + virtual void SetSizeMode(nsSizeMode aMode) override; + virtual void GetWorkspaceID(nsAString& workspaceID) override; + virtual void MoveToWorkspace(const nsAString& workspaceID) override; + virtual void Enable(bool aState) override; + virtual void SetFocus(Raise, mozilla::dom::CallerType aCallerType) override; + virtual LayoutDeviceIntRect GetScreenBounds() override; + virtual LayoutDeviceIntRect GetClientBounds() override; + virtual LayoutDeviceIntSize GetClientSize() override; + virtual LayoutDeviceIntPoint GetClientOffset() override; + virtual void SetCursor(nsCursor aDefaultCursor, imgIContainer* aCursor, + uint32_t aHotspotX, uint32_t aHotspotY) override; + virtual void Invalidate(const LayoutDeviceIntRect& aRect) override; + virtual void* GetNativeData(uint32_t aDataType) override; + virtual nsresult SetTitle(const nsAString& aTitle) override; + virtual void SetIcon(const nsAString& aIconSpec) override; + virtual void SetWindowClass(const nsAString& xulWinType) override; + virtual LayoutDeviceIntPoint WidgetToScreenOffset() override; + virtual void CaptureMouse(bool aCapture) override; + virtual void CaptureRollupEvents(nsIRollupListener* aListener, + bool aDoCapture) override; + [[nodiscard]] virtual nsresult GetAttention(int32_t aCycleCount) override; + virtual nsresult SetWindowClipRegion( + const nsTArray<LayoutDeviceIntRect>& aRects, + bool aIntersectWithExisting) override; + virtual bool HasPendingInputEvent() override; + + virtual bool PrepareForFullscreenTransition(nsISupports** aData) override; + virtual void PerformFullscreenTransition(FullscreenTransitionStage aStage, + uint16_t aDuration, + nsISupports* aData, + nsIRunnable* aCallback) override; + virtual already_AddRefed<nsIScreen> GetWidgetScreen() override; + virtual nsresult MakeFullScreen(bool aFullScreen, + nsIScreen* aTargetScreen = nullptr) override; + virtual void HideWindowChrome(bool aShouldHide) override; + + /** + * GetLastUserInputTime returns a timestamp for the most recent user input + * event. This is intended for pointer grab requests (including drags). + */ + static guint32 GetLastUserInputTime(); + + // utility method, -1 if no change should be made, otherwise returns a + // value that can be passed to gdk_window_set_decorations + gint ConvertBorderStyles(nsBorderStyle aStyle); + + GdkRectangle DevicePixelsToGdkRectRoundOut(LayoutDeviceIntRect aRect); + + mozilla::widget::IMContextWrapper* GetIMContext() const { return mIMContext; } + + bool DispatchCommandEvent(nsAtom* aCommand); + bool DispatchContentCommandEvent(mozilla::EventMessage aMsg); + + // event callbacks + gboolean OnExposeEvent(cairo_t* cr); + gboolean OnConfigureEvent(GtkWidget* aWidget, GdkEventConfigure* aEvent); + void OnContainerUnrealize(); + void OnSizeAllocate(GtkAllocation* aAllocation); + void OnDeleteEvent(); + void OnEnterNotifyEvent(GdkEventCrossing* aEvent); + void OnLeaveNotifyEvent(GdkEventCrossing* aEvent); + void OnMotionNotifyEvent(GdkEventMotion* aEvent); + void OnButtonPressEvent(GdkEventButton* aEvent); + void OnButtonReleaseEvent(GdkEventButton* aEvent); + void OnContainerFocusInEvent(GdkEventFocus* aEvent); + void OnContainerFocusOutEvent(GdkEventFocus* aEvent); + gboolean OnKeyPressEvent(GdkEventKey* aEvent); + gboolean OnKeyReleaseEvent(GdkEventKey* aEvent); + + void OnScrollEvent(GdkEventScroll* aEvent); + + void OnWindowStateEvent(GtkWidget* aWidget, GdkEventWindowState* aEvent); + void OnDragDataReceivedEvent(GtkWidget* aWidget, GdkDragContext* aDragContext, + gint aX, gint aY, + GtkSelectionData* aSelectionData, guint aInfo, + guint aTime, gpointer aData); + gboolean OnPropertyNotifyEvent(GtkWidget* aWidget, GdkEventProperty* aEvent); + gboolean OnTouchEvent(GdkEventTouch* aEvent); + gboolean OnTouchpadPinchEvent(GdkEventTouchpadPinch* aEvent); + + void UpdateTopLevelOpaqueRegion(); + + virtual already_AddRefed<mozilla::gfx::DrawTarget> StartRemoteDrawingInRegion( + LayoutDeviceIntRegion& aInvalidRegion, + mozilla::layers::BufferMode* aBufferMode) override; + virtual void EndRemoteDrawingInRegion( + mozilla::gfx::DrawTarget* aDrawTarget, + const LayoutDeviceIntRegion& aInvalidRegion) override; + + void SetProgress(unsigned long progressPercent); + +#ifdef MOZ_WAYLAND + void SetEGLNativeWindowSize(const LayoutDeviceIntSize& aEGLWindowSize); + static nsWindow* GetFocusedWindow(); +#endif + + RefPtr<mozilla::gfx::VsyncSource> GetVsyncSource() override; + + static void WithSettingsChangesIgnored(const std::function<void()>& aFn); + + private: + void UpdateAlpha(mozilla::gfx::SourceSurface* aSourceSurface, + nsIntRect aBoundsRect); + + void NativeMove(); + void NativeResize(); + void NativeMoveResize(); + + void NativeShow(bool aAction); + void SetHasMappedToplevel(bool aState); + LayoutDeviceIntSize GetSafeWindowSize(LayoutDeviceIntSize aSize); + + void EnsureGrabs(void); + void GrabPointer(guint32 aTime); + void ReleaseGrabs(void); + + void UpdateClientOffsetFromFrameExtents(); + void UpdateClientOffsetFromCSDWindow(); + + void DispatchContextMenuEventFromMouseEvent(uint16_t domButton, + GdkEventButton* aEvent); +#ifdef MOZ_WAYLAND + void MaybeResumeCompositor(); +#endif + + void WaylandStartVsync(); + void WaylandStopVsync(); + + public: + void ThemeChanged(void); + void OnDPIChanged(void); + void OnCheckResize(void); + void OnCompositedChanged(void); + void OnScaleChanged(GtkAllocation* aAllocation); + void DispatchResized(); + +#ifdef MOZ_X11 + Window mOldFocusWindow; +#endif /* MOZ_X11 */ + + static guint32 sLastButtonPressTime; + + [[nodiscard]] virtual nsresult BeginResizeDrag( + mozilla::WidgetGUIEvent* aEvent, int32_t aHorizontal, + int32_t aVertical) override; + + MozContainer* GetMozContainer() { return mContainer; } + LayoutDeviceIntRect GetMozContainerSize(); + // GetMozContainerWidget returns the MozContainer even for undestroyed + // descendant windows + GtkWidget* GetMozContainerWidget(); + GdkWindow* GetGdkWindow() { return mGdkWindow; } + GtkWidget* GetGtkWidget() { return mShell; } + nsIFrame* GetFrame(); + bool IsDestroyed() { return mIsDestroyed; } + bool IsPopup(); + bool IsWaylandPopup(); + bool IsPIPWindow() { return mIsPIPWindow; }; + + void DispatchDragEvent(mozilla::EventMessage aMsg, + const LayoutDeviceIntPoint& aRefPoint, guint aTime); + static void UpdateDragStatus(GdkDragContext* aDragContext, + nsIDragService* aDragService); + + WidgetEventTime GetWidgetEventTime(guint32 aEventTime); + mozilla::TimeStamp GetEventTimeStamp(guint32 aEventTime); + mozilla::CurrentX11TimeGetter* GetCurrentTimeGetter(); + + virtual void SetInputContext(const InputContext& aContext, + const InputContextAction& aAction) override; + virtual InputContext GetInputContext() override; + virtual TextEventDispatcherListener* GetNativeTextEventDispatcherListener() + override; + void GetEditCommandsRemapped(NativeKeyBindingsType aType, + const mozilla::WidgetKeyboardEvent& aEvent, + nsTArray<mozilla::CommandInt>& aCommands, + uint32_t aGeckoKeyCode, uint32_t aNativeKeyCode); + virtual bool GetEditCommands( + NativeKeyBindingsType aType, const mozilla::WidgetKeyboardEvent& aEvent, + nsTArray<mozilla::CommandInt>& aCommands) override; + + // These methods are for toplevel windows only. + void ResizeTransparencyBitmap(); + void ApplyTransparencyBitmap(); + void ClearTransparencyBitmap(); + + virtual void SetTransparencyMode(nsTransparencyMode aMode) override; + virtual nsTransparencyMode GetTransparencyMode() override; + virtual void SetWindowMouseTransparent(bool aIsTransparent) override; + virtual nsresult ConfigureChildren( + const nsTArray<Configuration>& aConfigurations) override; + nsresult UpdateTranslucentWindowAlphaInternal(const nsIntRect& aRect, + uint8_t* aAlphas, + int32_t aStride); + void UpdateTitlebarTransparencyBitmap(); + + virtual void ReparentNativeWidget(nsIWidget* aNewParent) 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, GDK_MOTION_NOTIFY, 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 nsresult SynthesizeNativeTouchPoint(uint32_t aPointerId, + TouchPointerState aPointerState, + LayoutDeviceIntPoint aPoint, + double aPointerPressure, + uint32_t aPointerOrientation, + nsIObserver* aObserver) override; + +#ifdef MOZ_X11 + Display* XDisplay() { return mXDisplay; } +#endif +#ifdef MOZ_WAYLAND + wl_display* GetWaylandDisplay(); + bool WaylandSurfaceNeedsClear(); + virtual void CreateCompositorVsyncDispatcher() override; +#endif + virtual void GetCompositorWidgetInitData( + mozilla::widget::CompositorWidgetInitData* aInitData) override; + + virtual nsresult SetNonClientMargins( + LayoutDeviceIntMargin& aMargins) override; + void SetDrawsInTitlebar(bool aState) override; + bool GetTitlebarRect(mozilla::gfx::Rect& aRect); + virtual void UpdateWindowDraggingRegion( + const LayoutDeviceIntRegion& aRegion) override; + + // HiDPI scale conversion + gint GdkScaleFactor(); + + // To GDK + gint DevicePixelsToGdkCoordRoundUp(int pixels); + gint DevicePixelsToGdkCoordRoundDown(int pixels); + GdkPoint DevicePixelsToGdkPointRoundDown(LayoutDeviceIntPoint point); + GdkRectangle DevicePixelsToGdkSizeRoundUp(LayoutDeviceIntSize pixelSize); + + // From GDK + int GdkCoordToDevicePixels(gint coord); + LayoutDeviceIntPoint GdkPointToDevicePixels(GdkPoint point); + LayoutDeviceIntPoint GdkEventCoordsToDevicePixels(gdouble x, gdouble y); + LayoutDeviceIntRect GdkRectToDevicePixels(GdkRectangle rect); + + virtual bool WidgetTypeSupportsAcceleration() override; + + nsresult SetSystemFont(const nsCString& aFontName) override; + nsresult GetSystemFont(nsCString& aFontName) override; + + typedef enum { + CSD_SUPPORT_SYSTEM, // CSD including shadows + CSD_SUPPORT_CLIENT, // CSD without shadows + CSD_SUPPORT_NONE, // WM does not support CSD at all + CSD_SUPPORT_UNKNOWN + } CSDSupportLevel; + /** + * Get the support of Client Side Decoration by checking + * the XDG_CURRENT_DESKTOP environment variable. + */ + static CSDSupportLevel GetSystemCSDSupportLevel(bool aIsPopup = false); + + static bool HideTitlebarByDefault(); + static bool GetTopLevelWindowActiveState(nsIFrame* aFrame); + static bool TitlebarUseShapeMask(); +#ifdef MOZ_WAYLAND + virtual nsresult GetScreenRect(LayoutDeviceIntRect* aRect) override; + virtual nsRect GetPreferredPopupRect() override { + return mPreferredPopupRect; + }; + virtual void FlushPreferredPopupRect() override { + mPreferredPopupRect = nsRect(0, 0, 0, 0); + mPreferredPopupRectFlushed = true; + }; +#endif + bool IsRemoteContent() { return HasRemoteContent(); } + static void HideWaylandOpenedPopups(); + void NativeMoveResizeWaylandPopupCB(const GdkRectangle* aFinalSize, + bool aFlippedX, bool aFlippedY); + static bool IsToplevelWindowTransparent(); + + protected: + virtual ~nsWindow(); + + // event handling code + void DispatchActivateEvent(void); + void DispatchDeactivateEvent(void); + void MaybeDispatchResized(); + + virtual void RegisterTouchWindow() override; + virtual bool CompositorInitiallyPaused() override { +#ifdef MOZ_WAYLAND + return mCompositorInitiallyPaused; +#else + return false; +#endif + } + nsCOMPtr<nsIWidget> mParent; + // Is this a toplevel window? + bool mIsTopLevel; + // Has this widget been destroyed yet? + bool mIsDestroyed; + + // Should we send resize events on all resizes? + bool mListenForResizes; + // Does WindowResized need to be called on listeners? + bool mNeedsDispatchResized; + // This flag tracks if we're hidden or shown. + bool mIsShown; + bool mNeedsShow; + // is this widget enabled? + bool mEnabled; + // has the native window for this been created yet? + bool mCreated; + // whether we handle touch event + bool mHandleTouchEvent; + // true if this is a drag and drop feedback popup + bool mIsDragPopup; + // Can we access X? + bool mIsX11Display; +#ifdef MOZ_WAYLAND + bool mNeedsCompositorResume; + bool mCompositorInitiallyPaused; +#endif + bool mWindowScaleFactorChanged; + int mWindowScaleFactor; + bool mCompositedScreen; + + private: + void DestroyChildWindows(); + GtkWidget* GetToplevelWidget(); + nsWindow* GetContainerWindow(); + void SetUrgencyHint(GtkWidget* top_window, bool state); + void SetDefaultIcon(void); + void SetWindowDecoration(nsBorderStyle aStyle); + void InitButtonEvent(mozilla::WidgetMouseEvent& aEvent, + GdkEventButton* aGdkEvent); + bool CheckForRollup(gdouble aMouseX, gdouble aMouseY, bool aIsWheel, + bool aAlwaysRollup); + void CheckForRollupDuringGrab() { CheckForRollup(0, 0, false, true); } + + bool GetDragInfo(mozilla::WidgetMouseEvent* aMouseEvent, GdkWindow** aWindow, + gint* aButton, gint* aRootX, gint* aRootY); + void ClearCachedResources(); + nsIWidgetListener* GetListener(); + + nsWindow* GetTransientForWindowIfPopup(); + bool IsHandlingTouchSequence(GdkEventSequence* aSequence); + + void ResizeInt(int aX, int aY, int aWidth, int aHeight, bool aMove, + bool aRepaint); + void NativeMoveResizeWaylandPopup(GdkPoint* aPosition, GdkRectangle* aSize); + + GtkTextDirection GetTextDirection(); + + void AddCSDDecorationSize(int* aWidth, int* aHeight); + +#ifdef MOZ_X11 + typedef enum {GTK_WIDGET_COMPOSIDED_DEFAULT = 0, + GTK_WIDGET_COMPOSIDED_DISABLED = 1, + GTK_WIDGET_COMPOSIDED_ENABLED = 2} WindowComposeRequest; + + void SetCompositorHint(WindowComposeRequest aState); +#endif + nsCString mGtkWindowAppName; + nsCString mGtkWindowRoleName; + void RefreshWindowClass(); + + GtkWidget* mShell; + MozContainer* mContainer; + GdkWindow* mGdkWindow; + bool mWindowShouldStartDragging = false; + PlatformCompositorWidgetDelegate* mCompositorWidgetDelegate; + + uint32_t mHasMappedToplevel : 1, mRetryPointerGrab : 1; + nsSizeMode mSizeState; + float mAspectRatio; + float mAspectRatioSaved; + nsIntPoint mClientOffset; + + // This field omits duplicate scroll events caused by GNOME bug 726878. + guint32 mLastScrollEventTime; + mozilla::ScreenCoord mLastPinchEventSpan; + bool mPanInProgress = false; + + // for touch event handling + nsRefPtrHashtable<nsPtrHashKey<GdkEventSequence>, mozilla::dom::Touch> + mTouches; + +#ifdef MOZ_X11 + Display* mXDisplay; + Window mXWindow; + Visual* mXVisual; + int mXDepth; + mozilla::widget::WindowSurfaceProvider mSurfaceProvider; + + bool ConfigureX11GLVisual(bool aUseAlpha); +#endif +#ifdef MOZ_WAYLAND + RefPtr<mozilla::gfx::VsyncSource> mWaylandVsyncSource; +#endif + + // Upper bound on pending ConfigureNotify events to be dispatched to the + // window. See bug 1225044. + unsigned int mPendingConfigures; + + // Window titlebar rendering mode, CSD_SUPPORT_NONE if it's disabled + // for this window. + CSDSupportLevel mCSDSupportLevel; + // Use dedicated GdkWindow for mContainer + bool mDrawToContainer; + // If true, draw our own window titlebar. + bool mDrawInTitlebar; + // Draw titlebar with :backdrop css state (inactive/unfocused). + bool mTitlebarBackdropState; + // Draggable titlebar region maintained by UpdateWindowDraggingRegion + LayoutDeviceIntRegion mDraggableRegion; + // It's PictureInPicture window. + bool mIsPIPWindow; + bool mAlwaysOnTop; + +#ifdef ACCESSIBILITY + RefPtr<mozilla::a11y::Accessible> mRootAccessible; + + /** + * Request to create the accessible for this window if it is top level. + */ + void CreateRootAccessible(); + + /** + * Dispatch accessible event for the top level window accessible. + * + * @param aEventType [in] the accessible event type to dispatch + */ + void DispatchEventToRootAccessible(uint32_t aEventType); + + /** + * Dispatch accessible window activate event for the top level window + * accessible. + */ + void DispatchActivateEventAccessible(); + + /** + * Dispatch accessible window deactivate event for the top level window + * accessible. + */ + void DispatchDeactivateEventAccessible(); + + /** + * Dispatch accessible window maximize event for the top level window + * accessible. + */ + void DispatchMaximizeEventAccessible(); + + /** + * Dispatch accessible window minize event for the top level window + * accessible. + */ + void DispatchMinimizeEventAccessible(); + + /** + * Dispatch accessible window restore event for the top level window + * accessible. + */ + void DispatchRestoreEventAccessible(); +#endif + + // The cursor cache + static GdkCursor* gsGtkCursorCache[eCursorCount]; + + // Transparency + bool mIsTransparent; + // This bitmap tracks which pixels are transparent. We don't support + // full translucency at this time; each pixel is either fully opaque + // or fully transparent. + gchar* mTransparencyBitmap; + int32_t mTransparencyBitmapWidth; + int32_t mTransparencyBitmapHeight; + // The transparency bitmap is used instead of ARGB visual for toplevel + // window to draw titlebar. + bool mTransparencyBitmapForTitlebar; + + // True when we're on compositing window manager and this + // window is using visual with alpha channel. + bool mHasAlphaVisual; + + // all of our DND stuff + void InitDragEvent(mozilla::WidgetDragEvent& aEvent); + + float mLastMotionPressure; + + // Remember the last sizemode so that we can restore it when + // leaving fullscreen + nsSizeMode mLastSizeMode; + // We can't detect size state changes correctly so set this flag + // to force update mBounds after a size state change from a configure + // event. + bool mBoundsAreValid; + + static bool DragInProgress(void); + + void DispatchMissedButtonReleases(GdkEventCrossing* aGdkEvent); + + // nsBaseWidget + virtual LayerManager* GetLayerManager( + PLayerTransactionChild* aShadowManager = nullptr, + LayersBackend aBackendHint = mozilla::layers::LayersBackend::LAYERS_NONE, + LayerManagerPersistence aPersistence = LAYER_MANAGER_CURRENT) override; + + void SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) override; + + void CleanLayerManagerRecursive(); + + virtual int32_t RoundsWidgetCoordinatesTo() override; + + void UpdateMozWindowActive(); + + void ForceTitlebarRedraw(); + bool DoDrawTilebarCorners(); + bool IsChromeWindowTitlebar(); + + void SetPopupWindowDecoration(bool aShowOnTaskbar); + + void ApplySizeConstraints(void); + + bool IsMainMenuWindow(); + GtkWidget* ConfigureWaylandPopupWindows(); + void PauseRemoteRenderer(); + void HideWaylandWindow(); + void HideWaylandTooltips(); + void HideWaylandPopupAndAllChildren(); + void CleanupWaylandPopups(); + GtkWindow* GetCurrentTopmostWindow(); + GtkWindow* GetCurrentWindow(); + GtkWindow* GetTopmostWindow(); + bool IsWidgetOverflowWindow(); + nsRect mPreferredPopupRect; + bool mPreferredPopupRectFlushed; + bool mWaitingForMoveToRectCB; + LayoutDeviceIntRect mPendingSizeRect; + + /** + * |mIMContext| takes all IME related stuff. + * + * This is owned by the top-level nsWindow or the topmost child + * nsWindow embedded in a non-Gecko widget. + * + * The instance is created when the top level widget is created. And when + * the widget is destroyed, it's released. All child windows refer its + * ancestor widget's instance. So, one set of IM contexts is created for + * all windows in a hierarchy. If the children are released after the top + * level window is released, the children still have a valid pointer, + * however, IME doesn't work at that time. + */ + RefPtr<mozilla::widget::IMContextWrapper> mIMContext; + + mozilla::UniquePtr<mozilla::CurrentX11TimeGetter> mCurrentTimeGetter; + static CSDSupportLevel sCSDSupportLevel; + + static bool sTransparentMainWindow; +}; + +#endif /* __nsWindow_h__ */ |