mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-13 01:55:44 +00:00
a81830ccdb
`nsIWidget` isn't scriptable, so it is unnecessary to return `nsIScreen` for `GetWidgetScreen`. Differential Revision: https://phabricator.services.mozilla.com/D168029
554 lines
18 KiB
C++
554 lines
18 KiB
C++
/* -*- 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
|