summaryrefslogtreecommitdiffstats
path: root/widget/gtk/ScreenHelperGTK.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--widget/gtk/ScreenHelperGTK.cpp553
1 files changed, 553 insertions, 0 deletions
diff --git a/widget/gtk/ScreenHelperGTK.cpp b/widget/gtk/ScreenHelperGTK.cpp
new file mode 100644
index 0000000000..a4bd69f33b
--- /dev/null
+++ b/widget/gtk/ScreenHelperGTK.cpp
@@ -0,0 +1,553 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "ScreenHelperGTK.h"
+
+#ifdef MOZ_X11
+# include <gdk/gdkx.h>
+#endif /* MOZ_X11 */
+#ifdef MOZ_WAYLAND
+# include <gdk/gdkwayland.h>
+#endif /* MOZ_WAYLAND */
+#include <dlfcn.h>
+#include <gtk/gtk.h>
+
+#include "gfxPlatformGtk.h"
+#include "mozilla/dom/DOMTypes.h"
+#include "mozilla/Logging.h"
+#include "mozilla/WidgetUtilsGtk.h"
+#include "nsGtkUtils.h"
+#include "nsTArray.h"
+#include "nsWindow.h"
+
+#ifdef MOZ_WAYLAND
+# include "nsWaylandDisplay.h"
+#endif
+
+namespace mozilla::widget {
+
+#ifdef MOZ_LOGGING
+static LazyLogModule sScreenLog("WidgetScreen");
+# define LOG_SCREEN(...) MOZ_LOG(sScreenLog, LogLevel::Debug, (__VA_ARGS__))
+#else
+# define LOG_SCREEN(...)
+#endif /* MOZ_LOGGING */
+
+using GdkMonitor = struct _GdkMonitor;
+
+static UniquePtr<ScreenGetter> gScreenGetter;
+struct MonitorConfig {
+ int id = 0;
+ int x = 0;
+ int y = 0;
+ int width_mm = 0;
+ int height_mm = 0;
+ int width = 0;
+ int height = 0;
+ int scale = 0;
+ int refresh = 0;
+ int transform = 0;
+
+ explicit MonitorConfig(int aId) : id(aId) {}
+};
+
+static void monitors_changed(GdkScreen* aScreen, gpointer aClosure) {
+ LOG_SCREEN("Received monitors-changed event");
+ auto* self = static_cast<ScreenGetterGtk*>(aClosure);
+ self->RefreshScreens();
+}
+
+static void screen_resolution_changed(GdkScreen* aScreen, GParamSpec* aPspec,
+ ScreenGetterGtk* self) {
+ self->RefreshScreens();
+}
+
+static GdkFilterReturn root_window_event_filter(GdkXEvent* aGdkXEvent,
+ GdkEvent* aGdkEvent,
+ gpointer aClosure) {
+#ifdef MOZ_X11
+ ScreenGetterGtk* self = static_cast<ScreenGetterGtk*>(aClosure);
+ XEvent* xevent = static_cast<XEvent*>(aGdkXEvent);
+
+ switch (xevent->type) {
+ case PropertyNotify: {
+ XPropertyEvent* propertyEvent = &xevent->xproperty;
+ if (propertyEvent->atom == self->NetWorkareaAtom()) {
+ LOG_SCREEN("Work area size changed");
+ self->RefreshScreens();
+ }
+ } break;
+ default:
+ break;
+ }
+#endif
+
+ return GDK_FILTER_CONTINUE;
+}
+
+ScreenGetterGtk::ScreenGetterGtk()
+ : mRootWindow(nullptr)
+#ifdef MOZ_X11
+ ,
+ mNetWorkareaAtom(0)
+#endif
+{
+}
+
+void ScreenGetterGtk::Init() {
+ LOG_SCREEN("ScreenGetterGtk created");
+ GdkScreen* defaultScreen = gdk_screen_get_default();
+ if (!defaultScreen) {
+ // Sometimes we don't initial X (e.g., xpcshell)
+ MOZ_LOG(sScreenLog, LogLevel::Debug,
+ ("defaultScreen is nullptr, running headless"));
+ return;
+ }
+ mRootWindow = gdk_get_default_root_window();
+ MOZ_ASSERT(mRootWindow);
+
+ g_object_ref(mRootWindow);
+
+ // GDK_PROPERTY_CHANGE_MASK ==> PropertyChangeMask, for PropertyNotify
+ gdk_window_set_events(mRootWindow,
+ GdkEventMask(gdk_window_get_events(mRootWindow) |
+ GDK_PROPERTY_CHANGE_MASK));
+
+ g_signal_connect(defaultScreen, "monitors-changed",
+ G_CALLBACK(monitors_changed), this);
+ // Use _after to ensure this callback is run after gfxPlatformGtk.cpp's
+ // handler.
+ g_signal_connect_after(defaultScreen, "notify::resolution",
+ G_CALLBACK(screen_resolution_changed), this);
+#ifdef MOZ_X11
+ gdk_window_add_filter(mRootWindow, root_window_event_filter, this);
+ if (GdkIsX11Display()) {
+ mNetWorkareaAtom = XInternAtom(GDK_WINDOW_XDISPLAY(mRootWindow),
+ "_NET_WORKAREA", X11False);
+ }
+#endif
+ RefreshScreens();
+}
+
+ScreenGetterGtk::~ScreenGetterGtk() {
+ if (mRootWindow) {
+ g_signal_handlers_disconnect_by_data(gdk_screen_get_default(), this);
+
+ gdk_window_remove_filter(mRootWindow, root_window_event_filter, this);
+ g_object_unref(mRootWindow);
+ mRootWindow = nullptr;
+ }
+}
+
+static uint32_t GetGTKPixelDepth() {
+ GdkVisual* visual = gdk_screen_get_system_visual(gdk_screen_get_default());
+ return gdk_visual_get_depth(visual);
+}
+
+static already_AddRefed<Screen> MakeScreenGtk(GdkScreen* aScreen,
+ gint aMonitorNum) {
+ gint gdkScaleFactor = ScreenHelperGTK::GetGTKMonitorScaleFactor(aMonitorNum);
+
+ // gdk_screen_get_monitor_geometry / workarea returns application pixels
+ // (desktop pixels), so we need to convert it to device pixels with
+ // gdkScaleFactor.
+ gint geometryScaleFactor = gdkScaleFactor;
+
+ LayoutDeviceIntRect rect;
+
+ gint refreshRate = [&] {
+ // Since gtk 3.22
+ static auto s_gdk_display_get_monitor = (GdkMonitor * (*)(GdkDisplay*, int))
+ dlsym(RTLD_DEFAULT, "gdk_display_get_monitor");
+ static auto s_gdk_monitor_get_refresh_rate = (int (*)(GdkMonitor*))dlsym(
+ RTLD_DEFAULT, "gdk_monitor_get_refresh_rate");
+
+ if (!s_gdk_monitor_get_refresh_rate) {
+ return 0;
+ }
+ GdkMonitor* monitor =
+ s_gdk_display_get_monitor(gdk_display_get_default(), aMonitorNum);
+ if (!monitor) {
+ return 0;
+ }
+ // Convert to Hz.
+ return NSToIntRound(s_gdk_monitor_get_refresh_rate(monitor) / 1000.0f);
+ }();
+
+ GdkRectangle workarea;
+ gdk_screen_get_monitor_workarea(aScreen, aMonitorNum, &workarea);
+ LayoutDeviceIntRect availRect(workarea.x * geometryScaleFactor,
+ workarea.y * geometryScaleFactor,
+ workarea.width * geometryScaleFactor,
+ workarea.height * geometryScaleFactor);
+ if (GdkIsX11Display()) {
+ GdkRectangle monitor;
+ gdk_screen_get_monitor_geometry(aScreen, aMonitorNum, &monitor);
+ rect = LayoutDeviceIntRect(monitor.x * geometryScaleFactor,
+ monitor.y * geometryScaleFactor,
+ monitor.width * geometryScaleFactor,
+ monitor.height * geometryScaleFactor);
+ } else {
+ // We use Gtk workarea on Wayland as it matches our needs (Bug 1732682).
+ rect = availRect;
+ }
+
+ uint32_t pixelDepth = GetGTKPixelDepth();
+
+ // Use per-monitor scaling factor in gtk/wayland, or 1.0 otherwise.
+ DesktopToLayoutDeviceScale contentsScale(1.0);
+#ifdef MOZ_WAYLAND
+ if (GdkIsWaylandDisplay()) {
+ contentsScale.scale = gdkScaleFactor;
+ }
+#endif
+
+ CSSToLayoutDeviceScale defaultCssScale(gdkScaleFactor);
+
+ float dpi = 96.0f;
+ gint heightMM = gdk_screen_get_monitor_height_mm(aScreen, aMonitorNum);
+ if (heightMM > 0) {
+ dpi = rect.height / (heightMM / MM_PER_INCH_FLOAT);
+ }
+
+ LOG_SCREEN(
+ "New monitor %d size [%d,%d -> %d x %d] depth %d scale %f CssScale %f "
+ "DPI %f refresh %d ]",
+ aMonitorNum, rect.x, rect.y, rect.width, rect.height, pixelDepth,
+ contentsScale.scale, defaultCssScale.scale, dpi, refreshRate);
+ return MakeAndAddRef<Screen>(rect, availRect, pixelDepth, pixelDepth,
+ refreshRate, contentsScale, defaultCssScale, dpi,
+ Screen::IsPseudoDisplay::No);
+}
+
+void ScreenGetterGtk::RefreshScreens() {
+ LOG_SCREEN("ScreenGetterGtk::RefreshScreens()");
+ AutoTArray<RefPtr<Screen>, 4> screenList;
+
+ GdkScreen* defaultScreen = gdk_screen_get_default();
+ gint numScreens = gdk_screen_get_n_monitors(defaultScreen);
+ LOG_SCREEN("GDK reports %d screens", numScreens);
+
+ for (gint i = 0; i < numScreens; i++) {
+ screenList.AppendElement(MakeScreenGtk(defaultScreen, i));
+ }
+
+ ScreenManager::Refresh(std::move(screenList));
+}
+
+#ifdef MOZ_WAYLAND
+static void output_handle_geometry(void* data, struct wl_output* wl_output,
+ int x, int y, int physical_width,
+ int physical_height, int subpixel,
+ const char* make, const char* model,
+ int32_t transform) {
+ auto* monitor = static_cast<MonitorConfig*>(data);
+ LOG_SCREEN(
+ "wl_output: geometry position %d %d physical size %d %d, subpixel %d, "
+ "transform %d",
+ x, y, physical_width, physical_height, subpixel, transform);
+ monitor->x = x;
+ monitor->y = y;
+ monitor->width_mm = physical_width;
+ monitor->height_mm = physical_height;
+ monitor->transform = transform;
+}
+
+static void output_handle_done(void* data, struct wl_output* wl_output) {
+ LOG_SCREEN("done");
+ gScreenGetter->RefreshScreens();
+}
+
+static void output_handle_scale(void* data, struct wl_output* wl_output,
+ int32_t scale) {
+ auto* monitor = static_cast<MonitorConfig*>(data);
+ LOG_SCREEN("wl_output: scale %d", scale);
+ monitor->scale = scale;
+}
+
+static void output_handle_mode(void* data, struct wl_output* wl_output,
+ uint32_t flags, int width, int height,
+ int refresh) {
+ auto* monitor = static_cast<MonitorConfig*>(data);
+ LOG_SCREEN("wl_output: mode output size %d x %d refresh %d", width, height,
+ refresh);
+
+ if ((flags & WL_OUTPUT_MODE_CURRENT) == 0) return;
+
+ monitor->refresh = NSToIntRound(refresh / 1000.0f);
+ monitor->width = width;
+ monitor->height = height;
+}
+
+static const struct wl_output_listener output_listener = {
+ output_handle_geometry,
+ output_handle_mode,
+ output_handle_done,
+ output_handle_scale,
+};
+
+static void screen_registry_handler(void* data, wl_registry* registry,
+ uint32_t id, const char* interface,
+ uint32_t version) {
+ auto* getter = static_cast<ScreenGetterWayland*>(data);
+ if (strcmp(interface, "wl_output") == 0 && version > 1) {
+ auto* output =
+ WaylandRegistryBind<wl_output>(registry, id, &wl_output_interface, 2);
+ wl_output_add_listener(output, &output_listener,
+ getter->AddMonitorConfig(id));
+ }
+}
+
+static void screen_registry_remover(void* data, struct wl_registry* registry,
+ uint32_t id) {
+ auto* getter = static_cast<ScreenGetterWayland*>(data);
+ if (getter->RemoveMonitorConfig(id)) {
+ getter->RefreshScreens();
+ }
+ /* TODO: the object needs to be destroyed here, we're leaking */
+}
+
+static const struct wl_registry_listener screen_registry_listener = {
+ screen_registry_handler, screen_registry_remover};
+
+void ScreenGetterWayland::Init() {
+ MOZ_ASSERT(GdkIsWaylandDisplay());
+ LOG_SCREEN("ScreenGetterWayland created");
+ wl_display* display = WaylandDisplayGetWLDisplay();
+ mRegistry = wl_display_get_registry(display);
+ wl_registry_add_listener((wl_registry*)mRegistry, &screen_registry_listener,
+ this);
+ wl_display_roundtrip(display);
+ wl_display_roundtrip(display);
+}
+
+MonitorConfig* ScreenGetterWayland::AddMonitorConfig(int aId) {
+ LOG_SCREEN("Add Monitor ID %d num %d", aId, (int)(mMonitors.Length() - 1));
+ UniquePtr<MonitorConfig> monitor = MakeUnique<MonitorConfig>(aId);
+ mMonitors.AppendElement(std::move(monitor));
+ return mMonitors.LastElement().get();
+}
+
+bool ScreenGetterWayland::RemoveMonitorConfig(int aId) {
+ for (unsigned int i = 0; i < mMonitors.Length(); i++) {
+ if (mMonitors[i]->id == aId) {
+ LOG_SCREEN("Remove Monitor ID %d num %d", aId, i);
+ mMonitors.RemoveElementAt(i);
+ return true;
+ }
+ }
+ return false;
+}
+
+ScreenGetterWayland::ScreenGetterWayland() = default;
+
+ScreenGetterWayland::~ScreenGetterWayland() {
+ MozClearPointer(mRegistry, wl_registry_destroy);
+}
+
+static bool GdkMonitorGetWorkarea(GdkMonitor* monitor, GdkRectangle* workarea) {
+ static auto s_gdk_monitor_get_workarea =
+ (void (*)(GdkMonitor*, GdkRectangle*))dlsym(RTLD_DEFAULT,
+ "gdk_monitor_get_workarea");
+ if (!s_gdk_monitor_get_workarea) {
+ return false;
+ }
+
+ s_gdk_monitor_get_workarea(monitor, workarea);
+ return true;
+}
+
+already_AddRefed<Screen> ScreenGetterWayland::MakeScreenWayland(gint aMonitor) {
+ MonitorConfig* monitor = mMonitors[aMonitor].get();
+
+ // On GNOME/Mutter we use results from wl_output directly
+ LayoutDeviceIntRect rect(monitor->x, monitor->y, monitor->width,
+ monitor->height);
+
+ uint32_t pixelDepth = GetGTKPixelDepth();
+
+ // Use per-monitor scaling factor in gtk/wayland, or 1.0 otherwise.
+ DesktopToLayoutDeviceScale contentsScale(monitor->scale);
+
+ CSSToLayoutDeviceScale defaultCssScale(monitor->scale);
+
+ float dpi = 96.0f;
+ gint heightMM = monitor->height_mm;
+ if (heightMM > 0) {
+ dpi = rect.height / (heightMM / MM_PER_INCH_FLOAT);
+ }
+
+ bool defaultIsLandscape;
+ if (monitor->transform == WL_OUTPUT_TRANSFORM_90 ||
+ monitor->transform == WL_OUTPUT_TRANSFORM_270) {
+ defaultIsLandscape = rect.width < rect.height;
+ } else {
+ defaultIsLandscape = rect.width >= rect.height;
+ }
+
+ hal::ScreenOrientation orientation;
+ Screen::OrientationAngle angle;
+ // transform is counter-clockwise, but Screen Orientation API is clockwise.
+ switch (monitor->transform) {
+ case WL_OUTPUT_TRANSFORM_NORMAL:
+ orientation = defaultIsLandscape
+ ? hal::ScreenOrientation::LandscapePrimary
+ : hal::ScreenOrientation::PortraitPrimary;
+ angle = 0;
+ break;
+ case WL_OUTPUT_TRANSFORM_90:
+ orientation = defaultIsLandscape
+ ? hal::ScreenOrientation::PortraitPrimary
+ : hal::ScreenOrientation::LandscapeSecondary;
+ angle = 270;
+ break;
+ case WL_OUTPUT_TRANSFORM_180:
+ orientation = defaultIsLandscape
+ ? hal::ScreenOrientation::LandscapeSecondary
+ : hal::ScreenOrientation::PortraitSecondary;
+ angle = 180;
+ break;
+ case WL_OUTPUT_TRANSFORM_270:
+ orientation = defaultIsLandscape
+ ? hal::ScreenOrientation::PortraitSecondary
+ : hal::ScreenOrientation::LandscapePrimary;
+ angle = 90;
+ break;
+ default:
+ // WL_OUTPUT_TRANSFORM_FLIPPED_* is ignore since this is unused on normal
+ // situation.
+ orientation = hal::ScreenOrientation::None;
+ angle = 0;
+ break;
+ }
+
+ LOG_SCREEN(
+ "Monitor %d [%d %d -> %d x %d depth %d content scale %f css scale %f "
+ "DPI %f, refresh %d, orientation %u, angle %u]",
+ aMonitor, rect.x, rect.y, rect.width, rect.height, pixelDepth,
+ contentsScale.scale, defaultCssScale.scale, dpi, monitor->refresh,
+ static_cast<uint32_t>(orientation), angle);
+
+ // We report zero screen shift on Wayland. All popups positions are relative
+ // to toplevel and we can't get toplevel position from Wayland compositor.
+ rect.x = rect.y = 0;
+ return MakeAndAddRef<Screen>(
+ rect, rect, pixelDepth, pixelDepth, monitor->refresh, contentsScale,
+ defaultCssScale, dpi, Screen::IsPseudoDisplay::No, orientation, angle);
+}
+
+void ScreenGetterWayland::RefreshScreens() {
+ LOG_SCREEN("ScreenGetterWayland::RefreshScreens()");
+ AutoTArray<RefPtr<Screen>, 4> managerScreenList;
+
+ mScreenList.Clear();
+ const gint numScreens = mMonitors.Length();
+ LOG_SCREEN("Wayland reports %d monitors", numScreens);
+ for (gint i = 0; i < numScreens; i++) {
+ RefPtr<Screen> screen = MakeScreenWayland(i);
+ mScreenList.AppendElement(screen);
+ managerScreenList.AppendElement(screen);
+ }
+
+ ScreenManager::Refresh(std::move(managerScreenList));
+}
+
+int ScreenGetterWayland::GetMonitorForWindow(nsWindow* aWindow) {
+ LOG_SCREEN("GetMonitorForWindow() [%p]", aWindow);
+
+ static auto s_gdk_display_get_monitor_at_window =
+ (GdkMonitor * (*)(GdkDisplay*, GdkWindow*))
+ dlsym(RTLD_DEFAULT, "gdk_display_get_monitor_at_window");
+
+ if (!s_gdk_display_get_monitor_at_window) {
+ LOG_SCREEN(" failed, missing Gtk helpers");
+ return -1;
+ }
+
+ GdkWindow* gdkWindow = gtk_widget_get_window(aWindow->GetGtkWidget());
+ if (!gdkWindow) {
+ LOG_SCREEN(" failed, can't get GdkWindow");
+ return -1;
+ }
+
+ GdkMonitor* monitor =
+ s_gdk_display_get_monitor_at_window(gdk_display_get_default(), gdkWindow);
+ if (!monitor) {
+ LOG_SCREEN(" failed, can't get monitor for GdkWindow");
+ return -1;
+ }
+
+ GdkRectangle workArea;
+ if (!GdkMonitorGetWorkarea(monitor, &workArea)) {
+ LOG_SCREEN(" failed, can't get work area");
+ return -1;
+ }
+
+ for (unsigned int i = 0; i < mMonitors.Length(); i++) {
+ // Although Gtk/Mutter is very creative in reporting various screens sizes
+ // we can rely on Gtk work area start position to match wl_output.
+ if (mMonitors[i]->x == workArea.x && mMonitors[i]->y == workArea.y) {
+ LOG_SCREEN(" monitor %d work area [%d, %d] -> (%d x %d) scale %d", i,
+ mMonitors[i]->x, mMonitors[i]->y, mMonitors[i]->width,
+ mMonitors[i]->height, mMonitors[i]->scale);
+ return i;
+ }
+ }
+
+ return -1;
+}
+
+RefPtr<widget::Screen> ScreenGetterWayland::GetScreenForWindow(
+ nsWindow* aWindow) {
+ if (mMonitors.IsEmpty()) {
+ return nullptr;
+ }
+
+ int monitor = GetMonitorForWindow(aWindow);
+ if (monitor < 0) {
+ return nullptr;
+ }
+
+ if (mMonitors.Length() != mScreenList.Length()) {
+ // Gtk list of GtkScreens are out of sync with our monitor list.
+ // Try to refresh it now.
+ RefreshScreens();
+ }
+
+ MOZ_DIAGNOSTIC_ASSERT((unsigned)monitor < mScreenList.Length(),
+ "We're missing screen?");
+ return mScreenList[monitor];
+}
+#endif
+
+RefPtr<widget::Screen> ScreenHelperGTK::GetScreenForWindow(nsWindow* aWindow) {
+ return gScreenGetter->GetScreenForWindow(aWindow);
+}
+
+gint ScreenHelperGTK::GetGTKMonitorScaleFactor(gint aMonitorNum) {
+ GdkScreen* screen = gdk_screen_get_default();
+ return gdk_screen_get_monitor_scale_factor(screen, aMonitorNum);
+}
+
+ScreenHelperGTK::ScreenHelperGTK() {
+#ifdef MOZ_WAYLAND
+ // Use ScreenGetterWayland on Gnome/Mutter only. It uses additional wl_output
+ // to track screen size changes (which are wrongly reported by mutter)
+ // and causes issues on Sway (Bug 1730476).
+ // https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/3941
+ if (GdkIsWaylandDisplay() && IsGnomeDesktopEnvironment()) {
+ gScreenGetter = MakeUnique<ScreenGetterWayland>();
+ }
+#endif
+ if (!gScreenGetter) {
+ gScreenGetter = MakeUnique<ScreenGetterGtk>();
+ }
+ gScreenGetter->Init();
+}
+
+ScreenHelperGTK::~ScreenHelperGTK() { gScreenGetter = nullptr; }
+
+} // namespace mozilla::widget