void wxBitmapComboBox::GTKCreateComboBoxWidget() { GtkListStore *store; store = gtk_list_store_new( 2, G_TYPE_OBJECT, G_TYPE_STRING ); if ( HasFlag(wxCB_READONLY) ) { m_widget = gtk_combo_box_new_with_model( GTK_TREE_MODEL(store) ); } else { m_widget = gtk_combo_box_entry_new_with_model( GTK_TREE_MODEL(store), m_stringCellIndex ); m_entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(m_widget))); gtk_editable_set_editable(GTK_EDITABLE(m_entry), true); } g_object_ref(m_widget); // This must be called as gtk_combo_box_entry_new_with_model adds // automatically adds one text column. gtk_cell_layout_clear( GTK_CELL_LAYOUT(m_widget) ); GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(m_widget), imageRenderer, FALSE); gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(m_widget), imageRenderer, "pixbuf", 0); GtkCellRenderer* textRenderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_end( GTK_CELL_LAYOUT(m_widget), textRenderer, TRUE ); gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(m_widget), textRenderer, "text", 1); }
void init_object_combo_box(GtkWidget *cbox) { GtkCellRenderer *rend; GtkTreeViewRowSeparatorFunc func; func = gtk_combo_box_get_row_separator_func(GTK_COMBO_BOX(cbox)); if (func == NULL) { gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(cbox), combo_box_separator_func, NULL, NULL); } gtk_cell_layout_clear(GTK_CELL_LAYOUT(cbox)); rend = gtk_cell_renderer_toggle_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbox), rend, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(cbox), rend, "active", OBJECT_COLUMN_TYPE_TOGGLE, "visible", OBJECT_COLUMN_TYPE_TOGGLE_VISIBLE, "radio", OBJECT_COLUMN_TYPE_TOGGLE_IS_RADIO, NULL); rend = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbox), rend, FALSE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(cbox), rend, "text", OBJECT_COLUMN_TYPE_STRING); rend = gtk_cell_renderer_pixbuf_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbox), rend, FALSE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(cbox), rend, "pixbuf", OBJECT_COLUMN_TYPE_PIXBUF); }
static void brasero_medium_selection_set_show_used_space (BraseroMediumSelection *selector) { GtkCellRenderer *renderer; gtk_cell_layout_clear (GTK_CELL_LAYOUT (selector)); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "follow-state", TRUE, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer, "gicon", ICON_COL, NULL); renderer = gtk_cell_renderer_progress_new (); g_object_set (renderer, "xpad", 4, "text-xalign", 0.0, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer, "text", NAME_COL, "value", USED_COL, "visible", VISIBLE_PROGRESS_COL, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 4, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer, "markup", NAME_COL, "visible", VISIBLE_TEXT_COL, NULL); }
void gnomegadu_ui_init_statusbar () { GtkComboBox *combobox = GTK_COMBO_BOX (glade_xml_get_widget (gladexml, "StatusComboBox")); GtkListStore *status_store = NULL; GtkCellRenderer *render_text, *render_pixbuf; GtkTreeIter iter, iter_init; GdkPixbuf *pixbuf; gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox)); status_store = gtk_list_store_new (UI_STATUS_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT); render_pixbuf = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), render_pixbuf, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), render_pixbuf, "pixbuf", UI_STATUS_COLUMN_ICON, NULL); render_text = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), render_text, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), render_text, "markup", UI_STATUS_COLUMN_NAME, NULL); pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-user-available"); gtk_list_store_append (status_store, &iter); gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Dostępny", UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_AVAIL, -1); gdk_pixbuf_unref (pixbuf); pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-user-away"); gtk_list_store_append (status_store, &iter); gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Zajęty", UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_BUSY, -1); gdk_pixbuf_unref (pixbuf); pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-user-invisible"); gtk_list_store_append (status_store, &iter); gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Niewidoczny", UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_INVISIBLE, -1); gdk_pixbuf_unref (pixbuf); pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-user-not-available"); gtk_list_store_append (status_store, &iter_init); gtk_list_store_set (status_store, &iter_init, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Niedostępny", UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_UNAVAIL, -1); gdk_pixbuf_unref (pixbuf); gtk_list_store_append (status_store, &iter); gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_UNKNOWN, -1); pixbuf = gnomegadu_stock_get_pixbuf ("gnomegadu-description"); gtk_list_store_append (status_store, &iter); gtk_list_store_set (status_store, &iter, UI_STATUS_COLUMN_ICON, pixbuf, UI_STATUS_COLUMN_NAME, "Ustaw opis", UI_STATUS_COLUMN_STATUS, GNOMEGADU_STATUS_DESC, -1); gdk_pixbuf_unref (pixbuf); gtk_combo_box_set_row_separator_func (combobox, userlist_combo_separator_func, NULL, NULL); gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (status_store)); gtk_combo_box_set_active_iter (combobox, &iter_init); g_object_unref (status_store); }
static void scheme_combo_init (GtkComboBox *combo) { GtkListStore *store; MooLangMgr *mgr; GSList *list, *l; GtkCellRenderer *cell; mgr = moo_lang_mgr_default (); list = moo_lang_mgr_list_schemes (mgr); g_return_if_fail (list != NULL); store = gtk_list_store_new (1, MOO_TYPE_TEXT_STYLE_SCHEME); for (l = list; l != NULL; l = l->next) { GtkTreeIter iter; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, l->data, -1); } gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), cell, (GtkCellLayoutDataFunc) scheme_combo_data_func, NULL, NULL); g_object_unref (store); g_slist_foreach (list, (GFunc) g_object_unref, NULL); g_slist_free (list); }
void seahorse_combo_keys_attach (GtkComboBox *combo, GcrCollection *collection, const gchar *none_option) { GtkTreeModel *model; GtkTreeIter iter; GtkCellRenderer *renderer; GList *l, *objects; g_object_set_data_full (G_OBJECT (combo), "combo-keys-closure", combo_closure_new (), combo_closure_free); /* Setup the None Option */ model = gtk_combo_box_get_model (combo); if (!model) { model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER)); gtk_combo_box_set_model (combo, model); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); 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, "markup", COMBO_MARKUP); } /* Setup the object list */ objects = gcr_collection_get_objects (collection); for (l = objects; l != NULL; l = g_list_next (l)) on_collection_added (collection, l->data, combo); g_list_free (objects); g_signal_connect_after (collection, "added", G_CALLBACK (on_collection_added), combo); g_signal_connect_after (collection, "removed", G_CALLBACK (on_collection_removed), combo); if (none_option) { gtk_list_store_prepend (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, COMBO_LABEL, NULL, COMBO_MARKUP, none_option, COMBO_POINTER, NULL, -1); } gtk_tree_model_get_iter_first (model, &iter); gtk_combo_box_set_active_iter (combo, &iter); g_signal_connect_data (combo, "destroy", G_CALLBACK (on_combo_destroy), g_object_ref (collection), (GClosureNotify)g_object_unref, 0); }
static void account_chooser_constructed (GObject *object) { EmpathyAccountChooser *self = (EmpathyAccountChooser *) object; GtkListStore *store; GtkCellRenderer *renderer; GtkComboBox *combobox; if (G_OBJECT_CLASS (empathy_account_chooser_parent_class)->constructed) G_OBJECT_CLASS (empathy_account_chooser_parent_class)->constructed (object); /* Set up combo box with new store */ combobox = GTK_COMBO_BOX (self); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox)); store = gtk_list_store_new (COL_ACCOUNT_COUNT, GDK_TYPE_PIXBUF, /* Image */ G_TYPE_STRING, /* Name */ G_TYPE_BOOLEAN, /* Enabled */ G_TYPE_UINT, /* Row type */ TP_TYPE_ACCOUNT); gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store), account_cmp, self, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); 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, "pixbuf", COL_ACCOUNT_IMAGE, "sensitive", COL_ACCOUNT_ENABLED, 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 */ tp_proxy_prepare_async (self->priv->manager, NULL, account_manager_prepared_cb, self); g_object_unref (store); }
void XAP_makeGtkComboBoxText2(GtkComboBox * combo, GType secondary, GType tertiary) { GtkListStore * store; store = gtk_list_store_new(3, G_TYPE_STRING, secondary, tertiary); 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); }
static void ipreferences_merge(IAnjutaPreferences* ipref, AnjutaPreferences* prefs, GError** e) { /* Add preferences */ SourceviewPlugin* plugin = ANJUTA_PLUGIN_SOURCEVIEW (ipref); GtkCellRenderer* renderer_name = gtk_cell_renderer_text_new (); GtkCellRenderer* renderer_desc = gtk_cell_renderer_text_new (); GtkTreeIter* iter = NULL; GError* error = NULL; builder = gtk_builder_new (); if (!gtk_builder_add_from_file(builder, PREFS_GLADE, &error)) { DEBUG_PRINT ("Could load sourceview preferences: %s", error->message); g_error_free (error); return; } anjuta_preferences_add_from_builder (prefs, builder, plugin->settings, "Editor", _("GtkSourceView Editor"), ICON_FILE); plugin->check_font = GTK_WIDGET (gtk_builder_get_object (builder, FONT_USE_THEME_BUTTON)); g_signal_connect(G_OBJECT(plugin->check_font), "toggled", G_CALLBACK(on_font_check_toggled), builder); on_font_check_toggled (GTK_TOGGLE_BUTTON (plugin->check_font), builder); /* Init styles combo */ plugin->combo_styles = GTK_WIDGET (gtk_builder_get_object (builder, COMBO_STYLES)); gtk_combo_box_set_model (GTK_COMBO_BOX (plugin->combo_styles), create_style_model(plugin->settings, &iter)); g_signal_connect (plugin->combo_styles, "changed", G_CALLBACK (on_style_changed), plugin); gtk_cell_layout_clear (GTK_CELL_LAYOUT(plugin->combo_styles)); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_name, TRUE); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_desc, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_name, "text", COLUMN_NAME); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(plugin->combo_styles), renderer_desc, "text", COLUMN_DESC); g_object_set (renderer_desc, "style", PANGO_STYLE_ITALIC, NULL); if (iter) { gtk_combo_box_set_active_iter (GTK_COMBO_BOX (plugin->combo_styles), iter); gtk_tree_iter_free (iter); } }
/* col 0 is for the full path, col 1 is just the filename and is what gets displayed */ void filename_combo_box_build_model(GtkComboBox *cbox) { GtkListStore *store; GtkCellRenderer *renderer; store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); gtk_combo_box_set_model(GTK_COMBO_BOX(cbox), GTK_TREE_MODEL(store)); gtk_cell_layout_clear(GTK_CELL_LAYOUT(cbox)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(cbox), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(cbox), renderer, "text", 1, NULL); }
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); }
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 gtk_cell_layout_default_clear (GtkCellLayout *cell_layout) { GtkCellLayoutIface *iface; GtkCellArea *area; iface = GTK_CELL_LAYOUT_GET_IFACE (cell_layout); if (iface->get_area) { area = iface->get_area (cell_layout); if (area) gtk_cell_layout_clear (GTK_CELL_LAYOUT (area)); else warn_no_cell_area ("GtkCellLayoutIface->clear()"); } }
static void combo_add_columns (GtkComboBox *combo) { GtkCellRenderer *renderer; gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo), renderer, "pixbuf", NFS_HOST_COL_PIXBUF); g_object_unref (renderer); 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", NFS_HOST_COL_NAME); g_object_unref (renderer); }
static void set_combo_box_enum_model (GtkComboBox* combo_box, const ATPEnumType* list) { GtkTreeModel *model; GtkCellRenderer * renderer; model = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT)); for (; list->id != -1;++list) { GtkTreeIter iter; gtk_list_store_append (GTK_LIST_STORE(model), &iter); gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, _(list->name), 1, list->id, -1); } gtk_combo_box_set_model (combo_box, model); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_clear (GTK_CELL_LAYOUT(combo_box)); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT(combo_box), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT(combo_box), renderer, "text", 0 ); }
void populate_combo_box(GtkWidget *widget, GList *list) { GtkListStore *store; GtkCellRenderer *renderer; store = gtk_list_store_new(1, G_TYPE_STRING); // Clear existing data from combo box gtk_cell_layout_clear(GTK_CELL_LAYOUT(widget)); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(widget), renderer, FALSE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(widget), renderer, "text", 0); while (list != NULL) { GtkTreeIter iter; gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, (char *)list->data, -1); list = list->next; } gtk_combo_box_set_model(GTK_COMBO_BOX(widget), GTK_TREE_MODEL(store)); }
static void fill_pilots_combo (GnomePilotCapplet *gpcap) { GnomePilotCappletPrivate *priv; GList *tmp; GPilotPilot *pilot = NULL; GtkListStore *store; GtkTreeIter iter; priv = gpcap->priv; store = gtk_list_store_new(1, G_TYPE_STRING); tmp = priv->state->pilots; while (tmp != NULL) { if (pilot == NULL) pilot = tmp->data; gtk_list_store_append(store, &iter); gtk_list_store_set (store, &iter, 0, ((GPilotPilot*)tmp->data)->name, -1); tmp = tmp->next; } g_signal_connect (G_OBJECT(priv->pilots_combo),"changed", G_CALLBACK (gpcap_conduits_choose_pilot), gpcap); gtk_combo_box_set_model (GTK_COMBO_BOX (priv->pilots_combo), GTK_TREE_MODEL(store)); gtk_cell_layout_clear(GTK_CELL_LAYOUT(priv->pilots_combo)); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->pilots_combo), renderer, TRUE); gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->pilots_combo), renderer, "text", 0); gtk_combo_box_set_active (GTK_COMBO_BOX (priv->pilots_combo), 0); set_conduit_pilot (gpcap, pilot); }
static void lang_combo_init (GtkComboBox *combo, MooPrefsPage *page, PrefsLangsXml *gxml) { GtkTreeModel *model; GtkCellRenderer *cell; MooTreeHelper *helper; fix_style (GTK_WIDGET (combo)); model = page_get_lang_model (page); g_return_if_fail (model != NULL); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), cell, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), cell, "text", COLUMN_NAME, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), cell, set_sensitive, NULL, NULL); gtk_combo_box_set_model (combo, model); _moo_combo_box_select_first (combo); helper = _moo_tree_helper_new (GTK_WIDGET (combo), NULL, NULL, NULL, NULL); g_return_if_fail (helper != NULL); g_object_set_data_full (G_OBJECT (page), "moo-tree-helper", helper, g_object_unref); g_signal_connect_swapped (helper, "update-widgets", G_CALLBACK (helper_update_widgets), gxml); g_signal_connect_swapped (helper, "update-model", G_CALLBACK (helper_update_model), gxml); _moo_tree_helper_update_widgets (helper); }
static void gimp_unit_combo_box_style_set (GtkWidget *widget, GtkStyle *prev_style) { GtkCellLayout *layout; GtkCellRenderer *cell; gdouble scale; GTK_WIDGET_CLASS (parent_class)->style_set (widget, prev_style); gtk_widget_style_get (widget, "label-scale", &scale, NULL); /* hackedehack ... */ layout = GTK_CELL_LAYOUT (gtk_bin_get_child (GTK_BIN (widget))); gtk_cell_layout_clear (layout); cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "scale", scale, NULL); gtk_cell_layout_pack_start (layout, cell, TRUE); gtk_cell_layout_set_attributes (layout, cell, "text", GIMP_UNIT_STORE_UNIT_SHORT_FORMAT, NULL); }
static void fill_model_combo (GtkWidget *combo, const char *mount_path) { GHashTable *models; Itdb_Device *device; GtkTreeStore *store; const Itdb_IpodInfo *ipod_info; GtkCellRenderer *renderer; struct FillModelContext ctx; device = itdb_device_new (); itdb_device_set_mountpoint (device, mount_path); itdb_device_read_sysinfo (device); ipod_info = itdb_device_get_ipod_info (device); itdb_device_free (device); store = gtk_tree_store_new (1, G_TYPE_POINTER); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), GTK_TREE_MODEL (store)); ctx.combo = combo; ctx.store = store; ctx.ipod_info = ipod_info; models = build_model_table (mount_path); g_hash_table_foreach (models, fill_one_generation, &ctx); g_hash_table_destroy (models); g_object_unref (store); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), renderer, set_cell, NULL, NULL); }
void desktop_init (AppearanceData *data, const gchar **uris) { GtkWidget *add_button, *w; GtkCellRenderer *cr; char *url; data->wp_update_settings = TRUE; data->wp_uris = NULL; if (uris != NULL) { while (*uris != NULL) { data->wp_uris = g_slist_append (data->wp_uris, g_strdup (*uris)); uris++; } } w = appearance_capplet_get_widget (data, "more_backgrounds_linkbutton"); url = g_settings_get_string (data->settings, MORE_BACKGROUNDS_URL_KEY); if (url != NULL && url[0] != '\0') { gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url); gtk_widget_show (w); } else { gtk_widget_hide (w); } g_free (url); data->wp_hash = g_hash_table_new (g_str_hash, g_str_equal); g_signal_connect (data->wp_settings, "changed::" WP_FILE_KEY, G_CALLBACK (wp_file_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_OPTIONS_KEY, G_CALLBACK (wp_options_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_SHADING_KEY, G_CALLBACK (wp_shading_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_PCOLOR_KEY, G_CALLBACK (wp_color1_changed), data); g_signal_connect (data->wp_settings, "changed::" WP_SCOLOR_KEY, G_CALLBACK (wp_color2_changed), data); data->wp_model = GTK_TREE_MODEL (gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_POINTER)); data->wp_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "wp_view")); gtk_icon_view_set_model (data->wp_view, GTK_TREE_MODEL (data->wp_model)); g_signal_connect_after (data->wp_view, "realize", (GCallback) wp_select_after_realize, data); gtk_cell_layout_clear (GTK_CELL_LAYOUT (data->wp_view)); cr = gtk_cell_renderer_pixbuf_new (); g_object_set (cr, "xpad", 5, "ypad", 5, NULL); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (data->wp_view), cr, "pixbuf", 0, NULL); cr = gtk_cell_renderer_pixbuf_new (); create_button_images (data); g_object_set (cr, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, "pixbuf", buttons[0], NULL); g_object_set_data (G_OBJECT (cr), "buttons", GINT_TO_POINTER (TRUE)); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (data->wp_view), cr, FALSE); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (data->wp_view), cr, buttons_cell_data_func, data, NULL); g_signal_connect (data->wp_view, "selection-changed", (GCallback) wp_selected_changed_cb, data); g_signal_connect (data->wp_view, "button-press-event", G_CALLBACK (wp_button_press_cb), data); data->frame = -1; gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (data->wp_model), 1, (GtkTreeIterCompareFunc) wp_list_sort, data, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->wp_model), 1, GTK_SORT_ASCENDING); gtk_drag_dest_set (GTK_WIDGET (data->wp_view), GTK_DEST_DEFAULT_ALL, drop_types, G_N_ELEMENTS (drop_types), GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (data->wp_view, "drag_data_received", (GCallback) wp_drag_received, data); gtk_drag_source_set (GTK_WIDGET (data->wp_view), GDK_BUTTON1_MASK, drag_types, G_N_ELEMENTS (drag_types), GDK_ACTION_COPY); g_signal_connect (data->wp_view, "drag-data-get", (GCallback) wp_drag_get_data, data); data->wp_style_menu = appearance_capplet_get_widget (data, "wp_style_menu"); g_signal_connect (data->wp_style_menu, "changed", (GCallback) wp_scale_type_changed, data); data->wp_color_menu = appearance_capplet_get_widget (data, "wp_color_menu"); g_signal_connect (data->wp_color_menu, "changed", (GCallback) wp_shade_type_changed, data); data->wp_scpicker = appearance_capplet_get_widget (data, "wp_scpicker"); g_signal_connect (data->wp_scpicker, "color-set", (GCallback) wp_scolor_changed, data); data->wp_pcpicker = appearance_capplet_get_widget (data, "wp_pcpicker"); g_signal_connect (data->wp_pcpicker, "color-set", (GCallback) wp_scolor_changed, data); add_button = appearance_capplet_get_widget (data, "wp_add_button"); gtk_button_set_image (GTK_BUTTON (add_button), gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_BUTTON)); g_signal_connect (add_button, "clicked", (GCallback) wp_file_open_dialog, data); data->wp_rem_button = appearance_capplet_get_widget (data, "wp_rem_button"); g_signal_connect (data->wp_rem_button, "clicked", (GCallback) wp_remove_wallpaper, data); data->screen_monitors_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)), "monitors-changed", G_CALLBACK (screen_monitors_changed), data); data->screen_size_handler = g_signal_connect (gtk_widget_get_screen (GTK_WIDGET (data->wp_view)), "size-changed", G_CALLBACK (screen_monitors_changed), data); g_signal_connect (data->wp_view, "selection-changed", (GCallback) wp_props_wp_selected, data); g_signal_connect (data->wp_view, "query-tooltip", (GCallback) wp_view_tooltip_cb, data); gtk_widget_set_has_tooltip (GTK_WIDGET (data->wp_view), TRUE); wp_set_sensitivities (data); /* create the file selector later to save time on startup */ data->wp_filesel = NULL; }
void info_load_iface (Netinfo *info) { GtkTreeModel *model; GtkTreeIter iter; GtkCellRenderer *renderer; GList *items = NULL; GList *p; GdkPixbuf *pixbuf = NULL; gchar *iface = NULL; gchar *text; items = info_get_interfaces (info); p = items; model = gtk_combo_box_get_model (GTK_COMBO_BOX (info->combo)); if (!items) { iface = g_strdup_printf ("<i>%s</i>", _("Network Devices Not Found")); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, NULL, 1, iface, 2, (gpointer) NULL, -1); g_free (iface); } else { while (p) { text = g_strdup (p->data); info_get_interface_from_dev_name (text, &iface, &pixbuf); gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, pixbuf, 1, iface, 2, (gpointer) text, -1); g_free (iface); g_object_unref (pixbuf); p = g_list_next (p); } g_list_free (items); } gtk_cell_layout_clear (GTK_CELL_LAYOUT (info->combo)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (info->combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (info->combo), renderer, "pixbuf", 0, NULL); g_object_unref (renderer); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (info->combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (info->combo), renderer, "markup", 1, NULL); g_object_unref (renderer); gtk_combo_box_set_active (GTK_COMBO_BOX (info->combo), 0); }
/* Gets the widgets from the XML file and returns TRUE if they are all available. */ static gboolean get_widgets (Dialog *dialog) { dialog->toplevel = e_builder_get_widget (dialog->builder, "alarm-dialog"); if (!dialog->toplevel) return FALSE; dialog->action_combo = e_builder_get_widget (dialog->builder, "action-combobox"); dialog->interval_value = e_builder_get_widget (dialog->builder, "interval-value"); dialog->value_units_combo = e_builder_get_widget (dialog->builder, "value-units-combobox"); dialog->relative_combo = e_builder_get_widget (dialog->builder, "relative-combobox"); dialog->time_combo = e_builder_get_widget (dialog->builder, "time-combobox"); dialog->repeat_toggle = e_builder_get_widget (dialog->builder, "repeat-toggle"); dialog->repeat_group = e_builder_get_widget (dialog->builder, "repeat-group"); dialog->repeat_quantity = e_builder_get_widget (dialog->builder, "repeat-quantity"); dialog->repeat_value = e_builder_get_widget (dialog->builder, "repeat-value"); dialog->repeat_unit_combo = e_builder_get_widget (dialog->builder, "repeat-unit-combobox"); dialog->option_notebook = e_builder_get_widget (dialog->builder, "option-notebook"); dialog->dalarm_group = e_builder_get_widget (dialog->builder, "dalarm-group"); dialog->dalarm_message = e_builder_get_widget (dialog->builder, "dalarm-message"); dialog->dalarm_description = e_builder_get_widget (dialog->builder, "dalarm-description"); dialog->aalarm_group = e_builder_get_widget (dialog->builder, "aalarm-group"); dialog->aalarm_sound = e_builder_get_widget (dialog->builder, "aalarm-sound"); dialog->aalarm_file_chooser = e_builder_get_widget (dialog->builder, "aalarm-file-chooser"); dialog->malarm_group = e_builder_get_widget (dialog->builder, "malarm-group"); dialog->malarm_address_group = e_builder_get_widget (dialog->builder, "malarm-address-group"); dialog->malarm_addressbook = e_builder_get_widget (dialog->builder, "malarm-addressbook"); dialog->malarm_message = e_builder_get_widget (dialog->builder, "malarm-message"); dialog->malarm_description = e_builder_get_widget (dialog->builder, "malarm-description"); dialog->palarm_group = e_builder_get_widget (dialog->builder, "palarm-group"); dialog->palarm_program = e_builder_get_widget (dialog->builder, "palarm-program"); dialog->palarm_args = e_builder_get_widget (dialog->builder, "palarm-args"); if (dialog->action_combo) { const gchar *actions[] = { N_("Pop up an alert"), N_("Play a sound"), N_("Run a program"), N_("Send an email") }; GtkComboBox *combo = (GtkComboBox *) dialog->action_combo; GtkCellRenderer *cell; GtkListStore *store; gint i; g_return_val_if_fail (combo != NULL, FALSE); g_return_val_if_fail (GTK_IS_COMBO_BOX (combo), FALSE); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN); gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store)); g_object_unref (store); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); 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, "sensitive", 1, NULL); for (i = 0; i < G_N_ELEMENTS (actions); i++) { GtkTreeIter iter; gtk_list_store_append (store, &iter); gtk_list_store_set ( store, &iter, 0, _(actions[i]), 1, TRUE, -1); } } return (dialog->action_combo && dialog->interval_value && dialog->value_units_combo && dialog->relative_combo && dialog->time_combo && dialog->repeat_toggle && dialog->repeat_group && dialog->repeat_quantity && dialog->repeat_value && dialog->repeat_unit_combo && dialog->option_notebook && dialog->dalarm_group && dialog->dalarm_message && dialog->dalarm_description && dialog->aalarm_group && dialog->aalarm_sound && dialog->aalarm_file_chooser && dialog->malarm_group && dialog->malarm_address_group && dialog->malarm_addressbook && dialog->malarm_message && dialog->malarm_description && dialog->palarm_group && dialog->palarm_program && dialog->palarm_args); }
/* Build the multiple file dialog */ static SeahorseWidget* prepare_dialog (FilesCtx *ctx, guint nfolders, guint nfiles, GFileInfo *info, gchar* ext) { SeahorseWidget *swidget; const gchar* pkg; GtkWidget *tog; GtkWidget *w; GtkWidget *combo; gchar *msg, *display; gboolean sep; gint i; GtkCellRenderer *cell; GtkTreeModel *store; FRFileType *save_type_list; g_assert (info); swidget = seahorse_widget_new ("multi-encrypt", NULL); g_return_val_if_fail (swidget != NULL, NULL); /* The main 'selected' message */ msg = make_message (nfolders, nfiles); w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "message")); gtk_label_set_markup (GTK_LABEL(w), msg); g_free (msg); /* Setup the remote or local messages */ w = GTK_WIDGET (seahorse_widget_get_widget (swidget, ctx->remote ? "remote-options" : "local-options")); gtk_widget_show (w); tog = GTK_WIDGET (seahorse_widget_get_widget (swidget, "do-separate")); if (ctx->remote) { /* Always use the seperate option */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tog), TRUE); /* The local stuff */ } else { sep = g_settings_get_boolean (seahorse_tool_settings, "separate-files"); /* Setup the package */ w = GTK_WIDGET (seahorse_widget_get_widget (swidget, "package-name")); display = g_strdup (g_file_info_get_display_name (info)); pkg = seahorse_util_uri_split_last (display); gtk_entry_set_text (GTK_ENTRY (w), pkg); g_free (display); /* Setup the URI combo box */ combo = GTK_WIDGET (seahorse_widget_get_widget (swidget, "package-extension")); store = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); gtk_combo_box_set_model (GTK_COMBO_BOX (combo), store); g_object_unref (store); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); 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); compute_supported_archive_types (); save_type_list = save_type; for (i = 0; save_type_list[i] != FR_FILE_TYPE_NULL; i++) { gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), file_type_desc[save_type_list[i]].ext); if (strcmp(ext, file_type_desc[save_type_list[i]].ext) == 0) gtk_combo_box_set_active (GTK_COMBO_BOX (combo), i); } if(sep == FALSE) { gtk_widget_grab_focus (w); gtk_editable_select_region (GTK_EDITABLE (w), 0, strlen (pkg)); } /* Setup the main radio buttons */ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tog), sep); g_signal_connect (tog, "toggled", G_CALLBACK (seperate_toggled), w); seperate_toggled (tog, w); } return swidget; }
static void subversion_commit_dialog (GtkAction* action, Subversion* plugin, gchar *filename) { GtkBuilder* bxml = gtk_builder_new (); GtkWidget* dialog; GtkWidget *logtext; GtkWidget *commit_select_all_button; GtkWidget *commit_clear_button; GtkWidget *commit_status_view; GtkWidget *commit_status_progress_bar; GtkWidget *commit_prev_msg_enable; GtkWidget *commit_prev_msg_combo; GtkCellRenderer *cell; GtkListStore *store; SvnStatusCommand *status_command; SubversionData* data; GError* error = NULL; if (!gtk_builder_add_from_file (bxml, GLADE_FILE, &error)) { g_warning ("Couldn't load builder file: %s", error->message); g_error_free (error); } dialog = GTK_WIDGET (gtk_builder_get_object (bxml, "subversion_commit")); commit_select_all_button = GTK_WIDGET (gtk_builder_get_object (bxml, "commit_select_all_button")); commit_clear_button = GTK_WIDGET (gtk_builder_get_object (bxml, "commit_clear_button")); commit_status_view = GTK_WIDGET (gtk_builder_get_object (bxml, "commit_status_view")); commit_status_progress_bar = GTK_WIDGET (gtk_builder_get_object (bxml, "commit_status_progress_bar")); logtext = GTK_WIDGET (gtk_builder_get_object (bxml, "subversion_log_view")); status_command = svn_status_command_new (plugin->project_root_dir, TRUE, TRUE); commit_prev_msg_enable = GTK_WIDGET (gtk_builder_get_object (bxml, "commit_prev_msg_enable")); commit_prev_msg_combo = GTK_WIDGET (gtk_builder_get_object (bxml, "commit_prev_msg_combo")); g_signal_connect (G_OBJECT (commit_select_all_button), "clicked", G_CALLBACK (select_all_status_items), commit_status_view); g_signal_connect (G_OBJECT (commit_clear_button), "clicked", G_CALLBACK (clear_all_status_selections), commit_status_view); g_signal_connect (G_OBJECT (status_command), "command-finished", G_CALLBACK (select_all_files), commit_status_view); g_signal_connect(G_OBJECT (commit_prev_msg_enable), "toggled", G_CALLBACK(on_prev_message_enable_clicked), logtext); pulse_progress_bar (GTK_PROGRESS_BAR (commit_status_progress_bar)); g_signal_connect (G_OBJECT (status_command), "command-finished", G_CALLBACK (cancel_data_arrived_signal_disconnect), commit_status_view); g_signal_connect (G_OBJECT (status_command), "command-finished", G_CALLBACK (hide_pulse_progress_bar), commit_status_progress_bar); g_signal_connect (G_OBJECT (status_command), "command-finished", G_CALLBACK (on_status_command_finished), NULL); g_signal_connect (G_OBJECT (status_command), "data-arrived", G_CALLBACK (on_status_command_data_arrived), commit_status_view); g_object_weak_ref (G_OBJECT (commit_status_view), (GWeakNotify) disconnect_data_arrived_signals, status_command); anjuta_command_start (ANJUTA_COMMAND (status_command)); data = subversion_data_new(plugin, bxml); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(on_subversion_commit_response), data); store = gtk_list_store_new (1, G_TYPE_STRING); cell = gtk_cell_renderer_text_new (); gtk_cell_layout_clear(GTK_CELL_LAYOUT(commit_prev_msg_combo)); gtk_combo_box_set_model(GTK_COMBO_BOX(commit_prev_msg_combo), NULL); gtk_combo_box_set_model(GTK_COMBO_BOX(commit_prev_msg_combo), GTK_TREE_MODEL(store)); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (commit_prev_msg_combo), cell, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (commit_prev_msg_combo), cell, "text", 0, NULL); g_object_unref (store); gtk_widget_show_all (dialog); g_list_foreach(plugin->svn_commit_logs, subversion_commit_dialog_populate_logs, commit_prev_msg_combo); gtk_combo_box_set_active(GTK_COMBO_BOX(commit_prev_msg_combo), 0); }
static VALUE rg_clear(VALUE self) { gtk_cell_layout_clear(_SELF(self)); return self; }
void empathy_account_widget_irc_build (EmpathyAccountWidget *self, const char *filename, GtkWidget **table_common_settings) { EmpathyAccountWidgetIrc *settings; gchar *dir, *user_file_with_path, *global_file_with_path; GtkListStore *store; GtkCellRenderer *renderer; settings = g_slice_new0 (EmpathyAccountWidgetIrc); settings->self = self; dir = g_build_filename (g_get_user_config_dir (), PACKAGE_NAME, NULL); g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR); user_file_with_path = g_build_filename (dir, IRC_NETWORKS_FILENAME, NULL); g_free (dir); global_file_with_path = g_build_filename (g_getenv ("EMPATHY_SRCDIR"), "libempathy-gtk", IRC_NETWORKS_FILENAME, NULL); if (!g_file_test (global_file_with_path, G_FILE_TEST_EXISTS)) { g_free (global_file_with_path); global_file_with_path = g_build_filename (DATADIR, "empathy", IRC_NETWORKS_FILENAME, NULL); } settings->network_manager = empathy_irc_network_manager_new ( global_file_with_path, user_file_with_path); g_free (global_file_with_path); g_free (user_file_with_path); self->ui_details->gui = empathy_builder_get_file (filename, "table_irc_settings", table_common_settings, "vbox_irc", &self->ui_details->widget, "table_irc_settings", &settings->vbox_settings, "combobox_network", &settings->combobox_network, NULL); /* Fill the networks combobox */ store = gtk_list_store_new (2, G_TYPE_OBJECT, G_TYPE_STRING); gtk_cell_layout_clear (GTK_CELL_LAYOUT (settings->combobox_network)); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (settings->combobox_network), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (settings->combobox_network), renderer, "text", COL_NETWORK_NAME, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), COL_NETWORK_NAME, GTK_SORT_ASCENDING); gtk_combo_box_set_model (GTK_COMBO_BOX (settings->combobox_network), GTK_TREE_MODEL (store)); g_object_unref (store); account_widget_irc_setup (settings); empathy_account_widget_handle_params (self, "entry_nick", "account", "entry_fullname", "fullname", "entry_password", "password", "entry_quit_message", "quit-message", NULL); empathy_builder_connect (self->ui_details->gui, settings, "table_irc_settings", "destroy", account_widget_irc_destroy_cb, "button_network", "clicked", account_widget_irc_button_edit_network_clicked_cb, "button_add_network", "clicked", account_widget_irc_button_add_network_clicked_cb, "button_remove_network", "clicked", account_widget_irc_button_remove_clicked_cb, "combobox_network", "changed", account_widget_irc_combobox_network_changed_cb, NULL); self->ui_details->default_focus = g_strdup ("entry_nick"); }
void caja_autorun_prepare_combo_box (GtkWidget *combo_box, const char *x_content_type, gboolean include_ask, gboolean include_open_with_other_app, gboolean update_settings, CajaAutorunComboBoxChanged changed_cb, gpointer user_data) { GList *l; GList *app_info_list; GAppInfo *default_app_info; GtkListStore *list_store; GtkTreeIter iter; GdkPixbuf *pixbuf; int icon_size; int set_active; int n; int num_apps; gboolean pref_ask; gboolean pref_start_app; gboolean pref_ignore; gboolean pref_open_folder; CajaAutorunComboBoxData *data; GtkCellRenderer *renderer; gboolean new_data; caja_autorun_get_preferences (x_content_type, &pref_start_app, &pref_ignore, &pref_open_folder); pref_ask = !pref_start_app && !pref_ignore && !pref_open_folder; icon_size = caja_get_icon_size_for_stock_size (GTK_ICON_SIZE_MENU); set_active = -1; data = NULL; new_data = TRUE; app_info_list = g_app_info_get_all_for_type (x_content_type); default_app_info = g_app_info_get_default_for_type (x_content_type, FALSE); num_apps = g_list_length (app_info_list); list_store = gtk_list_store_new (5, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_APP_INFO, G_TYPE_STRING, G_TYPE_INT); /* no apps installed */ if (num_apps == 0) { gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), GTK_STOCK_DIALOG_ERROR, icon_size, 0, NULL); /* TODO: integrate with PackageKit-mate to find applications */ gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("No applications found"), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_ASK, -1); g_object_unref (pixbuf); } else { if (include_ask) { gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), GTK_STOCK_DIALOG_QUESTION, icon_size, 0, NULL); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("Ask what to do"), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_ASK, -1); g_object_unref (pixbuf); } gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), GTK_STOCK_CLOSE, icon_size, 0, NULL); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("Do Nothing"), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_IGNORE, -1); g_object_unref (pixbuf); gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "folder-open", icon_size, 0, NULL); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("Open Folder"), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_OPEN_FOLDER, -1); g_object_unref (pixbuf); gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, NULL, COLUMN_AUTORUN_NAME, NULL, COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, NULL, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_SEP, -1); for (l = app_info_list, n = include_ask ? 4 : 3; l != NULL; l = l->next, n++) { GIcon *icon; CajaIconInfo *icon_info; char *open_string; GAppInfo *app_info = l->data; /* we deliberately ignore should_show because some apps might want * to install special handlers that should be hidden in the regular * application launcher menus */ icon = g_app_info_get_icon (app_info); icon_info = caja_icon_info_lookup (icon, icon_size); pixbuf = caja_icon_info_get_pixbuf_at_size (icon_info, icon_size); g_object_unref (icon_info); open_string = g_strdup_printf (_("Open %s"), g_app_info_get_display_name (app_info)); gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, open_string, COLUMN_AUTORUN_APP_INFO, app_info, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_APP, -1); if (pixbuf != NULL) { g_object_unref (pixbuf); } g_free (open_string); if (g_app_info_equal (app_info, default_app_info)) { set_active = n; } } } if (include_open_with_other_app) { gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, NULL, COLUMN_AUTORUN_NAME, NULL, COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, NULL, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_SEP, -1); gtk_list_store_append (list_store, &iter); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "application-x-executable", icon_size, 0, NULL); gtk_list_store_set (list_store, &iter, COLUMN_AUTORUN_PIXBUF, pixbuf, COLUMN_AUTORUN_NAME, _("Open with other Application..."), COLUMN_AUTORUN_APP_INFO, NULL, COLUMN_AUTORUN_X_CONTENT_TYPE, x_content_type, COLUMN_AUTORUN_ITEM_TYPE, AUTORUN_OTHER_APP, -1); g_object_unref (pixbuf); } if (default_app_info != NULL) { g_object_unref (default_app_info); } g_list_foreach (app_info_list, (GFunc) g_object_unref, NULL); g_list_free(app_info_list); gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (list_store)); g_object_unref (G_OBJECT (list_store)); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo_box)); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer, "pixbuf", COLUMN_AUTORUN_PIXBUF, NULL); 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", COLUMN_AUTORUN_NAME, NULL); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo_box), combo_box_separator_func, NULL, NULL); if (num_apps == 0) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0); gtk_widget_set_sensitive (combo_box, FALSE); } else { gtk_widget_set_sensitive (combo_box, TRUE); if (pref_ask && include_ask) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0); } else if (pref_ignore) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), include_ask ? 1 : 0); } else if (pref_open_folder) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), include_ask ? 2 : 1); } else if (set_active != -1) { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), set_active); } else { gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), include_ask ? 1 : 0); } /* See if we have an old data around */ data = g_object_get_data (G_OBJECT (combo_box), "caja_autorun_combobox_data"); if (data) { new_data = FALSE; g_free (data->x_content_type); } else { data = g_new0 (CajaAutorunComboBoxData, 1); } data->x_content_type = g_strdup (x_content_type); data->include_ask = include_ask; data->include_open_with_other_app = include_open_with_other_app; data->update_settings = update_settings; data->changed_cb = changed_cb; data->user_data = user_data; data->combo_box = combo_box; if (data->changed_signal_id == 0) { data->changed_signal_id = g_signal_connect (G_OBJECT (combo_box), "changed", G_CALLBACK (combo_box_changed), data); } } if (new_data) { g_object_set_data_full (G_OBJECT (combo_box), "caja_autorun_combobox_data", data, (GDestroyNotify) caja_autorun_combobox_data_destroy); } }
static void finish_setup (CEPageSecurity *page) { NMConnection *connection = CE_PAGE (page)->connection; NMSettingWireless *sw; NMSettingWirelessSecurity *sws; gboolean is_adhoc = FALSE; GtkListStore *sec_model; GtkTreeIter iter; const gchar *mode; const gchar *security; guint32 dev_caps = 0; NMUtilsSecurityType default_type = NMU_SEC_NONE; int active = -1; int item = 0; GtkComboBox *combo; GtkCellRenderer *renderer; sw = nm_connection_get_setting_wireless (connection); g_assert (sw); page->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); page->security_heading = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "heading_sec")); page->security_combo = combo = GTK_COMBO_BOX (gtk_builder_get_object (CE_PAGE (page)->builder, "combo_sec")); dev_caps = NM_WIFI_DEVICE_CAP_CIPHER_WEP40 | NM_WIFI_DEVICE_CAP_CIPHER_WEP104 | NM_WIFI_DEVICE_CAP_CIPHER_TKIP | NM_WIFI_DEVICE_CAP_CIPHER_CCMP | NM_WIFI_DEVICE_CAP_WPA | NM_WIFI_DEVICE_CAP_RSN; mode = nm_setting_wireless_get_mode (sw); if (mode && !strcmp (mode, "adhoc")) is_adhoc = TRUE; page->adhoc = is_adhoc; sws = nm_connection_get_setting_wireless_security (connection); security = nm_setting_wireless_get_security (sw); if (!security || strcmp (security, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME) != 0) sws = NULL; if (sws) default_type = get_default_type_for_security (sws); sec_model = gtk_list_store_new (3, G_TYPE_STRING, wireless_security_get_g_type (), G_TYPE_BOOLEAN); if (nm_utils_security_valid (NMU_SEC_NONE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { gtk_list_store_insert_with_values (sec_model, &iter, -1, S_NAME_COLUMN, C_("Wi-Fi/Ethernet security", "None"), S_ADHOC_VALID_COLUMN, TRUE, -1); if (default_type == NMU_SEC_NONE) active = item; item++; } if (nm_utils_security_valid (NMU_SEC_STATIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityWEPKey *ws_wep; NMWepKeyType wep_type = NM_WEP_KEY_TYPE_KEY; if (default_type == NMU_SEC_STATIC_WEP) { sws = nm_connection_get_setting_wireless_security (connection); if (sws) wep_type = nm_setting_wireless_security_get_wep_key_type (sws); if (wep_type == NM_WEP_KEY_TYPE_UNKNOWN) wep_type = NM_WEP_KEY_TYPE_KEY; } ws_wep = ws_wep_key_new (connection, NM_WEP_KEY_TYPE_KEY, FALSE, FALSE); if (ws_wep) { add_security_item (page, WIRELESS_SECURITY (ws_wep), sec_model, &iter, _("WEP 40/128-bit Key (Hex or ASCII)"), TRUE); if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_KEY)) active = item; item++; } ws_wep = ws_wep_key_new (connection, NM_WEP_KEY_TYPE_PASSPHRASE, FALSE, FALSE); if (ws_wep) { add_security_item (page, WIRELESS_SECURITY (ws_wep), sec_model, &iter, _("WEP 128-bit Passphrase"), TRUE); if ((active < 0) && (default_type == NMU_SEC_STATIC_WEP) && (wep_type == NM_WEP_KEY_TYPE_PASSPHRASE)) active = item; item++; } } if (nm_utils_security_valid (NMU_SEC_LEAP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityLEAP *ws_leap; ws_leap = ws_leap_new (connection, FALSE); if (ws_leap) { add_security_item (page, WIRELESS_SECURITY (ws_leap), sec_model, &iter, _("LEAP"), FALSE); if ((active < 0) && (default_type == NMU_SEC_LEAP)) active = item; item++; } } if (nm_utils_security_valid (NMU_SEC_DYNAMIC_WEP, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityDynamicWEP *ws_dynamic_wep; ws_dynamic_wep = ws_dynamic_wep_new (connection, TRUE, FALSE); if (ws_dynamic_wep) { add_security_item (page, WIRELESS_SECURITY (ws_dynamic_wep), sec_model, &iter, _("Dynamic WEP (802.1x)"), FALSE); if ((active < 0) && (default_type == NMU_SEC_DYNAMIC_WEP)) active = item; item++; } } if (nm_utils_security_valid (NMU_SEC_WPA_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0) || nm_utils_security_valid (NMU_SEC_WPA2_PSK, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityWPAPSK *ws_wpa_psk; ws_wpa_psk = ws_wpa_psk_new (connection, FALSE); if (ws_wpa_psk) { add_security_item (page, WIRELESS_SECURITY (ws_wpa_psk), sec_model, &iter, _("WPA & WPA2 Personal"), FALSE); if ((active < 0) && ((default_type == NMU_SEC_WPA_PSK) || (default_type == NMU_SEC_WPA2_PSK))) active = item; item++; } } if (nm_utils_security_valid (NMU_SEC_WPA_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0) || nm_utils_security_valid (NMU_SEC_WPA2_ENTERPRISE, dev_caps, FALSE, is_adhoc, 0, 0, 0)) { WirelessSecurityWPAEAP *ws_wpa_eap; ws_wpa_eap = ws_wpa_eap_new (connection, TRUE, FALSE); if (ws_wpa_eap) { add_security_item (page, WIRELESS_SECURITY (ws_wpa_eap), sec_model, &iter, _("WPA & WPA2 Enterprise"), FALSE); if ((active < 0) && ((default_type == NMU_SEC_WPA_ENTERPRISE) || (default_type == NMU_SEC_WPA2_ENTERPRISE))) active = item; item++; } } gtk_combo_box_set_model (combo, GTK_TREE_MODEL (sec_model)); gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo)); 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", S_NAME_COLUMN, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), renderer, set_sensitive, &page->adhoc, NULL); gtk_combo_box_set_active (combo, active < 0 ? 0 : (guint32) active); g_object_unref (G_OBJECT (sec_model)); page->security_combo = combo; security_combo_changed (combo, page); g_signal_connect (combo, "changed", G_CALLBACK (security_combo_changed), page); }
static void gimp_scale_combo_box_constructed (GObject *object) { GimpScaleComboBox *combo_box = GIMP_SCALE_COMBO_BOX (object); GtkWidget *entry; GtkListStore *store; GtkCellLayout *layout; GtkCellRenderer *cell; GtkTreeIter iter; GtkBorder border = { 0, 0, 0, 0 }; gint i; G_OBJECT_CLASS (parent_class)->constructed (object); store = gtk_list_store_new (N_COLUMNS, G_TYPE_DOUBLE, /* SCALE */ G_TYPE_STRING, /* LABEL */ G_TYPE_BOOLEAN); /* PERSISTENT */ gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store)); g_object_unref (store); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (combo_box), COLUMN_LABEL); entry = gtk_bin_get_child (GTK_BIN (combo_box)); g_object_set (entry, "xalign", 1.0, "width-chars", 7, "truncate-multiline", TRUE, "inner-border", &border, NULL); layout = GTK_CELL_LAYOUT (combo_box); cell = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "xalign", 1.0, NULL); gtk_cell_layout_clear (layout); gtk_cell_layout_pack_start (layout, cell, TRUE); gtk_cell_layout_set_attributes (layout, cell, "text", COLUMN_LABEL, NULL); for (i = 8; i > 0; i /= 2) { gtk_list_store_append (store, &iter); gimp_scale_combo_box_scale_iter_set (store, &iter, i, TRUE); } for (i = 2; i <= 8; i *= 2) { gtk_list_store_append (store, &iter); gimp_scale_combo_box_scale_iter_set (store, &iter, 1.0 / i, TRUE); } g_signal_connect (combo_box, "changed", G_CALLBACK (gimp_scale_combo_box_changed), NULL); g_signal_connect (entry, "activate", G_CALLBACK (gimp_scale_combo_box_entry_activate), combo_box); g_signal_connect (entry, "key-press-event", G_CALLBACK (gimp_scale_combo_box_entry_key_press), combo_box); }