diff options
Diffstat (limited to '')
| -rw-r--r-- | widget/gtk/nsWindow.cpp | 8420 |
1 files changed, 8420 insertions, 0 deletions
diff --git a/widget/gtk/nsWindow.cpp b/widget/gtk/nsWindow.cpp new file mode 100644 index 0000000000..f435464f7a --- /dev/null +++ b/widget/gtk/nsWindow.cpp @@ -0,0 +1,8420 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:expandtab:shiftwidth=2:tabstop=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/. */ + +#include "nsWindow.h" + +#include "mozilla/ArrayUtils.h" +#include "mozilla/EventForwards.h" +#include "mozilla/MiscEvents.h" +#include "mozilla/MouseEvents.h" +#include "mozilla/PresShell.h" +#include "mozilla/RefPtr.h" +#include "mozilla/ScopeExit.h" +#include "mozilla/StaticPrefs_apz.h" +#include "mozilla/StaticPrefs_ui.h" +#include "mozilla/TextEvents.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/TouchEvents.h" +#include "mozilla/UniquePtrExtensions.h" +#include "mozilla/WidgetUtils.h" +#include "mozilla/X11Util.h" +#include "mozilla/XREAppData.h" +#include "mozilla/dom/Document.h" +#include "mozilla/dom/WheelEventBinding.h" +#include "InputData.h" +#include "nsAppRunner.h" +#include <algorithm> + +#include "GeckoProfiler.h" + +#include "prlink.h" +#include "nsGTKToolkit.h" +#include "nsIRollupListener.h" +#include "nsINode.h" + +#include "nsWidgetsCID.h" +#include "nsDragService.h" +#include "nsIWidgetListener.h" +#include "nsIScreenManager.h" +#include "SystemTimeConverter.h" +#include "nsViewManager.h" +#include "nsMenuPopupFrame.h" +#include "nsXPLookAndFeel.h" + +#include "nsGtkKeyUtils.h" +#include "nsGtkCursors.h" +#include "ScreenHelperGTK.h" + +#include <gtk/gtk.h> +#include <gtk/gtkx.h> + +#ifdef MOZ_WAYLAND +# include <gdk/gdkwayland.h> +#endif /* MOZ_WAYLAND */ + +#ifdef MOZ_X11 +# include <gdk/gdkx.h> +# include <X11/Xatom.h> +# include <X11/extensions/XShm.h> +# include <X11/extensions/shape.h> +# include <gdk/gdkkeysyms-compat.h> +#endif /* MOZ_X11 */ + +#include <gdk/gdkkeysyms.h> + +#if defined(MOZ_WAYLAND) +# include <gdk/gdkwayland.h> +# include "nsView.h" +#endif + +#include "nsGkAtoms.h" + +#include "mozilla/Assertions.h" +#include "mozilla/Likely.h" +#include "mozilla/Preferences.h" +#include "nsGfxCIID.h" +#include "nsGtkUtils.h" +#include "nsLayoutUtils.h" +#include "mozilla/layers/LayersTypes.h" +#include "nsIUserIdleServiceInternal.h" +#include "GLContext.h" +#include "gfx2DGlue.h" + +#ifdef ACCESSIBILITY +# include "mozilla/a11y/Accessible.h" +# include "mozilla/a11y/Platform.h" +# include "nsAccessibilityService.h" + +using namespace mozilla; +using namespace mozilla::widget; +#endif + +/* For SetIcon */ +#include "nsAppDirectoryServiceDefs.h" +#include "nsString.h" +#include "nsIFile.h" + +/* SetCursor(imgIContainer*) */ +#include <gdk/gdk.h> +#include <wchar.h> +#include "imgIContainer.h" +#include "nsGfxCIID.h" +#include "nsImageToPixbuf.h" +#include "nsIInterfaceRequestorUtils.h" +#include "ClientLayerManager.h" +#include "nsIGSettingsService.h" + +#include "gfxPlatformGtk.h" +#include "gfxContext.h" +#include "gfxImageSurface.h" +#include "gfxUtils.h" +#include "Layers.h" +#include "GLContextProvider.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/HelpersCairo.h" +#include "mozilla/gfx/GPUProcessManager.h" +#include "mozilla/layers/CompositorBridgeParent.h" +#include "mozilla/layers/CompositorThread.h" +#include "mozilla/layers/KnowsCompositor.h" +#include "mozilla/layers/WebRenderBridgeChild.h" +#include "mozilla/layers/WebRenderLayerManager.h" + +#include "mozilla/layers/APZInputBridge.h" +#include "mozilla/layers/IAPZCTreeManager.h" + +#ifdef MOZ_X11 +# include "mozilla/gfx/gfxVars.h" +# include "GLContextGLX.h" // for GLContextGLX::FindVisual() +# include "GLContextEGL.h" // for GLContextEGL::FindVisual() +# include "GtkCompositorWidget.h" +# include "gfxXlibSurface.h" +# include "WindowSurfaceX11Image.h" +# include "WindowSurfaceX11SHM.h" +# include "WindowSurfaceXRender.h" +#endif // MOZ_X11 +#ifdef MOZ_WAYLAND +# include "nsIClipboard.h" +#endif + +#include "nsShmImage.h" +#include "gtkdrawing.h" + +#include "NativeKeyBindings.h" + +#include <dlfcn.h> +#include "nsPresContext.h" + +using namespace mozilla; +using namespace mozilla::gfx; +using namespace mozilla::widget; +using namespace mozilla::layers; +using mozilla::gl::GLContextEGL; +using mozilla::gl::GLContextGLX; + +// Don't put more than this many rects in the dirty region, just fluff +// out to the bounding-box if there are more +#define MAX_RECTS_IN_REGION 100 + +#if !GTK_CHECK_VERSION(3, 18, 0) + +struct _GdkEventTouchpadPinch { + GdkEventType type; + GdkWindow* window; + gint8 send_event; + gint8 phase; + gint8 n_fingers; + guint32 time; + gdouble x; + gdouble y; + gdouble dx; + gdouble dy; + gdouble angle_delta; + gdouble scale; + gdouble x_root, y_root; + guint state; +}; + +typedef enum { + GDK_TOUCHPAD_GESTURE_PHASE_BEGIN, + GDK_TOUCHPAD_GESTURE_PHASE_UPDATE, + GDK_TOUCHPAD_GESTURE_PHASE_END, + GDK_TOUCHPAD_GESTURE_PHASE_CANCEL +} GdkTouchpadGesturePhase; + +GdkEventMask GDK_TOUCHPAD_GESTURE_MASK = static_cast<GdkEventMask>(1 << 24); +GdkEventType GDK_TOUCHPAD_PINCH = static_cast<GdkEventType>(42); + +#endif + +const gint kEvents = GDK_TOUCHPAD_GESTURE_MASK | GDK_EXPOSURE_MASK | + GDK_STRUCTURE_MASK | GDK_VISIBILITY_NOTIFY_MASK | + GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | + GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | + GDK_SMOOTH_SCROLL_MASK | GDK_TOUCH_MASK | GDK_SCROLL_MASK | + GDK_POINTER_MOTION_MASK | GDK_PROPERTY_CHANGE_MASK; + +#if !GTK_CHECK_VERSION(3, 22, 0) +typedef enum { + GDK_ANCHOR_FLIP_X = 1 << 0, + GDK_ANCHOR_FLIP_Y = 1 << 1, + GDK_ANCHOR_SLIDE_X = 1 << 2, + GDK_ANCHOR_SLIDE_Y = 1 << 3, + GDK_ANCHOR_RESIZE_X = 1 << 4, + GDK_ANCHOR_RESIZE_Y = 1 << 5, + GDK_ANCHOR_FLIP = GDK_ANCHOR_FLIP_X | GDK_ANCHOR_FLIP_Y, + GDK_ANCHOR_SLIDE = GDK_ANCHOR_SLIDE_X | GDK_ANCHOR_SLIDE_Y, + GDK_ANCHOR_RESIZE = GDK_ANCHOR_RESIZE_X | GDK_ANCHOR_RESIZE_Y +} GdkAnchorHints; +#endif + +/* utility functions */ +static bool is_mouse_in_window(GdkWindow* aWindow, gdouble aMouseX, + gdouble aMouseY); +static nsWindow* get_window_for_gtk_widget(GtkWidget* widget); +static nsWindow* get_window_for_gdk_window(GdkWindow* window); +static GtkWidget* get_gtk_widget_for_gdk_window(GdkWindow* window); +static GdkCursor* get_gtk_cursor(nsCursor aCursor); + +static GdkWindow* get_inner_gdk_window(GdkWindow* aWindow, gint x, gint y, + gint* retx, gint* rety); + +static int is_parent_ungrab_enter(GdkEventCrossing* aEvent); +static int is_parent_grab_leave(GdkEventCrossing* aEvent); + +/* callbacks from widgets */ +static gboolean expose_event_cb(GtkWidget* widget, cairo_t* rect); +static gboolean configure_event_cb(GtkWidget* widget, GdkEventConfigure* event); +static void container_unrealize_cb(GtkWidget* widget); +static void size_allocate_cb(GtkWidget* widget, GtkAllocation* allocation); +static void toplevel_window_size_allocate_cb(GtkWidget* widget, + GtkAllocation* allocation); +static gboolean delete_event_cb(GtkWidget* widget, GdkEventAny* event); +static gboolean enter_notify_event_cb(GtkWidget* widget, + GdkEventCrossing* event); +static gboolean leave_notify_event_cb(GtkWidget* widget, + GdkEventCrossing* event); +static gboolean motion_notify_event_cb(GtkWidget* widget, + GdkEventMotion* event); +static gboolean button_press_event_cb(GtkWidget* widget, GdkEventButton* event); +static gboolean button_release_event_cb(GtkWidget* widget, + GdkEventButton* event); +static gboolean focus_in_event_cb(GtkWidget* widget, GdkEventFocus* event); +static gboolean focus_out_event_cb(GtkWidget* widget, GdkEventFocus* event); +static gboolean key_press_event_cb(GtkWidget* widget, GdkEventKey* event); +static gboolean key_release_event_cb(GtkWidget* widget, GdkEventKey* event); +static gboolean property_notify_event_cb(GtkWidget* widget, + GdkEventProperty* event); +static gboolean scroll_event_cb(GtkWidget* widget, GdkEventScroll* event); + +static void hierarchy_changed_cb(GtkWidget* widget, + GtkWidget* previous_toplevel); +static gboolean window_state_event_cb(GtkWidget* widget, + GdkEventWindowState* event); +static void settings_changed_cb(GtkSettings* settings, GParamSpec* pspec, + nsWindow* data); +static void settings_xft_dpi_changed_cb(GtkSettings* settings, + GParamSpec* pspec, nsWindow* data); +static void check_resize_cb(GtkContainer* container, gpointer user_data); +static void screen_composited_changed_cb(GdkScreen* screen, gpointer user_data); +static void widget_composited_changed_cb(GtkWidget* widget, gpointer user_data); + +static void scale_changed_cb(GtkWidget* widget, GParamSpec* aPSpec, + gpointer aPointer); +static gboolean touch_event_cb(GtkWidget* aWidget, GdkEventTouch* aEvent); +static gboolean generic_event_cb(GtkWidget* widget, GdkEvent* aEvent); + +static nsWindow* GetFirstNSWindowForGDKWindow(GdkWindow* aGdkWindow); + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ +#ifdef MOZ_X11 +static GdkFilterReturn popup_take_focus_filter(GdkXEvent* gdk_xevent, + GdkEvent* event, gpointer data); +#endif /* MOZ_X11 */ +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +static gboolean drag_motion_event_cb(GtkWidget* aWidget, + GdkDragContext* aDragContext, gint aX, + gint aY, guint aTime, gpointer aData); +static void drag_leave_event_cb(GtkWidget* aWidget, + GdkDragContext* aDragContext, guint aTime, + gpointer aData); +static gboolean drag_drop_event_cb(GtkWidget* aWidget, + GdkDragContext* aDragContext, gint aX, + gint aY, guint aTime, gpointer aData); +static void drag_data_received_event_cb(GtkWidget* aWidget, + GdkDragContext* aDragContext, gint aX, + gint aY, + GtkSelectionData* aSelectionData, + guint aInfo, guint32 aTime, + gpointer aData); + +/* initialization static functions */ +static nsresult initialize_prefs(void); + +static guint32 sLastUserInputTime = GDK_CURRENT_TIME; +static guint32 sRetryGrabTime; + +static SystemTimeConverter<guint32>& TimeConverter() { + static SystemTimeConverter<guint32> sTimeConverterSingleton; + return sTimeConverterSingleton; +} + +nsWindow::CSDSupportLevel nsWindow::sCSDSupportLevel = CSD_SUPPORT_UNKNOWN; +bool nsWindow::sTransparentMainWindow = false; +static bool sIgnoreChangedSettings = false; + +void nsWindow::WithSettingsChangesIgnored(const std::function<void()>& aFn) { + AutoRestore ar(sIgnoreChangedSettings); + sIgnoreChangedSettings = true; + aFn(); +} + +namespace mozilla { + +class CurrentX11TimeGetter { + public: + explicit CurrentX11TimeGetter(GdkWindow* aWindow) + : mWindow(aWindow), mAsyncUpdateStart() {} + + guint32 GetCurrentTime() const { return gdk_x11_get_server_time(mWindow); } + + void GetTimeAsyncForPossibleBackwardsSkew(const TimeStamp& aNow) { + // Check for in-flight request + if (!mAsyncUpdateStart.IsNull()) { + return; + } + mAsyncUpdateStart = aNow; + + Display* xDisplay = GDK_WINDOW_XDISPLAY(mWindow); + Window xWindow = GDK_WINDOW_XID(mWindow); + unsigned char c = 'a'; + Atom timeStampPropAtom = TimeStampPropAtom(); + XChangeProperty(xDisplay, xWindow, timeStampPropAtom, timeStampPropAtom, 8, + PropModeReplace, &c, 1); + XFlush(xDisplay); + } + + gboolean PropertyNotifyHandler(GtkWidget* aWidget, GdkEventProperty* aEvent) { + if (aEvent->atom != gdk_x11_xatom_to_atom(TimeStampPropAtom())) { + return FALSE; + } + + guint32 eventTime = aEvent->time; + TimeStamp lowerBound = mAsyncUpdateStart; + + TimeConverter().CompensateForBackwardsSkew(eventTime, lowerBound); + mAsyncUpdateStart = TimeStamp(); + return TRUE; + } + + private: + static Atom TimeStampPropAtom() { + return gdk_x11_get_xatom_by_name_for_display(gdk_display_get_default(), + "GDK_TIMESTAMP_PROP"); + } + + // This is safe because this class is stored as a member of mWindow and + // won't outlive it. + GdkWindow* mWindow; + TimeStamp mAsyncUpdateStart; +}; + +} // namespace mozilla + +static NS_DEFINE_IID(kCDragServiceCID, NS_DRAGSERVICE_CID); + +// The window from which the focus manager asks us to dispatch key events. +static nsWindow* gFocusWindow = nullptr; +static bool gBlockActivateEvent = false; +static bool gGlobalsInitialized = false; +static bool gRaiseWindows = true; +static bool gUseWaylandVsync = true; +static bool gUseWaylandUseOpaqueRegion = true; +static bool gUseAspectRatio = true; +static GList* gVisibleWaylandPopupWindows = nullptr; +static uint32_t gLastTouchID = 0; + +#define NS_WINDOW_TITLE_MAX_LENGTH 4095 + +// If after selecting profile window, the startup fail, please refer to +// http://bugzilla.gnome.org/show_bug.cgi?id=88940 + +// needed for imgIContainer cursors +// GdkDisplay* was added in 2.2 +typedef struct _GdkDisplay GdkDisplay; + +#define kWindowPositionSlop 20 + +// cursor cache +static GdkCursor* gCursorCache[eCursorCount]; + +static GtkWidget* gInvisibleContainer = nullptr; + +// Sometimes this actually also includes the state of the modifier keys, but +// only the button state bits are used. +static guint gButtonState; + +static inline int32_t GetBitmapStride(int32_t width) { +#if defined(MOZ_X11) + return (width + 7) / 8; +#else + return cairo_format_stride_for_width(CAIRO_FORMAT_A1, width); +#endif +} + +static inline bool TimestampIsNewerThan(guint32 a, guint32 b) { + // Timestamps are just the least significant bits of a monotonically + // increasing function, and so the use of unsigned overflow arithmetic. + return a - b <= G_MAXUINT32 / 2; +} + +static void UpdateLastInputEventTime(void* aGdkEvent) { + nsCOMPtr<nsIUserIdleServiceInternal> idleService = + do_GetService("@mozilla.org/widget/useridleservice;1"); + if (idleService) { + idleService->ResetIdleTimeOut(0); + } + + guint timestamp = gdk_event_get_time(static_cast<GdkEvent*>(aGdkEvent)); + if (timestamp == GDK_CURRENT_TIME) return; + + sLastUserInputTime = timestamp; +} + +void GetWindowOrigin(GdkWindow* aWindow, int* aX, int* aY) { + if (aWindow) { + gdk_window_get_origin(aWindow, aX, aY); + } + + // TODO(bug 1655924): gdk_window_get_origin is can block waiting for the x + // server for a long time, we would like to use the implementation below + // instead. However, removing the synchronous x server queries causes a race + // condition to surface, causing issues such as bug 1652743 and bug 1653711. +#if 0 + *aX = 0; + *aY = 0; + if (!aWindow) { + return; + } + + GdkWindow* current = aWindow; + while (GdkWindow* parent = gdk_window_get_parent(current)) { + if (parent == current) { + break; + } + + int x = 0; + int y = 0; + gdk_window_get_position(current, &x, &y); + *aX += x; + *aY += y; + + current = parent; + } +#endif +} + +nsWindow::nsWindow() { + mIsTopLevel = false; + mIsDestroyed = false; + mListenForResizes = false; + mNeedsDispatchResized = false; + mIsShown = false; + mNeedsShow = false; + mEnabled = true; + mCreated = false; + mHandleTouchEvent = false; + mIsDragPopup = false; + mIsX11Display = gfxPlatformGtk::GetPlatform()->IsX11Display(); + + mContainer = nullptr; + mGdkWindow = nullptr; + mShell = nullptr; + mCompositorWidgetDelegate = nullptr; + mHasMappedToplevel = false; + mRetryPointerGrab = false; + mWindowType = eWindowType_child; + mSizeState = nsSizeMode_Normal; + mBoundsAreValid = true; + mAspectRatio = 0.0f; + mAspectRatioSaved = 0.0f; + mLastSizeMode = nsSizeMode_Normal; + mSizeConstraints.mMaxSize = GetSafeWindowSize(mSizeConstraints.mMaxSize); + +#ifdef MOZ_X11 + mOldFocusWindow = 0; + + mXDisplay = nullptr; + mXWindow = X11None; + mXVisual = nullptr; + mXDepth = 0; +#endif /* MOZ_X11 */ + +#ifdef MOZ_WAYLAND + mNeedsCompositorResume = false; + mCompositorInitiallyPaused = false; +#endif + mWaitingForMoveToRectCB = false; + mPendingSizeRect = LayoutDeviceIntRect(0, 0, 0, 0); + + if (!gGlobalsInitialized) { + gGlobalsInitialized = true; + + // It's OK if either of these fail, but it may not be one day. + initialize_prefs(); + +#ifdef MOZ_WAYLAND + // Wayland provides clipboard data to application on focus-in event + // so we need to init our clipboard hooks before we create window + // and get focus. + if (!mIsX11Display) { + nsCOMPtr<nsIClipboard> clipboard = + do_GetService("@mozilla.org/widget/clipboard;1"); + NS_ASSERTION(clipboard, "Failed to init clipboard!"); + } +#endif + } + + mLastMotionPressure = 0; + +#ifdef ACCESSIBILITY + mRootAccessible = nullptr; +#endif + + mIsTransparent = false; + mTransparencyBitmap = nullptr; + mTransparencyBitmapForTitlebar = false; + + mTransparencyBitmapWidth = 0; + mTransparencyBitmapHeight = 0; + + mLastScrollEventTime = GDK_CURRENT_TIME; + + mPendingConfigures = 0; + mCSDSupportLevel = CSD_SUPPORT_NONE; + mDrawToContainer = false; + mDrawInTitlebar = false; + mTitlebarBackdropState = false; + + mHasAlphaVisual = false; + mIsPIPWindow = false; + mAlwaysOnTop = false; + + mWindowScaleFactorChanged = true; + mWindowScaleFactor = 1; + + mCompositedScreen = gdk_screen_is_composited(gdk_screen_get_default()); +} + +nsWindow::~nsWindow() { + LOG(("nsWindow::~nsWindow() [%p]\n", (void*)this)); + + delete[] mTransparencyBitmap; + mTransparencyBitmap = nullptr; + + Destroy(); +} + +/* static */ +void nsWindow::ReleaseGlobals() { + for (auto& cursor : gCursorCache) { + if (cursor) { + g_object_unref(cursor); + cursor = nullptr; + } + } +} + +void nsWindow::CommonCreate(nsIWidget* aParent, bool aListenForResizes) { + mParent = aParent; + mListenForResizes = aListenForResizes; + mCreated = true; +} + +void nsWindow::DispatchActivateEvent(void) { + NS_ASSERTION(mContainer || mIsDestroyed, + "DispatchActivateEvent only intended for container windows"); + +#ifdef ACCESSIBILITY + DispatchActivateEventAccessible(); +#endif // ACCESSIBILITY + + if (mWidgetListener) mWidgetListener->WindowActivated(); +} + +void nsWindow::DispatchDeactivateEvent(void) { + if (mWidgetListener) mWidgetListener->WindowDeactivated(); + +#ifdef ACCESSIBILITY + DispatchDeactivateEventAccessible(); +#endif // ACCESSIBILITY +} + +void nsWindow::DispatchResized() { + mNeedsDispatchResized = false; + if (mWidgetListener) { + mWidgetListener->WindowResized(this, mBounds.width, mBounds.height); + } + if (mAttachedWidgetListener) { + mAttachedWidgetListener->WindowResized(this, mBounds.width, mBounds.height); + } +} + +void nsWindow::MaybeDispatchResized() { + if (mNeedsDispatchResized && !mIsDestroyed) { + DispatchResized(); + } +} + +nsIWidgetListener* nsWindow::GetListener() { + return mAttachedWidgetListener ? mAttachedWidgetListener : mWidgetListener; +} + +nsresult nsWindow::DispatchEvent(WidgetGUIEvent* aEvent, + nsEventStatus& aStatus) { +#ifdef DEBUG + debug_DumpEvent(stdout, aEvent->mWidget, aEvent, "something", 0); +#endif + aStatus = nsEventStatus_eIgnore; + nsIWidgetListener* listener = GetListener(); + if (listener) { + aStatus = listener->HandleEvent(aEvent, mUseAttachedEvents); + } + + return NS_OK; +} + +void nsWindow::OnDestroy(void) { + if (mOnDestroyCalled) return; + + mOnDestroyCalled = true; + + // Prevent deletion. + nsCOMPtr<nsIWidget> kungFuDeathGrip = this; + + // release references to children, device context, toolkit + app shell + nsBaseWidget::OnDestroy(); + + // Remove association between this object and its parent and siblings. + nsBaseWidget::Destroy(); + mParent = nullptr; + + NotifyWindowDestroyed(); +} + +bool nsWindow::AreBoundsSane() { + return mBounds.width > 0 && mBounds.height > 0; +} + +static GtkWidget* EnsureInvisibleContainer() { + if (!gInvisibleContainer) { + // GtkWidgets need to be anchored to a GtkWindow to be realized (to + // have a window). Using GTK_WINDOW_POPUP rather than + // GTK_WINDOW_TOPLEVEL in the hope that POPUP results in less + // initialization and window manager interaction. + GtkWidget* window = gtk_window_new(GTK_WINDOW_POPUP); + gInvisibleContainer = moz_container_new(); + gtk_container_add(GTK_CONTAINER(window), gInvisibleContainer); + gtk_widget_realize(gInvisibleContainer); + } + return gInvisibleContainer; +} + +static void CheckDestroyInvisibleContainer() { + MOZ_ASSERT(gInvisibleContainer, "oh, no"); + + if (!gdk_window_peek_children(gtk_widget_get_window(gInvisibleContainer))) { + // No children, so not in use. + // Make sure to destroy the GtkWindow also. + gtk_widget_destroy(gtk_widget_get_parent(gInvisibleContainer)); + gInvisibleContainer = nullptr; + } +} + +// Change the containing GtkWidget on a sub-hierarchy of GdkWindows belonging +// to aOldWidget and rooted at aWindow, and reparent any child GtkWidgets of +// the GdkWindow hierarchy to aNewWidget. +static void SetWidgetForHierarchy(GdkWindow* aWindow, GtkWidget* aOldWidget, + GtkWidget* aNewWidget) { + gpointer data; + gdk_window_get_user_data(aWindow, &data); + + if (data != aOldWidget) { + if (!GTK_IS_WIDGET(data)) return; + + auto* widget = static_cast<GtkWidget*>(data); + if (gtk_widget_get_parent(widget) != aOldWidget) return; + + // This window belongs to a child widget, which will no longer be a + // child of aOldWidget. + gtk_widget_reparent(widget, aNewWidget); + + return; + } + + GList* children = gdk_window_get_children(aWindow); + for (GList* list = children; list; list = list->next) { + SetWidgetForHierarchy(GDK_WINDOW(list->data), aOldWidget, aNewWidget); + } + g_list_free(children); + + gdk_window_set_user_data(aWindow, aNewWidget); +} + +// Walk the list of child windows and call destroy on them. +void nsWindow::DestroyChildWindows() { + if (!mGdkWindow) return; + + while (GList* children = gdk_window_peek_children(mGdkWindow)) { + GdkWindow* child = GDK_WINDOW(children->data); + nsWindow* kid = get_window_for_gdk_window(child); + if (kid) { + kid->Destroy(); + } else { + // This child is not an nsWindow. + // Destroy the child GtkWidget. + gpointer data; + gdk_window_get_user_data(child, &data); + if (GTK_IS_WIDGET(data)) { + gtk_widget_destroy(static_cast<GtkWidget*>(data)); + } + } + } +} + +void nsWindow::Destroy() { + if (mIsDestroyed || !mCreated) return; + + LOG(("nsWindow::Destroy [%p]\n", (void*)this)); + mIsDestroyed = true; + mCreated = false; + + /** Need to clean our LayerManager up while still alive */ + if (mLayerManager) { + mLayerManager->Destroy(); + } + mLayerManager = nullptr; + +#ifdef MOZ_WAYLAND + // Shut down our local vsync source + if (mWaylandVsyncSource) { + mWaylandVsyncSource->Shutdown(); + mWaylandVsyncSource = nullptr; + } +#endif + + // It is safe to call DestroyeCompositor several times (here and + // in the parent class) since it will take effect only once. + // The reason we call it here is because on gtk platforms we need + // to destroy the compositor before we destroy the gdk window (which + // destroys the the gl context attached to it). + DestroyCompositor(); + +#ifdef MOZ_X11 + // Ensure any resources assigned to the window get cleaned up first + // to avoid double-freeing. + mSurfaceProvider.CleanupResources(); +#endif + + ClearCachedResources(); + + g_signal_handlers_disconnect_by_data(gtk_settings_get_default(), this); + + nsIRollupListener* rollupListener = nsBaseWidget::GetActiveRollupListener(); + if (rollupListener) { + nsCOMPtr<nsIWidget> rollupWidget = rollupListener->GetRollupWidget(); + if (static_cast<nsIWidget*>(this) == rollupWidget) { + rollupListener->Rollup(0, false, nullptr, nullptr); + } + } + + // dragService will be null after shutdown of the service manager. + RefPtr<nsDragService> dragService = nsDragService::GetInstance(); + if (dragService && this == dragService->GetMostRecentDestWindow()) { + dragService->ScheduleLeaveEvent(); + } + + NativeShow(false); + + if (mIMContext) { + mIMContext->OnDestroyWindow(this); + } + + // make sure that we remove ourself as the focus window + if (gFocusWindow == this) { + LOGFOCUS(("automatically losing focus...\n")); + gFocusWindow = nullptr; + } + + GtkWidget* owningWidget = GetMozContainerWidget(); + if (mShell) { + gtk_widget_destroy(mShell); + mShell = nullptr; + mContainer = nullptr; + MOZ_ASSERT(!mGdkWindow, + "mGdkWindow should be NULL when mContainer is destroyed"); + } else if (mContainer) { + gtk_widget_destroy(GTK_WIDGET(mContainer)); + mContainer = nullptr; + MOZ_ASSERT(!mGdkWindow, + "mGdkWindow should be NULL when mContainer is destroyed"); + } else if (mGdkWindow) { + // Destroy child windows to ensure that their mThebesSurfaces are + // released and to remove references from GdkWindows back to their + // container widget. (OnContainerUnrealize() does this when the + // MozContainer widget is destroyed.) + DestroyChildWindows(); + + gdk_window_set_user_data(mGdkWindow, nullptr); + g_object_set_data(G_OBJECT(mGdkWindow), "nsWindow", nullptr); + gdk_window_destroy(mGdkWindow); + mGdkWindow = nullptr; + } + + if (gInvisibleContainer && owningWidget == gInvisibleContainer) { + CheckDestroyInvisibleContainer(); + } + +#ifdef ACCESSIBILITY + if (mRootAccessible) { + mRootAccessible = nullptr; + } +#endif + + // Save until last because OnDestroy() may cause us to be deleted. + OnDestroy(); +} + +nsIWidget* nsWindow::GetParent(void) { return mParent; } + +float nsWindow::GetDPI() { + float dpi = 96.0f; + nsCOMPtr<nsIScreen> screen = GetWidgetScreen(); + if (screen) { + screen->GetDpi(&dpi); + } + return dpi; +} + +double nsWindow::GetDefaultScaleInternal() { + return GdkScaleFactor() * gfxPlatformGtk::GetFontScaleFactor(); +} + +DesktopToLayoutDeviceScale nsWindow::GetDesktopToDeviceScale() { +#ifdef MOZ_WAYLAND + if (!mIsX11Display) { + return DesktopToLayoutDeviceScale(GdkScaleFactor()); + } +#endif + + // In Gtk/X11, we manage windows using device pixels. + return DesktopToLayoutDeviceScale(1.0); +} + +DesktopToLayoutDeviceScale nsWindow::GetDesktopToDeviceScaleByScreen() { +#ifdef MOZ_WAYLAND + // In Wayland there's no way to get absolute position of the window and use it + // to determine the screen factor of the monitor on which the window is + // placed. The window is notified of the current scale factor but not at this + // point, so the GdkScaleFactor can return wrong value which can lead to wrong + // popup placement. We need to use parent's window scale factor for the new + // one. + if (!mIsX11Display) { + nsView* view = nsView::GetViewFor(this); + if (view) { + nsView* parentView = view->GetParent(); + if (parentView) { + nsIWidget* parentWidget = parentView->GetNearestWidget(nullptr); + if (parentWidget) { + return DesktopToLayoutDeviceScale( + parentWidget->RoundsWidgetCoordinatesTo()); + } + NS_WARNING("Widget has no parent"); + } + } else { + NS_WARNING("Cannot find widget view"); + } + } +#endif + return nsBaseWidget::GetDesktopToDeviceScale(); +} + +void nsWindow::SetParent(nsIWidget* aNewParent) { + if (!mGdkWindow) { + MOZ_ASSERT_UNREACHABLE("The native window has already been destroyed"); + return; + } + + if (mContainer) { + // FIXME bug 1469183 + NS_ERROR("nsWindow should not have a container here"); + return; + } + + nsCOMPtr<nsIWidget> kungFuDeathGrip = this; + if (mParent) { + mParent->RemoveChild(this); + } + mParent = aNewParent; + + GtkWidget* oldContainer = GetMozContainerWidget(); + if (!oldContainer) { + // The GdkWindows have been destroyed so there is nothing else to + // reparent. + MOZ_ASSERT(gdk_window_is_destroyed(mGdkWindow), + "live GdkWindow with no widget"); + return; + } + + nsWindow* newParent = static_cast<nsWindow*>(aNewParent); + GdkWindow* newParentWindow = nullptr; + GtkWidget* newContainer = nullptr; + if (aNewParent) { + aNewParent->AddChild(this); + newParentWindow = newParent->mGdkWindow; + newContainer = newParent->GetMozContainerWidget(); + } else { + // aNewParent is nullptr, but reparent to a hidden window to avoid + // destroying the GdkWindow and its descendants. + // An invisible container widget is needed to hold descendant + // GtkWidgets. + newContainer = EnsureInvisibleContainer(); + newParentWindow = gtk_widget_get_window(newContainer); + } + + if (!newContainer) { + // The new parent GdkWindow has been destroyed. + MOZ_ASSERT(!newParentWindow || gdk_window_is_destroyed(newParentWindow), + "live GdkWindow with no widget"); + Destroy(); + } else { + if (newContainer != oldContainer) { + MOZ_ASSERT(!gdk_window_is_destroyed(newParentWindow), + "destroyed GdkWindow with widget"); + SetWidgetForHierarchy(mGdkWindow, oldContainer, newContainer); + + if (oldContainer == gInvisibleContainer) { + CheckDestroyInvisibleContainer(); + } + } + + gdk_window_reparent(mGdkWindow, newParentWindow, + DevicePixelsToGdkCoordRoundDown(mBounds.x), + DevicePixelsToGdkCoordRoundDown(mBounds.y)); + } + + bool parentHasMappedToplevel = newParent && newParent->mHasMappedToplevel; + if (mHasMappedToplevel != parentHasMappedToplevel) { + SetHasMappedToplevel(parentHasMappedToplevel); + } +} + +bool nsWindow::WidgetTypeSupportsAcceleration() { + if (IsSmallPopup()) { + return false; + } + // Workaround for Bug 1479135 + // We draw transparent popups on non-compositing screens by SW as we don't + // implement X shape masks in WebRender. + if (mWindowType == eWindowType_popup) { + return mCompositedScreen; + } + return true; +} + +void nsWindow::ReparentNativeWidget(nsIWidget* aNewParent) { + MOZ_ASSERT(aNewParent, "null widget"); + MOZ_ASSERT(!mIsDestroyed, ""); + MOZ_ASSERT(!static_cast<nsWindow*>(aNewParent)->mIsDestroyed, ""); + MOZ_ASSERT(!gdk_window_is_destroyed(mGdkWindow), + "destroyed GdkWindow with widget"); + + MOZ_ASSERT( + !mParent, + "nsWindow::ReparentNativeWidget() works on toplevel windows only."); + + auto* newParent = static_cast<nsWindow*>(aNewParent); + GtkWindow* newParentWidget = GTK_WINDOW(newParent->GetGtkWidget()); + GtkWindow* shell = GTK_WINDOW(mShell); + + if (shell && gtk_window_get_transient_for(shell)) { + gtk_window_set_transient_for(shell, newParentWidget); + } +} + +void nsWindow::SetModal(bool aModal) { + LOG(("nsWindow::SetModal [%p] %d\n", (void*)this, aModal)); + if (mIsDestroyed) return; + if (!mIsTopLevel || !mShell) return; + gtk_window_set_modal(GTK_WINDOW(mShell), aModal ? TRUE : FALSE); +} + +// nsIWidget method, which means IsShown. +bool nsWindow::IsVisible() const { return mIsShown; } + +void nsWindow::RegisterTouchWindow() { + mHandleTouchEvent = true; + mTouches.Clear(); +} + +void nsWindow::ConstrainPosition(bool aAllowSlop, int32_t* aX, int32_t* aY) { + if (!mIsTopLevel || !mShell) return; + + double dpiScale = GetDefaultScale().scale; + + // we need to use the window size in logical screen pixels + int32_t logWidth = std::max(NSToIntRound(mBounds.width / dpiScale), 1); + int32_t logHeight = std::max(NSToIntRound(mBounds.height / dpiScale), 1); + + /* get our playing field. use the current screen, or failing that + for any reason, use device caps for the default screen. */ + nsCOMPtr<nsIScreen> screen; + nsCOMPtr<nsIScreenManager> screenmgr = + do_GetService("@mozilla.org/gfx/screenmanager;1"); + if (screenmgr) { + screenmgr->ScreenForRect(*aX, *aY, logWidth, logHeight, + getter_AddRefs(screen)); + } + + // We don't have any screen so leave the coordinates as is + if (!screen) return; + + nsIntRect screenRect; + if (mSizeMode != nsSizeMode_Fullscreen) { + // For normalized windows, use the desktop work area. + screen->GetAvailRectDisplayPix(&screenRect.x, &screenRect.y, + &screenRect.width, &screenRect.height); + } else { + // For full screen windows, use the desktop. + screen->GetRectDisplayPix(&screenRect.x, &screenRect.y, &screenRect.width, + &screenRect.height); + } + + if (aAllowSlop) { + if (*aX < screenRect.x - logWidth + kWindowPositionSlop) + *aX = screenRect.x - logWidth + kWindowPositionSlop; + else if (*aX >= screenRect.XMost() - kWindowPositionSlop) + *aX = screenRect.XMost() - kWindowPositionSlop; + + if (*aY < screenRect.y - logHeight + kWindowPositionSlop) + *aY = screenRect.y - logHeight + kWindowPositionSlop; + else if (*aY >= screenRect.YMost() - kWindowPositionSlop) + *aY = screenRect.YMost() - kWindowPositionSlop; + } else { + if (*aX < screenRect.x) + *aX = screenRect.x; + else if (*aX >= screenRect.XMost() - logWidth) + *aX = screenRect.XMost() - logWidth; + + if (*aY < screenRect.y) + *aY = screenRect.y; + else if (*aY >= screenRect.YMost() - logHeight) + *aY = screenRect.YMost() - logHeight; + } +} + +void nsWindow::SetSizeConstraints(const SizeConstraints& aConstraints) { + mSizeConstraints.mMinSize = GetSafeWindowSize(aConstraints.mMinSize); + mSizeConstraints.mMaxSize = GetSafeWindowSize(aConstraints.mMaxSize); + + ApplySizeConstraints(); +} + +void nsWindow::AddCSDDecorationSize(int* aWidth, int* aHeight) { + if (mCSDSupportLevel == CSD_SUPPORT_CLIENT && mDrawInTitlebar) { + GtkBorder decorationSize = GetCSDDecorationSize(!mIsTopLevel); + *aWidth += decorationSize.left + decorationSize.right; + *aHeight += decorationSize.top + decorationSize.bottom; + } +} + +void nsWindow::ApplySizeConstraints(void) { + if (mShell) { + GdkGeometry geometry; + geometry.min_width = + DevicePixelsToGdkCoordRoundUp(mSizeConstraints.mMinSize.width); + geometry.min_height = + DevicePixelsToGdkCoordRoundUp(mSizeConstraints.mMinSize.height); + geometry.max_width = + DevicePixelsToGdkCoordRoundDown(mSizeConstraints.mMaxSize.width); + geometry.max_height = + DevicePixelsToGdkCoordRoundDown(mSizeConstraints.mMaxSize.height); + + uint32_t hints = 0; + if (mSizeConstraints.mMinSize != LayoutDeviceIntSize(0, 0)) { + AddCSDDecorationSize(&geometry.min_width, &geometry.min_height); + hints |= GDK_HINT_MIN_SIZE; + LOG(("nsWindow::ApplySizeConstraints [%p] min size %d %d\n", (void*)this, + geometry.min_width, geometry.min_height)); + } + if (mSizeConstraints.mMaxSize != + LayoutDeviceIntSize(NS_MAXSIZE, NS_MAXSIZE)) { + AddCSDDecorationSize(&geometry.max_width, &geometry.max_height); + hints |= GDK_HINT_MAX_SIZE; + LOG(("nsWindow::ApplySizeConstraints [%p] max size %d %d\n", (void*)this, + geometry.max_width, geometry.max_height)); + } + + if (mAspectRatio != 0.0f) { + geometry.min_aspect = mAspectRatio; + geometry.max_aspect = mAspectRatio; + hints |= GDK_HINT_ASPECT; + } + + gtk_window_set_geometry_hints(GTK_WINDOW(mShell), nullptr, &geometry, + GdkWindowHints(hints)); + } +} + +void nsWindow::Show(bool aState) { + if (aState == mIsShown) return; + + // Clear our cached resources when the window is hidden. + if (mIsShown && !aState) { + ClearCachedResources(); + } + + mIsShown = aState; + + LOG(("nsWindow::Show [%p] state %d\n", (void*)this, aState)); + + if (aState) { + // Now that this window is shown, mHasMappedToplevel needs to be + // tracked on viewable descendants. + SetHasMappedToplevel(mHasMappedToplevel); + } + + // Ok, someone called show on a window that isn't sized to a sane + // value. Mark this window as needing to have Show() called on it + // and return. + if ((aState && !AreBoundsSane()) || !mCreated) { + LOG(("\tbounds are insane or window hasn't been created yet\n")); + mNeedsShow = true; + return; + } + + // If someone is hiding this widget, clear any needing show flag. + if (!aState) mNeedsShow = false; + +#ifdef ACCESSIBILITY + if (aState && a11y::ShouldA11yBeEnabled()) CreateRootAccessible(); +#endif + + NativeShow(aState); +} + +void nsWindow::ResizeInt(int aX, int aY, int aWidth, int aHeight, bool aMove, + bool aRepaint) { + LOG(("nsWindow::ResizeInt [%p] x:%d y:%d -> w:%d h:%d repaint %d aMove %d\n", + (void*)this, aX, aY, aWidth, aHeight, aRepaint, aMove)); + + ConstrainSize(&aWidth, &aHeight); + + LOG((" ConstrainSize: w:%d h;%d\n", aWidth, aHeight)); + + // If we used to have insane bounds, we may have skipped actually positioning + // the widget in NativeMoveResizeWaylandPopup, in which case we need to + // actually position it now as well. + const bool hadInsaneWaylandPopupDimensions = + !AreBoundsSane() && IsWaylandPopup(); + + if (aMove) { + mBounds.x = aX; + mBounds.y = aY; + } + + // For top-level windows, aWidth and aHeight should possibly be + // interpreted as frame bounds, but NativeResize treats these as window + // bounds (Bug 581866). + mBounds.SizeTo(aWidth, aHeight); + + // We set correct mBounds in advance here. This can be invalided by state + // event. + mBoundsAreValid = true; + + // Recalculate aspect ratio when resized from DOM + if (mAspectRatio != 0.0) { + LockAspectRatio(true); + } + + if (!mCreated) return; + + if (aMove || mPreferredPopupRectFlushed || hadInsaneWaylandPopupDimensions) { + LOG((" Need also to move, flushed? %d, bounds were insane: %d\n", + mPreferredPopupRectFlushed, hadInsaneWaylandPopupDimensions)); + NativeMoveResize(); + } else { + NativeResize(); + } + + NotifyRollupGeometryChange(); + + // send a resize notification if this is a toplevel + if (mIsTopLevel || mListenForResizes) { + DispatchResized(); + } +} + +void nsWindow::Resize(double aWidth, double aHeight, bool aRepaint) { + LOG(("nsWindow::Resize [%p] %f %f\n", (void*)this, aWidth, aHeight)); + + double scale = + BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0; + int32_t width = NSToIntRound(scale * aWidth); + int32_t height = NSToIntRound(scale * aHeight); + + ResizeInt(0, 0, width, height, /* aMove */ false, aRepaint); +} + +void nsWindow::Resize(double aX, double aY, double aWidth, double aHeight, + bool aRepaint) { + LOG(("nsWindow::Resize [%p] %f %f repaint %d\n", (void*)this, aWidth, aHeight, + aRepaint)); + + double scale = + BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0; + int32_t width = NSToIntRound(scale * aWidth); + int32_t height = NSToIntRound(scale * aHeight); + + int32_t x = NSToIntRound(scale * aX); + int32_t y = NSToIntRound(scale * aY); + + ResizeInt(x, y, width, height, /* aMove */ true, aRepaint); +} + +void nsWindow::Enable(bool aState) { mEnabled = aState; } + +bool nsWindow::IsEnabled() const { return mEnabled; } + +void nsWindow::Move(double aX, double aY) { + LOG(("nsWindow::Move [%p] %f %f\n", (void*)this, aX, aY)); + + double scale = + BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0; + int32_t x = NSToIntRound(aX * scale); + int32_t y = NSToIntRound(aY * scale); + + if (mWindowType == eWindowType_toplevel || + mWindowType == eWindowType_dialog) { + SetSizeMode(nsSizeMode_Normal); + } + + // Since a popup window's x/y coordinates are in relation to to + // the parent, the parent might have moved so we always move a + // popup window. + if (x == mBounds.x && y == mBounds.y && mWindowType != eWindowType_popup) + return; + + // XXX Should we do some AreBoundsSane check here? + + mBounds.x = x; + mBounds.y = y; + + if (!mCreated) return; + + if (IsWaylandPopup()) { + int32_t p2a = AppUnitsPerCSSPixel() / gfxPlatformGtk::GetFontScaleFactor(); + if (mPreferredPopupRect.x != mBounds.x * p2a && + mPreferredPopupRect.y != mBounds.y * p2a) { + NativeMove(); + NotifyRollupGeometryChange(); + } else { + LOG((" mBounds same as mPreferredPopupRect, no need to move")); + } + } else { + NativeMove(); + NotifyRollupGeometryChange(); + } +} + +bool nsWindow::IsPopup() { + return mIsTopLevel && mWindowType == eWindowType_popup; +} + +bool nsWindow::IsWaylandPopup() { return !mIsX11Display && IsPopup(); } + +void nsWindow::HideWaylandTooltips() { + while (gVisibleWaylandPopupWindows) { + nsWindow* window = + static_cast<nsWindow*>(gVisibleWaylandPopupWindows->data); + if (window->mPopupType != ePopupTypeTooltip) break; + LOG(("nsWindow::HideWaylandTooltips [%p] hidding tooltip [%p].\n", + (void*)this, window)); + window->HideWaylandWindow(); + } +} + +void nsWindow::HideWaylandOpenedPopups() { + while (gVisibleWaylandPopupWindows) { + nsWindow* window = + static_cast<nsWindow*>(gVisibleWaylandPopupWindows->data); + window->HideWaylandWindow(); + } +} + +// Hide popup nsWindows which are no longer in the nsXULPopupManager widget +// chain list. +void nsWindow::CleanupWaylandPopups() { + LOG(("nsWindow::CleanupWaylandPopups...\n")); + nsXULPopupManager* pm = nsXULPopupManager::GetInstance(); + AutoTArray<nsIWidget*, 5> widgetChain; + pm->GetSubmenuWidgetChain(&widgetChain); + GList* popupList = gVisibleWaylandPopupWindows; + while (popupList) { + LOG((" Looking for %p [nsWindow]\n", popupList->data)); + nsWindow* waylandWnd = static_cast<nsWindow*>(popupList->data); + // Remove only menu popups or empty frames - they are most likely + // already rolledup popups + if (waylandWnd->IsMainMenuWindow() || !waylandWnd->GetFrame()) { + bool popupFound = false; + for (unsigned long i = 0; i < widgetChain.Length(); i++) { + if (waylandWnd == widgetChain[i]) { + popupFound = true; + break; + } + } + if (!popupFound) { + LOG((" nsWindow [%p] not found in PopupManager, hiding it.\n", + waylandWnd)); + waylandWnd->HideWaylandWindow(); + popupList = gVisibleWaylandPopupWindows; + } else { + LOG((" nsWindow [%p] is still open.\n", waylandWnd)); + popupList = popupList->next; + } + } else { + popupList = popupList->next; + } + } +} + +static nsMenuPopupFrame* GetMenuPopupFrame(nsIFrame* aFrame) { + if (aFrame) { + nsMenuPopupFrame* menuPopupFrame = do_QueryFrame(aFrame); + return menuPopupFrame; + } + return nullptr; +} + +// The MenuList popups are used as dropdown menus for example in WebRTC +// microphone/camera chooser or autocomplete widgets. +bool nsWindow::IsMainMenuWindow() { + nsMenuPopupFrame* menuPopupFrame = GetMenuPopupFrame(GetFrame()); + if (menuPopupFrame) { + LOG((" nsMenuPopupFrame [%p] type: %d IsMenu: %d, IsMenuList: %d\n", + menuPopupFrame, menuPopupFrame->PopupType(), menuPopupFrame->IsMenu(), + menuPopupFrame->IsMenuList())); + return mPopupType == ePopupTypeMenu && !menuPopupFrame->IsMenuList(); + } + return false; +} + +GtkWindow* nsWindow::GetTopmostWindow() { + nsView* view = nsView::GetViewFor(this); + if (view) { + nsView* parentView = view->GetParent(); + if (parentView) { + nsIWidget* parentWidget = parentView->GetNearestWidget(nullptr); + if (parentWidget) { + nsWindow* parentnsWindow = static_cast<nsWindow*>(parentWidget); + LOG((" Topmost window: %p [nsWindow]\n", parentnsWindow)); + return GTK_WINDOW(parentnsWindow->mShell); + } + } + } + return nullptr; +} + +GtkWindow* nsWindow::GetCurrentWindow() { + GtkWindow* parentGtkWindow = nullptr; + // get the last opened window from gVisibleWaylandPopupWindows + if (gVisibleWaylandPopupWindows) { + nsWindow* parentnsWindow = + static_cast<nsWindow*>(gVisibleWaylandPopupWindows->data); + if (parentnsWindow) { + LOG((" Setting parent to last opened window: %p [nsWindow]\n", + parentnsWindow)); + parentGtkWindow = GTK_WINDOW(parentnsWindow->GetGtkWidget()); + } + } + // get the topmost window if the last opened windows are empty + if (!parentGtkWindow) { + parentGtkWindow = GetTopmostWindow(); + } + if (parentGtkWindow && GTK_IS_WINDOW(parentGtkWindow)) { + return GTK_WINDOW(parentGtkWindow); + } else { + LOG((" Failed to get current window for %p: %p\n", this, parentGtkWindow)); + } + return nullptr; +} + +bool nsWindow::IsWidgetOverflowWindow() { + if (this->GetFrame() && this->GetFrame()->GetContent()->GetID()) { + nsCString nodeId; + this->GetFrame()->GetContent()->GetID()->ToUTF8String(nodeId); + return nodeId.Equals("widget-overflow"); + } + return false; +} + +// Wayland keeps strong popup window hierarchy. We need to track active +// (visible) popup windows and make sure we hide popup on the same level +// before we open another one on that level. It means that every open +// popup needs to have an unique parent. +GtkWidget* nsWindow::ConfigureWaylandPopupWindows() { + MOZ_ASSERT(this->mWindowType == eWindowType_popup); + LOG( + ("nsWindow::ConfigureWaylandPopupWindows [%p], frame %p hasRemoteContent " + "%d\n", + (void*)this, this->GetFrame(), this->HasRemoteContent())); +#if DEBUG + if (this->GetFrame() && this->GetFrame()->GetContent()->GetID()) { + nsCString nodeId; + this->GetFrame()->GetContent()->GetID()->ToUTF8String(nodeId); + LOG((" [%p] popup node id=%s\n", this, nodeId.get())); + } +#endif + + if (!GetFrame()) { + LOG((" Window without frame cannot be configured.\n")); + return nullptr; + } + + // Check if we're already configured. + if (gVisibleWaylandPopupWindows && + g_list_find(gVisibleWaylandPopupWindows, this)) { + LOG((" [%p] is already configured.\n", (void*)this)); + return GTK_WIDGET(gtk_window_get_transient_for(GTK_WINDOW(mShell))); + } + + // If we're opening a new window we don't want to attach it to a tooltip + // as it's short lived temporary window. + HideWaylandTooltips(); + + // Cleanup already closed menus + CleanupWaylandPopups(); + + if (gVisibleWaylandPopupWindows && + (HasRemoteContent() || IsWidgetOverflowWindow())) { + nsWindow* openedWindow = + static_cast<nsWindow*>(gVisibleWaylandPopupWindows->data); + LOG((" this [%p], lastOpenedWindow [%p]", this, openedWindow)); + if (openedWindow != this) { + LOG( + (" Hiding all opened popups because the window is remote content or " + "overflow-widget")); + HideWaylandOpenedPopups(); + } + } + + GtkWindow* parentGtkWindow = GetCurrentWindow(); + if (parentGtkWindow) { + MOZ_ASSERT(parentGtkWindow != GTK_WINDOW(this->GetGtkWidget()), + "Cannot set self as parent"); + gtk_window_set_transient_for(GTK_WINDOW(mShell), + GTK_WINDOW(parentGtkWindow)); + // Add current window to the visible popup list + gVisibleWaylandPopupWindows = + g_list_prepend(gVisibleWaylandPopupWindows, this); + LOG((" Parent window for %p: %p [GtkWindow]", this, parentGtkWindow)); + } + + MOZ_ASSERT(parentGtkWindow, "NO parent window for %p: expect popup glitches"); + return GTK_WIDGET(parentGtkWindow); +} + +static void NativeMoveResizeWaylandPopupCallback( + GdkWindow* window, const GdkRectangle* flipped_rect, + const GdkRectangle* final_rect, gboolean flipped_x, gboolean flipped_y, + void* aWindow) { + LOG(("NativeMoveResizeWaylandPopupCallback [%p] flipped_x %d flipped_y %d\n", + aWindow, flipped_x, flipped_y)); + + LOG((" flipped_rect x=%d y=%d width=%d height=%d\n", flipped_rect->x, + flipped_rect->y, flipped_rect->width, flipped_rect->height)); + LOG((" final_rect x=%d y=%d width=%d height=%d\n", final_rect->x, + final_rect->y, final_rect->width, final_rect->height)); + nsWindow* wnd = get_window_for_gdk_window(window); + + wnd->NativeMoveResizeWaylandPopupCB(final_rect, flipped_x, flipped_y); +} + +void nsWindow::NativeMoveResizeWaylandPopupCB(const GdkRectangle* aFinalSize, + bool aFlippedX, bool aFlippedY) { + LOG((" orig mBounds x=%d y=%d width=%d height=%d\n", mBounds.x, mBounds.y, + mBounds.width, mBounds.height)); + + // Remove signal handler because it can also be called from + // xdg_popup_configure + GdkWindow* gdkWindow = gtk_widget_get_window(GTK_WIDGET(mShell)); + if (g_signal_handler_find( + gdkWindow, G_SIGNAL_MATCH_FUNC, 0, 0, nullptr, + FuncToGpointer(NativeMoveResizeWaylandPopupCallback), this)) { + LOG((" Disconnecting NativeMoveResizeWaylandPopupCallback")); + g_signal_handlers_disconnect_by_func( + gdkWindow, FuncToGpointer(NativeMoveResizeWaylandPopupCallback), this); + } + mWaitingForMoveToRectCB = false; + + // We ignore the callback position data because the another resize has been + // called before the callback have been triggered. + if (mPendingSizeRect.height > 0 || mPendingSizeRect.width > 0) { + LOG( + (" Another resize called during waiting for callback, calling " + "Resize(%d, %d)\n", + mPendingSizeRect.width, mPendingSizeRect.height)); + // Set the preferred size to zero to avoid wrong size of popup because the + // mPreferredPopupRect is used in nsMenuPopupFrame to set dimensions + mPreferredPopupRect = nsRect(0, 0, 0, 0); + + // We need to schedule another resize because the window has been resized + // again before callback was called. + Resize(mPendingSizeRect.width, mPendingSizeRect.height, true); + DispatchResized(); + mPendingSizeRect.width = mPendingSizeRect.height = 0; + return; + } + + GtkWindow* parentGtkWindow = gtk_window_get_transient_for(GTK_WINDOW(mShell)); + if (!parentGtkWindow || !GTK_IS_WIDGET(parentGtkWindow)) { + NS_WARNING("Popup has no parent!"); + return; + } + + // The position of the menu in GTK is relative to it's parent window while + // in mBounds we have position relative to toplevel window. We need to check + // and update mBounds in the toplevel coordinates. + int x_parent, y_parent; + GetWindowOrigin(gtk_widget_get_window(GTK_WIDGET(parentGtkWindow)), &x_parent, + &y_parent); + + LayoutDeviceIntRect newBounds(aFinalSize->x, aFinalSize->y, aFinalSize->width, + aFinalSize->height); + + newBounds.x = GdkCoordToDevicePixels(newBounds.x); + newBounds.y = GdkCoordToDevicePixels(newBounds.y); + + double scale = + BoundsUseDesktopPixels() ? GetDesktopToDeviceScale().scale : 1.0; + int32_t newWidth = NSToIntRound(scale * newBounds.width); + int32_t newHeight = NSToIntRound(scale * newBounds.height); + + LOG((" new mBounds x=%d y=%d width=%d height=%d\n", newBounds.x, + newBounds.y, newWidth, newHeight)); + + bool needsPositionUpdate = + (newBounds.x != mBounds.x || newBounds.y != mBounds.y); + bool needsSizeUpdate = + (newWidth != mBounds.width || newHeight != mBounds.height); + // Update view + + if (needsSizeUpdate) { + LOG((" needSizeUpdate\n")); + int32_t p2a = AppUnitsPerCSSPixel() / gfxPlatformGtk::GetFontScaleFactor(); + mPreferredPopupRect = nsRect(NSIntPixelsToAppUnits(newBounds.x, p2a), + NSIntPixelsToAppUnits(newBounds.y, p2a), + NSIntPixelsToAppUnits(newBounds.width, p2a), + NSIntPixelsToAppUnits(newBounds.height, p2a)); + mPreferredPopupRectFlushed = false; + Resize(newBounds.width, newBounds.height, true); + DispatchResized(); + + nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame()); + if (popupFrame) { + RefPtr<PresShell> presShell = popupFrame->PresShell(); + presShell->FrameNeedsReflow(popupFrame, IntrinsicDirty::Resize, + NS_FRAME_IS_DIRTY); + } + } + + if (needsPositionUpdate) { + LOG((" needPositionUpdate\n")); + // The newBounds are in coordinates relative to the parent window/popup. + // The NotifyWindowMoved requires the coordinates relative to the toplevel. + // We use the gdk_window_get_origin to get correct coordinates. + gint x = 0, y = 0; + GetWindowOrigin(gtk_widget_get_window(GTK_WIDGET(mShell)), &x, &y); + NotifyWindowMoved(GdkCoordToDevicePixels(x), GdkCoordToDevicePixels(y)); + } +} + +#ifdef MOZ_WAYLAND +static GdkGravity PopupAlignmentToGdkGravity(int8_t aAlignment) { + switch (aAlignment) { + case POPUPALIGNMENT_NONE: + return GDK_GRAVITY_NORTH_WEST; + break; + case POPUPALIGNMENT_TOPLEFT: + return GDK_GRAVITY_NORTH_WEST; + break; + case POPUPALIGNMENT_TOPRIGHT: + return GDK_GRAVITY_NORTH_EAST; + break; + case POPUPALIGNMENT_BOTTOMLEFT: + return GDK_GRAVITY_SOUTH_WEST; + break; + case POPUPALIGNMENT_BOTTOMRIGHT: + return GDK_GRAVITY_SOUTH_EAST; + break; + case POPUPALIGNMENT_LEFTCENTER: + return GDK_GRAVITY_WEST; + break; + case POPUPALIGNMENT_RIGHTCENTER: + return GDK_GRAVITY_EAST; + break; + case POPUPALIGNMENT_TOPCENTER: + return GDK_GRAVITY_NORTH; + break; + case POPUPALIGNMENT_BOTTOMCENTER: + return GDK_GRAVITY_SOUTH; + break; + } + return GDK_GRAVITY_STATIC; +} +#endif + +void nsWindow::NativeMoveResizeWaylandPopup(GdkPoint* aPosition, + GdkRectangle* aSize) { + // Available as of GTK 3.24+ + static auto sGdkWindowMoveToRect = (void (*)( + GdkWindow*, const GdkRectangle*, GdkGravity, GdkGravity, GdkAnchorHints, + gint, gint))dlsym(RTLD_DEFAULT, "gdk_window_move_to_rect"); + LOG(("nsWindow::NativeMoveResizeWaylandPopup [%p]\n", (void*)this)); + + // Compositor may be confused by windows with width/height = 0 + // and positioning such windows leads to Bug 1555866. + if (!AreBoundsSane()) { + LOG((" Bounds are not sane (width: %d height: %d)\n", mBounds.width, + mBounds.height)); + return; + } + + if (aSize) { + gtk_window_resize(GTK_WINDOW(mShell), aSize->width, aSize->height); + } + + GdkWindow* gdkWindow = gtk_widget_get_window(GTK_WIDGET(mShell)); + + // Use standard gtk_window_move() instead of gdk_window_move_to_rect() when: + // - gdk_window_move_to_rect() is not available + // - the widget doesn't have a valid GdkWindow + if (!sGdkWindowMoveToRect || !gdkWindow) { + LOG((" use gtk_window_move(%d, %d)\n", aPosition->x, aPosition->y)); + gtk_window_move(GTK_WINDOW(mShell), aPosition->x, aPosition->y); + return; + } + + GtkWidget* parentWindow = ConfigureWaylandPopupWindows(); + LOG(("nsWindow::NativeMoveResizeWaylandPopup: Set popup parent %p\n", + parentWindow)); + + // Get anchor rectangle + LayoutDeviceIntRect anchorRect(0, 0, 0, 0); + nsMenuPopupFrame* popupFrame = GetMenuPopupFrame(GetFrame()); + + int32_t p2a; + double devPixelsPerCSSPixel = StaticPrefs::layout_css_devPixelsPerPx(); + if (devPixelsPerCSSPixel > 0.0) { + p2a = AppUnitsPerCSSPixel() / devPixelsPerCSSPixel * GdkScaleFactor(); + } else { + p2a = AppUnitsPerCSSPixel() / gfxPlatformGtk::GetFontScaleFactor(); + } + if (popupFrame) { +#ifdef MOZ_WAYLAND + anchorRect = LayoutDeviceIntRect::FromAppUnitsToOutside( + popupFrame->GetAnchorRect(), p2a); +#endif + } + +#ifdef MOZ_WAYLAND + bool hasAnchorRect = true; +#endif + if (anchorRect.width == 0) { + LOG((" No anchor rect given, use aPosition for anchor")); + anchorRect.SetRect(aPosition->x, aPosition->y, 1, 1); +#ifdef MOZ_WAYLAND + hasAnchorRect = false; +#endif + } + LOG((" anchor x %d y %d width %d height %d (absolute coords)\n", + anchorRect.x, anchorRect.y, anchorRect.width, anchorRect.height)); + + // Anchor rect is in the toplevel coordinates but we need to transfer it to + // the coordinates relative to the popup parent for the + // gdk_window_move_to_rect + int x_parent = 0, y_parent = 0; + GtkWindow* parentGtkWindow = gtk_window_get_transient_for(GTK_WINDOW(mShell)); + if (parentGtkWindow) { + GetWindowOrigin(gtk_widget_get_window(GTK_WIDGET(parentGtkWindow)), + &x_parent, &y_parent); + } + LOG((" x_parent %d y_parent %d\n", x_parent, y_parent)); + anchorRect.MoveBy(-x_parent, -y_parent); + GdkRectangle rect = {anchorRect.x, anchorRect.y, anchorRect.width, + anchorRect.height}; + + // Get gravity and flip type + GdkGravity rectAnchor = GDK_GRAVITY_NORTH_WEST; + GdkGravity menuAnchor = GDK_GRAVITY_NORTH_WEST; + FlipType flipType = FlipType_Default; + int8_t position = -1; + if (popupFrame) { +#ifdef MOZ_WAYLAND + rectAnchor = PopupAlignmentToGdkGravity(popupFrame->GetPopupAnchor()); + menuAnchor = PopupAlignmentToGdkGravity(popupFrame->GetPopupAlignment()); + flipType = popupFrame->GetFlipType(); + position = popupFrame->GetAlignmentPosition(); +#endif + } else { + LOG((" NO ANCHOR INFO")); + if (GetTextDirection() == GTK_TEXT_DIR_RTL) { + rectAnchor = GDK_GRAVITY_NORTH_EAST; + menuAnchor = GDK_GRAVITY_NORTH_EAST; + } + } + LOG((" parentRect gravity: %d anchor gravity: %d\n", rectAnchor, menuAnchor)); + + GdkAnchorHints hints = GdkAnchorHints(GDK_ANCHOR_RESIZE); + + // slideHorizontal from nsMenuPopupFrame::SetPopupPosition + if (position >= POPUPPOSITION_BEFORESTART && + position <= POPUPPOSITION_AFTEREND) { + hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE_X); + } + // slideVertical from nsMenuPopupFrame::SetPopupPosition + if (position >= POPUPPOSITION_STARTBEFORE && + position <= POPUPPOSITION_ENDAFTER) { + hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE_Y); + } + + if (popupFrame && rectAnchor == GDK_GRAVITY_CENTER && + menuAnchor == GDK_GRAVITY_CENTER) { + // only slide + hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE); + } else { + switch (flipType) { + case FlipType_Both: + hints = GdkAnchorHints(hints | GDK_ANCHOR_FLIP); + break; + case FlipType_Slide: + hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE); + break; + case FlipType_Default: + hints = GdkAnchorHints(hints | GDK_ANCHOR_FLIP); + break; + default: + break; + } + } + if (!IsMainMenuWindow()) { + // we don't want to slide menus to fit the screen rather resize them + hints = GdkAnchorHints(hints | GDK_ANCHOR_SLIDE); + } + + // A workaround for https://gitlab.gnome.org/GNOME/gtk/issues/1986 + // gdk_window_move_to_rect() does not reposition visible windows. + static auto sGtkWidgetIsVisible = + (gboolean(*)(GtkWidget*))dlsym(RTLD_DEFAULT, "gtk_widget_is_visible"); + + bool isWidgetVisible = + (sGtkWidgetIsVisible != nullptr) && sGtkWidgetIsVisible(mShell); + if (isWidgetVisible) { + PauseRemoteRenderer(); + gtk_widget_hide(mShell); + } + + LOG((" requested rect: x: %d y: %d width: %d height: %d\n", rect.x, rect.y, + rect.width, rect.height)); + if (aSize) { + LOG((" aSize: x%d y%d w%d h%d\n", aSize->x, aSize->y, aSize->width, + aSize->height)); + } else { + LOG((" No aSize given")); + } + + // Inspired by nsMenuPopupFrame::AdjustPositionForAnchorAlign + nsPoint cursorOffset(0, 0); +#ifdef MOZ_WAYLAND + // Offset is already computed to the tooltips + if (hasAnchorRect && popupFrame && mPopupType != ePopupTypeTooltip) { + nsMargin margin(0, 0, 0, 0); + popupFrame->StyleMargin()->GetMargin(margin); + switch (popupFrame->GetPopupAlignment()) { + case POPUPALIGNMENT_TOPRIGHT: + cursorOffset.MoveBy(-margin.right, margin.top); + break; + case POPUPALIGNMENT_BOTTOMLEFT: + cursorOffset.MoveBy(margin.left, -margin.bottom); + break; + case POPUPALIGNMENT_BOTTOMRIGHT: + cursorOffset.MoveBy(-margin.right, -margin.bottom); + break; + case POPUPALIGNMENT_TOPLEFT: + default: + cursorOffset.MoveBy(margin.left, margin.top); + break; + } + } +#endif + + if (!g_signal_handler_find( + gdkWindow, G_SIGNAL_MATCH_FUNC, 0, 0, nullptr, + FuncToGpointer(NativeMoveResizeWaylandPopupCallback), this)) { + g_signal_connect(gdkWindow, "moved-to-rect", + G_CALLBACK(NativeMoveResizeWaylandPopupCallback), this); + } + + LOG((" popup window cursor offset x: %d y: %d\n", cursorOffset.x / p2a, + cursorOffset.y / p2a)); + mWaitingForMoveToRectCB = true; + sGdkWindowMoveToRect(gdkWindow, &rect, rectAnchor, menuAnchor, hints, + cursorOffset.x / p2a, cursorOffset.y / p2a); + + if (isWidgetVisible) { + // We show the popup with the same configuration so no need to call + // ConfigureWaylandPopupWindows() before gtk_widget_show(). + gtk_widget_show(mShell); + } +} + +void nsWindow::NativeMove() { + GdkPoint point = DevicePixelsToGdkPointRoundDown(mBounds.TopLeft()); + + LOG(("nsWindow::NativeMove [%p] %d %d\n", (void*)this, point.x, point.y)); + + if (IsWaylandPopup()) { + GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mBounds.Size()); + NativeMoveResizeWaylandPopup(&point, &size); + } else if (mIsTopLevel) { + gtk_window_move(GTK_WINDOW(mShell), point.x, point.y); + } else if (mGdkWindow) { + gdk_window_move(mGdkWindow, point.x, point.y); + } +} + +void nsWindow::SetZIndex(int32_t aZIndex) { + nsIWidget* oldPrev = GetPrevSibling(); + + nsBaseWidget::SetZIndex(aZIndex); + + if (GetPrevSibling() == oldPrev) { + return; + } + + NS_ASSERTION(!mContainer, "Expected Mozilla child widget"); + + // We skip the nsWindows that don't have mGdkWindows. + // These are probably in the process of being destroyed. + + if (!GetNextSibling()) { + // We're to be on top. + if (mGdkWindow) gdk_window_raise(mGdkWindow); + } else { + // All the siblings before us need to be below our widget. + for (nsWindow* w = this; w; + w = static_cast<nsWindow*>(w->GetPrevSibling())) { + if (w->mGdkWindow) gdk_window_lower(w->mGdkWindow); + } + } +} + +void nsWindow::SetSizeMode(nsSizeMode aMode) { + LOG(("nsWindow::SetSizeMode [%p] %d\n", (void*)this, aMode)); + + // Save the requested state. + nsBaseWidget::SetSizeMode(aMode); + + // return if there's no shell or our current state is the same as + // the mode we were just set to. + if (!mShell || mSizeState == mSizeMode) { + LOG((" already set")); + return; + } + + switch (aMode) { + case nsSizeMode_Maximized: + LOG((" set maximized")); + gtk_window_maximize(GTK_WINDOW(mShell)); + break; + case nsSizeMode_Minimized: + LOG((" set minimized")); + gtk_window_iconify(GTK_WINDOW(mShell)); + break; + case nsSizeMode_Fullscreen: + LOG((" set fullscreen")); + MakeFullScreen(true); + break; + + default: + LOG((" set normal")); + // nsSizeMode_Normal, really. + if (mSizeState == nsSizeMode_Minimized) + gtk_window_deiconify(GTK_WINDOW(mShell)); + else if (mSizeState == nsSizeMode_Maximized) + gtk_window_unmaximize(GTK_WINDOW(mShell)); + break; + } + + // Request mBounds update from configure event as we may not get + // OnSizeAllocate for size state changes (Bug 1489463). + mBoundsAreValid = false; + + mSizeState = mSizeMode; +} + +static bool GetWindowManagerName(GdkWindow* gdk_window, nsACString& wmName) { + if (!gfxPlatformGtk::GetPlatform()->IsX11Display()) { + return false; + } + + Display* xdisplay = gdk_x11_get_default_xdisplay(); + GdkScreen* screen = gdk_window_get_screen(gdk_window); + Window root_win = GDK_WINDOW_XID(gdk_screen_get_root_window(screen)); + + int actual_format_return; + Atom actual_type_return; + unsigned long nitems_return; + unsigned long bytes_after_return; + unsigned char* prop_return = nullptr; + auto releaseXProperty = MakeScopeExit([&] { + if (prop_return) { + XFree(prop_return); + } + }); + + Atom property = XInternAtom(xdisplay, "_NET_SUPPORTING_WM_CHECK", true); + Atom req_type = XInternAtom(xdisplay, "WINDOW", true); + if (!property || !req_type) { + return false; + } + int result = + XGetWindowProperty(xdisplay, root_win, property, + 0L, // offset + sizeof(Window) / 4, // length + false, // delete + req_type, &actual_type_return, &actual_format_return, + &nitems_return, &bytes_after_return, &prop_return); + + if (result != Success || bytes_after_return != 0 || nitems_return != 1) { + return false; + } + + Window wmWindow = reinterpret_cast<Window*>(prop_return)[0]; + if (!wmWindow) { + return false; + } + + XFree(prop_return); + prop_return = nullptr; + + property = XInternAtom(xdisplay, "_NET_WM_NAME", true); + req_type = XInternAtom(xdisplay, "UTF8_STRING", true); + if (!property || !req_type) { + return false; + } + { + // Suppress fatal errors for a missing window. + ScopedXErrorHandler handler; + result = + XGetWindowProperty(xdisplay, wmWindow, property, + 0L, // offset + INT32_MAX, // length + false, // delete + req_type, &actual_type_return, &actual_format_return, + &nitems_return, &bytes_after_return, &prop_return); + } + + if (result != Success || bytes_after_return != 0) { + return false; + } + + wmName = reinterpret_cast<const char*>(prop_return); + return true; +} + +#define kDesktopMutterSchema "org.gnome.mutter" +#define kDesktopDynamicWorkspacesKey "dynamic-workspaces" + +static bool WorkspaceManagementDisabled(GdkWindow* gdk_window) { + if (Preferences::GetBool("widget.disable-workspace-management", false)) { + return true; + } + if (Preferences::HasUserValue("widget.workspace-management")) { + return Preferences::GetBool("widget.workspace-management"); + } + + static const char* currentDesktop = getenv("XDG_CURRENT_DESKTOP"); + if (currentDesktop && strstr(currentDesktop, "GNOME")) { + // Gnome uses dynamic workspaces by default so disable workspace management + // in that case. + bool usesDynamicWorkspaces = true; + nsCOMPtr<nsIGSettingsService> gsettings = + do_GetService(NS_GSETTINGSSERVICE_CONTRACTID); + if (gsettings) { + nsCOMPtr<nsIGSettingsCollection> mutterSettings; + gsettings->GetCollectionForSchema(nsLiteralCString(kDesktopMutterSchema), + getter_AddRefs(mutterSettings)); + if (mutterSettings) { + if (NS_SUCCEEDED(mutterSettings->GetBoolean( + nsLiteralCString(kDesktopDynamicWorkspacesKey), + &usesDynamicWorkspaces))) { + } + } + } + return usesDynamicWorkspaces; + } + + // When XDG_CURRENT_DESKTOP is missing, try to get window manager name. + if (!currentDesktop) { + nsAutoCString wmName; + if (GetWindowManagerName(gdk_window, wmName)) { + if (wmName.EqualsLiteral("bspwm")) { + return true; + } + if (wmName.EqualsLiteral("i3")) { + return true; + } + } + } + + return false; +} + +void nsWindow::GetWorkspaceID(nsAString& workspaceID) { + workspaceID.Truncate(); + + if (!mIsX11Display || !mShell) { + return; + } + // Get the gdk window for this widget. + GdkWindow* gdk_window = gtk_widget_get_window(mShell); + if (!gdk_window) { + return; + } + + if (WorkspaceManagementDisabled(gdk_window)) { + return; + } + + GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL); + GdkAtom type_returned; + int format_returned; + int length_returned; + long* wm_desktop; + + if (!gdk_property_get(gdk_window, gdk_atom_intern("_NET_WM_DESKTOP", FALSE), + cardinal_atom, + 0, // offset + INT32_MAX, // length + FALSE, // delete + &type_returned, &format_returned, &length_returned, + (guchar**)&wm_desktop)) { + return; + } + + workspaceID.AppendInt((int32_t)wm_desktop[0]); + g_free(wm_desktop); +} + +void nsWindow::MoveToWorkspace(const nsAString& workspaceIDStr) { + nsresult rv = NS_OK; + int32_t workspaceID = workspaceIDStr.ToInteger(&rv); + if (NS_FAILED(rv) || !workspaceID || !mIsX11Display || !mShell) { + return; + } + + // Get the gdk window for this widget. + GdkWindow* gdk_window = gtk_widget_get_window(mShell); + if (!gdk_window) { + return; + } + + // This code is inspired by some found in the 'gxtuner' project. + // https://github.com/brummer10/gxtuner/blob/792d453da0f3a599408008f0f1107823939d730d/deskpager.cpp#L50 + XEvent xevent; + Display* xdisplay = gdk_x11_get_default_xdisplay(); + GdkScreen* screen = gdk_window_get_screen(gdk_window); + Window root_win = GDK_WINDOW_XID(gdk_screen_get_root_window(screen)); + GdkDisplay* display = gdk_window_get_display(gdk_window); + Atom type = gdk_x11_get_xatom_by_name_for_display(display, "_NET_WM_DESKTOP"); + + xevent.type = ClientMessage; + xevent.xclient.type = ClientMessage; + xevent.xclient.serial = 0; + xevent.xclient.send_event = TRUE; + xevent.xclient.display = xdisplay; + xevent.xclient.window = GDK_WINDOW_XID(gdk_window); + xevent.xclient.message_type = type; + xevent.xclient.format = 32; + xevent.xclient.data.l[0] = workspaceID; + xevent.xclient.data.l[1] = X11CurrentTime; + xevent.xclient.data.l[2] = 0; + xevent.xclient.data.l[3] = 0; + xevent.xclient.data.l[4] = 0; + + XSendEvent(xdisplay, root_win, FALSE, + SubstructureNotifyMask | SubstructureRedirectMask, &xevent); + + XFlush(xdisplay); +} + +typedef void (*SetUserTimeFunc)(GdkWindow* aWindow, guint32 aTimestamp); + +static void SetUserTimeAndStartupIDForActivatedWindow(GtkWidget* aWindow) { + nsGTKToolkit* GTKToolkit = nsGTKToolkit::GetToolkit(); + if (!GTKToolkit) return; + + nsAutoCString desktopStartupID; + GTKToolkit->GetDesktopStartupID(&desktopStartupID); + if (desktopStartupID.IsEmpty()) { + // We don't have the data we need. Fall back to an + // approximation ... using the timestamp of the remote command + // being received as a guess for the timestamp of the user event + // that triggered it. + uint32_t timestamp = GTKToolkit->GetFocusTimestamp(); + if (timestamp) { + gdk_window_focus(gtk_widget_get_window(aWindow), timestamp); + GTKToolkit->SetFocusTimestamp(0); + } + return; + } + + gtk_window_set_startup_id(GTK_WINDOW(aWindow), desktopStartupID.get()); + + // If we used the startup ID, that already contains the focus timestamp; + // we don't want to reuse the timestamp next time we raise the window + GTKToolkit->SetFocusTimestamp(0); + GTKToolkit->SetDesktopStartupID(""_ns); +} + +/* static */ +guint32 nsWindow::GetLastUserInputTime() { + // gdk_x11_display_get_user_time/gtk_get_current_event_time tracks + // button and key presses, DESKTOP_STARTUP_ID used to start the app, + // drop events from external drags, + // WM_DELETE_WINDOW delete events, but not usually mouse motion nor + // button and key releases. Therefore use the most recent of + // gdk_x11_display_get_user_time and the last time that we have seen. + GdkDisplay* gdkDisplay = gdk_display_get_default(); + guint32 timestamp = GDK_IS_X11_DISPLAY(gdkDisplay) + ? gdk_x11_display_get_user_time(gdkDisplay) + : gtk_get_current_event_time(); + + if (sLastUserInputTime != GDK_CURRENT_TIME && + TimestampIsNewerThan(sLastUserInputTime, timestamp)) { + return sLastUserInputTime; + } + + return timestamp; +} + +void nsWindow::SetFocus(Raise aRaise, mozilla::dom::CallerType aCallerType) { + // Make sure that our owning widget has focus. If it doesn't try to + // grab it. Note that we don't set our focus flag in this case. + + LOGFOCUS((" SetFocus %d [%p]\n", aRaise == Raise::Yes, (void*)this)); + + GtkWidget* owningWidget = GetMozContainerWidget(); + if (!owningWidget) return; + + // Raise the window if someone passed in true and the prefs are + // set properly. + GtkWidget* toplevelWidget = gtk_widget_get_toplevel(owningWidget); + + if (gRaiseWindows && aRaise == Raise::Yes && toplevelWidget && + !gtk_widget_has_focus(owningWidget) && + !gtk_widget_has_focus(toplevelWidget)) { + GtkWidget* top_window = GetToplevelWidget(); + if (top_window && (gtk_widget_get_visible(top_window))) { + gdk_window_show_unraised(gtk_widget_get_window(top_window)); + // Unset the urgency hint if possible. + SetUrgencyHint(top_window, false); + } + } + + RefPtr<nsWindow> owningWindow = get_window_for_gtk_widget(owningWidget); + if (!owningWindow) return; + + if (aRaise == Raise::Yes) { + // means request toplevel activation. + + // This is asynchronous. + // If and when the window manager accepts the request, then the focus + // widget will get a focus-in-event signal. + if (gRaiseWindows && owningWindow->mIsShown && owningWindow->mShell && + !gtk_window_is_active(GTK_WINDOW(owningWindow->mShell))) { + if (!mIsX11Display && + Preferences::GetBool("testing.browserTestHarness.running", false)) { + // Wayland does not support focus changes so we need to workaround it + // by window hide/show sequence but only when it's running in testsuite. + owningWindow->NativeShow(false); + owningWindow->NativeShow(true); + return; + } + + uint32_t timestamp = GDK_CURRENT_TIME; + + nsGTKToolkit* GTKToolkit = nsGTKToolkit::GetToolkit(); + if (GTKToolkit) timestamp = GTKToolkit->GetFocusTimestamp(); + + LOGFOCUS((" requesting toplevel activation [%p]\n", (void*)this)); + NS_ASSERTION(owningWindow->mWindowType != eWindowType_popup || mParent, + "Presenting an override-redirect window"); + gtk_window_present_with_time(GTK_WINDOW(owningWindow->mShell), timestamp); + + if (GTKToolkit) GTKToolkit->SetFocusTimestamp(0); + } + return; + } + + // aRaise == No means that keyboard events should be dispatched from this + // widget. + + // Ensure owningWidget is the focused GtkWidget within its toplevel window. + // + // For eWindowType_popup, this GtkWidget may not actually be the one that + // receives the key events as it may be the parent window that is active. + if (!gtk_widget_is_focus(owningWidget)) { + // This is synchronous. It takes focus from a plugin or from a widget + // in an embedder. The focus manager already knows that this window + // is active so gBlockActivateEvent avoids another (unnecessary) + // activate notification. + gBlockActivateEvent = true; + gtk_widget_grab_focus(owningWidget); + gBlockActivateEvent = false; + } + + // If this is the widget that already has focus, return. + if (gFocusWindow == this) { + LOGFOCUS((" already have focus [%p]\n", (void*)this)); + return; + } + + // Set this window to be the focused child window + gFocusWindow = this; + + if (mIMContext) { + mIMContext->OnFocusWindow(this); + } + + LOGFOCUS((" widget now has focus in SetFocus() [%p]\n", (void*)this)); +} + +LayoutDeviceIntRect nsWindow::GetScreenBounds() { + LayoutDeviceIntRect rect; + if (mIsTopLevel && mContainer) { + // use the point including window decorations + gint x, y; + gdk_window_get_root_origin(gtk_widget_get_window(GTK_WIDGET(mContainer)), + &x, &y); + rect.MoveTo(GdkPointToDevicePixels({x, y})); + } else { + rect.MoveTo(WidgetToScreenOffset()); + } + // mBounds.Size() is the window bounds, not the window-manager frame + // bounds (bug 581863). gdk_window_get_frame_extents would give the + // frame bounds, but mBounds.Size() is returned here for consistency + // with Resize. + rect.SizeTo(mBounds.Size()); +#if MOZ_LOGGING + gint scale = GdkScaleFactor(); + LOG(("GetScreenBounds [%p] %d,%d -> %d x %d, unscaled %d,%d -> %d x %d\n", + this, rect.x, rect.y, rect.width, rect.height, rect.x / scale, + rect.y / scale, rect.width / scale, rect.height / scale)); +#endif + return rect; +} + +LayoutDeviceIntSize nsWindow::GetClientSize() { + return LayoutDeviceIntSize(mBounds.width, mBounds.height); +} + +LayoutDeviceIntRect nsWindow::GetClientBounds() { + // GetBounds returns a rect whose top left represents the top left of the + // outer bounds, but whose width/height represent the size of the inner + // bounds (which is messed up). + LayoutDeviceIntRect rect = GetBounds(); + rect.MoveBy(GetClientOffset()); + return rect; +} + +void nsWindow::UpdateClientOffsetFromFrameExtents() { + AUTO_PROFILER_LABEL("nsWindow::UpdateClientOffsetFromFrameExtents", OTHER); + + if (mCSDSupportLevel == CSD_SUPPORT_CLIENT && mDrawInTitlebar) { + return; + } + + if (!mIsTopLevel || !mShell || + gtk_window_get_window_type(GTK_WINDOW(mShell)) == GTK_WINDOW_POPUP) { + mClientOffset = nsIntPoint(0, 0); + return; + } + + GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL); + + GdkAtom type_returned; + int format_returned; + int length_returned; + long* frame_extents; + + if (!gdk_property_get(gtk_widget_get_window(mShell), + gdk_atom_intern("_NET_FRAME_EXTENTS", FALSE), + cardinal_atom, + 0, // offset + 4 * 4, // length + FALSE, // delete + &type_returned, &format_returned, &length_returned, + (guchar**)&frame_extents) || + length_returned / sizeof(glong) != 4) { + mClientOffset = nsIntPoint(0, 0); + } else { + // data returned is in the order left, right, top, bottom + auto left = int32_t(frame_extents[0]); + auto top = int32_t(frame_extents[2]); + g_free(frame_extents); + + mClientOffset = nsIntPoint(left, top); + } + + // Send a WindowMoved notification. This ensures that BrowserParent + // picks up the new client offset and sends it to the child process + // if appropriate. + NotifyWindowMoved(mBounds.x, mBounds.y); + + LOG(("nsWindow::UpdateClientOffsetFromFrameExtents [%p] %d,%d\n", (void*)this, + mClientOffset.x, mClientOffset.y)); +} + +LayoutDeviceIntPoint nsWindow::GetClientOffset() { + return mIsX11Display ? LayoutDeviceIntPoint::FromUnknownPoint(mClientOffset) + : LayoutDeviceIntPoint(0, 0); +} + +gboolean nsWindow::OnPropertyNotifyEvent(GtkWidget* aWidget, + GdkEventProperty* aEvent) { + if (aEvent->atom == gdk_atom_intern("_NET_FRAME_EXTENTS", FALSE)) { + UpdateClientOffsetFromFrameExtents(); + return FALSE; + } + + if (GetCurrentTimeGetter()->PropertyNotifyHandler(aWidget, aEvent)) { + return TRUE; + } + + return FALSE; +} + +static GdkCursor* GetCursorForImage(imgIContainer* aCursorImage, + uint32_t aHotspotX, uint32_t aHotspotY) { + if (!aCursorImage) { + return nullptr; + } + GdkPixbuf* pixbuf = nsImageToPixbuf::ImageToPixbuf(aCursorImage); + if (!pixbuf) { + return nullptr; + } + + int width = gdk_pixbuf_get_width(pixbuf); + int height = gdk_pixbuf_get_height(pixbuf); + + auto CleanupPixBuf = + mozilla::MakeScopeExit([&]() { g_object_unref(pixbuf); }); + + // Reject cursors greater than 128 pixels in some direction, to prevent + // spoofing. + // XXX ideally we should rescale. Also, we could modify the API to + // allow trusted content to set larger cursors. + // + // TODO(emilio, bug 1445844): Unify the solution for this with other + // platforms. + if (width > 128 || height > 128) { + return nullptr; + } + + // Looks like all cursors need an alpha channel (tested on Gtk 2.4.4). This + // is of course not documented anywhere... + // So add one if there isn't one yet + if (!gdk_pixbuf_get_has_alpha(pixbuf)) { + GdkPixbuf* alphaBuf = gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0); + g_object_unref(pixbuf); + pixbuf = alphaBuf; + if (!alphaBuf) { + return nullptr; + } + } + + return gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, + aHotspotX, aHotspotY); +} + +void nsWindow::SetCursor(nsCursor aDefaultCursor, imgIContainer* aCursorImage, + uint32_t aHotspotX, uint32_t aHotspotY) { + // if we're not the toplevel window pass up the cursor request to + // the toplevel window to handle it. + if (!mContainer && mGdkWindow) { + nsWindow* window = GetContainerWindow(); + if (!window) return; + + window->SetCursor(aDefaultCursor, aCursorImage, aHotspotX, aHotspotY); + return; + } + + // Only change cursor if it's actually been changed + if (!aCursorImage && aDefaultCursor == mCursor && !mUpdateCursor) { + return; + } + + mUpdateCursor = false; + mCursor = eCursorInvalid; + + // Try to set the cursor image first, and fall back to the numeric cursor. + GdkCursor* newCursor = GetCursorForImage(aCursorImage, aHotspotX, aHotspotY); + if (!newCursor) { + newCursor = get_gtk_cursor(aDefaultCursor); + if (newCursor) { + mCursor = aDefaultCursor; + } + } + + auto CleanupCursor = mozilla::MakeScopeExit([&]() { + // get_gtk_cursor returns a weak reference, which we shouldn't unref. + if (newCursor && mCursor == eCursorInvalid) { + g_object_unref(newCursor); + } + }); + + if (!newCursor || !mContainer) { + return; + } + + gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(mContainer)), + newCursor); +} + +void nsWindow::Invalidate(const LayoutDeviceIntRect& aRect) { + if (!mGdkWindow) return; + + GdkRectangle rect = DevicePixelsToGdkRectRoundOut(aRect); + gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE); + + LOGDRAW(("Invalidate (rect) [%p]: %d %d %d %d\n", (void*)this, rect.x, rect.y, + rect.width, rect.height)); +} + +void* nsWindow::GetNativeData(uint32_t aDataType) { + switch (aDataType) { + case NS_NATIVE_WINDOW: + case NS_NATIVE_WIDGET: { + if (!mGdkWindow) return nullptr; + + return mGdkWindow; + } + + case NS_NATIVE_DISPLAY: { +#ifdef MOZ_X11 + GdkDisplay* gdkDisplay = gdk_display_get_default(); + if (gdkDisplay && GDK_IS_X11_DISPLAY(gdkDisplay)) { + return GDK_DISPLAY_XDISPLAY(gdkDisplay); + } +#endif /* MOZ_X11 */ + // Don't bother to return native display on Wayland as it's for + // X11 only NPAPI plugins. + return nullptr; + } + case NS_NATIVE_SHELLWIDGET: + return GetToplevelWidget(); + + case NS_NATIVE_WINDOW_WEBRTC_DEVICE_ID: + case NS_NATIVE_SHAREABLE_WINDOW: + if (mIsX11Display) { + return (void*)GDK_WINDOW_XID(gdk_window_get_toplevel(mGdkWindow)); + } + NS_WARNING( + "nsWindow::GetNativeData(): " + "NS_NATIVE_SHAREABLE_WINDOW / NS_NATIVE_WINDOW_WEBRTC_DEVICE_ID is " + "not " + "handled on Wayland!"); + return nullptr; + case NS_RAW_NATIVE_IME_CONTEXT: { + void* pseudoIMEContext = GetPseudoIMEContext(); + if (pseudoIMEContext) { + return pseudoIMEContext; + } + // If IME context isn't available on this widget, we should set |this| + // instead of nullptr. + if (!mIMContext) { + return this; + } + return mIMContext.get(); + } + case NS_NATIVE_OPENGL_CONTEXT: + return nullptr; + case NS_NATIVE_EGL_WINDOW: { + if (mIsX11Display) { + return mGdkWindow ? (void*)GDK_WINDOW_XID(mGdkWindow) : nullptr; + } +#ifdef MOZ_WAYLAND + if (mContainer) { + return moz_container_wayland_get_egl_window(mContainer, + GdkScaleFactor()); + } +#endif + return nullptr; + } + default: + NS_WARNING("nsWindow::GetNativeData called with bad value"); + return nullptr; + } +} + +nsresult nsWindow::SetTitle(const nsAString& aTitle) { + if (!mShell) return NS_OK; + + // convert the string into utf8 and set the title. +#define UTF8_FOLLOWBYTE(ch) (((ch)&0xC0) == 0x80) + NS_ConvertUTF16toUTF8 titleUTF8(aTitle); + if (titleUTF8.Length() > NS_WINDOW_TITLE_MAX_LENGTH) { + // Truncate overlong titles (bug 167315). Make sure we chop after a + // complete sequence by making sure the next char isn't a follow-byte. + uint32_t len = NS_WINDOW_TITLE_MAX_LENGTH; + while (UTF8_FOLLOWBYTE(titleUTF8[len])) --len; + titleUTF8.Truncate(len); + } + gtk_window_set_title(GTK_WINDOW(mShell), (const char*)titleUTF8.get()); + + return NS_OK; +} + +void nsWindow::SetIcon(const nsAString& aIconSpec) { + if (!mShell) return; + + nsAutoCString iconName; + + if (aIconSpec.EqualsLiteral("default")) { + nsAutoString brandName; + WidgetUtils::GetBrandShortName(brandName); + if (brandName.IsEmpty()) { + brandName.AssignLiteral(u"Mozilla"); + } + AppendUTF16toUTF8(brandName, iconName); + ToLowerCase(iconName); + } else { + AppendUTF16toUTF8(aIconSpec, iconName); + } + + nsCOMPtr<nsIFile> iconFile; + nsAutoCString path; + + gint* iconSizes = gtk_icon_theme_get_icon_sizes(gtk_icon_theme_get_default(), + iconName.get()); + bool foundIcon = (iconSizes[0] != 0); + g_free(iconSizes); + + if (!foundIcon) { + // Look for icons with the following suffixes appended to the base name + // The last two entries (for the old XPM format) will be ignored unless + // no icons are found using other suffixes. XPM icons are deprecated. + + const char16_t extensions[9][8] = {u".png", u"16.png", u"32.png", + u"48.png", u"64.png", u"128.png", + u"256.png", u".xpm", u"16.xpm"}; + + for (uint32_t i = 0; i < ArrayLength(extensions); i++) { + // Don't bother looking for XPM versions if we found a PNG. + if (i == ArrayLength(extensions) - 2 && foundIcon) break; + + ResolveIconName(aIconSpec, nsDependentString(extensions[i]), + getter_AddRefs(iconFile)); + if (iconFile) { + iconFile->GetNativePath(path); + GdkPixbuf* icon = gdk_pixbuf_new_from_file(path.get(), nullptr); + if (icon) { + gtk_icon_theme_add_builtin_icon(iconName.get(), + gdk_pixbuf_get_height(icon), icon); + g_object_unref(icon); + foundIcon = true; + } + } + } + } + + // leave the default icon intact if no matching icons were found + if (foundIcon) { + gtk_window_set_icon_name(GTK_WINDOW(mShell), iconName.get()); + } +} + +LayoutDeviceIntPoint nsWindow::WidgetToScreenOffset() { + nsIntPoint origin(0, 0); + GetWindowOrigin(mGdkWindow, &origin.x, &origin.y); + + return GdkPointToDevicePixels({origin.x, origin.y}); +} + +void nsWindow::CaptureMouse(bool aCapture) { + LOG(("CaptureMouse %p\n", (void*)this)); + + if (!mGdkWindow) return; + + if (!mContainer) return; + + if (aCapture) { + gtk_grab_add(GTK_WIDGET(mContainer)); + GrabPointer(GetLastUserInputTime()); + } else { + ReleaseGrabs(); + gtk_grab_remove(GTK_WIDGET(mContainer)); + } +} + +void nsWindow::CaptureRollupEvents(nsIRollupListener* aListener, + bool aDoCapture) { + if (!mGdkWindow) return; + + if (!mContainer) return; + + LOG(("CaptureRollupEvents %p %i\n", this, int(aDoCapture))); + + if (aDoCapture) { + gRollupListener = aListener; + // Don't add a grab if a drag is in progress, or if the widget is a drag + // feedback popup. (panels with type="drag"). + if (!mIsDragPopup && !nsWindow::DragInProgress()) { + gtk_grab_add(GTK_WIDGET(mContainer)); + GrabPointer(GetLastUserInputTime()); + } + } else { + if (!nsWindow::DragInProgress()) { + ReleaseGrabs(); + } + // There may not have been a drag in process when aDoCapture was set, + // so make sure to remove any added grab. This is a no-op if the grab + // was not added to this widget. + gtk_grab_remove(GTK_WIDGET(mContainer)); + gRollupListener = nullptr; + } +} + +nsresult nsWindow::GetAttention(int32_t aCycleCount) { + LOG(("nsWindow::GetAttention [%p]\n", (void*)this)); + + GtkWidget* top_window = GetToplevelWidget(); + GtkWidget* top_focused_window = + gFocusWindow ? gFocusWindow->GetToplevelWidget() : nullptr; + + // Don't get attention if the window is focused anyway. + if (top_window && (gtk_widget_get_visible(top_window)) && + top_window != top_focused_window) { + SetUrgencyHint(top_window, true); + } + + return NS_OK; +} + +bool nsWindow::HasPendingInputEvent() { + // This sucks, but gtk/gdk has no way to answer the question we want while + // excluding paint events, and there's no X API that will let us peek + // without blocking or removing. To prevent event reordering, peek + // anything except expose events. Reordering expose and others should be + // ok, hopefully. + bool haveEvent = false; +#ifdef MOZ_X11 + XEvent ev; + if (mIsX11Display) { + Display* display = GDK_DISPLAY_XDISPLAY(gdk_display_get_default()); + haveEvent = XCheckMaskEvent( + display, + KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | + EnterWindowMask | LeaveWindowMask | PointerMotionMask | + PointerMotionHintMask | Button1MotionMask | Button2MotionMask | + Button3MotionMask | Button4MotionMask | Button5MotionMask | + ButtonMotionMask | KeymapStateMask | VisibilityChangeMask | + StructureNotifyMask | ResizeRedirectMask | SubstructureNotifyMask | + SubstructureRedirectMask | FocusChangeMask | PropertyChangeMask | + ColormapChangeMask | OwnerGrabButtonMask, + &ev); + if (haveEvent) { + XPutBackEvent(display, &ev); + } + } +#endif + return haveEvent; +} + +#if 0 +# ifdef DEBUG +// Paint flashing code (disabled for cairo - see below) + +# define CAPS_LOCK_IS_ON \ + (KeymapWrapper::AreModifiersCurrentlyActive(KeymapWrapper::CAPS_LOCK)) + +# define WANT_PAINT_FLASHING (debug_WantPaintFlashing() && CAPS_LOCK_IS_ON) + +# ifdef MOZ_X11 +static void +gdk_window_flash(GdkWindow * aGdkWindow, + unsigned int aTimes, + unsigned int aInterval, // Milliseconds + GdkRegion * aRegion) +{ + gint x; + gint y; + gint width; + gint height; + guint i; + GdkGC * gc = 0; + GdkColor white; + + gdk_window_get_geometry(aGdkWindow,nullptr,nullptr,&width,&height); + + gdk_window_get_origin (aGdkWindow, + &x, + &y); + + gc = gdk_gc_new(gdk_get_default_root_window()); + + white.pixel = WhitePixel(gdk_display,DefaultScreen(gdk_display)); + + gdk_gc_set_foreground(gc,&white); + gdk_gc_set_function(gc,GDK_XOR); + gdk_gc_set_subwindow(gc,GDK_INCLUDE_INFERIORS); + + gdk_region_offset(aRegion, x, y); + gdk_gc_set_clip_region(gc, aRegion); + + /* + * Need to do this twice so that the XOR effect can replace + * the original window contents. + */ + for (i = 0; i < aTimes * 2; i++) + { + gdk_draw_rectangle(gdk_get_default_root_window(), + gc, + TRUE, + x, + y, + width, + height); + + gdk_flush(); + + PR_Sleep(PR_MillisecondsToInterval(aInterval)); + } + + gdk_gc_destroy(gc); + + gdk_region_offset(aRegion, -x, -y); +} +# endif /* MOZ_X11 */ +# endif // DEBUG +#endif + +#ifdef cairo_copy_clip_rectangle_list +# error "Looks like we're including Mozilla's cairo instead of system cairo" +#endif +static bool ExtractExposeRegion(LayoutDeviceIntRegion& aRegion, cairo_t* cr) { + cairo_rectangle_list_t* rects = cairo_copy_clip_rectangle_list(cr); + if (rects->status != CAIRO_STATUS_SUCCESS) { + NS_WARNING("Failed to obtain cairo rectangle list."); + return false; + } + + for (int i = 0; i < rects->num_rectangles; i++) { + const cairo_rectangle_t& r = rects->rectangles[i]; + aRegion.Or(aRegion, + LayoutDeviceIntRect::Truncate(r.x, r.y, r.width, r.height)); + LOGDRAW(("\t%f %f %f %f\n", r.x, r.y, r.width, r.height)); + } + + cairo_rectangle_list_destroy(rects); + return true; +} + +#ifdef MOZ_WAYLAND +void nsWindow::MaybeResumeCompositor() { + MOZ_RELEASE_ASSERT(NS_IsMainThread()); + + if (mIsDestroyed || !mNeedsCompositorResume) { + return; + } + + if (CompositorBridgeChild* remoteRenderer = GetRemoteRenderer()) { + MOZ_ASSERT(mCompositorWidgetDelegate); + if (mCompositorWidgetDelegate) { + mCompositorInitiallyPaused = false; + mNeedsCompositorResume = false; + remoteRenderer->SendResumeAsync(); + } + remoteRenderer->SendForcePresent(); + } +} + +void nsWindow::CreateCompositorVsyncDispatcher() { + if (!mWaylandVsyncSource) { + nsBaseWidget::CreateCompositorVsyncDispatcher(); + return; + } + + if (XRE_IsParentProcess()) { + if (!mCompositorVsyncDispatcherLock) { + mCompositorVsyncDispatcherLock = + MakeUnique<Mutex>("mCompositorVsyncDispatcherLock"); + } + MutexAutoLock lock(*mCompositorVsyncDispatcherLock); + if (!mCompositorVsyncDispatcher) { + mCompositorVsyncDispatcher = + new CompositorVsyncDispatcher(mWaylandVsyncSource); + } + } +} +#endif + +gboolean nsWindow::OnExposeEvent(cairo_t* cr) { + // Send any pending resize events so that layout can update. + // May run event loop. + MaybeDispatchResized(); + + if (mIsDestroyed) { + return FALSE; + } + + // Windows that are not visible will be painted after they become visible. + if (!mGdkWindow || !mHasMappedToplevel) { + return FALSE; + } +#ifdef MOZ_WAYLAND + if (!mIsX11Display && !moz_container_wayland_can_draw(mContainer)) { + return FALSE; + } +#endif + + nsIWidgetListener* listener = GetListener(); + if (!listener) return FALSE; + + LOGDRAW(("received expose event [%p] %p 0x%lx (rects follow):\n", this, + mGdkWindow, mIsX11Display ? gdk_x11_window_get_xid(mGdkWindow) : 0)); + LayoutDeviceIntRegion exposeRegion; + if (!ExtractExposeRegion(exposeRegion, cr)) { + return FALSE; + } + + gint scale = GdkScaleFactor(); + LayoutDeviceIntRegion region = exposeRegion; + region.ScaleRoundOut(scale, scale); + + if (GetLayerManager()->AsKnowsCompositor() && mCompositorSession) { + // We need to paint to the screen even if nothing changed, since if we + // don't have a compositing window manager, our pixels could be stale. + GetLayerManager()->SetNeedsComposite(true); + GetLayerManager()->SendInvalidRegion(region.ToUnknownRegion()); + } + + RefPtr<nsWindow> strongThis(this); + + // Dispatch WillPaintWindow notification to allow scripts etc. to run + // before we paint + { + listener->WillPaintWindow(this); + + // If the window has been destroyed during the will paint notification, + // there is nothing left to do. + if (!mGdkWindow) return TRUE; + + // Re-get the listener since the will paint notification might have + // killed it. + listener = GetListener(); + if (!listener) return FALSE; + } + + if (GetLayerManager()->AsKnowsCompositor() && + GetLayerManager()->NeedsComposite()) { + GetLayerManager()->ScheduleComposite(); + GetLayerManager()->SetNeedsComposite(false); + } + + // Our bounds may have changed after calling WillPaintWindow. Clip + // to the new bounds here. The region is relative to this + // window. + region.And(region, LayoutDeviceIntRect(0, 0, mBounds.width, mBounds.height)); + + bool shaped = false; + if (eTransparencyTransparent == GetTransparencyMode()) { + auto window = static_cast<nsWindow*>(GetTopLevelWidget()); + if (mTransparencyBitmapForTitlebar) { + if (mSizeState == nsSizeMode_Normal) { + window->UpdateTitlebarTransparencyBitmap(); + } else { + window->ClearTransparencyBitmap(); + } + } else { + if (mHasAlphaVisual) { + // Remove possible shape mask from when window manger was not + // previously compositing. + window->ClearTransparencyBitmap(); + } else { + shaped = true; + } + } + } + + if (!shaped) { + GList* children = gdk_window_peek_children(mGdkWindow); + while (children) { + GdkWindow* gdkWin = GDK_WINDOW(children->data); + nsWindow* kid = get_window_for_gdk_window(gdkWin); + if (kid && gdk_window_is_visible(gdkWin)) { + AutoTArray<LayoutDeviceIntRect, 1> clipRects; + kid->GetWindowClipRegion(&clipRects); + LayoutDeviceIntRect bounds = kid->GetBounds(); + for (uint32_t i = 0; i < clipRects.Length(); ++i) { + LayoutDeviceIntRect r = clipRects[i] + bounds.TopLeft(); + region.Sub(region, r); + } + } + children = children->next; + } + } + + if (region.IsEmpty()) { + return TRUE; + } + + // If this widget uses OMTC... + if (GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_CLIENT || + GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_WR) { + listener->PaintWindow(this, region); + + // Re-get the listener since the will paint notification might have + // killed it. + listener = GetListener(); + if (!listener) return TRUE; + + listener->DidPaintWindow(); + return TRUE; + } + + BufferMode layerBuffering = BufferMode::BUFFERED; + RefPtr<DrawTarget> dt = StartRemoteDrawingInRegion(region, &layerBuffering); + if (!dt || !dt->IsValid()) { + return FALSE; + } + RefPtr<gfxContext> ctx; + IntRect boundsRect = region.GetBounds().ToUnknownRect(); + IntPoint offset(0, 0); + if (dt->GetSize() == boundsRect.Size()) { + offset = boundsRect.TopLeft(); + dt->SetTransform(Matrix::Translation(-offset)); + } + +#ifdef MOZ_X11 + if (shaped) { + // Collapse update area to the bounding box. This is so we only have to + // call UpdateTranslucentWindowAlpha once. After we have dropped + // support for non-Thebes graphics, UpdateTranslucentWindowAlpha will be + // our private interface so we can rework things to avoid this. + dt->PushClipRect(Rect(boundsRect)); + + // The double buffering is done here to extract the shape mask. + // (The shape mask won't be necessary when a visual with an alpha + // channel is used on compositing window managers.) + layerBuffering = BufferMode::BUFFER_NONE; + RefPtr<DrawTarget> destDT = + dt->CreateSimilarDrawTarget(boundsRect.Size(), SurfaceFormat::B8G8R8A8); + if (!destDT || !destDT->IsValid()) { + return FALSE; + } + destDT->SetTransform(Matrix::Translation(-boundsRect.TopLeft())); + ctx = gfxContext::CreatePreservingTransformOrNull(destDT); + } else { + gfxUtils::ClipToRegion(dt, region.ToUnknownRegion()); + ctx = gfxContext::CreatePreservingTransformOrNull(dt); + } + MOZ_ASSERT(ctx); // checked both dt and destDT valid draw target above + +# if 0 + // NOTE: Paint flashing region would be wrong for cairo, since + // cairo inflates the update region, etc. So don't paint flash + // for cairo. +# ifdef DEBUG + // XXX aEvent->region may refer to a newly-invalid area. FIXME + if (0 && WANT_PAINT_FLASHING && gtk_widget_get_window(aEvent)) + gdk_window_flash(mGdkWindow, 1, 100, aEvent->region); +# endif +# endif + +#endif // MOZ_X11 + + bool painted = false; + { + if (GetLayerManager()->GetBackendType() == LayersBackend::LAYERS_BASIC) { + if (GetTransparencyMode() == eTransparencyTransparent && + layerBuffering == BufferMode::BUFFER_NONE && mHasAlphaVisual) { + // If our draw target is unbuffered and we use an alpha channel, + // clear the image beforehand to ensure we don't get artifacts from a + // reused SHM image. See bug 1258086. + dt->ClearRect(Rect(boundsRect)); + } + AutoLayerManagerSetup setupLayerManager(this, ctx, layerBuffering); + painted = listener->PaintWindow(this, region); + + // Re-get the listener since the will paint notification might have + // killed it. + listener = GetListener(); + if (!listener) return TRUE; + } + } + +#ifdef MOZ_X11 + // PaintWindow can Destroy us (bug 378273), avoid doing any paint + // operations below if that happened - it will lead to XError and exit(). + if (shaped) { + if (MOZ_LIKELY(!mIsDestroyed)) { + if (painted) { + RefPtr<SourceSurface> surf = ctx->GetDrawTarget()->Snapshot(); + + UpdateAlpha(surf, boundsRect); + + dt->DrawSurface(surf, Rect(boundsRect), + Rect(0, 0, boundsRect.width, boundsRect.height), + DrawSurfaceOptions(SamplingFilter::POINT), + DrawOptions(1.0f, CompositionOp::OP_SOURCE)); + } + } + } + + ctx = nullptr; + dt->PopClip(); + +#endif // MOZ_X11 + + EndRemoteDrawingInRegion(dt, region); + + listener->DidPaintWindow(); + + // Synchronously flush any new dirty areas + cairo_region_t* dirtyArea = gdk_window_get_update_area(mGdkWindow); + + if (dirtyArea) { + gdk_window_invalidate_region(mGdkWindow, dirtyArea, false); + cairo_region_destroy(dirtyArea); + gdk_window_process_updates(mGdkWindow, false); + } + + // check the return value! + return TRUE; +} + +void nsWindow::UpdateAlpha(SourceSurface* aSourceSurface, + nsIntRect aBoundsRect) { + // We need to create our own buffer to force the stride to match the + // expected stride. + int32_t stride = + GetAlignedStride<4>(aBoundsRect.width, BytesPerPixel(SurfaceFormat::A8)); + if (stride == 0) { + return; + } + int32_t bufferSize = stride * aBoundsRect.height; + auto imageBuffer = MakeUniqueFallible<uint8_t[]>(bufferSize); + { + RefPtr<DrawTarget> drawTarget = gfxPlatform::CreateDrawTargetForData( + imageBuffer.get(), aBoundsRect.Size(), stride, SurfaceFormat::A8); + + if (drawTarget) { + drawTarget->DrawSurface(aSourceSurface, + Rect(0, 0, aBoundsRect.width, aBoundsRect.height), + Rect(0, 0, aSourceSurface->GetSize().width, + aSourceSurface->GetSize().height), + DrawSurfaceOptions(SamplingFilter::POINT), + DrawOptions(1.0f, CompositionOp::OP_SOURCE)); + } + } + UpdateTranslucentWindowAlphaInternal(aBoundsRect, imageBuffer.get(), stride); +} + +gboolean nsWindow::OnConfigureEvent(GtkWidget* aWidget, + GdkEventConfigure* aEvent) { + // These events are only received on toplevel windows. + // + // GDK ensures that the coordinates are the client window top-left wrt the + // root window. + // + // GDK calculates the cordinates for real ConfigureNotify events on + // managed windows (that would normally be relative to the parent + // window). + // + // Synthetic ConfigureNotify events are from the window manager and + // already relative to the root window. GDK creates all X windows with + // border_width = 0, so synthetic events also indicate the top-left of + // the client window. + // + // Override-redirect windows are children of the root window so parent + // coordinates are root coordinates. + + LOG(("configure event [%p] %d %d %d %d\n", (void*)this, aEvent->x, aEvent->y, + aEvent->width, aEvent->height)); + + if (mPendingConfigures > 0) { + mPendingConfigures--; + } + + LayoutDeviceIntRect screenBounds = GetScreenBounds(); + + if (mWindowType == eWindowType_toplevel || + mWindowType == eWindowType_dialog) { + // This check avoids unwanted rollup on spurious configure events from + // Cygwin/X (bug 672103). + if (mBounds.x != screenBounds.x || mBounds.y != screenBounds.y) { + CheckForRollup(0, 0, false, true); + } + } + + NS_ASSERTION(GTK_IS_WINDOW(aWidget), + "Configure event on widget that is not a GtkWindow"); + if (gtk_window_get_window_type(GTK_WINDOW(aWidget)) == GTK_WINDOW_POPUP) { + // Override-redirect window + // + // These windows should not be moved by the window manager, and so any + // change in position is a result of our direction. mBounds has + // already been set in std::move() or Resize(), and that is more + // up-to-date than the position in the ConfigureNotify event if the + // event is from an earlier window move. + // + // Skipping the WindowMoved call saves context menus from an infinite + // loop when nsXULPopupManager::PopupMoved moves the window to the new + // position and nsMenuPopupFrame::SetPopupPosition adds + // offsetForContextMenu on each iteration. + + // Our back buffer might have been invalidated while we drew the last + // frame, and its contents might be incorrect. See bug 1280653 comment 7 + // and comment 10. Specifically we must ensure we recomposite the frame + // as soon as possible to avoid the corrupted frame being displayed. + GetLayerManager()->FlushRendering(); + return FALSE; + } + + mBounds.MoveTo(screenBounds.TopLeft()); + + // XXX mozilla will invalidate the entire window after this move + // complete. wtf? + NotifyWindowMoved(mBounds.x, mBounds.y); + + // A GTK app would usually update its client area size in response to + // a "size-allocate" signal. + // However, we need to set mBounds in advance at Resize() + // as JS code expects immediate window size change. + // If Gecko requests a resize from GTK, but subsequently, + // before a corresponding "size-allocate" signal is emitted, the window is + // resized to its former size via other means, such as maximizing, + // then there is no "size-allocate" signal from which to update + // the value of mBounds. Similarly, if Gecko's resize request is refused + // by the window manager, then there will be no "size-allocate" signal. + // In the refused request case, the window manager is required to dispatch + // a ConfigureNotify event. mBounds can then be updated here. + // This seems to also be sufficient to update mBounds when Gecko resizes + // the window from maximized size and then immediately maximizes again. + if (!mBoundsAreValid) { + GtkAllocation allocation = {-1, -1, 0, 0}; + gtk_window_get_size(GTK_WINDOW(mShell), &allocation.width, + &allocation.height); + OnSizeAllocate(&allocation); + } + + return FALSE; +} + +void nsWindow::OnContainerUnrealize() { + // The GdkWindows are about to be destroyed (but not deleted), so remove + // their references back to their container widget while the GdkWindow + // hierarchy is still available. + + if (mGdkWindow) { + DestroyChildWindows(); + + g_object_set_data(G_OBJECT(mGdkWindow), "nsWindow", nullptr); + mGdkWindow = nullptr; + } +} + +void nsWindow::OnSizeAllocate(GtkAllocation* aAllocation) { + LOG(("nsWindow::OnSizeAllocate [%p] %d,%d -> %d x %d\n", (void*)this, + aAllocation->x, aAllocation->y, aAllocation->width, + aAllocation->height)); + + // Client offset are updated by _NET_FRAME_EXTENTS on X11 when system titlebar + // is enabled. In either cases (Wayland or system titlebar is off on X11) + // we don't get _NET_FRAME_EXTENTS X11 property notification so we derive + // it from mContainer position. + if (mCSDSupportLevel == CSD_SUPPORT_CLIENT) { + if (!mIsX11Display || (mIsX11Display && mDrawInTitlebar)) { + UpdateClientOffsetFromCSDWindow(); + } + } + + mBoundsAreValid = true; + + LayoutDeviceIntSize size = GdkRectToDevicePixels(*aAllocation).Size(); + if (mBounds.Size() == size) { + LOG((" Already the same size")); + // We were already resized at nsWindow::OnConfigureEvent() so skip it. + return; + } + + // Invalidate the new part of the window now for the pending paint to + // minimize background flashes (GDK does not do this for external resizes + // of toplevels.) + if (mBounds.width < size.width) { + GdkRectangle rect = DevicePixelsToGdkRectRoundOut(LayoutDeviceIntRect( + mBounds.width, 0, size.width - mBounds.width, size.height)); + gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE); + } + if (mBounds.height < size.height) { + GdkRectangle rect = DevicePixelsToGdkRectRoundOut(LayoutDeviceIntRect( + 0, mBounds.height, size.width, size.height - mBounds.height)); + gdk_window_invalidate_rect(mGdkWindow, &rect, FALSE); + } + + mBounds.SizeTo(size); + +#ifdef MOZ_X11 + // Notify the GtkCompositorWidget of a ClientSizeChange + if (mCompositorWidgetDelegate) { + mCompositorWidgetDelegate->NotifyClientSizeChanged(GetClientSize()); + } +#endif + + // Gecko permits running nested event loops during processing of events, + // GtkWindow callers of gtk_widget_size_allocate expect the signal + // handlers to return sometime in the near future. + mNeedsDispatchResized = true; + NS_DispatchToCurrentThread(NewRunnableMethod( + "nsWindow::MaybeDispatchResized", this, &nsWindow::MaybeDispatchResized)); +} + +void nsWindow::OnDeleteEvent() { + if (mWidgetListener) mWidgetListener->RequestWindowClose(this); +} + +void nsWindow::OnEnterNotifyEvent(GdkEventCrossing* aEvent) { + // This skips NotifyVirtual and NotifyNonlinearVirtual enter notify events + // when the pointer enters a child window. If the destination window is a + // Gecko window then we'll catch the corresponding event on that window, + // but we won't notice when the pointer directly enters a foreign (plugin) + // child window without passing over a visible portion of a Gecko window. + if (aEvent->subwindow != nullptr) return; + + // Check before is_parent_ungrab_enter() as the button state may have + // changed while a non-Gecko ancestor window had a pointer grab. + DispatchMissedButtonReleases(aEvent); + + if (is_parent_ungrab_enter(aEvent)) return; + + WidgetMouseEvent event(true, eMouseEnterIntoWidget, this, + WidgetMouseEvent::eReal); + + event.mRefPoint = GdkEventCoordsToDevicePixels(aEvent->x, aEvent->y); + event.AssignEventTime(GetWidgetEventTime(aEvent->time)); + + LOG(("OnEnterNotify: %p\n", (void*)this)); + + DispatchInputEvent(&event); +} + +// XXX Is this the right test for embedding cases? +static bool is_top_level_mouse_exit(GdkWindow* aWindow, + GdkEventCrossing* aEvent) { + auto x = gint(aEvent->x_root); + auto y = gint(aEvent->y_root); + GdkDisplay* display = gdk_window_get_display(aWindow); + GdkWindow* winAtPt = gdk_display_get_window_at_pointer(display, &x, &y); + if (!winAtPt) return true; + GdkWindow* topLevelAtPt = gdk_window_get_toplevel(winAtPt); + GdkWindow* topLevelWidget = gdk_window_get_toplevel(aWindow); + return topLevelAtPt != topLevelWidget; +} + +void nsWindow::OnLeaveNotifyEvent(GdkEventCrossing* aEvent) { + // This ignores NotifyVirtual and NotifyNonlinearVirtual leave notify + // events when the pointer leaves a child window. If the destination + // window is a Gecko window then we'll catch the corresponding event on + // that window. + // + // XXXkt However, we will miss toplevel exits when the pointer directly + // leaves a foreign (plugin) child window without passing over a visible + // portion of a Gecko window. + if (aEvent->subwindow != nullptr) return; + + WidgetMouseEvent event(true, eMouseExitFromWidget, this, + WidgetMouseEvent::eReal); + + event.mRefPoint = GdkEventCoordsToDevicePixels(aEvent->x, aEvent->y); + event.AssignEventTime(GetWidgetEventTime(aEvent->time)); + + event.mExitFrom = Some(is_top_level_mouse_exit(mGdkWindow, aEvent) + ? WidgetMouseEvent::ePlatformTopLevel + : WidgetMouseEvent::ePlatformChild); + + LOG(("OnLeaveNotify: %p\n", (void*)this)); + + DispatchInputEvent(&event); +} + +template <typename Event> +static LayoutDeviceIntPoint GetRefPoint(nsWindow* aWindow, Event* aEvent) { + if (aEvent->window == aWindow->GetGdkWindow()) { + // we are the window that the event happened on so no need for expensive + // WidgetToScreenOffset + return aWindow->GdkEventCoordsToDevicePixels(aEvent->x, aEvent->y); + } + // XXX we're never quite sure which GdkWindow the event came from due to our + // custom bubbling in scroll_event_cb(), so use ScreenToWidget to translate + // the screen root coordinates into coordinates relative to this widget. + return aWindow->GdkEventCoordsToDevicePixels(aEvent->x_root, aEvent->y_root) - + aWindow->WidgetToScreenOffset(); +} + +void nsWindow::OnMotionNotifyEvent(GdkEventMotion* aEvent) { + if (mWindowShouldStartDragging) { + mWindowShouldStartDragging = false; + // find the top-level window + GdkWindow* gdk_window = gdk_window_get_toplevel(mGdkWindow); + MOZ_ASSERT(gdk_window, "gdk_window_get_toplevel should not return null"); + + bool canDrag = true; + if (mIsX11Display) { + // Workaround for https://bugzilla.gnome.org/show_bug.cgi?id=789054 + // To avoid crashes disable double-click on WM without _NET_WM_MOVERESIZE. + // See _should_perform_ewmh_drag() at gdkwindow-x11.c + GdkScreen* screen = gdk_window_get_screen(gdk_window); + GdkAtom atom = gdk_atom_intern("_NET_WM_MOVERESIZE", FALSE); + if (!gdk_x11_screen_supports_net_wm_hint(screen, atom)) { + canDrag = false; + } + } + + if (canDrag) { + gdk_window_begin_move_drag(gdk_window, 1, aEvent->x_root, aEvent->y_root, + aEvent->time); + return; + } + } + + // see if we can compress this event + // XXXldb Why skip every other motion event when we have multiple, + // but not more than that? + bool synthEvent = false; +#ifdef MOZ_X11 + XEvent xevent; + + if (mIsX11Display) { + while (XPending(GDK_WINDOW_XDISPLAY(aEvent->window))) { + XEvent peeked; + XPeekEvent(GDK_WINDOW_XDISPLAY(aEvent->window), &peeked); + if (peeked.xany.window != gdk_x11_window_get_xid(aEvent->window) || + peeked.type != MotionNotify) + break; + + synthEvent = true; + XNextEvent(GDK_WINDOW_XDISPLAY(aEvent->window), &xevent); + } + } +#endif /* MOZ_X11 */ + + WidgetMouseEvent event(true, eMouseMove, this, WidgetMouseEvent::eReal); + + gdouble pressure = 0; + gdk_event_get_axis((GdkEvent*)aEvent, GDK_AXIS_PRESSURE, &pressure); + // Sometime gdk generate 0 pressure value between normal values + // We have to ignore that and use last valid value + if (pressure) mLastMotionPressure = pressure; + event.mPressure = mLastMotionPressure; + + guint modifierState; + if (synthEvent) { +#ifdef MOZ_X11 + event.mRefPoint.x = nscoord(xevent.xmotion.x); + event.mRefPoint.y = nscoord(xevent.xmotion.y); + + modifierState = xevent.xmotion.state; + + event.AssignEventTime(GetWidgetEventTime(xevent.xmotion.time)); +#else + event.mRefPoint = GdkEventCoordsToDevicePixels(aEvent->x, aEvent->y); + + modifierState = aEvent->state; + + event.AssignEventTime(GetWidgetEventTime(aEvent->time)); +#endif /* MOZ_X11 */ + } else { + event.mRefPoint = GetRefPoint(this, aEvent); + + modifierState = aEvent->state; + + event.AssignEventTime(GetWidgetEventTime(aEvent->time)); + } + + KeymapWrapper::InitInputEvent(event, modifierState); + + DispatchInputEvent(&event); +} + +// If the automatic pointer grab on ButtonPress has deactivated before +// ButtonRelease, and the mouse button is released while the pointer is not +// over any a Gecko window, then the ButtonRelease event will not be received. +// (A similar situation exists when the pointer is grabbed with owner_events +// True as the ButtonRelease may be received on a foreign [plugin] window). +// Use this method to check for released buttons when the pointer returns to a +// Gecko window. +void nsWindow::DispatchMissedButtonReleases(GdkEventCrossing* aGdkEvent) { + guint changed = aGdkEvent->state ^ gButtonState; + // Only consider button releases. + // (Ignore button presses that occurred outside Gecko.) + guint released = changed & gButtonState; + gButtonState = aGdkEvent->state; + + // Loop over each button, excluding mouse wheel buttons 4 and 5 for which + // GDK ignores releases. + for (guint buttonMask = GDK_BUTTON1_MASK; buttonMask <= GDK_BUTTON3_MASK; + buttonMask <<= 1) { + if (released & buttonMask) { + int16_t buttonType; + switch (buttonMask) { + case GDK_BUTTON1_MASK: + buttonType = MouseButton::ePrimary; + break; + case GDK_BUTTON2_MASK: + buttonType = MouseButton::eMiddle; + break; + default: + NS_ASSERTION(buttonMask == GDK_BUTTON3_MASK, + "Unexpected button mask"); + buttonType = MouseButton::eSecondary; + } + + LOG(("Synthesized button %u release on %p\n", guint(buttonType + 1), + (void*)this)); + + // Dispatch a synthesized button up event to tell Gecko about the + // change in state. This event is marked as synthesized so that + // it is not dispatched as a DOM event, because we don't know the + // position, widget, modifiers, or time/order. + WidgetMouseEvent synthEvent(true, eMouseUp, this, + WidgetMouseEvent::eSynthesized); + synthEvent.mButton = buttonType; + DispatchInputEvent(&synthEvent); + } + } +} + +void nsWindow::InitButtonEvent(WidgetMouseEvent& aEvent, + GdkEventButton* aGdkEvent) { + aEvent.mRefPoint = GetRefPoint(this, aGdkEvent); + + guint modifierState = aGdkEvent->state; + // aEvent's state includes the button state from immediately before this + // event. If aEvent is a mousedown or mouseup event, we need to update + // the button state. + guint buttonMask = 0; + switch (aGdkEvent->button) { + case 1: + buttonMask = GDK_BUTTON1_MASK; + break; + case 2: + buttonMask = GDK_BUTTON2_MASK; + break; + case 3: + buttonMask = GDK_BUTTON3_MASK; + break; + } + if (aGdkEvent->type == GDK_BUTTON_RELEASE) { + modifierState &= ~buttonMask; + } else { + modifierState |= buttonMask; + } + + KeymapWrapper::InitInputEvent(aEvent, modifierState); + + aEvent.AssignEventTime(GetWidgetEventTime(aGdkEvent->time)); + + switch (aGdkEvent->type) { + case GDK_2BUTTON_PRESS: + aEvent.mClickCount = 2; + break; + case GDK_3BUTTON_PRESS: + aEvent.mClickCount = 3; + break; + // default is one click + default: + aEvent.mClickCount = 1; + } +} + +static guint ButtonMaskFromGDKButton(guint button) { + return GDK_BUTTON1_MASK << (button - 1); +} + +void nsWindow::DispatchContextMenuEventFromMouseEvent(uint16_t domButton, + GdkEventButton* aEvent) { + if (domButton == MouseButton::eSecondary && MOZ_LIKELY(!mIsDestroyed)) { + WidgetMouseEvent contextMenuEvent(true, eContextMenu, this, + WidgetMouseEvent::eReal); + InitButtonEvent(contextMenuEvent, aEvent); + contextMenuEvent.mPressure = mLastMotionPressure; + DispatchInputEvent(&contextMenuEvent); + } +} + +void nsWindow::OnButtonPressEvent(GdkEventButton* aEvent) { + LOG(("Button %u press on %p\n", aEvent->button, (void*)this)); + + // If you double click in GDK, it will actually generate a second + // GDK_BUTTON_PRESS before sending the GDK_2BUTTON_PRESS, and this is + // different than the DOM spec. GDK puts this in the queue + // programatically, so it's safe to assume that if there's a + // double click in the queue, it was generated so we can just drop + // this click. + GdkEvent* peekedEvent = gdk_event_peek(); + if (peekedEvent) { + GdkEventType type = peekedEvent->any.type; + gdk_event_free(peekedEvent); + if (type == GDK_2BUTTON_PRESS || type == GDK_3BUTTON_PRESS) return; + } + + nsWindow* containerWindow = GetContainerWindow(); + if (!gFocusWindow && containerWindow) { + containerWindow->DispatchActivateEvent(); + } + + // check to see if we should rollup + if (CheckForRollup(aEvent->x_root, aEvent->y_root, false, false)) return; + + gdouble pressure = 0; + gdk_event_get_axis((GdkEvent*)aEvent, GDK_AXIS_PRESSURE, &pressure); + mLastMotionPressure = pressure; + + uint16_t domButton; + switch (aEvent->button) { + case 1: + domButton = MouseButton::ePrimary; + break; + case 2: + domButton = MouseButton::eMiddle; + break; + case 3: + domButton = MouseButton::eSecondary; + break; + // These are mapped to horizontal scroll + case 6: + case 7: + NS_WARNING("We're not supporting legacy horizontal scroll event"); + return; + // Map buttons 8-9 to back/forward + case 8: + if (!Preferences::GetBool("mousebutton.4th.enabled", true)) { + return; + } + DispatchCommandEvent(nsGkAtoms::Back); + return; + case 9: + if (!Preferences::GetBool("mousebutton.5th.enabled", true)) { + return; + } + DispatchCommandEvent(nsGkAtoms::Forward); + return; + default: + return; + } + + gButtonState |= ButtonMaskFromGDKButton(aEvent->button); + + WidgetMouseEvent event(true, eMouseDown, this, WidgetMouseEvent::eReal); + event.mButton = domButton; + InitButtonEvent(event, aEvent); + event.mPressure = mLastMotionPressure; + + nsEventStatus eventStatus = DispatchInputEvent(&event); + + LayoutDeviceIntPoint refPoint = + GdkEventCoordsToDevicePixels(aEvent->x, aEvent->y); + if (mDraggableRegion.Contains(refPoint.x, refPoint.y) && + domButton == MouseButton::ePrimary && + eventStatus != nsEventStatus_eConsumeNoDefault) { + mWindowShouldStartDragging = true; + } + + // right menu click on linux should also pop up a context menu + if (!StaticPrefs::ui_context_menus_after_mouseup()) { + DispatchContextMenuEventFromMouseEvent(domButton, aEvent); + } +} + +void nsWindow::OnButtonReleaseEvent(GdkEventButton* aEvent) { + LOG(("Button %u release on %p\n", aEvent->button, (void*)this)); + + if (mWindowShouldStartDragging) { + mWindowShouldStartDragging = false; + } + + uint16_t domButton; + switch (aEvent->button) { + case 1: + domButton = MouseButton::ePrimary; + break; + case 2: + domButton = MouseButton::eMiddle; + break; + case 3: + domButton = MouseButton::eSecondary; + break; + default: + return; + } + + gButtonState &= ~ButtonMaskFromGDKButton(aEvent->button); + + WidgetMouseEvent event(true, eMouseUp, this, WidgetMouseEvent::eReal); + event.mButton = domButton; + InitButtonEvent(event, aEvent); + gdouble pressure = 0; + gdk_event_get_axis((GdkEvent*)aEvent, GDK_AXIS_PRESSURE, &pressure); + event.mPressure = pressure ? pressure : mLastMotionPressure; + + // The mRefPoint is manipulated in DispatchInputEvent, we're saving it + // to use it for the doubleclick position check. + LayoutDeviceIntPoint pos = event.mRefPoint; + + nsEventStatus eventStatus = DispatchInputEvent(&event); + + bool defaultPrevented = (eventStatus == nsEventStatus_eConsumeNoDefault); + // Check if mouse position in titlebar and doubleclick happened to + // trigger restore/maximize. + if (!defaultPrevented && mDrawInTitlebar && + event.mButton == MouseButton::ePrimary && event.mClickCount == 2 && + mDraggableRegion.Contains(pos.x, pos.y)) { + if (mSizeState == nsSizeMode_Maximized) { + SetSizeMode(nsSizeMode_Normal); + } else { + SetSizeMode(nsSizeMode_Maximized); + } + } + mLastMotionPressure = pressure; + + // right menu click on linux should also pop up a context menu + if (StaticPrefs::ui_context_menus_after_mouseup()) { + DispatchContextMenuEventFromMouseEvent(domButton, aEvent); + } + + // Open window manager menu on PIP window to allow user + // to place it on top / all workspaces. + if (mIsPIPWindow && aEvent->button == 3) { + static auto sGdkWindowShowWindowMenu = + (gboolean(*)(GdkWindow * window, GdkEvent*)) + dlsym(RTLD_DEFAULT, "gdk_window_show_window_menu"); + if (sGdkWindowShowWindowMenu) { + sGdkWindowShowWindowMenu(mGdkWindow, (GdkEvent*)aEvent); + } + } +} + +void nsWindow::OnContainerFocusInEvent(GdkEventFocus* aEvent) { + LOGFOCUS(("OnContainerFocusInEvent [%p]\n", (void*)this)); + + // Unset the urgency hint, if possible + GtkWidget* top_window = GetToplevelWidget(); + if (top_window && (gtk_widget_get_visible(top_window))) + SetUrgencyHint(top_window, false); + + // Return if being called within SetFocus because the focus manager + // already knows that the window is active. + if (gBlockActivateEvent) { + LOGFOCUS(("activated notification is blocked [%p]\n", (void*)this)); + return; + } + + // If keyboard input will be accepted, the focus manager will call + // SetFocus to set the correct window. + gFocusWindow = nullptr; + + DispatchActivateEvent(); + + if (!gFocusWindow) { + // We don't really have a window for dispatching key events, but + // setting a non-nullptr value here prevents OnButtonPressEvent() from + // dispatching an activation notification if the widget is already + // active. + gFocusWindow = this; + } + + LOGFOCUS(("Events sent from focus in event [%p]\n", (void*)this)); +} + +void nsWindow::OnContainerFocusOutEvent(GdkEventFocus* aEvent) { + LOGFOCUS(("OnContainerFocusOutEvent [%p]\n", (void*)this)); + + if (mWindowType == eWindowType_toplevel || + mWindowType == eWindowType_dialog) { + nsCOMPtr<nsIDragService> dragService = do_GetService(kCDragServiceCID); + nsCOMPtr<nsIDragSession> dragSession; + dragService->GetCurrentSession(getter_AddRefs(dragSession)); + + // Rollup popups when a window is focused out unless a drag is occurring. + // This check is because drags grab the keyboard and cause a focus out on + // versions of GTK before 2.18. + bool shouldRollup = !dragSession; + if (!shouldRollup) { + // we also roll up when a drag is from a different application + nsCOMPtr<nsINode> sourceNode; + dragSession->GetSourceNode(getter_AddRefs(sourceNode)); + shouldRollup = (sourceNode == nullptr); + } + + if (shouldRollup) { + CheckForRollup(0, 0, false, true); + } + } + + if (gFocusWindow) { + RefPtr<nsWindow> kungFuDeathGrip = gFocusWindow; + if (gFocusWindow->mIMContext) { + gFocusWindow->mIMContext->OnBlurWindow(gFocusWindow); + } + gFocusWindow = nullptr; + } + + DispatchDeactivateEvent(); + + if (IsChromeWindowTitlebar()) { + // DispatchDeactivateEvent() ultimately results in a call to + // BrowsingContext::SetIsActiveBrowserWindow(), which resets + // the state. We call UpdateMozWindowActive() to keep it in + // sync with GDK_WINDOW_STATE_FOCUSED. + UpdateMozWindowActive(); + } + + LOGFOCUS(("Done with container focus out [%p]\n", (void*)this)); +} + +bool nsWindow::DispatchCommandEvent(nsAtom* aCommand) { + nsEventStatus status; + WidgetCommandEvent appCommandEvent(true, aCommand, this); + DispatchEvent(&appCommandEvent, status); + return TRUE; +} + +bool nsWindow::DispatchContentCommandEvent(EventMessage aMsg) { + nsEventStatus status; + WidgetContentCommandEvent event(true, aMsg, this); + DispatchEvent(&event, status); + return TRUE; +} + +WidgetEventTime nsWindow::GetWidgetEventTime(guint32 aEventTime) { + return WidgetEventTime(aEventTime, GetEventTimeStamp(aEventTime)); +} + +TimeStamp nsWindow::GetEventTimeStamp(guint32 aEventTime) { + if (MOZ_UNLIKELY(!mGdkWindow)) { + // nsWindow has been Destroy()ed. + return TimeStamp::Now(); + } + if (aEventTime == 0) { + // Some X11 and GDK events may be received with a time of 0 to indicate + // that they are synthetic events. Some input method editors do this. + // In this case too, just return the current timestamp. + return TimeStamp::Now(); + } + + TimeStamp eventTimeStamp; + + if (!mIsX11Display) { + // Wayland compositors use monotonic time to set timestamps. + int64_t timestampTime = g_get_monotonic_time() / 1000; + guint32 refTimeTruncated = guint32(timestampTime); + + timestampTime -= refTimeTruncated - aEventTime; + int64_t tick = + BaseTimeDurationPlatformUtils::TicksFromMilliseconds(timestampTime); + eventTimeStamp = TimeStamp::FromSystemTime(tick); + } else { + CurrentX11TimeGetter* getCurrentTime = GetCurrentTimeGetter(); + MOZ_ASSERT(getCurrentTime, + "Null current time getter despite having a window"); + eventTimeStamp = + TimeConverter().GetTimeStampFromSystemTime(aEventTime, *getCurrentTime); + } + return eventTimeStamp; +} + +mozilla::CurrentX11TimeGetter* nsWindow::GetCurrentTimeGetter() { + MOZ_ASSERT(mGdkWindow, "Expected mGdkWindow to be set"); + if (MOZ_UNLIKELY(!mCurrentTimeGetter)) { + mCurrentTimeGetter = MakeUnique<CurrentX11TimeGetter>(mGdkWindow); + } + return mCurrentTimeGetter.get(); +} + +gboolean nsWindow::OnKeyPressEvent(GdkEventKey* aEvent) { + LOGFOCUS(("OnKeyPressEvent [%p]\n", (void*)this)); + + RefPtr<nsWindow> self(this); + KeymapWrapper::HandleKeyPressEvent(self, aEvent); + return TRUE; +} + +gboolean nsWindow::OnKeyReleaseEvent(GdkEventKey* aEvent) { + LOGFOCUS(("OnKeyReleaseEvent [%p]\n", (void*)this)); + + RefPtr<nsWindow> self(this); + if (NS_WARN_IF(!KeymapWrapper::HandleKeyReleaseEvent(self, aEvent))) { + return FALSE; + } + return TRUE; +} + +void nsWindow::OnScrollEvent(GdkEventScroll* aEvent) { + // check to see if we should rollup + if (CheckForRollup(aEvent->x_root, aEvent->y_root, true, false)) return; + // check for duplicate legacy scroll event, see GNOME bug 726878 + if (aEvent->direction != GDK_SCROLL_SMOOTH && + mLastScrollEventTime == aEvent->time) { + LOG(("[%d] duplicate legacy scroll event %d\n", aEvent->time, + aEvent->direction)); + return; + } + WidgetWheelEvent wheelEvent(true, eWheel, this); + wheelEvent.mDeltaMode = dom::WheelEvent_Binding::DOM_DELTA_LINE; + switch (aEvent->direction) { + case GDK_SCROLL_SMOOTH: { + // As of GTK 3.4, all directional scroll events are provided by + // the GDK_SCROLL_SMOOTH direction on XInput2 and Wayland devices. + mLastScrollEventTime = aEvent->time; + + // Special handling for touchpads to support flings + // (also known as kinetic/inertial/momentum scrolling) + GdkDevice* device = gdk_event_get_source_device((GdkEvent*)aEvent); + GdkInputSource source = gdk_device_get_source(device); + if (source == GDK_SOURCE_TOUCHSCREEN || source == GDK_SOURCE_TOUCHPAD) { + if (StaticPrefs::apz_gtk_kinetic_scroll_enabled() && + gtk_check_version(3, 20, 0) == nullptr) { + static auto sGdkEventIsScrollStopEvent = + (gboolean(*)(const GdkEvent*))dlsym( + RTLD_DEFAULT, "gdk_event_is_scroll_stop_event"); + + LOG(("[%d] pan smooth event dx=%f dy=%f inprogress=%d\n", + aEvent->time, aEvent->delta_x, aEvent->delta_y, mPanInProgress)); + PanGestureInput::PanGestureType eventType = + PanGestureInput::PANGESTURE_PAN; + if (sGdkEventIsScrollStopEvent((GdkEvent*)aEvent)) { + eventType = PanGestureInput::PANGESTURE_END; + mPanInProgress = false; + } else if (!mPanInProgress) { + eventType = PanGestureInput::PANGESTURE_START; + mPanInProgress = true; + } + + LayoutDeviceIntPoint touchPoint = GetRefPoint(this, aEvent); + PanGestureInput panEvent( + eventType, aEvent->time, GetEventTimeStamp(aEvent->time), + ScreenPoint(touchPoint.x, touchPoint.y), + ScreenPoint(aEvent->delta_x, aEvent->delta_y), + KeymapWrapper::ComputeKeyModifiers(aEvent->state)); + panEvent.mDeltaType = PanGestureInput::PANDELTA_PAGE; + panEvent.mSimulateMomentum = true; + + DispatchPanGestureInput(panEvent); + + return; + } + + // Older GTK doesn't support stop events, so we can't support fling + wheelEvent.mScrollType = WidgetWheelEvent::SCROLL_ASYNCHRONOUSELY; + } + + // TODO - use a more appropriate scrolling unit than lines. + // Multiply event deltas by 3 to emulate legacy behaviour. + wheelEvent.mDeltaX = aEvent->delta_x * 3; + wheelEvent.mDeltaY = aEvent->delta_y * 3; + wheelEvent.mIsNoLineOrPageDelta = true; + + break; + } + case GDK_SCROLL_UP: + wheelEvent.mDeltaY = wheelEvent.mLineOrPageDeltaY = -3; + break; + case GDK_SCROLL_DOWN: + wheelEvent.mDeltaY = wheelEvent.mLineOrPageDeltaY = 3; + break; + case GDK_SCROLL_LEFT: + wheelEvent.mDeltaX = wheelEvent.mLineOrPageDeltaX = -1; + break; + case GDK_SCROLL_RIGHT: + wheelEvent.mDeltaX = wheelEvent.mLineOrPageDeltaX = 1; + break; + } + + wheelEvent.mRefPoint = GetRefPoint(this, aEvent); + + KeymapWrapper::InitInputEvent(wheelEvent, aEvent->state); + + wheelEvent.AssignEventTime(GetWidgetEventTime(aEvent->time)); + + DispatchInputEvent(&wheelEvent); +} + +void nsWindow::OnWindowStateEvent(GtkWidget* aWidget, + GdkEventWindowState* aEvent) { + LOG( + ("nsWindow::OnWindowStateEvent [%p] for %p changed 0x%x new_window_state " + "0x%x\n", + (void*)this, aWidget, aEvent->changed_mask, aEvent->new_window_state)); + + if (IS_MOZ_CONTAINER(aWidget)) { + // This event is notifying the container widget of changes to the + // toplevel window. Just detect changes affecting whether windows are + // viewable. + // + // (A visibility notify event is sent to each window that becomes + // viewable when the toplevel is mapped, but we can't rely on that for + // setting mHasMappedToplevel because these toplevel window state + // events are asynchronous. The windows in the hierarchy now may not + // be the same windows as when the toplevel was mapped, so they may + // not get VisibilityNotify events.) + bool mapped = !(aEvent->new_window_state & + (GDK_WINDOW_STATE_ICONIFIED | GDK_WINDOW_STATE_WITHDRAWN)); + if (mHasMappedToplevel != mapped) { + SetHasMappedToplevel(mapped); + } + LOG(("\tquick return because IS_MOZ_CONTAINER(aWidget) is true\n")); + return; + } + // else the widget is a shell widget. + + // The block below is a bit evil. + // + // When a window is resized before it is shown, gtk_window_resize() delays + // resizes until the window is shown. If gtk_window_state_event() sees a + // GDK_WINDOW_STATE_MAXIMIZED change [1] before the window is shown, then + // gtk_window_compute_configure_request_size() ignores the values from the + // resize [2]. See bug 1449166 for an example of how this could happen. + // + // [1] https://gitlab.gnome.org/GNOME/gtk/blob/3.22.30/gtk/gtkwindow.c#L7967 + // [2] https://gitlab.gnome.org/GNOME/gtk/blob/3.22.30/gtk/gtkwindow.c#L9377 + // + // In order to provide a sensible size for the window when the user exits + // maximized state, we hide the GDK_WINDOW_STATE_MAXIMIZED change from + // gtk_window_state_event() so as to trick GTK into using the values from + // gtk_window_resize() in its configure request. + // + // We instead notify gtk_window_state_event() of the maximized state change + // once the window is shown. + // + // See https://gitlab.gnome.org/GNOME/gtk/issues/1044 + // + // This may be fixed in Gtk 3.24+ but some DE still have this issue + // (Bug 1624199) so let's remove it for Wayland only. + if (mIsX11Display) { + if (!mIsShown) { + aEvent->changed_mask = static_cast<GdkWindowState>( + aEvent->changed_mask & ~GDK_WINDOW_STATE_MAXIMIZED); + } else if (aEvent->changed_mask & GDK_WINDOW_STATE_WITHDRAWN && + aEvent->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) { + aEvent->changed_mask = static_cast<GdkWindowState>( + aEvent->changed_mask | GDK_WINDOW_STATE_MAXIMIZED); + } + } + + // This is a workaround for https://gitlab.gnome.org/GNOME/gtk/issues/1395 + // Gtk+ controls window active appearance by window-state-event signal. + if (IsChromeWindowTitlebar() && + (aEvent->changed_mask & GDK_WINDOW_STATE_FOCUSED)) { + // Emulate what Gtk+ does at gtk_window_state_event(). + // We can't check GTK_STATE_FLAG_BACKDROP directly as it's set by Gtk+ + // *after* this window-state-event handler. + mTitlebarBackdropState = + !(aEvent->new_window_state & GDK_WINDOW_STATE_FOCUSED); + + // keep IsActiveBrowserWindow in sync with GDK_WINDOW_STATE_FOCUSED + UpdateMozWindowActive(); + + ForceTitlebarRedraw(); + } + + // We don't care about anything but changes in the maximized/icon/fullscreen + // states but we need a workaround for bug in Wayland: + // https://gitlab.gnome.org/GNOME/gtk/issues/67 + // Under wayland the gtk_window_iconify implementation does NOT synthetize + // window_state_event where the GDK_WINDOW_STATE_ICONIFIED is set. + // During restore we won't get aEvent->changed_mask with + // the GDK_WINDOW_STATE_ICONIFIED so to detect that change we use the stored + // mSizeState and obtaining a focus. + bool waylandWasIconified = + (!mIsX11Display && aEvent->changed_mask & GDK_WINDOW_STATE_FOCUSED && + aEvent->new_window_state & GDK_WINDOW_STATE_FOCUSED && + mSizeState == nsSizeMode_Minimized); + if (!waylandWasIconified && + (aEvent->changed_mask & + (GDK_WINDOW_STATE_ICONIFIED | GDK_WINDOW_STATE_MAXIMIZED | + GDK_WINDOW_STATE_TILED | GDK_WINDOW_STATE_FULLSCREEN)) == 0) { + LOG(("\tearly return because no interesting bits changed\n")); + return; + } + + if (aEvent->new_window_state & GDK_WINDOW_STATE_ICONIFIED) { + LOG(("\tIconified\n")); + mSizeState = nsSizeMode_Minimized; +#ifdef ACCESSIBILITY + DispatchMinimizeEventAccessible(); +#endif // ACCESSIBILITY + } else if (aEvent->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) { + LOG(("\tFullscreen\n")); + mSizeState = nsSizeMode_Fullscreen; + } else if (aEvent->new_window_state & GDK_WINDOW_STATE_MAXIMIZED) { + LOG(("\tMaximized\n")); + mSizeState = nsSizeMode_Maximized; +#ifdef ACCESSIBILITY + DispatchMaximizeEventAccessible(); +#endif // ACCESSIBILITY + } else { + LOG(("\tNormal\n")); + mSizeState = nsSizeMode_Normal; +#ifdef ACCESSIBILITY + DispatchRestoreEventAccessible(); +#endif // ACCESSIBILITY + } + + if (aEvent->new_window_state & GDK_WINDOW_STATE_TILED) { + LOG(("\tTiled\n")); + mIsTiled = true; + } else { + LOG(("\tNot tiled\n")); + mIsTiled = false; + } + + if (mWidgetListener) { + mWidgetListener->SizeModeChanged(mSizeState); + if (aEvent->changed_mask & GDK_WINDOW_STATE_FULLSCREEN) { + mWidgetListener->FullscreenChanged(aEvent->new_window_state & + GDK_WINDOW_STATE_FULLSCREEN); + } + } + + if (mDrawInTitlebar && mTransparencyBitmapForTitlebar) { + if (mSizeState == nsSizeMode_Normal && !mIsTiled) { + UpdateTitlebarTransparencyBitmap(); + } else { + ClearTransparencyBitmap(); + } + } +} + +void nsWindow::ThemeChanged() { + // Everything could've changed. + NotifyThemeChanged(ThemeChangeKind::StyleAndLayout); + + if (!mGdkWindow || MOZ_UNLIKELY(mIsDestroyed)) return; + + // Dispatch theme change notification to all child windows + GList* children = gdk_window_peek_children(mGdkWindow); + while (children) { + GdkWindow* gdkWin = GDK_WINDOW(children->data); + + auto* win = (nsWindow*)g_object_get_data(G_OBJECT(gdkWin), "nsWindow"); + + if (win && win != this) { // guard against infinite recursion + RefPtr<nsWindow> kungFuDeathGrip = win; + win->ThemeChanged(); + } + + children = children->next; + } + + IMContextWrapper::OnThemeChanged(); +} + +void nsWindow::OnDPIChanged() { + if (mWidgetListener) { + if (PresShell* presShell = mWidgetListener->GetPresShell()) { + presShell->BackingScaleFactorChanged(); + // Update menu's font size etc. + // This affects style / layout because it affects system font sizes. + presShell->ThemeChanged(ThemeChangeKind::StyleAndLayout); + } + mWidgetListener->UIResolutionChanged(); + } +} + +void nsWindow::OnCheckResize() { mPendingConfigures++; } + +void nsWindow::OnCompositedChanged() { + // Update CSD after the change in alpha visibility. This only affects + // system metrics, not other theme shenanigans. + NotifyThemeChanged(ThemeChangeKind::MediaQueriesOnly); + mCompositedScreen = gdk_screen_is_composited(gdk_screen_get_default()); +} + +void nsWindow::OnScaleChanged(GtkAllocation* aAllocation) { + LOG(("nsWindow::OnScaleChanged [%p] %d,%d -> %d x %d\n", (void*)this, + aAllocation->x, aAllocation->y, aAllocation->width, + aAllocation->height)); + + // Force scale factor recalculation + mWindowScaleFactorChanged = true; + + // This eventually propagate new scale to the PuppetWidgets + OnDPIChanged(); + + // configure_event is already fired before scale-factor signal, + // but size-allocate isn't fired by changing scale + OnSizeAllocate(aAllocation); + + // Client offset are updated by _NET_FRAME_EXTENTS on X11 when system titlebar + // is enabled. In ither cases (Wayland or system titlebar is off on X11) + // we don't get _NET_FRAME_EXTENTS X11 property notification so we derive + // it from mContainer position. + if (mCSDSupportLevel == CSD_SUPPORT_CLIENT) { + if (!mIsX11Display || (mIsX11Display && mDrawInTitlebar)) { + UpdateClientOffsetFromCSDWindow(); + } + } + +#ifdef MOZ_WAYLAND + // We need to update scale when scale of egl window is changed. + if (mContainer && moz_container_wayland_has_egl_window(mContainer)) { + moz_container_wayland_set_scale_factor(mContainer); + } +#endif +} + +void nsWindow::DispatchDragEvent(EventMessage aMsg, + const LayoutDeviceIntPoint& aRefPoint, + guint aTime) { + WidgetDragEvent event(true, aMsg, this); + + InitDragEvent(event); + + event.mRefPoint = aRefPoint; + event.AssignEventTime(GetWidgetEventTime(aTime)); + + DispatchInputEvent(&event); +} + +void nsWindow::OnDragDataReceivedEvent(GtkWidget* aWidget, + GdkDragContext* aDragContext, gint aX, + gint aY, + GtkSelectionData* aSelectionData, + guint aInfo, guint aTime, + gpointer aData) { + LOGDRAG(("nsWindow::OnDragDataReceived(%p)\n", (void*)this)); + + RefPtr<nsDragService> dragService = nsDragService::GetInstance(); + dragService->TargetDataReceived(aWidget, aDragContext, aX, aY, aSelectionData, + aInfo, aTime); +} + +nsWindow* nsWindow::GetTransientForWindowIfPopup() { + if (mWindowType != eWindowType_popup) { + return nullptr; + } + GtkWindow* toplevel = gtk_window_get_transient_for(GTK_WINDOW(mShell)); + if (toplevel) { + return get_window_for_gtk_widget(GTK_WIDGET(toplevel)); + } + return nullptr; +} + +bool nsWindow::IsHandlingTouchSequence(GdkEventSequence* aSequence) { + return mHandleTouchEvent && mTouches.Contains(aSequence); +} + +gboolean nsWindow::OnTouchpadPinchEvent(GdkEventTouchpadPinch* aEvent) { + if (StaticPrefs::apz_gtk_touchpad_pinch_enabled()) { + PinchGestureInput::PinchGestureType pinchGestureType = + PinchGestureInput::PINCHGESTURE_SCALE; + ScreenCoord CurrentSpan; + ScreenCoord PreviousSpan; + + switch (aEvent->phase) { + case GDK_TOUCHPAD_GESTURE_PHASE_BEGIN: + pinchGestureType = PinchGestureInput::PINCHGESTURE_START; + CurrentSpan = aEvent->scale; + + // Assign PreviousSpan --> 0.999 to make mDeltaY field of the + // WidgetWheelEvent that this PinchGestureInput event will be converted + // to not equal Zero as our discussion because we observed that the + // scale of the PHASE_BEGIN event is 1. + PreviousSpan = 0.999; + mLastPinchEventSpan = aEvent->scale; + break; + + case GDK_TOUCHPAD_GESTURE_PHASE_UPDATE: + pinchGestureType = PinchGestureInput::PINCHGESTURE_SCALE; + if (aEvent->scale == mLastPinchEventSpan) { + return FALSE; + } + CurrentSpan = aEvent->scale; + PreviousSpan = mLastPinchEventSpan; + mLastPinchEventSpan = aEvent->scale; + break; + + case GDK_TOUCHPAD_GESTURE_PHASE_END: + pinchGestureType = PinchGestureInput::PINCHGESTURE_END; + CurrentSpan = aEvent->scale; + PreviousSpan = mLastPinchEventSpan; + break; + + default: + return FALSE; + } + + LayoutDeviceIntPoint touchpadPoint = GetRefPoint(this, aEvent); + PinchGestureInput event( + pinchGestureType, PinchGestureInput::TRACKPAD, aEvent->time, + GetEventTimeStamp(aEvent->time), ExternalPoint(0, 0), + ScreenPoint(touchpadPoint.x, touchpadPoint.y), CurrentSpan, + PreviousSpan, KeymapWrapper::ComputeKeyModifiers(aEvent->state)); + + DispatchPinchGestureInput(event); + } + return TRUE; +} + +gboolean nsWindow::OnTouchEvent(GdkEventTouch* aEvent) { + if (!mHandleTouchEvent) { + // If a popup window was spawned (e.g. as the result of a long-press) + // and touch events got diverted to that window within a touch sequence, + // ensure the touch event gets sent to the original window instead. We + // keep the checks here very conservative so that we only redirect + // events in this specific scenario. + nsWindow* targetWindow = GetTransientForWindowIfPopup(); + if (targetWindow && + targetWindow->IsHandlingTouchSequence(aEvent->sequence)) { + return targetWindow->OnTouchEvent(aEvent); + } + + return FALSE; + } + + EventMessage msg; + switch (aEvent->type) { + case GDK_TOUCH_BEGIN: + msg = eTouchStart; + break; + case GDK_TOUCH_UPDATE: + msg = eTouchMove; + break; + case GDK_TOUCH_END: + msg = eTouchEnd; + break; + case GDK_TOUCH_CANCEL: + msg = eTouchCancel; + break; + default: + return FALSE; + } + + LayoutDeviceIntPoint touchPoint = GetRefPoint(this, aEvent); + + int32_t id; + RefPtr<dom::Touch> touch; + if (mTouches.Remove(aEvent->sequence, getter_AddRefs(touch))) { + id = touch->mIdentifier; + } else { + id = ++gLastTouchID & 0x7FFFFFFF; + } + + touch = + new dom::Touch(id, touchPoint, LayoutDeviceIntPoint(1, 1), 0.0f, 0.0f); + + WidgetTouchEvent event(true, msg, this); + KeymapWrapper::InitInputEvent(event, aEvent->state); + event.mTime = aEvent->time; + + if (aEvent->type == GDK_TOUCH_BEGIN || aEvent->type == GDK_TOUCH_UPDATE) { + mTouches.Put(aEvent->sequence, std::move(touch)); + // add all touch points to event object + for (auto iter = mTouches.Iter(); !iter.Done(); iter.Next()) { + event.mTouches.AppendElement(new dom::Touch(*iter.UserData())); + } + } else if (aEvent->type == GDK_TOUCH_END || + aEvent->type == GDK_TOUCH_CANCEL) { + *event.mTouches.AppendElement() = std::move(touch); + } + + DispatchInputEvent(&event); + return TRUE; +} + +// Return true if toplevel window is transparent. +// It's transparent when we're running on composited screens +// and we can draw main window without system titlebar. +bool nsWindow::IsToplevelWindowTransparent() { + static bool transparencyConfigured = false; + + if (!transparencyConfigured) { + if (gdk_screen_is_composited(gdk_screen_get_default())) { + // Some Gtk+ themes use non-rectangular toplevel windows. To fully + // support such themes we need to make toplevel window transparent + // with ARGB visual. + // It may cause performanance issue so make it configurable + // and enable it by default for selected window managers. + if (Preferences::HasUserValue("mozilla.widget.use-argb-visuals")) { + // argb visual is explicitly required so use it + sTransparentMainWindow = + Preferences::GetBool("mozilla.widget.use-argb-visuals"); + } else { + // Enable transparent toplevel window if we can draw main window + // without system titlebar as Gtk+ themes use titlebar round corners. + sTransparentMainWindow = GetSystemCSDSupportLevel() != CSD_SUPPORT_NONE; + } + } + transparencyConfigured = true; + } + + return sTransparentMainWindow; +} + +static GdkWindow* CreateGdkWindow(GdkWindow* parent, GtkWidget* widget) { + GdkWindowAttr attributes; + gint attributes_mask = GDK_WA_VISUAL; + + attributes.event_mask = kEvents; + + attributes.width = 1; + attributes.height = 1; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gtk_widget_get_visual(widget); + attributes.window_type = GDK_WINDOW_CHILD; + + GdkWindow* window = gdk_window_new(parent, &attributes, attributes_mask); + gdk_window_set_user_data(window, widget); + + return window; +} + +// Configure GL visual on X11. We add alpha silently +// if we use WebRender to workaround NVIDIA specific Bug 1663273. +bool nsWindow::ConfigureX11GLVisual(bool aUseAlpha) { + if (!mIsX11Display) { + return false; + } + + // If using WebRender on X11, we need to select a visual with a depth + // buffer, as well as an alpha channel if transparency is requested. This + // must be done before the widget is realized. + bool useWebRender = gfx::gfxVars::UseWebRender(); + auto* screen = gtk_widget_get_screen(mShell); + int visualId = 0; + bool haveVisual; + + // See https://bugzilla.mozilla.org/show_bug.cgi?id=1663003 + // We need to use GLX to get visual even on EGL until + // EGL can provide compositable visual: + // https://gitlab.freedesktop.org/mesa/mesa/-/issues/149 + if ((true /* !gfx::gfxVars::UseEGL() */)) { + auto* display = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(mShell)); + int screenNumber = GDK_SCREEN_XNUMBER(screen); + haveVisual = GLContextGLX::FindVisual(display, screenNumber, useWebRender, + aUseAlpha || useWebRender, &visualId); + } else { + haveVisual = GLContextEGL::FindVisual(useWebRender, + aUseAlpha || useWebRender, &visualId); + } + + GdkVisual* gdkVisual = nullptr; + if (haveVisual) { + // If we're using CSD, rendering will go through mContainer, but + // it will inherit this visual as it is a child of mShell. + gdkVisual = gdk_x11_screen_lookup_visual(screen, visualId); + } + if (!gdkVisual) { + NS_WARNING("We're missing X11 Visual!"); + if (aUseAlpha || useWebRender) { + // We try to use a fallback alpha visual + GdkScreen* screen = gtk_widget_get_screen(mShell); + gdkVisual = gdk_screen_get_rgba_visual(screen); + } + } + if (gdkVisual) { + // TODO: We use alpha visual even on non-compositing screens (Bug 1479135). + gtk_widget_set_visual(mShell, gdkVisual); + mHasAlphaVisual = aUseAlpha; + } + + return true; +} + +nsresult nsWindow::Create(nsIWidget* aParent, nsNativeWidget aNativeParent, + const LayoutDeviceIntRect& aRect, + nsWidgetInitData* aInitData) { +#ifdef MOZ_LOGGING + if (this->GetFrame() && this->GetFrame()->GetContent()) { + nsCString nodeName = + NS_ConvertUTF16toUTF8(this->GetFrame()->GetContent()->NodeName()); + LOG(("nsWindow::Create: creating [%p]: nodename %s\n", this, + nodeName.get())); + } +#endif + // only set the base parent if we're going to be a dialog or a + // toplevel + nsIWidget* baseParent = + aInitData && (aInitData->mWindowType == eWindowType_dialog || + aInitData->mWindowType == eWindowType_toplevel || + aInitData->mWindowType == eWindowType_invisible) + ? nullptr + : aParent; + +#ifdef ACCESSIBILITY + // Send a DBus message to check whether a11y is enabled + a11y::PreInit(); +#endif + + // Ensure that the toolkit is created. + nsGTKToolkit::GetToolkit(); + + // initialize all the common bits of this class + BaseCreate(baseParent, aInitData); + + // Do we need to listen for resizes? + bool listenForResizes = false; + ; + if (aNativeParent || (aInitData && aInitData->mListenForResizes)) + listenForResizes = true; + + // and do our common creation + CommonCreate(aParent, listenForResizes); + + // save our bounds + mBounds = aRect; + LOG((" mBounds: x:%d y:%d w:%d h:%d\n", mBounds.x, mBounds.y, mBounds.width, + mBounds.height)); + + mPreferredPopupRectFlushed = false; + + ConstrainSize(&mBounds.width, &mBounds.height); + + GtkWidget* eventWidget = nullptr; + bool popupNeedsAlphaVisual = (mWindowType == eWindowType_popup && + (aInitData && aInitData->mSupportTranslucency)); + + // Figure out our parent window - only used for eWindowType_child + GtkWidget* parentMozContainer = nullptr; + GtkContainer* parentGtkContainer = nullptr; + GdkWindow* parentGdkWindow = nullptr; + nsWindow* parentnsWindow = nullptr; + + if (aParent) { + parentnsWindow = static_cast<nsWindow*>(aParent); + parentGdkWindow = parentnsWindow->mGdkWindow; + } else if (aNativeParent && GDK_IS_WINDOW(aNativeParent)) { + parentGdkWindow = GDK_WINDOW(aNativeParent); + parentnsWindow = get_window_for_gdk_window(parentGdkWindow); + if (!parentnsWindow) return NS_ERROR_FAILURE; + + } else if (aNativeParent && GTK_IS_CONTAINER(aNativeParent)) { + parentGtkContainer = GTK_CONTAINER(aNativeParent); + } + + if (parentGdkWindow) { + // get the widget for the window - it should be a moz container + parentMozContainer = parentnsWindow->GetMozContainerWidget(); + if (!parentMozContainer) return NS_ERROR_FAILURE; + } + // ^^ only used for eWindowType_child + + if (!mIsX11Display) { + if (mWindowType == eWindowType_child) { + // eWindowType_child is not supported on Wayland. Just switch to toplevel + // as a workaround. + mWindowType = eWindowType_toplevel; + } else if (mWindowType == eWindowType_popup && !aNativeParent && !aParent) { + // Workaround for Wayland where the popup windows always need to have + // parent window. For example webrtc ui is a popup window without parent. + mWindowType = eWindowType_toplevel; + } + } + + mAlwaysOnTop = aInitData && aInitData->mAlwaysOnTop; + mIsPIPWindow = aInitData && aInitData->mPIPWindow; + + // ok, create our windows + switch (mWindowType) { + case eWindowType_dialog: + case eWindowType_popup: + case eWindowType_toplevel: + case eWindowType_invisible: { + mIsTopLevel = true; + + // Popups that are not noautohide are only temporary. The are used + // for menus and the like and disappear when another window is used. + // For most popups, use the standard GtkWindowType GTK_WINDOW_POPUP, + // which will use a Window with the override-redirect attribute + // (for temporary windows). + // For long-lived windows, their stacking order is managed by the + // window manager, as indicated by GTK_WINDOW_TOPLEVEL. + // For Wayland we have to always use GTK_WINDOW_POPUP to control + // popup window position. + GtkWindowType type = GTK_WINDOW_TOPLEVEL; + if (mWindowType == eWindowType_popup) { + type = (mIsX11Display && aInitData->mNoAutoHide) ? GTK_WINDOW_TOPLEVEL + : GTK_WINDOW_POPUP; + } + mShell = gtk_window_new(type); + + // Ensure gfxPlatform is initialized, since that is what initializes + // gfxVars, used below. + Unused << gfxPlatform::GetPlatform(); + + if (mWindowType == eWindowType_toplevel || + mWindowType == eWindowType_dialog) { + bool isPopup = mIsPIPWindow || mWindowType == eWindowType_dialog; + mCSDSupportLevel = GetSystemCSDSupportLevel(isPopup); + } + + // Don't use transparency for PictureInPicture windows. + bool toplevelNeedsAlphaVisual = false; + if (mWindowType == eWindowType_toplevel && !mIsPIPWindow) { + toplevelNeedsAlphaVisual = IsToplevelWindowTransparent(); + } + + bool isGLVisualSet = false; + bool isAccelerated = ComputeShouldAccelerate(); +#ifdef MOZ_X11 + if (isAccelerated) { + isGLVisualSet = ConfigureX11GLVisual(popupNeedsAlphaVisual || + toplevelNeedsAlphaVisual); + } +#endif + if (!isGLVisualSet && + (popupNeedsAlphaVisual || toplevelNeedsAlphaVisual)) { + // We're running on composited screen so we can use alpha visual + // for both toplevel and popups. + if (mCompositedScreen) { + GdkVisual* visual = + gdk_screen_get_rgba_visual(gtk_widget_get_screen(mShell)); + if (visual) { + gtk_widget_set_visual(mShell, visual); + mHasAlphaVisual = true; + } + } + } + + // Use X shape mask to draw round corners of Firefox titlebar. + // We don't use shape masks any more as we switched to ARGB visual + // by default and non-compositing screens use solid-csd decorations + // without round corners. + // Leave the shape mask code here as it can be used to draw round + // corners on EGL (https://gitlab.freedesktop.org/mesa/mesa/-/issues/149) + // or when custom titlebar theme is used. + mTransparencyBitmapForTitlebar = TitlebarUseShapeMask(); + + // We have a toplevel window with transparency. + // Calls to UpdateTitlebarTransparencyBitmap() from OnExposeEvent() + // occur before SetTransparencyMode() receives eTransparencyTransparent + // from layout, so set mIsTransparent here. + if (mWindowType == eWindowType_toplevel && + (mHasAlphaVisual || mTransparencyBitmapForTitlebar)) { + mIsTransparent = true; + } + + // We only move a general managed toplevel window if someone has + // actually placed the window somewhere. If no placement has taken + // place, we just let the window manager Do The Right Thing. + NativeResize(); + + if (mWindowType == eWindowType_dialog) { + mGtkWindowRoleName = "Dialog"; + + SetDefaultIcon(); + gtk_window_set_type_hint(GTK_WINDOW(mShell), + GDK_WINDOW_TYPE_HINT_DIALOG); + + if (parentnsWindow) { + gtk_window_set_transient_for( + GTK_WINDOW(mShell), GTK_WINDOW(parentnsWindow->GetGtkWidget())); + LOG(( + "nsWindow::Create(): dialog [%p], parent window %p [GdkWindow]\n", + this, aNativeParent)); + } + + } else if (mWindowType == eWindowType_popup) { + mGtkWindowRoleName = "Popup"; + + if (aInitData->mNoAutoHide) { + // ... but the window manager does not decorate this window, + // nor provide a separate taskbar icon. + if (mBorderStyle == eBorderStyle_default) { + gtk_window_set_decorated(GTK_WINDOW(mShell), FALSE); + } else { + bool decorate = mBorderStyle & eBorderStyle_title; + gtk_window_set_decorated(GTK_WINDOW(mShell), decorate); + if (decorate) { + gtk_window_set_deletable(GTK_WINDOW(mShell), + mBorderStyle & eBorderStyle_close); + } + } + gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mShell), TRUE); + // Element focus is managed by the parent window so the + // WM_HINTS input field is set to False to tell the window + // manager not to set input focus to this window ... + gtk_window_set_accept_focus(GTK_WINDOW(mShell), FALSE); +#ifdef MOZ_X11 + // ... but when the window manager offers focus through + // WM_TAKE_FOCUS, focus is requested on the parent window. + if (mIsX11Display) { + gtk_widget_realize(mShell); + gdk_window_add_filter(gtk_widget_get_window(mShell), + popup_take_focus_filter, nullptr); + } +#endif + } + + GdkWindowTypeHint gtkTypeHint; + if (aInitData->mIsDragPopup) { + gtkTypeHint = GDK_WINDOW_TYPE_HINT_DND; + mIsDragPopup = true; + } else { + switch (aInitData->mPopupHint) { + case ePopupTypeMenu: + gtkTypeHint = GDK_WINDOW_TYPE_HINT_POPUP_MENU; + break; + case ePopupTypeTooltip: + gtkTypeHint = GDK_WINDOW_TYPE_HINT_TOOLTIP; + break; + default: + gtkTypeHint = GDK_WINDOW_TYPE_HINT_UTILITY; + break; + } + } + gtk_window_set_type_hint(GTK_WINDOW(mShell), gtkTypeHint); + if (parentnsWindow) { + LOG(("nsWindow::Create() [%p]: parent window for popup: %p\n", this, + parentnsWindow)); + gtk_window_set_transient_for( + GTK_WINDOW(mShell), GTK_WINDOW(parentnsWindow->GetGtkWidget())); + } + + // We need realized mShell at NativeMove(). + gtk_widget_realize(mShell); + + // With popup windows, we want to control their position, so don't + // wait for the window manager to place them (which wouldn't + // happen with override-redirect windows anyway). + NativeMove(); + } else { // must be eWindowType_toplevel + mGtkWindowRoleName = "Toplevel"; + SetDefaultIcon(); + + if (mIsPIPWindow) { + gtk_window_set_type_hint(GTK_WINDOW(mShell), + GDK_WINDOW_TYPE_HINT_UTILITY); + } + + // each toplevel window gets its own window group + GtkWindowGroup* group = gtk_window_group_new(); + gtk_window_group_add_window(group, GTK_WINDOW(mShell)); + g_object_unref(group); + } + + if (mAlwaysOnTop) { + gtk_window_set_keep_above(GTK_WINDOW(mShell), TRUE); + } + + // Create a container to hold child windows and child GtkWidgets. + GtkWidget* container = moz_container_new(); + mContainer = MOZ_CONTAINER(container); +#ifdef MOZ_WAYLAND + if (!mIsX11Display && isAccelerated) { + mCompositorInitiallyPaused = true; + RefPtr<nsWindow> self(this); + moz_container_wayland_add_initial_draw_callback( + mContainer, [self]() -> void { + self->mNeedsCompositorResume = true; + self->MaybeResumeCompositor(); + }); + } +#endif + + // "csd" style is set when widget is realized so we need to call + // it explicitly now. + gtk_widget_realize(mShell); + + /* There are several cases here: + * + * 1) We're running on Gtk+ without client side decorations. + * Content is rendered to mShell window and we listen + * to the Gtk+ events on mShell + * 2) We're running on Gtk+ and client side decorations + * are drawn by Gtk+ to mShell. Content is rendered to mContainer + * and we listen to the Gtk+ events on mContainer. + * 3) We're running on Wayland. All gecko content is rendered + * to mContainer and we listen to the Gtk+ events on mContainer. + */ + GtkStyleContext* style = gtk_widget_get_style_context(mShell); + mDrawToContainer = !mIsX11Display || + (mCSDSupportLevel == CSD_SUPPORT_CLIENT) || + gtk_style_context_has_class(style, "csd"); + eventWidget = (mDrawToContainer) ? container : mShell; + + // Prevent GtkWindow from painting a background to avoid flickering. + gtk_widget_set_app_paintable(eventWidget, TRUE); + + gtk_widget_add_events(eventWidget, kEvents); + if (mDrawToContainer) { + gtk_widget_add_events(mShell, GDK_PROPERTY_CHANGE_MASK); + gtk_widget_set_app_paintable(mShell, TRUE); + } + if (mTransparencyBitmapForTitlebar) { + moz_container_force_default_visual(mContainer); + } + + // If we draw to mContainer window then configure it now because + // gtk_container_add() realizes the child widget. + gtk_widget_set_has_window(container, mDrawToContainer); + + gtk_container_add(GTK_CONTAINER(mShell), container); + + // alwaysontop windows are generally used for peripheral indicators, + // so we don't focus them by default. + if (mAlwaysOnTop) { + gtk_window_set_focus_on_map(GTK_WINDOW(mShell), FALSE); + } + + gtk_widget_realize(container); + + // make sure this is the focus widget in the container + gtk_widget_show(container); + + if (!mAlwaysOnTop) { + gtk_widget_grab_focus(container); + } + + // the drawing window + mGdkWindow = gtk_widget_get_window(eventWidget); + + if (mWindowType == eWindowType_popup) { + // gdk does not automatically set the cursor for "temporary" + // windows, which are what gtk uses for popups. + + mCursor = eCursor_wait; // force SetCursor to actually set the + // cursor, even though our internal state + // indicates that we already have the + // standard cursor. + SetCursor(eCursor_standard, nullptr, 0, 0); + + if (aInitData->mNoAutoHide) { + gint wmd = ConvertBorderStyles(mBorderStyle); + if (wmd != -1) + gdk_window_set_decorations(mGdkWindow, (GdkWMDecoration)wmd); + } + + // If the popup ignores mouse events, set an empty input shape. + SetWindowMouseTransparent(aInitData->mMouseTransparent); + } + } break; + + case eWindowType_plugin: + case eWindowType_plugin_ipc_chrome: + case eWindowType_plugin_ipc_content: + MOZ_ASSERT_UNREACHABLE("Unexpected eWindowType_plugin*"); + return NS_ERROR_FAILURE; + + case eWindowType_child: { + if (parentMozContainer) { + mGdkWindow = CreateGdkWindow(parentGdkWindow, parentMozContainer); + mHasMappedToplevel = parentnsWindow->mHasMappedToplevel; + } else if (parentGtkContainer) { + // This MozContainer has its own window for drawing and receives + // events because there is no mShell widget (corresponding to this + // nsWindow). + GtkWidget* container = moz_container_new(); + mContainer = MOZ_CONTAINER(container); + eventWidget = container; + gtk_widget_add_events(eventWidget, kEvents); + gtk_container_add(parentGtkContainer, container); + gtk_widget_realize(container); + + mGdkWindow = gtk_widget_get_window(container); + } else { + NS_WARNING( + "Warning: tried to create a new child widget with no parent!"); + return NS_ERROR_FAILURE; + } + } break; + default: + break; + } + + // label the drawing window with this object so we can find our way home + g_object_set_data(G_OBJECT(mGdkWindow), "nsWindow", this); + if (mDrawToContainer) { + // Also label mShell toplevel window, + // property_notify_event_cb callback also needs to find its way home + g_object_set_data(G_OBJECT(gtk_widget_get_window(mShell)), "nsWindow", + this); + } + + if (mContainer) g_object_set_data(G_OBJECT(mContainer), "nsWindow", this); + + if (mShell) g_object_set_data(G_OBJECT(mShell), "nsWindow", this); + + // attach listeners for events + if (mShell) { + g_signal_connect(mShell, "configure_event", G_CALLBACK(configure_event_cb), + nullptr); + g_signal_connect(mShell, "delete_event", G_CALLBACK(delete_event_cb), + nullptr); + g_signal_connect(mShell, "window_state_event", + G_CALLBACK(window_state_event_cb), nullptr); + g_signal_connect(mShell, "check-resize", G_CALLBACK(check_resize_cb), + nullptr); + g_signal_connect(mShell, "composited-changed", + G_CALLBACK(widget_composited_changed_cb), nullptr); + g_signal_connect(mShell, "property-notify-event", + G_CALLBACK(property_notify_event_cb), nullptr); + + if (mWindowType == eWindowType_toplevel) { + g_signal_connect_after(mShell, "size_allocate", + G_CALLBACK(toplevel_window_size_allocate_cb), + nullptr); + } + + GdkScreen* screen = gtk_widget_get_screen(mShell); + if (!g_signal_handler_find(screen, G_SIGNAL_MATCH_FUNC, 0, 0, nullptr, + FuncToGpointer(screen_composited_changed_cb), + 0)) { + g_signal_connect(screen, "composited-changed", + G_CALLBACK(screen_composited_changed_cb), nullptr); + } + + GtkSettings* default_settings = gtk_settings_get_default(); + g_signal_connect_after(default_settings, "notify::gtk-theme-name", + G_CALLBACK(settings_changed_cb), this); + g_signal_connect_after(default_settings, "notify::gtk-font-name", + G_CALLBACK(settings_changed_cb), this); + g_signal_connect_after(default_settings, "notify::gtk-enable-animations", + G_CALLBACK(settings_changed_cb), this); + g_signal_connect_after(default_settings, "notify::gtk-decoration-layout", + G_CALLBACK(settings_changed_cb), this); + g_signal_connect_after(default_settings, "notify::gtk-xft-dpi", + G_CALLBACK(settings_xft_dpi_changed_cb), this); + // For remote LookAndFeel, to refresh the content processes' copies: + g_signal_connect_after(default_settings, "notify::gtk-cursor-blink-time", + G_CALLBACK(settings_changed_cb), this); + g_signal_connect_after(default_settings, "notify::gtk-cursor-blink", + G_CALLBACK(settings_changed_cb), this); + g_signal_connect_after(default_settings, + "notify::gtk-entry-select-on-focus", + G_CALLBACK(settings_changed_cb), this); + g_signal_connect_after(default_settings, + "notify::gtk-primary-button-warps-slider", + G_CALLBACK(settings_changed_cb), this); + g_signal_connect_after(default_settings, "notify::gtk-menu-popup-delay", + G_CALLBACK(settings_changed_cb), this); + g_signal_connect_after(default_settings, "notify::gtk-dnd-drag-threshold", + G_CALLBACK(settings_changed_cb), this); + } + + if (mContainer) { + // Widget signals + g_signal_connect(mContainer, "unrealize", + G_CALLBACK(container_unrealize_cb), nullptr); + g_signal_connect_after(mContainer, "size_allocate", + G_CALLBACK(size_allocate_cb), nullptr); + g_signal_connect(mContainer, "hierarchy-changed", + G_CALLBACK(hierarchy_changed_cb), nullptr); + g_signal_connect(mContainer, "notify::scale-factor", + G_CALLBACK(scale_changed_cb), nullptr); + // Initialize mHasMappedToplevel. + hierarchy_changed_cb(GTK_WIDGET(mContainer), nullptr); + // Expose, focus, key, and drag events are sent even to GTK_NO_WINDOW + // widgets. + g_signal_connect(G_OBJECT(mContainer), "draw", G_CALLBACK(expose_event_cb), + nullptr); + g_signal_connect(mContainer, "focus_in_event", + G_CALLBACK(focus_in_event_cb), nullptr); + g_signal_connect(mContainer, "focus_out_event", + G_CALLBACK(focus_out_event_cb), nullptr); + g_signal_connect(mContainer, "key_press_event", + G_CALLBACK(key_press_event_cb), nullptr); + g_signal_connect(mContainer, "key_release_event", + G_CALLBACK(key_release_event_cb), nullptr); + + gtk_drag_dest_set((GtkWidget*)mContainer, (GtkDestDefaults)0, nullptr, 0, + (GdkDragAction)0); + + g_signal_connect(mContainer, "drag_motion", + G_CALLBACK(drag_motion_event_cb), nullptr); + g_signal_connect(mContainer, "drag_leave", G_CALLBACK(drag_leave_event_cb), + nullptr); + g_signal_connect(mContainer, "drag_drop", G_CALLBACK(drag_drop_event_cb), + nullptr); + g_signal_connect(mContainer, "drag_data_received", + G_CALLBACK(drag_data_received_event_cb), nullptr); + +#ifdef MOZ_X11 + if (mIsX11Display) { + GtkWidget* widgets[] = {GTK_WIDGET(mContainer), + !mDrawToContainer ? mShell : nullptr}; + for (size_t i = 0; i < ArrayLength(widgets) && widgets[i]; ++i) { + // Double buffering is controlled by the window's owning + // widget. Disable double buffering for painting directly to the + // X Window. + gtk_widget_set_double_buffered(widgets[i], FALSE); + } + } +#endif + + // We create input contexts for all containers, except for + // toplevel popup windows + if (mWindowType != eWindowType_popup) { + mIMContext = new IMContextWrapper(this); + } + } else if (!mIMContext) { + nsWindow* container = GetContainerWindow(); + if (container) { + mIMContext = container->mIMContext; + } + } + + if (eventWidget) { + // These events are sent to the owning widget of the relevant window + // and propagate up to the first widget that handles the events, so we + // need only connect on mShell, if it exists, to catch events on its + // window and windows of mContainer. + g_signal_connect(eventWidget, "enter-notify-event", + G_CALLBACK(enter_notify_event_cb), nullptr); + g_signal_connect(eventWidget, "leave-notify-event", + G_CALLBACK(leave_notify_event_cb), nullptr); + g_signal_connect(eventWidget, "motion-notify-event", + G_CALLBACK(motion_notify_event_cb), nullptr); + g_signal_connect(eventWidget, "button-press-event", + G_CALLBACK(button_press_event_cb), nullptr); + g_signal_connect(eventWidget, "button-release-event", + G_CALLBACK(button_release_event_cb), nullptr); + g_signal_connect(eventWidget, "scroll-event", G_CALLBACK(scroll_event_cb), + nullptr); + if (gtk_check_version(3, 18, 0) == nullptr) { + g_signal_connect(eventWidget, "event", G_CALLBACK(generic_event_cb), + nullptr); + } + g_signal_connect(eventWidget, "touch-event", G_CALLBACK(touch_event_cb), + nullptr); + } + + LOG(("nsWindow [%p] %s %s\n", (void*)this, + mWindowType == eWindowType_toplevel ? "Toplevel" : "Popup", + mIsPIPWindow ? "PIP window" : "")); + if (mShell) { + LOG(("\tmShell %p mContainer %p mGdkWindow %p 0x%lx\n", mShell, mContainer, + mGdkWindow, mIsX11Display ? gdk_x11_window_get_xid(mGdkWindow) : 0)); + } else if (mContainer) { + LOG(("\tmContainer %p mGdkWindow %p\n", mContainer, mGdkWindow)); + } else if (mGdkWindow) { + LOG(("\tmGdkWindow %p parent %p\n", mGdkWindow, + gdk_window_get_parent(mGdkWindow))); + } + + // resize so that everything is set to the right dimensions + if (!mIsTopLevel) + Resize(mBounds.x, mBounds.y, mBounds.width, mBounds.height, false); + +#ifdef MOZ_X11 + if (mIsX11Display && mGdkWindow) { + mXDisplay = GDK_WINDOW_XDISPLAY(mGdkWindow); + mXWindow = gdk_x11_window_get_xid(mGdkWindow); + + GdkVisual* gdkVisual = gdk_window_get_visual(mGdkWindow); + mXVisual = gdk_x11_visual_get_xvisual(gdkVisual); + mXDepth = gdk_visual_get_depth(gdkVisual); + bool shaped = popupNeedsAlphaVisual && !mHasAlphaVisual; + + mSurfaceProvider.Initialize(mXDisplay, mXWindow, mXVisual, mXDepth, shaped); + + if (mIsTopLevel) { + // Set window manager hint to keep fullscreen windows composited. + // + // If the window were to get unredirected, there could be visible + // tearing because Gecko does not align its framebuffer updates with + // vblank. + SetCompositorHint(GTK_WIDGET_COMPOSIDED_ENABLED); + } + } +# ifdef MOZ_WAYLAND + else if (!mIsX11Display) { + mSurfaceProvider.Initialize(this); + WaylandStartVsync(); + } +# endif +#endif + + // Set default application name when it's empty. + if (mGtkWindowAppName.IsEmpty()) { + mGtkWindowAppName = gAppData->name; + } + RefreshWindowClass(); + + return NS_OK; +} + +void nsWindow::RefreshWindowClass(void) { + GdkWindow* gdkWindow = gtk_widget_get_window(mShell); + if (!gdkWindow) { + return; + } + + if (!mGtkWindowRoleName.IsEmpty()) { + gdk_window_set_role(gdkWindow, mGtkWindowRoleName.get()); + } + +#ifdef MOZ_X11 + if (!mGtkWindowAppName.IsEmpty() && mIsX11Display) { + XClassHint* class_hint = XAllocClassHint(); + if (!class_hint) { + return; + } + const char* res_class = gdk_get_program_class(); + if (!res_class) return; + + class_hint->res_name = const_cast<char*>(mGtkWindowAppName.get()); + class_hint->res_class = const_cast<char*>(res_class); + + // Can't use gtk_window_set_wmclass() for this; it prints + // a warning & refuses to make the change. + GdkDisplay* display = gdk_display_get_default(); + XSetClassHint(GDK_DISPLAY_XDISPLAY(display), + gdk_x11_window_get_xid(gdkWindow), class_hint); + XFree(class_hint); + } +#endif /* MOZ_X11 */ +} + +void nsWindow::SetWindowClass(const nsAString& xulWinType) { + if (!mShell) return; + + char* res_name = ToNewCString(xulWinType, mozilla::fallible); + if (!res_name) return; + + const char* role = nullptr; + + // Parse res_name into a name and role. Characters other than + // [A-Za-z0-9_-] are converted to '_'. Anything after the first + // colon is assigned to role; if there's no colon, assign the + // whole thing to both role and res_name. + for (char* c = res_name; *c; c++) { + if (':' == *c) { + *c = 0; + role = c + 1; + } else if (!isascii(*c) || (!isalnum(*c) && ('_' != *c) && ('-' != *c))) + *c = '_'; + } + res_name[0] = toupper(res_name[0]); + if (!role) role = res_name; + + mGtkWindowAppName = res_name; + mGtkWindowRoleName = role; + free(res_name); + + RefreshWindowClass(); +} + +void nsWindow::NativeResize() { + if (!AreBoundsSane()) { + // If someone has set this so that the needs show flag is false + // and it needs to be hidden, update the flag and hide the + // window. This flag will be cleared the next time someone + // hides the window or shows it. It also prevents us from + // calling NativeShow(false) excessively on the window which + // causes unneeded X traffic. + if (!mNeedsShow && mIsShown) { + mNeedsShow = true; + NativeShow(false); + } + return; + } + + GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mBounds.Size()); + + LOG(("nsWindow::NativeResize [%p] %d %d\n", (void*)this, size.width, + size.height)); + + if (mIsTopLevel) { + MOZ_ASSERT(size.width > 0 && size.height > 0, + "Can't resize window smaller than 1x1."); + gtk_window_resize(GTK_WINDOW(mShell), size.width, size.height); + if (mWaitingForMoveToRectCB) { + LOG(("Waiting for move to rect, schedulling ")); + mPendingSizeRect = mBounds; + } + } else if (mContainer) { + GtkWidget* widget = GTK_WIDGET(mContainer); + GtkAllocation allocation, prev_allocation; + gtk_widget_get_allocation(widget, &prev_allocation); + allocation.x = prev_allocation.x; + allocation.y = prev_allocation.y; + allocation.width = size.width; + allocation.height = size.height; + gtk_widget_size_allocate(widget, &allocation); + } else if (mGdkWindow) { + gdk_window_resize(mGdkWindow, size.width, size.height); + } + +#ifdef MOZ_X11 + // Notify the GtkCompositorWidget of a ClientSizeChange + // This is different than OnSizeAllocate to catch initial sizing + if (mCompositorWidgetDelegate) { + mCompositorWidgetDelegate->NotifyClientSizeChanged(GetClientSize()); + } +#endif + + // Does it need to be shown because bounds were previously insane? + if (mNeedsShow && mIsShown) { + NativeShow(true); + } +} + +void nsWindow::NativeMoveResize() { + if (!AreBoundsSane()) { + // If someone has set this so that the needs show flag is false + // and it needs to be hidden, update the flag and hide the + // window. This flag will be cleared the next time someone + // hides the window or shows it. It also prevents us from + // calling NativeShow(false) excessively on the window which + // causes unneeded X traffic. + if (!mNeedsShow && mIsShown) { + mNeedsShow = true; + NativeShow(false); + } + NativeMove(); + + return; + } + + GdkRectangle size = DevicePixelsToGdkSizeRoundUp(mBounds.Size()); + GdkPoint topLeft = DevicePixelsToGdkPointRoundDown(mBounds.TopLeft()); + + LOG(("nsWindow::NativeMoveResize [%p] %d %d %d %d\n", (void*)this, topLeft.x, + topLeft.y, size.width, size.height)); + + if (IsWaylandPopup()) { + NativeMoveResizeWaylandPopup(&topLeft, &size); + } else { + if (mIsTopLevel) { + // x and y give the position of the window manager frame top-left. + gtk_window_move(GTK_WINDOW(mShell), topLeft.x, topLeft.y); + // This sets the client window size. + MOZ_ASSERT(size.width > 0 && size.height > 0, + "Can't resize window smaller than 1x1."); + gtk_window_resize(GTK_WINDOW(mShell), size.width, size.height); + } else if (mContainer) { + GtkAllocation allocation; + allocation.x = topLeft.x; + allocation.y = topLeft.y; + allocation.width = size.width; + allocation.height = size.height; + gtk_widget_size_allocate(GTK_WIDGET(mContainer), &allocation); + } else if (mGdkWindow) { + gdk_window_move_resize(mGdkWindow, topLeft.x, topLeft.y, size.width, + size.height); + } + } + +#ifdef MOZ_X11 + // Notify the GtkCompositorWidget of a ClientSizeChange + // This is different than OnSizeAllocate to catch initial sizing + if (mCompositorWidgetDelegate) { + mCompositorWidgetDelegate->NotifyClientSizeChanged(GetClientSize()); + } +#endif + + // Does it need to be shown because bounds were previously insane? + if (mNeedsShow && mIsShown) { + NativeShow(true); + } +} + +void nsWindow::PauseRemoteRenderer() { +#ifdef MOZ_WAYLAND + if (!mIsDestroyed) { + if (mContainer) { + // Because wl_egl_window is destroyed on moz_container_unmap(), + // the current compositor cannot use it anymore. To avoid crash, + // pause the compositor and destroy EGLSurface & resume the compositor + // and re-create EGLSurface on next expose event. + + // moz_container_wayland_has_egl_window() could not be used here, since + // there is a case that resume compositor is not completed yet. + + CompositorBridgeChild* remoteRenderer = GetRemoteRenderer(); + bool needsCompositorPause = !mNeedsCompositorResume && !!remoteRenderer && + mCompositorWidgetDelegate; + if (needsCompositorPause) { + // XXX slow sync IPC + remoteRenderer->SendPause(); + // Re-request initial draw callback + RefPtr<nsWindow> self(this); + moz_container_wayland_add_initial_draw_callback( + mContainer, [self]() -> void { + self->mNeedsCompositorResume = true; + self->MaybeResumeCompositor(); + }); + } else { + DestroyLayerManager(); + } + } + } +#endif +} + +void nsWindow::HideWaylandWindow() { + if (mWindowType == eWindowType_popup) { + LOG(("nsWindow::HideWaylandWindow: popup [%p]\n", this)); + GList* foundWindow = g_list_find(gVisibleWaylandPopupWindows, this); + if (foundWindow) { + gVisibleWaylandPopupWindows = + g_list_delete_link(gVisibleWaylandPopupWindows, foundWindow); + } + } + PauseRemoteRenderer(); + gtk_widget_hide(mShell); +} + +void nsWindow::WaylandStartVsync() { +#ifdef MOZ_WAYLAND + // only use for toplevel windows for now - see bug 1619246 + if (!gUseWaylandVsync || mWindowType != eWindowType_toplevel) { + return; + } + + if (!mWaylandVsyncSource) { + mWaylandVsyncSource = new mozilla::WaylandVsyncSource(mContainer); + } + WaylandVsyncSource::WaylandDisplay& display = + static_cast<WaylandVsyncSource::WaylandDisplay&>( + mWaylandVsyncSource->GetGlobalDisplay()); + display.EnableMonitor(); +#endif +} + +void nsWindow::WaylandStopVsync() { +#ifdef MOZ_WAYLAND + if (mWaylandVsyncSource) { + // The widget is going to be hidden, so clear the surface of our + // vsync source. + WaylandVsyncSource::WaylandDisplay& display = + static_cast<WaylandVsyncSource::WaylandDisplay&>( + mWaylandVsyncSource->GetGlobalDisplay()); + display.DisableMonitor(); + } +#endif +} + +void nsWindow::NativeShow(bool aAction) { + if (aAction) { + // unset our flag now that our window has been shown + mNeedsShow = false; + + if (mIsTopLevel) { + // Set up usertime/startupID metadata for the created window. + if (mWindowType != eWindowType_invisible) { + SetUserTimeAndStartupIDForActivatedWindow(mShell); + } + // Update popup window hierarchy run-time on Wayland. + if (IsWaylandPopup()) { + if (!ConfigureWaylandPopupWindows()) { + mNeedsShow = true; + return; + } + } + + LOG((" calling gtk_widget_show(mShell)\n")); + gtk_widget_show(mShell); + if (!mIsX11Display) { + WaylandStartVsync(); + } + } else if (mContainer) { + LOG((" calling gtk_widget_show(mContainer)\n")); + gtk_widget_show(GTK_WIDGET(mContainer)); + } else if (mGdkWindow) { + LOG((" calling gdk_window_show_unraised\n")); + gdk_window_show_unraised(mGdkWindow); + } + } else { + // There's a chance that when the popup will be shown again it might be + // resized because parent could be moved meanwhile. + mPreferredPopupRect = nsRect(0, 0, 0, 0); + mPreferredPopupRectFlushed = false; + if (!mIsX11Display) { + WaylandStopVsync(); + if (IsWaylandPopup() && IsMainMenuWindow()) { + CleanupWaylandPopups(); + } + HideWaylandWindow(); + } else if (mIsTopLevel) { + // Workaround window freezes on GTK versions before 3.21.2 by + // ensuring that configure events get dispatched to windows before + // they are unmapped. See bug 1225044. + if (gtk_check_version(3, 21, 2) != nullptr && mPendingConfigures > 0) { + GtkAllocation allocation; + gtk_widget_get_allocation(GTK_WIDGET(mShell), &allocation); + + GdkEventConfigure event; + PodZero(&event); + event.type = GDK_CONFIGURE; + event.window = mGdkWindow; + event.send_event = TRUE; + event.x = allocation.x; + event.y = allocation.y; + event.width = allocation.width; + event.height = allocation.height; + + auto shellClass = GTK_WIDGET_GET_CLASS(mShell); + for (unsigned int i = 0; i < mPendingConfigures; i++) { + Unused << shellClass->configure_event(mShell, &event); + } + mPendingConfigures = 0; + } + gtk_widget_hide(mShell); + + ClearTransparencyBitmap(); // Release some resources + } else if (mContainer) { + gtk_widget_hide(GTK_WIDGET(mContainer)); + } else if (mGdkWindow) { + gdk_window_hide(mGdkWindow); + } + } +} + +void nsWindow::SetHasMappedToplevel(bool aState) { + // Even when aState == mHasMappedToplevel (as when this method is called + // from Show()), child windows need to have their state checked, so don't + // return early. + bool oldState = mHasMappedToplevel; + mHasMappedToplevel = aState; + + // mHasMappedToplevel is not updated for children of windows that are + // hidden; GDK knows not to send expose events for these windows. The + // state is recorded on the hidden window itself, but, for child trees of + // hidden windows, their state essentially becomes disconnected from their + // hidden parent. When the hidden parent gets shown, the child trees are + // reconnected, and the state of the window being shown can be easily + // propagated. + if (!mIsShown || !mGdkWindow) return; + + if (aState && !oldState) { + // Check that a grab didn't fail due to the window not being + // viewable. + EnsureGrabs(); + } + + for (GList* children = gdk_window_peek_children(mGdkWindow); children; + children = children->next) { + GdkWindow* gdkWin = GDK_WINDOW(children->data); + nsWindow* child = get_window_for_gdk_window(gdkWin); + + if (child && child->mHasMappedToplevel != aState) { + child->SetHasMappedToplevel(aState); + } + } +} + +LayoutDeviceIntSize nsWindow::GetSafeWindowSize(LayoutDeviceIntSize aSize) { + // The X protocol uses CARD32 for window sizes, but the server (1.11.3) + // reads it as CARD16. Sizes of pixmaps, used for drawing, are (unsigned) + // CARD16 in the protocol, but the server's ProcCreatePixmap returns + // BadAlloc if dimensions cannot be represented by signed shorts. + // Because we are creating Cairo surfaces to represent window buffers, + // we also must ensure that the window can fit in a Cairo surface. + LayoutDeviceIntSize result = aSize; + int32_t maxSize = 32767; + if (mLayerManager && mLayerManager->AsKnowsCompositor()) { + maxSize = std::min(maxSize, + mLayerManager->AsKnowsCompositor()->GetMaxTextureSize()); + } + if (result.width > maxSize) { + result.width = maxSize; + } + if (result.height > maxSize) { + result.height = maxSize; + } + return result; +} + +void nsWindow::EnsureGrabs(void) { + if (mRetryPointerGrab) GrabPointer(sRetryGrabTime); +} + +void nsWindow::CleanLayerManagerRecursive(void) { + if (mLayerManager) { + mLayerManager->Destroy(); + mLayerManager = nullptr; + } + + DestroyCompositor(); + + GList* children = gdk_window_peek_children(mGdkWindow); + for (GList* list = children; list; list = list->next) { + nsWindow* window = get_window_for_gdk_window(GDK_WINDOW(list->data)); + if (window) { + window->CleanLayerManagerRecursive(); + } + } +} + +void nsWindow::SetTransparencyMode(nsTransparencyMode aMode) { + if (!mShell) { + // Pass the request to the toplevel window + GtkWidget* topWidget = GetToplevelWidget(); + if (!topWidget) return; + + nsWindow* topWindow = get_window_for_gtk_widget(topWidget); + if (!topWindow) return; + + topWindow->SetTransparencyMode(aMode); + return; + } + + bool isTransparent = aMode == eTransparencyTransparent; + + if (mIsTransparent == isTransparent) { + return; + } + + if (mWindowType != eWindowType_popup) { + // https://bugzilla.mozilla.org/show_bug.cgi?id=1344839 reported + // problems cleaning the layer manager for toplevel windows. + // Ignore the request so as to workaround that. + // mIsTransparent is set in Create() if transparency may be required. + if (isTransparent) { + NS_WARNING("Transparent mode not supported on non-popup windows."); + } + return; + } + + if (!isTransparent) { + ClearTransparencyBitmap(); + } // else the new default alpha values are "all 1", so we don't + // need to change anything yet + + mIsTransparent = isTransparent; + + if (!mHasAlphaVisual) { + // The choice of layer manager depends on + // GtkCompositorWidgetInitData::Shaped(), which will need to change, so + // clean out the old layer manager. + CleanLayerManagerRecursive(); + } +} + +nsTransparencyMode nsWindow::GetTransparencyMode() { + if (!mShell) { + // Pass the request to the toplevel window + GtkWidget* topWidget = GetToplevelWidget(); + if (!topWidget) { + return eTransparencyOpaque; + } + + nsWindow* topWindow = get_window_for_gtk_widget(topWidget); + if (!topWindow) { + return eTransparencyOpaque; + } + + return topWindow->GetTransparencyMode(); + } + + return mIsTransparent ? eTransparencyTransparent : eTransparencyOpaque; +} + +void nsWindow::SetWindowMouseTransparent(bool aIsTransparent) { + if (!mGdkWindow) { + return; + } + + cairo_rectangle_int_t emptyRect = {0, 0, 0, 0}; + cairo_region_t* region = + aIsTransparent ? cairo_region_create_rectangle(&emptyRect) : nullptr; + + gdk_window_input_shape_combine_region(mGdkWindow, region, 0, 0); + if (region) { + cairo_region_destroy(region); + } +} + +// For setting the draggable titlebar region from CSS +// with -moz-window-dragging: drag. +void nsWindow::UpdateWindowDraggingRegion( + const LayoutDeviceIntRegion& aRegion) { + if (mDraggableRegion != aRegion) { + mDraggableRegion = aRegion; + } +} + +// See subtract_corners_from_region() at gtk/gtkwindow.c +// We need to subtract corners from toplevel window opaque region +// to draw transparent corners of default Gtk titlebar. +// Both implementations (cairo_region_t and wl_region) needs to be synced. +static void SubtractTitlebarCorners(cairo_region_t* aRegion, int aX, int aY, + int aWindowWidth) { + cairo_rectangle_int_t rect = {aX, aY, TITLEBAR_SHAPE_MASK_HEIGHT, + TITLEBAR_SHAPE_MASK_HEIGHT}; + cairo_region_subtract_rectangle(aRegion, &rect); + rect = { + aX + aWindowWidth - TITLEBAR_SHAPE_MASK_HEIGHT, + aY, + TITLEBAR_SHAPE_MASK_HEIGHT, + TITLEBAR_SHAPE_MASK_HEIGHT, + }; + cairo_region_subtract_rectangle(aRegion, &rect); +} + +void nsWindow::UpdateTopLevelOpaqueRegion(void) { + if (!mCompositedScreen) { + return; + } + + GdkWindow* window = + (mDrawToContainer) ? gtk_widget_get_window(mShell) : mGdkWindow; + if (!window) { + return; + } + MOZ_ASSERT(gdk_window_get_window_type(window) == GDK_WINDOW_TOPLEVEL); + + int x = 0; + int y = 0; + + if (mDrawToContainer) { + gdk_window_get_position(mGdkWindow, &x, &y); + } + + int width = DevicePixelsToGdkCoordRoundDown(mBounds.width); + int height = DevicePixelsToGdkCoordRoundDown(mBounds.height); + + cairo_region_t* region = cairo_region_create(); + cairo_rectangle_int_t rect = {x, y, width, height}; + cairo_region_union_rectangle(region, &rect); + + bool subtractCorners = DoDrawTilebarCorners(); + if (subtractCorners) { + SubtractTitlebarCorners(region, x, y, width); + } + + gdk_window_set_opaque_region(window, region); + + cairo_region_destroy(region); + +#ifdef MOZ_WAYLAND + // We don't set opaque region to mozContainer by default due to Bug 1615098. + if (!mIsX11Display && gUseWaylandUseOpaqueRegion) { + moz_container_wayland_update_opaque_region(mContainer, subtractCorners); + } +#endif +} + +bool nsWindow::IsChromeWindowTitlebar() { + return mDrawInTitlebar && !mIsPIPWindow && + mWindowType == eWindowType_toplevel; +} + +bool nsWindow::DoDrawTilebarCorners() { + return IsChromeWindowTitlebar() && mSizeState == nsSizeMode_Normal && + !mIsTiled; +} + +nsresult nsWindow::ConfigureChildren( + const nsTArray<Configuration>& aConfigurations) { + // If this is a remotely updated widget we receive clipping, position, and + // size information from a source other than our owner. Don't let our parent + // update this information. + if (mWindowType == eWindowType_plugin_ipc_chrome) { + return NS_OK; + } + + for (uint32_t i = 0; i < aConfigurations.Length(); ++i) { + const Configuration& configuration = aConfigurations[i]; + auto* w = static_cast<nsWindow*>(configuration.mChild.get()); + NS_ASSERTION(w->GetParent() == this, "Configured widget is not a child"); + w->SetWindowClipRegion(configuration.mClipRegion, true); + if (w->mBounds.Size() != configuration.mBounds.Size()) { + w->Resize(configuration.mBounds.x, configuration.mBounds.y, + configuration.mBounds.width, configuration.mBounds.height, + true); + } else if (w->mBounds.TopLeft() != configuration.mBounds.TopLeft()) { + w->Move(configuration.mBounds.x, configuration.mBounds.y); + } + w->SetWindowClipRegion(configuration.mClipRegion, false); + } + return NS_OK; +} + +nsresult nsWindow::SetWindowClipRegion( + const nsTArray<LayoutDeviceIntRect>& aRects, bool aIntersectWithExisting) { + const nsTArray<LayoutDeviceIntRect>* newRects = &aRects; + + AutoTArray<LayoutDeviceIntRect, 1> intersectRects; + if (aIntersectWithExisting) { + AutoTArray<LayoutDeviceIntRect, 1> existingRects; + GetWindowClipRegion(&existingRects); + + LayoutDeviceIntRegion existingRegion = RegionFromArray(existingRects); + LayoutDeviceIntRegion newRegion = RegionFromArray(aRects); + LayoutDeviceIntRegion intersectRegion; + intersectRegion.And(newRegion, existingRegion); + + // If mClipRects is null we haven't set a clip rect yet, so we + // need to set the clip even if it is equal. + if (mClipRects && intersectRegion.IsEqual(existingRegion)) { + return NS_OK; + } + + if (!intersectRegion.IsEqual(newRegion)) { + ArrayFromRegion(intersectRegion, intersectRects); + newRects = &intersectRects; + } + } + + if (IsWindowClipRegionEqual(*newRects)) return NS_OK; + + StoreWindowClipRegion(*newRects); + + if (!mGdkWindow) return NS_OK; + + cairo_region_t* region = cairo_region_create(); + for (uint32_t i = 0; i < newRects->Length(); ++i) { + const LayoutDeviceIntRect& r = newRects->ElementAt(i); + cairo_rectangle_int_t rect = {r.x, r.y, r.width, r.height}; + cairo_region_union_rectangle(region, &rect); + } + + gdk_window_shape_combine_region(mGdkWindow, region, 0, 0); + cairo_region_destroy(region); + + return NS_OK; +} + +void nsWindow::ResizeTransparencyBitmap() { + if (!mTransparencyBitmap) return; + + if (mBounds.width == mTransparencyBitmapWidth && + mBounds.height == mTransparencyBitmapHeight) + return; + + int32_t newRowBytes = GetBitmapStride(mBounds.width); + int32_t newSize = newRowBytes * mBounds.height; + auto* newBits = new gchar[newSize]; + // fill new mask with "transparent", first + memset(newBits, 0, newSize); + + // Now copy the intersection of the old and new areas into the new mask + int32_t copyWidth = std::min(mBounds.width, mTransparencyBitmapWidth); + int32_t copyHeight = std::min(mBounds.height, mTransparencyBitmapHeight); + int32_t oldRowBytes = GetBitmapStride(mTransparencyBitmapWidth); + int32_t copyBytes = GetBitmapStride(copyWidth); + + int32_t i; + gchar* fromPtr = mTransparencyBitmap; + gchar* toPtr = newBits; + for (i = 0; i < copyHeight; i++) { + memcpy(toPtr, fromPtr, copyBytes); + fromPtr += oldRowBytes; + toPtr += newRowBytes; + } + + delete[] mTransparencyBitmap; + mTransparencyBitmap = newBits; + mTransparencyBitmapWidth = mBounds.width; + mTransparencyBitmapHeight = mBounds.height; +} + +static bool ChangedMaskBits(gchar* aMaskBits, int32_t aMaskWidth, + int32_t aMaskHeight, const nsIntRect& aRect, + uint8_t* aAlphas, int32_t aStride) { + int32_t x, y, xMax = aRect.XMost(), yMax = aRect.YMost(); + int32_t maskBytesPerRow = GetBitmapStride(aMaskWidth); + for (y = aRect.y; y < yMax; y++) { + gchar* maskBytes = aMaskBits + y * maskBytesPerRow; + uint8_t* alphas = aAlphas; + for (x = aRect.x; x < xMax; x++) { + bool newBit = *alphas > 0x7f; + alphas++; + + gchar maskByte = maskBytes[x >> 3]; + bool maskBit = (maskByte & (1 << (x & 7))) != 0; + + if (maskBit != newBit) { + return true; + } + } + aAlphas += aStride; + } + + return false; +} + +static void UpdateMaskBits(gchar* aMaskBits, int32_t aMaskWidth, + int32_t aMaskHeight, const nsIntRect& aRect, + uint8_t* aAlphas, int32_t aStride) { + int32_t x, y, xMax = aRect.XMost(), yMax = aRect.YMost(); + int32_t maskBytesPerRow = GetBitmapStride(aMaskWidth); + for (y = aRect.y; y < yMax; y++) { + gchar* maskBytes = aMaskBits + y * maskBytesPerRow; + uint8_t* alphas = aAlphas; + for (x = aRect.x; x < xMax; x++) { + bool newBit = *alphas > 0x7f; + alphas++; + + gchar mask = 1 << (x & 7); + gchar maskByte = maskBytes[x >> 3]; + // Note: '-newBit' turns 0 into 00...00 and 1 into 11...11 + maskBytes[x >> 3] = (maskByte & ~mask) | (-newBit & mask); + } + aAlphas += aStride; + } +} + +void nsWindow::ApplyTransparencyBitmap() { +#ifdef MOZ_X11 + // We use X11 calls where possible, because GDK handles expose events + // for shaped windows in a way that's incompatible with us (Bug 635903). + // It doesn't occur when the shapes are set through X. + Display* xDisplay = GDK_WINDOW_XDISPLAY(mGdkWindow); + Window xDrawable = GDK_WINDOW_XID(mGdkWindow); + Pixmap maskPixmap = XCreateBitmapFromData( + xDisplay, xDrawable, mTransparencyBitmap, mTransparencyBitmapWidth, + mTransparencyBitmapHeight); + XShapeCombineMask(xDisplay, xDrawable, ShapeBounding, 0, 0, maskPixmap, + ShapeSet); + XFreePixmap(xDisplay, maskPixmap); +#else + cairo_surface_t* maskBitmap; + maskBitmap = cairo_image_surface_create_for_data( + (unsigned char*)mTransparencyBitmap, CAIRO_FORMAT_A1, + mTransparencyBitmapWidth, mTransparencyBitmapHeight, + GetBitmapStride(mTransparencyBitmapWidth)); + if (!maskBitmap) return; + + cairo_region_t* maskRegion = gdk_cairo_region_create_from_surface(maskBitmap); + gtk_widget_shape_combine_region(mShell, maskRegion); + cairo_region_destroy(maskRegion); + cairo_surface_destroy(maskBitmap); +#endif // MOZ_X11 +} + +void nsWindow::ClearTransparencyBitmap() { + if (!mTransparencyBitmap) return; + + delete[] mTransparencyBitmap; + mTransparencyBitmap = nullptr; + mTransparencyBitmapWidth = 0; + mTransparencyBitmapHeight = 0; + + if (!mShell) return; + +#ifdef MOZ_X11 + if (!mGdkWindow) return; + + Display* xDisplay = GDK_WINDOW_XDISPLAY(mGdkWindow); + Window xWindow = gdk_x11_window_get_xid(mGdkWindow); + + XShapeCombineMask(xDisplay, xWindow, ShapeBounding, 0, 0, X11None, ShapeSet); +#endif +} + +nsresult nsWindow::UpdateTranslucentWindowAlphaInternal(const nsIntRect& aRect, + uint8_t* aAlphas, + int32_t aStride) { + if (!mShell) { + // Pass the request to the toplevel window + GtkWidget* topWidget = GetToplevelWidget(); + if (!topWidget) return NS_ERROR_FAILURE; + + nsWindow* topWindow = get_window_for_gtk_widget(topWidget); + if (!topWindow) return NS_ERROR_FAILURE; + + return topWindow->UpdateTranslucentWindowAlphaInternal(aRect, aAlphas, + aStride); + } + + NS_ASSERTION(mIsTransparent, "Window is not transparent"); + NS_ASSERTION(!mTransparencyBitmapForTitlebar, + "Transparency bitmap is already used for titlebar rendering"); + + if (mTransparencyBitmap == nullptr) { + int32_t size = GetBitmapStride(mBounds.width) * mBounds.height; + mTransparencyBitmap = new gchar[size]; + memset(mTransparencyBitmap, 255, size); + mTransparencyBitmapWidth = mBounds.width; + mTransparencyBitmapHeight = mBounds.height; + } else { + ResizeTransparencyBitmap(); + } + + nsIntRect rect; + rect.IntersectRect(aRect, nsIntRect(0, 0, mBounds.width, mBounds.height)); + + if (!ChangedMaskBits(mTransparencyBitmap, mBounds.width, mBounds.height, rect, + aAlphas, aStride)) + // skip the expensive stuff if the mask bits haven't changed; hopefully + // this is the common case + return NS_OK; + + UpdateMaskBits(mTransparencyBitmap, mBounds.width, mBounds.height, rect, + aAlphas, aStride); + + if (!mNeedsShow) { + ApplyTransparencyBitmap(); + } + return NS_OK; +} + +bool nsWindow::GetTitlebarRect(mozilla::gfx::Rect& aRect) { + if (!mGdkWindow || !mDrawInTitlebar) { + return false; + } + + aRect = gfx::Rect(0, 0, mBounds.width, TITLEBAR_SHAPE_MASK_HEIGHT); + return true; +} + +void nsWindow::UpdateTitlebarTransparencyBitmap() { + NS_ASSERTION(mTransparencyBitmapForTitlebar, + "Transparency bitmap is already used to draw window shape"); + + if (!mGdkWindow || !mDrawInTitlebar || + (mBounds.width == mTransparencyBitmapWidth && + mBounds.height == mTransparencyBitmapHeight)) { + return; + } + + bool maskCreate = + !mTransparencyBitmap || mBounds.width > mTransparencyBitmapWidth; + + bool maskUpdate = + !mTransparencyBitmap || mBounds.width != mTransparencyBitmapWidth; + + if (maskCreate) { + if (mTransparencyBitmap) { + delete[] mTransparencyBitmap; + } + int32_t size = GetBitmapStride(mBounds.width) * TITLEBAR_SHAPE_MASK_HEIGHT; + mTransparencyBitmap = new gchar[size]; + mTransparencyBitmapWidth = mBounds.width; + } else { + mTransparencyBitmapWidth = mBounds.width; + } + mTransparencyBitmapHeight = mBounds.height; + + if (maskUpdate) { + cairo_surface_t* surface = cairo_image_surface_create( + CAIRO_FORMAT_A8, mTransparencyBitmapWidth, TITLEBAR_SHAPE_MASK_HEIGHT); + if (!surface) return; + + cairo_t* cr = cairo_create(surface); + + GtkWidgetState state; + memset((void*)&state, 0, sizeof(state)); + GdkRectangle rect = {0, 0, mTransparencyBitmapWidth, + TITLEBAR_SHAPE_MASK_HEIGHT}; + + moz_gtk_widget_paint(MOZ_GTK_HEADER_BAR, cr, &rect, &state, 0, + GTK_TEXT_DIR_NONE); + + cairo_destroy(cr); + cairo_surface_mark_dirty(surface); + cairo_surface_flush(surface); + + UpdateMaskBits( + mTransparencyBitmap, mTransparencyBitmapWidth, + TITLEBAR_SHAPE_MASK_HEIGHT, + nsIntRect(0, 0, mTransparencyBitmapWidth, TITLEBAR_SHAPE_MASK_HEIGHT), + cairo_image_surface_get_data(surface), + cairo_format_stride_for_width(CAIRO_FORMAT_A8, + mTransparencyBitmapWidth)); + + cairo_surface_destroy(surface); + } + + if (!mNeedsShow) { + Display* xDisplay = GDK_WINDOW_XDISPLAY(mGdkWindow); + Window xDrawable = GDK_WINDOW_XID(mGdkWindow); + + Pixmap maskPixmap = XCreateBitmapFromData( + xDisplay, xDrawable, mTransparencyBitmap, mTransparencyBitmapWidth, + TITLEBAR_SHAPE_MASK_HEIGHT); + + XShapeCombineMask(xDisplay, xDrawable, ShapeBounding, 0, 0, maskPixmap, + ShapeSet); + + if (mTransparencyBitmapHeight > TITLEBAR_SHAPE_MASK_HEIGHT) { + XRectangle rect = {0, 0, (unsigned short)mTransparencyBitmapWidth, + (unsigned short)(mTransparencyBitmapHeight - + TITLEBAR_SHAPE_MASK_HEIGHT)}; + XShapeCombineRectangles(xDisplay, xDrawable, ShapeBounding, 0, + TITLEBAR_SHAPE_MASK_HEIGHT, &rect, 1, ShapeUnion, + 0); + } + + XFreePixmap(xDisplay, maskPixmap); + } +} + +void nsWindow::GrabPointer(guint32 aTime) { + LOG(("GrabPointer time=0x%08x retry=%d\n", (unsigned int)aTime, + mRetryPointerGrab)); + + mRetryPointerGrab = false; + sRetryGrabTime = aTime; + + // If the window isn't visible, just set the flag to retry the + // grab. When this window becomes visible, the grab will be + // retried. + if (!mHasMappedToplevel) { + LOG(("GrabPointer: window not visible\n")); + mRetryPointerGrab = true; + return; + } + + if (!mGdkWindow) return; + + if (!mIsX11Display) { + // Don't to the grab on Wayland as it causes a regression + // from Bug 1377084. + return; + } + + gint retval; + // Note that we need GDK_TOUCH_MASK below to work around a GDK/X11 bug that + // causes touch events that would normally be received by this client on + // other windows to be discarded during the grab. + retval = gdk_pointer_grab( + mGdkWindow, TRUE, + (GdkEventMask)(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | + GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | + GDK_POINTER_MOTION_MASK | GDK_TOUCH_MASK), + (GdkWindow*)nullptr, nullptr, aTime); + + if (retval == GDK_GRAB_NOT_VIEWABLE) { + LOG(("GrabPointer: window not viewable; will retry\n")); + mRetryPointerGrab = true; + } else if (retval != GDK_GRAB_SUCCESS) { + LOG(("GrabPointer: pointer grab failed: %i\n", retval)); + // A failed grab indicates that another app has grabbed the pointer. + // Check for rollup now, because, without the grab, we likely won't + // get subsequent button press events. Do this with an event so that + // popups don't rollup while potentially adjusting the grab for + // this popup. + nsCOMPtr<nsIRunnable> event = + NewRunnableMethod("nsWindow::CheckForRollupDuringGrab", this, + &nsWindow::CheckForRollupDuringGrab); + NS_DispatchToCurrentThread(event.forget()); + } +} + +void nsWindow::ReleaseGrabs(void) { + LOG(("ReleaseGrabs\n")); + + mRetryPointerGrab = false; + + if (!mIsX11Display) { + // Don't to the ungrab on Wayland as it causes a regression + // from Bug 1377084. + return; + } + + gdk_pointer_ungrab(GDK_CURRENT_TIME); +} + +GtkWidget* nsWindow::GetToplevelWidget() { + if (mShell) { + return mShell; + } + + GtkWidget* widget = GetMozContainerWidget(); + if (!widget) return nullptr; + + return gtk_widget_get_toplevel(widget); +} + +GtkWidget* nsWindow::GetMozContainerWidget() { + if (!mGdkWindow) return nullptr; + + if (mContainer) return GTK_WIDGET(mContainer); + + GtkWidget* owningWidget = get_gtk_widget_for_gdk_window(mGdkWindow); + return owningWidget; +} + +nsWindow* nsWindow::GetContainerWindow() { + GtkWidget* owningWidget = GetMozContainerWidget(); + if (!owningWidget) return nullptr; + + nsWindow* window = get_window_for_gtk_widget(owningWidget); + NS_ASSERTION(window, "No nsWindow for container widget"); + return window; +} + +void nsWindow::SetUrgencyHint(GtkWidget* top_window, bool state) { + if (!top_window) return; + + gdk_window_set_urgency_hint(gtk_widget_get_window(top_window), state); +} + +void nsWindow::SetDefaultIcon(void) { SetIcon(u"default"_ns); } + +gint nsWindow::ConvertBorderStyles(nsBorderStyle aStyle) { + gint w = 0; + + if (aStyle == eBorderStyle_default) return -1; + + // note that we don't handle eBorderStyle_close yet + if (aStyle & eBorderStyle_all) w |= GDK_DECOR_ALL; + if (aStyle & eBorderStyle_border) w |= GDK_DECOR_BORDER; + if (aStyle & eBorderStyle_resizeh) w |= GDK_DECOR_RESIZEH; + if (aStyle & eBorderStyle_title) w |= GDK_DECOR_TITLE; + if (aStyle & eBorderStyle_menu) w |= GDK_DECOR_MENU; + if (aStyle & eBorderStyle_minimize) w |= GDK_DECOR_MINIMIZE; + if (aStyle & eBorderStyle_maximize) w |= GDK_DECOR_MAXIMIZE; + + return w; +} + +class FullscreenTransitionWindow final : public nsISupports { + public: + NS_DECL_ISUPPORTS + + explicit FullscreenTransitionWindow(GtkWidget* aWidget); + + GtkWidget* mWindow; + + private: + ~FullscreenTransitionWindow(); +}; + +NS_IMPL_ISUPPORTS0(FullscreenTransitionWindow) + +FullscreenTransitionWindow::FullscreenTransitionWindow(GtkWidget* aWidget) { + mWindow = gtk_window_new(GTK_WINDOW_POPUP); + GtkWindow* gtkWin = GTK_WINDOW(mWindow); + + gtk_window_set_type_hint(gtkWin, GDK_WINDOW_TYPE_HINT_SPLASHSCREEN); + gtk_window_set_transient_for(gtkWin, GTK_WINDOW(aWidget)); + gtk_window_set_decorated(gtkWin, false); + + GdkWindow* gdkWin = gtk_widget_get_window(aWidget); + GdkScreen* screen = gtk_widget_get_screen(aWidget); + gint monitorNum = gdk_screen_get_monitor_at_window(screen, gdkWin); + GdkRectangle monitorRect; + gdk_screen_get_monitor_geometry(screen, monitorNum, &monitorRect); + gtk_window_set_screen(gtkWin, screen); + gtk_window_move(gtkWin, monitorRect.x, monitorRect.y); + MOZ_ASSERT(monitorRect.width > 0 && monitorRect.height > 0, + "Can't resize window smaller than 1x1."); + gtk_window_resize(gtkWin, monitorRect.width, monitorRect.height); + + GdkColor bgColor; + bgColor.red = bgColor.green = bgColor.blue = 0; + gtk_widget_modify_bg(mWindow, GTK_STATE_NORMAL, &bgColor); + + gtk_window_set_opacity(gtkWin, 0.0); + gtk_widget_show(mWindow); +} + +FullscreenTransitionWindow::~FullscreenTransitionWindow() { + gtk_widget_destroy(mWindow); +} + +class FullscreenTransitionData { + public: + FullscreenTransitionData(nsIWidget::FullscreenTransitionStage aStage, + uint16_t aDuration, nsIRunnable* aCallback, + FullscreenTransitionWindow* aWindow) + : mStage(aStage), + mStartTime(TimeStamp::Now()), + mDuration(TimeDuration::FromMilliseconds(aDuration)), + mCallback(aCallback), + mWindow(aWindow) {} + + static const guint sInterval = 1000 / 30; // 30fps + static gboolean TimeoutCallback(gpointer aData); + + private: + nsIWidget::FullscreenTransitionStage mStage; + TimeStamp mStartTime; + TimeDuration mDuration; + nsCOMPtr<nsIRunnable> mCallback; + RefPtr<FullscreenTransitionWindow> mWindow; +}; + +/* static */ +gboolean FullscreenTransitionData::TimeoutCallback(gpointer aData) { + bool finishing = false; + auto data = static_cast<FullscreenTransitionData*>(aData); + gdouble opacity = (TimeStamp::Now() - data->mStartTime) / data->mDuration; + if (opacity >= 1.0) { + opacity = 1.0; + finishing = true; + } + if (data->mStage == nsIWidget::eAfterFullscreenToggle) { + opacity = 1.0 - opacity; + } + gtk_window_set_opacity(GTK_WINDOW(data->mWindow->mWindow), opacity); + + if (!finishing) { + return TRUE; + } + NS_DispatchToMainThread(data->mCallback.forget()); + delete data; + return FALSE; +} + +/* virtual */ +bool nsWindow::PrepareForFullscreenTransition(nsISupports** aData) { + if (!mCompositedScreen) { + return false; + } + *aData = do_AddRef(new FullscreenTransitionWindow(mShell)).take(); + return true; +} + +/* virtual */ +void nsWindow::PerformFullscreenTransition(FullscreenTransitionStage aStage, + uint16_t aDuration, + nsISupports* aData, + nsIRunnable* aCallback) { + auto data = static_cast<FullscreenTransitionWindow*>(aData); + // This will be released at the end of the last timeout callback for it. + auto transitionData = + new FullscreenTransitionData(aStage, aDuration, aCallback, data); + g_timeout_add_full(G_PRIORITY_HIGH, FullscreenTransitionData::sInterval, + FullscreenTransitionData::TimeoutCallback, transitionData, + nullptr); +} + +already_AddRefed<nsIScreen> nsWindow::GetWidgetScreen() { + nsCOMPtr<nsIScreenManager> screenManager; + screenManager = do_GetService("@mozilla.org/gfx/screenmanager;1"); + if (!screenManager) { + return nullptr; + } + + // GetScreenBounds() is slow for the GTK port so we override and use + // mBounds directly. + LayoutDeviceIntRect bounds = mBounds; + if (!mIsTopLevel) { + bounds.MoveTo(WidgetToScreenOffset()); + } + + DesktopIntRect deskBounds = RoundedToInt(bounds / GetDesktopToDeviceScale()); + nsCOMPtr<nsIScreen> screen; + screenManager->ScreenForRect(deskBounds.x, deskBounds.y, deskBounds.width, + deskBounds.height, getter_AddRefs(screen)); + return screen.forget(); +} + +RefPtr<VsyncSource> nsWindow::GetVsyncSource() { +#ifdef MOZ_WAYLAND + if (mWaylandVsyncSource) { + return mWaylandVsyncSource; + } +#endif + + return nullptr; +} + +static bool IsFullscreenSupported(GtkWidget* aShell) { +#ifdef MOZ_X11 + GdkScreen* screen = gtk_widget_get_screen(aShell); + GdkAtom atom = gdk_atom_intern("_NET_WM_STATE_FULLSCREEN", FALSE); + if (!gdk_x11_screen_supports_net_wm_hint(screen, atom)) { + return false; + } +#endif + return true; +} + +nsresult nsWindow::MakeFullScreen(bool aFullScreen, nsIScreen* aTargetScreen) { + LOG(("nsWindow::MakeFullScreen [%p] aFullScreen %d\n", (void*)this, + aFullScreen)); + + if (mIsX11Display && !IsFullscreenSupported(mShell)) { + return NS_ERROR_NOT_AVAILABLE; + } + + bool wasFullscreen = mSizeState == nsSizeMode_Fullscreen; + if (aFullScreen != wasFullscreen && mWidgetListener) { + mWidgetListener->FullscreenWillChange(aFullScreen); + } + + if (aFullScreen) { + if (mSizeMode != nsSizeMode_Fullscreen) mLastSizeMode = mSizeMode; + + mSizeMode = nsSizeMode_Fullscreen; + + if (mIsPIPWindow) { + gtk_window_set_type_hint(GTK_WINDOW(mShell), GDK_WINDOW_TYPE_HINT_NORMAL); + if (gUseAspectRatio) { + mAspectRatioSaved = mAspectRatio; + mAspectRatio = 0.0f; + ApplySizeConstraints(); + } + } + + gtk_window_fullscreen(GTK_WINDOW(mShell)); + } else { + mSizeMode = mLastSizeMode; + gtk_window_unfullscreen(GTK_WINDOW(mShell)); + + if (mIsPIPWindow) { + gtk_window_set_type_hint(GTK_WINDOW(mShell), + GDK_WINDOW_TYPE_HINT_UTILITY); + if (gUseAspectRatio) { + mAspectRatio = mAspectRatioSaved; + // ApplySizeConstraints(); + } + } + } + + NS_ASSERTION(mLastSizeMode != nsSizeMode_Fullscreen, + "mLastSizeMode should never be fullscreen"); + return NS_OK; +} + +void nsWindow::SetWindowDecoration(nsBorderStyle aStyle) { + LOG(("nsWindow::SetWindowDecoration() [%p] Border style %x\n", (void*)this, + aStyle)); + + if (!mShell) { + // Pass the request to the toplevel window + GtkWidget* topWidget = GetToplevelWidget(); + if (!topWidget) return; + + nsWindow* topWindow = get_window_for_gtk_widget(topWidget); + if (!topWindow) return; + + topWindow->SetWindowDecoration(aStyle); + return; + } + + // We can't use mGdkWindow directly here as it can be + // derived from mContainer which is not a top-level GdkWindow. + GdkWindow* window = gtk_widget_get_window(mShell); + + // Sawfish, metacity, and presumably other window managers get + // confused if we change the window decorations while the window + // is visible. + bool wasVisible = false; + if (gdk_window_is_visible(window)) { + gdk_window_hide(window); + wasVisible = true; + } + + gint wmd = ConvertBorderStyles(aStyle); + if (wmd != -1) gdk_window_set_decorations(window, (GdkWMDecoration)wmd); + + if (wasVisible) gdk_window_show(window); + + // For some window managers, adding or removing window decorations + // requires unmapping and remapping our toplevel window. Go ahead + // and flush the queue here so that we don't end up with a BadWindow + // error later when this happens (when the persistence timer fires + // and GetWindowPos is called) +#ifdef MOZ_X11 + if (mIsX11Display) { + XSync(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), X11False); + } else +#endif /* MOZ_X11 */ + { + gdk_flush(); + } +} + +void nsWindow::HideWindowChrome(bool aShouldHide) { + SetWindowDecoration(aShouldHide ? eBorderStyle_none : mBorderStyle); +} + +bool nsWindow::CheckForRollup(gdouble aMouseX, gdouble aMouseY, bool aIsWheel, + bool aAlwaysRollup) { + nsIRollupListener* rollupListener = GetActiveRollupListener(); + nsCOMPtr<nsIWidget> rollupWidget; + if (rollupListener) { + rollupWidget = rollupListener->GetRollupWidget(); + } + if (!rollupWidget) { + nsBaseWidget::gRollupListener = nullptr; + return false; + } + + bool retVal = false; + auto* currentPopup = + (GdkWindow*)rollupWidget->GetNativeData(NS_NATIVE_WINDOW); + if (aAlwaysRollup || !is_mouse_in_window(currentPopup, aMouseX, aMouseY)) { + bool rollup = true; + if (aIsWheel) { + rollup = rollupListener->ShouldRollupOnMouseWheelEvent(); + retVal = rollupListener->ShouldConsumeOnMouseWheelEvent(); + } + // if we're dealing with menus, we probably have submenus and + // we don't want to rollup if the click is in a parent menu of + // the current submenu + uint32_t popupsToRollup = UINT32_MAX; + if (!aAlwaysRollup) { + AutoTArray<nsIWidget*, 5> widgetChain; + uint32_t sameTypeCount = + rollupListener->GetSubmenuWidgetChain(&widgetChain); + for (unsigned long i = 0; i < widgetChain.Length(); ++i) { + nsIWidget* widget = widgetChain[i]; + auto* currWindow = (GdkWindow*)widget->GetNativeData(NS_NATIVE_WINDOW); + if (is_mouse_in_window(currWindow, aMouseX, aMouseY)) { + // don't roll up if the mouse event occurred within a + // menu of the same type. If the mouse event occurred + // in a menu higher than that, roll up, but pass the + // number of popups to Rollup so that only those of the + // same type close up. + if (i < sameTypeCount) { + rollup = false; + } else { + popupsToRollup = sameTypeCount; + } + break; + } + } // foreach parent menu widget + } // if rollup listener knows about menus + + // if we've determined that we should still rollup, do it. + bool usePoint = !aIsWheel && !aAlwaysRollup; + IntPoint point; + if (usePoint) { + LayoutDeviceIntPoint p = GdkEventCoordsToDevicePixels(aMouseX, aMouseY); + point = p.ToUnknownPoint(); + } + if (rollup && + rollupListener->Rollup(popupsToRollup, true, + usePoint ? &point : nullptr, nullptr)) { + retVal = true; + } + } + return retVal; +} + +/* static */ +bool nsWindow::DragInProgress(void) { + nsCOMPtr<nsIDragService> dragService = do_GetService(kCDragServiceCID); + + if (!dragService) return false; + + nsCOMPtr<nsIDragSession> currentDragSession; + dragService->GetCurrentSession(getter_AddRefs(currentDragSession)); + + return currentDragSession != nullptr; +} + +static bool is_mouse_in_window(GdkWindow* aWindow, gdouble aMouseX, + gdouble aMouseY) { + gint x = 0; + gint y = 0; + gint w, h; + + gint offsetX = 0; + gint offsetY = 0; + + GdkWindow* window = aWindow; + + while (window) { + gint tmpX = 0; + gint tmpY = 0; + + gdk_window_get_position(window, &tmpX, &tmpY); + GtkWidget* widget = get_gtk_widget_for_gdk_window(window); + + // if this is a window, compute x and y given its origin and our + // offset + if (GTK_IS_WINDOW(widget)) { + x = tmpX + offsetX; + y = tmpY + offsetY; + break; + } + + offsetX += tmpX; + offsetY += tmpY; + window = gdk_window_get_parent(window); + } + + w = gdk_window_get_width(aWindow); + h = gdk_window_get_height(aWindow); + + if (aMouseX > x && aMouseX < x + w && aMouseY > y && aMouseY < y + h) + return true; + + return false; +} + +static nsWindow* get_window_for_gtk_widget(GtkWidget* widget) { + gpointer user_data = g_object_get_data(G_OBJECT(widget), "nsWindow"); + + return static_cast<nsWindow*>(user_data); +} + +static nsWindow* get_window_for_gdk_window(GdkWindow* window) { + gpointer user_data = g_object_get_data(G_OBJECT(window), "nsWindow"); + + return static_cast<nsWindow*>(user_data); +} + +static GtkWidget* get_gtk_widget_for_gdk_window(GdkWindow* window) { + gpointer user_data = nullptr; + gdk_window_get_user_data(window, &user_data); + + return GTK_WIDGET(user_data); +} + +static GdkCursor* get_gtk_cursor(nsCursor aCursor) { + GdkCursor* gdkcursor = nullptr; + uint8_t newType = 0xff; + + if ((gdkcursor = gCursorCache[aCursor])) { + return gdkcursor; + } + + GdkDisplay* defaultDisplay = gdk_display_get_default(); + + // The strategy here is to use standard GDK cursors, and, if not available, + // load by standard name with gdk_cursor_new_from_name. + // Spec is here: http://www.freedesktop.org/wiki/Specifications/cursor-spec/ + switch (aCursor) { + case eCursor_standard: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_LEFT_PTR); + break; + case eCursor_wait: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_WATCH); + break; + case eCursor_select: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_XTERM); + break; + case eCursor_hyperlink: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_HAND2); + break; + case eCursor_n_resize: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_TOP_SIDE); + break; + case eCursor_s_resize: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_BOTTOM_SIDE); + break; + case eCursor_w_resize: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_LEFT_SIDE); + break; + case eCursor_e_resize: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_RIGHT_SIDE); + break; + case eCursor_nw_resize: + gdkcursor = + gdk_cursor_new_for_display(defaultDisplay, GDK_TOP_LEFT_CORNER); + break; + case eCursor_se_resize: + gdkcursor = + gdk_cursor_new_for_display(defaultDisplay, GDK_BOTTOM_RIGHT_CORNER); + break; + case eCursor_ne_resize: + gdkcursor = + gdk_cursor_new_for_display(defaultDisplay, GDK_TOP_RIGHT_CORNER); + break; + case eCursor_sw_resize: + gdkcursor = + gdk_cursor_new_for_display(defaultDisplay, GDK_BOTTOM_LEFT_CORNER); + break; + case eCursor_crosshair: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_CROSSHAIR); + break; + case eCursor_move: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_FLEUR); + break; + case eCursor_help: + gdkcursor = + gdk_cursor_new_for_display(defaultDisplay, GDK_QUESTION_ARROW); + break; + case eCursor_copy: // CSS3 + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "copy"); + if (!gdkcursor) newType = MOZ_CURSOR_COPY; + break; + case eCursor_alias: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "alias"); + if (!gdkcursor) newType = MOZ_CURSOR_ALIAS; + break; + case eCursor_context_menu: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "context-menu"); + if (!gdkcursor) newType = MOZ_CURSOR_CONTEXT_MENU; + break; + case eCursor_cell: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_PLUS); + break; + // Those two aren’t standardized. Trying both KDE’s and GNOME’s names + case eCursor_grab: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "openhand"); + if (!gdkcursor) newType = MOZ_CURSOR_HAND_GRAB; + break; + case eCursor_grabbing: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "closedhand"); + if (!gdkcursor) + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "grabbing"); + if (!gdkcursor) newType = MOZ_CURSOR_HAND_GRABBING; + break; + case eCursor_spinning: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "progress"); + if (!gdkcursor) newType = MOZ_CURSOR_SPINNING; + break; + case eCursor_zoom_in: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "zoom-in"); + if (!gdkcursor) newType = MOZ_CURSOR_ZOOM_IN; + break; + case eCursor_zoom_out: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "zoom-out"); + if (!gdkcursor) newType = MOZ_CURSOR_ZOOM_OUT; + break; + case eCursor_not_allowed: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "not-allowed"); + if (!gdkcursor) // nonstandard, yet common + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "crossed_circle"); + if (!gdkcursor) newType = MOZ_CURSOR_NOT_ALLOWED; + break; + case eCursor_no_drop: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "no-drop"); + if (!gdkcursor) // this nonstandard sequence makes it work on KDE and + // GNOME + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "forbidden"); + if (!gdkcursor) + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "circle"); + if (!gdkcursor) newType = MOZ_CURSOR_NOT_ALLOWED; + break; + case eCursor_vertical_text: + newType = MOZ_CURSOR_VERTICAL_TEXT; + break; + case eCursor_all_scroll: + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_FLEUR); + break; + case eCursor_nesw_resize: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "size_bdiag"); + if (!gdkcursor) newType = MOZ_CURSOR_NESW_RESIZE; + break; + case eCursor_nwse_resize: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "size_fdiag"); + if (!gdkcursor) newType = MOZ_CURSOR_NWSE_RESIZE; + break; + case eCursor_ns_resize: + gdkcursor = + gdk_cursor_new_for_display(defaultDisplay, GDK_SB_V_DOUBLE_ARROW); + break; + case eCursor_ew_resize: + gdkcursor = + gdk_cursor_new_for_display(defaultDisplay, GDK_SB_H_DOUBLE_ARROW); + break; + // Here, two better fitting cursors exist in some cursor themes. Try those + // first + case eCursor_row_resize: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "split_v"); + if (!gdkcursor) + gdkcursor = + gdk_cursor_new_for_display(defaultDisplay, GDK_SB_V_DOUBLE_ARROW); + break; + case eCursor_col_resize: + gdkcursor = gdk_cursor_new_from_name(defaultDisplay, "split_h"); + if (!gdkcursor) + gdkcursor = + gdk_cursor_new_for_display(defaultDisplay, GDK_SB_H_DOUBLE_ARROW); + break; + case eCursor_none: + newType = MOZ_CURSOR_NONE; + break; + default: + NS_ASSERTION(aCursor, "Invalid cursor type"); + gdkcursor = gdk_cursor_new_for_display(defaultDisplay, GDK_LEFT_PTR); + break; + } + + // If by now we don't have a xcursor, this means we have to make a custom + // one. First, we try creating a named cursor based on the hash of our + // custom bitmap, as libXcursor has some magic to convert bitmapped cursors + // to themed cursors + if (newType != 0xFF && GtkCursors[newType].hash) { + gdkcursor = + gdk_cursor_new_from_name(defaultDisplay, GtkCursors[newType].hash); + } + + // If we still don't have a xcursor, we now really create a bitmap cursor + if (newType != 0xff && !gdkcursor) { + GdkPixbuf* cursor_pixbuf = + gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 32, 32); + if (!cursor_pixbuf) return nullptr; + + guchar* data = gdk_pixbuf_get_pixels(cursor_pixbuf); + + // Read data from GtkCursors and compose RGBA surface from 1bit bitmap and + // mask GtkCursors bits and mask are 32x32 monochrome bitmaps (1 bit for + // each pixel) so it's 128 byte array (4 bytes for are one bitmap row and + // there are 32 rows here). + const unsigned char* bits = GtkCursors[newType].bits; + const unsigned char* mask_bits = GtkCursors[newType].mask_bits; + + for (int i = 0; i < 128; i++) { + char bit = *bits++; + char mask = *mask_bits++; + for (int j = 0; j < 8; j++) { + unsigned char pix = ~(((bit >> j) & 0x01) * 0xff); + *data++ = pix; + *data++ = pix; + *data++ = pix; + *data++ = (((mask >> j) & 0x01) * 0xff); + } + } + + gdkcursor = gdk_cursor_new_from_pixbuf( + gdk_display_get_default(), cursor_pixbuf, GtkCursors[newType].hot_x, + GtkCursors[newType].hot_y); + + g_object_unref(cursor_pixbuf); + } + + gCursorCache[aCursor] = gdkcursor; + + return gdkcursor; +} + +// gtk callbacks + +void draw_window_of_widget(GtkWidget* widget, GdkWindow* aWindow, cairo_t* cr) { + if (gtk_cairo_should_draw_window(cr, aWindow)) { + RefPtr<nsWindow> window = get_window_for_gdk_window(aWindow); + if (!window) { + NS_WARNING("Cannot get nsWindow from GtkWidget"); + } else { + cairo_save(cr); + gtk_cairo_transform_to_window(cr, widget, aWindow); + // TODO - window->OnExposeEvent() can destroy this or other windows, + // do we need to handle it somehow? + window->OnExposeEvent(cr); + cairo_restore(cr); + } + } + + GList* children = gdk_window_get_children(aWindow); + GList* child = children; + while (child) { + GdkWindow* window = GDK_WINDOW(child->data); + gpointer windowWidget; + gdk_window_get_user_data(window, &windowWidget); + if (windowWidget == widget) { + draw_window_of_widget(widget, window, cr); + } + child = g_list_next(child); + } + g_list_free(children); +} + +/* static */ +gboolean expose_event_cb(GtkWidget* widget, cairo_t* cr) { + draw_window_of_widget(widget, gtk_widget_get_window(widget), cr); + + // A strong reference is already held during "draw" signal emission, + // but GTK+ 3.4 wants the object to live a little longer than that + // (bug 1225970). + g_object_ref(widget); + g_idle_add( + [](gpointer data) -> gboolean { + g_object_unref(data); + return G_SOURCE_REMOVE; + }, + widget); + + return FALSE; +} + +static gboolean configure_event_cb(GtkWidget* widget, + GdkEventConfigure* event) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) { + return FALSE; + } + + return window->OnConfigureEvent(widget, event); +} + +static void container_unrealize_cb(GtkWidget* widget) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) { + return; + } + + window->OnContainerUnrealize(); +} + +static void size_allocate_cb(GtkWidget* widget, GtkAllocation* allocation) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) { + return; + } + + window->OnSizeAllocate(allocation); +} + +static void toplevel_window_size_allocate_cb(GtkWidget* widget, + GtkAllocation* allocation) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) { + return; + } + + window->UpdateTopLevelOpaqueRegion(); +} + +static gboolean delete_event_cb(GtkWidget* widget, GdkEventAny* event) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) { + return FALSE; + } + + window->OnDeleteEvent(); + + return TRUE; +} + +static gboolean enter_notify_event_cb(GtkWidget* widget, + GdkEventCrossing* event) { + RefPtr<nsWindow> window = get_window_for_gdk_window(event->window); + if (!window) { + return TRUE; + } + + window->OnEnterNotifyEvent(event); + + return TRUE; +} + +static gboolean leave_notify_event_cb(GtkWidget* widget, + GdkEventCrossing* event) { + if (is_parent_grab_leave(event)) { + return TRUE; + } + + // bug 369599: Suppress LeaveNotify events caused by pointer grabs to + // avoid generating spurious mouse exit events. + auto x = gint(event->x_root); + auto y = gint(event->y_root); + GdkDisplay* display = gtk_widget_get_display(widget); + GdkWindow* winAtPt = gdk_display_get_window_at_pointer(display, &x, &y); + if (winAtPt == event->window) { + return TRUE; + } + + RefPtr<nsWindow> window = get_window_for_gdk_window(event->window); + if (!window) return TRUE; + + window->OnLeaveNotifyEvent(event); + + return TRUE; +} + +static nsWindow* GetFirstNSWindowForGDKWindow(GdkWindow* aGdkWindow) { + nsWindow* window; + while (!(window = get_window_for_gdk_window(aGdkWindow))) { + // The event has bubbled to the moz_container widget as passed into each + // caller's *widget parameter, but its corresponding nsWindow is an ancestor + // of the window that we need. Instead, look at event->window and find the + // first ancestor nsWindow of it because event->window may be in a plugin. + aGdkWindow = gdk_window_get_parent(aGdkWindow); + if (!aGdkWindow) { + window = nullptr; + break; + } + } + return window; +} + +static gboolean motion_notify_event_cb(GtkWidget* widget, + GdkEventMotion* event) { + UpdateLastInputEventTime(event); + + nsWindow* window = GetFirstNSWindowForGDKWindow(event->window); + if (!window) return FALSE; + + window->OnMotionNotifyEvent(event); + + return TRUE; +} + +static gboolean button_press_event_cb(GtkWidget* widget, + GdkEventButton* event) { + UpdateLastInputEventTime(event); + + nsWindow* window = GetFirstNSWindowForGDKWindow(event->window); + if (!window) return FALSE; + + window->OnButtonPressEvent(event); + + return TRUE; +} + +static gboolean button_release_event_cb(GtkWidget* widget, + GdkEventButton* event) { + UpdateLastInputEventTime(event); + + nsWindow* window = GetFirstNSWindowForGDKWindow(event->window); + if (!window) return FALSE; + + window->OnButtonReleaseEvent(event); + + return TRUE; +} + +static gboolean focus_in_event_cb(GtkWidget* widget, GdkEventFocus* event) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) return FALSE; + + window->OnContainerFocusInEvent(event); + + return FALSE; +} + +static gboolean focus_out_event_cb(GtkWidget* widget, GdkEventFocus* event) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) return FALSE; + + window->OnContainerFocusOutEvent(event); + + return FALSE; +} + +#ifdef MOZ_X11 +// For long-lived popup windows that don't really take focus themselves but +// may have elements that accept keyboard input when the parent window is +// active, focus is handled specially. These windows include noautohide +// panels. (This special handling is not necessary for temporary popups where +// the keyboard is grabbed.) +// +// Mousing over or clicking on these windows should not cause them to steal +// focus from their parent windows, so, the input field of WM_HINTS is set to +// False to request that the window manager not set the input focus to this +// window. http://tronche.com/gui/x/icccm/sec-4.html#s-4.1.7 +// +// However, these windows can still receive WM_TAKE_FOCUS messages from the +// window manager, so they can still detect when the user has indicated that +// they wish to direct keyboard input at these windows. When the window +// manager offers focus to these windows (after a mouse over or click, for +// example), a request to make the parent window active is issued. When the +// parent window becomes active, keyboard events will be received. + +static GdkFilterReturn popup_take_focus_filter(GdkXEvent* gdk_xevent, + GdkEvent* event, gpointer data) { + auto* xevent = static_cast<XEvent*>(gdk_xevent); + if (xevent->type != ClientMessage) return GDK_FILTER_CONTINUE; + + XClientMessageEvent& xclient = xevent->xclient; + if (xclient.message_type != gdk_x11_get_xatom_by_name("WM_PROTOCOLS")) + return GDK_FILTER_CONTINUE; + + Atom atom = xclient.data.l[0]; + if (atom != gdk_x11_get_xatom_by_name("WM_TAKE_FOCUS")) + return GDK_FILTER_CONTINUE; + + guint32 timestamp = xclient.data.l[1]; + + GtkWidget* widget = get_gtk_widget_for_gdk_window(event->any.window); + if (!widget) return GDK_FILTER_CONTINUE; + + GtkWindow* parent = gtk_window_get_transient_for(GTK_WINDOW(widget)); + if (!parent) return GDK_FILTER_CONTINUE; + + if (gtk_window_is_active(parent)) + return GDK_FILTER_REMOVE; // leave input focus on the parent + + GdkWindow* parent_window = gtk_widget_get_window(GTK_WIDGET(parent)); + if (!parent_window) return GDK_FILTER_CONTINUE; + + // In case the parent has not been deconified. + gdk_window_show_unraised(parent_window); + + // Request focus on the parent window. + // Use gdk_window_focus rather than gtk_window_present to avoid + // raising the parent window. + gdk_window_focus(parent_window, timestamp); + return GDK_FILTER_REMOVE; +} +#endif /* MOZ_X11 */ + +static gboolean key_press_event_cb(GtkWidget* widget, GdkEventKey* event) { + LOG(("key_press_event_cb\n")); + + UpdateLastInputEventTime(event); + + // find the window with focus and dispatch this event to that widget + nsWindow* window = get_window_for_gtk_widget(widget); + if (!window) return FALSE; + + RefPtr<nsWindow> focusWindow = gFocusWindow ? gFocusWindow : window; + +#ifdef MOZ_X11 + // Keyboard repeat can cause key press events to queue up when there are + // slow event handlers (bug 301029). Throttle these events by removing + // consecutive pending duplicate KeyPress events to the same window. + // We use the event time of the last one. + // Note: GDK calls XkbSetDetectableAutorepeat so that KeyRelease events + // are generated only when the key is physically released. +# define NS_GDKEVENT_MATCH_MASK 0x1FFF // GDK_SHIFT_MASK .. GDK_BUTTON5_MASK + // Our headers undefine X11 KeyPress - let's redefine it here. +# ifndef KeyPress +# define KeyPress 2 +# endif + GdkDisplay* gdkDisplay = gtk_widget_get_display(widget); + if (GDK_IS_X11_DISPLAY(gdkDisplay)) { + Display* dpy = GDK_DISPLAY_XDISPLAY(gdkDisplay); + while (XPending(dpy)) { + XEvent next_event; + XPeekEvent(dpy, &next_event); + GdkWindow* nextGdkWindow = + gdk_x11_window_lookup_for_display(gdkDisplay, next_event.xany.window); + if (nextGdkWindow != event->window || next_event.type != KeyPress || + next_event.xkey.keycode != event->hardware_keycode || + next_event.xkey.state != (event->state & NS_GDKEVENT_MATCH_MASK)) { + break; + } + XNextEvent(dpy, &next_event); + event->time = next_event.xkey.time; + } + } +#endif + + return focusWindow->OnKeyPressEvent(event); +} + +static gboolean key_release_event_cb(GtkWidget* widget, GdkEventKey* event) { + LOG(("key_release_event_cb\n")); + + UpdateLastInputEventTime(event); + + // find the window with focus and dispatch this event to that widget + nsWindow* window = get_window_for_gtk_widget(widget); + if (!window) return FALSE; + + RefPtr<nsWindow> focusWindow = gFocusWindow ? gFocusWindow : window; + + return focusWindow->OnKeyReleaseEvent(event); +} + +static gboolean property_notify_event_cb(GtkWidget* aWidget, + GdkEventProperty* aEvent) { + RefPtr<nsWindow> window = get_window_for_gdk_window(aEvent->window); + if (!window) return FALSE; + + return window->OnPropertyNotifyEvent(aWidget, aEvent); +} + +static gboolean scroll_event_cb(GtkWidget* widget, GdkEventScroll* event) { + nsWindow* window = GetFirstNSWindowForGDKWindow(event->window); + if (!window) return FALSE; + + window->OnScrollEvent(event); + + return TRUE; +} + +static void hierarchy_changed_cb(GtkWidget* widget, + GtkWidget* previous_toplevel) { + GtkWidget* toplevel = gtk_widget_get_toplevel(widget); + GdkWindowState old_window_state = GDK_WINDOW_STATE_WITHDRAWN; + GdkEventWindowState event; + + event.new_window_state = GDK_WINDOW_STATE_WITHDRAWN; + + if (GTK_IS_WINDOW(previous_toplevel)) { + g_signal_handlers_disconnect_by_func( + previous_toplevel, FuncToGpointer(window_state_event_cb), widget); + GdkWindow* win = gtk_widget_get_window(previous_toplevel); + if (win) { + old_window_state = gdk_window_get_state(win); + } + } + + if (GTK_IS_WINDOW(toplevel)) { + g_signal_connect_swapped(toplevel, "window-state-event", + G_CALLBACK(window_state_event_cb), widget); + GdkWindow* win = gtk_widget_get_window(toplevel); + if (win) { + event.new_window_state = gdk_window_get_state(win); + } + } + + event.changed_mask = + static_cast<GdkWindowState>(old_window_state ^ event.new_window_state); + + if (event.changed_mask) { + event.type = GDK_WINDOW_STATE; + event.window = nullptr; + event.send_event = TRUE; + window_state_event_cb(widget, &event); + } +} + +static gboolean window_state_event_cb(GtkWidget* widget, + GdkEventWindowState* event) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) return FALSE; + + window->OnWindowStateEvent(widget, event); + + return FALSE; +} + +static void settings_changed_cb(GtkSettings* settings, GParamSpec* pspec, + nsWindow* data) { + if (sIgnoreChangedSettings) { + return; + } + RefPtr<nsWindow> window = data; + window->ThemeChanged(); +} + +static void settings_xft_dpi_changed_cb(GtkSettings* gtk_settings, + GParamSpec* pspec, nsWindow* data) { + RefPtr<nsWindow> window = data; + window->OnDPIChanged(); + // Even though the window size in screen pixels has not changed, + // nsViewManager stores the dimensions in app units. + // DispatchResized() updates those. + window->DispatchResized(); +} + +static void check_resize_cb(GtkContainer* container, gpointer user_data) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(GTK_WIDGET(container)); + if (!window) { + return; + } + window->OnCheckResize(); +} + +static void screen_composited_changed_cb(GdkScreen* screen, + gpointer user_data) { + // This callback can run before gfxPlatform::Init() in rare + // cases involving the profile manager. When this happens, + // we have no reason to reset any compositors as graphics + // hasn't been initialized yet. + if (GPUProcessManager::Get()) { + GPUProcessManager::Get()->ResetCompositors(); + } +} + +static void widget_composited_changed_cb(GtkWidget* widget, + gpointer user_data) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) { + return; + } + window->OnCompositedChanged(); +} + +static void scale_changed_cb(GtkWidget* widget, GParamSpec* aPSpec, + gpointer aPointer) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(widget); + if (!window) { + return; + } + + GtkAllocation allocation; + gtk_widget_get_allocation(widget, &allocation); + window->OnScaleChanged(&allocation); +} + +static gboolean touch_event_cb(GtkWidget* aWidget, GdkEventTouch* aEvent) { + UpdateLastInputEventTime(aEvent); + + nsWindow* window = GetFirstNSWindowForGDKWindow(aEvent->window); + if (!window) { + return FALSE; + } + + return window->OnTouchEvent(aEvent); +} + +// This function called generic because there is no signal specific to touchpad +// pinch events. +static gboolean generic_event_cb(GtkWidget* widget, GdkEvent* aEvent) { + if (aEvent->type != GDK_TOUCHPAD_PINCH) { + return FALSE; + } + // Using reinterpret_cast because the touchpad_pinch field of GdkEvent is not + // available in GTK+ versions lower than v3.18 + GdkEventTouchpadPinch* event = + reinterpret_cast<GdkEventTouchpadPinch*>(aEvent); + + nsWindow* window = GetFirstNSWindowForGDKWindow(event->window); + + if (!window) { + return FALSE; + } + return window->OnTouchpadPinchEvent(event); +} + +////////////////////////////////////////////////////////////////////// +// These are all of our drag and drop operations + +void nsWindow::InitDragEvent(WidgetDragEvent& aEvent) { + // set the keyboard modifiers + guint modifierState = KeymapWrapper::GetCurrentModifierState(); + KeymapWrapper::InitInputEvent(aEvent, modifierState); +} + +gboolean WindowDragMotionHandler(GtkWidget* aWidget, + GdkDragContext* aDragContext, + nsWaylandDragContext* aWaylandDragContext, + gint aX, gint aY, guint aTime) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget); + if (!window) return FALSE; + + // figure out which internal widget this drag motion actually happened on + nscoord retx = 0; + nscoord rety = 0; + + GdkWindow* innerWindow = get_inner_gdk_window(gtk_widget_get_window(aWidget), + aX, aY, &retx, &rety); + RefPtr<nsWindow> innerMostWindow = get_window_for_gdk_window(innerWindow); + + if (!innerMostWindow) { + innerMostWindow = window; + } + + LOGDRAG(("nsWindow drag-motion signal for %p\n", (void*)innerMostWindow)); + + LayoutDeviceIntPoint point = window->GdkPointToDevicePixels({retx, rety}); + + RefPtr<nsDragService> dragService = nsDragService::GetInstance(); + return dragService->ScheduleMotionEvent(innerMostWindow, aDragContext, + aWaylandDragContext, point, aTime); +} + +static gboolean drag_motion_event_cb(GtkWidget* aWidget, + GdkDragContext* aDragContext, gint aX, + gint aY, guint aTime, gpointer aData) { + return WindowDragMotionHandler(aWidget, aDragContext, nullptr, aX, aY, aTime); +} + +void WindowDragLeaveHandler(GtkWidget* aWidget) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget); + if (!window) return; + + RefPtr<nsDragService> dragService = nsDragService::GetInstance(); + + nsWindow* mostRecentDragWindow = dragService->GetMostRecentDestWindow(); + if (!mostRecentDragWindow) { + // This can happen when the target will not accept a drop. A GTK drag + // source sends the leave message to the destination before the + // drag-failed signal on the source widget, but the leave message goes + // via the X server, and so doesn't get processed at least until the + // event loop runs again. + return; + } + + GtkWidget* mozContainer = mostRecentDragWindow->GetMozContainerWidget(); + if (aWidget != mozContainer) { + // When the drag moves between widgets, GTK can send leave signal for + // the old widget after the motion or drop signal for the new widget. + // We'll send the leave event when the motion or drop event is run. + return; + } + + LOGDRAG(("nsWindow drag-leave signal for %p\n", (void*)mostRecentDragWindow)); + + dragService->ScheduleLeaveEvent(); +} + +static void drag_leave_event_cb(GtkWidget* aWidget, + GdkDragContext* aDragContext, guint aTime, + gpointer aData) { + WindowDragLeaveHandler(aWidget); +} + +gboolean WindowDragDropHandler(GtkWidget* aWidget, GdkDragContext* aDragContext, + nsWaylandDragContext* aWaylandDragContext, + gint aX, gint aY, guint aTime) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget); + if (!window) return FALSE; + + // figure out which internal widget this drag motion actually happened on + nscoord retx = 0; + nscoord rety = 0; + + GdkWindow* innerWindow = get_inner_gdk_window(gtk_widget_get_window(aWidget), + aX, aY, &retx, &rety); + RefPtr<nsWindow> innerMostWindow = get_window_for_gdk_window(innerWindow); + + if (!innerMostWindow) { + innerMostWindow = window; + } + + LOGDRAG(("nsWindow drag-drop signal for %p\n", (void*)innerMostWindow)); + + LayoutDeviceIntPoint point = window->GdkPointToDevicePixels({retx, rety}); + + RefPtr<nsDragService> dragService = nsDragService::GetInstance(); + return dragService->ScheduleDropEvent(innerMostWindow, aDragContext, + aWaylandDragContext, point, aTime); +} + +static gboolean drag_drop_event_cb(GtkWidget* aWidget, + GdkDragContext* aDragContext, gint aX, + gint aY, guint aTime, gpointer aData) { + return WindowDragDropHandler(aWidget, aDragContext, nullptr, aX, aY, aTime); +} + +static void drag_data_received_event_cb(GtkWidget* aWidget, + GdkDragContext* aDragContext, gint aX, + gint aY, + GtkSelectionData* aSelectionData, + guint aInfo, guint aTime, + gpointer aData) { + RefPtr<nsWindow> window = get_window_for_gtk_widget(aWidget); + if (!window) return; + + window->OnDragDataReceivedEvent(aWidget, aDragContext, aX, aY, aSelectionData, + aInfo, aTime, aData); +} + +static nsresult initialize_prefs(void) { + gRaiseWindows = + Preferences::GetBool("mozilla.widget.raise-on-setfocus", true); + gUseWaylandVsync = + Preferences::GetBool("widget.wayland_vsync.enabled", false); + gUseWaylandUseOpaqueRegion = + Preferences::GetBool("widget.wayland.use-opaque-region", false); + + if (Preferences::HasUserValue("widget.use-aspect-ratio")) { + gUseAspectRatio = Preferences::GetBool("widget.use-aspect-ratio", true); + } else { + static const char* currentDesktop = getenv("XDG_CURRENT_DESKTOP"); + gUseAspectRatio = + currentDesktop ? (strstr(currentDesktop, "GNOME") != nullptr) : false; + } + + return NS_OK; +} + +static GdkWindow* get_inner_gdk_window(GdkWindow* aWindow, gint x, gint y, + gint* retx, gint* rety) { + gint cx, cy, cw, ch; + GList* children = gdk_window_peek_children(aWindow); + for (GList* child = g_list_last(children); child; + child = g_list_previous(child)) { + auto* childWindow = (GdkWindow*)child->data; + if (get_window_for_gdk_window(childWindow)) { + gdk_window_get_geometry(childWindow, &cx, &cy, &cw, &ch); + if ((cx < x) && (x < (cx + cw)) && (cy < y) && (y < (cy + ch)) && + gdk_window_is_visible(childWindow)) { + return get_inner_gdk_window(childWindow, x - cx, y - cy, retx, rety); + } + } + } + *retx = x; + *rety = y; + return aWindow; +} + +static int is_parent_ungrab_enter(GdkEventCrossing* aEvent) { + return (GDK_CROSSING_UNGRAB == aEvent->mode) && + ((GDK_NOTIFY_ANCESTOR == aEvent->detail) || + (GDK_NOTIFY_VIRTUAL == aEvent->detail)); +} + +static int is_parent_grab_leave(GdkEventCrossing* aEvent) { + return (GDK_CROSSING_GRAB == aEvent->mode) && + ((GDK_NOTIFY_ANCESTOR == aEvent->detail) || + (GDK_NOTIFY_VIRTUAL == aEvent->detail)); +} + +#ifdef ACCESSIBILITY +void nsWindow::CreateRootAccessible() { + if (mIsTopLevel && !mRootAccessible) { + LOG(("nsWindow:: Create Toplevel Accessibility\n")); + mRootAccessible = GetRootAccessible(); + } +} + +void nsWindow::DispatchEventToRootAccessible(uint32_t aEventType) { + if (!a11y::ShouldA11yBeEnabled()) { + return; + } + + nsAccessibilityService* accService = GetOrCreateAccService(); + if (!accService) { + return; + } + + // Get the root document accessible and fire event to it. + a11y::Accessible* acc = GetRootAccessible(); + if (acc) { + accService->FireAccessibleEvent(aEventType, acc); + } +} + +void nsWindow::DispatchActivateEventAccessible(void) { + DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_ACTIVATE); +} + +void nsWindow::DispatchDeactivateEventAccessible(void) { + DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_DEACTIVATE); +} + +void nsWindow::DispatchMaximizeEventAccessible(void) { + DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_MAXIMIZE); +} + +void nsWindow::DispatchMinimizeEventAccessible(void) { + DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_MINIMIZE); +} + +void nsWindow::DispatchRestoreEventAccessible(void) { + DispatchEventToRootAccessible(nsIAccessibleEvent::EVENT_WINDOW_RESTORE); +} + +#endif /* #ifdef ACCESSIBILITY */ + +void nsWindow::SetInputContext(const InputContext& aContext, + const InputContextAction& aAction) { + if (!mIMContext) { + return; + } + mIMContext->SetInputContext(this, &aContext, &aAction); +} + +InputContext nsWindow::GetInputContext() { + InputContext context; + if (!mIMContext) { + context.mIMEState.mEnabled = IMEEnabled::Disabled; + context.mIMEState.mOpen = IMEState::OPEN_STATE_NOT_SUPPORTED; + } else { + context = mIMContext->GetInputContext(); + } + return context; +} + +TextEventDispatcherListener* nsWindow::GetNativeTextEventDispatcherListener() { + if (NS_WARN_IF(!mIMContext)) { + return nullptr; + } + return mIMContext; +} + +void nsWindow::GetEditCommandsRemapped(NativeKeyBindingsType aType, + const WidgetKeyboardEvent& aEvent, + nsTArray<CommandInt>& aCommands, + uint32_t aGeckoKeyCode, + uint32_t aNativeKeyCode) { + // If aEvent.mNativeKeyEvent is nullptr, the event was created by chrome + // script. In such case, we shouldn't expose the OS settings to it. + // So, just ignore such events here. + if (!aEvent.mNativeKeyEvent) { + return; + } + WidgetKeyboardEvent modifiedEvent(aEvent); + modifiedEvent.mKeyCode = aGeckoKeyCode; + static_cast<GdkEventKey*>(modifiedEvent.mNativeKeyEvent)->keyval = + aNativeKeyCode; + + NativeKeyBindings* keyBindings = NativeKeyBindings::GetInstance(aType); + keyBindings->GetEditCommands(modifiedEvent, aCommands); +} + +bool nsWindow::GetEditCommands(NativeKeyBindingsType aType, + const WidgetKeyboardEvent& aEvent, + nsTArray<CommandInt>& aCommands) { + // Validate the arguments. + if (NS_WARN_IF(!nsIWidget::GetEditCommands(aType, aEvent, aCommands))) { + return false; + } + + if (aEvent.mKeyCode >= NS_VK_LEFT && aEvent.mKeyCode <= NS_VK_DOWN) { + // Check if we're targeting content with vertical writing mode, + // and if so remap the arrow keys. + // XXX This may be expensive. + WidgetQueryContentEvent querySelectedTextEvent(true, eQuerySelectedText, + this); + nsEventStatus status; + DispatchEvent(&querySelectedTextEvent, status); + + if (querySelectedTextEvent.FoundSelection() && + querySelectedTextEvent.mReply->mWritingMode.IsVertical()) { + uint32_t geckoCode = 0; + uint32_t gdkCode = 0; + switch (aEvent.mKeyCode) { + case NS_VK_LEFT: + if (querySelectedTextEvent.mReply->mWritingMode.IsVerticalLR()) { + geckoCode = NS_VK_UP; + gdkCode = GDK_Up; + } else { + geckoCode = NS_VK_DOWN; + gdkCode = GDK_Down; + } + break; + + case NS_VK_RIGHT: + if (querySelectedTextEvent.mReply->mWritingMode.IsVerticalLR()) { + geckoCode = NS_VK_DOWN; + gdkCode = GDK_Down; + } else { + geckoCode = NS_VK_UP; + gdkCode = GDK_Up; + } + break; + + case NS_VK_UP: + geckoCode = NS_VK_LEFT; + gdkCode = GDK_Left; + break; + + case NS_VK_DOWN: + geckoCode = NS_VK_RIGHT; + gdkCode = GDK_Right; + break; + } + + GetEditCommandsRemapped(aType, aEvent, aCommands, geckoCode, gdkCode); + return true; + } + } + + NativeKeyBindings* keyBindings = NativeKeyBindings::GetInstance(aType); + keyBindings->GetEditCommands(aEvent, aCommands); + return true; +} + +already_AddRefed<DrawTarget> nsWindow::StartRemoteDrawingInRegion( + LayoutDeviceIntRegion& aInvalidRegion, BufferMode* aBufferMode) { + return mSurfaceProvider.StartRemoteDrawingInRegion(aInvalidRegion, + aBufferMode); +} + +void nsWindow::EndRemoteDrawingInRegion( + DrawTarget* aDrawTarget, const LayoutDeviceIntRegion& aInvalidRegion) { + mSurfaceProvider.EndRemoteDrawingInRegion(aDrawTarget, aInvalidRegion); +} + +// Code shared begin BeginMoveDrag and BeginResizeDrag +bool nsWindow::GetDragInfo(WidgetMouseEvent* aMouseEvent, GdkWindow** aWindow, + gint* aButton, gint* aRootX, gint* aRootY) { + if (aMouseEvent->mButton != MouseButton::ePrimary) { + // we can only begin a move drag with the left mouse button + return false; + } + *aButton = 1; + + // get the gdk window for this widget + GdkWindow* gdk_window = mGdkWindow; + if (!gdk_window) { + return false; + } +#ifdef DEBUG + // GDK_IS_WINDOW(...) expands to a statement-expression, and + // statement-expressions are not allowed in template-argument lists. So we + // have to make the MOZ_ASSERT condition indirect. + if (!GDK_IS_WINDOW(gdk_window)) { + MOZ_ASSERT(false, "must really be window"); + } +#endif + + // find the top-level window + gdk_window = gdk_window_get_toplevel(gdk_window); + MOZ_ASSERT(gdk_window, "gdk_window_get_toplevel should not return null"); + *aWindow = gdk_window; + + if (!aMouseEvent->mWidget) { + return false; + } + + if (mIsX11Display) { + // Workaround for https://bugzilla.gnome.org/show_bug.cgi?id=789054 + // To avoid crashes disable double-click on WM without _NET_WM_MOVERESIZE. + // See _should_perform_ewmh_drag() at gdkwindow-x11.c + GdkScreen* screen = gdk_window_get_screen(gdk_window); + GdkAtom atom = gdk_atom_intern("_NET_WM_MOVERESIZE", FALSE); + if (!gdk_x11_screen_supports_net_wm_hint(screen, atom)) { + static unsigned int lastTimeStamp = 0; + if (lastTimeStamp != aMouseEvent->mTime) { + lastTimeStamp = aMouseEvent->mTime; + } else { + return false; + } + } + } + + // FIXME: It would be nice to have the widget position at the time + // of the event, but it's relatively unlikely that the widget has + // moved since the mousedown. (On the other hand, it's quite likely + // that the mouse has moved, which is why we use the mouse position + // from the event.) + LayoutDeviceIntPoint offset = aMouseEvent->mWidget->WidgetToScreenOffset(); + *aRootX = aMouseEvent->mRefPoint.x + offset.x; + *aRootY = aMouseEvent->mRefPoint.y + offset.y; + + return true; +} + +nsresult nsWindow::BeginResizeDrag(WidgetGUIEvent* aEvent, int32_t aHorizontal, + int32_t aVertical) { + NS_ENSURE_ARG_POINTER(aEvent); + + if (aEvent->mClass != eMouseEventClass) { + // you can only begin a resize drag with a mouse event + return NS_ERROR_INVALID_ARG; + } + + GdkWindow* gdk_window; + gint button, screenX, screenY; + if (!GetDragInfo(aEvent->AsMouseEvent(), &gdk_window, &button, &screenX, + &screenY)) { + return NS_ERROR_FAILURE; + } + + // work out what GdkWindowEdge we're talking about + GdkWindowEdge window_edge; + if (aVertical < 0) { + if (aHorizontal < 0) { + window_edge = GDK_WINDOW_EDGE_NORTH_WEST; + } else if (aHorizontal == 0) { + window_edge = GDK_WINDOW_EDGE_NORTH; + } else { + window_edge = GDK_WINDOW_EDGE_NORTH_EAST; + } + } else if (aVertical == 0) { + if (aHorizontal < 0) { + window_edge = GDK_WINDOW_EDGE_WEST; + } else if (aHorizontal == 0) { + return NS_ERROR_INVALID_ARG; + } else { + window_edge = GDK_WINDOW_EDGE_EAST; + } + } else { + if (aHorizontal < 0) { + window_edge = GDK_WINDOW_EDGE_SOUTH_WEST; + } else if (aHorizontal == 0) { + window_edge = GDK_WINDOW_EDGE_SOUTH; + } else { + window_edge = GDK_WINDOW_EDGE_SOUTH_EAST; + } + } + + // tell the window manager to start the resize + gdk_window_begin_resize_drag(gdk_window, window_edge, button, screenX, + screenY, aEvent->mTime); + + return NS_OK; +} + +nsIWidget::LayerManager* nsWindow::GetLayerManager( + PLayerTransactionChild* aShadowManager, LayersBackend aBackendHint, + LayerManagerPersistence aPersistence) { + if (mIsDestroyed) { + // Prevent external code from triggering the re-creation of the + // LayerManager/Compositor during shutdown. Just return what we currently + // have, which is most likely null. + return mLayerManager; + } + + return nsBaseWidget::GetLayerManager(aShadowManager, aBackendHint, + aPersistence); +} + +void nsWindow::SetCompositorWidgetDelegate(CompositorWidgetDelegate* delegate) { + if (delegate) { + mCompositorWidgetDelegate = delegate->AsPlatformSpecificDelegate(); + MOZ_ASSERT(mCompositorWidgetDelegate, + "nsWindow::SetCompositorWidgetDelegate called with a " + "non-PlatformCompositorWidgetDelegate"); +#ifdef MOZ_WAYLAND + MaybeResumeCompositor(); +#endif + } else { + mCompositorWidgetDelegate = nullptr; + } +} + +void nsWindow::ClearCachedResources() { + if (mLayerManager && mLayerManager->GetBackendType() == + mozilla::layers::LayersBackend::LAYERS_BASIC) { + mLayerManager->ClearCachedResources(); + } + + GList* children = gdk_window_peek_children(mGdkWindow); + for (GList* list = children; list; list = list->next) { + nsWindow* window = get_window_for_gdk_window(GDK_WINDOW(list->data)); + if (window) { + window->ClearCachedResources(); + } + } +} + +/* nsWindow::UpdateClientOffsetFromCSDWindow() is designed to be called from + * nsWindow::OnConfigureEvent() when mContainer window is already positioned. + * + * It works only for CSD decorated GtkWindow. + */ +void nsWindow::UpdateClientOffsetFromCSDWindow() { + int x, y; + gdk_window_get_position(mGdkWindow, &x, &y); + + x = GdkCoordToDevicePixels(x); + y = GdkCoordToDevicePixels(y); + + if (mClientOffset.x != x || mClientOffset.y != y) { + mClientOffset = nsIntPoint(x, y); + + LOG(("nsWindow::UpdateClientOffsetFromCSDWindow [%p] %d, %d\n", (void*)this, + mClientOffset.x, mClientOffset.y)); + + // Send a WindowMoved notification. This ensures that BrowserParent + // picks up the new client offset and sends it to the child process + // if appropriate. + NotifyWindowMoved(mBounds.x, mBounds.y); + } +} + +nsresult nsWindow::SetNonClientMargins(LayoutDeviceIntMargin& aMargins) { + SetDrawsInTitlebar(aMargins.top == 0); + return NS_OK; +} + +void nsWindow::SetDrawsInTitlebar(bool aState) { + LOG(("nsWindow::SetDrawsInTitlebar() [%p] State %d mCSDSupportLevel %d\n", + (void*)this, aState, (int)mCSDSupportLevel)); + + if (!mShell || mCSDSupportLevel == CSD_SUPPORT_NONE || + aState == mDrawInTitlebar) { + return; + } + + if (mCSDSupportLevel == CSD_SUPPORT_SYSTEM) { + SetWindowDecoration(aState ? eBorderStyle_border : mBorderStyle); + } else if (mCSDSupportLevel == CSD_SUPPORT_CLIENT) { + LOG((" Using CSD mode\n")); + + /* Window manager does not support GDK_DECOR_BORDER, + * emulate it by CSD. + * + * gtk_window_set_titlebar() works on unrealized widgets only, + * we need to handle mShell carefully here. + * When CSD is enabled mGdkWindow is owned by mContainer which is good + * as we can't delete our mGdkWindow. To make mShell unrealized while + * mContainer is preserved we temporary reparent mContainer to an + * invisible GtkWindow. + */ + NativeShow(false); + + // Using GTK_WINDOW_POPUP rather than + // GTK_WINDOW_TOPLEVEL in the hope that POPUP results in less + // initialization and window manager interaction. + GtkWidget* tmpWindow = gtk_window_new(GTK_WINDOW_POPUP); + gtk_widget_realize(tmpWindow); + + gtk_widget_reparent(GTK_WIDGET(mContainer), tmpWindow); + gtk_widget_unrealize(GTK_WIDGET(mShell)); + + if (aState) { + // Add a hidden titlebar widget to trigger CSD, but disable the default + // titlebar. GtkFixed is a somewhat random choice for a simple unused + // widget. gtk_window_set_titlebar() takes ownership of the titlebar + // widget. + gtk_window_set_titlebar(GTK_WINDOW(mShell), gtk_fixed_new()); + } else { + gtk_window_set_titlebar(GTK_WINDOW(mShell), nullptr); + } + + /* A workaround for https://bugzilla.gnome.org/show_bug.cgi?id=791081 + * gtk_widget_realize() throws: + * "In pixman_region32_init_rect: Invalid rectangle passed" + * when mShell has default 1x1 size. + */ + GtkAllocation allocation = {0, 0, 0, 0}; + gtk_widget_get_preferred_width(GTK_WIDGET(mShell), nullptr, + &allocation.width); + gtk_widget_get_preferred_height(GTK_WIDGET(mShell), nullptr, + &allocation.height); + gtk_widget_size_allocate(GTK_WIDGET(mShell), &allocation); + + gtk_widget_realize(GTK_WIDGET(mShell)); + gtk_widget_reparent(GTK_WIDGET(mContainer), GTK_WIDGET(mShell)); + mNeedsShow = true; + NativeResize(); + + // Label mShell toplevel window so property_notify_event_cb callback + // can find its way home. + g_object_set_data(G_OBJECT(gtk_widget_get_window(mShell)), "nsWindow", + this); +#ifdef MOZ_X11 + SetCompositorHint(GTK_WIDGET_COMPOSIDED_ENABLED); +#endif + RefreshWindowClass(); + + gtk_widget_destroy(tmpWindow); + } + + mDrawInTitlebar = aState; + + if (mTransparencyBitmapForTitlebar) { + if (mDrawInTitlebar && mSizeState == nsSizeMode_Normal && !mIsTiled) { + UpdateTitlebarTransparencyBitmap(); + } else { + ClearTransparencyBitmap(); + } + } +} + +GtkWindow* nsWindow::GetCurrentTopmostWindow() { + GtkWindow* parentWindow = GTK_WINDOW(GetGtkWidget()); + GtkWindow* topmostParentWindow = nullptr; + while (parentWindow) { + topmostParentWindow = parentWindow; + parentWindow = gtk_window_get_transient_for(parentWindow); + } + return topmostParentWindow; +} + +gint nsWindow::GdkScaleFactor() { + // We depend on notify::scale-factor callback which is reliable for toplevel + // windows only, so don't use scale cache for popup windows. + if (mWindowType == eWindowType_toplevel && !mWindowScaleFactorChanged) { + return mWindowScaleFactor; + } + + GdkWindow* scaledGdkWindow = mGdkWindow; + if (!mIsX11Display) { + // For popup windows/dialogs with parent window we need to get scale factor + // of the topmost window. Otherwise the scale factor of the popup is + // not updated during it's hidden. + if (mWindowType == eWindowType_popup || mWindowType == eWindowType_dialog) { + // Get toplevel window for scale factor: + GtkWindow* topmostParentWindow = GetCurrentTopmostWindow(); + if (topmostParentWindow) { + scaledGdkWindow = + gtk_widget_get_window(GTK_WIDGET(topmostParentWindow)); + } else { + NS_WARNING("Popup/Dialog has no parent."); + } + // Fallback for windows which parent has been unrealized. + if (!scaledGdkWindow) { + scaledGdkWindow = mGdkWindow; + } + } + } + + // Available as of GTK 3.10+ + static auto sGdkWindowGetScaleFactorPtr = + (gint(*)(GdkWindow*))dlsym(RTLD_DEFAULT, "gdk_window_get_scale_factor"); + if (sGdkWindowGetScaleFactorPtr && scaledGdkWindow) { + mWindowScaleFactor = (*sGdkWindowGetScaleFactorPtr)(scaledGdkWindow); + mWindowScaleFactorChanged = false; + } else { + mWindowScaleFactor = ScreenHelperGTK::GetGTKMonitorScaleFactor(); + } + + return mWindowScaleFactor; +} + +gint nsWindow::DevicePixelsToGdkCoordRoundUp(int pixels) { + gint scale = GdkScaleFactor(); + return (pixels + scale - 1) / scale; +} + +gint nsWindow::DevicePixelsToGdkCoordRoundDown(int pixels) { + gint scale = GdkScaleFactor(); + return pixels / scale; +} + +GdkPoint nsWindow::DevicePixelsToGdkPointRoundDown(LayoutDeviceIntPoint point) { + gint scale = GdkScaleFactor(); + return {point.x / scale, point.y / scale}; +} + +GdkRectangle nsWindow::DevicePixelsToGdkRectRoundOut(LayoutDeviceIntRect rect) { + gint scale = GdkScaleFactor(); + int x = rect.x / scale; + int y = rect.y / scale; + int right = (rect.x + rect.width + scale - 1) / scale; + int bottom = (rect.y + rect.height + scale - 1) / scale; + return {x, y, right - x, bottom - y}; +} + +GdkRectangle nsWindow::DevicePixelsToGdkSizeRoundUp( + LayoutDeviceIntSize pixelSize) { + gint scale = GdkScaleFactor(); + gint width = (pixelSize.width + scale - 1) / scale; + gint height = (pixelSize.height + scale - 1) / scale; + return {0, 0, width, height}; +} + +int nsWindow::GdkCoordToDevicePixels(gint coord) { + return coord * GdkScaleFactor(); +} + +LayoutDeviceIntPoint nsWindow::GdkEventCoordsToDevicePixels(gdouble x, + gdouble y) { + gint scale = GdkScaleFactor(); + return LayoutDeviceIntPoint::Round(x * scale, y * scale); +} + +LayoutDeviceIntPoint nsWindow::GdkPointToDevicePixels(GdkPoint point) { + gint scale = GdkScaleFactor(); + return LayoutDeviceIntPoint(point.x * scale, point.y * scale); +} + +LayoutDeviceIntRect nsWindow::GdkRectToDevicePixels(GdkRectangle rect) { + gint scale = GdkScaleFactor(); + return LayoutDeviceIntRect(rect.x * scale, rect.y * scale, rect.width * scale, + rect.height * scale); +} + +nsresult nsWindow::SynthesizeNativeMouseEvent(LayoutDeviceIntPoint aPoint, + uint32_t aNativeMessage, + uint32_t aModifierFlags, + nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "mouseevent"); + + if (!mGdkWindow) { + return NS_OK; + } + + GdkDisplay* display = gdk_window_get_display(mGdkWindow); + + // When a button-press/release event is requested, create it here and put it + // in the event queue. This will not emit a motion event - this needs to be + // done explicitly *before* requesting a button-press/release. You will also + // need to wait for the motion event to be dispatched before requesting a + // button-press/release event to maintain the desired event order. + if (aNativeMessage == GDK_BUTTON_PRESS || + aNativeMessage == GDK_BUTTON_RELEASE) { + GdkEvent event; + memset(&event, 0, sizeof(GdkEvent)); + event.type = (GdkEventType)aNativeMessage; + event.button.button = 1; + event.button.window = mGdkWindow; + event.button.time = GDK_CURRENT_TIME; + + // Get device for event source + GdkDeviceManager* device_manager = gdk_display_get_device_manager(display); + event.button.device = gdk_device_manager_get_client_pointer(device_manager); + + event.button.x_root = DevicePixelsToGdkCoordRoundDown(aPoint.x); + event.button.y_root = DevicePixelsToGdkCoordRoundDown(aPoint.y); + + LayoutDeviceIntPoint pointInWindow = aPoint - WidgetToScreenOffset(); + event.button.x = DevicePixelsToGdkCoordRoundDown(pointInWindow.x); + event.button.y = DevicePixelsToGdkCoordRoundDown(pointInWindow.y); + + gdk_event_put(&event); + } else { + // We don't support specific events other than button-press/release. In all + // other cases we'll synthesize a motion event that will be emitted by + // gdk_display_warp_pointer(). + GdkScreen* screen = gdk_window_get_screen(mGdkWindow); + GdkPoint point = DevicePixelsToGdkPointRoundDown(aPoint); + gdk_display_warp_pointer(display, screen, point.x, point.y); + } + + return NS_OK; +} + +nsresult nsWindow::SynthesizeNativeMouseScrollEvent( + mozilla::LayoutDeviceIntPoint aPoint, uint32_t aNativeMessage, + double aDeltaX, double aDeltaY, double aDeltaZ, uint32_t aModifierFlags, + uint32_t aAdditionalFlags, nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "mousescrollevent"); + + if (!mGdkWindow) { + return NS_OK; + } + + GdkEvent event; + memset(&event, 0, sizeof(GdkEvent)); + event.type = GDK_SCROLL; + event.scroll.window = mGdkWindow; + event.scroll.time = GDK_CURRENT_TIME; + // Get device for event source + GdkDisplay* display = gdk_window_get_display(mGdkWindow); + GdkDeviceManager* device_manager = gdk_display_get_device_manager(display); + event.scroll.device = gdk_device_manager_get_client_pointer(device_manager); + event.scroll.x_root = DevicePixelsToGdkCoordRoundDown(aPoint.x); + event.scroll.y_root = DevicePixelsToGdkCoordRoundDown(aPoint.y); + + LayoutDeviceIntPoint pointInWindow = aPoint - WidgetToScreenOffset(); + event.scroll.x = DevicePixelsToGdkCoordRoundDown(pointInWindow.x); + event.scroll.y = DevicePixelsToGdkCoordRoundDown(pointInWindow.y); + + // The delta values are backwards on Linux compared to Windows and Cocoa, + // hence the negation. + event.scroll.direction = GDK_SCROLL_SMOOTH; + event.scroll.delta_x = -aDeltaX; + event.scroll.delta_y = -aDeltaY; + + gdk_event_put(&event); + + return NS_OK; +} + +nsresult nsWindow::SynthesizeNativeTouchPoint(uint32_t aPointerId, + TouchPointerState aPointerState, + LayoutDeviceIntPoint aPoint, + double aPointerPressure, + uint32_t aPointerOrientation, + nsIObserver* aObserver) { + AutoObserverNotifier notifier(aObserver, "touchpoint"); + + if (!mGdkWindow) { + return NS_OK; + } + + GdkEvent event; + memset(&event, 0, sizeof(GdkEvent)); + + static std::map<uint32_t, GdkEventSequence*> sKnownPointers; + + auto result = sKnownPointers.find(aPointerId); + switch (aPointerState) { + case TOUCH_CONTACT: + if (result == sKnownPointers.end()) { + // GdkEventSequence isn't a thing we can instantiate, and never gets + // dereferenced in the gtk code. It's an opaque pointer, the only + // requirement is that it be distinct from other instances of + // GdkEventSequence*. + event.touch.sequence = (GdkEventSequence*)((uintptr_t)aPointerId); + sKnownPointers[aPointerId] = event.touch.sequence; + event.type = GDK_TOUCH_BEGIN; + } else { + event.touch.sequence = result->second; + event.type = GDK_TOUCH_UPDATE; + } + break; + case TOUCH_REMOVE: + event.type = GDK_TOUCH_END; + if (result == sKnownPointers.end()) { + NS_WARNING("Tried to synthesize touch-end for unknown pointer!"); + return NS_ERROR_UNEXPECTED; + } + event.touch.sequence = result->second; + sKnownPointers.erase(result); + break; + case TOUCH_CANCEL: + event.type = GDK_TOUCH_CANCEL; + if (result == sKnownPointers.end()) { + NS_WARNING("Tried to synthesize touch-cancel for unknown pointer!"); + return NS_ERROR_UNEXPECTED; + } + event.touch.sequence = result->second; + sKnownPointers.erase(result); + break; + case TOUCH_HOVER: + default: + return NS_ERROR_NOT_IMPLEMENTED; + } + + event.touch.window = mGdkWindow; + event.touch.time = GDK_CURRENT_TIME; + + GdkDisplay* display = gdk_window_get_display(mGdkWindow); + GdkDeviceManager* device_manager = gdk_display_get_device_manager(display); + event.touch.device = gdk_device_manager_get_client_pointer(device_manager); + + event.touch.x_root = DevicePixelsToGdkCoordRoundDown(aPoint.x); + event.touch.y_root = DevicePixelsToGdkCoordRoundDown(aPoint.y); + + LayoutDeviceIntPoint pointInWindow = aPoint - WidgetToScreenOffset(); + event.touch.x = DevicePixelsToGdkCoordRoundDown(pointInWindow.x); + event.touch.y = DevicePixelsToGdkCoordRoundDown(pointInWindow.y); + + gdk_event_put(&event); + + return NS_OK; +} + +nsWindow::CSDSupportLevel nsWindow::GetSystemCSDSupportLevel(bool aIsPopup) { + if (sCSDSupportLevel != CSD_SUPPORT_UNKNOWN) { + return sCSDSupportLevel; + } + + // Allow MOZ_GTK_TITLEBAR_DECORATION to override our heuristics + const char* decorationOverride = getenv("MOZ_GTK_TITLEBAR_DECORATION"); + if (decorationOverride) { + if (strcmp(decorationOverride, "none") == 0) { + sCSDSupportLevel = CSD_SUPPORT_NONE; + } else if (strcmp(decorationOverride, "client") == 0) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + } else if (strcmp(decorationOverride, "system") == 0) { + sCSDSupportLevel = CSD_SUPPORT_SYSTEM; + } + return sCSDSupportLevel; + } + + // nsWindow::GetSystemCSDSupportLevel can be called from various threads + // so we can't use gfxPlatformGtk here. + if (!GDK_IS_X11_DISPLAY(gdk_display_get_default())) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + return sCSDSupportLevel; + } + + const char* currentDesktop = getenv("XDG_CURRENT_DESKTOP"); + if (currentDesktop) { + // GNOME Flashback (fallback) + if (strstr(currentDesktop, "GNOME-Flashback:GNOME") != nullptr) { + sCSDSupportLevel = aIsPopup ? CSD_SUPPORT_CLIENT : CSD_SUPPORT_SYSTEM; + // Pop Linux Bug 1629198 + } else if (strstr(currentDesktop, "pop:GNOME") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + // gnome-shell + } else if (strstr(currentDesktop, "GNOME") != nullptr) { + sCSDSupportLevel = aIsPopup ? CSD_SUPPORT_CLIENT : CSD_SUPPORT_SYSTEM; + } else if (strstr(currentDesktop, "XFCE") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + } else if (strstr(currentDesktop, "X-Cinnamon") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_SYSTEM; + // KDE Plasma + } else if (strstr(currentDesktop, "KDE") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + } else if (strstr(currentDesktop, "Enlightenment") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + } else if (strstr(currentDesktop, "LXDE") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + } else if (strstr(currentDesktop, "openbox") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + } else if (strstr(currentDesktop, "i3") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_NONE; + } else if (strstr(currentDesktop, "MATE") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + // Ubuntu Unity + } else if (strstr(currentDesktop, "Unity") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_SYSTEM; + // Elementary OS + } else if (strstr(currentDesktop, "Pantheon") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_SYSTEM; + } else if (strstr(currentDesktop, "LXQt") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_SYSTEM; + } else if (strstr(currentDesktop, "Deepin") != nullptr) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + } else { +// Release or beta builds are not supposed to be broken +// so disable titlebar rendering on untested/unknown systems. +#if defined(RELEASE_OR_BETA) + sCSDSupportLevel = CSD_SUPPORT_NONE; +#else + sCSDSupportLevel = CSD_SUPPORT_CLIENT; +#endif + } + } else { + sCSDSupportLevel = CSD_SUPPORT_NONE; + } + + // GTK_CSD forces CSD mode - use also CSD because window manager + // decorations does not work with CSD. + // We check GTK_CSD as well as gtk_window_should_use_csd() does. + if (sCSDSupportLevel == CSD_SUPPORT_SYSTEM) { + const char* csdOverride = getenv("GTK_CSD"); + if (csdOverride && g_strcmp0(csdOverride, "1") == 0) { + sCSDSupportLevel = CSD_SUPPORT_CLIENT; + } + } + + return sCSDSupportLevel; +} + +bool nsWindow::TitlebarUseShapeMask() { + static int useShapeMask = []() { + // Don't use titlebar shape mask on Wayland + if (!gfxPlatformGtk::GetPlatform()->IsX11Display()) { + return false; + } + + // We can'y use shape masks on Mutter/X.org as we can't resize Firefox + // window there (Bug 1530252). + const char* currentDesktop = getenv("XDG_CURRENT_DESKTOP"); + if (currentDesktop) { + if (strstr(currentDesktop, "GNOME") != nullptr) { + const char* sessionType = getenv("XDG_SESSION_TYPE"); + if (sessionType && strstr(sessionType, "x11") != nullptr) { + return false; + } + } + } + + return Preferences::GetBool("widget.titlebar-x11-use-shape-mask", false); + }(); + return useShapeMask; +} + +bool nsWindow::HideTitlebarByDefault() { + static int hideTitlebar = []() { + // When user defined widget.default-hidden-titlebar don't do any + // heuristics and just follow it. + if (Preferences::HasUserValue("widget.default-hidden-titlebar")) { + return Preferences::GetBool("widget.default-hidden-titlebar", false); + } + + // Don't hide titlebar when it's disabled on current desktop. + const char* currentDesktop = getenv("XDG_CURRENT_DESKTOP"); + if (!currentDesktop || GetSystemCSDSupportLevel() == CSD_SUPPORT_NONE) { + return false; + } + + // We hide system titlebar on Gnome/ElementaryOS without any restriction. + return ((strstr(currentDesktop, "GNOME-Flashback:GNOME") != nullptr || + strstr(currentDesktop, "GNOME") != nullptr || + strstr(currentDesktop, "Pantheon") != nullptr)); + }(); + return hideTitlebar; +} + +int32_t nsWindow::RoundsWidgetCoordinatesTo() { return GdkScaleFactor(); } + +void nsWindow::GetCompositorWidgetInitData( + mozilla::widget::CompositorWidgetInitData* aInitData) { + // Make sure the window XID is propagated to X server, we can fail otherwise + // in GPU process (Bug 1401634). + if (mXDisplay && mXWindow != X11None) { + XFlush(mXDisplay); + } + + bool isShaped = + mIsTransparent && !mHasAlphaVisual && !mTransparencyBitmapForTitlebar; + *aInitData = mozilla::widget::GtkCompositorWidgetInitData( + (mXWindow != X11None) ? mXWindow : (uintptr_t) nullptr, + mXDisplay ? nsCString(XDisplayString(mXDisplay)) : nsCString(), isShaped, + mIsX11Display, GetClientSize()); +} + +#ifdef MOZ_WAYLAND +bool nsWindow::WaylandSurfaceNeedsClear() { + if (mContainer) { + return moz_container_wayland_surface_needs_clear(MOZ_CONTAINER(mContainer)); + } + return false; +} +#endif + +#ifdef MOZ_X11 +/* XApp progress support currently works by setting a property + * on a window with this Atom name. A supporting window manager + * will notice this and pass it along to whatever handling has + * been implemented on that end (e.g. passing it on to a taskbar + * widget.) There is no issue if WM support is lacking, this is + * simply ignored in that case. + * + * See https://github.com/linuxmint/xapps/blob/master/libxapp/xapp-gtk-window.c + * for further details. + */ + +# define PROGRESS_HINT "_NET_WM_XAPP_PROGRESS" + +static void set_window_hint_cardinal(Window xid, const gchar* atom_name, + gulong cardinal) { + GdkDisplay* display; + + display = gdk_display_get_default(); + + if (cardinal > 0) { + XChangeProperty(GDK_DISPLAY_XDISPLAY(display), xid, + gdk_x11_get_xatom_by_name_for_display(display, atom_name), + XA_CARDINAL, 32, PropModeReplace, (guchar*)&cardinal, 1); + } else { + XDeleteProperty(GDK_DISPLAY_XDISPLAY(display), xid, + gdk_x11_get_xatom_by_name_for_display(display, atom_name)); + } +} +#endif // MOZ_X11 + +void nsWindow::SetProgress(unsigned long progressPercent) { +#ifdef MOZ_X11 + + if (!mIsX11Display) { + return; + } + + if (!mShell) { + return; + } + + progressPercent = MIN(progressPercent, 100); + + set_window_hint_cardinal(GDK_WINDOW_XID(gtk_widget_get_window(mShell)), + PROGRESS_HINT, progressPercent); +#endif // MOZ_X11 +} + +#ifdef MOZ_X11 +void nsWindow::SetCompositorHint(WindowComposeRequest aState) { + if (!mIsX11Display) { + return; + } + + gulong value = aState; + GdkAtom cardinal_atom = gdk_x11_xatom_to_atom(XA_CARDINAL); + gdk_property_change(gtk_widget_get_window(mShell), + gdk_atom_intern("_NET_WM_BYPASS_COMPOSITOR", FALSE), + cardinal_atom, + 32, // format + GDK_PROP_MODE_REPLACE, (guchar*)&value, 1); +} +#endif + +nsresult nsWindow::SetSystemFont(const nsCString& aFontName) { + GtkSettings* settings = gtk_settings_get_default(); + g_object_set(settings, "gtk-font-name", aFontName.get(), nullptr); + return NS_OK; +} + +nsresult nsWindow::GetSystemFont(nsCString& aFontName) { + GtkSettings* settings = gtk_settings_get_default(); + gchar* fontName = nullptr; + g_object_get(settings, "gtk-font-name", &fontName, nullptr); + if (fontName) { + aFontName.Assign(fontName); + g_free(fontName); + } + return NS_OK; +} + +already_AddRefed<nsIWidget> nsIWidget::CreateTopLevelWindow() { + nsCOMPtr<nsIWidget> window = new nsWindow(); + return window.forget(); +} + +already_AddRefed<nsIWidget> nsIWidget::CreateChildWindow() { + nsCOMPtr<nsIWidget> window = new nsWindow(); + return window.forget(); +} + +#ifdef MOZ_WAYLAND +nsresult nsWindow::GetScreenRect(LayoutDeviceIntRect* aRect) { + typedef struct _GdkMonitor GdkMonitor; + static auto s_gdk_display_get_monitor_at_window = + (GdkMonitor * (*)(GdkDisplay*, GdkWindow*)) + dlsym(RTLD_DEFAULT, "gdk_display_get_monitor_at_window"); + + static auto s_gdk_monitor_get_workarea = + (void (*)(GdkMonitor*, GdkRectangle*))dlsym(RTLD_DEFAULT, + "gdk_monitor_get_workarea"); + + if (!s_gdk_display_get_monitor_at_window || !s_gdk_monitor_get_workarea) { + return NS_ERROR_NOT_IMPLEMENTED; + } + + GtkWindow* topmostParentWindow = GetCurrentTopmostWindow(); + GdkWindow* gdkWindow = gtk_widget_get_window(GTK_WIDGET(topmostParentWindow)); + + GdkMonitor* monitor = + s_gdk_display_get_monitor_at_window(gdk_display_get_default(), gdkWindow); + if (monitor) { + GdkRectangle workArea; + s_gdk_monitor_get_workarea(monitor, &workArea); + // The monitor offset won't help us in Wayland, because we can't get the + // absolute position of our window. + aRect->x = aRect->y = 0; + aRect->width = workArea.width; + aRect->height = workArea.height; + LOG((" workarea for [%p], monitor %p: x%d y%d w%d h%d\n", this, monitor, + workArea.x, workArea.y, workArea.width, workArea.height)); + return NS_OK; + } + return NS_ERROR_NOT_IMPLEMENTED; +} +#endif + +bool nsWindow::GetTopLevelWindowActiveState(nsIFrame* aFrame) { + // Used by window frame and button box rendering. We can end up in here in + // the content process when rendering one of these moz styles freely in a + // page. Fail in this case, there is no applicable window focus state. + if (!XRE_IsParentProcess()) { + return false; + } + // All headless windows are considered active so they are painted. + if (gfxPlatform::IsHeadless()) { + return true; + } + // Get the widget. nsIFrame's GetNearestWidget walks up the view chain + // until it finds a real window. + nsWindow* window = static_cast<nsWindow*>(aFrame->GetNearestWidget()); + if (!window) { + return false; + } + + // Get our toplevel nsWindow. + if (!window->mIsTopLevel) { + GtkWidget* widget = window->GetMozContainerWidget(); + if (!widget) { + return false; + } + + GtkWidget* toplevelWidget = gtk_widget_get_toplevel(widget); + window = get_window_for_gtk_widget(toplevelWidget); + if (!window) { + return false; + } + } + + return !window->mTitlebarBackdropState; +} + +static nsIFrame* FindTitlebarFrame(nsIFrame* aFrame) { + for (nsIFrame* childFrame : aFrame->PrincipalChildList()) { + StyleAppearance appearance = + childFrame->StyleDisplay()->EffectiveAppearance(); + if (appearance == StyleAppearance::MozWindowTitlebar || + appearance == StyleAppearance::MozWindowTitlebarMaximized) { + return childFrame; + } + + if (nsIFrame* foundFrame = FindTitlebarFrame(childFrame)) { + return foundFrame; + } + } + return nullptr; +} + +nsIFrame* nsWindow::GetFrame(void) { + nsView* view = nsView::GetViewFor(this); + if (!view) { + return nullptr; + } + return view->GetFrame(); +} + +void nsWindow::UpdateMozWindowActive() { + // Update activation state for the :-moz-window-inactive pseudoclass. + // Normally, this follows focus; we override it here to follow + // GDK_WINDOW_STATE_FOCUSED. + if (mozilla::dom::Document* document = GetDocument()) { + if (nsPIDOMWindowOuter* window = document->GetWindow()) { + if (RefPtr<mozilla::dom::BrowsingContext> bc = + window->GetBrowsingContext()) { + bc->SetIsActiveBrowserWindow(!mTitlebarBackdropState); + } + } + } +} + +void nsWindow::ForceTitlebarRedraw(void) { + MOZ_ASSERT(mDrawInTitlebar, "We should not redraw invisible titlebar."); + + if (!mWidgetListener || !mWidgetListener->GetPresShell()) { + return; + } + + nsIFrame* frame = GetFrame(); + if (!frame) { + return; + } + + frame = FindTitlebarFrame(frame); + if (frame) { + nsIContent* content = frame->GetContent(); + if (content) { + nsLayoutUtils::PostRestyleEvent(content->AsElement(), RestyleHint{0}, + nsChangeHint_RepaintFrame); + } + } +} + +GtkTextDirection nsWindow::GetTextDirection() { + nsIFrame* frame = GetFrame(); + if (!frame) { + return GTK_TEXT_DIR_LTR; + } + + WritingMode wm = frame->GetWritingMode(); + return wm.IsPhysicalLTR() ? GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL; +} + +void nsWindow::LockAspectRatio(bool aShouldLock) { + if (!gUseAspectRatio) { + return; + } + + if (aShouldLock) { + int decWidth = 0, decHeight = 0; + AddCSDDecorationSize(&decWidth, &decHeight); + + float width = + (float)DevicePixelsToGdkCoordRoundDown(mBounds.width) + decWidth; + float height = + (float)DevicePixelsToGdkCoordRoundDown(mBounds.height) + decHeight; + + mAspectRatio = width / height; + LOG(("nsWindow::LockAspectRatio() [%p] width %f height %f aspect %f\n", + (void*)this, width, height, mAspectRatio)); + } else { + mAspectRatio = 0.0; + LOG(("nsWindow::LockAspectRatio() [%p] removed aspect ratio\n", + (void*)this)); + } + + ApplySizeConstraints(); +} + +#ifdef MOZ_WAYLAND +void nsWindow::SetEGLNativeWindowSize( + const LayoutDeviceIntSize& aEGLWindowSize) { + if (mContainer && !mIsX11Display) { + moz_container_wayland_egl_window_set_size(mContainer, aEGLWindowSize.width, + aEGLWindowSize.height); + } +} + +nsWindow* nsWindow::GetFocusedWindow() { return gFocusWindow; } +#endif + +LayoutDeviceIntRect nsWindow::GetMozContainerSize() { + LayoutDeviceIntRect size(0, 0, 0, 0); + if (mContainer) { + GtkAllocation allocation; + gtk_widget_get_allocation(GTK_WIDGET(mContainer), &allocation); + int scale = GdkScaleFactor(); + size.width = allocation.width * scale; + size.height = allocation.height * scale; + } + return size; +} |