static void
update_sensor_value(IsSensor *sensor,
IsATIConfigPlugin *self)
{
const gchar *path;
gint gpu;
gdouble value = 0.0;
gboolean ret = FALSE;
GError *error = NULL;
path = is_sensor_get_path(sensor);
gpu = g_ascii_strtoll(path + strlen(ATICONFIG_PATH_PREFIX), NULL, 10);
if (IS_IS_TEMPERATURE_SENSOR(sensor)) {
ret = aticonfig_get_temperature(self, gpu, &value, &error);
if (ret) {
is_temperature_sensor_set_celsius_value(IS_TEMPERATURE_SENSOR(sensor),
value);
}
} else {
/* is a fan sensor */
ret = aticonfig_get_fanspeed(self, gpu, &value, &error);
if (ret) {
is_sensor_set_value(sensor, value);
}
}
/* emit any error which may have occurred */
if (error) {
is_sensor_emit_error(sensor, error);
g_error_free(error);
}
}
static void
sensor_menu_item_toggled(GtkMenuItem *menu_item,
IsIndicator *self)
{
IsSensor *sensor;
gboolean active = FALSE;
g_return_if_fail(IS_IS_INDICATOR(self));
/* only set as primary if was toggled to active state since we may have
* untoggled it instead */
active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(menu_item));
if (active)
{
sensor = IS_SENSOR(g_object_get_data(G_OBJECT(menu_item),
"sensor"));
is_debug("indicator", "Sensor %s menu-item toggled to active - setting as primary sensor",
is_sensor_get_path(sensor));
is_indicator_set_primary_sensor_path(self, is_sensor_get_path(sensor));
}
}
static void
update_sensor_value(IsSensor *sensor,
IsNvidiaPlugin *self)
{
IsNvidiaPluginPrivate *priv;
const gchar *path;
guint i;
priv = self->priv;
path = is_sensor_get_path(sensor);
for (i = 0; i < G_N_ELEMENTS(map); i++) {
Bool ret;
int value;
int idx;
if (g_strrstr(path, map[i].description) == NULL) {
continue;
}
idx = g_ascii_strtoll(g_strrstr(path, map[i].description) +
strlen(map[i].description), NULL, 10);
ret = XNVCTRLQueryTargetAttribute(priv->display,
map[i].target,
idx,
0,
map[i].attribute,
&value);
if (!ret) {
GError *error = g_error_new(g_quark_from_string("nvidia-plugin-error-quark"),
0,
/* first placeholder is
* sensor name */
_("Error getting sensor value for sensor %s"),
path);
is_sensor_emit_error(sensor, error);
g_error_free(error);
continue;
}
if (IS_IS_TEMPERATURE_SENSOR(sensor)) {
is_temperature_sensor_set_celsius_value(IS_TEMPERATURE_SENSOR(sensor),
value);
} else {
is_sensor_set_value(sensor, value);
}
}
}
static void
_sensor_disabled(IsSensor *sensor,
IsIndicator *self)
{
IsIndicatorPrivate *priv = self->priv;
GtkWidget *menu_item;
is_debug("indicator", "disabling sensor %s",
is_sensor_get_path(sensor));
/* destroy menu item */
menu_item = GTK_WIDGET(g_object_get_data(G_OBJECT(sensor),
"menu-item"));
priv->menu_items = g_slist_remove(priv->menu_items, menu_item);
gtk_container_remove(GTK_CONTAINER(is_indicator_get_menu(self)),
menu_item);
g_object_set_data(G_OBJECT(sensor), "menu-item", NULL);
g_signal_handlers_disconnect_by_func(sensor,
sensor_notify,
self);
}
static void
is_sensor_dialog_set_property(GObject *object,
guint property_id, const GValue *value, GParamSpec *pspec)
{
IsSensorDialog *self = IS_SENSOR_DIALOG(object);
IsSensorDialogPrivate *priv = self->priv;
gchar *markup;
switch (property_id) {
case PROP_SENSOR:
priv->sensor = g_object_ref(g_value_get_object(value));
markup = g_strdup_printf("<span weight='bold'>%s: %s</span>",
_("Sensor"),
is_sensor_get_path(priv->sensor));
gtk_label_set_markup(GTK_LABEL(priv->path_label),
markup);
g_free(markup);
gtk_widget_set_sensitive(priv->label_entry, TRUE);
gtk_entry_set_text(GTK_ENTRY(priv->label_entry),
is_sensor_get_label(priv->sensor));
g_signal_connect(priv->label_entry, "changed",
G_CALLBACK(label_changed),
self);
g_signal_connect(priv->sensor, "notify::label",
G_CALLBACK(sensor_notify_label),
self);
gtk_widget_set_sensitive(priv->alarm_mode_combo_box, TRUE);
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->alarm_mode_combo_box),
is_sensor_get_alarm_mode(priv->sensor));
g_signal_connect(priv->alarm_mode_combo_box, "changed",
G_CALLBACK(alarm_mode_changed),
self);
g_signal_connect(priv->sensor, "notify::alarm-mode",
G_CALLBACK(sensor_notify_alarm_mode),
self);
/* set sensitive so we can update */
gtk_widget_set_sensitive(priv->alarm_value_spin_button, TRUE);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(priv->alarm_value_spin_button),
is_sensor_get_digits(priv->sensor));
gtk_spin_button_set_value(GTK_SPIN_BUTTON(priv->alarm_value_spin_button),
is_sensor_get_alarm_value(priv->sensor));
g_signal_connect(priv->alarm_value_spin_button, "value-changed",
G_CALLBACK(alarm_value_changed),
self);
g_signal_connect(priv->sensor, "notify::alarm-value",
G_CALLBACK(sensor_notify_alarm_value),
self);
gtk_widget_set_sensitive(priv->alarm_value_spin_button,
(is_sensor_get_alarm_mode(priv->sensor) !=
IS_SENSOR_ALARM_MODE_DISABLED));
gtk_widget_set_sensitive(priv->units_label, TRUE);
gtk_label_set_text(GTK_LABEL(priv->units_label),
is_sensor_get_units(priv->sensor));
g_signal_connect(priv->sensor, "notify::units",
G_CALLBACK(sensor_notify_units),
self);
gtk_widget_set_sensitive(priv->low_value, TRUE);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(priv->low_value),
is_sensor_get_low_value(priv->sensor));
g_signal_connect(priv->low_value, "value-changed",
G_CALLBACK(low_value_changed),
self);
g_signal_connect(priv->sensor, "notify::low-value",
G_CALLBACK(sensor_notify_low_value),
self);
gtk_label_set_text(GTK_LABEL(priv->low_units_label),
is_sensor_get_units(priv->sensor));
gtk_widget_set_sensitive(priv->high_value, TRUE);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(priv->high_value),
is_sensor_get_high_value(priv->sensor));
g_signal_connect(priv->high_value, "value-changed",
G_CALLBACK(high_value_changed),
self);
g_signal_connect(priv->sensor, "notify::high-value",
G_CALLBACK(sensor_notify_high_value),
self);
gtk_label_set_text(GTK_LABEL(priv->high_units_label),
is_sensor_get_units(priv->sensor));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
static void
update_sensor_value(IsTemperatureSensor *sensor,
IsUdisksPlugin *self)
{
IsUdisksPluginPrivate *priv;
gchar *device, *path;
GDBusProxy *proxy;
GVariant *var;
GError *error = NULL;
SkDisk *sk_disk;
const gchar *blob;
gsize len;
guint64 temperature;
gdouble value;
priv = self->priv;
device = g_path_get_basename(is_sensor_get_path(IS_SENSOR(sensor)));
path = g_strdup_printf("%s/devices/%s", UDISKS_OBJECT_PATH, device);
proxy = g_dbus_proxy_new_sync(priv->connection,
G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
NULL,
UDISKS_BUS_NAME,
path,
UDISKS_DEVICE_INTERFACE_NAME,
NULL, &error);
g_free(path);
g_free(device);
if (!proxy) {
g_prefix_error(&error,
_("Error reading new SMART data for sensor %s"),
is_sensor_get_path(IS_SENSOR(sensor)));
is_sensor_emit_error(IS_SENSOR(sensor), error);
g_error_free(error);
goto out;
}
/* update smart data */
var = g_variant_new_strv(NULL, 0);
var = g_dbus_proxy_call_sync(proxy, "DriveAtaSmartRefreshData",
g_variant_new_tuple(&var,
1),
G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &error);
if (!var) {
g_prefix_error(&error,
_("Error refreshing SMART data for sensor %s"),
is_sensor_get_path(IS_SENSOR(sensor)));
is_sensor_emit_error(IS_SENSOR(sensor), error);
g_error_free(error);
g_object_unref(proxy);
goto out;
}
g_variant_unref(var);
var = g_dbus_proxy_get_cached_property(proxy,
"DriveAtaSmartBlob");
if (!var) {
is_debug("udisks", "unable to get atasmartblob for sensor %s",
is_sensor_get_path(IS_SENSOR(sensor)));
g_object_unref(proxy);
goto out;
}
g_object_unref(proxy);
/* can't unref var until done with blob */
blob = g_variant_get_fixed_array(var, &len, sizeof(gchar));
if (!blob) {
/* this can occur if udisks doesn't update immediately,
* ignore */
g_variant_unref(var);
goto out;
}
sk_disk_open(NULL, &sk_disk);
sk_disk_set_blob(sk_disk, blob, len);
if (sk_disk_smart_get_temperature(sk_disk, &temperature) < 0)
{
is_debug("udisks", "Error getting temperature from AtaSmartBlob for sensor %s",
is_sensor_get_path(IS_SENSOR(sensor)));
sk_disk_free(sk_disk);
g_variant_unref(var);
/* TODO: emit error */
goto out;
}
sk_disk_free(sk_disk);
g_variant_unref(var);
/* Temperature is in mK, so convert it to K first */
temperature /= 1000;
value = (gdouble)temperature - 273.15;
is_temperature_sensor_set_celsius_value(sensor, value);
out:
return;
}
static void
sensor_enabled(IsManager *manager,
IsSensor *sensor,
gint position,
IsIndicator *self)
{
IsIndicatorPrivate *priv = self->priv;
/* make sure we haven't seen this sensor before - if sensor has a
* menu-item then ignore it */
if (!g_object_get_data(G_OBJECT(sensor), "menu-item"))
{
GtkMenu *menu;
GtkWidget *menu_item;
is_debug("indicator", "Creating menu item for newly enabled sensor %s",
is_sensor_get_path(sensor));
g_signal_connect(sensor, "notify::value",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::label",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::alarmed",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::low-value",
G_CALLBACK(sensor_notify),
self);
g_signal_connect(sensor, "notify::high-value",
G_CALLBACK(sensor_notify),
self);
/* add a menu entry for this sensor */
menu = is_indicator_get_menu(self);
menu_item = gtk_check_menu_item_new();
gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(menu_item),
TRUE);
g_object_set_data(G_OBJECT(sensor), "menu-item", menu_item);
g_object_set_data(G_OBJECT(menu_item), "sensor", sensor);
priv->menu_items = g_slist_insert(priv->menu_items, menu_item,
position);
/* if we haven't seen our primary sensor yet or if this is the
* primary sensor, display this as primary anyway */
if (!priv->primary ||
g_strcmp0(is_sensor_get_path(sensor),
priv->primary_sensor_path) == 0)
{
is_debug("indicator", "Using sensor with path %s as primary",
is_sensor_get_path(sensor));
if (priv->primary)
{
GtkCheckMenuItem *item;
/* uncheck menu item if exists for this
* existing primary sensor */
item = (GtkCheckMenuItem *)(g_object_get_data(G_OBJECT(priv->primary),
"menu-item"));
if (item)
{
is_debug("indicator", "Unchecking current primary sensor item");
gtk_check_menu_item_set_active(item, FALSE);
}
g_object_unref(priv->primary);
}
priv->primary = g_object_ref(sensor);
is_debug("indicator", "Checking new primary sensor item");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item),
TRUE);
update_sensor_menu_item_label(self, sensor,
GTK_MENU_ITEM(menu_item));
}
/* connect to toggled signal now - if we connect to it earlier
* we may interpret the above menu_item_set_active as a user
* initiated setting of the primary sensor rather than us just
* picking the first available sensor */
g_signal_connect(menu_item, "toggled",
G_CALLBACK(sensor_menu_item_toggled),
self);
gtk_widget_show_all(menu_item);
update_sensor_menu_item_label(self, sensor, GTK_MENU_ITEM(menu_item));
gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menu_item, position);
}
else
{
is_debug("indicator", "Newly enabled sensor %s already has a menu-item, ignoring...",
is_sensor_get_path(sensor));
}
}
gboolean
is_store_add_sensor(IsStore *self,
IsSensor *sensor,
GtkTreeIter *iter)
{
IsStorePrivate *priv;
GSequence *entries;
IsStoreEntry *entry = NULL;
GSequenceIter *parent = NULL;
gchar **names = NULL;
int i;
GtkTreePath *path;
GtkTreeIter _iter;
gboolean ret = FALSE;
g_return_val_if_fail(IS_IS_STORE(self), FALSE);
g_return_val_if_fail(IS_IS_SENSOR(sensor), FALSE);
priv = self->priv;
entry = find_entry(self, is_sensor_get_path(sensor));
if (entry) {
is_warning("store", "sensor %s already exists in store, not adding duplicate",
is_sensor_get_path(sensor));
goto out;
}
entries = priv->entries;
names = g_strsplit(is_sensor_get_path(sensor), "/", 0);
/* otherwise iterate through to create the entry */
for (i = 0; names[i] != NULL; i++) {
GSequenceIter *seq_iter;
gchar *name = names[i];
entry = NULL;
for (seq_iter = g_sequence_get_begin_iter(entries);
!g_sequence_iter_is_end(seq_iter);
seq_iter = g_sequence_iter_next(seq_iter))
{
entry = (IsStoreEntry *)g_sequence_get(seq_iter);
if (g_strcmp0(entry->name, name) == 0) {
entries = entry->entries;
parent = seq_iter;
break;
}
entry = NULL;
}
if (!entry) {
/* create entry for this name component */
entry = entry_new(name);
entry->iter = g_sequence_append(entries, entry);
entry->parent = parent;
entries = entry->entries;
_iter.stamp = priv->stamp;
_iter.user_data = entry->iter;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(self),
&_iter);
gtk_tree_model_row_inserted(GTK_TREE_MODEL(self), path,
&_iter);
gtk_tree_path_free(path);
/* parent of the next entry we create will be this
* entry */
parent = entry->iter;
}
}
g_strfreev(names);
g_assert(entry);
g_assert(find_entry(self, is_sensor_get_path(sensor)) == entry);
is_debug("store", "inserted sensor %s with label %s",
is_sensor_get_path(sensor), is_sensor_get_label(sensor));
entry->sensor = g_object_ref(sensor);
_iter.stamp = priv->stamp;
_iter.user_data = entry->iter;
path = gtk_tree_model_get_path(GTK_TREE_MODEL(self),
&_iter);
gtk_tree_model_row_changed(GTK_TREE_MODEL(self), path,
&_iter);
gtk_tree_path_free(path);
/* return a copy of iter */
if (iter != NULL) {
iter->stamp = priv->stamp;
iter->user_data = entry->iter;
}
ret = TRUE;
out:
return ret;
}
