446 lines
15 KiB
C
446 lines
15 KiB
C
/*
|
|
* Copyright (C) 2017 Red Hat, Inc.
|
|
*
|
|
* 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, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
*/
|
|
|
|
#include "cc-display-config-dbus.h"
|
|
#include "cc-display-config-manager-dbus.h"
|
|
|
|
#include <gio/gio.h>
|
|
#include <stdint.h>
|
|
|
|
struct _CcDisplayConfigManagerDBus
|
|
{
|
|
CcDisplayConfigManager parent_instance;
|
|
|
|
GDBusProxy *proxy;
|
|
gulong properties_changed_id;
|
|
|
|
GCancellable *cancellable;
|
|
GDBusConnection *connection;
|
|
guint monitors_changed_id;
|
|
|
|
GVariant *current_state;
|
|
|
|
gboolean apply_allowed;
|
|
gboolean night_light_supported;
|
|
|
|
GPtrArray *output_luminance;
|
|
};
|
|
|
|
typedef struct _LuminanceEntry
|
|
{
|
|
char *connector;
|
|
CcDisplayColorMode color_mode;
|
|
double luminance;
|
|
double default_luminance;
|
|
} LuminanceEntry;
|
|
|
|
G_DEFINE_TYPE (CcDisplayConfigManagerDBus,
|
|
cc_display_config_manager_dbus,
|
|
CC_TYPE_DISPLAY_CONFIG_MANAGER)
|
|
|
|
static void
|
|
luminance_entry_free (LuminanceEntry *entry)
|
|
{
|
|
g_free (entry->connector);
|
|
g_free (entry);
|
|
}
|
|
|
|
static LuminanceEntry *
|
|
luminance_entry_new (const char *connector,
|
|
CcDisplayColorMode color_mode,
|
|
double luminance,
|
|
double default_luminance)
|
|
{
|
|
LuminanceEntry *entry;
|
|
|
|
entry = g_new0 (LuminanceEntry, 1);
|
|
entry->connector = g_strdup (connector);
|
|
entry->color_mode = color_mode;
|
|
entry->luminance = luminance;
|
|
entry->default_luminance = default_luminance;
|
|
|
|
return entry;
|
|
}
|
|
|
|
static gboolean
|
|
luminance_entry_matches (LuminanceEntry *entry,
|
|
const char *connector,
|
|
CcDisplayColorMode color_mode)
|
|
{
|
|
return (g_strcmp0 (entry->connector, connector) == 0 &&
|
|
entry->color_mode == color_mode);
|
|
}
|
|
|
|
static LuminanceEntry *
|
|
find_luminance_entry (CcDisplayConfigManagerDBus *self,
|
|
const char *connector,
|
|
CcDisplayColorMode color_mode)
|
|
{
|
|
size_t i;
|
|
|
|
for (i = 0; i < self->output_luminance->len; i++)
|
|
{
|
|
LuminanceEntry *entry =
|
|
g_ptr_array_index (self->output_luminance, i);
|
|
|
|
if (luminance_entry_matches (entry, connector, color_mode))
|
|
return entry;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static CcDisplayConfig *
|
|
cc_display_config_manager_dbus_get_current (CcDisplayConfigManager *pself)
|
|
{
|
|
CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (pself);
|
|
|
|
if (!self->current_state)
|
|
return NULL;
|
|
|
|
return g_object_new (CC_TYPE_DISPLAY_CONFIG_DBUS,
|
|
"state", self->current_state,
|
|
"connection", self->connection, NULL);
|
|
}
|
|
|
|
static void
|
|
got_current_state (GObject *object,
|
|
GAsyncResult *result,
|
|
gpointer data)
|
|
{
|
|
CcDisplayConfigManagerDBus *self;
|
|
GVariant *variant;
|
|
g_autoptr(GError) error = NULL;
|
|
|
|
variant = g_dbus_connection_call_finish (G_DBUS_CONNECTION (object),
|
|
result, &error);
|
|
if (!variant)
|
|
{
|
|
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
|
|
{
|
|
self = CC_DISPLAY_CONFIG_MANAGER_DBUS (data);
|
|
g_clear_pointer (&self->current_state, g_variant_unref);
|
|
_cc_display_config_manager_emit_changed (CC_DISPLAY_CONFIG_MANAGER (data));
|
|
g_warning ("Error calling GetCurrentState: %s", error->message);
|
|
}
|
|
return;
|
|
}
|
|
|
|
self = CC_DISPLAY_CONFIG_MANAGER_DBUS (data);
|
|
g_clear_pointer (&self->current_state, g_variant_unref);
|
|
self->current_state = variant;
|
|
|
|
_cc_display_config_manager_emit_changed (CC_DISPLAY_CONFIG_MANAGER (self));
|
|
}
|
|
|
|
static void
|
|
get_current_state (CcDisplayConfigManagerDBus *self)
|
|
{
|
|
g_dbus_connection_call (self->connection,
|
|
"org.gnome.Mutter.DisplayConfig",
|
|
"/org/gnome/Mutter/DisplayConfig",
|
|
"org.gnome.Mutter.DisplayConfig",
|
|
"GetCurrentState",
|
|
NULL,
|
|
NULL,
|
|
G_DBUS_CALL_FLAGS_NO_AUTO_START,
|
|
-1,
|
|
self->cancellable,
|
|
got_current_state,
|
|
self);
|
|
}
|
|
|
|
static void
|
|
monitors_changed (GDBusConnection *connection,
|
|
const gchar *sender_name,
|
|
const gchar *object_path,
|
|
const gchar *interface_name,
|
|
const gchar *signal_name,
|
|
GVariant *parameters,
|
|
gpointer data)
|
|
{
|
|
CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (data);
|
|
get_current_state (self);
|
|
}
|
|
|
|
static void
|
|
ensure_output_luminance_entry (CcDisplayConfigManagerDBus *self,
|
|
const char *connector,
|
|
CcDisplayColorMode color_mode,
|
|
double luminance,
|
|
double default_luminance)
|
|
{
|
|
LuminanceEntry *entry;
|
|
|
|
entry = find_luminance_entry (self, connector, color_mode);
|
|
if (entry)
|
|
{
|
|
entry->luminance = luminance;
|
|
}
|
|
else
|
|
{
|
|
entry = luminance_entry_new (connector, color_mode,
|
|
luminance, default_luminance);
|
|
g_ptr_array_add (self->output_luminance, entry);
|
|
}
|
|
}
|
|
|
|
static void
|
|
update_luminance (CcDisplayConfigManagerDBus *self)
|
|
{
|
|
g_autoptr(GVariant) variant = NULL;
|
|
GVariantIter iter;
|
|
gpointer luminance_entry_pointer;
|
|
|
|
variant = g_dbus_proxy_get_cached_property (self->proxy, "Luminance");
|
|
g_return_if_fail (variant);
|
|
|
|
g_variant_iter_init (&iter, variant);
|
|
while (g_variant_iter_next (&iter, "@a{sv}", &luminance_entry_pointer))
|
|
{
|
|
g_autoptr(GVariant) luminance_entry = luminance_entry_pointer;
|
|
char *connector = NULL;
|
|
uint32_t color_mode_value;
|
|
double luminance;
|
|
double default_luminance;
|
|
|
|
g_variant_lookup (luminance_entry, "connector", "&s", &connector);
|
|
g_variant_lookup (luminance_entry, "color-mode", "u", &color_mode_value);
|
|
|
|
g_variant_lookup (luminance_entry, "luminance", "d", &luminance);
|
|
g_variant_lookup (luminance_entry, "default", "d", &default_luminance);
|
|
|
|
ensure_output_luminance_entry (self, connector, color_mode_value,
|
|
luminance, default_luminance);
|
|
}
|
|
}
|
|
|
|
static double
|
|
cc_display_config_manager_dbus_get_luminance (CcDisplayConfigManager *pself,
|
|
CcDisplayMonitor *monitor,
|
|
CcDisplayColorMode color_mode)
|
|
{
|
|
CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (pself);
|
|
const char *connector = cc_display_monitor_get_connector_name (monitor);
|
|
LuminanceEntry *entry = find_luminance_entry (self, connector, color_mode);
|
|
|
|
g_return_val_if_fail (entry, 100.0);
|
|
|
|
return entry->luminance;
|
|
}
|
|
|
|
static double
|
|
cc_display_config_manager_dbus_get_default_luminance (CcDisplayConfigManager *pself,
|
|
CcDisplayMonitor *monitor,
|
|
CcDisplayColorMode color_mode)
|
|
{
|
|
CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (pself);
|
|
const char *connector = cc_display_monitor_get_connector_name (monitor);
|
|
LuminanceEntry *entry = find_luminance_entry (self, connector, color_mode);
|
|
|
|
g_return_val_if_fail (entry, 100.0);
|
|
|
|
return entry->default_luminance;
|
|
}
|
|
|
|
static void
|
|
cc_display_config_manager_dbus_set_luminance (CcDisplayConfigManager *pself,
|
|
CcDisplayMonitor *monitor,
|
|
CcDisplayColorMode color_mode,
|
|
double new_luminance)
|
|
{
|
|
CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (pself);
|
|
const char *connector = cc_display_monitor_get_connector_name (monitor);
|
|
LuminanceEntry *entry = find_luminance_entry (self, connector, color_mode);
|
|
|
|
g_return_if_fail (entry);
|
|
|
|
if (G_APPROX_VALUE (new_luminance, entry->default_luminance, DBL_EPSILON))
|
|
{
|
|
g_dbus_proxy_call (self->proxy,
|
|
"ResetLuminance",
|
|
g_variant_new ("(su)",
|
|
connector,
|
|
color_mode),
|
|
G_DBUS_CALL_FLAGS_NO_AUTO_START,
|
|
-1,
|
|
NULL, NULL, NULL);
|
|
}
|
|
else
|
|
{
|
|
g_dbus_proxy_call (self->proxy,
|
|
"SetLuminance",
|
|
g_variant_new ("(sud)",
|
|
connector,
|
|
color_mode,
|
|
new_luminance),
|
|
G_DBUS_CALL_FLAGS_NO_AUTO_START,
|
|
-1,
|
|
NULL, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
static void
|
|
properties_changed (GDBusProxy *proxy,
|
|
GVariant *changed_properties,
|
|
char **invalidated_properties,
|
|
CcDisplayConfigManagerDBus *self)
|
|
{
|
|
update_luminance (self);
|
|
}
|
|
|
|
static void
|
|
bus_gotten (GObject *object,
|
|
GAsyncResult *result,
|
|
gpointer data)
|
|
{
|
|
CcDisplayConfigManagerDBus *self;
|
|
GDBusConnection *connection;
|
|
g_autoptr(GError) error = NULL;
|
|
g_autoptr(GVariant) variant = NULL;
|
|
|
|
connection = g_bus_get_finish (result, &error);
|
|
if (!connection)
|
|
{
|
|
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
|
|
{
|
|
_cc_display_config_manager_emit_changed (CC_DISPLAY_CONFIG_MANAGER (data));
|
|
g_warning ("Error obtaining DBus connection: %s", error->message);
|
|
}
|
|
return;
|
|
}
|
|
|
|
self = CC_DISPLAY_CONFIG_MANAGER_DBUS (data);
|
|
self->connection = connection;
|
|
self->monitors_changed_id =
|
|
g_dbus_connection_signal_subscribe (self->connection,
|
|
"org.gnome.Mutter.DisplayConfig",
|
|
"org.gnome.Mutter.DisplayConfig",
|
|
"MonitorsChanged",
|
|
"/org/gnome/Mutter/DisplayConfig",
|
|
NULL,
|
|
G_DBUS_SIGNAL_FLAGS_NONE,
|
|
monitors_changed,
|
|
self,
|
|
NULL);
|
|
|
|
self->proxy = g_dbus_proxy_new_sync (self->connection,
|
|
G_DBUS_PROXY_FLAGS_NONE,
|
|
NULL,
|
|
"org.gnome.Mutter.DisplayConfig",
|
|
"/org/gnome/Mutter/DisplayConfig",
|
|
"org.gnome.Mutter.DisplayConfig",
|
|
NULL,
|
|
&error);
|
|
if (!self->proxy)
|
|
{
|
|
g_warning ("Failed to create D-Bus proxy to \"org.gnome.Mutter.DisplayConfig\": %s",
|
|
error->message);
|
|
return;
|
|
}
|
|
|
|
self->properties_changed_id =
|
|
g_signal_connect (self->proxy, "g-properties-changed",
|
|
G_CALLBACK (properties_changed),
|
|
self);
|
|
update_luminance (self);
|
|
|
|
variant = g_dbus_proxy_get_cached_property (self->proxy, "ApplyMonitorsConfigAllowed");
|
|
if (variant)
|
|
self->apply_allowed = g_variant_get_boolean (variant);
|
|
else
|
|
g_warning ("Missing property 'ApplyMonitorsConfigAllowed' on DisplayConfig API");
|
|
|
|
variant = g_dbus_proxy_get_cached_property (self->proxy, "NightLightSupported");
|
|
if (variant)
|
|
self->night_light_supported = g_variant_get_boolean (variant);
|
|
else
|
|
g_warning ("Missing property 'NightLightSupported' on DisplayConfig API");
|
|
|
|
get_current_state (self);
|
|
}
|
|
|
|
static void
|
|
cc_display_config_manager_dbus_init (CcDisplayConfigManagerDBus *self)
|
|
{
|
|
self->apply_allowed = TRUE;
|
|
self->night_light_supported = TRUE;
|
|
self->cancellable = g_cancellable_new ();
|
|
self->output_luminance =
|
|
g_ptr_array_new_with_free_func ((GDestroyNotify) luminance_entry_free);
|
|
|
|
g_bus_get (G_BUS_TYPE_SESSION, self->cancellable, bus_gotten, self);
|
|
}
|
|
|
|
static void
|
|
cc_display_config_manager_dbus_finalize (GObject *object)
|
|
{
|
|
CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (object);
|
|
|
|
g_cancellable_cancel (self->cancellable);
|
|
g_clear_object (&self->cancellable);
|
|
g_ptr_array_unref (self->output_luminance);
|
|
g_object_unref (self->proxy);
|
|
|
|
if (self->monitors_changed_id && self->connection)
|
|
g_dbus_connection_signal_unsubscribe (self->connection,
|
|
self->monitors_changed_id);
|
|
g_clear_object (&self->connection);
|
|
g_clear_pointer (&self->current_state, g_variant_unref);
|
|
|
|
G_OBJECT_CLASS (cc_display_config_manager_dbus_parent_class)->finalize (object);
|
|
}
|
|
|
|
static gboolean
|
|
cc_display_config_manager_dbus_get_apply_allowed (CcDisplayConfigManager *pself)
|
|
{
|
|
CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (pself);
|
|
|
|
return self->apply_allowed;
|
|
}
|
|
|
|
static gboolean
|
|
cc_display_config_manager_dbus_get_night_light_supported (CcDisplayConfigManager *pself)
|
|
{
|
|
CcDisplayConfigManagerDBus *self = CC_DISPLAY_CONFIG_MANAGER_DBUS (pself);
|
|
|
|
return self->night_light_supported;
|
|
}
|
|
|
|
static void
|
|
cc_display_config_manager_dbus_class_init (CcDisplayConfigManagerDBusClass *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
CcDisplayConfigManagerClass *parent_class = CC_DISPLAY_CONFIG_MANAGER_CLASS (klass);
|
|
|
|
gobject_class->finalize = cc_display_config_manager_dbus_finalize;
|
|
|
|
parent_class->get_current = cc_display_config_manager_dbus_get_current;
|
|
parent_class->get_apply_allowed = cc_display_config_manager_dbus_get_apply_allowed;
|
|
parent_class->get_night_light_supported = cc_display_config_manager_dbus_get_night_light_supported;
|
|
parent_class->get_luminance = cc_display_config_manager_dbus_get_luminance;
|
|
parent_class->get_default_luminance = cc_display_config_manager_dbus_get_default_luminance;
|
|
parent_class->set_luminance = cc_display_config_manager_dbus_set_luminance;
|
|
}
|
|
|
|
CcDisplayConfigManager *
|
|
cc_display_config_manager_dbus_new (void)
|
|
{
|
|
return g_object_new (CC_TYPE_DISPLAY_CONFIG_MANAGER_DBUS, NULL);
|
|
}
|