static void
is_indicator_set_property(GObject *object,
guint property_id, const GValue *value, GParamSpec *pspec)
{
IsIndicator *self = IS_INDICATOR(object);
IsIndicatorPrivate *priv = self->priv;
IsManager *manager;
switch (property_id)
{
case PROP_APPLICATION:
g_assert(!priv->application);
priv->application = g_object_ref(g_value_get_object(value));
manager = is_application_get_manager(priv->application);
g_signal_connect(manager, "sensor-enabled",
G_CALLBACK(sensor_enabled), self);
g_signal_connect(manager, "sensor-disabled",
G_CALLBACK(sensor_disabled), self);
g_signal_connect(manager, "sensor-added",
G_CALLBACK(sensor_added), self);
break;
case PROP_PRIMARY_SENSOR_PATH:
is_indicator_set_primary_sensor_path(self, g_value_get_string(value));
break;
case PROP_DISPLAY_FLAGS:
is_indicator_set_display_flags(self, g_value_get_int(value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
static void
is_max_plugin_deactivate(PeasActivatable *activatable)
{
IsMaxPlugin *self = IS_MAX_PLUGIN(activatable);
IsMaxPluginPrivate *priv = self->priv;
IsManager *manager;
GSList *sensors, *_list;
is_debug("max", "dettaching from signals");
manager = is_application_get_manager(priv->application);
is_manager_remove_path(manager, MAX_SENSOR_PATH);
sensors = is_manager_get_enabled_sensors_list(manager);
for (_list = sensors;
_list != NULL;
_list = _list->next)
{
IsSensor *sensor = IS_SENSOR(_list->data);
on_sensor_disabled(manager, sensor, self);
g_object_unref(sensor);
}
g_slist_free(sensors);
g_signal_handlers_disconnect_by_func(manager,
G_CALLBACK(on_sensor_enabled), self);
g_signal_handlers_disconnect_by_func(manager,
G_CALLBACK(on_sensor_disabled), self);
}
static void
is_indicator_dispose(GObject *object)
{
IsIndicator *self = (IsIndicator *)object;
IsIndicatorPrivate *priv = self->priv;
IsManager *manager;
GSList *sensors, *_list;
manager = is_application_get_manager(priv->application);
g_signal_handlers_disconnect_by_func(manager, sensor_enabled, self);
g_signal_handlers_disconnect_by_func(manager, sensor_disabled, self);
g_signal_handlers_disconnect_by_func(manager, sensor_added, self);
/* fake disabling of any sensors */
sensors = is_manager_get_enabled_sensors_list(manager);
for (_list = sensors; _list != NULL; _list = _list->next)
{
IsSensor *sensor = IS_SENSOR(_list->data);
_sensor_disabled(IS_SENSOR(_list->data), self);
g_object_unref(sensor);
}
g_slist_free(sensors);
#if !HAVE_APPINDICATOR
g_object_set_data(G_OBJECT(self), "indicator-menu", NULL);
#endif
G_OBJECT_CLASS(is_indicator_parent_class)->dispose(object);
}
static gboolean
fake_add_enable_sensors(IsIndicator *self)
{
IsManager *manager;
GSList *sensors, *_list;
gint i = 0;
manager = is_application_get_manager(self->priv->application);
/* fake addition of any sensors */
sensors = is_manager_get_all_sensors_list(manager);
for (_list = sensors; _list != NULL; _list = _list->next)
{
IsSensor *sensor = IS_SENSOR(_list->data);
sensor_added(manager, IS_SENSOR(_list->data), self);
g_object_unref(sensor);
}
g_slist_free(sensors);
/* fake enabling of any sensors */
sensors = is_manager_get_enabled_sensors_list(manager);
for (_list = sensors; _list != NULL; _list = _list->next)
{
IsSensor *sensor = IS_SENSOR(_list->data);
sensor_enabled(manager, IS_SENSOR(_list->data), i++,
self);
g_object_unref(sensor);
}
g_slist_free(sensors);
return FALSE;
}
void is_indicator_set_primary_sensor_path(IsIndicator *self,
const gchar *path)
{
IsIndicatorPrivate *priv;
g_return_if_fail(IS_IS_INDICATOR(self));
priv = self->priv;
if (g_strcmp0(priv->primary_sensor_path, path) != 0 &&
g_strcmp0(path, "") != 0)
{
IsSensor *sensor;
is_debug("indicator", "new primary sensor path %s (previously %s)",
path, priv->primary_sensor_path);
/* uncheck current primary sensor label - may be NULL as is
* already disabled */
if (priv->primary)
{
GtkCheckMenuItem *item;
item = (GtkCheckMenuItem *)(g_object_get_data(G_OBJECT(priv->primary),
"menu-item"));
if (item)
{
gtk_check_menu_item_set_active(item, FALSE);
}
g_object_unref(priv->primary);
}
g_free(priv->primary_sensor_path);
priv->primary_sensor_path = g_strdup(path);
is_debug("indicator", "Setting primary sensor path to: %s", path);
/* try and activate this sensor if it exists */
sensor = is_manager_get_sensor(is_application_get_manager(priv->application),
priv->primary_sensor_path);
if (sensor)
{
GtkCheckMenuItem *item = (GtkCheckMenuItem *)(g_object_get_data(G_OBJECT(sensor),
"menu-item"));
/* take reference from manager */
priv->primary = sensor;
if (item)
{
gtk_check_menu_item_set_active(item, TRUE);
update_sensor_menu_item_label(self, sensor,
GTK_MENU_ITEM(item));
}
}
g_object_notify_by_pspec(G_OBJECT(self),
properties[PROP_PRIMARY_SENSOR_PATH]);
}
}
static void
manager_selection_changed(GtkTreeSelection *selection,
IsPreferencesDialog *self)
{
IsSensor *sensor;
gboolean sensitive = FALSE;
sensor = is_manager_get_selected_sensor(is_application_get_manager(self->priv->application));
if (sensor) {
sensitive = TRUE;
g_object_unref(sensor);
}
gtk_widget_set_sensitive(self->priv->sensor_properties_button,
sensitive);
}
static void
is_fake_plugin_activate(PeasActivatable *activatable)
{
IsFakePlugin *self = IS_FAKE_PLUGIN(activatable);
IsFakePluginPrivate *priv = self->priv;
int i;
int n_fans = 0;
/* generate some fake sensors */
for (i = 0; i < 5; i++) {
gchar *path;
gchar *label;
IsSensor *sensor;
path = g_strdup_printf("fake/sensor%d", i);
if (g_rand_boolean(priv->rand)) {
n_fans++;
sensor = is_fan_sensor_new(path);
is_sensor_set_low_value(sensor, 100.0);
is_sensor_set_high_value(sensor, 5000.0);
label = g_strdup_printf(_("Fake Fan %d"),
n_fans);
} else {
sensor = is_temperature_sensor_new(path);
is_sensor_set_icon(sensor, IS_STOCK_CPU);
label = g_strdup_printf(_("Fake CPU %d"),
i - n_fans + 1);
}
/* no decimal places to display */
is_sensor_set_digits(sensor, 0);
is_sensor_set_label(sensor, label);
/* connect to update-value signal */
g_signal_connect(sensor, "update-value",
G_CALLBACK(update_sensor_value),
self);
is_manager_add_sensor(is_application_get_manager(priv->application),
sensor);
g_free(label);
g_free(path);
}
}
static void
is_max_plugin_activate(PeasActivatable *activatable)
{
IsMaxPlugin *self = IS_MAX_PLUGIN(activatable);
IsMaxPluginPrivate *priv = self->priv;
IsManager *manager;
GSList *sensors, *_list;
int i = 0;
manager = is_application_get_manager(priv->application);
// create our virtual sensor which mimics the current highest value sensor's
// value and label
is_debug("max", "creating virtual sensor");
priv->sensor = is_sensor_new(MAX_SENSOR_PATH);
is_sensor_set_label(priv->sensor, "Δ");
is_sensor_set_icon(priv->sensor, IS_STOCK_CHIP);
is_sensor_set_value(priv->sensor, 0.0);
is_sensor_set_units(priv->sensor, "");
is_sensor_set_digits(priv->sensor, 1);
is_manager_add_sensor(manager, priv->sensor);
is_debug("max", "attaching to signals");
sensors = is_manager_get_enabled_sensors_list(manager);
for (_list = sensors;
_list != NULL;
_list = _list->next)
{
IsSensor *sensor = IS_SENSOR(_list->data);
on_sensor_enabled(manager, sensor, i, self);
g_object_unref(sensor);
i++;
}
g_slist_free(sensors);
g_signal_connect(manager, "sensor-enabled",
G_CALLBACK(on_sensor_enabled), self);
g_signal_connect(manager, "sensor-disabled",
G_CALLBACK(on_sensor_disabled), self);
}
static void
is_udisks_plugin_activate(PeasActivatable *activatable)
{
IsUdisksPlugin *self = IS_UDISKS_PLUGIN(activatable);
IsUdisksPluginPrivate *priv = self->priv;
GDBusProxy *proxy;
GError *error = NULL;
GVariant *container, *paths;
GVariantIter iter;
gchar *path;
priv->connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
if (!priv->connection)
{
is_warning("udisks", "Failed to open connection to system dbus: %s",
error->message);
g_error_free(error);
goto out;
}
/* This is the proxy which is only used once during the enumeration of
* the device object paths
*/
proxy = g_dbus_proxy_new_sync(priv->connection,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
NULL,
UDISKS_BUS_NAME,
UDISKS_OBJECT_PATH,
UDISKS_INTERFACE_NAME,
NULL, &error);
if (!proxy) {
is_warning("udisks", "Error getting proxy to udisks on system bus: %s",
error->message);
g_error_free(error);
goto out;
}
/* The object paths of the disks are enumerated and placed in an array
* of object paths
*/
container = g_dbus_proxy_call_sync(proxy, "EnumerateDevices", NULL,
G_DBUS_CALL_FLAGS_NONE, -1, NULL,
&error);
if (!container) {
is_warning("udisks", "Failed to enumerate disk devices: %s",
error->message);
g_error_free(error);
g_object_unref(proxy);
goto out;
}
paths = g_variant_get_child_value(container, 0);
g_variant_unref(container);
g_variant_iter_init(&iter, paths);
while (g_variant_iter_loop(&iter, "o", &path)) {
/* This proxy is used to get the required data in order to build
* up the list of sensors
*/
GDBusProxy *sensor_proxy;
GVariant *model, *smart_available;
IsSensor *sensor;
gchar *name, *sensor_path;
sensor_proxy = g_dbus_proxy_new_sync(priv->connection,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
UDISKS_BUS_NAME,
path,
UDISKS_DEVICE_INTERFACE_NAME,
NULL,
&error);
if (!sensor_proxy) {
is_debug("udisks", "error getting sensor proxy for disk %s: %s",
path, error->message);
g_clear_error(&error);
g_object_unref(sensor_proxy);
continue;
}
smart_available = g_dbus_proxy_get_cached_property(sensor_proxy,
"DriveAtaSmartIsAvailable");
if (!smart_available) {
is_debug("udisks", "error getting smart status for disk %s",
path);
g_object_unref(sensor_proxy);
continue;
}
if (!g_variant_get_boolean(smart_available)) {
is_debug("udisks", "drive %s does not support SMART monitoring, ignoring...",
path);
g_variant_unref(smart_available);
g_object_unref(sensor_proxy);
continue;
}
g_variant_unref(smart_available);
model = g_dbus_proxy_get_cached_property(sensor_proxy,
"DriveModel");
if (!model) {
is_debug("udisks", "error getting drive model for disk %s",
path);
g_clear_error(&error);
g_object_unref(sensor_proxy);
continue;
}
name = g_path_get_basename(path);
sensor_path = g_strdup_printf("udisks/%s", name);
sensor = is_temperature_sensor_new(sensor_path);
is_sensor_set_label(sensor, g_variant_get_string(model, NULL));
is_sensor_set_digits(sensor, 0);
is_sensor_set_icon(sensor, IS_STOCK_DISK);
/* only update every minute to avoid waking disk too much */
is_sensor_set_update_interval(sensor, 60);
g_signal_connect(sensor, "update-value",
G_CALLBACK(update_sensor_value), self);
is_manager_add_sensor(is_application_get_manager(priv->application),
sensor);
g_free(sensor_path);
g_free(name);
g_object_unref(sensor);
g_object_unref(sensor_proxy);
}
g_variant_unref(paths);
g_object_unref(proxy);
out:
return;
}
static void
is_nvidia_plugin_activate(PeasActivatable *activatable)
{
IsNvidiaPlugin *self = IS_NVIDIA_PLUGIN(activatable);
IsNvidiaPluginPrivate *priv = self->priv;
Bool ret;
int event_base, error_base;
gint n;
int i;
/* search for sensors and add them to manager */
if (!priv->inited) {
is_warning("nvidia", "not inited, unable to find sensors");
goto out;
}
is_debug("nvidia", "searching for sensors");
/* check if the NV-CONTROL extension is available on this X
* server */
ret = XNVCTRLQueryExtension(priv->display, &event_base, &error_base);
if (!ret) {
goto out;
}
/* get number of GPUs, then for each GPU get any thermal_sensors and
coolers used by it */
ret = XNVCTRLQueryTargetCount(priv->display,
NV_CTRL_TARGET_TYPE_GPU,
&n);
if (!ret) {
goto out;
}
for (i = 0; i < n; i++) {
guint j;
char *label = NULL;
ret = XNVCTRLQueryTargetStringAttribute(priv->display,
NV_CTRL_TARGET_TYPE_GPU,
i,
0,
NV_CTRL_STRING_PRODUCT_NAME,
&label);
for (j = 0; j < G_N_ELEMENTS(map); j++) {
int32_t *data;
int len;
int k;
ret = XNVCTRLQueryTargetBinaryData(priv->display,
NV_CTRL_TARGET_TYPE_GPU,
i,
0,
map[j].gpu_attribute,
(unsigned char **)&data,
&len);
if (!ret) {
continue;
}
/* data[0] contains number of sensors, and each sensor
indice follows */
for (k = 1; k <= data[0]; k++) {
int idx = data[k];
gint value;
IsSensor *sensor;
gchar *path;
ret = XNVCTRLQueryTargetAttribute(priv->display,
map[j].target,
idx,
0,
map[j].attribute,
&value);
if (!ret) {
continue;
}
path = g_strdup_printf("nvidia/%s%d", map[j].description, idx);
if (map[j].target == NV_CTRL_TARGET_TYPE_COOLER) {
/* fan sensors are given as a percentage
from 0 to 100 */
sensor = is_sensor_new(path);
is_sensor_set_icon(sensor, IS_STOCK_FAN);
is_sensor_set_units(sensor, "%");
is_sensor_set_low_value(sensor, 0.0);
is_sensor_set_high_value(sensor, 100.0);
} else {
sensor = is_temperature_sensor_new(path);
is_sensor_set_icon(sensor, IS_STOCK_GPU);
}
/* no decimal places to display */
is_sensor_set_digits(sensor, 0);
is_sensor_set_label(sensor, label);
/* connect to update-value signal */
g_signal_connect(sensor, "update-value",
G_CALLBACK(update_sensor_value),
self);
is_manager_add_sensor(is_application_get_manager(priv->application),
sensor);
g_free(path);
}
free(data);
}
free(label);
}
out:
return;
}
static void
is_preferences_dialog_set_property(GObject *object,
guint property_id, const GValue *value, GParamSpec *pspec)
{
IsPreferencesDialog *self = IS_PREFERENCES_DIALOG(object);
IsPreferencesDialogPrivate *priv = self->priv;
GtkWidget *scrolled_window;
IsManager *manager;
IsIndicatorDisplayFlags flags;
switch (property_id)
{
case PROP_APPLICATION:
priv->application = g_object_ref(g_value_get_object(value));
gtk_widget_set_sensitive(priv->display_icon_check_button, TRUE);
gtk_widget_set_sensitive(priv->display_label_check_button, TRUE);
gtk_widget_set_sensitive(priv->display_value_check_button, TRUE);
flags = g_settings_get_int(self->priv->indicator_settings,
"display-flags");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->display_icon_check_button),
flags & IS_INDICATOR_DISPLAY_ICON);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->display_label_check_button),
flags & IS_INDICATOR_DISPLAY_LABEL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->display_value_check_button),
flags & IS_INDICATOR_DISPLAY_VALUE);
g_signal_connect(priv->display_icon_check_button, "toggled",
G_CALLBACK(display_icon_toggled),
self);
g_signal_connect(priv->display_label_check_button, "toggled",
G_CALLBACK(display_label_toggled),
self);
g_signal_connect(priv->display_value_check_button, "toggled",
G_CALLBACK(display_value_toggled),
self);
g_signal_connect(priv->indicator_settings, "changed::display-flags",
G_CALLBACK(settings_display_flags_changed),
self);
manager = is_application_get_manager(priv->application);
g_signal_connect(manager, "row-activated",
G_CALLBACK(manager_row_activated), self);
/* control properties button sensitivity */
g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(manager)),
"changed", G_CALLBACK(manager_selection_changed),
self);
/* set state of autostart checkbutton */
gtk_widget_set_sensitive(priv->autostart_check_button, TRUE);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->autostart_check_button),
is_application_get_autostart(priv->application));
gtk_widget_set_sensitive(priv->celsius_radio_button, TRUE);
gtk_widget_set_sensitive(priv->fahrenheit_radio_button, TRUE);
switch (is_application_get_temperature_scale(priv->application))
{
case IS_TEMPERATURE_SENSOR_SCALE_CELSIUS:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->celsius_radio_button),
TRUE);
break;
case IS_TEMPERATURE_SENSOR_SCALE_FAHRENHEIT:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->fahrenheit_radio_button),
TRUE);
break;
case IS_TEMPERATURE_SENSOR_SCALE_INVALID:
case NUM_IS_TEMPERATURE_SENSOR_SCALE:
default:
g_assert_not_reached();
}
g_signal_connect(priv->autostart_check_button, "toggled",
G_CALLBACK(autostart_toggled), priv->application);
g_signal_connect(priv->application, "notify::autostart",
G_CALLBACK(application_notify_autostart),
priv->autostart_check_button);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrolled_window),
GTK_WIDGET(manager));
gtk_widget_set_hexpand(scrolled_window, TRUE);
gtk_widget_set_vexpand(scrolled_window, TRUE);
gtk_grid_attach(GTK_GRID(priv->grid),
scrolled_window,
0, 4,
3, 1);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
int main(int argc, char **argv)
{
IsApplication *application;
GSettings *settings;
IsManager *manager;
gchar *plugin_dir;
PeasEngine *engine;
PeasExtensionSet *set;
GError *error = NULL;
gtk_init(&argc, &argv);
if (!g_irepository_require(g_irepository_get_default(), "Peas", "1.0",
0, &error))
{
is_warning("main", "Could not load Peas repository: %s", error->message);
g_error_free (error);
error = NULL;
}
engine = peas_engine_get_default();
g_signal_connect(engine, "notify::plugin-list",
G_CALLBACK(on_plugin_list_notify), NULL);
/* add home dir to search path */
plugin_dir = g_build_filename(g_get_user_config_dir(), PACKAGE,
"plugins", NULL);
peas_engine_add_search_path(engine, plugin_dir, NULL);
g_free(plugin_dir);
/* add system path to search path */
plugin_dir = g_build_filename(LIBDIR, PACKAGE, "plugins", NULL);
peas_engine_add_search_path(engine, plugin_dir, NULL);
g_free(plugin_dir);
/* init notifications */
is_notify_init();
application = is_application_new();
settings = g_settings_new("indicator-sensors.application");
g_settings_bind(settings, "temperature-scale",
application, "temperature-scale",
G_SETTINGS_BIND_DEFAULT);
/* create extension set and set manager as object */
set = peas_extension_set_new(engine, PEAS_TYPE_ACTIVATABLE,
"object", application, NULL);
/* activate all activatable extensions */
peas_extension_set_call(set, "activate");
/* and make sure to activate any ones which are found in the future */
g_signal_connect(set, "extension-added",
G_CALLBACK(on_extension_added), application);
g_signal_connect(set, "extension-removed",
G_CALLBACK(on_extension_removed), application);
/* since all plugins are now inited show a notification if we detected
* sensors but none are enabled - TODO: perhaps just open the pref's
* dialog?? */
manager = is_application_get_manager(application);
GSList *sensors = is_manager_get_all_sensors_list(manager);
if (sensors) {
gchar **enabled_sensors = is_manager_get_enabled_sensors(manager);
if (!g_strv_length(enabled_sensors)) {
is_notify(IS_NOTIFY_LEVEL_INFO,
_("No Sensors Enabled For Monitoring"),
_("Sensors detected but none are enabled for monitoring. To enable monitoring of sensors open the Preferences window and select the sensors to monitor"));
}
g_strfreev(enabled_sensors);
g_slist_foreach(sensors, (GFunc)g_object_unref, NULL);
g_slist_free(sensors);
}
gtk_main();
g_object_unref(application);
is_notify_uninit();
return 0;
}
static void
is_aticonfig_plugin_activate(PeasActivatable *activatable)
{
IsATIConfigPlugin *self = IS_ATICONFIG_PLUGIN(activatable);
IsManager *manager;
gchar *output = NULL;
GError *error = NULL;
GRegex *regex = NULL;
GMatchInfo *match = NULL;
gboolean ret;
manager = is_application_get_manager(self->priv->application);
/* search for sensors and add them to manager */
is_debug("aticonfig", "searching for sensors");
/* call aticonfig with --list-adapters to get available adapters,
* then test if each can do temperature and fan speed - if so add
* appropriate sensors */
ret = g_spawn_command_line_sync("aticonfig --list-adapters",
&output, NULL, NULL, &error);
if (!ret) {
is_warning("aticonfig", "Error calling aticonfig to detect available sensors: %s",
error->message);
g_error_free(error);
goto out;
}
regex = g_regex_new("^.*([0-9]+)\\. ([0-9][0-9]:[0-9][0-9]\\.[0-9])\\s*(.*?)\\s*$",
G_REGEX_MULTILINE, 0, &error);
if (!regex) {
is_warning("aticonfig", "Error compiling regex to detect listed sensors: %s",
error->message);
g_error_free(error);
goto out;
}
ret = g_regex_match(regex, output, 0, &match);
if (!ret) {
is_warning("aticonfig", "No sensors found in aticonfig output: %s", output);
goto out;
}
while (g_match_info_matches(match)) {
gint i;
gchar *idx, *pci, *name;
gdouble value;
gchar *path;
IsSensor *sensor;
idx = g_match_info_fetch(match, 1);
pci = g_match_info_fetch(match, 2);
name = g_match_info_fetch(match, 3);
i = g_ascii_strtoull(idx, NULL, 10);
/* we have an adapter - see if we can get its temperature and
fanspeed */
ret = aticonfig_get_temperature(self, i, &value, &error);
if (!ret) {
is_warning("aticonfig", "Error getting temperature for adapter %d: %s",
i, error->message);
g_clear_error(&error);
} else {
path = g_strdup_printf("%s%d%s", ATICONFIG_PATH_PREFIX, i, _("Temperature"));
sensor = is_temperature_sensor_new(path);
is_sensor_set_label(sensor, name);
is_sensor_set_icon(sensor, IS_STOCK_GPU);
g_signal_connect(sensor, "update-value",
G_CALLBACK(update_sensor_value),
self);
is_manager_add_sensor(manager, sensor);
g_object_unref(sensor);
g_free(path);
}
ret = aticonfig_get_fanspeed(self, i, &value, &error);
if (!ret) {
is_warning("aticonfig", "Error getting fanpeed for adapter %d: %s",
i, error->message);
g_clear_error(&error);
} else {
path = g_strdup_printf("%s%d%s", ATICONFIG_PATH_PREFIX, i, _("Fan"));
sensor = is_sensor_new(path);
is_sensor_set_label(sensor, name);
/* fan sensors are given as a percentage from 0 to 100 */
is_sensor_set_units(sensor, "%");
is_sensor_set_low_value(sensor, 0.0);
is_sensor_set_high_value(sensor, 100.0);
is_sensor_set_digits(sensor, 0);
is_sensor_set_icon(sensor, IS_STOCK_FAN);
g_signal_connect(sensor, "update-value",
G_CALLBACK(update_sensor_value),
self);
is_manager_add_sensor(manager, sensor);
g_object_unref(sensor);
g_free(path);
}
g_free(idx);
g_free(pci);
g_free(name);
g_match_info_next(match, &error);
}
out:
g_match_info_free(match);
if (regex) {
g_regex_unref(regex);
}
g_free(output);
return;
}
