void xmi_msim_gui_compound_dialog_set_weight(XmiMsimGuiCompoundDialog *dialog, gdouble weight) { gchar *text = g_strdup_printf("%g", weight); gtk_entry_set_text(GTK_ENTRY(dialog->weightEntry), text); g_free(text); }
static void search_next_clicked (GtkWidget *button, GtkWidget *entry) { search (gtk_entry_get_text (GTK_ENTRY (entry)), TRUE); }
wxTextPos wxComboBox::GetLastPosition() const { GtkWidget *entry = GTK_COMBO(m_widget)->entry; int pos = GTK_ENTRY(entry)->text_length; return (long) pos-1; }
// main program /////////////////////////////////////////////////////////////////////////////////////////////////// int main(int argc, char *argv[]) { int return_value = EXIT_ERROR; PinDialogInfo pindialog; char caller_path[1024]; gtk_init(&argc, &argv); // initialize gtk+ putenv("LANGUAGE="); bindtextdomain("dialogs-beid", DATAROOTDIR "/locale"); textdomain("dialogs-beid"); // create new message dialog with CANCEL and OK buttons in standard places, in center of user's screen /////////////////////////////////////////////////////////////////////////////////////////////////////////////////// if(argc < 2 || (strlen(argv[1]) == 0)) { fprintf(stderr, "E: required argument: PIN name"); exit(EXIT_ERROR); } if (get_parent_path(caller_path, sizeof(caller_path) - 2) > 0) { pindialog.dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, gettext("Request from Application [%s]:\n\nPlease enter your current eID %s, followed by your new eID %s (twice)"), caller_path, argv[1], argv[1]); } else { fprintf(stderr, "Failed To Determine Parent Process. Aborting.\n"); exit(EXIT_ERROR); } pindialog.cancelbutton = GTK_BUTTON(gtk_dialog_add_button (GTK_DIALOG(pindialog.dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL)); pindialog.okbutton = GTK_BUTTON(gtk_dialog_add_button (GTK_DIALOG(pindialog.dialog), GTK_STOCK_OK, GTK_RESPONSE_OK)); gtk_dialog_set_default_response(GTK_DIALOG(pindialog.dialog), GTK_RESPONSE_OK); gtk_window_set_title(GTK_WINDOW(pindialog.dialog), gettext("beID: Change PIN Code")); gtk_window_set_position(GTK_WINDOW(pindialog.dialog), GTK_WIN_POS_CENTER); g_signal_connect(pindialog.dialog, "delete-event", G_CALLBACK(on_delete_event), &pindialog); // create original, new, and verify new pin entry fields with labels, in a table /////////////////////////////////////////////////////////////////////////////////////////////////////////// pindialog.newPinsTable = gtk_table_new(3, 2, TRUE); // table of 4 rows, 3 columns pindialog.originalPinLabel = gtk_label_new(gettext("Current PIN:")); pindialog.newPin0Label = gtk_label_new(gettext("New PIN:")); pindialog.newPin1Label = gtk_label_new(gettext("New PIN (again):")); pindialog.originalPinEntry = gtk_entry_new(); pindialog.newPin0Entry = gtk_entry_new(); pindialog.newPin1Entry = gtk_entry_new(); // set max lengths gtk_entry_set_max_length(GTK_ENTRY(pindialog.originalPinEntry), MAX_PIN_LENGTH); gtk_entry_set_max_length(GTK_ENTRY(pindialog.newPin0Entry), MAX_PIN_LENGTH); gtk_entry_set_max_length(GTK_ENTRY(pindialog.newPin1Entry), MAX_PIN_LENGTH); // disable visibilities gtk_entry_set_visibility(GTK_ENTRY(pindialog.originalPinEntry), FALSE); gtk_entry_set_visibility(GTK_ENTRY(pindialog.newPin0Entry), FALSE); gtk_entry_set_visibility(GTK_ENTRY(pindialog.newPin1Entry), FALSE); // put labels and entries in a table gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.originalPinLabel, 0, 1, 0, 1, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.newPin0Label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.newPin1Label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.originalPinEntry, 1, 2, 0, 1, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.newPin0Entry, 1, 2, 1, 2, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); gtk_table_attach(GTK_TABLE(pindialog.newPinsTable), pindialog.newPin1Entry, 1, 2, 2, 3, (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), (GtkAttachOptions) (GTK_SHRINK | GTK_FILL), 2, 2); // connect signals to filter and read inputs g_signal_connect(pindialog.originalPinEntry, "insert_text", G_CALLBACK(insert_only_digits), (gpointer) & pindialog); g_signal_connect(pindialog.newPin0Entry, "insert_text", G_CALLBACK(insert_only_digits), (gpointer) & pindialog); g_signal_connect(pindialog.newPin1Entry, "insert_text", G_CALLBACK(insert_only_digits), (gpointer) & pindialog); g_signal_connect(pindialog.originalPinEntry, "changed", G_CALLBACK(pins_changed), (gpointer) & pindialog); g_signal_connect(pindialog.newPin0Entry, "changed", G_CALLBACK(pins_changed), (gpointer) & pindialog); g_signal_connect(pindialog.newPin1Entry, "changed", G_CALLBACK(pins_changed), (gpointer) & pindialog); // add all these objects to the dialog /////////////////////////////////////////////////////////////////////////////////////////////////////////// gtk_container_set_border_width(GTK_CONTAINER(pindialog.dialog), 10); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(pindialog.dialog))), pindialog.newPinsTable, TRUE, TRUE, 2); // initial state for OK button ///////////////////////////////////////////////////////////////////////////////////////////////////////// update_ok_button(&pindialog); // show all these widgets, and run the dialog as a modal dialog until it is closed by the user ////////////////////////////////////////////////////////////////////////////////////////////// gtk_widget_show_all(GTK_WIDGET(pindialog.dialog)); switch (gtk_dialog_run(GTK_DIALOG(pindialog.dialog))) { case GTK_RESPONSE_OK: // if the user chose OK { const char *oldpin = gtk_entry_get_text(GTK_ENTRY(pindialog.originalPinEntry)); const char *newpin = gtk_entry_get_text(GTK_ENTRY(pindialog.newPin0Entry)); printf("%s:%s\n", oldpin, newpin); // output the PINs to stdout return_value = EXIT_OK; // and return OK } break; default: // otherwise printf("CANCEL\n"); return_value = EXIT_OK; // output CANCEL and return ok (cancel is not an error) break; } // properly dispose of the dialog (which disposes of all it's children), and exit with specific return value ///////////////////////////////////////////////////////////////////////////////////////////////////////////// gtk_widget_destroy(pindialog.dialog); exit(return_value); }
static void search_entry_changed (GtkWidget *entry) { search (gtk_entry_get_text (GTK_ENTRY (entry)), TRUE); }
/* * display the interface selection for bridged sniffing */ static void gtkui_bridged_sniff(void) { GtkWidget *dialog, *vbox, *hbox, *image; GtkWidget *hbox_big, *label, *combo1, *combo2; GList *iface_list; const char *iface_desc = NULL; char err[100]; pcap_if_t *dev; DEBUG_MSG("gtk_bridged_sniff"); dialog = gtk_dialog_new_with_buttons("Bridged Sniffing", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); hbox_big = gtk_hbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox_big, FALSE, FALSE, 0); gtk_widget_show(hbox_big); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.1); gtk_box_pack_start (GTK_BOX (hbox_big), image, FALSE, FALSE, 5); gtk_widget_show(image); vbox = gtk_vbox_new (FALSE, 2); gtk_container_set_border_width(GTK_CONTAINER (vbox), 5); gtk_box_pack_start (GTK_BOX (hbox_big), vbox, TRUE, TRUE, 0); gtk_widget_show(vbox); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_widget_show(hbox); label = gtk_label_new ("First network interface : "); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start(GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show(label); /* make a list of network interfaces */ iface_list = NULL; for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { iface_list = g_list_append(iface_list, dev->description); } /* make a drop down box and assign the list to it */ combo1 = gtk_combo_new(); gtk_combo_set_popdown_strings (GTK_COMBO (combo1), iface_list); gtk_box_pack_start (GTK_BOX (hbox), combo1, FALSE, FALSE, 0); gtk_widget_show(combo1); hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_widget_show(hbox); label = gtk_label_new ("Second network interface : "); gtk_misc_set_alignment(GTK_MISC (label), 0, 0.5); gtk_box_pack_start(GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_widget_show(label); /* make a drop down box and assign the list to it */ combo2 = gtk_combo_new(); gtk_combo_set_popdown_strings (GTK_COMBO (combo2), iface_list); gtk_box_pack_start (GTK_BOX (hbox), combo2, FALSE, FALSE, 0); gtk_widget_show(combo2); /* pick the second interface by default, since they can't match */ if(iface_list && iface_list->next) gtk_entry_set_text(GTK_ENTRY (GTK_COMBO (combo2)->entry), iface_list->next->data); /* list is stored in the widget, can safely free this copy */ g_list_free(iface_list); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { gtk_widget_hide(dialog); iface_desc = gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (combo1)->entry)); for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { if(!strncmp(dev->description, iface_desc, IFACE_LEN)) { SAFE_FREE(GBL_OPTIONS->iface); SAFE_CALLOC(GBL_OPTIONS->iface, IFACE_LEN, sizeof(char)); strncpy(GBL_OPTIONS->iface, dev->name, IFACE_LEN); break; } } /* if no match in list */ if(GBL_OPTIONS->iface == NULL) { snprintf(err, 100, "Invalid interface: %s", iface_desc); gtkui_error(err); gtk_widget_destroy(dialog); return; } iface_desc = gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (combo2)->entry)); for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { if(!strncmp(dev->description, iface_desc, IFACE_LEN)) { SAFE_FREE(GBL_OPTIONS->iface_bridge); SAFE_CALLOC(GBL_OPTIONS->iface_bridge, IFACE_LEN, sizeof(char)); strncpy(GBL_OPTIONS->iface_bridge, dev->name, IFACE_LEN); break; } } /* if no match in list */ if(GBL_OPTIONS->iface_bridge == NULL) { snprintf(err, 100, "Invalid interface: %s", iface_desc); gtkui_error(err); gtk_widget_destroy(dialog); return; } bridged_sniff(); } gtk_widget_destroy(dialog); }
void gui_prefs_fetch(GtkWidget *w) { prefs.gui_plist_sel_browse = fetch_enum_value( g_object_get_data(G_OBJECT(w), PLIST_SEL_BROWSE_KEY), selection_mode_vals); prefs.gui_ptree_sel_browse = fetch_enum_value( g_object_get_data(G_OBJECT(w), PTREE_SEL_BROWSE_KEY), selection_mode_vals); prefs.gui_geometry_save_position = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GEOMETRY_POSITION_KEY)); prefs.gui_geometry_save_size = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GEOMETRY_SIZE_KEY)); prefs.gui_geometry_save_maximized = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GEOMETRY_MAXIMIZED_KEY)); #if defined(HAVE_IGE_MAC_INTEGRATION) || defined(HAVE_GTKOSXAPPLICATION) prefs.gui_macosx_style = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), MACOSX_STYLE_KEY)); #endif #ifdef _WIN32 prefs.gui_console_open = fetch_enum_value( g_object_get_data(G_OBJECT(w), GUI_CONSOLE_OPEN_KEY), gui_console_open_vals); #endif prefs.gui_fileopen_style = fetch_preference_radio_buttons_val( g_object_get_data(G_OBJECT(w), GUI_FILEOPEN_KEY), gui_fileopen_vals); g_free(prefs.gui_fileopen_dir); prefs.gui_fileopen_dir = g_strdup(gtk_entry_get_text( GTK_ENTRY(g_object_get_data(G_OBJECT(w), GUI_FILEOPEN_DIR_KEY)))); prefs.gui_ask_unsaved = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_ASK_UNSAVED_KEY)); prefs.gui_find_wrap = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_FIND_WRAP_KEY)); prefs.gui_use_pref_save = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_USE_PREF_SAVE_KEY)); prefs.gui_version_in_start_page = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_SHOW_VERSION_KEY)); prefs.gui_auto_scroll_on_expand = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_AUTO_SCROLL_KEY)); if (browser_needs_pref()) { g_free(prefs.gui_webbrowser); prefs.gui_webbrowser = g_strdup(gtk_entry_get_text( GTK_ENTRY(g_object_get_data(G_OBJECT(w), GUI_WEBBROWSER_KEY)))); } prefs.gui_expert_composite_eyecandy = gtk_toggle_button_get_active(g_object_get_data(G_OBJECT(w), GUI_EXPERT_EYECANDY_KEY)); /* * XXX - we need to have a way to fetch the preferences into * local storage and only set the permanent preferences if there * weren't any errors in those fetches, as there are several * places where there *can* be a bad preference value. */ if (font_fetch()) { if (strcmp(new_font_name, prefs.gui_font_name) != 0) { font_changed = TRUE; g_free(prefs.gui_font_name); prefs.gui_font_name = g_strdup(new_font_name); } } }
int l_uplmt_p(class l_uplmt_rek *rek_poi,GtkWidget *wpredok) { class l_uplmt_p_data data; char strsql[512]; data.rk=rek_poi; data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(data.window),TRUE); sprintf(strsql,"%s %s",name_system,gettext("Поиск")); gtk_window_set_title(GTK_WINDOW(data.window),strsql); gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL); gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_uplmt_p_key_press),&data); if(wpredok != NULL) { gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); //Удерживать окно над породившем его окном всегда gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok)); //Закрыть окно если окно предок удалено gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE); } GtkWidget *vbox = gtk_vbox_new (FALSE, 0); GtkWidget *hbox[KOLENTER]; for(int i=0; i < KOLENTER; i++) hbox[i] = gtk_hbox_new (FALSE, 0); GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (data.window), vbox); for(int i=0; i < KOLENTER; i++) gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); gtk_container_add (GTK_CONTAINER (vbox), hboxknop); GtkWidget *label=gtk_label_new(gettext("Код палива")); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_TOP]), label, FALSE, FALSE, 0); data.entry[E_KOD_TOP] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_TOP]), data.entry[E_KOD_TOP], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_TOP]), "activate",GTK_SIGNAL_FUNC(l_uplmt_p_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_TOP]),data.rk->kod_top.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_TOP]),(gpointer)E_KOD_TOP); label=gtk_label_new(gettext("Код материалла")); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_MAT]), label, FALSE, FALSE, 0); data.entry[E_KOD_MAT] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_MAT]), data.entry[E_KOD_MAT], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_MAT]), "activate",GTK_SIGNAL_FUNC(l_uplmt_p_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_MAT]),data.rk->kod_mat.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_MAT]),(gpointer)E_KOD_MAT); GtkTooltips *tooltips[KOL_FK]; sprintf(strsql,"F2 %s",gettext("Поиск")); data.knopka[FK2]=gtk_button_new_with_label(strsql); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать поиск нужных записей"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(l_uplmt_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0); sprintf(strsql,"F4 %s",gettext("Очистить")); data.knopka[FK4]=gtk_button_new_with_label(strsql); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введеноой информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(l_uplmt_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); tooltips[FK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Поиск не выполнять"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(l_uplmt_p_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[0]); gtk_widget_show_all (data.window); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
/** * vtable_dialog_get_table_name: * */ const gchar * vtable_dialog_get_table_name (VtableDialog *dlg) { g_return_val_if_fail (IS_VTABLE_DIALOG (dlg), NULL); return gtk_entry_get_text (GTK_ENTRY (dlg->priv->tname_entry)); }
bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value, const wxPoint &pos, const wxSize &size, long style, const wxValidator& validator, const wxString &name ) { m_needParent = true; m_acceptsFocus = true; if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxTextCtrl creation failed") ); return false; } m_vScrollbarVisible = false; bool multi_line = (style & wxTE_MULTILINE) != 0; if (multi_line) { // create our control ... m_text = gtk_text_new( NULL, NULL ); // ... and put into the upper left hand corner of the table bool bHasHScrollbar = false; m_widget = gtk_table_new(bHasHScrollbar ? 2 : 1, 2, FALSE); GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS ); gtk_table_attach( GTK_TABLE(m_widget), m_text, 0, 1, 0, 1, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK), (GtkAttachOptions)(GTK_FILL | GTK_EXPAND | GTK_SHRINK), 0, 0); // always wrap words gtk_text_set_word_wrap( GTK_TEXT(m_text), TRUE ); // finally, put the vertical scrollbar in the upper right corner m_vScrollbar = gtk_vscrollbar_new( GTK_TEXT(m_text)->vadj ); GTK_WIDGET_UNSET_FLAGS( m_vScrollbar, GTK_CAN_FOCUS ); gtk_table_attach(GTK_TABLE(m_widget), m_vScrollbar, 1, 2, 0, 1, GTK_FILL, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL | GTK_SHRINK), 0, 0); } else { // a single-line text control: no need for scrollbars m_widget = m_text = gtk_entry_new(); } m_parent->DoAddChild( this ); m_focusWidget = m_text; PostCreation(size); if (multi_line) gtk_widget_show(m_text); if (multi_line) { gtk_signal_connect(GTK_OBJECT(GTK_TEXT(m_text)->vadj), "changed", (GtkSignalFunc) gtk_scrollbar_changed_callback, (gpointer) this ); // only initialize gs_gtk_text_draw once, starting from the next the // klass::draw will already be wxgtk_text_draw if ( !gs_gtk_text_draw ) { GtkDrawCallback& draw = GTK_WIDGET_CLASS(GTK_OBJECT(m_text)->klass)->draw; gs_gtk_text_draw = draw; draw = wxgtk_text_draw; } } if (!value.empty()) { #if !GTK_CHECK_VERSION(1, 2, 0) // if we don't realize it, GTK 1.0.6 dies with a SIGSEGV in // gtk_editable_insert_text() gtk_widget_realize(m_text); #endif // GTK 1.0 gint tmp = 0; #if wxUSE_UNICODE wxWX2MBbuf val = value.mbc_str(); gtk_editable_insert_text( GTK_EDITABLE(m_text), val, strlen(val), &tmp ); #else gtk_editable_insert_text( GTK_EDITABLE(m_text), value, value.length(), &tmp ); #endif if (multi_line) { // Bring editable's cursor uptodate. Bug in GTK. SET_EDITABLE_POS(m_text, gtk_text_get_point( GTK_TEXT(m_text) )); } } if (style & wxTE_PASSWORD) { if (!multi_line) gtk_entry_set_visibility( GTK_ENTRY(m_text), FALSE ); } if (style & wxTE_READONLY) { if (!multi_line) gtk_entry_set_editable( GTK_ENTRY(m_text), FALSE ); } else { if (multi_line) gtk_text_set_editable( GTK_TEXT(m_text), 1 ); } // We want to be notified about text changes. gtk_signal_connect( GTK_OBJECT(m_text), "changed", GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this); m_cursor = wxCursor( wxCURSOR_IBEAM ); wxTextAttr attrDef(GetForegroundColour(), GetBackgroundColour(), GetFont()); SetDefaultStyle( attrDef ); return true; }
void read_rek() { rk->kod_top.new_plus(iceb_u_fromutf((char*)gtk_entry_get_text(GTK_ENTRY(entry[E_KOD_TOP])))); rk->kod_mat.new_plus(iceb_u_fromutf((char*)gtk_entry_get_text(GTK_ENTRY(entry[E_KOD_MAT])))); }
static void mpg123_configurewin_ok(GtkWidget * widget, gpointer data) { ConfigFile *cfg; gchar *filename; if (GTK_TOGGLE_BUTTON(decode_res_16)->active) mpg123_cfg.resolution = 16; else if (GTK_TOGGLE_BUTTON(decode_res_8)->active) mpg123_cfg.resolution = 8; if (GTK_TOGGLE_BUTTON(decode_ch_stereo)->active) mpg123_cfg.channels = 2; else if (GTK_TOGGLE_BUTTON(decode_ch_mono)->active) mpg123_cfg.channels = 1; if (GTK_TOGGLE_BUTTON(decode_freq_1to1)->active) mpg123_cfg.downsample = 0; else if (GTK_TOGGLE_BUTTON(decode_freq_1to2)->active) mpg123_cfg.downsample = 1; if (GTK_TOGGLE_BUTTON(decode_freq_1to4)->active) mpg123_cfg.downsample = 2; if (GTK_TOGGLE_BUTTON(detect_by_content)->active) mpg123_cfg.detect_by = DETECT_CONTENT; else if (GTK_TOGGLE_BUTTON(detect_by_extension)->active) mpg123_cfg.detect_by = DETECT_EXTENSION; else if (GTK_TOGGLE_BUTTON(detect_by_both)->active) mpg123_cfg.detect_by = DETECT_BOTH; else mpg123_cfg.detect_by = DETECT_EXTENSION; #ifdef USE_SIMD if (GTK_TOGGLE_BUTTON(auto_select)->active) mpg123_cfg.default_synth = SYNTH_AUTO; else if (GTK_TOGGLE_BUTTON(decoder_fpu)->active) mpg123_cfg.default_synth = SYNTH_FPU; else if (GTK_TOGGLE_BUTTON(decoder_mmx)->active) mpg123_cfg.default_synth = SYNTH_MMX; else mpg123_cfg.default_synth = SYNTH_3DNOW; #endif mpg123_cfg.http_buffer_size = (gint) GTK_ADJUSTMENT(streaming_size_adj)->value; mpg123_cfg.http_prebuffer = (gint) GTK_ADJUSTMENT(streaming_pre_adj)->value; mpg123_cfg.use_proxy = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_use)); g_free(mpg123_cfg.proxy_host); mpg123_cfg.proxy_host = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_host_entry))); mpg123_cfg.proxy_port = atoi(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_port_entry))); mpg123_cfg.proxy_use_auth = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_proxy_auth_use)); if(mpg123_cfg.proxy_user) g_free(mpg123_cfg.proxy_user); mpg123_cfg.proxy_user = NULL; if(strlen(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_user_entry))) > 0) mpg123_cfg.proxy_user = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_user_entry))); if(mpg123_cfg.proxy_pass) g_free(mpg123_cfg.proxy_pass); mpg123_cfg.proxy_pass = NULL; if(strlen(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_pass_entry))) > 0) mpg123_cfg.proxy_pass = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_proxy_auth_pass_entry))); mpg123_cfg.save_http_stream = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_save_use)); if (mpg123_cfg.save_http_path) g_free(mpg123_cfg.save_http_path); mpg123_cfg.save_http_path = g_strdup(gtk_entry_get_text(GTK_ENTRY(streaming_save_entry))); mpg123_cfg.cast_title_streaming = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_cast_title)); mpg123_cfg.use_udp_channel = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(streaming_udp_title)); mpg123_cfg.title_override = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(title_override)); mpg123_cfg.disable_id3v2 = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(title_id3v2_disable)); g_free(mpg123_cfg.id3_format); mpg123_cfg.id3_format = g_strdup(gtk_entry_get_text(GTK_ENTRY(title_id3_entry))); filename = g_strconcat(g_get_home_dir(), "/.xmms/config", NULL); cfg = xmms_cfg_open_file(filename); if (!cfg) cfg = xmms_cfg_new(); xmms_cfg_write_int(cfg, "MPG123", "resolution", mpg123_cfg.resolution); xmms_cfg_write_int(cfg, "MPG123", "channels", mpg123_cfg.channels); xmms_cfg_write_int(cfg, "MPG123", "downsample", mpg123_cfg.downsample); xmms_cfg_write_int(cfg, "MPG123", "http_buffer_size", mpg123_cfg.http_buffer_size); xmms_cfg_write_int(cfg, "MPG123", "http_prebuffer", mpg123_cfg.http_prebuffer); xmms_cfg_write_boolean(cfg, "MPG123", "use_proxy", mpg123_cfg.use_proxy); xmms_cfg_write_string(cfg, "MPG123", "proxy_host", mpg123_cfg.proxy_host); xmms_cfg_write_int(cfg, "MPG123", "proxy_port", mpg123_cfg.proxy_port); xmms_cfg_write_boolean(cfg, "MPG123", "proxy_use_auth", mpg123_cfg.proxy_use_auth); if(mpg123_cfg.proxy_user) xmms_cfg_write_string(cfg, "MPG123", "proxy_user", mpg123_cfg.proxy_user); else xmms_cfg_remove_key(cfg, "MPG123", "proxy_user"); if(mpg123_cfg.proxy_pass) xmms_cfg_write_string(cfg, "MPG123", "proxy_pass", mpg123_cfg.proxy_pass); else xmms_cfg_remove_key(cfg, "MPG123", "proxy_pass"); xmms_cfg_write_boolean(cfg, "MPG123", "save_http_stream", mpg123_cfg.save_http_stream); xmms_cfg_write_string(cfg, "MPG123", "save_http_path", mpg123_cfg.save_http_path); xmms_cfg_write_boolean(cfg, "MPG123", "cast_title_streaming", mpg123_cfg.cast_title_streaming); xmms_cfg_write_boolean(cfg, "MPG123", "use_udp_channel", mpg123_cfg.use_udp_channel); xmms_cfg_write_boolean(cfg, "MPG123", "title_override", mpg123_cfg.title_override); xmms_cfg_write_boolean(cfg, "MPG123", "disable_id3v2", mpg123_cfg.disable_id3v2); xmms_cfg_write_string(cfg, "MPG123", "id3_format", mpg123_cfg.id3_format); xmms_cfg_write_int(cfg, "MPG123", "detect_by", mpg123_cfg.detect_by); #ifdef USE_SIMD xmms_cfg_write_int(cfg, "MPG123", "default_synth", mpg123_cfg.default_synth); #endif xmms_cfg_write_file(cfg, filename); xmms_cfg_free(cfg); g_free(filename); gtk_widget_destroy(mpg123_configurewin); }
static void streaming_save_dirbrowser_cb(gchar * dir) { gtk_entry_set_text(GTK_ENTRY(streaming_save_entry), dir); }
gdouble xmi_msim_gui_compound_dialog_get_weight(XmiMsimGuiCompoundDialog *dialog) { return strtod(gtk_entry_get_text(GTK_ENTRY(dialog->weightEntry)), NULL); }
void cb_ask_for_information (ScreenshooterJob *job, GtkListStore *liststore, const gchar *message, gpointer unused) { GtkWidget *dialog; GtkWidget *information_label; GtkWidget *vbox, *main_alignment; GtkWidget *table; GtkWidget *user_entry, *password_entry, *title_entry, *comment_entry; GtkWidget *user_label, *password_label, *title_label, *comment_label; GtkTreeIter iter; gint response; g_return_if_fail (SCREENSHOOTER_IS_JOB (job)); g_return_if_fail (GTK_IS_LIST_STORE (liststore)); g_return_if_fail (message != NULL); TRACE ("Create the dialog to ask for user information."); /* Create the information dialog */ dialog = xfce_titled_dialog_new_with_buttons (_("Details about the screenshot for ZimageZ"), NULL, GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG(dialog)->vbox), 12); gtk_window_set_icon_name (GTK_WINDOW (dialog), "gtk-info"); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); /* Create the main alignment for the dialog */ main_alignment = gtk_alignment_new (0, 0, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (main_alignment), 6, 0, 12, 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_alignment, TRUE, TRUE, 0); /* Create the main box for the dialog */ vbox = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_container_add (GTK_CONTAINER (main_alignment), vbox); /* Create the information label */ information_label = gtk_label_new (""); gtk_label_set_markup (GTK_LABEL (information_label), message); gtk_misc_set_alignment (GTK_MISC (information_label), 0, 0); gtk_container_add (GTK_CONTAINER (vbox), information_label); /* Create the layout table */ table = gtk_table_new (4, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 12); gtk_container_add (GTK_CONTAINER (vbox), table); /* Create the user label */ user_label = gtk_label_new (_("User:"******"Your Zimagez user name, if you do not have one yet" " please create one on the Web page linked above")); gtk_entry_set_activates_default (GTK_ENTRY (user_entry), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), user_entry, 1, 2, 0, 1); /* Create the password label */ password_label = gtk_label_new (_("Password:"******"The password for the user above")); gtk_entry_set_visibility (GTK_ENTRY (password_entry), FALSE); gtk_entry_set_activates_default (GTK_ENTRY (password_entry), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), password_entry, 1, 2, 1, 2); /* Create the title label */ title_label = gtk_label_new (_("Title:")); gtk_misc_set_alignment (GTK_MISC (title_label), 0, 0.5); gtk_table_attach (GTK_TABLE (table), title_label, 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0); /* Create the title entry */ title_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (title_entry, _("The title of the screenshot, it will be used when" " displaying the screenshot on ZimageZ")); gtk_entry_set_activates_default (GTK_ENTRY (title_entry), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), title_entry, 1, 2, 2, 3); /* Create the comment label */ comment_label = gtk_label_new (_("Comment:")); gtk_misc_set_alignment (GTK_MISC (comment_label), 0, 0.5); gtk_table_attach (GTK_TABLE (table), comment_label, 0, 1, 3, 4, GTK_FILL, GTK_FILL, 0, 0); /* Create the comment entry */ comment_entry = gtk_entry_new (); gtk_widget_set_tooltip_text (comment_entry, _("A comment on the screenshot, it will be used when" " displaying the screenshot on ZimageZ")); gtk_entry_set_activates_default (GTK_ENTRY (comment_entry), TRUE); gtk_table_attach_defaults (GTK_TABLE (table), comment_entry, 1, 2, 3, 4); /* Set the values */ gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter); do { gint field_index; gchar *field_value = NULL; gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter, 0, &field_index, 1, &field_value, -1); switch (field_index) { case USER: gtk_entry_set_text (GTK_ENTRY (user_entry), field_value); break; case PASSWORD: gtk_entry_set_text (GTK_ENTRY (password_entry), field_value); break; case TITLE: gtk_entry_set_text (GTK_ENTRY (title_entry), field_value); break; case COMMENT: gtk_entry_set_text (GTK_ENTRY (comment_entry), field_value); break; default: break; } g_free (field_value); } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter)); gtk_widget_show_all (GTK_DIALOG(dialog)->vbox); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_hide (dialog); if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT) { exo_job_cancel (EXO_JOB (job)); } else if (response == GTK_RESPONSE_OK) { gtk_tree_model_get_iter_first (GTK_TREE_MODEL (liststore), &iter); do { gint field_index; gtk_tree_model_get (GTK_TREE_MODEL (liststore), &iter, 0, &field_index, -1); switch (field_index) { case USER: gtk_list_store_set (liststore, &iter, 1, gtk_entry_get_text (GTK_ENTRY (user_entry)), -1); break; case PASSWORD: gtk_list_store_set (liststore, &iter, 1, gtk_entry_get_text (GTK_ENTRY (password_entry)), -1); break; case TITLE: gtk_list_store_set (liststore, &iter, 1, gtk_entry_get_text (GTK_ENTRY (title_entry)), -1); break; case COMMENT: gtk_list_store_set (liststore, &iter, 1, gtk_entry_get_text (GTK_ENTRY (comment_entry)), -1); break; default: break; } } while (gtk_tree_model_iter_next (GTK_TREE_MODEL (liststore), &iter)); } gtk_widget_destroy (dialog); }
void prefs_spelling_create_widget(PrefsPage *_page, GtkWindow *window, gpointer data) { SpellingPage *prefs_spelling = (SpellingPage *) _page; /* START GLADE CODE */ GtkWidget *table; GtkWidget *checkbtn_enable_aspell; GtkWidget *checkbtn_check_while_typing; GtkWidget *checkbtn_use_alternate; GtkWidget *label2; GtkWidget *entry_aspell_path; GtkWidget *label3; GtkWidget *optmenu_dictionary; GtkWidget *optmenu_dictionary_menu; GtkWidget *label4; GtkWidget *optmenu_sugmode; GtkWidget *optmenu_sugmode_menu; GtkWidget *label5; GtkWidget *btn_aspell_path; GtkWidget *hbox1; GtkWidget *misspelled_btn; GtkTooltips *tooltips; tooltips = gtk_tooltips_new (); table = gtk_table_new(8, 3, FALSE); gtk_widget_show(table); gtk_container_set_border_width(GTK_CONTAINER(table), 8); gtk_table_set_row_spacings(GTK_TABLE(table), 4); gtk_table_set_col_spacings(GTK_TABLE(table), 8); checkbtn_enable_aspell = gtk_check_button_new_with_label(_("Enable spell checker")); gtk_widget_show(checkbtn_enable_aspell); gtk_table_attach(GTK_TABLE(table), checkbtn_enable_aspell, 0, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); checkbtn_check_while_typing = gtk_check_button_new_with_label(_("Check while typing")); gtk_widget_show(checkbtn_check_while_typing); gtk_table_attach(GTK_TABLE(table), checkbtn_check_while_typing, 0, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); checkbtn_use_alternate = gtk_check_button_new_with_label(_ ("Enable alternate dictionary")); gtk_widget_show(checkbtn_use_alternate); gtk_table_attach(GTK_TABLE(table), checkbtn_use_alternate, 0, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_tooltips_set_tip (tooltips, checkbtn_use_alternate, _("Faster switching with last used dictionary"), NULL); label2 = gtk_label_new(_("Dictionaries path:")); gtk_widget_show(label2); gtk_table_attach(GTK_TABLE(table), label2, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(label2), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment(GTK_MISC(label2), 1, 0.5); entry_aspell_path = gtk_entry_new(); gtk_widget_show(entry_aspell_path); gtk_table_attach(GTK_TABLE(table), entry_aspell_path, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label3 = gtk_label_new(_("Default dictionary:")); gtk_widget_show(label3); gtk_table_attach(GTK_TABLE(table), label3, 0, 1, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(label3), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment(GTK_MISC(label3), 1, 0.5); optmenu_dictionary = gtk_option_menu_new(); gtk_widget_show(optmenu_dictionary); gtk_table_attach(GTK_TABLE(table), optmenu_dictionary, 1, 3, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); optmenu_dictionary_menu = gtk_menu_new(); gtk_option_menu_set_menu(GTK_OPTION_MENU(optmenu_dictionary), optmenu_dictionary_menu); label4 = gtk_label_new(_("Default suggestion mode:")); gtk_widget_show(label4); gtk_table_attach(GTK_TABLE(table), label4, 0, 1, 6, 7, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(label4), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment(GTK_MISC(label4), 1, 0.5); optmenu_sugmode = gtk_option_menu_new(); gtk_widget_show(optmenu_sugmode); gtk_table_attach(GTK_TABLE(table), optmenu_sugmode, 1, 3, 6, 7, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); optmenu_sugmode_menu = gtk_menu_new(); gtk_option_menu_set_menu(GTK_OPTION_MENU(optmenu_sugmode), optmenu_sugmode_menu); label5 = gtk_label_new(_("Misspelled word color:")); gtk_widget_show(label5); gtk_table_attach(GTK_TABLE(table), label5, 0, 1, 7, 8, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(label5), GTK_JUSTIFY_RIGHT); gtk_misc_set_alignment(GTK_MISC(label5), 1, 0.5); btn_aspell_path = gtk_button_new_with_label(_(" ... ")); gtk_widget_show(btn_aspell_path); gtk_table_attach(GTK_TABLE(table), btn_aspell_path, 2, 3, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox1); gtk_table_attach(GTK_TABLE(table), hbox1, 1, 2, 7, 8, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); misspelled_btn = gtk_button_new_with_label(""); gtk_widget_show(misspelled_btn); gtk_box_pack_start(GTK_BOX(hbox1), misspelled_btn, FALSE, FALSE, 0); gtk_widget_set_usize(misspelled_btn, 30, 20); /* END GLADE CODE */ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_enable_aspell), prefs_common.enable_aspell); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_check_while_typing), prefs_common.check_while_typing); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbtn_use_alternate), prefs_common.use_alternate); gtk_entry_set_text(GTK_ENTRY(entry_aspell_path), SAFE_STRING(prefs_common.aspell_path)); gtk_signal_connect(GTK_OBJECT(checkbtn_enable_aspell), "toggled", GTK_SIGNAL_FUNC(prefs_spelling_checkbtn_enable_aspell_toggle_cb), prefs_spelling); gtk_signal_connect(GTK_OBJECT(btn_aspell_path), "clicked", GTK_SIGNAL_FUNC(prefs_spelling_btn_aspell_path_clicked_cb), prefs_spelling); gtk_signal_connect(GTK_OBJECT(misspelled_btn), "clicked", GTK_SIGNAL_FUNC(prefs_spelling_colorsel), prefs_spelling); gtk_option_menu_set_menu(GTK_OPTION_MENU(optmenu_dictionary), gtkaspell_dictionary_option_menu_new(prefs_common.aspell_path)); gtkaspell_set_dictionary_menu_active_item(optmenu_dictionary, prefs_common.dictionary); gtk_option_menu_set_menu(GTK_OPTION_MENU(optmenu_sugmode), gtkaspell_sugmode_option_menu_new(prefs_common.aspell_sugmode)); gtkaspell_sugmode_option_menu_set(GTK_OPTION_MENU(optmenu_sugmode), prefs_common.aspell_sugmode); prefs_spelling->misspell_col = prefs_common.misspelled_col; gtkut_set_widget_bgcolor_rgb(misspelled_btn, prefs_spelling->misspell_col); prefs_spelling->window = GTK_WIDGET(window); prefs_spelling->checkbtn_enable_aspell = checkbtn_enable_aspell; prefs_spelling->entry_aspell_path = entry_aspell_path; prefs_spelling->btn_aspell_path = btn_aspell_path; prefs_spelling->optmenu_dictionary = optmenu_dictionary; prefs_spelling->optmenu_sugmode = optmenu_sugmode; prefs_spelling->checkbtn_use_alternate = checkbtn_use_alternate; prefs_spelling->checkbtn_check_while_typing = checkbtn_check_while_typing; prefs_spelling->misspelled_btn = misspelled_btn; prefs_spelling->page.widget = table; prefs_spelling_enable(prefs_spelling, prefs_common.enable_aspell); }
/* * display the interface selection dialog */ static void gtkui_unified_sniff(void) { GList *iface_list; const char *iface_desc = NULL; char err[100]; GtkWidget *iface_combo; pcap_if_t *dev; GtkWidget *dialog, *label, *hbox, *image; DEBUG_MSG("gtk_unified_sniff"); dialog = gtk_dialog_new_with_buttons(EC_PROGRAM" Input", GTK_WINDOW (window), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_set_has_separator(GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 5); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 0); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); label = gtk_label_new ("Network interface : "); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_selectable (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); /* make a list of network interfaces */ iface_list = NULL; for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { iface_list = g_list_append(iface_list, dev->description); } /* make a drop down box and assign the list to it */ iface_combo = gtk_combo_new(); gtk_combo_set_popdown_strings (GTK_COMBO (iface_combo), iface_list); gtk_box_pack_start (GTK_BOX (hbox), iface_combo, FALSE, FALSE, 0); /* hitting Enter in the drop down box clicks OK */ g_object_set_data(G_OBJECT (GTK_COMBO (iface_combo)->entry), "dialog", dialog); g_signal_connect(G_OBJECT (GTK_COMBO (iface_combo)->entry), "activate", G_CALLBACK (gtkui_dialog_enter), NULL); /* list is stored in the widget, can safely free this copy */ g_list_free(iface_list); /* render the contents of the dialog */ gtk_widget_show_all (hbox); /* show the dialog itself and become interactive */ if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) { iface_desc = gtk_entry_get_text(GTK_ENTRY (GTK_COMBO (iface_combo)->entry)); for(dev = (pcap_if_t *)GBL_PCAP->ifs; dev != NULL; dev = dev->next) { if(!strncmp(dev->description, iface_desc, IFACE_LEN)) { SAFE_FREE(GBL_OPTIONS->iface); SAFE_CALLOC(GBL_OPTIONS->iface, IFACE_LEN, sizeof(char)); strncpy(GBL_OPTIONS->iface, dev->name, IFACE_LEN); break; } } /* if no match in list */ if(GBL_OPTIONS->iface == NULL) { snprintf(err, 100, "Invalid interface: %s", iface_desc); gtkui_error(err); gtk_widget_destroy(dialog); return; } /* exit setup iterface */ gtk_widget_destroy(dialog); gtk_main_quit(); return; } gtk_widget_destroy(dialog); }
void gui_init (dt_lib_module_t *self) { dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t)); self->data = (void *)d; d->imgsel = -1; self->widget = gtk_vbox_new(TRUE, 5); gtk_widget_set_size_request(self->widget,100,-1); GtkBox *box, *hbox; GtkWidget *button; GtkWidget *w; GtkListStore *liststore; // left side, current box = GTK_BOX(gtk_vbox_new(FALSE, 0)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0); w = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->current = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->current, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->current, col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->current), "tooltip-text", _("attached tags,\ndoubleclick to detach"), (char *)NULL); g_signal_connect(G_OBJECT (d->current), "row-activated", G_CALLBACK (detach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current)); // attach/detach buttons hbox = GTK_BOX(gtk_hbox_new(TRUE, 5)); button = gtk_button_new_with_label(_("attach")); d->attach_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("attach tag to all selected images"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (attach_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("detach")); d->detach_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("detach tag from all selected images"), (char *)NULL); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (detach_button_clicked), (gpointer)self); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // right side, related box = GTK_BOX(gtk_vbox_new(FALSE, 5)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5); // text entry and new button w = gtk_entry_new(); dt_gui_key_accel_block_on_focus (w); g_object_set(G_OBJECT(w), "tooltip-text", _("enter tag name"), (char *)NULL); gtk_box_pack_start(box, w, TRUE, TRUE, 0); gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK); // g_signal_connect(G_OBJECT(w), "key-release-event", g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(tag_name_changed), (gpointer)self); g_signal_connect(G_OBJECT (w), "activate", G_CALLBACK (entry_activated), (gpointer)self); d->entry = GTK_ENTRY(w); // related tree view w = gtk_scrolled_window_new(NULL, NULL); gtk_widget_set_size_request(w,-1,100); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(box, w, TRUE, TRUE, 0); d->related = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->related, FALSE); liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); col = gtk_tree_view_column_new(); gtk_tree_view_append_column(d->related, col); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->related), "tooltip-text", _("related tags,\ndoubleclick to attach"), (char *)NULL); g_signal_connect(G_OBJECT (d->related), "row-activated", G_CALLBACK (attach_activated), (gpointer)self); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related)); // attach and delete buttons hbox = GTK_BOX(gtk_hbox_new(TRUE, 5)); button = gtk_button_new_with_label(_("new")); d->new_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("create a new tag with the\nname you entered"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (new_button_clicked), (gpointer)self); button = gtk_button_new_with_label(_("delete")); d->delete_button = button; g_object_set(G_OBJECT(button), "tooltip-text", _("delete selected tag"), (char *)NULL); gtk_box_pack_start(hbox, button, FALSE, TRUE, 0); g_signal_connect(G_OBJECT (button), "clicked", G_CALLBACK (delete_button_clicked), (gpointer)self); gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* connect to mouse over id */ dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, G_CALLBACK(_lib_tagging_redraw_callback), self); set_keyword(self, d); }
GtkWidget* gui_prefs_show(void) { GtkWidget *main_tb, *main_vb; GtkWidget *plist_browse_om; GtkWidget *ptree_browse_om; #ifdef _WIN32 GtkWidget *console_open_om; #endif GtkWidget *fileopen_rb, *fileopen_dir_te, *fileopen_preview_te; GtkWidget *recent_files_count_max_te, *recent_df_entries_max_te, *ask_unsaved_cb, *find_wrap_cb; GtkWidget *use_pref_save_cb; GtkWidget *show_version_cb; GtkWidget *auto_scroll_cb, *scroll_percent_te; GtkWidget *webbrowser_te; GtkWidget *save_position_cb, *save_size_cb, *save_maximized_cb; #if defined(HAVE_IGE_MAC_INTEGRATION) || defined(HAVE_GTKOSXAPPLICATION) GtkWidget *macosx_style_cb; #endif GtkWidget *expert_info_eyecandy_cb; int pos = 0; char current_val_str[128]; /* The font haven't been changed yet. */ font_changed = FALSE; /* The columns haven't been changed yet */ cfile.cinfo.columns_changed = FALSE; /* Main vertical box */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 7, FALSE); gtk_container_set_border_width( GTK_CONTAINER(main_vb), 5 ); /* Main table */ main_tb = gtk_table_new(GUI_TABLE_ROWS, 2, FALSE); gtk_box_pack_start(GTK_BOX(main_vb), main_tb, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10); gtk_table_set_col_spacings(GTK_TABLE(main_tb), 15); /* Packet list selection browseable */ plist_browse_om = create_preference_option_menu(main_tb, pos++, "Packet list selection mode:", "Choose to browse or select a packet for detailed dissection.", selection_mode_vals, prefs.gui_plist_sel_browse); g_object_set_data(G_OBJECT(main_vb), PLIST_SEL_BROWSE_KEY, plist_browse_om); /* Proto tree selection browseable */ ptree_browse_om = create_preference_option_menu(main_tb, pos++, "Protocol tree selection mode:", "Choose to browse or select.", selection_mode_vals, prefs.gui_ptree_sel_browse); g_object_set_data(G_OBJECT(main_vb), PTREE_SEL_BROWSE_KEY, ptree_browse_om); /* Geometry prefs */ save_position_cb = create_preference_check_button(main_tb, pos++, "Save window position:", "Whether to save the position of the main window.", prefs.gui_geometry_save_position); g_object_set_data(G_OBJECT(main_vb), GEOMETRY_POSITION_KEY, save_position_cb); save_size_cb = create_preference_check_button(main_tb, pos++, "Save window size:", "Whether to save the size of the main window.", prefs.gui_geometry_save_size); g_object_set_data(G_OBJECT(main_vb), GEOMETRY_SIZE_KEY, save_size_cb); save_maximized_cb = create_preference_check_button(main_tb, pos++, "Save maximized state:", "Whether to save the maximized state of the main window.", prefs.gui_geometry_save_maximized); g_object_set_data(G_OBJECT(main_vb), GEOMETRY_MAXIMIZED_KEY, save_maximized_cb); #if defined(HAVE_IGE_MAC_INTEGRATION) || defined(HAVE_GTKOSXAPPLICATION) macosx_style_cb = create_preference_check_button(main_tb, pos++, "Mac OS X style", "Whether to create a Mac OS X look and feel. Checking this box will move the " "menu bar to the top of the screen instead of the top of the Wireshark window. " "Requires a restart of Wireshark to take effect.", prefs.gui_macosx_style); g_object_set_data(G_OBJECT(main_vb), MACOSX_STYLE_KEY, macosx_style_cb); #endif #ifdef _WIN32 /* How the console window should be opened */ console_open_om = create_preference_option_menu(main_tb, pos++, "Open a console window", "Whether to open a console window " "(Automatic will open a console if messages appear).", gui_console_open_vals, prefs.gui_console_open); g_object_set_data(G_OBJECT(main_vb), GUI_CONSOLE_OPEN_KEY, console_open_om); #endif /* Allow user to select where they want the File Open dialog to open to * by default */ fileopen_rb = create_preference_radio_buttons(main_tb, pos++, "\"File Open\" dialog behavior:", "Which directory the \"File Open\" dialog should start with.", gui_fileopen_vals, prefs.gui_fileopen_style); /* Directory to default File Open dialog to */ fileopen_dir_te = create_preference_entry(main_tb, pos++, "Directory:", "The \"File Open\" dialog defaults always to this directory.", prefs.gui_fileopen_dir); g_object_set_data(G_OBJECT(main_vb), GUI_FILEOPEN_KEY, fileopen_rb); g_object_set_data(G_OBJECT(main_vb), GUI_FILEOPEN_DIR_KEY, fileopen_dir_te); g_signal_connect(fileopen_rb, "clicked", G_CALLBACK(fileopen_selected_cb), main_vb); g_signal_connect(fileopen_dir_te, "focus-out-event", G_CALLBACK(fileopen_dir_changed_cb), main_vb); /* File Open dialog preview timeout */ fileopen_preview_te = create_preference_entry(main_tb, pos++, "\"File Open\" preview timeout:", "Reading preview data in the \"File Open\" dialog will be stopped after given seconds.", open_file_preview_str); g_snprintf(current_val_str, sizeof(current_val_str), "%d", prefs.gui_fileopen_preview); gtk_entry_set_text(GTK_ENTRY(fileopen_preview_te), current_val_str); g_object_set_data(G_OBJECT(main_vb), GUI_FILEOPEN_PREVIEW_KEY, fileopen_preview_te); g_signal_connect(fileopen_preview_te, "focus_out_event", G_CALLBACK(fileopen_preview_changed_cb), main_vb); /* Number of recent entries in the display filter list ... */ recent_df_entries_max_te = create_preference_entry(main_tb, pos++, "Filter display max. list entries:", "Maximum number of recent entries in filter display list.", recent_df_entries_max_str); g_snprintf(current_val_str, sizeof(current_val_str), "%d", prefs.gui_recent_df_entries_max); gtk_entry_set_text(GTK_ENTRY(recent_df_entries_max_te), current_val_str); g_object_set_data(G_OBJECT(main_vb), GUI_RECENT_DF_ENTRIES_KEY, recent_df_entries_max_te); g_signal_connect(recent_df_entries_max_te, "focus_out_event", G_CALLBACK(recent_df_entries_changed_cb), main_vb); /* Number of entries in the recent_files list ... */ recent_files_count_max_te = create_preference_entry(main_tb, pos++, "\"Open Recent\" max. list entries:", "Maximum number of entries in the \"File/Open Recent\" list.", recent_files_count_max_str); g_snprintf(current_val_str, sizeof(current_val_str), "%d", prefs.gui_recent_files_count_max); gtk_entry_set_text(GTK_ENTRY(recent_files_count_max_te), current_val_str); g_object_set_data(G_OBJECT(main_vb), GUI_RECENT_FILES_COUNT_KEY, recent_files_count_max_te); g_signal_connect(recent_files_count_max_te, "focus_out_event", G_CALLBACK(recent_files_count_changed_cb), main_vb); fileopen_selected_cb(NULL, main_vb); /* ask for unsaved capture files? */ ask_unsaved_cb = create_preference_check_button(main_tb, pos++, "Ask for unsaved capture files:", "Whether a dialog should pop up in case of an unsaved capture file.", prefs.gui_ask_unsaved); g_object_set_data(G_OBJECT(main_vb), GUI_ASK_UNSAVED_KEY, ask_unsaved_cb); /* do we want to wrap when searching for data? */ find_wrap_cb = create_preference_check_button(main_tb, pos++, "Wrap to end/beginning of file during a find:", "Whether a search should wrap in a capture file.", prefs.gui_find_wrap); g_object_set_data(G_OBJECT(main_vb), GUI_FIND_WRAP_KEY, find_wrap_cb); /* show an explicit Save button for settings dialogs (preferences and alike)? */ use_pref_save_cb = create_preference_check_button(main_tb, pos++, "Settings dialogs show a save button:", "Whether the various settings dialogs (e.g. Preferences) should " "use an explicit save button - for advanced users.", prefs.gui_use_pref_save); g_object_set_data(G_OBJECT(main_vb), GUI_USE_PREF_SAVE_KEY, use_pref_save_cb); /* Show version in welcome screen */ show_version_cb = create_preference_check_button(main_tb, pos++, "Welcome screen and title bar shows version:", "Whether version should be shown in the start page and main screen's title bar.", prefs.gui_version_in_start_page ); g_object_set_data(G_OBJECT(main_vb), GUI_SHOW_VERSION_KEY, show_version_cb); /* Whether to auto scroll when expanding items */ auto_scroll_cb = create_preference_check_button(main_tb, pos++, "Auto scroll on expansion:", "Whether the details view should be automatically scrolled up when expanding an item.", prefs.gui_auto_scroll_on_expand ); g_object_set_data(G_OBJECT(main_vb), GUI_AUTO_SCROLL_KEY, auto_scroll_cb); /* Where to auto scroll to when expanding items */ scroll_percent_te = create_preference_entry(main_tb, pos++, "Auto scroll percentage:", "Where to scroll the expanded item to within the view e.g. 0% = top of view, 50% = center of view.", scroll_percent_preview_str); g_snprintf(current_val_str, sizeof(current_val_str), "%d", prefs.gui_auto_scroll_percentage); gtk_entry_set_text(GTK_ENTRY(scroll_percent_te), current_val_str); g_object_set_data(G_OBJECT(main_vb), GUI_SCROLL_PERCENT_KEY, scroll_percent_te); g_signal_connect(scroll_percent_te, "focus_out_event", G_CALLBACK(scroll_percent_changed_cb), main_vb); /* Webbrowser */ if (browser_needs_pref()) { webbrowser_te = create_preference_entry(main_tb, pos++, "Web browser command:", "Command line to desired browser.", prefs.gui_webbrowser); gtk_entry_set_text(GTK_ENTRY(webbrowser_te), prefs.gui_webbrowser); g_object_set_data(G_OBJECT(main_vb), GUI_WEBBROWSER_KEY, webbrowser_te); } /* Enable Expert Infos Dialog Tab Label "eye-candy" */ expert_info_eyecandy_cb = create_preference_check_button(main_tb, pos++, "Display LEDs in the Expert Infos dialog tab labels:", "Whether colored LED images should be displayed in the Expert Infos dialog tab labels.", prefs.gui_expert_composite_eyecandy ); g_object_set_data(G_OBJECT(main_vb), GUI_EXPERT_EYECANDY_KEY, expert_info_eyecandy_cb); /* Show 'em what we got */ gtk_widget_show_all(main_vb); return(main_vb); }
static gboolean _lib_tagging_tag_show(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, dt_lib_module_t* self) { int mouse_over_id = -1; int zoom = dt_conf_get_int("plugins/lighttable/images_in_row"); // the order is: // if(zoom == 1) => currently shown image // else if(selection not empty) => slected images // else if(cursor over image) => hovered image // else => return if(zoom == 1 || dt_collection_get_selected_count(darktable.collection) == 0) { DT_CTL_GET_GLOBAL(mouse_over_id, lib_image_mouse_over_id); if(mouse_over_id < 0) return TRUE; } dt_lib_tagging_t *d = (dt_lib_tagging_t*)self->data; d->floating_tag_imgid = mouse_over_id; gint x, y; gint px, py, w, h; GtkWidget *window = dt_ui_main_window(darktable.gui->ui); GtkWidget *center = dt_ui_center(darktable.gui->ui); gdk_window_get_origin(gtk_widget_get_window(center), &px, &py); gdk_window_get_size(gtk_widget_get_window(center),&w,&h); x = px + 0.5*(w-FLOATING_ENTRY_WIDTH); y = py + h - 50; /* put the floating box at the mouse pointer */ // gint pointerx, pointery; // gtk_widget_get_pointer(center, &pointerx, &pointery); // x = px + pointerx + 1; // y = py + pointery + 1; d->floating_tag_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* stackoverflow.com/questions/1925568/how-to-give-keyboard-focus-to-a-pop-up-gtk-window */ GTK_WIDGET_SET_FLAGS(d->floating_tag_window, GTK_CAN_FOCUS); gtk_window_set_decorated(GTK_WINDOW(d->floating_tag_window), FALSE); gtk_window_set_has_frame(GTK_WINDOW(d->floating_tag_window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(d->floating_tag_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU); gtk_window_set_transient_for(GTK_WINDOW(d->floating_tag_window), GTK_WINDOW(window)); gtk_window_set_opacity(GTK_WINDOW(d->floating_tag_window), 0.8); gtk_window_move(GTK_WINDOW(d->floating_tag_window), x, y); GtkWidget *entry = gtk_entry_new(); gtk_widget_set_size_request(entry, FLOATING_ENTRY_WIDTH, -1); gtk_widget_add_events(entry, GDK_FOCUS_CHANGE_MASK); GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(GTK_ENTRY(entry), completion); gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1); gtk_container_add(GTK_CONTAINER(d->floating_tag_window), entry); g_signal_connect_swapped(entry, "focus-out-event", G_CALLBACK(gtk_widget_destroy), d->floating_tag_window); g_signal_connect(entry, "key-press-event", G_CALLBACK(_lib_tagging_tag_key_press), self); gtk_widget_show_all(d->floating_tag_window); gtk_widget_grab_focus(entry); gtk_window_present(GTK_WINDOW(d->floating_tag_window)); return TRUE; }
Client * newclient(void) { int i; Client *c; WebKitWebSettings *settings; char *uri; if(!(c = calloc(1, sizeof(Client)))) die("Cannot malloc!\n"); /* Window */ if(embed) { c->win = gtk_plug_new(embed); } else { c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_wmclass(GTK_WINDOW(c->win), "surf", "surf"); } gtk_window_set_default_size(GTK_WINDOW(c->win), 800, 600); g_signal_connect(G_OBJECT(c->win), "destroy", G_CALLBACK(destroywin), c); g_signal_connect(G_OBJECT(c->win), "key-press-event", G_CALLBACK(keypress), c); if(!(c->items = calloc(1, sizeof(GtkWidget *) * LENGTH(items)))) die("Cannot malloc!\n"); /* contextmenu */ for(i = 0; i < LENGTH(items); i++) { c->items[i] = gtk_menu_item_new_with_label(items[i].label); g_signal_connect(G_OBJECT(c->items[i]), "activate", G_CALLBACK(itemclick), c); } /* VBox */ c->vbox = gtk_vbox_new(FALSE, 0); /* scrolled window */ c->scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(c->scroll), GTK_POLICY_NEVER, GTK_POLICY_NEVER); /* webview */ c->view = WEBKIT_WEB_VIEW(webkit_web_view_new()); g_signal_connect(G_OBJECT(c->view), "title-changed", G_CALLBACK(titlechange), c); g_signal_connect(G_OBJECT(c->view), "load-progress-changed", G_CALLBACK(progresschange), c); g_signal_connect(G_OBJECT(c->view), "load-finished", G_CALLBACK(loadfinished), c); g_signal_connect(G_OBJECT(c->view), "load-committed", G_CALLBACK(loadcommit), c); g_signal_connect(G_OBJECT(c->view), "load-started", G_CALLBACK(loadstart), c); g_signal_connect(G_OBJECT(c->view), "hovering-over-link", G_CALLBACK(linkhover), c); g_signal_connect(G_OBJECT(c->view), "create-web-view", G_CALLBACK(createwindow), c); g_signal_connect(G_OBJECT(c->view), "new-window-policy-decision-requested", G_CALLBACK(decidewindow), c); g_signal_connect(G_OBJECT(c->view), "download-requested", G_CALLBACK(initdownload), c); g_signal_connect(G_OBJECT(c->view), "window-object-cleared", G_CALLBACK(windowobjectcleared), c); g_signal_connect(G_OBJECT(c->view), "focus-in-event", G_CALLBACK(focusview), c); g_signal_connect(G_OBJECT(c->view), "populate-popup", G_CALLBACK(context), c); /* uribar */ c->uribar = gtk_entry_new(); gtk_entry_set_has_frame(GTK_ENTRY(c->uribar), FALSE); /* searchbar */ c->searchbar = gtk_entry_new(); gtk_entry_set_has_frame(GTK_ENTRY(c->searchbar), FALSE); /* indicator */ c->indicator = gtk_drawing_area_new(); gtk_widget_set_size_request(c->indicator, 0, 2); g_signal_connect (G_OBJECT (c->indicator), "expose_event", G_CALLBACK (exposeindicator), c); /* Arranging */ gtk_container_add(GTK_CONTAINER(c->scroll), GTK_WIDGET(c->view)); gtk_container_add(GTK_CONTAINER(c->win), c->vbox); gtk_container_add(GTK_CONTAINER(c->vbox), c->scroll); gtk_container_add(GTK_CONTAINER(c->vbox), c->searchbar); gtk_container_add(GTK_CONTAINER(c->vbox), c->uribar); gtk_container_add(GTK_CONTAINER(c->vbox), c->indicator); /* Setup */ gtk_box_set_child_packing(GTK_BOX(c->vbox), c->uribar, FALSE, FALSE, 0, GTK_PACK_START); gtk_box_set_child_packing(GTK_BOX(c->vbox), c->searchbar, FALSE, FALSE, 0, GTK_PACK_START); gtk_box_set_child_packing(GTK_BOX(c->vbox), c->indicator, FALSE, FALSE, 0, GTK_PACK_START); gtk_box_set_child_packing(GTK_BOX(c->vbox), c->scroll, TRUE, TRUE, 0, GTK_PACK_START); gtk_widget_grab_focus(GTK_WIDGET(c->view)); gtk_widget_hide_all(c->searchbar); gtk_widget_hide_all(c->uribar); gtk_widget_show(c->vbox); gtk_widget_show(c->indicator); gtk_widget_show(c->scroll); gtk_widget_show(GTK_WIDGET(c->view)); gtk_widget_show(c->win); gdk_window_set_events(GTK_WIDGET(c->win)->window, GDK_ALL_EVENTS_MASK); gdk_window_add_filter(GTK_WIDGET(c->win)->window, processx, c); webkit_web_view_set_full_content_zoom(c->view, TRUE); settings = webkit_web_view_get_settings(c->view); g_object_set(G_OBJECT(settings), "user-agent", useragent, NULL); uri = g_strconcat("file://", stylefile, NULL); g_object_set(G_OBJECT(settings), "user-stylesheet-uri", uri, NULL); g_free(uri); c->download = NULL; c->title = NULL; c->next = clients; clients = c; if(showxid) { gdk_display_sync(gtk_widget_get_display(c->win)); printf("%u\n", (guint)GDK_WINDOW_XID(GTK_WIDGET(c->win)->window)); fflush(NULL); } return c; }
void gnc_stock_split_assistant_finish (GtkAssistant *assistant, gpointer user_data) { StockSplitInfo *info = user_data; GList *account_commits; GList *node; gnc_numeric amount; Transaction *trans; Account *account; Split *split; time64 date; account = info->acct; g_return_if_fail (account != NULL); amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->distribution_edit)); g_return_if_fail (!gnc_numeric_zero_p (amount)); gnc_suspend_gui_refresh (); trans = xaccMallocTransaction (gnc_get_current_book ()); xaccTransBeginEdit (trans); xaccTransSetCurrency (trans, gnc_default_currency ()); date = gnc_date_edit_get_date (GNC_DATE_EDIT (info->date_edit)); xaccTransSetDatePostedSecsNormalized (trans, date); { const char *description; description = gtk_entry_get_text (GTK_ENTRY (info->description_entry)); xaccTransSetDescription (trans, description); } split = xaccMallocSplit (gnc_get_current_book ()); xaccAccountBeginEdit (account); account_commits = g_list_prepend (NULL, account); xaccTransAppendSplit (trans, split); xaccAccountInsertSplit (account, split); xaccSplitSetAmount (split, amount); xaccSplitMakeStockSplit (split); /* Set split-action with gnc_set_num_action which is the same as * xaccSplitSetAction with these arguments */ /* Translators: This string has a disambiguation prefix */ gnc_set_num_action (NULL, split, NULL, Q_("Action Column|Split")); amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->price_edit)); if (gnc_numeric_positive_p (amount)) { QofBook *book; GNCPrice *price; GNCPriceDB *pdb; GNCCurrencyEdit *ce; Timespec ts; ce = GNC_CURRENCY_EDIT (info->price_currency_edit); ts.tv_sec = date; ts.tv_nsec = 0; price = gnc_price_create (gnc_get_current_book ()); gnc_price_begin_edit (price); gnc_price_set_commodity (price, xaccAccountGetCommodity (account)); gnc_price_set_currency (price, gnc_currency_edit_get_currency (ce)); gnc_price_set_time (price, ts); gnc_price_set_source (price, "user:stock-split"); gnc_price_set_typestr (price, "unknown"); gnc_price_set_value (price, amount); gnc_price_commit_edit (price); book = gnc_get_current_book (); pdb = gnc_pricedb_get_db (book); if (!gnc_pricedb_add_price (pdb, price)) gnc_error_dialog (info->window, "%s", _("Error adding price.")); gnc_price_unref (price); } amount = gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (info->cash_edit)); if (gnc_numeric_positive_p (amount)) { const char *memo; memo = gtk_entry_get_text (GTK_ENTRY (info->memo_entry)); /* asset split */ account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->asset_tree)); split = xaccMallocSplit (gnc_get_current_book ()); xaccAccountBeginEdit (account); account_commits = g_list_prepend (account_commits, account); xaccAccountInsertSplit (account, split); xaccTransAppendSplit (trans, split); xaccSplitSetAmount (split, amount); xaccSplitSetValue (split, amount); xaccSplitSetMemo (split, memo); /* income split */ account = gnc_tree_view_account_get_selected_account (GNC_TREE_VIEW_ACCOUNT(info->income_tree)); split = xaccMallocSplit (gnc_get_current_book ()); xaccAccountBeginEdit (account); account_commits = g_list_prepend (account_commits, account); xaccAccountInsertSplit (account, split); xaccTransAppendSplit (trans, split); xaccSplitSetAmount (split, gnc_numeric_neg (amount)); xaccSplitSetValue (split, gnc_numeric_neg (amount)); xaccSplitSetMemo (split, memo); } xaccTransCommitEdit (trans); for (node = account_commits; node; node = node->next) xaccAccountCommitEdit (node->data); g_list_free (account_commits); gnc_resume_gui_refresh (); gnc_close_gui_component_by_data (ASSISTANT_STOCK_SPLIT_CM_CLASS, info); }
void on_bt_wine_port_ok_clicked (GtkButton *button, gpointer user_data) { FILE * fd; FILE * fo; int find=0; char enr[512]; char enr2[512]; char ftemp[512]; strcpy(ftemp,XWineDir); strcat(ftemp,"/temp.conf"); /* Ports Séries */ fd=fopen(FichierConfig,"rt"); fo=fopen(ftemp,"wt"); fgets(enr, 512, fd); while (!feof(fd)) { if (chaine_contient(enr,"[serialports]")) { find=1; fputs(enr,fo); strcpy(enr2,"\"Com1\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_COM1")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Com2\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_COM2")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Com3\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_COM3")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Com4\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_COM4")))); strcat(enr2,"\"\n"); fputs(enr2,fo); } else if (chaine_contient(enr,"#") || chaine_contient(enr,"[")) find=0; if (!find) fputs(enr,fo); fgets(enr, 512, fd); } fclose(fd); fclose(fo); // Ports Parallèles fo=fopen(FichierConfig,"wt"); fd=fopen(ftemp,"rt"); find=0; fgets(enr, 512, fd); while (!feof(fd)) { if (chaine_contient(enr,"[parallelports]")) { find=1; fputs(enr,fo); strcpy(enr2,"\"Lpt1\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPT1")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Lpt2\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPT2")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Lpt3\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPT3")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"Lpt4\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPT4")))); strcat(enr2,"\"\n"); fputs(enr2,fo); } else if (chaine_contient(enr,"#") || chaine_contient(enr,"[")) find=0; if (!find) fputs(enr,fo); fgets(enr, 512, fd); } fclose(fd); fclose(fo); // Imprimantes fd=fopen(FichierConfig,"rt"); fo=fopen(ftemp,"wt"); find=0; fgets(enr, 512, fd); while (!feof(fd)) { if (chaine_contient(enr,"[spooler]")) { find=1; fputs(enr,fo); strcpy(enr2,"\"LPT1:\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPR1")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"LPT2:\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPR2")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"LPT3:\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPR3")))); strcat(enr2,"\"\n"); fputs(enr2,fo); strcpy(enr2,"\"LPT4:\" = \""); strcat(enr2,gtk_entry_get_text(GTK_ENTRY(lookup_widget(W_WINE_PORT,"E_LPR4")))); strcat(enr2,"\"\n"); fputs(enr2,fo); } else if (chaine_contient(enr,"#") || chaine_contient(enr,"[")) find=0; if (!find) fputs(enr,fo); fgets(enr, 512, fd); } fclose(fd); fclose(fo); /* Recopier le fichier Config */ fd=fopen(FichierConfig,"wt"); fo=fopen(ftemp,"rt"); fgets(enr, 512, fo); while (!feof(fo)) { fputs(enr,fd); fgets(enr, 512, fo); } fclose(fd); fclose(fo); ecrire_dans_log(texte[178],texte[191]); gtk_widget_destroy(W_WINE_PORT); }
static void gopt_str_store_set_val(struct gopt_str *s, const char *text) { if (text) gtk_entry_set_text(GTK_ENTRY(s->entry), text); }
static void search_prev_clicked (GtkWidget *button, GtkWidget *entry) { search (gtk_entry_get_text (GTK_ENTRY (entry)), FALSE); }
static gboolean formhistory_check_master_password (GtkWidget* parent, FormHistoryPriv* priv) { GtkWidget* dialog; GtkWidget* content_area; GtkWidget* hbox; GtkWidget* image; GtkWidget* label; GtkWidget* entry; const gchar* title; static int alive; gboolean ret = FALSE; /* Password is set */ if (priv->master_password && *priv->master_password) return TRUE; /* Other prompt is active */ if (alive == 1) return FALSE; /* Prompt was cancelled */ if (priv->master_password_canceled == 1) return FALSE; alive = 1; title = _("Form history"); dialog = gtk_dialog_new_with_buttons (title, GTK_WINDOW (parent), GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DIALOG_AUTHENTICATION); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_container_set_border_width (GTK_CONTAINER (content_area), 5); hbox = gtk_hbox_new (FALSE, 8); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); label = gtk_label_new (_("Master password required\n" "to open password database")); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, TRUE, 0); entry = gtk_entry_new (); g_object_set (entry, "truncate-multiline", TRUE, NULL); gtk_entry_set_visibility(GTK_ENTRY (entry),FALSE); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); gtk_box_pack_start (GTK_BOX (content_area), entry, FALSE, TRUE, 0); gtk_widget_show_all (entry); gtk_widget_show_all (hbox); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { /* FIXME: add password verification */ katze_assign (priv->master_password, g_strdup (gtk_entry_get_text (GTK_ENTRY (entry)))); ret = TRUE; } else priv->master_password_canceled = 1; gtk_widget_destroy (dialog); alive = 0; return ret; }
bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value, const wxPoint& pos, const wxSize& size, int n, const wxString choices[], long style, const wxValidator& validator, const wxString& name ) { m_ignoreNextUpdate = false; m_needParent = true; m_acceptsFocus = true; m_prevSelection = 0; if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxComboBox creation failed") ); return false; } m_widget = gtk_combo_new(); GtkCombo *combo = GTK_COMBO(m_widget); // Disable GTK's broken events ... gtk_signal_disconnect( GTK_OBJECT(combo->entry), combo->entry_change_id ); // ... and add surrogate handler. combo->entry_change_id = gtk_signal_connect (GTK_OBJECT (combo->entry), "changed", (GtkSignalFunc) gtk_dummy_callback, combo); // make it more useable gtk_combo_set_use_arrows_always( GTK_COMBO(m_widget), TRUE ); // and case-sensitive gtk_combo_set_case_sensitive( GTK_COMBO(m_widget), TRUE ); GtkWidget *list = GTK_COMBO(m_widget)->list; // gtk_list_set_selection_mode( GTK_LIST(list), GTK_SELECTION_MULTIPLE ); for (int i = 0; i < n; i++) { GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( choices[i] ) ); m_clientDataList.Append( NULL ); m_clientObjectList.Append( NULL ); gtk_container_add( GTK_CONTAINER(list), list_item ); gtk_widget_show( list_item ); } m_parent->DoAddChild( this ); m_focusWidget = combo->entry; PostCreation(size); ConnectWidget( combo->button ); // MSW's combo box shows the value and the selection is -1 gtk_entry_set_text( GTK_ENTRY(combo->entry), wxGTK_CONV(value) ); gtk_list_unselect_all( GTK_LIST(combo->list) ); if (style & wxCB_READONLY) gtk_entry_set_editable( GTK_ENTRY( combo->entry ), FALSE ); // "show" and "hide" events are generated when user click on the combobox button which popups a list // this list is the "popwin" gtk widget gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "hide", GTK_SIGNAL_FUNC(gtk_popup_hide_callback), (gpointer)this ); gtk_signal_connect( GTK_OBJECT(GTK_COMBO(combo)->popwin), "show", GTK_SIGNAL_FUNC(gtk_popup_show_callback), (gpointer)this ); gtk_signal_connect_after( GTK_OBJECT(combo->entry), "changed", GTK_SIGNAL_FUNC(gtk_text_changed_callback), (gpointer)this ); gtk_signal_connect_after( GTK_OBJECT(combo->list), "select-child", GTK_SIGNAL_FUNC(gtk_combo_select_child_callback), (gpointer)this ); SetInitialSize(size); // need this too because this is a wxControlWithItems // This is required for tool bar support // wxSize setsize = GetSize(); // gtk_widget_set_usize( m_widget, setsize.x, setsize.y ); return true; }
GtkWidget * do_search_entry (GtkWidget *do_widget) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *entry; GtkWidget *find_button; GtkWidget *cancel_button; if (!window) { window = gtk_dialog_new_with_buttons ("Search Entry", GTK_WINDOW (do_widget), 0, GTK_STOCK_CLOSE, GTK_RESPONSE_NONE, NULL); gtk_window_set_resizable (GTK_WINDOW (window), FALSE); g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_signal_connect (window, "destroy", G_CALLBACK (search_entry_destroyed), &window); vbox = gtk_vbox_new (FALSE, 5); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "Search entry demo"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hbox), 0); /* Create our entry */ entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0); /* Create the find and cancel buttons */ notebook = gtk_notebook_new (); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook), FALSE); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook), FALSE); gtk_box_pack_start (GTK_BOX (hbox), notebook, FALSE, FALSE, 0); find_button = gtk_button_new_with_label ("Find"); g_signal_connect (find_button, "clicked", G_CALLBACK (start_search), entry); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), find_button, NULL); gtk_widget_show (find_button); cancel_button = gtk_button_new_with_label ("Cancel"); g_signal_connect (cancel_button, "clicked", G_CALLBACK (stop_search), NULL); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), cancel_button, NULL); gtk_widget_show (cancel_button); /* Set up the search icon */ search_by_name (NULL, GTK_ENTRY (entry)); /* Set up the clear icon */ gtk_entry_set_icon_from_stock (GTK_ENTRY (entry), GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CLEAR); text_changed_cb (GTK_ENTRY (entry), NULL, find_button); g_signal_connect (entry, "icon-press", G_CALLBACK (icon_press_cb), NULL); g_signal_connect (entry, "notify::text", G_CALLBACK (text_changed_cb), find_button); g_signal_connect (entry, "activate", G_CALLBACK (activate_cb), NULL); /* Create the menu */ menu = create_search_menu (entry); gtk_menu_attach_to_widget (GTK_MENU (menu), entry, NULL); /* add accessible alternatives for icon functionality */ g_signal_connect (entry, "populate-popup", G_CALLBACK (entry_populate_popup), NULL); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else { gtk_widget_destroy (menu); gtk_widget_destroy (window); window = NULL; } return window; }
void wxComboBox::SetEditable( bool editable ) { GtkWidget *entry = GTK_COMBO(m_widget)->entry; gtk_entry_set_editable( GTK_ENTRY(entry), editable ); }
gchar *xmi_msim_gui_compound_dialog_get_compound(XmiMsimGuiCompoundDialog *dialog) { return g_strdup(gtk_entry_get_text(GTK_ENTRY(dialog->compoundEntry))); }