mirror of
https://github.com/brl/mutter.git
synced 2024-12-04 22:00:42 -05:00
4a5a31edc6
To silence code-style-check complains.
Fixes d44f02ba64
Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/3018>
4068 lines
134 KiB
C
4068 lines
134 KiB
C
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
|
|
|
|
/*
|
|
* Copyright (C) 2001, 2002 Havoc Pennington
|
|
* Copyright (C) 2002, 2003 Red Hat Inc.
|
|
* Some ICCCM manager selection code derived from fvwm2,
|
|
* Copyright (C) 2001 Dominik Vogt, Matthias Clasen, and fvwm2 team
|
|
* Copyright (C) 2003 Rob Adams
|
|
* Copyright (C) 2004-2006 Elijah Newren
|
|
* Copyright (C) 2013 Red Hat Inc.
|
|
* Copyright (C) 2020 NVIDIA CORPORATION
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/**
|
|
* MetaMonitorManager:
|
|
*
|
|
* A manager for multiple monitors
|
|
*
|
|
* #MetaMonitorManager is an abstract class which contains methods to handle
|
|
* multiple monitors (both #MetaMonitor and #MetaLogicalMonitor) and GPU's
|
|
* (#MetaGpu). Its functions include reading and/or changing the current
|
|
* configuration and available capabiliies.
|
|
*
|
|
* The #MetaMonitorManager also provides the "org.gnome.Mutter.DisplayConfig"
|
|
* DBus service, so apps like GNOME Settings can use this functionality.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include "backends/meta-monitor-manager-private.h"
|
|
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "backends/meta-backend-private.h"
|
|
#include "backends/meta-crtc.h"
|
|
#include "backends/meta-logical-monitor.h"
|
|
#include "backends/meta-monitor.h"
|
|
#include "backends/meta-monitor-config-manager.h"
|
|
#include "backends/meta-monitor-config-store.h"
|
|
#include "backends/meta-orientation-manager.h"
|
|
#include "backends/meta-output.h"
|
|
#include "backends/meta-virtual-monitor.h"
|
|
#include "backends/x11/meta-monitor-manager-xrandr.h"
|
|
#include "clutter/clutter.h"
|
|
#include "core/util-private.h"
|
|
#include "meta/main.h"
|
|
#include "meta/meta-x11-errors.h"
|
|
|
|
#include "meta-dbus-display-config.h"
|
|
|
|
#define DEFAULT_DISPLAY_CONFIGURATION_TIMEOUT 20
|
|
|
|
enum
|
|
{
|
|
PROP_0,
|
|
|
|
PROP_BACKEND,
|
|
PROP_PANEL_ORIENTATION_MANAGED,
|
|
PROP_HAS_BUILTIN_PANEL,
|
|
PROP_NIGHT_LIGHT_SUPPORTED,
|
|
PROP_EXPERIMENTAL_HDR,
|
|
|
|
PROP_LAST
|
|
};
|
|
|
|
static GParamSpec *obj_props[PROP_LAST];
|
|
|
|
enum
|
|
{
|
|
MONITORS_CHANGED,
|
|
MONITORS_CHANGED_INTERNAL,
|
|
POWER_SAVE_MODE_CHANGED,
|
|
CONFIRM_DISPLAY_CHANGE,
|
|
MONITOR_PRIVACY_SCREEN_CHANGED,
|
|
SIGNALS_LAST
|
|
};
|
|
|
|
/* Array index matches MetaMonitorTransform */
|
|
static gfloat transform_matrices[][6] = {
|
|
{ 1, 0, 0, 0, 1, 0 }, /* normal */
|
|
{ 0, -1, 1, 1, 0, 0 }, /* 90° */
|
|
{ -1, 0, 1, 0, -1, 1 }, /* 180° */
|
|
{ 0, 1, 0, -1, 0, 1 }, /* 270° */
|
|
{ -1, 0, 1, 0, 1, 0 }, /* normal flipped */
|
|
{ 0, 1, 0, 1, 0, 0 }, /* 90° flipped */
|
|
{ 1, 0, 0, 0, -1, 1 }, /* 180° flipped */
|
|
{ 0, -1, 1, -1, 0, 1 }, /* 270° flipped */
|
|
};
|
|
|
|
static int signals[SIGNALS_LAST];
|
|
|
|
typedef struct _MetaMonitorManagerPrivate
|
|
{
|
|
MetaPowerSave power_save_mode;
|
|
gboolean initial_orient_change_done;
|
|
|
|
GList *virtual_monitors;
|
|
|
|
gboolean shutting_down;
|
|
|
|
gboolean has_builtin_panel;
|
|
gboolean night_light_supported;
|
|
const char *experimental_hdr;
|
|
|
|
guint switch_config_handle_id;
|
|
} MetaMonitorManagerPrivate;
|
|
|
|
G_DEFINE_TYPE_WITH_PRIVATE (MetaMonitorManager, meta_monitor_manager,
|
|
G_TYPE_OBJECT)
|
|
|
|
static void initialize_dbus_interface (MetaMonitorManager *manager);
|
|
static void monitor_manager_setup_dbus_config_handlers (MetaMonitorManager *manager);
|
|
|
|
static gboolean
|
|
meta_monitor_manager_is_config_complete (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config);
|
|
|
|
static void
|
|
meta_monitor_manager_real_read_current_state (MetaMonitorManager *manager);
|
|
|
|
static gboolean
|
|
is_global_scale_matching_in_config (MetaMonitorsConfig *config,
|
|
float scale);
|
|
|
|
MetaBackend *
|
|
meta_monitor_manager_get_backend (MetaMonitorManager *manager)
|
|
{
|
|
return manager->backend;
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_init (MetaMonitorManager *manager)
|
|
{
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_set_primary_logical_monitor (MetaMonitorManager *manager,
|
|
MetaLogicalMonitor *logical_monitor)
|
|
{
|
|
manager->primary_logical_monitor = logical_monitor;
|
|
if (logical_monitor)
|
|
meta_logical_monitor_make_primary (logical_monitor);
|
|
}
|
|
|
|
static gboolean
|
|
is_main_tiled_monitor_output (MetaOutput *output)
|
|
{
|
|
const MetaOutputInfo *output_info = meta_output_get_info (output);
|
|
|
|
return (output_info->tile_info.loc_h_tile == 0 &&
|
|
output_info->tile_info.loc_v_tile == 0);
|
|
}
|
|
|
|
static MetaLogicalMonitor *
|
|
logical_monitor_from_layout (MetaMonitorManager *manager,
|
|
GList *logical_monitors,
|
|
MetaRectangle *layout)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = logical_monitors; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitor *logical_monitor = l->data;
|
|
|
|
if (meta_rectangle_equal (layout, &logical_monitor->rect))
|
|
return logical_monitor;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_rebuild_logical_monitors (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config)
|
|
{
|
|
GList *logical_monitor_configs;
|
|
GList *logical_monitors = NULL;
|
|
GList *l;
|
|
int monitor_number = 0;
|
|
MetaLogicalMonitor *primary_logical_monitor = NULL;
|
|
|
|
logical_monitor_configs = config ? config->logical_monitor_configs : NULL;
|
|
for (l = logical_monitor_configs; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitorConfig *logical_monitor_config = l->data;
|
|
MetaLogicalMonitor *logical_monitor;
|
|
|
|
logical_monitor = meta_logical_monitor_new (manager,
|
|
logical_monitor_config,
|
|
monitor_number);
|
|
monitor_number++;
|
|
|
|
if (logical_monitor_config->is_primary)
|
|
primary_logical_monitor = logical_monitor;
|
|
|
|
logical_monitors = g_list_append (logical_monitors, logical_monitor);
|
|
}
|
|
|
|
/*
|
|
* If no monitor was marked as primary, fall back on marking the first
|
|
* logical monitor the primary one.
|
|
*/
|
|
if (!primary_logical_monitor && logical_monitors)
|
|
primary_logical_monitor = g_list_first (logical_monitors)->data;
|
|
|
|
manager->logical_monitors = logical_monitors;
|
|
meta_monitor_manager_set_primary_logical_monitor (manager,
|
|
primary_logical_monitor);
|
|
}
|
|
|
|
static float
|
|
derive_configured_global_scale (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = config->logical_monitor_configs; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitorConfig *monitor_config = l->data;
|
|
|
|
if (is_global_scale_matching_in_config (config, monitor_config->scale))
|
|
return monitor_config->scale;
|
|
}
|
|
|
|
return 1.0;
|
|
}
|
|
|
|
static float
|
|
calculate_monitor_scale (MetaMonitorManager *manager,
|
|
MetaMonitor *monitor)
|
|
{
|
|
MetaMonitorMode *monitor_mode;
|
|
|
|
monitor_mode = meta_monitor_get_current_mode (monitor);
|
|
return meta_monitor_manager_calculate_monitor_mode_scale (manager,
|
|
manager->layout_mode,
|
|
monitor,
|
|
monitor_mode);
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_is_scale_supported_by_other_monitors (MetaMonitorManager *manager,
|
|
MetaMonitor *not_this_one,
|
|
float scale)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
MetaMonitorMode *mode;
|
|
|
|
if (monitor == not_this_one || !meta_monitor_is_active (monitor))
|
|
continue;
|
|
|
|
mode = meta_monitor_get_current_mode (monitor);
|
|
if (!meta_monitor_manager_is_scale_supported (manager,
|
|
manager->layout_mode,
|
|
monitor, mode, scale))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static float
|
|
derive_calculated_global_scale (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitor *monitor = NULL;
|
|
float scale;
|
|
GList *l;
|
|
|
|
scale = 1.0;
|
|
monitor = meta_monitor_manager_get_primary_monitor (manager);
|
|
|
|
if (monitor && meta_monitor_is_active (monitor))
|
|
{
|
|
scale = calculate_monitor_scale (manager, monitor);
|
|
if (meta_monitor_manager_is_scale_supported_by_other_monitors (manager,
|
|
monitor,
|
|
scale))
|
|
return scale;
|
|
}
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *other_monitor = l->data;
|
|
float monitor_scale;
|
|
|
|
if (other_monitor == monitor || !meta_monitor_is_active (other_monitor))
|
|
continue;
|
|
|
|
monitor_scale = calculate_monitor_scale (manager, other_monitor);
|
|
if (meta_monitor_manager_is_scale_supported_by_other_monitors (manager,
|
|
other_monitor,
|
|
monitor_scale))
|
|
scale = MAX (scale, monitor_scale);
|
|
}
|
|
|
|
return scale;
|
|
}
|
|
|
|
static float
|
|
derive_scale_from_config (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config,
|
|
MetaRectangle *layout)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = config->logical_monitor_configs; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitorConfig *logical_monitor_config = l->data;
|
|
|
|
if (meta_rectangle_equal (layout, &logical_monitor_config->layout))
|
|
return logical_monitor_config->scale;
|
|
}
|
|
|
|
g_warning ("Missing logical monitor, using scale 1");
|
|
return 1.0;
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_rebuild_logical_monitors_derived (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config)
|
|
{
|
|
GList *logical_monitors = NULL;
|
|
GList *l;
|
|
int monitor_number;
|
|
MetaLogicalMonitor *primary_logical_monitor = NULL;
|
|
gboolean use_global_scale;
|
|
float global_scale = 0.0;
|
|
MetaMonitorManagerCapability capabilities;
|
|
|
|
monitor_number = 0;
|
|
|
|
capabilities = meta_monitor_manager_get_capabilities (manager);
|
|
use_global_scale =
|
|
!!(capabilities & META_MONITOR_MANAGER_CAPABILITY_GLOBAL_SCALE_REQUIRED);
|
|
|
|
if (use_global_scale)
|
|
{
|
|
if (config)
|
|
global_scale = derive_configured_global_scale (manager, config);
|
|
else
|
|
global_scale = derive_calculated_global_scale (manager);
|
|
}
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
MetaLogicalMonitor *logical_monitor;
|
|
MetaRectangle layout;
|
|
|
|
if (!meta_monitor_is_active (monitor))
|
|
continue;
|
|
|
|
meta_monitor_derive_layout (monitor, &layout);
|
|
logical_monitor = logical_monitor_from_layout (manager, logical_monitors,
|
|
&layout);
|
|
if (logical_monitor)
|
|
{
|
|
meta_logical_monitor_add_monitor (logical_monitor, monitor);
|
|
}
|
|
else
|
|
{
|
|
float scale;
|
|
|
|
if (use_global_scale)
|
|
scale = global_scale;
|
|
else if (config)
|
|
scale = derive_scale_from_config (manager, config, &layout);
|
|
else
|
|
scale = calculate_monitor_scale (manager, monitor);
|
|
|
|
g_assert (scale > 0);
|
|
|
|
logical_monitor = meta_logical_monitor_new_derived (manager,
|
|
monitor,
|
|
&layout,
|
|
scale,
|
|
monitor_number);
|
|
logical_monitors = g_list_append (logical_monitors, logical_monitor);
|
|
monitor_number++;
|
|
}
|
|
|
|
if (meta_monitor_is_primary (monitor))
|
|
primary_logical_monitor = logical_monitor;
|
|
}
|
|
|
|
manager->logical_monitors = logical_monitors;
|
|
|
|
/*
|
|
* If no monitor was marked as primary, fall back on marking the first
|
|
* logical monitor the primary one.
|
|
*/
|
|
if (!primary_logical_monitor && manager->logical_monitors)
|
|
primary_logical_monitor = g_list_first (manager->logical_monitors)->data;
|
|
|
|
meta_monitor_manager_set_primary_logical_monitor (manager,
|
|
primary_logical_monitor);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_power_save_mode_changed (MetaMonitorManager *manager,
|
|
MetaPowerSave mode)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
if (priv->power_save_mode == mode)
|
|
return;
|
|
|
|
priv->power_save_mode = mode;
|
|
g_signal_emit (manager, signals[POWER_SAVE_MODE_CHANGED], 0);
|
|
}
|
|
|
|
static void
|
|
power_save_mode_changed (MetaMonitorManager *manager,
|
|
GParamSpec *pspec,
|
|
gpointer user_data)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
MetaMonitorManagerClass *klass;
|
|
int mode = meta_dbus_display_config_get_power_save_mode (manager->display_config);
|
|
|
|
if (mode == META_POWER_SAVE_UNSUPPORTED)
|
|
return;
|
|
|
|
/* If DPMS is unsupported, force the property back. */
|
|
if (priv->power_save_mode == META_POWER_SAVE_UNSUPPORTED)
|
|
{
|
|
meta_dbus_display_config_set_power_save_mode (manager->display_config, META_POWER_SAVE_UNSUPPORTED);
|
|
return;
|
|
}
|
|
|
|
klass = META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
if (klass->set_power_save_mode)
|
|
klass->set_power_save_mode (manager, mode);
|
|
|
|
meta_monitor_manager_power_save_mode_changed (manager, mode);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_lid_is_closed_changed (MetaMonitorManager *manager)
|
|
{
|
|
meta_monitor_manager_ensure_configured (manager);
|
|
}
|
|
|
|
static void
|
|
lid_is_closed_changed (MetaBackend *backend,
|
|
gboolean lid_is_closed,
|
|
gpointer user_data)
|
|
{
|
|
MetaMonitorManager *manager = user_data;
|
|
meta_monitor_manager_lid_is_closed_changed (manager);
|
|
}
|
|
|
|
static void
|
|
prepare_shutdown (MetaBackend *backend,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
priv->shutting_down = TRUE;
|
|
}
|
|
|
|
static void
|
|
ensure_hdr_settings (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
MetaOutputColorspace color_space;
|
|
MetaOutputHdrMetadata hdr_metadata;
|
|
GList *l;
|
|
|
|
if (g_strcmp0 (priv->experimental_hdr, "on") == 0)
|
|
{
|
|
color_space = META_OUTPUT_COLORSPACE_BT2020;
|
|
hdr_metadata = (MetaOutputHdrMetadata) {
|
|
.active = TRUE,
|
|
.eotf = META_OUTPUT_HDR_METADATA_EOTF_PQ,
|
|
};
|
|
}
|
|
else
|
|
{
|
|
color_space = META_OUTPUT_COLORSPACE_DEFAULT;
|
|
hdr_metadata = (MetaOutputHdrMetadata) {
|
|
.active = FALSE,
|
|
};
|
|
}
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
g_autoptr (GError) error = NULL;
|
|
|
|
if (!meta_monitor_set_color_space (monitor, color_space, &error))
|
|
{
|
|
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED))
|
|
continue;
|
|
|
|
g_warning ("Failed to set color space on monitor %s: %s",
|
|
meta_monitor_get_display_name (monitor), error->message);
|
|
|
|
meta_monitor_set_color_space (monitor,
|
|
META_OUTPUT_COLORSPACE_DEFAULT,
|
|
NULL);
|
|
|
|
continue;
|
|
}
|
|
|
|
if (!meta_monitor_set_hdr_metadata (monitor, &hdr_metadata, &error))
|
|
{
|
|
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED))
|
|
continue;
|
|
|
|
g_warning ("Failed to set HDR metadata on monitor %s: %s",
|
|
meta_monitor_get_display_name (monitor), error->message);
|
|
|
|
meta_monitor_set_color_space (monitor,
|
|
META_OUTPUT_COLORSPACE_DEFAULT,
|
|
NULL);
|
|
meta_monitor_set_hdr_metadata (monitor, &(MetaOutputHdrMetadata) {
|
|
.active = FALSE,
|
|
}, NULL);
|
|
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_is_headless:
|
|
* @manager: A #MetaMonitorManager object
|
|
*
|
|
* Returns whether the monitor manager is headless, i.e. without
|
|
* any `MetaLogicalMonitor`s attached to it.
|
|
*
|
|
* Returns: %TRUE if no monitors are attached, %FALSE otherwise.
|
|
*/
|
|
gboolean
|
|
meta_monitor_manager_is_headless (MetaMonitorManager *manager)
|
|
{
|
|
return !manager->logical_monitors;
|
|
}
|
|
|
|
float
|
|
meta_monitor_manager_calculate_monitor_mode_scale (MetaMonitorManager *manager,
|
|
MetaLogicalMonitorLayoutMode layout_mode,
|
|
MetaMonitor *monitor,
|
|
MetaMonitorMode *monitor_mode)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
return manager_class->calculate_monitor_mode_scale (manager,
|
|
layout_mode,
|
|
monitor,
|
|
monitor_mode);
|
|
}
|
|
|
|
float *
|
|
meta_monitor_manager_calculate_supported_scales (MetaMonitorManager *manager,
|
|
MetaLogicalMonitorLayoutMode layout_mode,
|
|
MetaMonitor *monitor,
|
|
MetaMonitorMode *monitor_mode,
|
|
int *n_supported_scales)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
return manager_class->calculate_supported_scales (manager,
|
|
layout_mode,
|
|
monitor,
|
|
monitor_mode,
|
|
n_supported_scales);
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_capabilities:
|
|
* @manager: A #MetaMonitorManager object
|
|
*
|
|
* Queries the capabilities of the monitor manager.
|
|
*
|
|
* Returns: #MetaMonitorManagerCapability flags representing the capabilities.
|
|
*/
|
|
MetaMonitorManagerCapability
|
|
meta_monitor_manager_get_capabilities (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
return manager_class->get_capabilities (manager);
|
|
}
|
|
|
|
gboolean
|
|
meta_monitor_manager_get_max_screen_size (MetaMonitorManager *manager,
|
|
int *max_width,
|
|
int *max_height)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
return manager_class->get_max_screen_size (manager, max_width, max_height);
|
|
}
|
|
|
|
|
|
MetaLogicalMonitorLayoutMode
|
|
meta_monitor_manager_get_default_layout_mode (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
return manager_class->get_default_layout_mode (manager);
|
|
}
|
|
|
|
static void
|
|
on_virtual_monitor_destroyed (MetaVirtualMonitor *virtual_monitor,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
MetaOutput *output;
|
|
|
|
output = meta_virtual_monitor_get_output (virtual_monitor);
|
|
g_message ("Removed virtual monitor %s", meta_output_get_name (output));
|
|
priv->virtual_monitors = g_list_remove (priv->virtual_monitors,
|
|
virtual_monitor);
|
|
|
|
if (!priv->shutting_down)
|
|
meta_monitor_manager_reload (manager);
|
|
}
|
|
|
|
MetaVirtualMonitor *
|
|
meta_monitor_manager_create_virtual_monitor (MetaMonitorManager *manager,
|
|
const MetaVirtualMonitorInfo *info,
|
|
GError **error)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
MetaVirtualMonitor *virtual_monitor;
|
|
MetaOutput *output;
|
|
|
|
if (!manager_class->create_virtual_monitor)
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
|
|
"Backend doesn't support creating virtual monitors");
|
|
return NULL;
|
|
}
|
|
|
|
virtual_monitor = manager_class->create_virtual_monitor (manager, info,
|
|
error);
|
|
if (!virtual_monitor)
|
|
return NULL;
|
|
|
|
g_signal_connect (virtual_monitor, "destroy",
|
|
G_CALLBACK (on_virtual_monitor_destroyed),
|
|
manager);
|
|
|
|
priv->virtual_monitors = g_list_append (priv->virtual_monitors,
|
|
virtual_monitor);
|
|
|
|
output = meta_virtual_monitor_get_output (virtual_monitor);
|
|
g_message ("Added virtual monitor %s", meta_output_get_name (output));
|
|
|
|
return virtual_monitor;
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_ensure_initial_config (MetaMonitorManager *manager)
|
|
{
|
|
META_MONITOR_MANAGER_GET_CLASS (manager)->ensure_initial_config (manager);
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_apply_monitors_config (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config,
|
|
MetaMonitorsConfigMethod method,
|
|
GError **error)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
g_assert (!config ||
|
|
!(config->flags & META_MONITORS_CONFIG_FLAG_MIGRATED));
|
|
|
|
if (!manager_class->apply_monitors_config (manager, config, method, error))
|
|
return FALSE;
|
|
|
|
switch (method)
|
|
{
|
|
case META_MONITORS_CONFIG_METHOD_TEMPORARY:
|
|
case META_MONITORS_CONFIG_METHOD_PERSISTENT:
|
|
meta_monitor_config_manager_set_current (manager->config_manager, config);
|
|
break;
|
|
case META_MONITORS_CONFIG_METHOD_VERIFY:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean
|
|
meta_monitor_manager_has_hotplug_mode_update (MetaMonitorManager *manager)
|
|
{
|
|
GList *gpus;
|
|
GList *l;
|
|
|
|
gpus = meta_backend_get_gpus (manager->backend);
|
|
for (l = gpus; l; l = l->next)
|
|
{
|
|
MetaGpu *gpu = l->data;
|
|
|
|
if (meta_gpu_has_hotplug_mode_update (gpu))
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
should_use_stored_config (MetaMonitorManager *manager)
|
|
{
|
|
return (manager->in_init ||
|
|
!meta_monitor_manager_has_hotplug_mode_update (manager));
|
|
}
|
|
|
|
MetaMonitorsConfig *
|
|
meta_monitor_manager_ensure_configured (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorsConfig *config = NULL;
|
|
GError *error = NULL;
|
|
gboolean use_stored_config;
|
|
MetaMonitorsConfigMethod method;
|
|
MetaMonitorsConfigMethod fallback_method =
|
|
META_MONITORS_CONFIG_METHOD_TEMPORARY;
|
|
|
|
use_stored_config = should_use_stored_config (manager);
|
|
if (use_stored_config)
|
|
method = META_MONITORS_CONFIG_METHOD_PERSISTENT;
|
|
else
|
|
method = META_MONITORS_CONFIG_METHOD_TEMPORARY;
|
|
|
|
if (use_stored_config)
|
|
{
|
|
config = meta_monitor_config_manager_get_stored (manager->config_manager);
|
|
if (config)
|
|
{
|
|
g_autoptr (MetaMonitorsConfig) oriented_config = NULL;
|
|
|
|
if (manager->panel_orientation_managed)
|
|
{
|
|
oriented_config = meta_monitor_config_manager_create_for_builtin_orientation (
|
|
manager->config_manager, config);
|
|
|
|
if (oriented_config)
|
|
config = oriented_config;
|
|
}
|
|
|
|
if (!meta_monitor_manager_apply_monitors_config (manager,
|
|
config,
|
|
method,
|
|
&error))
|
|
{
|
|
config = NULL;
|
|
g_warning ("Failed to use stored monitor configuration: %s",
|
|
error->message);
|
|
g_clear_error (&error);
|
|
}
|
|
else
|
|
{
|
|
g_object_ref (config);
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (manager->panel_orientation_managed)
|
|
{
|
|
MetaMonitorsConfig *current_config =
|
|
meta_monitor_config_manager_get_current (manager->config_manager);
|
|
|
|
if (current_config)
|
|
{
|
|
config = meta_monitor_config_manager_create_for_builtin_orientation (
|
|
manager->config_manager, current_config);
|
|
}
|
|
}
|
|
|
|
if (config)
|
|
{
|
|
if (meta_monitor_manager_is_config_complete (manager, config))
|
|
{
|
|
if (!meta_monitor_manager_apply_monitors_config (manager,
|
|
config,
|
|
method,
|
|
&error))
|
|
{
|
|
g_clear_object (&config);
|
|
g_warning ("Failed to use current monitor configuration: %s",
|
|
error->message);
|
|
g_clear_error (&error);
|
|
}
|
|
else
|
|
{
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
config = meta_monitor_config_manager_create_suggested (manager->config_manager);
|
|
if (config)
|
|
{
|
|
if (!meta_monitor_manager_apply_monitors_config (manager,
|
|
config,
|
|
method,
|
|
&error))
|
|
{
|
|
g_clear_object (&config);
|
|
g_warning ("Failed to use suggested monitor configuration: %s",
|
|
error->message);
|
|
g_clear_error (&error);
|
|
}
|
|
else
|
|
{
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
config = meta_monitor_config_manager_get_previous (manager->config_manager);
|
|
if (config)
|
|
{
|
|
g_autoptr (MetaMonitorsConfig) oriented_config = NULL;
|
|
|
|
if (manager->panel_orientation_managed)
|
|
{
|
|
oriented_config =
|
|
meta_monitor_config_manager_create_for_builtin_orientation (
|
|
manager->config_manager, config);
|
|
|
|
if (oriented_config)
|
|
config = oriented_config;
|
|
}
|
|
|
|
config = g_object_ref (config);
|
|
|
|
if (meta_monitor_manager_is_config_complete (manager, config))
|
|
{
|
|
if (!meta_monitor_manager_apply_monitors_config (manager,
|
|
config,
|
|
method,
|
|
&error))
|
|
{
|
|
g_warning ("Failed to use suggested monitor configuration: %s",
|
|
error->message);
|
|
g_clear_error (&error);
|
|
}
|
|
else
|
|
{
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
g_clear_object (&config);
|
|
}
|
|
|
|
config = meta_monitor_config_manager_create_linear (manager->config_manager);
|
|
if (config)
|
|
{
|
|
if (!meta_monitor_manager_apply_monitors_config (manager,
|
|
config,
|
|
method,
|
|
&error))
|
|
{
|
|
g_clear_object (&config);
|
|
g_warning ("Failed to use linear monitor configuration: %s",
|
|
error->message);
|
|
g_clear_error (&error);
|
|
}
|
|
else
|
|
{
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
config = meta_monitor_config_manager_create_fallback (manager->config_manager);
|
|
if (config)
|
|
{
|
|
if (!meta_monitor_manager_apply_monitors_config (manager,
|
|
config,
|
|
fallback_method,
|
|
&error))
|
|
{
|
|
g_clear_object (&config);
|
|
g_warning ("Failed to use fallback monitor configuration: %s",
|
|
error->message);
|
|
g_clear_error (&error);
|
|
}
|
|
else
|
|
{
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
done:
|
|
if (!config)
|
|
{
|
|
meta_monitor_manager_apply_monitors_config (manager,
|
|
NULL,
|
|
fallback_method,
|
|
&error);
|
|
return NULL;
|
|
}
|
|
|
|
g_object_unref (config);
|
|
|
|
return config;
|
|
}
|
|
|
|
static void
|
|
handle_orientation_change (MetaOrientationManager *orientation_manager,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
MetaOrientation orientation;
|
|
MetaMonitorTransform transform;
|
|
MetaMonitorTransform panel_transform;
|
|
GError *error = NULL;
|
|
MetaMonitorsConfig *config;
|
|
MetaMonitor *laptop_panel;
|
|
MetaLogicalMonitor *laptop_logical_monitor;
|
|
MetaMonitorsConfig *current_config;
|
|
|
|
laptop_panel = meta_monitor_manager_get_laptop_panel (manager);
|
|
g_return_if_fail (laptop_panel);
|
|
|
|
if (!meta_monitor_is_active (laptop_panel))
|
|
return;
|
|
|
|
orientation = meta_orientation_manager_get_orientation (orientation_manager);
|
|
transform = meta_monitor_transform_from_orientation (orientation);
|
|
|
|
laptop_logical_monitor = meta_monitor_get_logical_monitor (laptop_panel);
|
|
panel_transform =
|
|
meta_monitor_crtc_to_logical_transform (laptop_panel, transform);
|
|
if (meta_logical_monitor_get_transform (laptop_logical_monitor) ==
|
|
panel_transform)
|
|
return;
|
|
|
|
current_config =
|
|
meta_monitor_config_manager_get_current (manager->config_manager);
|
|
if (!current_config)
|
|
return;
|
|
|
|
config =
|
|
meta_monitor_config_manager_create_for_orientation (manager->config_manager,
|
|
current_config,
|
|
transform);
|
|
if (!config)
|
|
return;
|
|
|
|
if (!meta_monitor_manager_apply_monitors_config (manager,
|
|
config,
|
|
META_MONITORS_CONFIG_METHOD_TEMPORARY,
|
|
&error))
|
|
{
|
|
g_warning ("Failed to use orientation monitor configuration: %s",
|
|
error->message);
|
|
g_error_free (error);
|
|
}
|
|
g_object_unref (config);
|
|
}
|
|
|
|
/*
|
|
* Special case for tablets with a native portrait mode and a keyboard dock,
|
|
* where the device gets docked in landscape mode. For this combo to work
|
|
* properly with mutter starting while the tablet is docked, we need to take
|
|
* the accelerometer reported orientation into account (at mutter startup)
|
|
* even if there is a tablet-mode-switch which indicates that the device is
|
|
* NOT in tablet-mode (because it is docked).
|
|
*/
|
|
static gboolean
|
|
handle_initial_orientation_change (MetaOrientationManager *orientation_manager,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
ClutterBackend *clutter_backend;
|
|
ClutterSeat *seat;
|
|
MetaMonitor *monitor;
|
|
MetaMonitorMode *mode;
|
|
int width, height;
|
|
|
|
clutter_backend = meta_backend_get_clutter_backend (manager->backend);
|
|
seat = clutter_backend_get_default_seat (clutter_backend);
|
|
|
|
/*
|
|
* This is a workaround to ignore the tablet mode switch on the initial config
|
|
* of devices with a native portrait mode panel. The touchscreen and
|
|
* accelerometer requirements for applying the orientation must still be met.
|
|
*/
|
|
if (!clutter_seat_has_touchscreen (seat) ||
|
|
!meta_orientation_manager_has_accelerometer (orientation_manager))
|
|
return FALSE;
|
|
|
|
/* Check for a portrait mode panel */
|
|
monitor = meta_monitor_manager_get_laptop_panel (manager);
|
|
if (!monitor)
|
|
return FALSE;
|
|
|
|
mode = meta_monitor_get_preferred_mode (monitor);
|
|
meta_monitor_mode_get_resolution (mode, &width, &height);
|
|
if (width > height)
|
|
return FALSE;
|
|
|
|
handle_orientation_change (orientation_manager, manager);
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
orientation_changed (MetaOrientationManager *orientation_manager,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
if (!priv->initial_orient_change_done)
|
|
{
|
|
priv->initial_orient_change_done = TRUE;
|
|
if (handle_initial_orientation_change (orientation_manager, manager))
|
|
return;
|
|
}
|
|
|
|
if (!manager->panel_orientation_managed)
|
|
return;
|
|
|
|
handle_orientation_change (orientation_manager, manager);
|
|
}
|
|
|
|
static void
|
|
experimental_features_changed (MetaSettings *settings,
|
|
MetaExperimentalFeature old_experimental_features,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
gboolean was_stage_views_scaled;
|
|
gboolean is_stage_views_scaled;
|
|
gboolean should_reconfigure = FALSE;
|
|
|
|
was_stage_views_scaled =
|
|
!!(old_experimental_features &
|
|
META_EXPERIMENTAL_FEATURE_SCALE_MONITOR_FRAMEBUFFER);
|
|
is_stage_views_scaled =
|
|
meta_settings_is_experimental_feature_enabled (
|
|
settings,
|
|
META_EXPERIMENTAL_FEATURE_SCALE_MONITOR_FRAMEBUFFER);
|
|
|
|
if (is_stage_views_scaled != was_stage_views_scaled)
|
|
should_reconfigure = TRUE;
|
|
|
|
if (should_reconfigure)
|
|
meta_monitor_manager_reconfigure (manager);
|
|
|
|
meta_settings_update_ui_scaling_factor (settings);
|
|
}
|
|
|
|
static gboolean
|
|
ensure_privacy_screen_settings (MetaMonitorManager *manager)
|
|
{
|
|
MetaSettings *settings = meta_backend_get_settings (manager->backend);
|
|
gboolean privacy_screen_enabled;
|
|
GList *l;
|
|
|
|
privacy_screen_enabled = meta_settings_is_privacy_screen_enabled (settings);
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
g_autoptr (GError) error = NULL;
|
|
|
|
if (!meta_monitor_set_privacy_screen_enabled (monitor,
|
|
privacy_screen_enabled,
|
|
&error))
|
|
{
|
|
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED))
|
|
continue;
|
|
|
|
g_warning ("Failed to set privacy screen setting on monitor %s: %s",
|
|
meta_monitor_get_display_name (monitor), error->message);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static MetaPrivacyScreenState
|
|
get_global_privacy_screen_state (MetaMonitorManager *manager)
|
|
{
|
|
MetaPrivacyScreenState global_state = META_PRIVACY_SCREEN_UNAVAILABLE;
|
|
GList *l;
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
MetaPrivacyScreenState monitor_state;
|
|
|
|
if (!meta_monitor_is_active (monitor))
|
|
continue;
|
|
|
|
monitor_state = meta_monitor_get_privacy_screen_state (monitor);
|
|
if (monitor_state == META_PRIVACY_SCREEN_UNAVAILABLE)
|
|
continue;
|
|
|
|
if (monitor_state & META_PRIVACY_SCREEN_DISABLED)
|
|
return META_PRIVACY_SCREEN_DISABLED;
|
|
|
|
if (monitor_state & META_PRIVACY_SCREEN_ENABLED)
|
|
global_state = META_PRIVACY_SCREEN_ENABLED;
|
|
}
|
|
|
|
return global_state;
|
|
}
|
|
|
|
static gboolean
|
|
privacy_screen_needs_update (MetaMonitorManager *manager)
|
|
{
|
|
MetaSettings *settings = meta_backend_get_settings (manager->backend);
|
|
MetaPrivacyScreenState privacy_screen_state =
|
|
get_global_privacy_screen_state (manager);
|
|
|
|
if (privacy_screen_state == META_PRIVACY_SCREEN_UNAVAILABLE)
|
|
return FALSE;
|
|
|
|
return (!!(privacy_screen_state & META_PRIVACY_SCREEN_ENABLED) !=
|
|
meta_settings_is_privacy_screen_enabled (settings));
|
|
}
|
|
|
|
static void
|
|
apply_privacy_screen_settings (MetaMonitorManager *manager)
|
|
{
|
|
if (privacy_screen_needs_update (manager) &&
|
|
ensure_privacy_screen_settings (manager))
|
|
{
|
|
manager->privacy_screen_change_state =
|
|
META_PRIVACY_SCREEN_CHANGE_STATE_PENDING_SETTING;
|
|
}
|
|
}
|
|
|
|
static void
|
|
update_panel_orientation_managed (MetaMonitorManager *manager)
|
|
{
|
|
MetaOrientationManager *orientation_manager;
|
|
ClutterBackend *clutter_backend;
|
|
ClutterSeat *seat;
|
|
gboolean panel_orientation_managed;
|
|
|
|
clutter_backend = meta_backend_get_clutter_backend (manager->backend);
|
|
seat = clutter_backend_get_default_seat (clutter_backend);
|
|
|
|
orientation_manager = meta_backend_get_orientation_manager (manager->backend);
|
|
|
|
panel_orientation_managed =
|
|
(clutter_seat_get_touch_mode (seat) &&
|
|
meta_orientation_manager_has_accelerometer (orientation_manager) &&
|
|
meta_monitor_manager_get_laptop_panel (manager));
|
|
|
|
if (manager->panel_orientation_managed == panel_orientation_managed)
|
|
return;
|
|
|
|
manager->panel_orientation_managed = panel_orientation_managed;
|
|
g_object_notify_by_pspec (G_OBJECT (manager),
|
|
obj_props[PROP_PANEL_ORIENTATION_MANAGED]);
|
|
|
|
meta_dbus_display_config_set_panel_orientation_managed (manager->display_config,
|
|
manager->panel_orientation_managed);
|
|
|
|
/* The orientation may have changed while it was unmanaged */
|
|
if (panel_orientation_managed)
|
|
handle_orientation_change (orientation_manager, manager);
|
|
}
|
|
|
|
static void
|
|
update_has_builtin_panel (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
GList *l;
|
|
gboolean has_builtin_panel = FALSE;
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = META_MONITOR (l->data);
|
|
|
|
if (meta_monitor_is_laptop_panel (monitor))
|
|
{
|
|
has_builtin_panel = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (priv->has_builtin_panel == has_builtin_panel)
|
|
return;
|
|
|
|
priv->has_builtin_panel = has_builtin_panel;
|
|
g_object_notify_by_pspec (G_OBJECT (manager),
|
|
obj_props[PROP_HAS_BUILTIN_PANEL]);
|
|
}
|
|
|
|
static void
|
|
update_night_light_supported (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
GList *l;
|
|
|
|
gboolean night_light_supported = FALSE;
|
|
|
|
for (l = meta_backend_get_gpus (manager->backend); l; l = l->next)
|
|
{
|
|
MetaGpu *gpu = l->data;
|
|
GList *l_crtc;
|
|
|
|
for (l_crtc = meta_gpu_get_crtcs (gpu); l_crtc; l_crtc = l_crtc->next)
|
|
{
|
|
MetaCrtc *crtc = l_crtc->data;
|
|
|
|
if (meta_crtc_get_gamma_lut_size (crtc) > 0)
|
|
{
|
|
night_light_supported = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (priv->night_light_supported == night_light_supported)
|
|
return;
|
|
|
|
priv->night_light_supported = night_light_supported;
|
|
g_object_notify_by_pspec (G_OBJECT (manager),
|
|
obj_props[PROP_NIGHT_LIGHT_SUPPORTED]);
|
|
meta_dbus_display_config_set_night_light_supported (manager->display_config,
|
|
night_light_supported);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_setup (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorConfigStore *config_store;
|
|
const MetaMonitorConfigPolicy *policy;
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
manager->in_init = TRUE;
|
|
|
|
manager->config_manager = meta_monitor_config_manager_new (manager);
|
|
config_store =
|
|
meta_monitor_config_manager_get_store (manager->config_manager);
|
|
policy = meta_monitor_config_store_get_policy (config_store);
|
|
meta_dbus_display_config_set_apply_monitors_config_allowed (manager->display_config,
|
|
policy->enable_dbus);
|
|
|
|
meta_dbus_display_config_set_night_light_supported (manager->display_config,
|
|
priv->night_light_supported);
|
|
|
|
meta_monitor_manager_read_current_state (manager);
|
|
|
|
meta_monitor_manager_ensure_initial_config (manager);
|
|
|
|
if (privacy_screen_needs_update (manager))
|
|
manager->privacy_screen_change_state = META_PRIVACY_SCREEN_CHANGE_STATE_INIT;
|
|
|
|
manager->in_init = FALSE;
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_constructed (GObject *object)
|
|
{
|
|
MetaMonitorManager *manager = META_MONITOR_MANAGER (object);
|
|
MetaBackend *backend = manager->backend;
|
|
MetaSettings *settings = meta_backend_get_settings (backend);
|
|
|
|
manager->display_config = meta_dbus_display_config_skeleton_new ();
|
|
|
|
g_signal_connect_object (settings,
|
|
"experimental-features-changed",
|
|
G_CALLBACK (experimental_features_changed),
|
|
manager, 0);
|
|
|
|
g_signal_connect_object (settings,
|
|
"privacy-screen-changed",
|
|
G_CALLBACK (apply_privacy_screen_settings),
|
|
manager, G_CONNECT_SWAPPED);
|
|
|
|
monitor_manager_setup_dbus_config_handlers (manager);
|
|
|
|
g_signal_connect_object (manager->display_config, "notify::power-save-mode",
|
|
G_CALLBACK (power_save_mode_changed), manager,
|
|
G_CONNECT_SWAPPED);
|
|
|
|
g_signal_connect_object (meta_backend_get_orientation_manager (backend),
|
|
"orientation-changed",
|
|
G_CALLBACK (orientation_changed),
|
|
manager, 0);
|
|
|
|
g_signal_connect_object (meta_backend_get_orientation_manager (backend),
|
|
"notify::has-accelerometer",
|
|
G_CALLBACK (update_panel_orientation_managed), manager,
|
|
G_CONNECT_SWAPPED);
|
|
|
|
g_signal_connect_object (backend,
|
|
"lid-is-closed-changed",
|
|
G_CALLBACK (lid_is_closed_changed),
|
|
manager, 0);
|
|
|
|
g_signal_connect (backend, "prepare-shutdown",
|
|
G_CALLBACK (prepare_shutdown),
|
|
manager);
|
|
|
|
g_signal_connect (manager, "notify::experimental-hdr",
|
|
G_CALLBACK (ensure_hdr_settings),
|
|
NULL);
|
|
|
|
manager->current_switch_config = META_MONITOR_SWITCH_CONFIG_UNKNOWN;
|
|
|
|
initialize_dbus_interface (manager);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_finalize (GObject *object)
|
|
{
|
|
MetaMonitorManager *manager = META_MONITOR_MANAGER (object);
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
g_list_free_full (manager->logical_monitors, g_object_unref);
|
|
|
|
g_warn_if_fail (!priv->virtual_monitors);
|
|
|
|
G_OBJECT_CLASS (meta_monitor_manager_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_dispose (GObject *object)
|
|
{
|
|
MetaMonitorManager *manager = META_MONITOR_MANAGER (object);
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
g_clear_handle_id (&manager->dbus_name_id, g_bus_unown_name);
|
|
|
|
g_clear_object (&manager->display_config);
|
|
g_clear_object (&manager->config_manager);
|
|
|
|
g_clear_handle_id (&manager->persistent_timeout_id, g_source_remove);
|
|
g_clear_handle_id (&manager->restore_config_id, g_source_remove);
|
|
g_clear_handle_id (&priv->switch_config_handle_id, g_source_remove);
|
|
|
|
G_OBJECT_CLASS (meta_monitor_manager_parent_class)->dispose (object);
|
|
}
|
|
|
|
static GBytes *
|
|
meta_monitor_manager_real_read_edid (MetaMonitorManager *manager,
|
|
MetaOutput *output)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_set_property (GObject *object,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
MetaMonitorManager *manager = META_MONITOR_MANAGER (object);
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_BACKEND:
|
|
manager->backend = g_value_get_object (value);
|
|
break;
|
|
case PROP_EXPERIMENTAL_HDR:
|
|
priv->experimental_hdr = g_value_dup_string (value);
|
|
break;
|
|
case PROP_PANEL_ORIENTATION_MANAGED:
|
|
case PROP_HAS_BUILTIN_PANEL:
|
|
case PROP_NIGHT_LIGHT_SUPPORTED:
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_get_property (GObject *object,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
MetaMonitorManager *manager = META_MONITOR_MANAGER (object);
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_BACKEND:
|
|
g_value_set_object (value, manager->backend);
|
|
break;
|
|
case PROP_PANEL_ORIENTATION_MANAGED:
|
|
g_value_set_boolean (value, manager->panel_orientation_managed);
|
|
break;
|
|
case PROP_HAS_BUILTIN_PANEL:
|
|
g_value_set_boolean (value, priv->has_builtin_panel);
|
|
break;
|
|
case PROP_NIGHT_LIGHT_SUPPORTED:
|
|
g_value_set_boolean (value, priv->night_light_supported);
|
|
break;
|
|
case PROP_EXPERIMENTAL_HDR:
|
|
g_value_set_string (value, priv->experimental_hdr);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
}
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_class_init (MetaMonitorManagerClass *klass)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
object_class->constructed = meta_monitor_manager_constructed;
|
|
object_class->dispose = meta_monitor_manager_dispose;
|
|
object_class->finalize = meta_monitor_manager_finalize;
|
|
object_class->get_property = meta_monitor_manager_get_property;
|
|
object_class->set_property = meta_monitor_manager_set_property;
|
|
|
|
klass->read_edid = meta_monitor_manager_real_read_edid;
|
|
klass->read_current_state = meta_monitor_manager_real_read_current_state;
|
|
|
|
signals[MONITORS_CHANGED] =
|
|
g_signal_new ("monitors-changed",
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
G_SIGNAL_RUN_LAST,
|
|
0,
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 0);
|
|
|
|
signals[MONITORS_CHANGED_INTERNAL] =
|
|
g_signal_new ("monitors-changed-internal",
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
G_SIGNAL_RUN_LAST,
|
|
0,
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 0);
|
|
|
|
signals[POWER_SAVE_MODE_CHANGED] =
|
|
g_signal_new ("power-save-mode-changed",
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
G_SIGNAL_RUN_LAST,
|
|
0,
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 0);
|
|
|
|
signals[CONFIRM_DISPLAY_CHANGE] =
|
|
g_signal_new ("confirm-display-change",
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
G_SIGNAL_RUN_LAST,
|
|
0,
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 0);
|
|
|
|
/**
|
|
* MetaMonitorManager::monitor-privacy-screen-changed: (skip)
|
|
* @monitor_manager: The #MetaMonitorManager
|
|
* @logical_monitor: The #MetaLogicalMonitor where the privacy screen state
|
|
* changed
|
|
* @enabled: %TRUE if the privacy screen was enabled, otherwise %FALSE
|
|
*/
|
|
signals[MONITOR_PRIVACY_SCREEN_CHANGED] =
|
|
g_signal_new ("monitor-privacy-screen-changed",
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
G_SIGNAL_RUN_LAST,
|
|
0,
|
|
NULL, NULL, NULL,
|
|
G_TYPE_NONE, 2, META_TYPE_LOGICAL_MONITOR, G_TYPE_BOOLEAN);
|
|
|
|
obj_props[PROP_BACKEND] =
|
|
g_param_spec_object ("backend",
|
|
"backend",
|
|
"MetaBackend",
|
|
META_TYPE_BACKEND,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT_ONLY |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
obj_props[PROP_PANEL_ORIENTATION_MANAGED] =
|
|
g_param_spec_boolean ("panel-orientation-managed",
|
|
"Panel orientation managed",
|
|
"Panel orientation is managed",
|
|
FALSE,
|
|
G_PARAM_READABLE |
|
|
G_PARAM_EXPLICIT_NOTIFY |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
obj_props[PROP_HAS_BUILTIN_PANEL] =
|
|
g_param_spec_boolean ("has-builtin-panel",
|
|
"Has builtin panel",
|
|
"The system has a built in panel",
|
|
FALSE,
|
|
G_PARAM_READABLE |
|
|
G_PARAM_EXPLICIT_NOTIFY |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
obj_props[PROP_NIGHT_LIGHT_SUPPORTED] =
|
|
g_param_spec_boolean ("night-light-supported",
|
|
"Night light supported",
|
|
"Night light is supported",
|
|
FALSE,
|
|
G_PARAM_READABLE |
|
|
G_PARAM_EXPLICIT_NOTIFY |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
obj_props[PROP_EXPERIMENTAL_HDR] =
|
|
g_param_spec_string ("experimental-hdr",
|
|
"Experimental HDR",
|
|
"Experimental HDR settings string",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_STRINGS);
|
|
|
|
g_object_class_install_properties (object_class, PROP_LAST, obj_props);
|
|
}
|
|
|
|
gboolean
|
|
meta_monitor_has_aspect_as_size (MetaMonitor *monitor)
|
|
{
|
|
int width_mm;
|
|
int height_mm;
|
|
|
|
meta_monitor_get_physical_dimensions (monitor, &width_mm, &height_mm);
|
|
|
|
return (width_mm == 1600 && height_mm == 900) ||
|
|
(width_mm == 1600 && height_mm == 1000) ||
|
|
(width_mm == 160 && height_mm == 90) ||
|
|
(width_mm == 160 && height_mm == 100) ||
|
|
(width_mm == 16 && height_mm == 9) ||
|
|
(width_mm == 16 && height_mm == 10);
|
|
}
|
|
|
|
static const char *
|
|
get_connector_type_name (MetaConnectorType connector_type)
|
|
{
|
|
switch (connector_type)
|
|
{
|
|
case META_CONNECTOR_TYPE_Unknown: return "Unknown";
|
|
case META_CONNECTOR_TYPE_VGA: return "VGA";
|
|
case META_CONNECTOR_TYPE_DVII: return "DVII";
|
|
case META_CONNECTOR_TYPE_DVID: return "DVID";
|
|
case META_CONNECTOR_TYPE_DVIA: return "DVIA";
|
|
case META_CONNECTOR_TYPE_Composite: return "Composite";
|
|
case META_CONNECTOR_TYPE_SVIDEO: return "SVIDEO";
|
|
case META_CONNECTOR_TYPE_LVDS: return "LVDS";
|
|
case META_CONNECTOR_TYPE_Component: return "Component";
|
|
case META_CONNECTOR_TYPE_9PinDIN: return "9PinDIN";
|
|
case META_CONNECTOR_TYPE_DisplayPort: return "DisplayPort";
|
|
case META_CONNECTOR_TYPE_HDMIA: return "HDMIA";
|
|
case META_CONNECTOR_TYPE_HDMIB: return "HDMIB";
|
|
case META_CONNECTOR_TYPE_TV: return "TV";
|
|
case META_CONNECTOR_TYPE_eDP: return "eDP";
|
|
case META_CONNECTOR_TYPE_VIRTUAL: return "VIRTUAL";
|
|
case META_CONNECTOR_TYPE_DSI: return "DSI";
|
|
case META_CONNECTOR_TYPE_DPI: return "DPI";
|
|
case META_CONNECTOR_TYPE_WRITEBACK: return "WRITEBACK";
|
|
case META_CONNECTOR_TYPE_SPI: return "SPI";
|
|
case META_CONNECTOR_TYPE_USB: return "USB";
|
|
default: g_assert_not_reached ();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static GList *
|
|
combine_gpu_lists (MetaMonitorManager *manager,
|
|
GList * (*list_getter) (MetaGpu *gpu))
|
|
{
|
|
GList *gpus;
|
|
GList *list = NULL;
|
|
GList *l;
|
|
|
|
gpus = meta_backend_get_gpus (manager->backend);
|
|
for (l = gpus; l; l = l->next)
|
|
{
|
|
MetaGpu *gpu = l->data;
|
|
|
|
list = g_list_concat (list, g_list_copy (list_getter (gpu)));
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
static void
|
|
emit_privacy_screen_change (MetaMonitorManager *manager)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
MetaPrivacyScreenState privacy_screen_state;
|
|
gboolean enabled;
|
|
|
|
if (!meta_monitor_is_active (monitor))
|
|
continue;
|
|
|
|
privacy_screen_state = meta_monitor_get_privacy_screen_state (monitor);
|
|
if (privacy_screen_state == META_PRIVACY_SCREEN_UNAVAILABLE)
|
|
continue;
|
|
|
|
enabled = !!(privacy_screen_state & META_PRIVACY_SCREEN_ENABLED);
|
|
|
|
g_signal_emit (manager, signals[MONITOR_PRIVACY_SCREEN_CHANGED], 0,
|
|
meta_monitor_get_logical_monitor (monitor), enabled);
|
|
}
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_maybe_emit_privacy_screen_change (MetaMonitorManager *manager)
|
|
{
|
|
MetaPrivacyScreenChangeState reason = manager->privacy_screen_change_state;
|
|
|
|
if (reason == META_PRIVACY_SCREEN_CHANGE_STATE_NONE ||
|
|
reason == META_PRIVACY_SCREEN_CHANGE_STATE_INIT)
|
|
return;
|
|
|
|
if (reason == META_PRIVACY_SCREEN_CHANGE_STATE_PENDING_HOTKEY)
|
|
emit_privacy_screen_change (manager);
|
|
|
|
if (reason != META_PRIVACY_SCREEN_CHANGE_STATE_PENDING_SETTING)
|
|
{
|
|
MetaSettings *settings = meta_backend_get_settings (manager->backend);
|
|
|
|
meta_settings_set_privacy_screen_enabled (settings,
|
|
get_global_privacy_screen_state (manager) ==
|
|
META_PRIVACY_SCREEN_ENABLED);
|
|
}
|
|
|
|
meta_dbus_display_config_emit_monitors_changed (manager->display_config);
|
|
manager->privacy_screen_change_state = META_PRIVACY_SCREEN_CHANGE_STATE_NONE;
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_handle_get_resources (MetaDBusDisplayConfig *skeleton,
|
|
GDBusMethodInvocation *invocation,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerClass *manager_class = META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
GList *combined_modes;
|
|
GList *combined_outputs;
|
|
GList *combined_crtcs;
|
|
GVariantBuilder crtc_builder, output_builder, mode_builder;
|
|
GList *l;
|
|
unsigned int i, j;
|
|
int max_screen_width;
|
|
int max_screen_height;
|
|
|
|
combined_modes = combine_gpu_lists (manager, meta_gpu_get_modes);
|
|
combined_outputs = combine_gpu_lists (manager, meta_gpu_get_outputs);
|
|
combined_crtcs = combine_gpu_lists (manager, meta_gpu_get_crtcs);
|
|
|
|
g_variant_builder_init (&crtc_builder, G_VARIANT_TYPE ("a(uxiiiiiuaua{sv})"));
|
|
g_variant_builder_init (&output_builder, G_VARIANT_TYPE ("a(uxiausauaua{sv})"));
|
|
g_variant_builder_init (&mode_builder, G_VARIANT_TYPE ("a(uxuudu)"));
|
|
|
|
for (l = combined_crtcs, i = 0; l; l = l->next, i++)
|
|
{
|
|
MetaCrtc *crtc = l->data;
|
|
GVariantBuilder transforms;
|
|
const MetaCrtcConfig *crtc_config;
|
|
|
|
g_variant_builder_init (&transforms, G_VARIANT_TYPE ("au"));
|
|
for (j = 0; j <= META_MONITOR_TRANSFORM_FLIPPED_270; j++)
|
|
{
|
|
if (meta_crtc_get_all_transforms (crtc) & (1 << j))
|
|
g_variant_builder_add (&transforms, "u", j);
|
|
}
|
|
|
|
crtc_config = meta_crtc_get_config (crtc);
|
|
if (crtc_config)
|
|
{
|
|
int current_mode_index;
|
|
|
|
current_mode_index = g_list_index (combined_modes, crtc_config->mode);
|
|
g_variant_builder_add (&crtc_builder, "(uxiiiiiuaua{sv})",
|
|
i, /* ID */
|
|
(int64_t) meta_crtc_get_id (crtc),
|
|
(int) roundf (crtc_config->layout.origin.x),
|
|
(int) roundf (crtc_config->layout.origin.y),
|
|
(int) roundf (crtc_config->layout.size.width),
|
|
(int) roundf (crtc_config->layout.size.height),
|
|
current_mode_index,
|
|
(uint32_t) crtc_config->transform,
|
|
&transforms,
|
|
NULL /* properties */);
|
|
}
|
|
else
|
|
{
|
|
g_variant_builder_add (&crtc_builder, "(uxiiiiiuaua{sv})",
|
|
i, /* ID */
|
|
(int64_t) meta_crtc_get_id (crtc),
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
-1,
|
|
(uint32_t) META_MONITOR_TRANSFORM_NORMAL,
|
|
&transforms,
|
|
NULL /* properties */);
|
|
}
|
|
}
|
|
|
|
for (l = combined_outputs, i = 0; l; l = l->next, i++)
|
|
{
|
|
MetaOutput *output = l->data;
|
|
const MetaOutputInfo *output_info = meta_output_get_info (output);
|
|
GVariantBuilder crtcs, modes, clones, properties;
|
|
GBytes *edid;
|
|
MetaCrtc *crtc;
|
|
int crtc_index;
|
|
int backlight;
|
|
int min_backlight_step;
|
|
gboolean is_primary;
|
|
gboolean is_presentation;
|
|
const char * connector_type_name;
|
|
gboolean is_underscanning;
|
|
gboolean supports_underscanning;
|
|
gboolean supports_color_transform;
|
|
const char *vendor;
|
|
const char *product;
|
|
const char *serial;
|
|
|
|
g_variant_builder_init (&crtcs, G_VARIANT_TYPE ("au"));
|
|
for (j = 0; j < output_info->n_possible_crtcs; j++)
|
|
{
|
|
MetaCrtc *possible_crtc = output_info->possible_crtcs[j];
|
|
unsigned possible_crtc_index;
|
|
|
|
possible_crtc_index = g_list_index (combined_crtcs, possible_crtc);
|
|
g_variant_builder_add (&crtcs, "u", possible_crtc_index);
|
|
}
|
|
|
|
g_variant_builder_init (&modes, G_VARIANT_TYPE ("au"));
|
|
for (j = 0; j < output_info->n_modes; j++)
|
|
{
|
|
unsigned mode_index;
|
|
|
|
mode_index = g_list_index (combined_modes, output_info->modes[j]);
|
|
g_variant_builder_add (&modes, "u", mode_index);
|
|
}
|
|
|
|
g_variant_builder_init (&clones, G_VARIANT_TYPE ("au"));
|
|
for (j = 0; j < output_info->n_possible_clones; j++)
|
|
{
|
|
unsigned int possible_clone_index;
|
|
|
|
possible_clone_index = g_list_index (combined_outputs,
|
|
output_info->possible_clones[j]);
|
|
g_variant_builder_add (&clones, "u", possible_clone_index);
|
|
}
|
|
|
|
backlight = meta_output_get_backlight (output);
|
|
min_backlight_step =
|
|
output_info->backlight_max - output_info->backlight_min
|
|
? 100 / (output_info->backlight_max - output_info->backlight_min)
|
|
: -1;
|
|
is_primary = meta_output_is_primary (output);
|
|
is_presentation = meta_output_is_presentation (output);
|
|
is_underscanning = meta_output_is_underscanning (output);
|
|
connector_type_name = get_connector_type_name (output_info->connector_type);
|
|
supports_underscanning = output_info->supports_underscanning;
|
|
supports_color_transform = output_info->supports_color_transform;
|
|
vendor = output_info->vendor;
|
|
product = output_info->product;
|
|
serial = output_info->serial;
|
|
|
|
g_variant_builder_init (&properties, G_VARIANT_TYPE ("a{sv}"));
|
|
g_variant_builder_add (&properties, "{sv}", "vendor",
|
|
g_variant_new_string (vendor ? vendor : "unknown"));
|
|
g_variant_builder_add (&properties, "{sv}", "product",
|
|
g_variant_new_string (product ? product : "unknown"));
|
|
g_variant_builder_add (&properties, "{sv}", "serial",
|
|
g_variant_new_string (serial ? serial : "unknown"));
|
|
g_variant_builder_add (&properties, "{sv}", "width-mm",
|
|
g_variant_new_int32 (output_info->width_mm));
|
|
g_variant_builder_add (&properties, "{sv}", "height-mm",
|
|
g_variant_new_int32 (output_info->height_mm));
|
|
g_variant_builder_add (&properties, "{sv}", "display-name",
|
|
g_variant_new_string (output_info->name));
|
|
g_variant_builder_add (&properties, "{sv}", "backlight",
|
|
g_variant_new_int32 (backlight));
|
|
g_variant_builder_add (&properties, "{sv}", "min-backlight-step",
|
|
g_variant_new_int32 (min_backlight_step));
|
|
g_variant_builder_add (&properties, "{sv}", "primary",
|
|
g_variant_new_boolean (is_primary));
|
|
g_variant_builder_add (&properties, "{sv}", "presentation",
|
|
g_variant_new_boolean (is_presentation));
|
|
g_variant_builder_add (&properties, "{sv}", "connector-type",
|
|
g_variant_new_string (connector_type_name));
|
|
g_variant_builder_add (&properties, "{sv}", "underscanning",
|
|
g_variant_new_boolean (is_underscanning));
|
|
g_variant_builder_add (&properties, "{sv}", "supports-underscanning",
|
|
g_variant_new_boolean (supports_underscanning));
|
|
g_variant_builder_add (&properties, "{sv}", "supports-color-transform",
|
|
g_variant_new_boolean (supports_color_transform));
|
|
|
|
edid = manager_class->read_edid (manager, output);
|
|
if (edid)
|
|
{
|
|
g_variant_builder_add (&properties, "{sv}", "edid",
|
|
g_variant_new_from_bytes (G_VARIANT_TYPE ("ay"),
|
|
edid, TRUE));
|
|
g_bytes_unref (edid);
|
|
}
|
|
|
|
if (output_info->tile_info.group_id)
|
|
{
|
|
GVariant *tile_variant;
|
|
|
|
tile_variant = g_variant_new ("(uuuuuuuu)",
|
|
output_info->tile_info.group_id,
|
|
output_info->tile_info.flags,
|
|
output_info->tile_info.max_h_tiles,
|
|
output_info->tile_info.max_v_tiles,
|
|
output_info->tile_info.loc_h_tile,
|
|
output_info->tile_info.loc_v_tile,
|
|
output_info->tile_info.tile_w,
|
|
output_info->tile_info.tile_h);
|
|
g_variant_builder_add (&properties, "{sv}", "tile", tile_variant);
|
|
}
|
|
|
|
crtc = meta_output_get_assigned_crtc (output);
|
|
crtc_index = crtc ? g_list_index (combined_crtcs, crtc) : -1;
|
|
g_variant_builder_add (&output_builder, "(uxiausauaua{sv})",
|
|
i, /* ID */
|
|
meta_output_get_id (output),
|
|
crtc_index,
|
|
&crtcs,
|
|
meta_output_get_name (output),
|
|
&modes,
|
|
&clones,
|
|
&properties);
|
|
}
|
|
|
|
for (l = combined_modes, i = 0; l; l = l->next, i++)
|
|
{
|
|
MetaCrtcMode *mode = l->data;
|
|
const MetaCrtcModeInfo *crtc_mode_info =
|
|
meta_crtc_mode_get_info (mode);
|
|
|
|
g_variant_builder_add (&mode_builder, "(uxuudu)",
|
|
i, /* ID */
|
|
(int64_t) meta_crtc_mode_get_id (mode),
|
|
(uint32_t) crtc_mode_info->width,
|
|
(uint32_t) crtc_mode_info->height,
|
|
(double) crtc_mode_info->refresh_rate,
|
|
(uint32_t) crtc_mode_info->flags);
|
|
}
|
|
|
|
if (!meta_monitor_manager_get_max_screen_size (manager,
|
|
&max_screen_width,
|
|
&max_screen_height))
|
|
{
|
|
/* No max screen size, just send something large */
|
|
max_screen_width = 65535;
|
|
max_screen_height = 65535;
|
|
}
|
|
|
|
meta_dbus_display_config_complete_get_resources (skeleton,
|
|
invocation,
|
|
manager->serial,
|
|
g_variant_builder_end (&crtc_builder),
|
|
g_variant_builder_end (&output_builder),
|
|
g_variant_builder_end (&mode_builder),
|
|
max_screen_width,
|
|
max_screen_height);
|
|
|
|
g_list_free (combined_modes);
|
|
g_list_free (combined_outputs);
|
|
g_list_free (combined_crtcs);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
restore_previous_config (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorsConfig *previous_config;
|
|
GError *error = NULL;
|
|
|
|
previous_config =
|
|
meta_monitor_config_manager_pop_previous (manager->config_manager);
|
|
|
|
if (previous_config)
|
|
{
|
|
MetaMonitorsConfigMethod method;
|
|
|
|
if (manager->panel_orientation_managed)
|
|
{
|
|
g_autoptr (MetaMonitorsConfig) oriented_config = NULL;
|
|
|
|
oriented_config =
|
|
meta_monitor_config_manager_create_for_builtin_orientation (
|
|
manager->config_manager, previous_config);
|
|
|
|
if (oriented_config)
|
|
g_set_object (&previous_config, oriented_config);
|
|
}
|
|
|
|
method = META_MONITORS_CONFIG_METHOD_TEMPORARY;
|
|
if (meta_monitor_manager_apply_monitors_config (manager,
|
|
previous_config,
|
|
method,
|
|
&error))
|
|
{
|
|
g_object_unref (previous_config);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
g_object_unref (previous_config);
|
|
g_warning ("Failed to restore previous configuration: %s",
|
|
error->message);
|
|
g_error_free (error);
|
|
}
|
|
}
|
|
|
|
meta_monitor_manager_ensure_configured (manager);
|
|
}
|
|
|
|
int
|
|
meta_monitor_manager_get_display_configuration_timeout (MetaMonitorManager *manager)
|
|
{
|
|
return DEFAULT_DISPLAY_CONFIGURATION_TIMEOUT;
|
|
}
|
|
|
|
static gboolean
|
|
save_config_timeout (gpointer user_data)
|
|
{
|
|
MetaMonitorManager *manager = user_data;
|
|
|
|
restore_previous_config (manager);
|
|
manager->persistent_timeout_id = 0;
|
|
|
|
return G_SOURCE_REMOVE;
|
|
}
|
|
|
|
static void
|
|
request_persistent_confirmation (MetaMonitorManager *manager)
|
|
{
|
|
int timeout_s;
|
|
|
|
timeout_s = meta_monitor_manager_get_display_configuration_timeout (manager);
|
|
manager->persistent_timeout_id = g_timeout_add_seconds (timeout_s,
|
|
save_config_timeout,
|
|
manager);
|
|
g_source_set_name_by_id (manager->persistent_timeout_id,
|
|
"[mutter] save_config_timeout");
|
|
|
|
g_signal_emit (manager, signals[CONFIRM_DISPLAY_CHANGE], 0);
|
|
}
|
|
|
|
#define META_DISPLAY_CONFIG_MODE_FLAGS_PREFERRED (1 << 0)
|
|
#define META_DISPLAY_CONFIG_MODE_FLAGS_CURRENT (1 << 1)
|
|
|
|
#define MODE_FORMAT "(siiddada{sv})"
|
|
#define MODES_FORMAT "a" MODE_FORMAT
|
|
#define MONITOR_SPEC_FORMAT "(ssss)"
|
|
#define MONITOR_FORMAT "(" MONITOR_SPEC_FORMAT MODES_FORMAT "a{sv})"
|
|
#define MONITORS_FORMAT "a" MONITOR_FORMAT
|
|
|
|
#define LOGICAL_MONITOR_MONITORS_FORMAT "a" MONITOR_SPEC_FORMAT
|
|
#define LOGICAL_MONITOR_FORMAT "(iidub" LOGICAL_MONITOR_MONITORS_FORMAT "a{sv})"
|
|
#define LOGICAL_MONITORS_FORMAT "a" LOGICAL_MONITOR_FORMAT
|
|
|
|
static gboolean
|
|
meta_monitor_manager_handle_get_current_state (MetaDBusDisplayConfig *skeleton,
|
|
GDBusMethodInvocation *invocation,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
MetaSettings *settings = meta_backend_get_settings (manager->backend);
|
|
GVariantBuilder monitors_builder;
|
|
GVariantBuilder logical_monitors_builder;
|
|
GVariantBuilder properties_builder;
|
|
GList *l;
|
|
int i;
|
|
MetaMonitorManagerCapability capabilities;
|
|
int ui_scaling_factor;
|
|
int max_screen_width, max_screen_height;
|
|
|
|
g_variant_builder_init (&monitors_builder,
|
|
G_VARIANT_TYPE (MONITORS_FORMAT));
|
|
g_variant_builder_init (&logical_monitors_builder,
|
|
G_VARIANT_TYPE (LOGICAL_MONITORS_FORMAT));
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
MetaMonitorSpec *monitor_spec = meta_monitor_get_spec (monitor);
|
|
MetaMonitorMode *current_mode;
|
|
MetaMonitorMode *preferred_mode;
|
|
MetaPrivacyScreenState privacy_screen_state;
|
|
GVariantBuilder modes_builder;
|
|
GVariantBuilder monitor_properties_builder;
|
|
GList *k;
|
|
gboolean is_builtin;
|
|
const char *display_name;
|
|
|
|
current_mode = meta_monitor_get_current_mode (monitor);
|
|
preferred_mode = meta_monitor_get_preferred_mode (monitor);
|
|
|
|
g_variant_builder_init (&modes_builder, G_VARIANT_TYPE (MODES_FORMAT));
|
|
for (k = meta_monitor_get_modes (monitor); k; k = k->next)
|
|
{
|
|
MetaMonitorMode *monitor_mode = k->data;
|
|
GVariantBuilder supported_scales_builder;
|
|
const char *mode_id;
|
|
int mode_width, mode_height;
|
|
float refresh_rate;
|
|
float preferred_scale;
|
|
float *supported_scales;
|
|
int n_supported_scales;
|
|
GVariantBuilder mode_properties_builder;
|
|
MetaCrtcModeFlag mode_flags;
|
|
|
|
if (!meta_monitor_mode_should_be_advertised (monitor_mode))
|
|
continue;
|
|
|
|
mode_id = meta_monitor_mode_get_id (monitor_mode);
|
|
meta_monitor_mode_get_resolution (monitor_mode,
|
|
&mode_width, &mode_height);
|
|
|
|
refresh_rate = meta_monitor_mode_get_refresh_rate (monitor_mode);
|
|
|
|
preferred_scale =
|
|
meta_monitor_manager_calculate_monitor_mode_scale (manager,
|
|
manager->layout_mode,
|
|
monitor,
|
|
monitor_mode);
|
|
|
|
g_variant_builder_init (&supported_scales_builder,
|
|
G_VARIANT_TYPE ("ad"));
|
|
supported_scales =
|
|
meta_monitor_manager_calculate_supported_scales (manager,
|
|
manager->layout_mode,
|
|
monitor,
|
|
monitor_mode,
|
|
&n_supported_scales);
|
|
for (i = 0; i < n_supported_scales; i++)
|
|
g_variant_builder_add (&supported_scales_builder, "d",
|
|
(double) supported_scales[i]);
|
|
g_free (supported_scales);
|
|
|
|
mode_flags = meta_monitor_mode_get_flags (monitor_mode);
|
|
|
|
g_variant_builder_init (&mode_properties_builder,
|
|
G_VARIANT_TYPE ("a{sv}"));
|
|
if (monitor_mode == current_mode)
|
|
g_variant_builder_add (&mode_properties_builder, "{sv}",
|
|
"is-current",
|
|
g_variant_new_boolean (TRUE));
|
|
if (monitor_mode == preferred_mode)
|
|
g_variant_builder_add (&mode_properties_builder, "{sv}",
|
|
"is-preferred",
|
|
g_variant_new_boolean (TRUE));
|
|
if (mode_flags & META_CRTC_MODE_FLAG_INTERLACE)
|
|
g_variant_builder_add (&mode_properties_builder, "{sv}",
|
|
"is-interlaced",
|
|
g_variant_new_boolean (TRUE));
|
|
|
|
g_variant_builder_add (&modes_builder, MODE_FORMAT,
|
|
mode_id,
|
|
mode_width,
|
|
mode_height,
|
|
refresh_rate,
|
|
(double) preferred_scale,
|
|
&supported_scales_builder,
|
|
&mode_properties_builder);
|
|
}
|
|
|
|
g_variant_builder_init (&monitor_properties_builder,
|
|
G_VARIANT_TYPE ("a{sv}"));
|
|
if (meta_monitor_supports_underscanning (monitor))
|
|
{
|
|
gboolean is_underscanning = meta_monitor_is_underscanning (monitor);
|
|
|
|
g_variant_builder_add (&monitor_properties_builder, "{sv}",
|
|
"is-underscanning",
|
|
g_variant_new_boolean (is_underscanning));
|
|
}
|
|
|
|
is_builtin = meta_monitor_is_laptop_panel (monitor);
|
|
g_variant_builder_add (&monitor_properties_builder, "{sv}",
|
|
"is-builtin",
|
|
g_variant_new_boolean (is_builtin));
|
|
|
|
display_name = meta_monitor_get_display_name (monitor);
|
|
g_variant_builder_add (&monitor_properties_builder, "{sv}",
|
|
"display-name",
|
|
g_variant_new_string (display_name));
|
|
|
|
privacy_screen_state = meta_monitor_get_privacy_screen_state (monitor);
|
|
if (privacy_screen_state != META_PRIVACY_SCREEN_UNAVAILABLE)
|
|
{
|
|
GVariant *state;
|
|
|
|
state = g_variant_new ("(bb)",
|
|
!!(privacy_screen_state & META_PRIVACY_SCREEN_ENABLED),
|
|
!!(privacy_screen_state & META_PRIVACY_SCREEN_LOCKED));
|
|
|
|
g_variant_builder_add (&monitor_properties_builder, "{sv}",
|
|
"privacy-screen-state", state);
|
|
}
|
|
|
|
g_variant_builder_add (&monitors_builder, MONITOR_FORMAT,
|
|
monitor_spec->connector,
|
|
monitor_spec->vendor,
|
|
monitor_spec->product,
|
|
monitor_spec->serial,
|
|
&modes_builder,
|
|
&monitor_properties_builder);
|
|
}
|
|
|
|
for (l = manager->logical_monitors; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitor *logical_monitor = l->data;
|
|
GVariantBuilder logical_monitor_monitors_builder;
|
|
GList *k;
|
|
|
|
g_variant_builder_init (&logical_monitor_monitors_builder,
|
|
G_VARIANT_TYPE (LOGICAL_MONITOR_MONITORS_FORMAT));
|
|
|
|
for (k = logical_monitor->monitors; k; k = k->next)
|
|
{
|
|
MetaMonitor *monitor = k->data;
|
|
MetaMonitorSpec *monitor_spec = meta_monitor_get_spec (monitor);
|
|
|
|
g_variant_builder_add (&logical_monitor_monitors_builder,
|
|
MONITOR_SPEC_FORMAT,
|
|
monitor_spec->connector,
|
|
monitor_spec->vendor,
|
|
monitor_spec->product,
|
|
monitor_spec->serial);
|
|
}
|
|
|
|
g_variant_builder_add (&logical_monitors_builder,
|
|
LOGICAL_MONITOR_FORMAT,
|
|
logical_monitor->rect.x,
|
|
logical_monitor->rect.y,
|
|
(double) logical_monitor->scale,
|
|
logical_monitor->transform,
|
|
logical_monitor->is_primary,
|
|
&logical_monitor_monitors_builder,
|
|
NULL);
|
|
}
|
|
|
|
g_variant_builder_init (&properties_builder, G_VARIANT_TYPE ("a{sv}"));
|
|
capabilities = meta_monitor_manager_get_capabilities (manager);
|
|
|
|
g_variant_builder_add (&properties_builder, "{sv}",
|
|
"layout-mode",
|
|
g_variant_new_uint32 (manager->layout_mode));
|
|
if (capabilities & META_MONITOR_MANAGER_CAPABILITY_LAYOUT_MODE)
|
|
{
|
|
g_variant_builder_add (&properties_builder, "{sv}",
|
|
"supports-changing-layout-mode",
|
|
g_variant_new_boolean (TRUE));
|
|
}
|
|
|
|
if (capabilities & META_MONITOR_MANAGER_CAPABILITY_GLOBAL_SCALE_REQUIRED)
|
|
{
|
|
g_variant_builder_add (&properties_builder, "{sv}",
|
|
"global-scale-required",
|
|
g_variant_new_boolean (TRUE));
|
|
}
|
|
|
|
ui_scaling_factor = meta_settings_get_ui_scaling_factor (settings);
|
|
g_variant_builder_add (&properties_builder, "{sv}",
|
|
"legacy-ui-scaling-factor",
|
|
g_variant_new_int32 (ui_scaling_factor));
|
|
|
|
if (meta_monitor_manager_get_max_screen_size (manager,
|
|
&max_screen_width,
|
|
&max_screen_height))
|
|
{
|
|
GVariantBuilder max_screen_size_builder;
|
|
|
|
g_variant_builder_init (&max_screen_size_builder,
|
|
G_VARIANT_TYPE ("(ii)"));
|
|
g_variant_builder_add (&max_screen_size_builder, "i",
|
|
max_screen_width);
|
|
g_variant_builder_add (&max_screen_size_builder, "i",
|
|
max_screen_height);
|
|
|
|
g_variant_builder_add (&properties_builder, "{sv}",
|
|
"max-screen-size",
|
|
g_variant_builder_end (&max_screen_size_builder));
|
|
}
|
|
|
|
meta_dbus_display_config_complete_get_current_state (
|
|
skeleton,
|
|
invocation,
|
|
manager->serial,
|
|
g_variant_builder_end (&monitors_builder),
|
|
g_variant_builder_end (&logical_monitors_builder),
|
|
g_variant_builder_end (&properties_builder));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#undef MODE_FORMAT
|
|
#undef MODES_FORMAT
|
|
#undef MONITOR_SPEC_FORMAT
|
|
#undef MONITOR_FORMAT
|
|
#undef MONITORS_FORMAT
|
|
#undef LOGICAL_MONITOR_MONITORS_FORMAT
|
|
#undef LOGICAL_MONITOR_FORMAT
|
|
#undef LOGICAL_MONITORS_FORMAT
|
|
|
|
gboolean
|
|
meta_monitor_manager_is_scale_supported (MetaMonitorManager *manager,
|
|
MetaLogicalMonitorLayoutMode layout_mode,
|
|
MetaMonitor *monitor,
|
|
MetaMonitorMode *monitor_mode,
|
|
float scale)
|
|
{
|
|
g_autofree float *supported_scales = NULL;
|
|
int n_supported_scales;
|
|
int i;
|
|
|
|
supported_scales =
|
|
meta_monitor_manager_calculate_supported_scales (manager,
|
|
layout_mode,
|
|
monitor,
|
|
monitor_mode,
|
|
&n_supported_scales);
|
|
for (i = 0; i < n_supported_scales; i++)
|
|
{
|
|
if (supported_scales[i] == scale)
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
is_global_scale_matching_in_config (MetaMonitorsConfig *config,
|
|
float scale)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = config->logical_monitor_configs; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitorConfig *logical_monitor_config = l->data;
|
|
|
|
if (!G_APPROX_VALUE (logical_monitor_config->scale, scale, FLT_EPSILON))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_is_scale_supported_for_config (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config,
|
|
MetaMonitor *monitor,
|
|
MetaMonitorMode *monitor_mode,
|
|
float scale)
|
|
{
|
|
if (meta_monitor_manager_is_scale_supported (manager, config->layout_mode,
|
|
monitor, monitor_mode, scale))
|
|
{
|
|
if (meta_monitor_manager_get_capabilities (manager) &
|
|
META_MONITOR_MANAGER_CAPABILITY_GLOBAL_SCALE_REQUIRED)
|
|
return is_global_scale_matching_in_config (config, scale);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_is_config_applicable (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config,
|
|
GError **error)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = config->logical_monitor_configs; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitorConfig *logical_monitor_config = l->data;
|
|
float scale = logical_monitor_config->scale;
|
|
GList *k;
|
|
|
|
for (k = logical_monitor_config->monitor_configs; k; k = k->next)
|
|
{
|
|
MetaMonitorConfig *monitor_config = k->data;
|
|
MetaMonitorSpec *monitor_spec = monitor_config->monitor_spec;
|
|
MetaMonitorModeSpec *mode_spec = monitor_config->mode_spec;
|
|
MetaMonitor *monitor;
|
|
MetaMonitorMode *monitor_mode;
|
|
|
|
monitor = meta_monitor_manager_get_monitor_from_spec (manager,
|
|
monitor_spec);
|
|
if (!monitor)
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Specified monitor not found");
|
|
return FALSE;
|
|
}
|
|
|
|
monitor_mode = meta_monitor_get_mode_from_spec (monitor, mode_spec);
|
|
if (!monitor_mode)
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Specified monitor mode not available");
|
|
return FALSE;
|
|
}
|
|
|
|
if (!meta_monitor_manager_is_scale_supported_for_config (manager,
|
|
config,
|
|
monitor,
|
|
monitor_mode,
|
|
scale))
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Scale not supported by backend");
|
|
return FALSE;
|
|
}
|
|
|
|
if (meta_monitor_is_laptop_panel (monitor) &&
|
|
meta_backend_is_lid_closed (manager->backend))
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Refusing to activate a closed laptop panel");
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_is_config_complete (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config)
|
|
{
|
|
MetaMonitorsConfigKey *current_state_key;
|
|
gboolean is_config_complete;
|
|
|
|
current_state_key =
|
|
meta_create_monitors_config_key_for_current_state (manager);
|
|
if (!current_state_key)
|
|
return FALSE;
|
|
|
|
is_config_complete = meta_monitors_config_key_equal (current_state_key,
|
|
config->key);
|
|
meta_monitors_config_key_free (current_state_key);
|
|
|
|
if (!is_config_complete)
|
|
return FALSE;
|
|
|
|
return meta_monitor_manager_is_config_applicable (manager, config, NULL);
|
|
}
|
|
|
|
static MetaMonitor *
|
|
find_monitor_from_connector (MetaMonitorManager *manager,
|
|
char *connector)
|
|
{
|
|
GList *monitors;
|
|
GList *l;
|
|
|
|
if (!connector)
|
|
return NULL;
|
|
|
|
monitors = meta_monitor_manager_get_monitors (manager);
|
|
for (l = monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
MetaMonitorSpec *monitor_spec = meta_monitor_get_spec (monitor);
|
|
|
|
if (g_str_equal (connector, monitor_spec->connector))
|
|
return monitor;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#define MONITOR_CONFIG_FORMAT "(ssa{sv})"
|
|
#define MONITOR_CONFIGS_FORMAT "a" MONITOR_CONFIG_FORMAT
|
|
|
|
#define LOGICAL_MONITOR_CONFIG_FORMAT "(iidub" MONITOR_CONFIGS_FORMAT ")"
|
|
|
|
static MetaMonitorConfig *
|
|
create_monitor_config_from_variant (MetaMonitorManager *manager,
|
|
GVariant *monitor_config_variant,
|
|
GError **error)
|
|
{
|
|
|
|
MetaMonitorConfig *monitor_config = NULL;
|
|
g_autofree char *connector = NULL;
|
|
g_autofree char *mode_id = NULL;
|
|
MetaMonitorMode *monitor_mode;
|
|
MetaMonitor *monitor;
|
|
MetaMonitorSpec *monitor_spec;
|
|
MetaMonitorModeSpec *monitor_mode_spec;
|
|
g_autoptr (GVariant) properties_variant = NULL;
|
|
gboolean enable_underscanning = FALSE;
|
|
gboolean set_underscanning = FALSE;
|
|
|
|
g_variant_get (monitor_config_variant, "(ss@a{sv})",
|
|
&connector,
|
|
&mode_id,
|
|
&properties_variant);
|
|
|
|
monitor = find_monitor_from_connector (manager, connector);
|
|
if (!monitor)
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Invalid connector '%s' specified", connector);
|
|
return NULL;
|
|
}
|
|
|
|
monitor_mode = meta_monitor_get_mode_from_id (monitor, mode_id);
|
|
if (!monitor_mode)
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Invalid mode '%s' specified", mode_id);
|
|
return NULL;
|
|
}
|
|
|
|
set_underscanning =
|
|
g_variant_lookup (properties_variant, "underscanning", "b",
|
|
&enable_underscanning);
|
|
if (set_underscanning)
|
|
{
|
|
if (enable_underscanning && !meta_monitor_supports_underscanning (monitor))
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Underscanning requested but unsupported");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
monitor_spec = meta_monitor_spec_clone (meta_monitor_get_spec (monitor));
|
|
|
|
monitor_mode_spec = g_new0 (MetaMonitorModeSpec, 1);
|
|
*monitor_mode_spec = *meta_monitor_mode_get_spec (monitor_mode);
|
|
|
|
monitor_config = g_new0 (MetaMonitorConfig, 1);
|
|
*monitor_config = (MetaMonitorConfig) {
|
|
.monitor_spec = monitor_spec,
|
|
.mode_spec = monitor_mode_spec,
|
|
.enable_underscanning = enable_underscanning
|
|
};
|
|
|
|
return monitor_config;
|
|
}
|
|
|
|
static gboolean
|
|
find_monitor_mode_scale (MetaMonitorManager *manager,
|
|
MetaLogicalMonitorLayoutMode layout_mode,
|
|
MetaMonitorConfig *monitor_config,
|
|
float scale,
|
|
float *out_scale,
|
|
GError **error)
|
|
{
|
|
MetaMonitorSpec *monitor_spec;
|
|
MetaMonitor *monitor;
|
|
MetaMonitorModeSpec *monitor_mode_spec;
|
|
MetaMonitorMode *monitor_mode;
|
|
g_autofree float *supported_scales = NULL;
|
|
int n_supported_scales;
|
|
int i;
|
|
|
|
monitor_spec = monitor_config->monitor_spec;
|
|
monitor = meta_monitor_manager_get_monitor_from_spec (manager,
|
|
monitor_spec);
|
|
if (!monitor)
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Monitor not found");
|
|
return FALSE;
|
|
}
|
|
|
|
monitor_mode_spec = monitor_config->mode_spec;
|
|
monitor_mode = meta_monitor_get_mode_from_spec (monitor,
|
|
monitor_mode_spec);
|
|
if (!monitor_mode)
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Monitor mode not found");
|
|
return FALSE;
|
|
}
|
|
|
|
supported_scales =
|
|
meta_monitor_manager_calculate_supported_scales (manager, layout_mode,
|
|
monitor, monitor_mode,
|
|
&n_supported_scales);
|
|
|
|
for (i = 0; i < n_supported_scales; i++)
|
|
{
|
|
float supported_scale = supported_scales[i];
|
|
|
|
if (fabsf (supported_scale - scale) < FLT_EPSILON)
|
|
{
|
|
*out_scale = supported_scale;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Scale %g not valid for resolution %dx%d",
|
|
scale,
|
|
monitor_mode_spec->width,
|
|
monitor_mode_spec->height);
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
derive_logical_monitor_size (MetaMonitorConfig *monitor_config,
|
|
int *out_width,
|
|
int *out_height,
|
|
float scale,
|
|
MetaMonitorTransform transform,
|
|
MetaLogicalMonitorLayoutMode layout_mode,
|
|
GError **error)
|
|
{
|
|
int width, height;
|
|
|
|
if (meta_monitor_transform_is_rotated (transform))
|
|
{
|
|
width = monitor_config->mode_spec->height;
|
|
height = monitor_config->mode_spec->width;
|
|
}
|
|
else
|
|
{
|
|
width = monitor_config->mode_spec->width;
|
|
height = monitor_config->mode_spec->height;
|
|
}
|
|
|
|
switch (layout_mode)
|
|
{
|
|
case META_LOGICAL_MONITOR_LAYOUT_MODE_LOGICAL:
|
|
width = roundf (width / scale);
|
|
height = roundf (height / scale);
|
|
break;
|
|
case META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL:
|
|
break;
|
|
}
|
|
|
|
*out_width = width;
|
|
*out_height = height;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static MetaLogicalMonitorConfig *
|
|
create_logical_monitor_config_from_variant (MetaMonitorManager *manager,
|
|
GVariant *logical_monitor_config_variant,
|
|
MetaLogicalMonitorLayoutMode layout_mode,
|
|
GError **error)
|
|
{
|
|
MetaLogicalMonitorConfig *logical_monitor_config;
|
|
int x, y, width, height;
|
|
double scale_d;
|
|
float scale;
|
|
MetaMonitorTransform transform;
|
|
gboolean is_primary;
|
|
GVariantIter *monitor_configs_iter;
|
|
GList *monitor_configs = NULL;
|
|
MetaMonitorConfig *monitor_config;
|
|
|
|
g_variant_get (logical_monitor_config_variant, LOGICAL_MONITOR_CONFIG_FORMAT,
|
|
&x,
|
|
&y,
|
|
&scale_d,
|
|
&transform,
|
|
&is_primary,
|
|
&monitor_configs_iter);
|
|
scale = (float) scale_d;
|
|
|
|
while (TRUE)
|
|
{
|
|
GVariant *monitor_config_variant =
|
|
g_variant_iter_next_value (monitor_configs_iter);
|
|
MetaMonitorConfig *monitor_config;
|
|
|
|
if (!monitor_config_variant)
|
|
break;
|
|
|
|
monitor_config =
|
|
create_monitor_config_from_variant (manager,
|
|
monitor_config_variant, error);
|
|
g_variant_unref (monitor_config_variant);
|
|
|
|
if (!monitor_config)
|
|
goto err;
|
|
|
|
if (!meta_verify_monitor_config (monitor_config, error))
|
|
{
|
|
meta_monitor_config_free (monitor_config);
|
|
goto err;
|
|
}
|
|
|
|
monitor_configs = g_list_append (monitor_configs, monitor_config);
|
|
}
|
|
g_variant_iter_free (monitor_configs_iter);
|
|
|
|
if (!monitor_configs)
|
|
{
|
|
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
|
|
"Empty logical monitor");
|
|
goto err;
|
|
}
|
|
|
|
monitor_config = monitor_configs->data;
|
|
if (!find_monitor_mode_scale (manager,
|
|
layout_mode,
|
|
monitor_config,
|
|
scale,
|
|
&scale,
|
|
error))
|
|
goto err;
|
|
|
|
if (!derive_logical_monitor_size (monitor_config, &width, &height,
|
|
scale, transform, layout_mode, error))
|
|
goto err;
|
|
|
|
logical_monitor_config = g_new0 (MetaLogicalMonitorConfig, 1);
|
|
*logical_monitor_config = (MetaLogicalMonitorConfig) {
|
|
.layout = {
|
|
.x = x,
|
|
.y = y,
|
|
.width = width,
|
|
.height = height
|
|
},
|
|
.transform = transform,
|
|
.scale = scale,
|
|
.is_primary = is_primary,
|
|
.monitor_configs = monitor_configs
|
|
};
|
|
|
|
if (!meta_verify_logical_monitor_config (logical_monitor_config,
|
|
layout_mode,
|
|
manager,
|
|
error))
|
|
{
|
|
meta_logical_monitor_config_free (logical_monitor_config);
|
|
return NULL;
|
|
}
|
|
|
|
return logical_monitor_config;
|
|
|
|
err:
|
|
g_list_free_full (monitor_configs, (GDestroyNotify) meta_monitor_config_free);
|
|
return NULL;
|
|
}
|
|
|
|
static gboolean
|
|
is_valid_layout_mode (MetaLogicalMonitorLayoutMode layout_mode)
|
|
{
|
|
switch (layout_mode)
|
|
{
|
|
case META_LOGICAL_MONITOR_LAYOUT_MODE_LOGICAL:
|
|
case META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL:
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_handle_apply_monitors_config (MetaDBusDisplayConfig *skeleton,
|
|
GDBusMethodInvocation *invocation,
|
|
guint serial,
|
|
guint method,
|
|
GVariant *logical_monitor_configs_variant,
|
|
GVariant *properties_variant,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorConfigStore *config_store;
|
|
const MetaMonitorConfigPolicy *policy;
|
|
MetaMonitorManagerCapability capabilities;
|
|
GVariant *layout_mode_variant = NULL;
|
|
MetaLogicalMonitorLayoutMode layout_mode;
|
|
GVariantIter logical_monitor_configs_iter;
|
|
MetaMonitorsConfig *config;
|
|
GList *logical_monitor_configs = NULL;
|
|
GError *error = NULL;
|
|
|
|
if (serial != manager->serial)
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_ACCESS_DENIED,
|
|
"The requested configuration is based on stale information");
|
|
return TRUE;
|
|
}
|
|
|
|
config_store =
|
|
meta_monitor_config_manager_get_store (manager->config_manager);
|
|
policy = meta_monitor_config_store_get_policy (config_store);
|
|
|
|
if (!policy->enable_dbus)
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_ACCESS_DENIED,
|
|
"Monitor configuration via D-Bus is disabled");
|
|
return TRUE;
|
|
}
|
|
|
|
capabilities = meta_monitor_manager_get_capabilities (manager);
|
|
|
|
if (properties_variant)
|
|
layout_mode_variant = g_variant_lookup_value (properties_variant,
|
|
"layout-mode",
|
|
G_VARIANT_TYPE ("u"));
|
|
|
|
if (layout_mode_variant &&
|
|
capabilities & META_MONITOR_MANAGER_CAPABILITY_LAYOUT_MODE)
|
|
{
|
|
g_variant_get (layout_mode_variant, "u", &layout_mode);
|
|
}
|
|
else if (!layout_mode_variant)
|
|
{
|
|
layout_mode =
|
|
meta_monitor_manager_get_default_layout_mode (manager);
|
|
}
|
|
else
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"Can't set layout mode");
|
|
return TRUE;
|
|
}
|
|
|
|
if (!is_valid_layout_mode (layout_mode))
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_ACCESS_DENIED,
|
|
"Invalid layout mode specified");
|
|
return TRUE;
|
|
}
|
|
|
|
g_variant_iter_init (&logical_monitor_configs_iter,
|
|
logical_monitor_configs_variant);
|
|
while (TRUE)
|
|
{
|
|
GVariant *logical_monitor_config_variant =
|
|
g_variant_iter_next_value (&logical_monitor_configs_iter);
|
|
MetaLogicalMonitorConfig *logical_monitor_config;
|
|
|
|
if (!logical_monitor_config_variant)
|
|
break;
|
|
|
|
logical_monitor_config =
|
|
create_logical_monitor_config_from_variant (manager,
|
|
logical_monitor_config_variant,
|
|
layout_mode,
|
|
&error);
|
|
g_variant_unref (logical_monitor_config_variant);
|
|
|
|
if (!logical_monitor_config)
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"%s", error->message);
|
|
g_error_free (error);
|
|
g_list_free_full (logical_monitor_configs,
|
|
(GDestroyNotify) meta_logical_monitor_config_free);
|
|
return TRUE;
|
|
}
|
|
|
|
logical_monitor_configs = g_list_append (logical_monitor_configs,
|
|
logical_monitor_config);
|
|
}
|
|
|
|
config = meta_monitors_config_new (manager,
|
|
logical_monitor_configs,
|
|
layout_mode,
|
|
META_MONITORS_CONFIG_FLAG_NONE);
|
|
if (!meta_verify_monitors_config (config, manager, &error))
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"%s", error->message);
|
|
g_error_free (error);
|
|
g_object_unref (config);
|
|
return TRUE;
|
|
}
|
|
|
|
if (!meta_monitor_manager_is_config_applicable (manager, config, &error))
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"%s", error->message);
|
|
g_error_free (error);
|
|
g_object_unref (config);
|
|
return TRUE;
|
|
}
|
|
|
|
if (method != META_MONITORS_CONFIG_METHOD_VERIFY)
|
|
{
|
|
g_clear_handle_id (&manager->restore_config_id, g_source_remove);
|
|
g_clear_handle_id (&manager->persistent_timeout_id, g_source_remove);
|
|
}
|
|
|
|
if (!meta_monitor_manager_apply_monitors_config (manager,
|
|
config,
|
|
method,
|
|
&error))
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"%s", error->message);
|
|
g_error_free (error);
|
|
g_object_unref (config);
|
|
return TRUE;
|
|
}
|
|
|
|
if (method == META_MONITORS_CONFIG_METHOD_PERSISTENT)
|
|
request_persistent_confirmation (manager);
|
|
|
|
meta_dbus_display_config_complete_apply_monitors_config (skeleton, invocation);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#undef MONITOR_MODE_SPEC_FORMAT
|
|
#undef MONITOR_CONFIG_FORMAT
|
|
#undef MONITOR_CONFIGS_FORMAT
|
|
#undef LOGICAL_MONITOR_CONFIG_FORMAT
|
|
|
|
void
|
|
meta_monitor_manager_confirm_configuration (MetaMonitorManager *manager,
|
|
gboolean ok)
|
|
{
|
|
if (!manager->persistent_timeout_id)
|
|
return;
|
|
|
|
g_clear_handle_id (&manager->restore_config_id, g_source_remove);
|
|
g_clear_handle_id (&manager->persistent_timeout_id, g_source_remove);
|
|
|
|
if (ok)
|
|
{
|
|
meta_monitor_config_manager_save_current (manager->config_manager);
|
|
}
|
|
else
|
|
{
|
|
manager->restore_config_id =
|
|
g_idle_add_once ((GSourceOnceFunc) restore_previous_config, manager);
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_handle_change_backlight (MetaDBusDisplayConfig *skeleton,
|
|
GDBusMethodInvocation *invocation,
|
|
guint serial,
|
|
guint output_index,
|
|
gint value,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
GList *combined_outputs;
|
|
MetaOutput *output;
|
|
const MetaOutputInfo *output_info;
|
|
int new_backlight;
|
|
|
|
if (serial != manager->serial)
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_ACCESS_DENIED,
|
|
"The requested configuration is based on stale information");
|
|
return TRUE;
|
|
}
|
|
|
|
combined_outputs = combine_gpu_lists (manager, meta_gpu_get_outputs);
|
|
|
|
if (output_index >= g_list_length (combined_outputs))
|
|
{
|
|
g_list_free (combined_outputs);
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"Invalid output id");
|
|
return TRUE;
|
|
}
|
|
output = g_list_nth_data (combined_outputs, output_index);
|
|
g_list_free (combined_outputs);
|
|
|
|
if (value < 0 || value > 100)
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"Invalid backlight value");
|
|
return TRUE;
|
|
}
|
|
|
|
output_info = meta_output_get_info (output);
|
|
if (meta_output_get_backlight (output) == -1 ||
|
|
(output_info->backlight_min == 0 &&
|
|
output_info->backlight_max == 0))
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"Output does not support changing backlight");
|
|
return TRUE;
|
|
}
|
|
|
|
META_MONITOR_MANAGER_GET_CLASS (manager)->change_backlight (manager, output, value);
|
|
|
|
new_backlight = meta_output_get_backlight (output);
|
|
meta_dbus_display_config_complete_change_backlight (skeleton,
|
|
invocation,
|
|
new_backlight);
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_handle_get_crtc_gamma (MetaDBusDisplayConfig *skeleton,
|
|
GDBusMethodInvocation *invocation,
|
|
guint serial,
|
|
guint crtc_id,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
GList *combined_crtcs;
|
|
MetaCrtc *crtc;
|
|
g_autoptr (MetaGammaLut) gamma_lut = NULL;
|
|
GBytes *red_bytes, *green_bytes, *blue_bytes;
|
|
GVariant *red_v, *green_v, *blue_v;
|
|
|
|
if (serial != manager->serial)
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_ACCESS_DENIED,
|
|
"The requested configuration is based on stale information");
|
|
return TRUE;
|
|
}
|
|
|
|
combined_crtcs = combine_gpu_lists (manager, meta_gpu_get_crtcs);
|
|
if (crtc_id >= g_list_length (combined_crtcs))
|
|
{
|
|
g_list_free (combined_crtcs);
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"Invalid crtc id");
|
|
return TRUE;
|
|
}
|
|
|
|
crtc = g_list_nth_data (combined_crtcs, crtc_id);
|
|
g_list_free (combined_crtcs);
|
|
|
|
gamma_lut = meta_crtc_get_gamma_lut (crtc);
|
|
|
|
red_bytes = g_bytes_new_take (g_steal_pointer (&gamma_lut->red),
|
|
gamma_lut->size * sizeof (unsigned short));
|
|
green_bytes = g_bytes_new_take (g_steal_pointer (&gamma_lut->green),
|
|
gamma_lut->size * sizeof (unsigned short));
|
|
blue_bytes = g_bytes_new_take (g_steal_pointer (&gamma_lut->blue),
|
|
gamma_lut->size * sizeof (unsigned short));
|
|
|
|
red_v = g_variant_new_from_bytes (G_VARIANT_TYPE ("aq"), red_bytes, TRUE);
|
|
green_v = g_variant_new_from_bytes (G_VARIANT_TYPE ("aq"), green_bytes, TRUE);
|
|
blue_v = g_variant_new_from_bytes (G_VARIANT_TYPE ("aq"), blue_bytes, TRUE);
|
|
|
|
meta_dbus_display_config_complete_get_crtc_gamma (skeleton, invocation,
|
|
red_v, green_v, blue_v);
|
|
|
|
g_bytes_unref (red_bytes);
|
|
g_bytes_unref (green_bytes);
|
|
g_bytes_unref (blue_bytes);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_handle_set_crtc_gamma (MetaDBusDisplayConfig *skeleton,
|
|
GDBusMethodInvocation *invocation,
|
|
guint serial,
|
|
guint crtc_id,
|
|
GVariant *red_v,
|
|
GVariant *green_v,
|
|
GVariant *blue_v,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
GList *combined_crtcs;
|
|
MetaCrtc *crtc;
|
|
size_t dummy;
|
|
GBytes *red_bytes, *green_bytes, *blue_bytes;
|
|
MetaGammaLut lut;
|
|
|
|
if (serial != manager->serial)
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_ACCESS_DENIED,
|
|
"The requested configuration is based on stale information");
|
|
return TRUE;
|
|
}
|
|
|
|
combined_crtcs = combine_gpu_lists (manager, meta_gpu_get_crtcs);
|
|
|
|
if (crtc_id >= g_list_length (combined_crtcs))
|
|
{
|
|
g_list_free (combined_crtcs);
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"Invalid crtc id");
|
|
return TRUE;
|
|
}
|
|
|
|
crtc = g_list_nth_data (combined_crtcs, crtc_id);
|
|
g_list_free (combined_crtcs);
|
|
|
|
red_bytes = g_variant_get_data_as_bytes (red_v);
|
|
green_bytes = g_variant_get_data_as_bytes (green_v);
|
|
blue_bytes = g_variant_get_data_as_bytes (blue_v);
|
|
|
|
lut.size = g_bytes_get_size (red_bytes) / sizeof (uint16_t);
|
|
lut.red = (uint16_t *) g_bytes_get_data (red_bytes, &dummy);
|
|
lut.green = (uint16_t *) g_bytes_get_data (green_bytes, &dummy);
|
|
lut.blue = (uint16_t *) g_bytes_get_data (blue_bytes, &dummy);
|
|
|
|
meta_crtc_set_gamma_lut (crtc, &lut);
|
|
meta_dbus_display_config_complete_set_crtc_gamma (skeleton, invocation);
|
|
|
|
g_bytes_unref (red_bytes);
|
|
g_bytes_unref (green_bytes);
|
|
g_bytes_unref (blue_bytes);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
meta_monitor_manager_handle_set_output_ctm (MetaDBusDisplayConfig *skeleton,
|
|
GDBusMethodInvocation *invocation,
|
|
guint serial,
|
|
guint output_id,
|
|
GVariant *ctm_var,
|
|
MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerClass *klass;
|
|
GList *combined_outputs;
|
|
MetaOutput *output;
|
|
MetaOutputCtm ctm;
|
|
int i;
|
|
|
|
if (serial != manager->serial)
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_ACCESS_DENIED,
|
|
"The requested configuration is based on stale information");
|
|
return TRUE;
|
|
}
|
|
|
|
combined_outputs = combine_gpu_lists (manager, meta_gpu_get_outputs);
|
|
|
|
if (output_id >= g_list_length (combined_outputs))
|
|
{
|
|
g_list_free (combined_outputs);
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"Invalid output id");
|
|
return TRUE;
|
|
}
|
|
|
|
output = g_list_nth_data (combined_outputs, output_id);
|
|
g_list_free (combined_outputs);
|
|
|
|
if (g_variant_n_children (ctm_var) != 9)
|
|
{
|
|
g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR,
|
|
G_DBUS_ERROR_INVALID_ARGS,
|
|
"Unexpected color transform matrix variant length");
|
|
return TRUE;
|
|
}
|
|
|
|
for (i = 0; i < 9; i++)
|
|
{
|
|
GVariant *tmp = g_variant_get_child_value (ctm_var, i);
|
|
ctm.matrix[i] = g_variant_get_uint64 (tmp);
|
|
g_variant_unref (tmp);
|
|
}
|
|
|
|
klass = META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
if (klass->set_output_ctm)
|
|
klass->set_output_ctm (output, &ctm);
|
|
meta_dbus_display_config_complete_set_output_ctm (skeleton, invocation);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
monitor_manager_setup_dbus_config_handlers (MetaMonitorManager *manager)
|
|
{
|
|
g_signal_connect_object (manager->display_config, "handle-get-resources",
|
|
G_CALLBACK (meta_monitor_manager_handle_get_resources),
|
|
manager, 0);
|
|
g_signal_connect_object (manager->display_config, "handle-change-backlight",
|
|
G_CALLBACK (meta_monitor_manager_handle_change_backlight),
|
|
manager, 0);
|
|
g_signal_connect_object (manager->display_config, "handle-get-crtc-gamma",
|
|
G_CALLBACK (meta_monitor_manager_handle_get_crtc_gamma),
|
|
manager, 0);
|
|
g_signal_connect_object (manager->display_config, "handle-set-crtc-gamma",
|
|
G_CALLBACK (meta_monitor_manager_handle_set_crtc_gamma),
|
|
manager, 0);
|
|
g_signal_connect_object (manager->display_config, "handle-get-current-state",
|
|
G_CALLBACK (meta_monitor_manager_handle_get_current_state),
|
|
manager, 0);
|
|
g_signal_connect_object (manager->display_config, "handle-apply-monitors-config",
|
|
G_CALLBACK (meta_monitor_manager_handle_apply_monitors_config),
|
|
manager, 0);
|
|
g_signal_connect_object (manager->display_config, "handle-set-output-ctm",
|
|
G_CALLBACK (meta_monitor_manager_handle_set_output_ctm),
|
|
manager, 0);
|
|
}
|
|
|
|
static void
|
|
on_bus_acquired (GDBusConnection *connection,
|
|
const char *name,
|
|
gpointer user_data)
|
|
{
|
|
MetaMonitorManager *manager = user_data;
|
|
|
|
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (manager->display_config),
|
|
connection,
|
|
"/org/gnome/Mutter/DisplayConfig",
|
|
NULL);
|
|
}
|
|
|
|
static void
|
|
on_name_acquired (GDBusConnection *connection,
|
|
const char *name,
|
|
gpointer user_data)
|
|
{
|
|
meta_topic (META_DEBUG_DBUS, "Acquired name %s", name);
|
|
}
|
|
|
|
static void
|
|
on_name_lost (GDBusConnection *connection,
|
|
const char *name,
|
|
gpointer user_data)
|
|
{
|
|
meta_topic (META_DEBUG_DBUS, "Lost or failed to acquire name %s", name);
|
|
}
|
|
|
|
static void
|
|
initialize_dbus_interface (MetaMonitorManager *manager)
|
|
{
|
|
MetaContext *context = meta_backend_get_context (manager->backend);
|
|
|
|
manager->dbus_name_id =
|
|
g_bus_own_name (G_BUS_TYPE_SESSION,
|
|
"org.gnome.Mutter.DisplayConfig",
|
|
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
|
|
(meta_context_is_replacing (context) ?
|
|
G_BUS_NAME_OWNER_FLAGS_REPLACE :
|
|
G_BUS_NAME_OWNER_FLAGS_NONE),
|
|
on_bus_acquired,
|
|
on_name_acquired,
|
|
on_name_lost,
|
|
g_object_ref (manager),
|
|
g_object_unref);
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_num_logical_monitors:
|
|
* @manager: A #MetaMonitorManager object
|
|
*
|
|
* Returns the number of `MetaLogicalMonitor`s (can be 0 in case of a
|
|
* headless setup).
|
|
*
|
|
* Returns: the total number of `MetaLogicalMonitor`s.
|
|
*/
|
|
int
|
|
meta_monitor_manager_get_num_logical_monitors (MetaMonitorManager *manager)
|
|
{
|
|
return g_list_length (manager->logical_monitors);
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_logical_monitors:
|
|
* @manager: A #MetaMonitorManager object
|
|
*
|
|
* Returns the list of `MetaLogicalMonitor`s that is handled. See also
|
|
* meta_monitor_manager_get_num_logical_monitors() if you only need the size of
|
|
* the list.
|
|
*
|
|
* Returns: (transfer none) (nullable): the list of logical monitors.
|
|
*/
|
|
GList *
|
|
meta_monitor_manager_get_logical_monitors (MetaMonitorManager *manager)
|
|
{
|
|
return manager->logical_monitors;
|
|
}
|
|
|
|
MetaLogicalMonitor *
|
|
meta_monitor_manager_get_logical_monitor_from_number (MetaMonitorManager *manager,
|
|
int number)
|
|
{
|
|
g_return_val_if_fail ((unsigned int) number < g_list_length (manager->logical_monitors), NULL);
|
|
|
|
return g_list_nth (manager->logical_monitors, number)->data;
|
|
}
|
|
|
|
MetaLogicalMonitor *
|
|
meta_monitor_manager_get_primary_logical_monitor (MetaMonitorManager *manager)
|
|
{
|
|
return manager->primary_logical_monitor;
|
|
}
|
|
|
|
static MetaMonitor *
|
|
find_monitor (MetaMonitorManager *monitor_manager,
|
|
gboolean (*match_func) (MetaMonitor *monitor))
|
|
{
|
|
GList *monitors;
|
|
GList *l;
|
|
|
|
monitors = meta_monitor_manager_get_monitors (monitor_manager);
|
|
for (l = monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
|
|
if (match_func (monitor))
|
|
return monitor;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_primary_monitor:
|
|
* @manager: A #MetaMonitorManager object
|
|
*
|
|
* Returns the primary monitor. This can be %NULL (e.g. when running headless).
|
|
*
|
|
* Returns: (transfer none) (nullable): The primary #MetaMonitor, or %NULL if
|
|
* none.
|
|
*/
|
|
MetaMonitor *
|
|
meta_monitor_manager_get_primary_monitor (MetaMonitorManager *manager)
|
|
{
|
|
return find_monitor (manager, meta_monitor_is_primary);
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_laptop_panel:
|
|
* @manager: A #MetaMonitorManager object
|
|
*
|
|
* Returns the #MetaMonitor that represents the built-in laptop panel (if
|
|
* applicable).
|
|
*
|
|
* Returns: (transfer none) (nullable): The laptop panel, or %NULL if none.
|
|
*/
|
|
MetaMonitor *
|
|
meta_monitor_manager_get_laptop_panel (MetaMonitorManager *manager)
|
|
{
|
|
return find_monitor (manager, meta_monitor_is_laptop_panel);
|
|
}
|
|
|
|
MetaMonitor *
|
|
meta_monitor_manager_get_monitor_from_connector (MetaMonitorManager *manager,
|
|
const char *connector)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
|
|
if (g_str_equal (meta_monitor_get_connector (monitor),
|
|
connector))
|
|
return monitor;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
MetaMonitor *
|
|
meta_monitor_manager_get_monitor_from_spec (MetaMonitorManager *manager,
|
|
MetaMonitorSpec *monitor_spec)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
|
|
if (meta_monitor_spec_equals (meta_monitor_get_spec (monitor),
|
|
monitor_spec))
|
|
return monitor;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_logical_monitor_at:
|
|
* @manager: A #MetaMonitorManager object
|
|
* @x: The x-coordinate
|
|
* @y: The y-coordinate
|
|
*
|
|
* Finds the #MetaLogicalMonitor at the given @x and @y coordinates in the
|
|
* total layout.
|
|
*
|
|
* Returns: (transfer none) (nullable): The #MetaLogicalMonitor at the given
|
|
* point, or %NULL if none.
|
|
*/
|
|
MetaLogicalMonitor *
|
|
meta_monitor_manager_get_logical_monitor_at (MetaMonitorManager *manager,
|
|
float x,
|
|
float y)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = manager->logical_monitors; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitor *logical_monitor = l->data;
|
|
|
|
if (META_POINT_IN_RECT (x, y, logical_monitor->rect))
|
|
return logical_monitor;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_logical_monitor_from_rect:
|
|
* @manager: A #MetaMonitorManager object
|
|
* @rect: The rectangle
|
|
*
|
|
* Finds the #MetaLogicalMonitor which contains the center of the given @rect
|
|
* or which has the largest area in common with the given @rect in the total
|
|
* layout if the center is not on a monitor.
|
|
*
|
|
* Returns: (transfer none) (nullable): The #MetaLogicalMonitor which
|
|
* corresponds the most to the given @rect, or %NULL if none.
|
|
*/
|
|
MetaLogicalMonitor *
|
|
meta_monitor_manager_get_logical_monitor_from_rect (MetaMonitorManager *manager,
|
|
MetaRectangle *rect)
|
|
{
|
|
MetaLogicalMonitor *best_logical_monitor;
|
|
int best_logical_monitor_area;
|
|
GList *l;
|
|
int center_x = rect->x + (rect->width / 2);
|
|
int center_y = rect->y + (rect->height / 2);
|
|
|
|
best_logical_monitor = NULL;
|
|
best_logical_monitor_area = 0;
|
|
|
|
for (l = manager->logical_monitors; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitor *logical_monitor = l->data;
|
|
MetaRectangle intersection;
|
|
int intersection_area;
|
|
|
|
if (META_POINT_IN_RECT (center_x, center_y, logical_monitor->rect))
|
|
return logical_monitor;
|
|
|
|
if (!meta_rectangle_intersect (&logical_monitor->rect,
|
|
rect,
|
|
&intersection))
|
|
continue;
|
|
|
|
intersection_area = meta_rectangle_area (&intersection);
|
|
|
|
if (intersection_area > best_logical_monitor_area)
|
|
{
|
|
best_logical_monitor = logical_monitor;
|
|
best_logical_monitor_area = intersection_area;
|
|
}
|
|
}
|
|
|
|
if (!best_logical_monitor)
|
|
best_logical_monitor = manager->primary_logical_monitor;
|
|
|
|
return best_logical_monitor;
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_highest_scale_from_rect:
|
|
* @manager: A #MetaMonitorManager object
|
|
* @rect: The rectangle
|
|
*
|
|
* Finds the #MetaLogicalMonitor with the highest scale intersecting @rect.
|
|
*
|
|
* Returns: (transfer none) (nullable): the #MetaLogicalMonitor with the
|
|
* highest scale intersecting with @rect, or %NULL if none.
|
|
*/
|
|
MetaLogicalMonitor *
|
|
meta_monitor_manager_get_highest_scale_monitor_from_rect (MetaMonitorManager *manager,
|
|
MetaRectangle *rect)
|
|
{
|
|
MetaLogicalMonitor *best_logical_monitor = NULL;
|
|
GList *l;
|
|
float best_scale = 0.0;
|
|
|
|
for (l = manager->logical_monitors; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitor *logical_monitor = l->data;
|
|
MetaRectangle intersection;
|
|
float scale;
|
|
|
|
if (!meta_rectangle_intersect (&logical_monitor->rect,
|
|
rect,
|
|
&intersection))
|
|
continue;
|
|
|
|
scale = meta_logical_monitor_get_scale (logical_monitor);
|
|
|
|
if (scale > best_scale)
|
|
{
|
|
best_scale = scale;
|
|
best_logical_monitor = logical_monitor;
|
|
}
|
|
}
|
|
|
|
return best_logical_monitor;
|
|
}
|
|
|
|
MetaLogicalMonitor *
|
|
meta_monitor_manager_get_logical_monitor_neighbor (MetaMonitorManager *manager,
|
|
MetaLogicalMonitor *logical_monitor,
|
|
MetaDisplayDirection direction)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = manager->logical_monitors; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitor *other = l->data;
|
|
|
|
if (meta_logical_monitor_has_neighbor (logical_monitor, other, direction))
|
|
return other;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_monitors:
|
|
* @manager: A #MetaMonitorManager object
|
|
*
|
|
* Returns the list of [class@Meta.Monitor]s. See also
|
|
* meta_monitor_manager_get_logical_monitors() for a list of
|
|
* `MetaLogicalMonitor`s.
|
|
*
|
|
* Returns: (transfer none) (nullable): the list of [class@Meta.Monitor]s.
|
|
*/
|
|
GList *
|
|
meta_monitor_manager_get_monitors (MetaMonitorManager *manager)
|
|
{
|
|
return manager->monitors;
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_get_screen_size (MetaMonitorManager *manager,
|
|
int *width,
|
|
int *height)
|
|
{
|
|
*width = manager->screen_width;
|
|
*height = manager->screen_height;
|
|
}
|
|
|
|
MetaPowerSave
|
|
meta_monitor_manager_get_power_save_mode (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
return priv->power_save_mode;
|
|
}
|
|
|
|
static void
|
|
destroy_monitor (MetaMonitor *monitor)
|
|
{
|
|
g_object_run_dispose (G_OBJECT (monitor));
|
|
g_object_unref (monitor);
|
|
}
|
|
|
|
static void
|
|
rebuild_monitors (MetaMonitorManager *manager)
|
|
{
|
|
GList *gpus;
|
|
GList *l;
|
|
|
|
if (manager->monitors)
|
|
{
|
|
g_list_free_full (manager->monitors, (GDestroyNotify) destroy_monitor);
|
|
manager->monitors = NULL;
|
|
}
|
|
|
|
gpus = meta_backend_get_gpus (manager->backend);
|
|
for (l = gpus; l; l = l->next)
|
|
{
|
|
MetaGpu *gpu = l->data;
|
|
GList *k;
|
|
|
|
for (k = meta_gpu_get_outputs (gpu); k; k = k->next)
|
|
{
|
|
MetaOutput *output = k->data;
|
|
const MetaOutputInfo *output_info = meta_output_get_info (output);
|
|
|
|
if (output_info->tile_info.group_id)
|
|
{
|
|
if (is_main_tiled_monitor_output (output))
|
|
{
|
|
MetaMonitorTiled *monitor_tiled;
|
|
|
|
monitor_tiled = meta_monitor_tiled_new (manager, output);
|
|
manager->monitors = g_list_append (manager->monitors,
|
|
monitor_tiled);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MetaMonitorNormal *monitor_normal;
|
|
|
|
monitor_normal = meta_monitor_normal_new (manager, output);
|
|
manager->monitors = g_list_append (manager->monitors,
|
|
monitor_normal);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (l = meta_monitor_manager_get_virtual_monitors (manager); l; l = l->next)
|
|
{
|
|
MetaVirtualMonitor *virtual_monitor = l->data;
|
|
MetaOutput *output = meta_virtual_monitor_get_output (virtual_monitor);
|
|
MetaMonitorNormal *monitor_normal;
|
|
|
|
monitor_normal = meta_monitor_normal_new (manager, output);
|
|
manager->monitors = g_list_append (manager->monitors,
|
|
monitor_normal);
|
|
|
|
}
|
|
|
|
update_panel_orientation_managed (manager);
|
|
update_has_builtin_panel (manager);
|
|
update_night_light_supported (manager);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_tiled_monitor_added (MetaMonitorManager *manager,
|
|
MetaMonitor *monitor)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
if (manager_class->tiled_monitor_added)
|
|
manager_class->tiled_monitor_added (manager, monitor);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_tiled_monitor_removed (MetaMonitorManager *manager,
|
|
MetaMonitor *monitor)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
if (manager_class->tiled_monitor_removed)
|
|
manager_class->tiled_monitor_removed (manager, monitor);
|
|
}
|
|
|
|
gboolean
|
|
meta_monitor_manager_is_transform_handled (MetaMonitorManager *manager,
|
|
MetaCrtc *crtc,
|
|
MetaMonitorTransform transform)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
return manager_class->is_transform_handled (manager, crtc, transform);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_real_read_current_state (MetaMonitorManager *manager)
|
|
{
|
|
GList *l;
|
|
|
|
manager->serial++;
|
|
|
|
for (l = meta_backend_get_gpus (manager->backend); l; l = l->next)
|
|
{
|
|
MetaGpu *gpu = l->data;
|
|
GError *error = NULL;
|
|
|
|
if (!meta_gpu_read_current (gpu, &error))
|
|
{
|
|
g_warning ("Failed to read current monitor state: %s", error->message);
|
|
g_clear_error (&error);
|
|
}
|
|
}
|
|
|
|
rebuild_monitors (manager);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_read_current_state (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerClass *manager_class =
|
|
META_MONITOR_MANAGER_GET_CLASS (manager);
|
|
|
|
manager_class->read_current_state (manager);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_notify_monitors_changed (MetaMonitorManager *manager)
|
|
{
|
|
meta_backend_monitors_changed (manager->backend);
|
|
|
|
g_signal_emit (manager, signals[MONITORS_CHANGED_INTERNAL], 0);
|
|
g_signal_emit (manager, signals[MONITORS_CHANGED], 0);
|
|
|
|
meta_dbus_display_config_emit_monitors_changed (manager->display_config);
|
|
}
|
|
|
|
static void
|
|
set_logical_monitor_modes (MetaMonitorManager *manager,
|
|
MetaLogicalMonitorConfig *logical_monitor_config)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = logical_monitor_config->monitor_configs; l; l = l->next)
|
|
{
|
|
MetaMonitorConfig *monitor_config = l->data;
|
|
MetaMonitorSpec *monitor_spec;
|
|
MetaMonitor *monitor;
|
|
MetaMonitorModeSpec *monitor_mode_spec;
|
|
MetaMonitorMode *monitor_mode;
|
|
|
|
monitor_spec = monitor_config->monitor_spec;
|
|
monitor = meta_monitor_manager_get_monitor_from_spec (manager,
|
|
monitor_spec);
|
|
monitor_mode_spec = monitor_config->mode_spec;
|
|
monitor_mode = meta_monitor_get_mode_from_spec (monitor,
|
|
monitor_mode_spec);
|
|
|
|
meta_monitor_set_current_mode (monitor, monitor_mode);
|
|
}
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_update_monitor_modes (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config)
|
|
{
|
|
GList *logical_monitor_configs;
|
|
GList *l;
|
|
|
|
g_list_foreach (manager->monitors,
|
|
(GFunc) meta_monitor_set_current_mode,
|
|
NULL);
|
|
|
|
logical_monitor_configs = config ? config->logical_monitor_configs : NULL;
|
|
for (l = logical_monitor_configs; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitorConfig *logical_monitor_config = l->data;
|
|
|
|
set_logical_monitor_modes (manager, logical_monitor_config);
|
|
}
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_update_logical_state (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config)
|
|
{
|
|
if (config)
|
|
{
|
|
manager->layout_mode = config->layout_mode;
|
|
manager->current_switch_config =
|
|
meta_monitors_config_get_switch_config (config);
|
|
}
|
|
else
|
|
{
|
|
manager->layout_mode =
|
|
meta_monitor_manager_get_default_layout_mode (manager);
|
|
manager->current_switch_config = META_MONITOR_SWITCH_CONFIG_UNKNOWN;
|
|
}
|
|
|
|
meta_monitor_manager_rebuild_logical_monitors (manager, config);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_rebuild (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config)
|
|
{
|
|
GList *old_logical_monitors;
|
|
|
|
meta_monitor_manager_update_monitor_modes (manager, config);
|
|
|
|
if (manager->in_init)
|
|
return;
|
|
|
|
old_logical_monitors = manager->logical_monitors;
|
|
|
|
meta_monitor_manager_update_logical_state (manager, config);
|
|
|
|
meta_monitor_manager_notify_monitors_changed (manager);
|
|
|
|
ensure_privacy_screen_settings (manager);
|
|
|
|
ensure_hdr_settings (manager);
|
|
|
|
g_list_free_full (old_logical_monitors, g_object_unref);
|
|
}
|
|
|
|
static void
|
|
meta_monitor_manager_update_monitor_modes_derived (MetaMonitorManager *manager)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
|
|
meta_monitor_derive_current_mode (monitor);
|
|
}
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_update_logical_state_derived (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config)
|
|
{
|
|
if (config)
|
|
manager->current_switch_config =
|
|
meta_monitors_config_get_switch_config (config);
|
|
else
|
|
manager->current_switch_config = META_MONITOR_SWITCH_CONFIG_UNKNOWN;
|
|
|
|
manager->layout_mode = META_LOGICAL_MONITOR_LAYOUT_MODE_PHYSICAL;
|
|
|
|
meta_monitor_manager_rebuild_logical_monitors_derived (manager, config);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_rebuild_derived (MetaMonitorManager *manager,
|
|
MetaMonitorsConfig *config)
|
|
{
|
|
GList *old_logical_monitors;
|
|
|
|
meta_monitor_manager_update_monitor_modes_derived (manager);
|
|
|
|
if (manager->in_init)
|
|
return;
|
|
|
|
old_logical_monitors = manager->logical_monitors;
|
|
|
|
meta_monitor_manager_update_logical_state_derived (manager, config);
|
|
|
|
meta_monitor_manager_notify_monitors_changed (manager);
|
|
|
|
g_list_free_full (old_logical_monitors, g_object_unref);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_reconfigure (MetaMonitorManager *manager)
|
|
{
|
|
meta_monitor_manager_ensure_configured (manager);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_reload (MetaMonitorManager *manager)
|
|
{
|
|
meta_monitor_manager_read_current_state (manager);
|
|
meta_monitor_manager_reconfigure (manager);
|
|
}
|
|
|
|
static gboolean
|
|
calculate_viewport_matrix (MetaMonitorManager *manager,
|
|
MetaLogicalMonitor *logical_monitor,
|
|
gfloat viewport[6])
|
|
{
|
|
gfloat x, y, width, height;
|
|
|
|
x = (float) logical_monitor->rect.x / manager->screen_width;
|
|
y = (float) logical_monitor->rect.y / manager->screen_height;
|
|
width = (float) logical_monitor->rect.width / manager->screen_width;
|
|
height = (float) logical_monitor->rect.height / manager->screen_height;
|
|
|
|
viewport[0] = width;
|
|
viewport[1] = 0.0f;
|
|
viewport[2] = x;
|
|
viewport[3] = 0.0f;
|
|
viewport[4] = height;
|
|
viewport[5] = y;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static inline void
|
|
multiply_matrix (float a[6],
|
|
float b[6],
|
|
float res[6])
|
|
{
|
|
res[0] = a[0] * b[0] + a[1] * b[3];
|
|
res[1] = a[0] * b[1] + a[1] * b[4];
|
|
res[2] = a[0] * b[2] + a[1] * b[5] + a[2];
|
|
res[3] = a[3] * b[0] + a[4] * b[3];
|
|
res[4] = a[3] * b[1] + a[4] * b[4];
|
|
res[5] = a[3] * b[2] + a[4] * b[5] + a[5];
|
|
}
|
|
|
|
gboolean
|
|
meta_monitor_manager_get_monitor_matrix (MetaMonitorManager *manager,
|
|
MetaMonitor *monitor,
|
|
MetaLogicalMonitor *logical_monitor,
|
|
gfloat matrix[6])
|
|
{
|
|
MetaMonitorTransform transform;
|
|
gfloat viewport[9];
|
|
|
|
if (!calculate_viewport_matrix (manager, logical_monitor, viewport))
|
|
return FALSE;
|
|
|
|
/* Get transform corrected for LCD panel-orientation. */
|
|
transform = logical_monitor->transform;
|
|
transform = meta_monitor_logical_to_crtc_transform (monitor, transform);
|
|
multiply_matrix (viewport, transform_matrices[transform],
|
|
matrix);
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_monitor_for_connector:
|
|
* @manager: A #MetaMonitorManager
|
|
* @connector: A valid connector name
|
|
*
|
|
* Returns: The monitor index or -1 if @id isn't valid or the connector
|
|
* isn't associated with a logical monitor.
|
|
*/
|
|
gint
|
|
meta_monitor_manager_get_monitor_for_connector (MetaMonitorManager *manager,
|
|
const char *connector)
|
|
{
|
|
GList *l;
|
|
|
|
for (l = manager->monitors; l; l = l->next)
|
|
{
|
|
MetaMonitor *monitor = l->data;
|
|
|
|
if (meta_monitor_is_active (monitor) &&
|
|
g_str_equal (connector, meta_monitor_get_connector (monitor)))
|
|
return meta_monitor_get_logical_monitor (monitor)->number;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* meta_monitor_manager_get_is_builtin_display_on:
|
|
* @manager: A #MetaMonitorManager object
|
|
*
|
|
* Returns whether the built-in display (i.e. a laptop panel) is turned on.
|
|
*/
|
|
gboolean
|
|
meta_monitor_manager_get_is_builtin_display_on (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitor *laptop_panel;
|
|
|
|
g_return_val_if_fail (META_IS_MONITOR_MANAGER (manager), FALSE);
|
|
|
|
laptop_panel = meta_monitor_manager_get_laptop_panel (manager);
|
|
if (!laptop_panel)
|
|
return FALSE;
|
|
|
|
return meta_monitor_is_active (laptop_panel);
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_rotate_monitor (MetaMonitorManager *manager)
|
|
{
|
|
GError *error = NULL;
|
|
MetaMonitorsConfig *config =
|
|
meta_monitor_config_manager_create_for_rotate_monitor (manager->config_manager);
|
|
|
|
if (!config)
|
|
return;
|
|
|
|
if (!meta_monitor_manager_apply_monitors_config (manager,
|
|
config,
|
|
META_MONITORS_CONFIG_METHOD_TEMPORARY,
|
|
&error))
|
|
{
|
|
g_warning ("Failed to use rotate monitor configuration: %s",
|
|
error->message);
|
|
g_error_free (error);
|
|
}
|
|
g_object_unref (config);
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
MetaMonitorManager *monitor_manager;
|
|
MetaMonitorSwitchConfigType config_type;
|
|
} SwitchConfigData;
|
|
|
|
static gboolean
|
|
switch_config_idle_cb (gpointer user_data)
|
|
{
|
|
SwitchConfigData *data = user_data;
|
|
MetaMonitorManager *monitor_manager = data->monitor_manager;
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (monitor_manager);
|
|
MetaMonitorConfigManager *config_manager = monitor_manager->config_manager;
|
|
MetaMonitorsConfig *config;
|
|
g_autoptr (GError) error = NULL;
|
|
|
|
priv->switch_config_handle_id = 0;
|
|
|
|
config =
|
|
meta_monitor_config_manager_create_for_switch_config (config_manager,
|
|
data->config_type);
|
|
if (!config)
|
|
return G_SOURCE_REMOVE;
|
|
|
|
if (!meta_monitor_manager_apply_monitors_config (monitor_manager,
|
|
config,
|
|
META_MONITORS_CONFIG_METHOD_TEMPORARY,
|
|
&error))
|
|
{
|
|
g_warning ("Failed to use switch monitor configuration: %s",
|
|
error->message);
|
|
}
|
|
else
|
|
{
|
|
monitor_manager->current_switch_config = data->config_type;
|
|
}
|
|
|
|
return G_SOURCE_REMOVE;
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_switch_config (MetaMonitorManager *manager,
|
|
MetaMonitorSwitchConfigType config_type)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
SwitchConfigData *data;
|
|
|
|
g_return_if_fail (config_type != META_MONITOR_SWITCH_CONFIG_UNKNOWN);
|
|
|
|
data = g_new0 (SwitchConfigData, 1);
|
|
data->monitor_manager = manager;
|
|
data->config_type = config_type;
|
|
|
|
g_clear_handle_id (&priv->switch_config_handle_id, g_source_remove);
|
|
priv->switch_config_handle_id = g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
|
|
switch_config_idle_cb,
|
|
data,
|
|
g_free);
|
|
}
|
|
|
|
gboolean
|
|
meta_monitor_manager_can_switch_config (MetaMonitorManager *manager)
|
|
{
|
|
return (!meta_backend_is_lid_closed (manager->backend) &&
|
|
g_list_length (manager->monitors) > 1);
|
|
}
|
|
|
|
MetaMonitorSwitchConfigType
|
|
meta_monitor_manager_get_switch_config (MetaMonitorManager *manager)
|
|
{
|
|
return manager->current_switch_config;
|
|
}
|
|
|
|
MetaMonitorConfigManager *
|
|
meta_monitor_manager_get_config_manager (MetaMonitorManager *manager)
|
|
{
|
|
return manager->config_manager;
|
|
}
|
|
|
|
gboolean
|
|
meta_monitor_manager_get_panel_orientation_managed (MetaMonitorManager *manager)
|
|
{
|
|
g_return_val_if_fail (META_IS_MONITOR_MANAGER (manager), FALSE);
|
|
|
|
return manager->panel_orientation_managed;
|
|
}
|
|
|
|
void
|
|
meta_monitor_manager_post_init (MetaMonitorManager *manager)
|
|
{
|
|
ClutterBackend *clutter_backend;
|
|
ClutterSeat *seat;
|
|
|
|
if (manager->privacy_screen_change_state ==
|
|
META_PRIVACY_SCREEN_CHANGE_STATE_INIT)
|
|
{
|
|
manager->privacy_screen_change_state =
|
|
META_PRIVACY_SCREEN_CHANGE_STATE_NONE;
|
|
}
|
|
|
|
apply_privacy_screen_settings (manager);
|
|
|
|
clutter_backend = meta_backend_get_clutter_backend (manager->backend);
|
|
seat = clutter_backend_get_default_seat (clutter_backend);
|
|
|
|
g_signal_connect_object (seat, "notify::touch-mode",
|
|
G_CALLBACK (update_panel_orientation_managed), manager,
|
|
G_CONNECT_SWAPPED);
|
|
}
|
|
|
|
MetaViewportInfo *
|
|
meta_monitor_manager_get_viewports (MetaMonitorManager *manager)
|
|
{
|
|
MetaBackend *backend = meta_monitor_manager_get_backend (manager);
|
|
MetaViewportInfo *info;
|
|
GArray *views, *scales;
|
|
GList *logical_monitors, *l;
|
|
|
|
views = g_array_new (FALSE, FALSE, sizeof (cairo_rectangle_int_t));
|
|
scales = g_array_new (FALSE, FALSE, sizeof (float));
|
|
|
|
logical_monitors = meta_monitor_manager_get_logical_monitors (manager);
|
|
|
|
for (l = logical_monitors; l; l = l->next)
|
|
{
|
|
MetaLogicalMonitor *logical_monitor = l->data;
|
|
cairo_rectangle_int_t rect;
|
|
float scale;
|
|
|
|
rect = logical_monitor->rect;
|
|
g_array_append_val (views, rect);
|
|
|
|
scale = logical_monitor->scale;
|
|
g_array_append_val (scales, scale);
|
|
}
|
|
|
|
info = meta_viewport_info_new ((cairo_rectangle_int_t *) views->data,
|
|
(float *) scales->data,
|
|
views->len,
|
|
meta_backend_is_stage_views_scaled (backend));
|
|
g_array_unref (views);
|
|
g_array_unref (scales);
|
|
|
|
return info;
|
|
}
|
|
|
|
GList *
|
|
meta_monitor_manager_get_virtual_monitors (MetaMonitorManager *manager)
|
|
{
|
|
MetaMonitorManagerPrivate *priv =
|
|
meta_monitor_manager_get_instance_private (manager);
|
|
|
|
return priv->virtual_monitors;
|
|
}
|