static void enum_pref_create_widget (GOConfNode *node, GtkWidget *grid, gint row, GType enum_type, enum_conf_setter_t setter, enum_conf_getter_t getter, gchar const *default_label, char const *(*label_getter)(int)) { unsigned int i; GtkTreeIter iter; GtkCellRenderer *renderer; GEnumClass *enum_class = G_ENUM_CLASS (g_type_class_ref (enum_type)); GtkWidget *combo = gtk_combo_box_new (); GtkListStore *model = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); gint current = getter (); gint current_index = -1; for (i = 0; i < enum_class->n_values ; i++) { gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, label_getter ((int) enum_class->values[i].value), 1, enum_class->values + i, -1); if (enum_class->values[i].value == current) current_index = i; } g_type_class_unref (enum_class); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (model)); g_object_unref (model); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", 0, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combo), current_index); gtk_grid_attach (GTK_GRID (grid), combo, 1, row, 1, 1); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (cb_enum_changed), (gpointer) setter); connect_notification (node, (GOConfMonitorFunc)enum_pref_conf_to_widget, combo, grid); pref_create_label (node, grid, row, default_label, combo); set_tip (node, combo); }
static void account_chooser_setup (EmpathyAccountChooser *chooser) { EmpathyAccountChooserPriv *priv; GList *accounts; GtkListStore *store; GtkCellRenderer *renderer; GtkComboBox *combobox; priv = GET_PRIV (chooser); /* Set up combo box with new store */ combobox = GTK_COMBO_BOX (chooser); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox)); store = gtk_list_store_new (COL_ACCOUNT_COUNT, G_TYPE_STRING, /* Image */ G_TYPE_STRING, /* Name */ G_TYPE_BOOLEAN, /* Enabled */ EMPATHY_TYPE_ACCOUNT); gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (store)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "icon-name", COL_ACCOUNT_IMAGE, "sensitive", COL_ACCOUNT_ENABLED, NULL); g_object_set (renderer, "stock-size", GTK_ICON_SIZE_BUTTON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer, "text", COL_ACCOUNT_TEXT, "sensitive", COL_ACCOUNT_ENABLED, NULL); /* Populate accounts */ accounts = empathy_account_manager_dup_accounts (priv->manager); g_list_foreach (accounts, (GFunc) account_chooser_account_add_foreach, chooser); g_list_free (accounts); g_object_unref (store); }
/** * gpk_prefs_set_combo_model_simple_text: **/ static void gpk_prefs_update_freq_combo_simple_text (GtkWidget *combo_box) { GtkCellRenderer *cell; GtkListStore *store; store = gtk_list_store_new (1, G_TYPE_STRING); gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store)); g_object_unref (store); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), cell, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), cell, "text", 0, NULL); }
static void setup_groups_combo (void) { GtkWidget *combo = gst_dialog_get_widget (tool->main_dialog, "user_settings_group"); GtkWidget *table = gst_dialog_get_widget (tool->main_dialog, "groups_table"); GtkCellRenderer *cell; GtkTreeModel *model; cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT (combo), cell, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT (combo), cell, "text", 0, NULL); model = gtk_tree_view_get_model (GTK_TREE_VIEW (table)); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), model); g_object_unref (model); }
int clip_GTK_COMBOBOXSETMODEL(ClipMachine * ClipMachineMemory) { C_widget *ccmb = _fetch_cw_arg(ClipMachineMemory); C_object *cmodel = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); CHECKCWID(ccmb, GTK_IS_COMBO_BOX); CHECKCOBJ(cmodel, GTK_IS_TREE_MODEL(cmodel->object)); gtk_combo_box_set_model(GTK_COMBO_BOX(ccmb->widget), GTK_TREE_MODEL(cmodel->object)); return 0; err: return 1; }
static void gimp_container_combo_box_init (GimpContainerComboBox *combo) { GtkTreeModel *model; GtkCellLayout *layout; GtkCellRenderer *cell; GType types[GIMP_CONTAINER_TREE_STORE_N_COLUMNS]; gint n_types = 0; gimp_container_tree_store_columns_init (types, &n_types); model = gimp_container_tree_store_new (GIMP_CONTAINER_VIEW (combo), n_types, types); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), model); g_object_unref (model); layout = GTK_CELL_LAYOUT (combo); cell = gimp_cell_renderer_viewable_new (); gtk_cell_layout_pack_start (layout, cell, FALSE); gtk_cell_layout_set_attributes (layout, cell, "renderer", GIMP_CONTAINER_TREE_STORE_COLUMN_RENDERER, NULL); gimp_container_tree_store_add_renderer_cell (GIMP_CONTAINER_TREE_STORE (model), cell); combo->viewable_renderer = cell; cell = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (layout, cell, TRUE); gtk_cell_layout_set_attributes (layout, cell, "text", GIMP_CONTAINER_TREE_STORE_COLUMN_NAME, NULL); combo->text_renderer = cell; g_signal_connect (combo, "changed", G_CALLBACK (gimp_container_combo_box_changed), combo); gtk_widget_set_sensitive (GTK_WIDGET (combo), FALSE); }
static void panel_properties_dialog_setup_orientation_combo (PanelPropertiesDialog *dialog, GtkBuilder *gui) { PanelOrientation orientation; GtkListStore *model; GtkTreeIter iter; GtkCellRenderer *renderer; int i; dialog->orientation_combo = PANEL_GTK_BUILDER_GET (gui, "orientation_combo"); g_return_if_fail (dialog->orientation_combo != NULL); dialog->orientation_label = PANEL_GTK_BUILDER_GET (gui, "orientation_label"); g_return_if_fail (dialog->orientation_label != NULL); orientation = panel_profile_get_toplevel_orientation (dialog->toplevel); model = gtk_list_store_new (NUMBER_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER); gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->orientation_combo), GTK_TREE_MODEL (model)); for (i = 0; i < G_N_ELEMENTS (orientation_items); i++) { gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COLUMN_TEXT, g_dpgettext2 (NULL, "Orientation", orientation_items [i].name), COLUMN_ITEM, &(orientation_items [i]), -1); if (orientation == orientation_items [i].orientation) gtk_combo_box_set_active_iter (GTK_COMBO_BOX (dialog->orientation_combo), &iter); } renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (dialog->orientation_combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (dialog->orientation_combo), renderer, "text", COLUMN_TEXT, NULL); g_signal_connect_swapped (dialog->orientation_combo, "changed", G_CALLBACK (panel_properties_dialog_orientation_changed), dialog); panel_properties_dialog_setup_orientation_combo_sensitivty (dialog, NULL); }
static void on_branch_list_command_started (AnjutaCommand *command, GitLogPane *self) { GtkComboBox *branch_combo; GtkListStore *log_branch_combo_model; branch_combo = GTK_COMBO_BOX (gtk_builder_get_object (self->priv->builder, "branch_combo")); log_branch_combo_model = GTK_LIST_STORE (gtk_builder_get_object (self->priv->builder, "log_branch_combo_model")); gtk_combo_box_set_model (branch_combo, NULL); gtk_list_store_clear (log_branch_combo_model); g_hash_table_remove_all (self->priv->branches_table); }
static void xfce_mixer_track_combo_init (XfceMixerTrackCombo *combo) { GtkCellRenderer *renderer; combo->card = NULL; combo->track = NULL; combo->list_store = gtk_list_store_new (2, G_TYPE_STRING, GST_TYPE_MIXER_TRACK); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (combo->list_store)); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "text", NAME_COLUMN); g_signal_connect_swapped (combo, "changed", G_CALLBACK (xfce_mixer_track_combo_changed), combo); }
static gboolean fill_algorithm_combo (SolverState *state, GnmSolverModelType type) { GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); GSList *solvers, *l; int sel = 0, i; GnmSolverParameters *param =state->sheet->solver_parameters; gtk_combo_box_set_model (state->algorithm_combo, GTK_TREE_MODEL (store)); l = NULL; for (solvers = gnm_solver_db_get (); solvers; solvers = solvers->next) { GnmSolverFactory *entry = solvers->data; if (type != entry->type) continue; l = g_slist_prepend (l, entry); } solvers = g_slist_reverse (l); gtk_widget_set_sensitive (GTK_WIDGET (state->solve_button), solvers != NULL); if (!solvers) return FALSE; for (l = solvers, i = 0; l; l = l->next, i++) { GnmSolverFactory *factory = l->data; GtkTreeIter iter; if (param->options.algorithm == factory) sel = i; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, factory->name, 1, factory, -1); } g_slist_free (solvers); gtk_combo_box_set_active (state->algorithm_combo, sel); g_object_unref (store); return TRUE; }
void XAP_makeGtkComboBoxText(GtkComboBox * combo, GType secondary) { GtkListStore * store; if (secondary != G_TYPE_NONE) { store = gtk_list_store_new(2, G_TYPE_STRING, secondary); } else { store = gtk_list_store_new(1, G_TYPE_STRING); } gtk_combo_box_set_model(combo, GTK_TREE_MODEL(store)); gtk_cell_layout_clear(GTK_CELL_LAYOUT(combo)); GtkCellRenderer *cell = GTK_CELL_RENDERER(gtk_cell_renderer_text_new()); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), cell, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), cell, "text", 0, NULL); }
void gtk_filebutton_set_recent_group(GtkFilebutton *filebutton, const gchar *recent_group) { g_return_if_fail(filebutton != NULL); g_return_if_fail(GTK_IS_FILEBUTTON(filebutton)); // Prepare for the case that we are called with the old value of // filebutton->recent_group. In this case we need to prevent to // access the old value after it is already feed. gchar *old = filebutton->recent_group; filebutton->recent_group = g_strdup(recent_group); g_free(old); GtkListStore *store = get_list_store(filebutton->recent_group); gtk_combo_box_set_model(GTK_COMBO_BOX(filebutton->comboboxentry), GTK_TREE_MODEL(store)); g_object_unref(store); }
/** * create a text only combo_box with an index * column 0 will contain the text * column 1 will have the index, in the order of the strings * * this function takes an array of string and attribute a number beginning by the first element of the array * to link some text with a special number, use gsb_combo_box_new_with_index_by_list * * \param string a pointer to an array of strings terminated by NULL, string will be appended in that order * \param func an optional function to call when change the current item (gboolean func (GtkWidget *combox, gpointer data) * \param data the data to send to the func * * \return a combo box widget * */ GtkWidget *gsb_combo_box_new_with_index ( gchar **string, GCallback func, gpointer data ) { GtkWidget *combo_box; GtkListStore *store; GtkCellRenderer *renderer; gint i = 0; combo_box = gtk_combo_box_new (); store = gtk_list_store_new ( 2, G_TYPE_STRING, G_TYPE_INT ); if (string) { while (string[i]) { GtkTreeIter iter; gtk_list_store_append ( GTK_LIST_STORE (store), &iter ); gtk_list_store_set ( store, &iter, 0, string[i], 1, i, -1 ); i++; } } gtk_combo_box_set_model ( GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store)); if ( func ) g_signal_connect ( G_OBJECT (combo_box), "changed", G_CALLBACK(func), data ); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer, "text", 0, NULL); return combo_box; }
static void notes_area_do_set_project (NotesArea *na, GttProject *proj) { const char * str; GttTask *tsk; if (!na) return; if (na->ignore_events) return; /* Calling gtk_entry_set_text makes 'changed' events happen, * which causes us to get the entry text, which exposes a gtk * bug. So we work around the bug and save cpu time by ignoring * change events during a mass update. */ na->ignore_events = TRUE; /* Note Bene its OK to have the proj be null: this has the * effect of clearing all the fields out. */ na->proj = proj; /* Fetch data from the data engine, stuff it into the GUI. */ str = gtt_project_get_title (proj); if (!str) str = ""; gtk_entry_set_text (na->proj_title, str); str = gtt_project_get_desc (proj); if (!str) str = ""; gtk_entry_set_text (na->proj_desc, str); str = gtt_project_get_notes (proj); if (!str) str = ""; xxxgtk_textview_set_text (na->proj_notes, str); GtkTreeModel *model = build_task_combo_model (proj); gtk_combo_box_set_model (na->task_combo, model); g_object_unref (model); tsk = gtt_project_get_current_task (proj); if (tsk == NULL) tsk = gtt_project_get_first_task (proj); notes_area_choose_task (na, tsk); na->ignore_events = FALSE; }
void setup_renderer_combo (GtkBuilder *builder) { GtkListStore *store; GtkCellRenderer *renderer; /* Create the renderer combo from gtk-builder */ renderer_combo = GTK_WIDGET(gtk_builder_get_object(builder, "renderer-combobox")); g_assert (renderer_combo != NULL); /* Catch selection changes from the renderer combo */ g_signal_connect (renderer_combo, "changed", G_CALLBACK (on_renderer_combo_changed), NULL); /* Create a list store for renderers and set it to the combo */ store = gtk_list_store_new (RENDERER_COMBO_COLUMNS, G_TYPE_STRING, /* Name */ G_TYPE_OBJECT, /* Renderer */ G_TYPE_UINT, /* State */ G_TYPE_UINT, /* Volume */ G_TYPE_UINT); /* Duration */ gtk_combo_box_set_model (GTK_COMBO_BOX (renderer_combo), GTK_TREE_MODEL(store)); g_object_unref (store); /* Create a text cell renderer for renderer name to the combo */ renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (renderer_combo), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (renderer_combo), renderer, "text", RENDERER_COMBO_COLUMN_NAME); /* Get the frame-on-pause button from gtk-builder */ fop_button = GTK_WIDGET(gtk_builder_get_object(builder, "frame-on-pause-button")); g_assert (fop_button != NULL); /* Catch selection changes from the renderer combo */ g_signal_connect (fop_button, "changed", G_CALLBACK (on_renderer_combo_changed), NULL); }
void on_btnSearch_clicked (GtkWidget *widget, void * user_data) { puts("\nFunction on_btnSearch_clicked:"); if (!strcmp((const char *)gtk_entry_get_text(gui->urlTxt),"")) puts("Empty URL provided"); else puts((const char *)gtk_entry_get_text(gui->urlTxt)); if (strcmp((const char *)gtk_entry_get_text(gui->urlTxt),"")) { int size,k; GtkListStore* list_store; GtkCellRenderer* renderer; GtkTreeIter iter; gtk_cell_layout_clear(GTK_CELL_LAYOUT(gui->qualBox)); list_store = gtk_list_store_new ( 1 , GTK_TYPE_STRING); gtk_combo_box_set_model(GTK_COMBO_BOX(gui->qualBox), GTK_TREE_MODEL(list_store)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(gui->qualBox), renderer, 0x01); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(gui->qualBox), renderer, "text", 0, NULL); gtk_widget_set_sensitive(widget,0x00); get_format((const char *)gtk_entry_get_text(gui->urlTxt), &size); printf("Got format. Size: %d\n", size); // cstring format[size]; puts("Format info:"); for (k=0; k<size; ++k) { cstring format = malloc(35*sizeof(char)); sprintf(format,"%d: %s [%s]%c",quality[k]->value,quality[k]->format, quality[k]->size,'\0'); GtkTreeIter * iter; gtk_list_store_append(list_store, &iter); gtk_list_store_set(list_store, &iter, 0, format,-1); free(format); } // cstring filename = malloc(257*sizeof(char)); get_title((const char *) gtk_entry_get_text(gui->urlTxt), &title); printf("%s.%s\n",title,quality[0]->format); // sprintf(filename,"%s.%s", title, quality[0]->format); gtk_combo_box_set_active(GTK_COMBO_BOX(gui->qualBox),0); gtk_widget_set_sensitive(widget,0x01); //http://www.youtube.com/watch?v=SniIBm-PWUM } }
static void build_branches_combo(GitgWindow *window, GtkBuilder *builder) { GtkComboBox *combo = GTK_COMBO_BOX(gtk_builder_get_object(builder, "combo_box_branches")); window->priv->branches_store = gtk_list_store_new(1, G_TYPE_STRING); window->priv->combo_branches = combo; GtkTreeIter iter; gtk_list_store_append(window->priv->branches_store, &iter); gtk_list_store_set(window->priv->branches_store, &iter, 0, _("Select branch"), -1); gtk_combo_box_set_model(combo, GTK_TREE_MODEL(window->priv->branches_store)); gtk_combo_box_set_active(combo, 0); gtk_combo_box_set_row_separator_func(combo, branches_separator_func, window, NULL); g_signal_connect(combo, "changed", G_CALLBACK(on_branches_combo_changed), window); }
static void share_nfs_create_combo (void) { GtkWidget *combo = gst_dialog_get_widget (tool->main_dialog, "share_nfs_host_type"); GtkListStore *store; store = gtk_list_store_new (NFS_HOST_COL_LAST, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (store)); g_object_unref (store); combo_add_columns (GTK_COMBO_BOX (combo)); }
GtkWidget *dev_select_combo_box_new(GtkWindow *parent) { GtkWidget *dev = gtk_combo_box_new(); /* Populate device list */ GtkListStore *devlist = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_POINTER, GTK_TYPE_CHECK_MENU_ITEM); GtkCellRenderer *cel = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dev), cel, TRUE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(dev), cel, "text", 0); gtk_combo_box_set_model(GTK_COMBO_BOX(dev), GTK_TREE_MODEL(devlist)); g_signal_connect(dev, "changed", G_CALLBACK(dev_selected), parent); g_object_set_data(G_OBJECT(parent), "devcombo", dev); dev_select_rescan(NULL, parent); return dev; }
void xfce_mixer_card_combo_update (XfceMixerCardCombo *combo, GstElement *card) { GtkTreeIter tree_iter; GList *iter; combo->list_store = gtk_list_store_new (2, G_TYPE_STRING, GST_TYPE_ELEMENT); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (combo->list_store)); for (iter = xfce_mixer_get_cards (); iter != NULL; iter = g_list_next (iter)) { gtk_list_store_append (combo->list_store, &tree_iter); gtk_list_store_set (combo->list_store, &tree_iter, NAME_COLUMN, xfce_mixer_get_card_display_name (iter->data), CARD_COLUMN, iter->data, -1); } _xfce_mixer_card_combo_set_active_card (combo, card); }
static void panel_run_dialog_setup_entry (PanelRunDialog *dialog, GtkBuilder *gui) { GdkScreen *screen; int width_request; GtkWidget *entry; dialog->combobox = PANEL_GTK_BUILDER_GET (gui, "comboboxentry"); entry = gtk_bin_get_child (GTK_BIN (dialog->combobox)); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->combobox), _panel_run_get_recent_programs_list (dialog)); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (dialog->combobox), 0); screen = gtk_window_get_screen (GTK_WINDOW (dialog->run_dialog)); /* 1/4 the width of the first monitor should be a good value */ width_request = panel_multiscreen_width (screen, 0) / 4; g_object_set (G_OBJECT (dialog->combobox), "width_request", width_request, NULL); g_signal_connect (entry, "key-press-event", G_CALLBACK (entry_event), dialog); dialog->changed_id = g_signal_connect (dialog->combobox, "changed", G_CALLBACK (combobox_changed), dialog); gtk_drag_dest_unset (dialog->combobox); gtk_drag_dest_set (dialog->combobox, GTK_DEST_DEFAULT_MOTION|GTK_DEST_DEFAULT_HIGHLIGHT, NULL, 0, GDK_ACTION_COPY); gtk_drag_dest_add_uri_targets (dialog->combobox); g_signal_connect (dialog->combobox, "drag_data_received", G_CALLBACK (entry_drag_data_received), dialog); }
static void setup_default_mixer (GladeXML *dialog) { GtkWidget *device_widget, *tracks_widget; GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeSelection *selection; gchar *mixer_device; device_widget = WID ("mixer_device"); tracks_widget = WID ("mixer_tracks"); model = create_mixer_device_tree_model (); gtk_combo_box_set_model (GTK_COMBO_BOX (device_widget), model); g_object_unref (G_OBJECT (model)); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (device_widget), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (device_widget), renderer, "text", MIXER_DEVICE_MODEL_NAME_COLUMN); g_signal_connect (G_OBJECT (device_widget), "changed", G_CALLBACK (mixer_device_combobox_changed), NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tracks_widget), -1, NULL, renderer, "text", MIXER_TRACKS_MODEL_LABEL_COLUMN, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tracks_widget)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (mixer_tracks_selection_changed), NULL); gconf_client_notify_add (gconf_client, DEFAULT_MIXER_DEVICE_KEY, (GConfClientNotifyFunc) default_mixer_device_notify, dialog, NULL, NULL); gconf_client_notify_add (gconf_client, DEFAULT_MIXER_TRACKS_KEY, (GConfClientNotifyFunc) default_mixer_tracks_notify, dialog, NULL, NULL); mixer_device = gconf_client_get_string (gconf_client, DEFAULT_MIXER_DEVICE_KEY, NULL); update_mixer_device_combobox (mixer_device, dialog); g_free (mixer_device); }
static void update_from_model(MathConverter *converter) { GtkTreeStore *from_model; from_model = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_OBJECT, G_TYPE_OBJECT); if (converter->priv->category == NULL) { const GList *categories, *iter; categories = unit_manager_get_categories(unit_manager_get_default()); for (iter = categories; iter; iter = iter->next) { UnitCategory *category = iter->data; GtkTreeIter parent; const GList *unit_iter; gtk_tree_store_append(from_model, &parent, NULL); gtk_tree_store_set(from_model, &parent, 0, unit_category_get_display_name(category), 1, category, -1); for (unit_iter = unit_category_get_units(category); unit_iter; unit_iter = unit_iter->next) { Unit *unit = unit_iter->data; GtkTreeIter iter; gtk_tree_store_append(from_model, &iter, &parent); gtk_tree_store_set(from_model, &iter, 0, unit_get_display_name(unit), 1, category, 2, unit, -1); } } } else { UnitCategory *category; const GList *unit_iter; category = unit_manager_get_category(unit_manager_get_default(), converter->priv->category); for (unit_iter = unit_category_get_units(category); unit_iter; unit_iter = unit_iter->next) { Unit *unit = unit_iter->data; GtkTreeIter iter; gtk_tree_store_append(from_model, &iter, NULL); gtk_tree_store_set(from_model, &iter, 0, unit_get_display_name(unit), 1, category, 2, unit, -1); } } gtk_combo_box_set_model(GTK_COMBO_BOX(converter->priv->from_combo), GTK_TREE_MODEL(from_model)); }
static GObject * e_source_combo_box_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { GtkCellRenderer *renderer; GtkListStore *store; GObject *object; /* Chain up to parent's "constructor" method. */ object = G_OBJECT_CLASS (parent_class)->constructor ( type, n_construct_properties, construct_properties); store = gtk_list_store_new ( NUM_COLUMNS, GDK_TYPE_COLOR, /* COLUMN_COLOR */ G_TYPE_STRING, /* COLUMN_NAME */ G_TYPE_BOOLEAN, /* COLUMN_SENSITIVE */ G_TYPE_OBJECT, /* COLUMN_SOURCE */ G_TYPE_BOOLEAN); /* COLUMN_VISIBLE */ gtk_combo_box_set_model ( GTK_COMBO_BOX (object), GTK_TREE_MODEL (store)); renderer = e_cell_renderer_color_new (); gtk_cell_layout_pack_start ( GTK_CELL_LAYOUT (object), renderer, FALSE); gtk_cell_layout_set_attributes ( GTK_CELL_LAYOUT (object), renderer, "color", COLUMN_COLOR, "sensitive", COLUMN_SENSITIVE, "visible", COLUMN_VISIBLE, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start ( GTK_CELL_LAYOUT (object), renderer, TRUE); gtk_cell_layout_set_attributes ( GTK_CELL_LAYOUT (object), renderer, "text", COLUMN_NAME, "sensitive", COLUMN_SENSITIVE, NULL); return object; }
QMetaObject::Connection gtk_combo_box_set_qmodel(GtkComboBox *box, QAbstractItemModel *qmodel, QItemSelectionModel *selection_model) { QMetaObject::Connection connection; GtkTreeModel *model; model = (GtkTreeModel *)gtk_q_tree_model_new( qmodel, 1, 0, Qt::DisplayRole, G_TYPE_STRING); /* use a filter model to remove disabled items */ GtkTreeModel *filter_model = gtk_tree_model_filter_new(model, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model), (GtkTreeModelFilterVisibleFunc)filter_disabled_items, NULL, NULL); gtk_combo_box_set_model(box, GTK_TREE_MODEL(filter_model)); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(box), renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(box), renderer, "text", 0, NULL); if (!selection_model) return connection; /* sync the initial selection */ gtk_combo_box_set_active_index(box, selection_model->currentIndex()); /* connect signals to and from the selection model */ connection = QObject::connect( selection_model, &QItemSelectionModel::currentChanged, [=](const QModelIndex current, G_GNUC_UNUSED const QModelIndex & previous) { gtk_combo_box_set_active_index(box, current); } ); g_signal_connect(box, "changed", G_CALLBACK(update_selection), selection_model); return connection; }
static void presence_chooser_dialog_setup (CustomMessageDialog *dialog) { GtkListStore *store; GtkCellRenderer *renderer; GtkTreeIter iter; guint i; store = gtk_list_store_new (COL_COUNT, G_TYPE_STRING, /* Icon name */ G_TYPE_STRING, /* Label */ MC_TYPE_PRESENCE); /* Presence */ gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->combobox_status), GTK_TREE_MODEL (store)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (dialog->combobox_status), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (dialog->combobox_status), renderer, "icon-name", COL_ICON, NULL); g_object_set (renderer, "stock-size", GTK_ICON_SIZE_BUTTON, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (dialog->combobox_status), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (dialog->combobox_status), renderer, "text", COL_LABEL, NULL); for (i = 0; i < G_N_ELEMENTS (states); i += 2) { if (!states[i+1]) { continue; } gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COL_ICON, empathy_icon_name_for_presence (states[i]), COL_LABEL, empathy_presence_get_default_message (states[i]), COL_PRESENCE, states[i], -1); } gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->combobox_status), 0); }
int ags_channel_link_collection_editor_parent_set_callback(GtkWidget *widget, GtkObject *old_parent, AgsChannelLinkCollectionEditor *channel_link_collection_editor) { AgsMachineEditor *machine_editor; if(old_parent != NULL) return(0); machine_editor = (AgsMachineEditor *) gtk_widget_get_ancestor(widget, AGS_TYPE_MACHINE_EDITOR); if(machine_editor != NULL && machine_editor->machine != NULL){ gtk_combo_box_set_model(channel_link_collection_editor->link, GTK_TREE_MODEL(ags_machine_get_possible_links(machine_editor->machine))); ags_channel_link_collection_editor_check(channel_link_collection_editor); } }
static void gimp_enum_combo_box_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkComboBox *combo_box = GTK_COMBO_BOX (object); switch (prop_id) { case PROP_MODEL: gtk_combo_box_set_model (combo_box, g_value_get_object (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/*! \brief fills in the AFR calibrator combobutton with the appropriate choices. The model stores the corresponding enum for later \param combo is a pointer to the combobutton to initialize \returns TRUE on success, FALSE otherwise */ G_MODULE_EXPORT gboolean populate_afr_calibrator_combo(GtkWidget *combo) { GtkListStore *store = NULL; GtkTreeIter iter; gint i = 0; g_return_val_if_fail(GTK_IS_COMBO_BOX(combo),FALSE); store = gtk_list_store_new(NUM_COLS,G_TYPE_STRING,G_TYPE_INT); for (i=0;i<num_symbols;i++) { gtk_list_store_append(store,&iter); gtk_list_store_set(store,&iter,COL_NAME,AFR_Tables[i].name,COL_SYMBOL,AFR_Tables[i].symbol,-1); } gtk_combo_box_set_model(GTK_COMBO_BOX(combo),GTK_TREE_MODEL(store)); gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(combo),0); return TRUE; }
static void setup_filesystem_menu(FormatDialog* dialog) { GtkTreeStore* model; model = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); GtkComboBox* combo = dialog->fs_combo; GtkCellRenderer* text_renderer; gtk_combo_box_set_model(combo, GTK_TREE_MODEL(model)); dialog->fs_model = model; /* Set up the column */ gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(combo), (text_renderer = gtk_cell_renderer_text_new()), TRUE ); gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(combo), text_renderer, "markup", FS_COLUMN_MARKUP ); gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(combo), text_renderer, "sensitive", FS_COLUMN_SENSITIVE ); /* Add the default items */ gtk_tree_store_insert_with_values(model, NULL, NULL, 100 /*Always at end*/, FS_COLUMN_REALNAME, "friendly_vfat", FS_COLUMN_MARKUP, _("For all computers"), FS_COLUMN_SENSITIVE, TRUE, -1); gtk_tree_store_insert_with_values(model, NULL, NULL, 100 /*Always at end*/, FS_COLUMN_REALNAME, "friendly_ext2", FS_COLUMN_MARKUP, _("For Linux computers"), FS_COLUMN_SENSITIVE, TRUE, -1); gtk_tree_store_insert_with_values(model, NULL, NULL, 100 /*Always at end*/, FS_COLUMN_REALNAME, "friendly_hfsplus", FS_COLUMN_MARKUP, _("For Apple computers"), FS_COLUMN_SENSITIVE, TRUE, -1); GtkTreeIter parent = {0, NULL}; gtk_tree_store_insert_with_values(model, &parent, NULL, 100 /*Always at end*/, FS_COLUMN_REALNAME, "specific_fs", FS_COLUMN_MARKUP, _("Specific Filesystem"), FS_COLUMN_SENSITIVE, TRUE, -1); /* Populate the specific fs list */ struct _setup_fs_duple s; s.model = model; s.parent = &parent; dialog->fs_map = build_supported_fs_list(); g_hash_table_foreach(dialog->fs_map, setup_fs_cb, &s); }