static void preferences_sound_cell_toggled_cb (GtkCellRendererToggle *toggle, char *path_string, EmpathyPreferences *preferences) { EmpathyPreferencesPriv *priv = GET_PRIV (preferences); GtkTreePath *path; gboolean toggled, instore; GtkTreeIter iter; GtkTreeView *view; GtkTreeModel *model; char *key; view = GTK_TREE_VIEW (priv->treeview_sounds); model = gtk_tree_view_get_model (view); path = gtk_tree_path_new_from_string (path_string); toggled = gtk_cell_renderer_toggle_get_active (toggle); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get (model, &iter, COL_SOUND_KEY, &key, COL_SOUND_ENABLED, &instore, -1); instore ^= 1; gtk_list_store_set (GTK_LIST_STORE (model), &iter, COL_SOUND_ENABLED, instore, -1); g_settings_set_boolean (priv->gsettings_sound, key, instore); g_free (key); gtk_tree_path_free (path); }
static void handle_toggle(GtkCellRendererToggle *toggle, char *path_str, ParasiteWidgetTree *widget_tree, int column, void (*enable_func)(GtkWidget*), void (*disable_func)(GtkWidget*)) { GtkTreeIter iter; GtkWidget *widget; gboolean new_active = !gtk_cell_renderer_toggle_get_active(toggle); if (!widget_tree->priv->edit_mode_enabled) return; gtk_tree_model_get_iter(GTK_TREE_MODEL(widget_tree->priv->model), &iter, gtk_tree_path_new_from_string(path_str)); gtk_tree_model_get(GTK_TREE_MODEL(widget_tree->priv->model), &iter, WIDGET, &widget, -1); if (new_active) enable_func(widget); else disable_func(widget); gtk_tree_store_set(widget_tree->priv->model, &iter, column, new_active, -1); }
static void _gtk_user_list_dialog_tree_checkbox_toggled(GtkCellRendererToggle *renderer, gchar *path, GtkTreeView *widget) { GtkUserListDialogPrivate *priv; GtkTreeModel *model; GtkTreeIter iter; GtkTreeIter child; g_assert(GTK_IS_DELETABLE_DIALOG(widget)); priv = GTK_USER_LIST_DIALOG(widget)->priv; if(priv->checkbox_column_activatable) { model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->tree)); if(gtk_tree_model_get_iter_from_string(model, &iter, path)) { gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(model), &child, &iter); model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model)); gtk_list_store_set(GTK_LIST_STORE(model), &child, GTK_USER_LIST_TREEVIEW_COLUMN_CHECKBOX, gtk_cell_renderer_toggle_get_active(renderer) ? FALSE : TRUE, -1); } } }
JNIEXPORT jboolean JNICALL Java_org_gnome_gtk_GtkCellRendererToggle_gtk_1cell_1renderer_1toggle_1get_1active ( JNIEnv* env, jclass cls, jlong _self ) { gboolean result; jboolean _result; GtkCellRendererToggle* self; // convert parameter self self = (GtkCellRendererToggle*) _self; // call function result = gtk_cell_renderer_toggle_get_active(self); // cleanup parameter self // translate return value to JNI type _result = (jboolean) result; // and finally return _result; }
/** * he_check_button_get_active: * @button: A #HeCheckButton * * Gets the current state of @button. * * Return value: %TRUE if @button is active, %FALSE otherwise. * * Since: 2.2 **/ gboolean he_check_button_get_active (HeCheckButton *button) { g_return_val_if_fail (HE_IS_CHECK_BUTTON (button), FALSE); return gtk_cell_renderer_toggle_get_active (button->priv->toggle_renderer); }
static void field_toggled (const gchar *child_schema, GtkCellRendererToggle *cell, gchar *path_str, gpointer data) { GtkTreeModel *model = static_cast<GtkTreeModel*>(data); GtkTreePath *path = gtk_tree_path_new_from_string (path_str); GtkTreeIter iter; GtkTreeViewColumn *column; gboolean toggled; GSettings *settings = g_settings_get_child (ProcData::get_instance()->settings, child_schema); gchar *key; int id; if (!path) return; gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get (model, &iter, 2, &column, -1); toggled = gtk_cell_renderer_toggle_get_active (cell); gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !toggled, -1); gtk_tree_view_column_set_visible (column, !toggled); id = gtk_tree_view_column_get_sort_column_id (column); key = g_strdup_printf ("col-%d-visible", id); g_settings_set_boolean (settings, key, !toggled); g_free (key); gtk_tree_path_free (path); }
/* * enable / disable all breaks for a file when it's checkbox icon has been clicked */ void on_enable_for_file(GtkCellRendererToggle *cell_renderer, gchar *path, gpointer user_data) { /* do not process event is page is readonly (debug is running) */ if (readonly) return; GtkTreeIter iter; GtkTreePath *tree_path = gtk_tree_path_new_from_string (path); gtk_tree_model_get_iter ( model, &iter, tree_path); gboolean current_state = gtk_cell_renderer_toggle_get_active(cell_renderer); /* check if this is a file row */ if(1 == gtk_tree_path_get_depth(tree_path)) { gchar *file; gtk_tree_model_get ( model, &iter, FILEPATH, &file, -1); breaks_set_enabled_for_file(file, !current_state); g_free(file); } gtk_tree_path_free(tree_path); }
static void photos_organize_collection_view_check_toggled (PhotosOrganizeCollectionView *self, gchar *path) { GApplication *app; GList *urns; GtkTreeIter iter; GtkTreePath *tree_path; PhotosSearchContextState *state; PhotosSetCollectionJob *job; gboolean active; gchar *coll_urn; app = g_application_get_default (); state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app)); tree_path = gtk_tree_path_new_from_string (path); gtk_tree_model_get_iter (GTK_TREE_MODEL (self->model), &iter, tree_path); gtk_tree_model_get (GTK_TREE_MODEL (self->model), &iter, PHOTOS_ORGANIZE_MODEL_ID, &coll_urn, -1); active = gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (self->renderer_check)); job = photos_set_collection_job_new (coll_urn, !active); urns = photos_selection_controller_get_selection (self->sel_cntrlr); photos_set_collection_job_run (job, state, urns, self->cancellable, photos_organize_collection_view_set_collection_executed, self); g_object_unref (job); g_free (coll_urn); }
void toggle_cell_checkbox(GtkTreeView *treeview, GtkListStore *listStore, GtkCellRendererToggle *cell_renderer, gchar *path, int row_index) { GtkTreeModel *model; GtkTreeIter iter; gboolean active = (gtk_cell_renderer_toggle_get_active(cell_renderer) ? FALSE : TRUE); model = gtk_tree_view_get_model(treeview); gtk_tree_model_get_iter_from_string(model, &iter, path); gtk_list_store_set(listStore,&iter, row_index, active, -1); }
static void todo_check_changed (GtkCellRendererToggle *cell_renderer, gchar *path, MaintainrProjectbox *item) { GtkTreeModel *model; GtkTreeIter iter; model = gtk_tree_view_get_model (GTK_TREE_VIEW (item->priv->todos)); gtk_tree_model_get_iter_from_string (model, &iter, path); gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !gtk_cell_renderer_toggle_get_active (cell_renderer), -1); g_signal_emit (item, signals [CONF_CHANGE], 0, NULL); }
void gtkui_cheats_check(GtkWidget *widget, gchar *element, gpointer userdata) { // This function doesn't work. Fix later. GtkTreeIter iter; bool value; // Read the value of the checkbox value = gtk_cell_renderer_toggle_get_active((GtkCellRendererToggle*)widget); // Flip the value and set it value ^= 1; gtk_cell_renderer_toggle_set_active((GtkCellRendererToggle*)widget, value); }
static void enable_toggled (GtkCellRendererToggle *cell, gchar *tree_path, GtkListStore *store) { GtkTreePath *path = gtk_tree_path_new_from_string (tree_path); GtkTreeIter iter; if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path)) gtk_list_store_set (store, &iter, COLUMN_ENABLED, !gtk_cell_renderer_toggle_get_active (cell), -1); gtk_tree_path_free (path); }
static void category_checkbox_toggled (GtkCellRendererToggle *toggle, gchar *path, GtkListStore *store) { GtkTreeIter iter; gboolean active; if (!gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store), &iter, path)) return; /* Get current state of the category */ active = gtk_cell_renderer_toggle_get_active(toggle); gtk_list_store_set(store, &iter, COL_CHECKED, !active, -1); }
void cell_edited_cb(GtkCellRendererToggle *cell_renderer, gchar* path, gpointer user_data) { /* Get reference to model */ GtkTreePath* model_path = gtk_tree_path_new_from_string(path); GtkTreeIter iter; gtk_tree_model_get_iter(GTK_TREE_MODEL(format_model), &iter, model_path); gtk_tree_path_free(model_path); GValue value = G_VALUE_INIT; g_value_init(&value, G_TYPE_BOOLEAN); g_value_set_boolean(&value, !gtk_cell_renderer_toggle_get_active(cell_renderer)); gtk_list_store_set_value(format_model, &iter, 1, &value); }
static void on_writable_toggled( GtkCellRendererToggle *renderer, gchar *path_string, BaseWindow *window ) { static const gchar *thisfn = "cact_providers_list_on_writable_toggled"; GtkTreeView *treeview; ProvidersListData *data; GtkTreeModel *model; GtkTreeIter iter; gboolean state; gboolean writable_mandatory; gchar *id; if( !st_on_selection_change ){ treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW )); model = gtk_tree_view_get_model( treeview ); if( gtk_tree_model_get_iter_from_string( model, &iter, path_string )){ gtk_tree_model_get( model, &iter, PROVIDER_WRITABLE_COLUMN, &state, PROVIDER_ID_COLUMN, &id, PROVIDER_WRITABLE_MANDATORY_COLUMN, &writable_mandatory, -1 ); g_debug( "%s: id=%s, writable=%s (mandatory=%s)", thisfn, id, state ? "True":"False", writable_mandatory ? "True":"False" ); data = get_providers_list_data( treeview ); if( writable_mandatory || data->preferences_locked ){ g_signal_handlers_block_by_func(( gpointer ) renderer, on_writable_toggled, window ); state = gtk_cell_renderer_toggle_get_active( renderer ); gtk_cell_renderer_toggle_set_active( renderer, !state ); g_signal_handlers_unblock_by_func(( gpointer ) renderer, on_writable_toggled, window ); } else { gtk_list_store_set( GTK_LIST_STORE( model ), &iter, PROVIDER_WRITABLE_COLUMN, !state, -1 ); } g_free( id ); } } }
/* callbacks */ void on_service_toggled (GtkCellRenderer *renderer, gchar *path_str, gpointer data) { GtkTreeView *treeview = GTK_TREE_VIEW (gst_dialog_get_widget (tool->main_dialog, "services_list")); GtkTreeModel *model = gtk_tree_view_get_model (treeview); GtkTreePath *path; GstTool *tool = GST_TOOL (data); GtkTreeIter iter; OobsService *service; gboolean value, new_value, dangerous; path = gtk_tree_path_new_from_string (path_str); value = gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (renderer)); new_value = !value; if (!gtk_tree_model_get_iter (model, &iter, path)) return; gtk_tree_model_get (model, &iter, COL_OBJECT, &service, COL_DANGEROUS, &dangerous, -1); if (new_value || !dangerous || show_warning_dialog (tool, service)) { OobsServicesRunlevel *rl; rl = GST_SERVICES_TOOL (tool)->default_runlevel; oobs_service_set_runlevel_configuration (service, rl, (new_value) ? OOBS_SERVICE_START : OOBS_SERVICE_IGNORE, /* FIXME: hardcoded value... */ 50); oobs_object_commit (GST_SERVICES_TOOL (tool)->services_config); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COL_ACTIVE, new_value, -1); } gtk_tree_path_free (path); }
static void cipher_enable_toggled(GtkCellRendererToggle *renderer, gchar *path, AccountSecurityTab *self) { g_return_if_fail(IS_ACCOUNT_SECURITY_TAB(self)); AccountSecurityTabPrivate *priv = ACCOUNT_SECURITY_TAB_GET_PRIVATE(self); /* we want to set it to the opposite of the current value */ gboolean toggle = !gtk_cell_renderer_toggle_get_active(renderer); /* get iter which was clicked */ GtkTreePath *tree_path = gtk_tree_path_new_from_string(path); GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(priv->treeview_cipher_list)); GtkTreeIter iter; gtk_tree_model_get_iter(model, &iter, tree_path); /* get qmodelindex from iter and set the model data */ QModelIndex idx = gtk_q_tree_model_get_source_idx(GTK_Q_TREE_MODEL(model), &iter); if (idx.isValid()) priv->account->cipherModel()->setData(idx, toggle ? Qt::Checked : Qt::Unchecked, Qt::CheckStateRole); }
static void prop_toggled(GtkCellRendererToggle *cel, gchar *path, GtkListStore *props) { struct sr_dev *dev = g_object_get_data(G_OBJECT(props), "dev"); GtkTreeIter iter; int type, cap; int ret; gboolean val; gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(props), &iter, path); gtk_tree_model_get(GTK_TREE_MODEL(props), &iter, DEV_PROP_HWCAP, &cap, DEV_PROP_TYPE, &type, -1); val = !gtk_cell_renderer_toggle_get_active(cel); ret = dev->driver->dev_config_set(dev->driver_index, cap, GINT_TO_POINTER(val)); if (!ret) gtk_list_store_set(props, &iter, DEV_PROP_BOOLVALUE, val, -1); }
static void import_dialog_cell_toggled_cb (GtkCellRendererToggle *cell_renderer, const gchar *path_str, EmpathyImportDialog *dialog) { GtkTreeModel *model; GtkTreeIter iter; GtkTreePath *path; path = gtk_tree_path_new_from_string (path_str); model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->treeview)); gtk_tree_model_get_iter (model, &iter, path); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COL_IMPORT, !gtk_cell_renderer_toggle_get_active (cell_renderer), -1); gtk_tree_path_free (path); }
/************************************************************ * Callbacks * ************************************************************/ static void gnc_tree_view_owner_active_toggled (GtkCellRendererToggle *cell, const gchar *s_path_str, gpointer user_data) { GncTreeViewOwner *tree_view; GtkTreePath *s_path; GncOwner *owner; gboolean active; /* Change the requested owner */ tree_view = user_data; s_path = gtk_tree_path_new_from_string (s_path_str); owner = gnc_tree_view_owner_get_owner_from_path (tree_view, s_path); if (owner) { active = !gtk_cell_renderer_toggle_get_active (cell); // hasn't changed yet. gncOwnerSetActive (owner, active); } /* Clean up */ gtk_tree_path_free (s_path); }
static void field_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data) { GtkTreeModel *model = static_cast<GtkTreeModel*>(data); GtkTreePath *path = gtk_tree_path_new_from_string (path_str); GtkTreeIter iter; GtkTreeViewColumn *column; gboolean toggled; if (!path) return; gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get (model, &iter, 2, &column, -1); toggled = gtk_cell_renderer_toggle_get_active (cell); gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, !toggled, -1); gtk_tree_view_column_set_visible (column, !toggled); gtk_tree_path_free (path); }
static void show_case_toggled (GtkCellRendererToggle *cell, gchar *str, struct _app_data *app) { GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter; test_case_t *c; gboolean active; active = ! gtk_cell_renderer_toggle_get_active (cell); model = GTK_TREE_MODEL (app->case_store); path = gtk_tree_path_new_from_string (str); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); gtk_tree_store_set (app->case_store, &iter, CASE_SHOWN, active, CASE_INCONSISTENT, FALSE, -1); gtk_tree_model_get (model, &iter, CASE_DATA, &c, -1); if (c != NULL) { if (active == c->shown) return; c->shown = active; } else { recurse_set_shown (model, &iter, active); } check_consistent (model, &iter); graph_view_update_visible ((GraphView *) app->gv); }
static void gimp_cell_renderer_toggle_render (GtkCellRenderer *cell, cairo_t *cr, GtkWidget *widget, const GdkRectangle *background_area, const GdkRectangle *cell_area, GtkCellRendererState flags) { GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell); GdkRectangle toggle_rect; GdkRectangle draw_rect; GtkStyleContext *context = gtk_widget_get_style_context (widget); GdkRectangle clip_rect; GtkStateFlags state; gboolean active; gint xpad; gint ypad; if (! toggle->stock_id) { GTK_CELL_RENDERER_CLASS (parent_class)->render (cell, cr, widget, background_area, cell_area, flags); return; } gtk_cell_renderer_get_size (cell, widget, cell_area, &toggle_rect.x, &toggle_rect.y, &toggle_rect.width, &toggle_rect.height); gtk_cell_renderer_get_padding (cell, &xpad, &ypad); toggle_rect.x += cell_area->x + xpad; toggle_rect.y += cell_area->y + ypad; toggle_rect.width -= xpad * 2; toggle_rect.height -= ypad * 2; if (toggle_rect.width <= 0 || toggle_rect.height <= 0) return; active = gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell)); if (!gtk_cell_renderer_get_sensitive (cell)) { state = GTK_STATE_FLAG_INSENSITIVE; } else if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED) { if (gtk_widget_has_focus (widget)) state = GTK_STATE_FLAG_SELECTED; else state = GTK_STATE_FLAG_ACTIVE; } else { if (gtk_cell_renderer_toggle_get_activatable (GTK_CELL_RENDERER_TOGGLE (cell))) state = GTK_STATE_FLAG_NORMAL; else state = GTK_STATE_FLAG_INSENSITIVE; } if ((flags & GTK_CELL_RENDERER_PRELIT) && gdk_cairo_get_clip_rectangle(cr, &clip_rect) && gdk_rectangle_intersect (&clip_rect, cell_area, &draw_rect)) { cairo_save (cr); gdk_cairo_rectangle (cr, &draw_rect); cairo_clip (cr); gtk_render_frame (context, //gtk_widget_get_style_context (widget), cr, toggle_rect.x, toggle_rect.y, toggle_rect.width, toggle_rect.height); gtk_style_context_restore (context); cairo_restore (cr); } if (active) { GdkPixbuf *insensitive = NULL; GdkPixbuf *pixbuf = toggle->pixbuf; GtkBorder border = { 1, 1, 1, 1 }; #if 0 /* FIXME: for some reason calling gtk_style_context_get_border * makes the icon only visible on hover, so use border = 1 * for now as a workaround */ gtk_style_context_get_border (context, state, &border); #endif toggle_rect.x += border.left; toggle_rect.y += border.top; toggle_rect.width -= (border.left + border.right); toggle_rect.height -= (border.top + border.bottom); if (state & GTK_STATE_FLAG_INSENSITIVE) { GtkIconSource *source; source = gtk_icon_source_new (); gtk_icon_source_set_pixbuf (source, pixbuf); /* The size here is arbitrary; since size isn't * wildcarded in the source, it isn't supposed to be * scaled by the engine function */ gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_icon_source_set_size_wildcarded (source, FALSE); gtk_style_context_save (context); gtk_style_context_set_state (context, GTK_STATE_FLAG_INSENSITIVE); insensitive = gtk_render_icon_pixbuf (context, source, (GtkIconSize)-1); gtk_style_context_restore (context); gtk_icon_source_free (source); pixbuf = insensitive; } if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect)) { gdk_cairo_set_source_pixbuf (cr, pixbuf, toggle_rect.x, toggle_rect.y); gdk_cairo_rectangle (cr, &draw_rect); cairo_fill (cr); } if (insensitive) g_object_unref (insensitive); } }
static void gimp_cell_renderer_toggle_render (GtkCellRenderer *cell, GdkWindow *window, GtkWidget *widget, GdkRectangle *background_area, GdkRectangle *cell_area, GdkRectangle *expose_area, GtkCellRendererState flags) { GimpCellRendererToggle *toggle = GIMP_CELL_RENDERER_TOGGLE (cell); GtkStyle *style = gtk_widget_get_style (widget); GdkRectangle toggle_rect; GdkRectangle draw_rect; GtkStateType state; gboolean active; gint xpad; gint ypad; if (! toggle->stock_id) { GTK_CELL_RENDERER_CLASS (parent_class)->render (cell, window, widget, background_area, cell_area, expose_area, flags); return; } gimp_cell_renderer_toggle_get_size (cell, widget, cell_area, &toggle_rect.x, &toggle_rect.y, &toggle_rect.width, &toggle_rect.height); gtk_cell_renderer_get_padding (cell, &xpad, &ypad); toggle_rect.x += cell_area->x + xpad; toggle_rect.y += cell_area->y + ypad; toggle_rect.width -= xpad * 2; toggle_rect.height -= ypad * 2; if (toggle_rect.width <= 0 || toggle_rect.height <= 0) return; active = gtk_cell_renderer_toggle_get_active (GTK_CELL_RENDERER_TOGGLE (cell)); if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED) { if (gtk_widget_has_focus (widget)) state = GTK_STATE_SELECTED; else state = GTK_STATE_ACTIVE; } else { if (gtk_cell_renderer_toggle_get_activatable (GTK_CELL_RENDERER_TOGGLE (cell))) state = GTK_STATE_NORMAL; else state = GTK_STATE_INSENSITIVE; } if (gdk_rectangle_intersect (expose_area, cell_area, &draw_rect) && (flags & GTK_CELL_RENDERER_PRELIT)) gtk_paint_shadow (style, window, state, active ? GTK_SHADOW_IN : GTK_SHADOW_OUT, &draw_rect, widget, NULL, toggle_rect.x, toggle_rect.y, toggle_rect.width, toggle_rect.height); if (active) { toggle_rect.x += style->xthickness; toggle_rect.y += style->ythickness; toggle_rect.width -= style->xthickness * 2; toggle_rect.height -= style->ythickness * 2; if (gdk_rectangle_intersect (&draw_rect, &toggle_rect, &draw_rect)) { cairo_t *cr = gdk_cairo_create (window); gboolean inconsistent; gdk_cairo_rectangle (cr, &draw_rect); cairo_clip (cr); gdk_cairo_set_source_pixbuf (cr, toggle->pixbuf, toggle_rect.x, toggle_rect.y); cairo_paint (cr); g_object_get (toggle, "inconsistent", &inconsistent, NULL); if (inconsistent) { gdk_cairo_set_source_color (cr, &style->fg[state]); cairo_set_line_width (cr, 1.5); cairo_move_to (cr, toggle_rect.x + toggle_rect.width - 1, toggle_rect.y + 1); cairo_line_to (cr, toggle_rect.x + 1, toggle_rect.y + toggle_rect.height - 1); cairo_stroke (cr); } cairo_destroy (cr); } } }