void ToolPageLayer::setLayerCount(int layer, int selected) { XOJ_CHECK_TYPE(ToolPageLayer); this->inCbUpdate = true; int count = gtk_tree_model_iter_n_children(gtk_combo_box_get_model(GTK_COMBO_BOX(this->layerComboBox)), NULL); for (int i = count - 1; i >= 0; i--) { gtk_combo_box_remove_text(GTK_COMBO_BOX(this->layerComboBox), i); } gtk_combo_box_append_text(GTK_COMBO_BOX(this->layerComboBox), _C("Background")); for (int i = 1; i <= layer; i++) { string text = FS(_F("Layer {1}") % i); gtk_combo_box_prepend_text(GTK_COMBO_BOX(this->layerComboBox), text.c_str()); } setSelectedLayer(selected); this->layerCount = layer; this->inCbUpdate = false; }
void wififriend_scan_network(GtkWidget* Widget, gpointer Data) { DWORD Error = ERROR_SUCCESS; PWLAN_AVAILABLE_NETWORK_LIST Network = NULL; t_wifi St; int I; GtkWidget *WinScan = NULL; GtkWidget *ListOfWifi = NULL; I = 1; St = wififriend_create_handle(); St = wififriend_retrieve_config(St); if((WlanGetAvailableNetworkList(St.MyHandle, &St.MyGuid, 0x00000001, NULL, &Network)) != ERROR_SUCCESS) error_scan(0); else { WinScan = create_window(236, 27, "Wifi scan"); ListOfWifi = gtk_combo_box_new_text(); while(I != Network->dwNumberOfItems) { gtk_combo_box_prepend_text(GTK_COMBO_BOX(ListOfWifi), (const gchar *)Network->Network[I].dot11Ssid.ucSSID); I++; } gtk_combo_box_set_active(GTK_COMBO_BOX(ListOfWifi), 0); gtk_container_add(GTK_CONTAINER(WinScan), ListOfWifi); g_signal_connect(G_OBJECT(ListOfWifi), "changed", G_CALLBACK(wififriend_connect_to_unsecure_network), (gpointer)ListOfWifi); display_interface(WinScan); WlanCloseHandle(St.MyHandle, NULL); } }
void combo_box_prepend_text (gpointer p, const gchar *s) { #if GTK_MAJOR_VERSION >= 3 gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(p), s); #else gtk_combo_box_prepend_text(GTK_COMBO_BOX(p), s); #endif }
/* Put an allocated string on the history list and combo text list | if it is not a duplicate. The history_list is just a shadow of the | combo list, but I think is needed because I don't see an api for reading | the combo strings. The combo box strings take "const gchar *", so the | same allocated string can go in both the history list and the combo list. | If removed from both lists, a string can be freed. */ static void command_history_add (gchar * cmd) { GList *list; gchar *s; gint i; if (!cmd || !*cmd) return; /* Check for a duplicate command. If found, move it to the | top of the list and similarly modify the combo box strings. */ for (i = 0, list = history_list; list; list = list->next, ++i) { s = (gchar *) list->data; if (!strcmp (cmd, s)) { history_list = g_list_remove (history_list, s); history_list = g_list_prepend (history_list, s); gtk_combo_box_remove_text (GTK_COMBO_BOX (ghidgui->command_combo_box), i); gtk_combo_box_prepend_text (GTK_COMBO_BOX (ghidgui->command_combo_box), s); return; } } /* Not a duplicate, so put first in history list and combo box text list. */ s = g_strdup (cmd); history_list = g_list_prepend (history_list, s); gtk_combo_box_prepend_text (GTK_COMBO_BOX (ghidgui->command_combo_box), s); /* And keep the lists trimmed! */ if (g_list_length (history_list) > ghidgui->history_size) { s = (gchar *) g_list_nth_data (history_list, ghidgui->history_size); history_list = g_list_remove (history_list, s); gtk_combo_box_remove_text (GTK_COMBO_BOX (ghidgui->command_combo_box), ghidgui->history_size); g_free (s); } }
int clip_GTK_COMBOBOXPREPENDTEXT(ClipMachine * cm) { C_widget *ccmb = _fetch_cw_arg(cm); gchar *text = _clip_parc(cm, 2); CHECKCWID(ccmb,GTK_IS_COMBO_BOX); CHECKARG(2, CHARACTER_t); LOCALE_TO_UTF(text); gtk_combo_box_prepend_text(GTK_COMBO_BOX(ccmb->widget), text); FREE_TEXT(text); return 0; err: return 1; }
static void gui_hlp_combo_box_prepend_text_or_set_active (GtkComboBox *combobox, const gchar *text, gboolean force_active) { str_cmp_data scd; GtkTreeModel *model = gtk_combo_box_get_model(combobox); scd.str = text; scd.success = FALSE; scd.combobox = combobox; gtk_tree_model_foreach(model, str_cmp_func, &scd); if(!scd.success) { gtk_combo_box_prepend_text(combobox, text); if(force_active) gtk_combo_box_set_active(combobox, 0); } }
static void init_color_scheme_menu (GtkWidget *combo_box) { #if GTK_CHECK_VERSION(3, 0, 0) GtkCellRenderer *renderer; GtkTreeIter iter; GtkListStore *store; int i; store = gtk_list_store_new (1, G_TYPE_STRING); for (i = 0; i < G_N_ELEMENTS (color_schemes); ++i) gtk_list_store_insert_with_values (store, &iter, -1, 0, _(color_schemes[i].name), -1); gtk_list_store_insert_with_values (store, &iter, -1, 0, _("Custom"), -1); gtk_combo_box_set_model (GTK_COMBO_BOX (combo_box), GTK_TREE_MODEL (store)); g_object_unref (store); 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); #else int i; i = G_N_ELEMENTS (color_schemes); while (i > 0) { gtk_combo_box_prepend_text (GTK_COMBO_BOX (combo_box), _(color_schemes[--i].name)); } #endif }
static void populate_ui (CEPageWired *self) { CEPageWiredPrivate *priv = CE_PAGE_WIRED_GET_PRIVATE (self); NMSettingWired *setting = priv->setting; const char *port; const char *duplex; int port_idx = PORT_DEFAULT; int speed_idx; int mtu_def; char **mac_list, **iter; const GByteArray *s_mac; char *s_mac_str; char *active_mac = NULL; GtkWidget *entry; /* Port */ port = nm_setting_wired_get_port (setting); if (port) { if (!strcmp (port, "tp")) port_idx = PORT_TP; else if (!strcmp (port, "aui")) port_idx = PORT_AUI; else if (!strcmp (port, "bnc")) port_idx = PORT_BNC; else if (!strcmp (port, "mii")) port_idx = PORT_MII; } gtk_combo_box_set_active (priv->port, port_idx); /* Speed */ switch (nm_setting_wired_get_speed (setting)) { case 10: speed_idx = SPEED_10; break; case 100: speed_idx = SPEED_100; break; case 1000: speed_idx = SPEED_1000; break; case 10000: speed_idx = SPEED_10000; break; default: speed_idx = SPEED_DEFAULT; break; } gtk_combo_box_set_active (priv->speed, speed_idx); /* Duplex */ duplex = nm_setting_wired_get_duplex (setting); if (duplex && !strcmp (duplex, "half")) gtk_toggle_button_set_active (priv->duplex, FALSE); else gtk_toggle_button_set_active (priv->duplex, TRUE); /* Autonegotiate */ gtk_toggle_button_set_active (priv->autonegotiate, nm_setting_wired_get_auto_negotiate (setting)); /* Device MAC address */ mac_list = ce_page_get_mac_list (CE_PAGE (self)); s_mac = nm_setting_wired_get_mac_address (setting); s_mac_str = s_mac ? g_strdup_printf ("%02X:%02X:%02X:%02X:%02X:%02X", s_mac->data[0], s_mac->data[1], s_mac->data[2], s_mac->data[3], s_mac->data[4], s_mac->data[5]): NULL; for (iter = mac_list; iter && *iter; iter++) { #if GTK_CHECK_VERSION (2,24,0) gtk_combo_box_text_append_text (priv->device_mac, *iter); #else gtk_combo_box_append_text (GTK_COMBO_BOX (priv->device_mac), *iter); #endif if (s_mac_str && g_ascii_strncasecmp (*iter, s_mac_str, 17) == 0) active_mac = *iter; } if (s_mac_str) { if (!active_mac) { #if GTK_CHECK_VERSION (2,24,0) gtk_combo_box_text_prepend_text (priv->device_mac, s_mac_str); #else gtk_combo_box_prepend_text (GTK_COMBO_BOX (priv->device_mac), s_mac_str); #endif } entry = gtk_bin_get_child (GTK_BIN (priv->device_mac)); if (entry) gtk_entry_set_text (GTK_ENTRY (entry), active_mac ? active_mac : s_mac_str); } g_strfreev (mac_list); g_signal_connect (priv->device_mac, "changed", G_CALLBACK (stuff_changed), self); /* Cloned MAC address */ ce_page_mac_to_entry (nm_setting_wired_get_cloned_mac_address (setting), priv->cloned_mac); g_signal_connect (priv->cloned_mac, "changed", G_CALLBACK (stuff_changed), self); /* MTU */ mtu_def = ce_get_property_default (NM_SETTING (setting), NM_SETTING_WIRED_MTU); g_signal_connect (priv->mtu, "output", G_CALLBACK (ce_spin_output_with_default), GINT_TO_POINTER (mtu_def)); gtk_spin_button_set_value (priv->mtu, (gdouble) nm_setting_wired_get_mtu (setting)); }
static void gmdb_sql_execute_cb(GtkWidget *w, GladeXML *xml) { guint len; gchar *buf; gchar *bound_data[256]; int i; MdbSQLColumn *sqlcol; GtkTextBuffer *txtbuffer; GtkTextIter start, end; GtkWidget *textview, *combobox, *treeview; GtkTreeModel *store; /*GtkWidget *window;*/ GType *gtypes; GtkTreeIter iter; GtkTreeViewColumn *column; long row, maxrow; /* GdkCursor *watch, *pointer; */ /* need to figure out how to clock during the treeview recalc/redraw window = glade_xml_get_widget(xml, "sql_window"); watch = gdk_cursor_new(GDK_WATCH); gdk_window_set_cursor(GTK_WIDGET(window)->window, watch); gdk_cursor_unref(watch); */ /* stuff this query on the history */ textview = glade_xml_get_widget(xml, "sql_textview"); combobox = glade_xml_get_widget(xml, "sql_combo"); txtbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview)); len = gtk_text_buffer_get_char_count(txtbuffer); gtk_text_buffer_get_iter_at_offset (txtbuffer, &start, 0); gtk_text_buffer_get_iter_at_offset (txtbuffer, &end, len); buf = gtk_text_buffer_get_text(txtbuffer, &start, &end, FALSE); /* add to the history */ gtk_combo_box_prepend_text(GTK_COMBO_BOX(combobox), buf); gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), 0); /* ok now execute it */ mdb_sql_run_query(sql, buf); if (mdb_sql_has_error(sql)) { GtkWidget* dlg = gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (w)), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "%s", mdb_sql_last_error(sql)); gtk_dialog_run (GTK_DIALOG (dlg)); gtk_widget_destroy (dlg); mdb_sql_reset(sql); return; } treeview = glade_xml_get_widget(xml, "sql_results"); gtypes = g_malloc(sizeof(GType) * sql->num_columns); for (i=0;i<sql->num_columns;i++) gtypes[i]=G_TYPE_STRING; store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)); if (store) { while ((column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 0))) { gtk_tree_view_remove_column(GTK_TREE_VIEW(treeview), column); } g_object_unref(store); } store = (GtkTreeModel*)gtk_list_store_newv(sql->num_columns, gtypes); g_free(gtypes); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), store); GtkCellRenderer *renderer; renderer = gtk_cell_renderer_text_new(); for (i=0;i<sql->num_columns;i++) { bound_data[i] = (char *) g_malloc0(MDB_BIND_SIZE); mdb_sql_bind_column(sql, i+1, bound_data[i], NULL); sqlcol = g_ptr_array_index(sql->columns,i); column = gtk_tree_view_column_new_with_attributes(sqlcol->name, renderer, "text", i, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (treeview), column); } maxrow = gmdb_prefs_get_maxrows(); row = 0; while(mdb_fetch_row(sql->cur_table) && (!maxrow || (row < maxrow))) { row++; gtk_list_store_append(GTK_LIST_STORE(store), &iter); for (i=0;i<sql->num_columns;i++) { gtk_list_store_set(GTK_LIST_STORE(store), &iter, i, (gchar *) bound_data[i], -1); } } /* free the memory used to bind */ for (i=0;i<sql->num_columns;i++) { g_free(bound_data[i]); } mdb_sql_reset(sql); g_free(buf); /* pointer = gdk_cursor_new(GDK_LEFT_PTR); gdk_window_set_cursor(GTK_WIDGET(window)->window, pointer); gdk_cursor_unref(pointer); */ }
GtkWidget * entry_create_widget (GtkWidget * dlg) { GtkWidget *c, *l = NULL, *w = NULL; #if !GTK_CHECK_VERSION(3,0,0) w = gtk_hbox_new (FALSE, 5); #else w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); #endif if (options.entry_data.entry_label) { l = gtk_label_new (NULL); if (options.data.no_markup) gtk_label_set_text_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label); else gtk_label_set_markup_with_mnemonic (GTK_LABEL (l), options.entry_data.entry_label); gtk_widget_set_name (l, "yad-entry-label"); gtk_box_pack_start (GTK_BOX (w), l, FALSE, FALSE, 1); } if (options.entry_data.numeric) { gdouble min, max, step, val; guint prec; min = 0.0; max = 65535.0; step = 1.0; prec = 0; if (options.extra_data && options.extra_data[0]) { min = g_ascii_strtod (options.extra_data[0], NULL); if (options.extra_data[1]) max = g_ascii_strtod (options.extra_data[1], NULL); if (options.extra_data[2]) step = g_ascii_strtod (options.extra_data[2], NULL); if (options.extra_data[3]) { prec = (guint) g_ascii_strtoull (options.extra_data[3], NULL, 0); if (prec > 20) prec = 20; } } c = entry = gtk_spin_button_new_with_range (min, max, step); gtk_entry_set_alignment (GTK_ENTRY (c), 1.0); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (c), prec); gtk_widget_set_name (entry, "yad-entry-spin"); if (options.entry_data.entry_text) { val = g_ascii_strtod (options.entry_data.entry_text, NULL); if (min >= max) { g_printerr (_("Maximum value must be greater than minimum value.\n")); min = 0.0; max = 65535.0; } if (val < min) { g_printerr (_("Initial value less than minimal.\n")); val = min; } else if (val > max) { g_printerr (_("Initial value greater than maximum.\n")); val = max; } gtk_spin_button_set_value (GTK_SPIN_BUTTON (c), val); } } else if (!options.entry_data.completion && options.extra_data && *options.extra_data) { gint active, i; if (options.common_data.editable || settings.combo_always_editable) { #if GTK_CHECK_VERSION(2,24,0) c = gtk_combo_box_text_new_with_entry (); #else c = gtk_combo_box_entry_new_text (); #endif gtk_widget_set_name (c, "yad-entry-edit-combo"); entry = gtk_bin_get_child (GTK_BIN (c)); if (options.entry_data.licon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb); } if (options.entry_data.ricon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb); } } else { #if GTK_CHECK_VERSION(2,24,0) c = entry = gtk_combo_box_text_new (); #else c = entry = gtk_combo_box_new_text (); #endif gtk_widget_set_name (c, "yad-entry-combo"); is_combo = TRUE; } i = 0; active = -1; while (options.extra_data[i] != NULL) { if (options.entry_data.entry_text && g_ascii_strcasecmp (options.extra_data[i], options.entry_data.entry_text) == 0) active = i; #if GTK_CHECK_VERSION(2,24,0) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (c), options.extra_data[i]); #else gtk_combo_box_append_text (GTK_COMBO_BOX (c), options.extra_data[i]); #endif i++; } if (options.entry_data.entry_text && active == -1) { #if GTK_CHECK_VERSION(2,24,0) gtk_combo_box_text_prepend_text (GTK_COMBO_BOX_TEXT (c), options.entry_data.entry_text); #else gtk_combo_box_prepend_text (GTK_COMBO_BOX (c), options.entry_data.entry_text); #endif } /* set first iter active */ if (!options.common_data.editable) gtk_combo_box_set_active (GTK_COMBO_BOX (c), (active != -1 ? active : 0)); } else { c = entry = gtk_entry_new (); gtk_widget_set_name (c, "yad-entry-widget"); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); if (options.entry_data.entry_text) gtk_entry_set_text (GTK_ENTRY (entry), options.entry_data.entry_text); if (options.entry_data.hide_text) g_object_set (G_OBJECT (entry), "visibility", FALSE, NULL); if (options.entry_data.completion) { GtkEntryCompletion *completion; GtkTreeModel *completion_model; completion = gtk_entry_completion_new (); gtk_entry_set_completion (GTK_ENTRY (entry), completion); completion_model = create_completion_model (); gtk_entry_completion_set_model (completion, completion_model); g_object_unref (completion_model); gtk_entry_completion_set_text_column (completion, 0); g_object_unref (completion); } if (options.entry_data.licon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.licon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_PRIMARY, pb); } if (options.entry_data.ricon) { GdkPixbuf *pb = get_pixbuf (options.entry_data.ricon, YAD_SMALL_ICON); if (pb) gtk_entry_set_icon_from_pixbuf (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, pb); } } if (l) gtk_label_set_mnemonic_widget (GTK_LABEL (l), entry); if (!is_combo) g_signal_connect (G_OBJECT (entry), "activate", G_CALLBACK (entry_activate_cb), dlg); else g_signal_connect (G_OBJECT (entry), "key-press-event", G_CALLBACK (combo_activate_cb), dlg); if (options.entry_data.licon || options.entry_data.ricon) g_signal_connect (G_OBJECT (entry), "icon-press", G_CALLBACK (icon_cb), NULL); gtk_box_pack_start (GTK_BOX (w), c, TRUE, TRUE, 1); return w; }
void gtk_combo_box_text_prepend_text (GtkComboBoxText *combo_box, const gchar *text) { gtk_combo_box_prepend_text (combo_box, text); }
static VALUE rg_prepend_text(VALUE self, VALUE text) { gtk_combo_box_prepend_text(_SELF(self), RVAL2CSTR(text)); return self; }
void matedialog_entry (MateDialogData *data, MateDialogEntryData *entry_data) { GtkBuilder *builder = NULL; GtkWidget *dialog; GObject *text; GSList *entries = NULL; GSList *tmp; GObject *vbox; builder = matedialog_util_load_ui_file ("matedialog_entry_dialog", NULL); if (builder == NULL) { data->exit_code = matedialog_util_return_exit_code (MATEDIALOG_ERROR); return; } gtk_builder_connect_signals (builder, NULL); dialog = GTK_WIDGET (gtk_builder_get_object (builder, "matedialog_entry_dialog")); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (matedialog_entry_dialog_response), data); if (data->dialog_title) gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title); matedialog_util_set_window_icon (dialog, data->window_icon, MATEDIALOG_IMAGE_FULLPATH ("matedialog-entry.png")); if (data->width > -1 || data->height > -1) gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height); text = gtk_builder_get_object (builder, "matedialog_entry_text"); if (entry_data->dialog_text) gtk_label_set_text_with_mnemonic (GTK_LABEL (text), g_strcompress (entry_data->dialog_text)); vbox = gtk_builder_get_object (builder, "vbox4"); matedialog_entry_fill_entries(&entries, entry_data->data); n_entries = g_slist_length (entries); if (n_entries > 1) { #if GTK_CHECK_VERSION(2,24,0) entry = gtk_combo_box_text_new_with_entry (); #else entry = gtk_combo_box_entry_new_text (); #endif for (tmp = entries; tmp; tmp = tmp->next) { #if GTK_CHECK_VERSION(2,24,0) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (entry), tmp->data); #else gtk_combo_box_append_text (GTK_COMBO_BOX (entry), tmp->data); #endif } if (entry_data->entry_text) { #if GTK_CHECK_VERSION(2,24,0) gtk_combo_box_text_prepend_text (GTK_COMBO_BOX_TEXT (entry), entry_data->entry_text); #else gtk_combo_box_prepend_text (GTK_COMBO_BOX (entry), entry_data->entry_text); #endif gtk_combo_box_set_active (GTK_COMBO_BOX (entry), 0); } g_signal_connect (gtk_bin_get_child (GTK_BIN (entry)), "activate", G_CALLBACK (matedialog_entry_combo_activate_default), GTK_WINDOW (dialog)); } else { entry = gtk_entry_new(); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); if (entry_data->entry_text) gtk_entry_set_text (GTK_ENTRY (entry), entry_data->entry_text); if (entry_data->hide_text) g_object_set (G_OBJECT (entry), "visibility", FALSE, NULL); } gtk_widget_show (entry); gtk_box_pack_end (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (text), entry); g_object_unref (builder); matedialog_util_show_dialog (dialog); if(data->timeout_delay > 0) { g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) matedialog_util_timeout_handle, NULL); } gtk_main (); }
static SCM gnc_style_sheet_new (StyleSheetDialog * ssd) { SCM make_ss = scm_c_eval_string("gnc:make-html-style-sheet"); SCM templates = scm_c_eval_string("(gnc:get-html-templates)"); SCM t_name = scm_c_eval_string("gnc:html-style-sheet-template-name"); SCM new_ss = SCM_BOOL_F; GtkWidget * template_combo; GtkTreeModel * template_model; GtkWidget * name_entry; gint dialog_retval; GList *template_names = NULL; /* get the new name for the style sheet */ GladeXML *xml = gnc_glade_xml_new ("report.glade", "New Style Sheet Dialog"); GtkWidget * dlg = glade_xml_get_widget (xml, "New Style Sheet Dialog"); template_combo = glade_xml_get_widget (xml, "template_combobox"); name_entry = glade_xml_get_widget (xml, "name_entry"); g_assert(ssd); /* Erase the initial dummy entry. */ template_model = gtk_combo_box_get_model(GTK_COMBO_BOX(template_combo)); gtk_list_store_clear(GTK_LIST_STORE(template_model)); /* put in the list of style sheet type names */ for (; !scm_is_null(templates); templates = SCM_CDR(templates)) { char * str; const char* orig_name; SCM t = SCM_CAR(templates); scm_dynwind_begin (0); str = scm_to_locale_string (scm_call_1(t_name, t)); orig_name = g_strdup (str); scm_dynwind_free (str); scm_dynwind_end (); /* Store the untranslated names for lookup later */ template_names = g_list_prepend (template_names, (gpointer)orig_name); /* The displayed name should be translated */ gtk_combo_box_prepend_text(GTK_COMBO_BOX(template_combo), _(orig_name)); } gtk_combo_box_set_active(GTK_COMBO_BOX(template_combo), 0); /* get the name */ gtk_window_set_transient_for (GTK_WINDOW(dlg), GTK_WINDOW(ssd->toplevel)); dialog_retval = gtk_dialog_run(GTK_DIALOG(dlg)); if (dialog_retval == GTK_RESPONSE_OK) { gint choice = gtk_combo_box_get_active (GTK_COMBO_BOX(template_combo)); const char *template_str = g_list_nth_data (template_names, choice); const char *name_str = gtk_entry_get_text(GTK_ENTRY(name_entry)); if (name_str && strlen(name_str) == 0) { /* If the name is empty, we display an error dialog but * refuse to create the new style sheet. */ gnc_error_dialog (ssd->toplevel, "%s", _("You must provide a name for the new style sheet.")); name_str = NULL; } if (template_str && name_str) { new_ss = scm_call_2(make_ss, scm_makfrom0str(template_str), scm_makfrom0str(name_str)); } } g_list_free (template_names); gtk_widget_destroy(dlg); return(new_ss); }
void gtk_combo_box_text_prepend_text(GtkComboBoxText *combo_box, const gchar *text) { gtk_combo_box_prepend_text(GTK_COMBO_BOX(combo_box), text); }