static void
play_back_delete_inpfile (GtkTreeRowReference *reference)
{
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
gboolean valid;
gchar *inpfile;
model = gtk_tree_row_reference_get_model (reference);
path = gtk_tree_row_reference_get_path (reference);
valid = gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
g_assert (valid);
gtk_tree_model_get (
model, &iter, GVA_GAME_STORE_COLUMN_INPFILE, &inpfile, -1);
g_assert (inpfile != NULL);
errno = 0;
if (g_unlink (inpfile) == 0)
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
else
g_warning ("%s: %s", inpfile, g_strerror (errno));
g_free (inpfile);
}
static void
configure_combo_box_set_active (GtkComboBox *combo_box, const gchar *value)
{
GtkTreeRowReference *reference;
GHashTable *index;
index = g_object_get_data (G_OBJECT (combo_box), "index");
g_return_if_fail (index != NULL);
reference = g_hash_table_lookup (index, value);
if (reference != NULL) {
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
model = gtk_tree_row_reference_get_model (reference);
path = gtk_tree_row_reference_get_path (reference);
if (path == NULL)
return;
if (gtk_tree_model_get_iter (model, &iter, path))
gtk_combo_box_set_active_iter (combo_box, &iter);
gtk_tree_path_free (path);
}
}
static void
attachment_button_update_cell_view (EAttachmentButton *button)
{
GtkCellView *cell_view;
EAttachment *attachment;
GtkTreeRowReference *reference;
GtkTreeModel *model = NULL;
GtkTreePath *path = NULL;
cell_view = GTK_CELL_VIEW (button->priv->cell_view);
attachment = e_attachment_button_get_attachment (button);
if (attachment == NULL)
goto exit;
reference = e_attachment_get_reference (attachment);
if (reference == NULL)
goto exit;
model = gtk_tree_row_reference_get_model (reference);
path = gtk_tree_row_reference_get_path (reference);
exit:
gtk_cell_view_set_model (cell_view, model);
if (model)
gtk_cell_view_set_displayed_row (cell_view, path);
if (path != NULL)
gtk_tree_path_free (path);
}
static void on_item_changed (MateBG *bg, AppearanceData *data) {
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
MateWPItem *item;
item = g_hash_table_find (data->wp_hash, predicate, bg);
if (!item)
return;
model = gtk_tree_row_reference_get_model (item->rowref);
path = gtk_tree_row_reference_get_path (item->rowref);
if (gtk_tree_model_get_iter (model, &iter, path)) {
GdkPixbuf *pixbuf;
g_signal_handlers_block_by_func (bg, G_CALLBACK (on_item_changed), data);
pixbuf = mate_wp_item_get_thumbnail (item,
data->thumb_factory,
data->thumb_width,
data->thumb_height);
if (pixbuf) {
gtk_list_store_set (GTK_LIST_STORE (data->wp_model), &iter, 0, pixbuf, -1);
g_object_unref (pixbuf);
}
g_signal_handlers_unblock_by_func (bg, G_CALLBACK (on_item_changed), data);
}
}
/* to be called when the icon within the GtkRowReference that this
* sensor references is changed - updates icon based upon value in the
* ActiveSensor */
void active_sensor_icon_changed(ActiveSensor *active_sensor,
SensorsApplet *sensors_applet) {
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
SensorType sensor_type;
GdkPixbuf *icon_pixbuf;
g_assert(active_sensor);
g_assert(sensors_applet);
model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);
path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);
/* if can successfully get iter can proceed */
if (gtk_tree_model_get_iter(model, &iter, path)) {
gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),
&iter,
SENSOR_TYPE_COLUMN, &sensor_type,
ICON_PIXBUF_COLUMN, &icon_pixbuf,
-1);
active_sensor_update_icon(active_sensor,
icon_pixbuf,
sensor_type);
g_object_unref(icon_pixbuf);
}
gtk_tree_path_free(path);
}
static VALUE
treerowref_get_model(VALUE self)
{
VALUE ret = GOBJ2RVAL(gtk_tree_row_reference_get_model(_SELF(self)));
G_CHILD_SET(self, id_model, ret);
return ret;
}
static void active_sensor_alarm_on(ActiveSensor *active_sensor,
NotifType notif_type) {
GtkTreeModel *model;
GtkTreePath *tree_path;
GtkTreeIter iter;
g_assert(active_sensor);
model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);
tree_path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);
if (gtk_tree_model_get_iter(model, &iter, tree_path)) {
if (active_sensor->alarm_timeout_id[notif_type] == -1) {
/* alarm is not currently on */
gtk_tree_model_get(model,
&iter,
(notif_type == LOW_ALARM ?
LOW_ALARM_COMMAND_COLUMN :
HIGH_ALARM_COMMAND_COLUMN),
&(active_sensor->alarm_command[notif_type]),
ALARM_TIMEOUT_COLUMN, &(active_sensor->alarm_timeout),
-1);
g_debug("Activating alarm to repeat every %d seconds", active_sensor->alarm_timeout);
/* execute alarm once, then add to time to
keep repeating it */
active_sensor_execute_alarm(active_sensor, notif_type);
int timeout = (active_sensor->alarm_timeout <= 0 ?
G_MAXINT :
active_sensor->alarm_timeout);
switch (notif_type) {
case LOW_ALARM:
active_sensor->alarm_timeout_id[notif_type] = g_timeout_add_seconds(timeout,
(GSourceFunc)active_sensor_execute_low_alarm,
active_sensor);
break;
case HIGH_ALARM:
active_sensor->alarm_timeout_id[notif_type] = g_timeout_add_seconds(timeout,
(GSourceFunc)active_sensor_execute_high_alarm,
active_sensor);
break;
default:
g_debug("Unknown notif type: %d", notif_type);
}
}
}
gtk_tree_path_free(tree_path);
}
static void
remote_editor_remove_branch (GtkTreeRowReference *ref)
{
GtkTreeModel *model;
GtkTreeIter iter;
model = gtk_tree_row_reference_get_model (ref);
gtk_tree_model_get_iter (model, &iter,
gtk_tree_row_reference_get_path (ref));
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
gtk_tree_row_reference_free (ref);
}
static void
source_viewer_update_row (ESourceViewer *viewer,
ESource *source)
{
GHashTable *source_index;
GtkTreeRowReference *reference;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
const gchar *display_name;
const gchar *source_uid;
gboolean removable;
gboolean writable;
gboolean remote_creatable;
gboolean remote_deletable;
source_index = viewer->source_index;
reference = g_hash_table_lookup (source_index, source);
/* We show all sources, so the reference should be valid. */
g_return_if_fail (gtk_tree_row_reference_valid (reference));
model = gtk_tree_row_reference_get_model (reference);
path = gtk_tree_row_reference_get_path (reference);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
source_uid = e_source_get_uid (source);
display_name = e_source_get_display_name (source);
removable = e_source_get_removable (source);
writable = e_source_get_writable (source);
remote_creatable = e_source_get_remote_creatable (source);
remote_deletable = e_source_get_remote_deletable (source);
gtk_tree_store_set (
GTK_TREE_STORE (model), &iter,
COLUMN_DISPLAY_NAME, display_name,
COLUMN_SOURCE_UID, source_uid,
COLUMN_REMOVABLE, removable,
COLUMN_WRITABLE, writable,
COLUMN_REMOTE_CREATABLE, remote_creatable,
COLUMN_REMOTE_DELETABLE, remote_deletable,
COLUMN_SOURCE, source,
-1);
}
/** Update the model when a toggle button is toggled.
*
* @param toggle_button the button which have been toggled
* @param row_reference associated row in the model
*/
static void update_model_from_toggle_button(
GtkToggleButton * toggle_button, GtkTreeRowReference * row_reference)
{
GtkTreeModel * model = gtk_tree_row_reference_get_model(row_reference);
GtkTreePath * path = gtk_tree_row_reference_get_path(row_reference);
GtkTreeIter iter;
g_assert(NULL != model);
g_assert(NULL != path);
if (gtk_tree_model_get_iter(model, &iter, path)) {
gtk_list_store_set(
GTK_LIST_STORE(model), &iter,
/* column: */ CHOICE_MODEL_SELECTED,
gtk_toggle_button_get_active(toggle_button),
-1 /* end of list */);
}
}
void
gnac_profiles_mgr_on_remove(GtkWidget *widget,
gpointer data)
{
GList *selected = gnac_profiles_mgr_get_selected_rows();
if (!selected) return;
GtkTreeRowReference *reference = (GtkTreeRowReference *) selected->data;
AudioProfileGeneric *profile;
gnac_profiles_mgr_get(reference, COL_PROFILE, &profile);
gnac_profiles_mgr_delete_profile_file(profile->generic->name);
gnac_profiles_mgr_display_status_message(NULL, NULL);
GtkTreeModel *model = gtk_tree_row_reference_get_model(reference);
GtkTreePath *path = gtk_tree_row_reference_get_path(reference);
GtkTreeIter iter;
gboolean new_selected = FALSE;
if (gtk_tree_model_get_iter(model, &iter, path)) {
if (gtk_tree_model_iter_next(model, &iter)
|| (gtk_tree_path_prev(path) &&
gtk_tree_model_get_iter(model, &iter, path)))
{
GtkTreeView *view = GTK_TREE_VIEW(
gnac_profiles_mgr_get_widget("profile_treeview"));
GtkTreeSelection *selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_select_iter(selection, &iter);
new_selected = TRUE;
}
}
gnac_profiles_mgr_remove(reference);
gnac_profiles_mgr_activate_buttons(new_selected);
gnac_profiles_mgr_show_description_frame(new_selected);
gtk_tree_path_free(path);
g_list_free_full(selected, (GDestroyNotify) gtk_tree_row_reference_free);
}
static void
favicon_ready_cb( gpointer pixbuf, gpointer vreference )
{
GtkTreeIter iter;
GtkTreeRowReference * reference = vreference;
if( pixbuf != NULL )
{
GtkTreePath * path = gtk_tree_row_reference_get_path( reference );
GtkTreeModel * model = gtk_tree_row_reference_get_model( reference );
if( gtk_tree_model_get_iter( model, &iter, path ) )
gtk_tree_store_set( GTK_TREE_STORE( model ), &iter,
CAT_FILTER_COL_PIXBUF, pixbuf,
-1 );
gtk_tree_path_free( path );
g_object_unref( pixbuf );
}
gtk_tree_row_reference_free( reference );
}
static void trg_torrent_model_ref_free(gpointer data)
{
GtkTreeRowReference *rr = (GtkTreeRowReference *) data;
GtkTreeModel *model = gtk_tree_row_reference_get_model(rr);
GtkTreePath *path = gtk_tree_row_reference_get_path(rr);
if (path) {
GtkTreeIter iter;
JsonObject *json;
if (gtk_tree_model_get_iter(model, &iter, path)) {
gtk_tree_model_get(model, &iter, TORRENT_COLUMN_JSON, &json,
-1);
json_object_unref(json);
g_object_set_data(G_OBJECT(model), PROP_REMOVE_IN_PROGRESS,
GINT_TO_POINTER(TRUE));
gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
g_object_set_data(G_OBJECT(model), PROP_REMOVE_IN_PROGRESS,
GINT_TO_POINTER(FALSE));
}
gtk_tree_path_free(path);
}
gtk_tree_row_reference_free(rr);
}
static void
action_combo_box_action_changed_cb (GtkRadioAction *action,
GtkRadioAction *current,
EActionComboBox *combo_box)
{
GtkTreeRowReference *reference;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
gboolean valid;
reference = g_hash_table_lookup (
combo_box->priv->index, GINT_TO_POINTER (
gtk_radio_action_get_current_value (current)));
g_return_if_fail (reference != NULL);
model = gtk_tree_row_reference_get_model (reference);
path = gtk_tree_row_reference_get_path (reference);
valid = gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
g_return_if_fail (valid);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo_box), &iter);
}
void active_sensor_update(ActiveSensor *active_sensor,
SensorsApplet *sensors_applet) {
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
/* instance data from the tree for this sensor */
gchar *sensor_path = NULL;
gchar *sensor_id = NULL;
gchar *sensor_label = NULL;
SensorType sensor_type;
gchar *sensor_interface;
gboolean sensor_enabled;
gdouble sensor_low_value;
gdouble sensor_high_value;
gboolean sensor_alarm_enabled;
gdouble sensor_multiplier;
gdouble sensor_offset;
gdouble sensor_value;
GdkPixbuf *icon_pixbuf;
gchar *graph_color;
/* to build the list of labels as we go */
gchar *value_text = NULL;
gchar *old_value_text;
TemperatureScale scale;
DisplayMode display_mode;
GError *error = NULL;
gchar *tooltip = NULL;
gchar *value_tooltip = NULL;
/* hidden gsettings options */
gint font_size = 0;
gboolean hide_units = FALSE;
g_assert(active_sensor);
g_assert(active_sensor->sensor_row);
g_assert(sensors_applet);
model = gtk_tree_row_reference_get_model(active_sensor->sensor_row);
path = gtk_tree_row_reference_get_path(active_sensor->sensor_row);
/* if can successfully get iter can proceed */
if (gtk_tree_model_get_iter(model, &iter, path)) {
gtk_tree_path_free(path);
gtk_tree_model_get(GTK_TREE_MODEL(sensors_applet->sensors),
&iter,
PATH_COLUMN, &sensor_path,
ID_COLUMN, &sensor_id,
LABEL_COLUMN, &sensor_label,
INTERFACE_COLUMN, &sensor_interface,
SENSOR_TYPE_COLUMN, &sensor_type,
ENABLE_COLUMN, &sensor_enabled,
LOW_VALUE_COLUMN, &sensor_low_value,
HIGH_VALUE_COLUMN, &sensor_high_value,
ALARM_ENABLE_COLUMN, &sensor_alarm_enabled,
MULTIPLIER_COLUMN, &sensor_multiplier,
OFFSET_COLUMN, &sensor_offset,
ICON_PIXBUF_COLUMN, &icon_pixbuf,
GRAPH_COLOR_COLUMN, &graph_color,
-1);
SensorsAppletPluginGetSensorValue get_sensor_value;
/* only call function if is in hash table for plugin */
if ((get_sensor_value = sensors_applet_plugins_get_sensor_value_func(sensors_applet, sensor_interface)) != NULL) {
sensor_value = get_sensor_value(sensor_path,
sensor_id,
sensor_type,
&error);
if (error) {
g_debug("Error updating active sensor: %s", error->message);
sensors_applet_notify_active_sensor(active_sensor,
SENSOR_INTERFACE_ERROR);
/* hard code text as ERROR */
value_text = g_strdup(_("ERROR"));
value_tooltip = g_strdup_printf("- %s", error->message);
g_error_free(error);
error = NULL;
/* set sensor value to an error code -
* note this is not unique */
sensor_value = -1;
} else {
/* use hidden gsettings key for hide_units */
hide_units = g_settings_get_boolean(sensors_applet->settings, HIDE_UNITS);
/* scale value and set text using this
* value */
switch (sensor_type) {
case TEMP_SENSOR:
scale = (TemperatureScale) g_settings_get_int(sensors_applet->settings, TEMPERATURE_SCALE);
/* scale value */
sensor_value = sensors_applet_convert_temperature(sensor_value,
CELSIUS,
scale);
sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
switch (scale) {
case FAHRENHEIT:
value_text = g_strdup_printf("%2.0f %s", sensor_value, (hide_units ? "" : UNITS_FAHRENHEIT));
/* tooltip should
* always display
* units */
value_tooltip = g_strdup_printf("%2.0f %s", sensor_value, UNITS_FAHRENHEIT);
break;
case CELSIUS:
value_text = g_strdup_printf("%2.0f %s", sensor_value, (hide_units ? "" : UNITS_CELSIUS));
value_tooltip = g_strdup_printf("%2.0f %s", sensor_value, UNITS_CELSIUS);
break;
case KELVIN:
value_text = g_strdup_printf("%2.0f", sensor_value);
value_tooltip = g_strdup(value_text);
break;
}
break;
case FAN_SENSOR:
sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
value_text = g_strdup_printf("%4.0f %s", sensor_value, (hide_units ? "" : UNITS_RPM));
value_tooltip = g_strdup_printf("%4.0f %s", sensor_value, UNITS_RPM);
break;
case VOLTAGE_SENSOR:
sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
value_text = g_strdup_printf("%4.2f %s", sensor_value, (hide_units ? "" : UNITS_VOLTAGE));
value_tooltip = g_strdup_printf("%4.2f %s", sensor_value, UNITS_VOLTAGE);
break;
case CURRENT_SENSOR:
sensor_value = (sensor_value * sensor_multiplier) + sensor_offset;
value_text = g_strdup_printf("%4.2f %s", sensor_value, (hide_units ? "" : UNITS_CURRENT));
value_tooltip = g_strdup_printf("%4.2f %s", sensor_value, UNITS_CURRENT);
break;
} /* end switch(sensor_type) */
} /* end else on error */
/* setup for tooltips */
tooltip = g_strdup_printf("%s %s", sensor_label, value_tooltip);
g_free(value_tooltip);
/* only do icons and labels / graphs if needed */
display_mode = g_settings_get_int (sensors_applet->settings, DISPLAY_MODE);
/* most users wont have a font size set */
font_size = g_settings_get_int (sensors_applet->settings, FONT_SIZE);
/* do icon if needed */
if (display_mode == DISPLAY_ICON ||
display_mode == DISPLAY_ICON_WITH_VALUE) {
/* update icon if icon range has changed if no
* update has been done before */
if ((sensor_value_range(sensor_value, sensor_low_value, sensor_high_value) != sensor_value_range(active_sensor->sensor_values[0], active_sensor->sensor_low_value, active_sensor->sensor_high_value)) || !(active_sensor->updated)) {
active_sensor_update_sensor_value(active_sensor,
sensor_value);
active_sensor->sensor_low_value = sensor_low_value;
active_sensor->sensor_high_value = sensor_high_value;
active_sensor_update_icon(active_sensor, icon_pixbuf, sensor_type);
}
/* always update tooltip */
gtk_widget_set_tooltip_text(active_sensor->icon,
tooltip);
}
active_sensor_update_sensor_value(active_sensor,
sensor_value);
active_sensor->sensor_low_value = sensor_low_value;
active_sensor->sensor_high_value = sensor_high_value;
/* do graph if needed */
if (display_mode == DISPLAY_GRAPH) {
/* update graph color in case has changed */
gdk_color_parse(graph_color,
&(active_sensor->graph_color));
gtk_widget_queue_draw (active_sensor->graph);
gtk_widget_set_tooltip_text(active_sensor->graph,
tooltip);
}
old_value_text = value_text;
if (sensor_alarm_enabled) {
if (sensor_value >= sensor_high_value ||
sensor_value <= sensor_low_value) {
/* make value text red and
* activate alarm */
if (display_mode == DISPLAY_LABEL_WITH_VALUE ||
display_mode == DISPLAY_ICON_WITH_VALUE ||
display_mode == DISPLAY_VALUE) {
value_text = g_markup_printf_escaped("<span foreground=\"#FF0000\">%s</span>", old_value_text);
g_free(old_value_text);
}
/* could have both coditions at once */
if (sensor_value >= sensor_high_value) {
active_sensor_alarm_on(active_sensor, HIGH_ALARM);
}
if (sensor_value <= sensor_low_value) {
active_sensor_alarm_on(active_sensor, LOW_ALARM);
}
} else {
/* make sure alarms are off */
active_sensor_all_alarms_off(active_sensor);
}
} else { /* else for if alarm enabled */
/* make sure all alarms are off */
active_sensor_all_alarms_off(active_sensor);
}
/* do value label */
if (display_mode == DISPLAY_LABEL_WITH_VALUE ||
display_mode == DISPLAY_ICON_WITH_VALUE ||
display_mode == DISPLAY_VALUE) {
if (font_size) {
old_value_text = value_text;
value_text = g_strdup_printf("<span font_desc=\"%d\">%s</span>", font_size, old_value_text);
g_free(old_value_text);
}
gtk_label_set_markup(GTK_LABEL(active_sensor->value),
value_text);
gtk_widget_set_tooltip_text(active_sensor->value,
tooltip);
}
/* finished with value text */
g_free(value_text);
/* do label label */
if (display_mode == DISPLAY_LABEL_WITH_VALUE) {
if (font_size) {
old_value_text = sensor_label;
sensor_label = g_strdup_printf("<span font_desc=\"%d\">%s</span>", font_size, old_value_text);
g_free(old_value_text);
}
gtk_label_set_markup(GTK_LABEL(active_sensor->label),
sensor_label);
gtk_widget_set_tooltip_text(active_sensor->label,
tooltip);
}
g_free(tooltip);
} else {
g_debug("no get_sensor_value function yet installed for interface %s.", sensor_interface);
}
g_free(sensor_path);
g_free(sensor_id);
g_free(sensor_label);
g_free(sensor_interface);
g_free(graph_color);
g_object_unref(icon_pixbuf);
} else {
g_debug("Error getting iter when updating sensor...");
}
active_sensor->updated = TRUE;
}
