static GtkWidget * default_keyserver_frame (SettingsDlg *dialog) { GtkWidget *frame; GtkWidget *label; GtkWidget *combo; GList *servers; /* Build UI */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); label = gtk_label_new_with_mnemonic (_("<b>Default key_server</b>")); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_frame_set_label_widget (GTK_FRAME (frame), label); combo = gtk_combo_box_entry_new_text (); gtk_container_set_border_width (GTK_CONTAINER (combo), 5); gtk_container_add (GTK_CONTAINER (frame), combo); /* Set current value. */ servers = keyserver_get_as_glist (); g_list_foreach (servers, append_to_combo, combo); g_list_free (servers); dialog->keyserver.combo = GTK_COMBO_BOX (combo); g_signal_connect_swapped (G_OBJECT (combo), "changed", G_CALLBACK (keyserver_selected_from_list_cb), dialog); dialog->keyserver.frame = frame; return frame; }
static void wired_private_init (CEPageWired *self) { CEPageWiredPrivate *priv = CE_PAGE_WIRED_GET_PRIVATE (self); GtkBuilder *builder; GtkWidget *align; GtkLabel *label; builder = CE_PAGE (self)->builder; #if GTK_CHECK_VERSION(2,24,0) priv->device_mac = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->device_mac), 0); #else priv->device_mac = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ()); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->device_mac), 0); #endif gtk_widget_set_tooltip_text (GTK_WIDGET (priv->device_mac), _("This option locks this connection to the network device specified by its permanent MAC address entered here. Example: 00:11:22:33:44:55")); align = GTK_WIDGET (gtk_builder_get_object (builder, "wired_device_mac_alignment")); gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->device_mac)); gtk_widget_show_all (GTK_WIDGET (priv->device_mac)); /* Set mnemonic widget for device MAC label */ label = GTK_LABEL (GTK_WIDGET (gtk_builder_get_object (builder, "wired_device_mac_label"))); gtk_label_set_mnemonic_widget (label, GTK_WIDGET (priv->device_mac)); priv->cloned_mac = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "wired_cloned_mac"))); priv->port = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wired_port"))); priv->speed = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wired_speed"))); priv->duplex = GTK_TOGGLE_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wired_duplex"))); priv->autonegotiate = GTK_TOGGLE_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wired_autonegotiate"))); priv->mtu = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wired_mtu"))); }
static void vlan_private_init (CEPageVlan *self) { CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self); GtkBuilder *builder; GtkWidget *align; GtkLabel *label; builder = CE_PAGE (self)->builder; #if GTK_CHECK_VERSION(2,24,0) priv->parent = GTK_COMBO_BOX (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (priv->parent, 0); #else priv->parent = GTK_COMBO_BOX (gtk_combo_box_entry_new_text ()); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->parent), 0); #endif priv->parent_entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (priv->parent))); align = GTK_WIDGET (gtk_builder_get_object (builder, "vlan_parent_alignment")); gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->parent)); gtk_widget_show_all (GTK_WIDGET (priv->parent)); /* Set mnemonic widget for parent label */ label = GTK_LABEL (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_parent_label"))); gtk_label_set_mnemonic_widget (label, GTK_WIDGET (priv->parent)); priv->id_entry = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_id_entry"))); priv->name_entry = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_name_entry"))); priv->cloned_mac = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_cloned_mac_entry"))); priv->mtu = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "vlan_mtu"))); }
GtkWidget *combo_box_text_new_with_entry (void) { #if GTK_MAJOR_VERSION >= 3 return gtk_combo_box_text_new_with_entry(); #else return gtk_combo_box_entry_new_text(); #endif }
/*# @method new_text GtkComboBoxEntry @brief Create a new text GtkComboBoxEntry. Convenience function which constructs a new editable text combo box, which is a GtkComboBoxEntry just displaying strings. If you use this function to create a text combo box, you should only manipulate its data source with the following convenience functions: append_text(), insert_text(), prepend_text() and remove_text(). */ FALCON_FUNC ComboBoxEntry::new_text( VMARG ) { #ifndef NO_PARAMETER_CHECK if ( vm->paramCount() ) throw_require_no_args(); #endif GtkWidget* wdt = gtk_combo_box_entry_new_text(); vm->retval( new Gtk::ComboBoxEntry( vm->findWKI( "GtkComboBoxEntry" )->asClass(), (GtkComboBoxEntry*) wdt ) ); }
void wxComboBox::GTKCreateComboBoxWidget() { #ifdef __WXGTK3__ m_widget = gtk_combo_box_text_new_with_entry(); #else m_widget = gtk_combo_box_entry_new_text(); #endif g_object_ref(m_widget); m_entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(m_widget))); }
void wxComboBox::GTKCreateComboBoxWidget() { #ifdef __WXGTK3__ m_widget = gtk_combo_box_text_new_with_entry(); #else m_widget = gtk_combo_box_entry_new_text(); #endif g_object_ref(m_widget); m_entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(m_widget))); g_object_add_weak_pointer(G_OBJECT(m_entry), (void**)&m_entry); }
/* Create the command_combo_box. Called once, either by | ghid_command_window_show() or ghid_command_entry_get(). Then as long as | ghidgui->use_command_window is TRUE, the command_combo_box will live | in a command window vbox or float if the command window is not up. | But if ghidgui->use_command_window is FALSE, the command_combo_box | will live in the status_line_hbox either shown or hidden. | Since it's never destroyed, the combo history strings never need | rebuilding and history is maintained if the combo box location is moved. */ static void command_combo_box_entry_create (void) { ghidgui->command_combo_box = gtk_combo_box_entry_new_text (); ghidgui->command_entry = GTK_ENTRY (gtk_bin_get_child (GTK_BIN (ghidgui->command_combo_box))); gtk_entry_set_width_chars (ghidgui->command_entry, 40); gtk_entry_set_activates_default (ghidgui->command_entry, TRUE); g_signal_connect (G_OBJECT (ghidgui->command_entry), "activate", G_CALLBACK (command_entry_activate_cb), NULL); g_object_ref (G_OBJECT (ghidgui->command_combo_box)); /* so can move it */ }
int clip_GTK_COMBOBOXENTRYNEWTEXT(ClipMachine * cm) { ClipVar * cv = _clip_spar(cm, 1); GtkWidget *wid = NULL; C_widget *cwid; CHECKOPT(1,MAP_t); wid = gtk_combo_box_entry_new_text(); if (!wid) goto err; cwid = _register_widget(cm, wid, cv); _clip_mclone(cm,RETPTR(cm),&cwid->obj); return 0; err: return 1; }
int main(int argc, char **argv) { gtk_init(&argc,&argv); static GtkWidget *window = NULL; GtkWidget *frame, *box, *combo, *entry; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Combo boxes"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_container_set_border_width (GTK_CONTAINER (window), 10); frame = gtk_frame_new ("Editable"); gtk_container_add (GTK_CONTAINER (window), frame); box = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), box); combo = gtk_combo_box_entry_new_text (); fill_combo_entry (combo); gtk_container_add (GTK_CONTAINER (box), combo); entry = g_object_new (TYPE_MASK_ENTRY, NULL); //MASK_ENTRY (entry)->mask = "^([0-9]*|One|Two|2\302\275|Three)$"; gtk_container_remove (GTK_CONTAINER (combo), GTK_BIN (combo)->child); gtk_container_add (GTK_CONTAINER (combo), entry); } if (!GTK_WIDGET_VISIBLE (window)) { gtk_widget_show_all (window); } else { gtk_widget_destroy (window); window = NULL; } gtk_widget_show_all (window); gtk_main (); }
static GtkWidget * servlist_create_charsetcombo (void) { GtkWidget *cb; int i; cb = gtk_combo_box_entry_new_text (); gtk_combo_box_append_text (GTK_COMBO_BOX (cb), "System default"); i = 0; while (pages[i]) { gtk_combo_box_append_text (GTK_COMBO_BOX (cb), (char *)pages[i]); i++; } g_signal_connect (G_OBJECT (GTK_BIN (cb)->child), "changed", G_CALLBACK (servlist_combo_cb), NULL); return cb; }
ZLGtkApplicationWindow::GtkEntryParameter::GtkEntryParameter(ZLGtkApplicationWindow &window, const ZLToolbar::ParameterItem &item) : myWindow(window), myItem(item) { if (item.type() == ZLToolbar::Item::COMBO_BOX) { myWidget = gtk_combo_box_entry_new_text(); myEntry = GTK_ENTRY(GTK_BIN(myWidget)->child); ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myEntry), "changed", GTK_SIGNAL_FUNC(::onValueChanged), this); } else { myWidget = gtk_entry_new(); myEntry = GTK_ENTRY(myWidget); } gtk_entry_set_alignment(myEntry, 0.5); gtk_entry_set_width_chars(myEntry, item.maxWidth()); gtk_entry_set_max_length(myEntry, item.maxWidth()); if (item.symbolSet() == ZLToolbar::ParameterItem::SET_DIGITS) { hildon_gtk_entry_set_input_mode(myEntry, HILDON_GTK_INPUT_MODE_NUMERIC); } else { hildon_gtk_entry_set_input_mode(myEntry, HILDON_GTK_INPUT_MODE_FULL); } ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myEntry), "key_press_event", GTK_SIGNAL_FUNC(::onKeyPressed), this); }
void ComboOptionView::_createItem() { const ZLComboOptionEntry &comboOptionEntry = (ZLComboOptionEntry&)*myOption; if (!name().empty()) { myLabel = gtkLabel(name()); } myComboBox = comboOptionEntry.isEditable() ? GTK_COMBO_BOX(gtk_combo_box_entry_new_text()) : GTK_COMBO_BOX(gtk_combo_box_new_text()); g_signal_connect(GTK_WIDGET(myComboBox), "changed", G_CALLBACK(_onValueChanged), this); if (myLabel != 0) { myHolder.attachWidgets(*this, GTK_WIDGET(myLabel), GTK_WIDGET(myComboBox)); } else { myHolder.attachWidget(*this, GTK_WIDGET(myComboBox)); } reset(); }
void ComboOptionView::_createItem() { const ZLComboOptionEntry &comboOptionEntry = (ZLComboOptionEntry&)*myOption; if (!ZLOptionView::name().empty()) { myLabel = gtkLabel(ZLOptionView::name()); } myComboBox = comboOptionEntry.isEditable() ? GTK_COMBO_BOX(gtk_combo_box_entry_new_text()) : GTK_COMBO_BOX(gtk_combo_box_new_text()); g_signal_connect(GTK_WIDGET(myComboBox), "changed", G_CALLBACK(_onValueChanged), this); if (myLabel != 0) { int midColumn = (myFromColumn + myToColumn) / 2; myTab->addItem(GTK_WIDGET(myLabel), myRow, myFromColumn, midColumn); myTab->addItem(GTK_WIDGET(myComboBox), myRow, midColumn, myToColumn); } else { myTab->addItem(GTK_WIDGET(myComboBox), myRow, myFromColumn, myToColumn); } reset(); }
static VALUE rg_initialize(int argc, VALUE *argv, VALUE self) { VALUE model_or_false, text_column; GtkWidget* widget; rb_scan_args(argc, argv, "02", &model_or_false, &text_column); if (rb_obj_is_kind_of(model_or_false, GTYPE2CLASS(GTK_TYPE_TREE_MODEL))){ widget = gtk_combo_box_entry_new_with_model( GTK_TREE_MODEL(RVAL2GOBJ(model_or_false)), NUM2INT(text_column)); } else if (NIL_P(model_or_false) || TYPE(model_or_false) == T_TRUE){ widget = gtk_combo_box_entry_new_text(); } else if (TYPE(model_or_false) == T_FALSE){ widget = gtk_combo_box_entry_new(); } else { rb_raise(rb_eArgError, "invalid 2nd argument %s (except true/false or Gtk::TreeModel)", rb_class2name(CLASS_OF(model_or_false))); } RBGTK_INITIALIZE(self, widget); return Qnil; }
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; } #ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) { m_widget = gtk_combo_box_entry_new_text(); GtkComboBox* combobox = GTK_COMBO_BOX( m_widget ); gtk_entry_set_editable( GTK_ENTRY( GTK_BIN(m_widget)->child ), TRUE ); for (int i = 0; i < n; i++) { gtk_combo_box_append_text( combobox, wxGTK_CONV( choices[i] ) ); m_clientDataList.Append( (wxObject*)NULL ); m_clientObjectList.Append( (wxObject*)NULL ); } } else #endif { m_widget = gtk_combo_new(); GtkCombo* combo = GTK_COMBO(m_widget); // Disable GTK's broken events ... g_signal_handler_disconnect (combo->entry, combo->entry_change_id); // ... and add surrogate handler. combo->entry_change_id = g_signal_connect (combo->entry, "changed", G_CALLBACK (gtkcombo_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 ); if (style & wxNO_BORDER) g_object_set (combo->entry, "has-frame", FALSE, NULL ); GtkWidget *list = combo->list; for (int i = 0; i < n; i++) { GtkWidget *list_item = gtk_list_item_new_with_label( wxGTK_CONV( choices[i] ) ); m_clientDataList.Append( (wxObject*)NULL ); m_clientObjectList.Append( (wxObject*)NULL ); gtk_container_add( GTK_CONTAINER(list), list_item ); gtk_widget_show( list_item ); } } m_parent->DoAddChild( this ); GtkEntry *entry = NULL; #ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) entry = GTK_ENTRY( GTK_BIN(m_widget)->child ); else #endif entry = GTK_ENTRY( GTK_COMBO(m_widget)->entry ); m_focusWidget = GTK_WIDGET( entry ); PostCreation(size); #ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) ConnectWidget( m_widget ); else #endif ConnectWidget( GTK_COMBO(m_widget)->button ); #ifdef __WXGTK24__ if (!gtk_check_version(2,4,0)) { gtk_entry_set_text( entry, wxGTK_CONV(value) ); if (style & wxCB_READONLY) gtk_entry_set_editable( entry, FALSE ); g_signal_connect_after (entry, "changed", G_CALLBACK (gtkcombobox_text_changed_callback), this); g_signal_connect_after (m_widget, "changed", G_CALLBACK (gtkcombobox_changed_callback), this); } else #endif { GtkCombo *combo = GTK_COMBO(m_widget); // MSW's combo box shows the value and the selection is -1 gtk_entry_set_text( entry, wxGTK_CONV(value) ); gtk_list_unselect_all( GTK_LIST(combo->list) ); if (style & wxCB_READONLY) gtk_entry_set_editable( 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 g_signal_connect (GTK_COMBO(combo)->popwin, "hide", G_CALLBACK (gtkcombo_popup_hide_callback), this); g_signal_connect (GTK_COMBO(combo)->popwin, "show", G_CALLBACK (gtkcombo_popup_show_callback), this); g_signal_connect_after (combo->list, "select-child", G_CALLBACK (gtkcombo_combo_select_child_callback), this); g_signal_connect_after (entry, "changed", G_CALLBACK (gtkcombo_text_changed_callback), this); // This is required for tool bar support // Doesn't currently work // wxSize setsize = GetSize(); // gtk_widget_set_size_request( m_widget, setsize.x, setsize.y ); } SetInitialSize(size); // need this too because this is a wxControlWithItems return true; }
static void qq_loginpanel_init(QQLoginPanel *obj) { login_users = gqq_config_get_all_login_user(cfg); //Put the last login user at the first of the array gint i; GQQLoginUser *usr, *tmp; for(i = 0; i < login_users -> len; ++i){ usr = (GQQLoginUser*)g_ptr_array_index(login_users, i); if(usr == NULL){ continue; } if(usr -> last == 1){ break; } } if(i < login_users -> len){ tmp = login_users -> pdata[0]; login_users -> pdata[0] = login_users -> pdata[i]; login_users -> pdata[i] = tmp; } obj -> uin_label = gtk_label_new("QQ Number:"); obj -> uin_entry = gtk_combo_box_entry_new_text(); for(i = 0; i < login_users -> len; ++i){ usr = (GQQLoginUser*)g_ptr_array_index(login_users, i); gtk_combo_box_append_text(GTK_COMBO_BOX(obj -> uin_entry) , usr -> qqnumber); } gtk_combo_box_set_active(GTK_COMBO_BOX(obj -> uin_entry), 0); obj -> passwd_label = gtk_label_new("Password:"******"changed" , G_CALLBACK(qqnumber_combox_changed), obj); //not visibily gtk_entry_set_visibility(GTK_ENTRY(obj -> passwd_entry), FALSE); gtk_widget_set_size_request(obj -> uin_entry, 200, -1); gtk_widget_set_size_request(obj -> passwd_entry, 220, -1); GtkWidget *vbox = gtk_vbox_new(FALSE, 10); //uin label and entry GtkWidget *uin_hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(uin_hbox), obj -> uin_label, FALSE, FALSE, 0); GtkWidget *uin_vbox = gtk_vbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(uin_vbox), uin_hbox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(uin_vbox), obj -> uin_entry, FALSE, FALSE, 0); //password label and entry GtkWidget *passwd_hbox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(passwd_hbox), obj -> passwd_label , FALSE, FALSE, 0); GtkWidget *passwd_vbox = gtk_vbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(passwd_vbox), passwd_hbox, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(passwd_vbox), obj -> passwd_entry, FALSE, FALSE, 0); //put uin and password in a vbox gtk_box_pack_start(GTK_BOX(vbox), uin_vbox, FALSE, FALSE, 2); gtk_box_pack_start(GTK_BOX(vbox), passwd_vbox, FALSE, FALSE, 2); //rember password check box obj -> rempwcb = gtk_check_button_new_with_label("Remeber Password"); if(login_users -> len > 0){ usr = (GQQLoginUser*)g_ptr_array_index(login_users, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(obj -> rempwcb), usr->rempw); } /* g_signal_connect(G_OBJECT(obj -> rempwcb), "toggled" */ /* , G_CALLBACK(qqnumber_combox_changed), obj); */ GtkWidget *hbox4 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox4), obj -> rempwcb, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox4, FALSE, TRUE, 2); //login button obj -> login_btn = gtk_button_new_with_label("Login"); gtk_widget_set_size_request(obj -> login_btn, 90, -1); g_signal_connect(G_OBJECT(obj -> login_btn), "clicked" , G_CALLBACK(login_btn_cb), (gpointer)obj); //status combo box obj -> status_comb = qq_statusbutton_new(); if(login_users -> len > 0){ usr = (GQQLoginUser*)g_ptr_array_index(login_users, 0); qq_statusbutton_set_status_string(obj -> status_comb, usr -> status); } #ifdef USE_PROXY //proxy setting obj -> set_proxy_btn = gtk_button_new_with_label("Network"); gtk_widget_set_size_request(obj -> set_proxy_btn, 100, -1); g_signal_connect(G_OBJECT(obj -> set_proxy_btn), "clicked" , G_CALLBACK(set_proxy_btn_cb), (gpointer)obj); #endif /* USE_PROXY */ GtkWidget *hbox1 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox1), vbox, TRUE, FALSE, 0); GtkWidget *hbox2 = gtk_hbox_new(FALSE, 0); GtkWidget *hbox3 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox2), obj -> status_comb, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox2), obj -> login_btn, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox3), hbox2, TRUE, FALSE, 0); #ifdef USE_PROXY GtkWidget *hbox_proxy_setting = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox_proxy_setting), GTK_BUTTONBOX_CENTER); gtk_box_pack_start(GTK_BOX(hbox_proxy_setting), obj -> set_proxy_btn, FALSE, FALSE, 0); #endif /* USE_PROXY */ //error informatin label obj -> err_label = gtk_label_new(""); GdkColor color; GdkColormap *cmap = gdk_colormap_get_system(); gdk_colormap_alloc_color(cmap, &color, TRUE, TRUE); gdk_color_parse("#fff000000", &color); //red //change text color to red //MUST modify fb, not text gtk_widget_modify_fg(obj -> err_label, GTK_STATE_NORMAL, &color); hbox2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox2), obj -> err_label, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox2, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, FALSE, 0); #ifdef USE_PROXY gtk_box_pack_start(GTK_BOX(vbox), hbox_proxy_setting, TRUE, TRUE, 10); #endif /* USE_PROXY */ gtk_box_set_homogeneous(GTK_BOX(obj), FALSE); GtkWidget *logo = gtk_image_new_from_file(IMGDIR"webqq_icon.png"); gtk_widget_set_size_request(logo, -1, 150); gtk_box_pack_start(GTK_BOX(obj), logo, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(obj), hbox1, FALSE, FALSE, 15); }
/** * Create the toolbar for the integrated UI * @return Main toolbar (GtkToolbar*) for the integrated UI main window */ static GtkWidget * create_integrated_ui_toolbar (void) { GtkToolbar *toolbar; GtkToolItem *sep; GtkWidget *w; GError *error = NULL; gchar *uifile; uifile = build_ui_filename ("ui/toolbar-ui.xml"); if (!gtk_ui_manager_add_ui_from_file (_ui_manager, uifile, &error)) { g_warning ("building menus failed: %s", error->message); g_error_free (error); error = NULL; toolbar = GTK_TOOLBAR (gtk_toolbar_new ()); } else { toolbar = GTK_TOOLBAR(gtk_ui_manager_get_widget (_ui_manager, "/Toolbar")); } g_free (uifile); /* Zoom Combo Box Entry */ #if GTK_CHECK_VERSION(2,24,0) w = gtk_combo_box_text_new_with_entry (); #else w = gtk_combo_box_entry_new_text (); #endif g_object_set_data (G_OBJECT (toolbar), DIA_INTEGRATED_TOOLBAR_ZOOM_COMBO, w); integrated_ui_toolbar_add_custom_item (toolbar, w); #if GTK_CHECK_VERSION(2,24,0) gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), ZOOM_FIT); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("800%")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("400%")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("300%")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("200%")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("150%")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("100%")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("75%")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("50%")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("25%")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (w), _("10%")); #else gtk_combo_box_append_text (GTK_COMBO_BOX (w), ZOOM_FIT); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("800%")); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("400%")); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("300%")); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("200%")); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("150%")); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("100%")); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("75%")); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("50%")); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("25%")); gtk_combo_box_append_text (GTK_COMBO_BOX (w), _("10%")); #endif g_signal_connect (G_OBJECT (w), "changed", G_CALLBACK (integrated_ui_toolbar_zoom_combo_selection_changed), NULL); /* Get the combo's GtkEntry child to set the width for the widget */ w = gtk_bin_get_child (GTK_BIN (w)); gtk_entry_set_width_chars (GTK_ENTRY (w), 6); g_signal_connect (G_OBJECT (w), "activate", G_CALLBACK(integrated_ui_toolbar_zoom_activate), NULL); /* Seperator */ sep = gtk_separator_tool_item_new (); gtk_toolbar_insert (toolbar, sep, -1); gtk_widget_show (GTK_WIDGET (sep)); /* Snap to grid */ w = dia_toggle_button_new_with_icons (dia_on_grid_icon, dia_off_grid_icon); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (integrated_ui_toolbar_grid_snap_toggle), toolbar); gtk_widget_set_tooltip_text (w, _("Toggles snap-to-grid.")); g_object_set_data (G_OBJECT (toolbar), DIA_INTEGRATED_TOOLBAR_SNAP_GRID, w); integrated_ui_toolbar_add_custom_item (toolbar, w); /* Object Snapping */ w = dia_toggle_button_new_with_icons (dia_mainpoints_on_icon, dia_mainpoints_off_icon); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (integrated_ui_toolbar_object_snap_toggle), toolbar); gtk_widget_set_tooltip_text (w, _("Toggles object snapping.")); g_object_set_data (G_OBJECT (toolbar), DIA_INTEGRATED_TOOLBAR_OBJECT_SNAP, w); integrated_ui_toolbar_add_custom_item (toolbar, w); sep = gtk_separator_tool_item_new (); gtk_toolbar_insert (toolbar, sep, -1); gtk_widget_show (GTK_WIDGET (sep)); return GTK_WIDGET (toolbar); }
Compose * compose_new(Config * config) { Compose * compose; GtkAccelGroup * group; GtkWidget * vbox; GtkWidget * toolbar; GtkToolItem * toolitem; GtkSizeGroup * sizegroup; GtkWidget * vpaned; GtkWidget * vbox2; GtkWidget * widget; GtkCellRenderer * renderer; GtkTreeViewColumn * column; GtkTreeIter iter; char const * headers[] = { "To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:", "Followup-To:" }; size_t i; if((compose = malloc(sizeof(*compose))) == NULL) { compose_error(NULL, strerror(errno), 0); return NULL; } compose->mime = mime_new(NULL); /* check errors */ if(compose->mime == NULL) { free(compose); return NULL; } compose->config = config; compose->standalone = FALSE; /* window */ group = gtk_accel_group_new(); compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_add_accel_group(GTK_WINDOW(compose->window), group); #ifndef EMBEDDED gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384); #else gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300); #endif gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose")); #if GTK_CHECK_VERSION(2, 6, 0) gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer"); #endif g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event", G_CALLBACK(_compose_on_closex), compose); vbox = gtk_vbox_new(FALSE, 0); /* menubar */ #ifndef EMBEDDED widget = desktop_menubar_create(_compose_menubar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); #endif /* toolbar */ toolbar = desktop_toolbar_create(_compose_toolbar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0); /* from */ sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("From: ")); gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); gtk_widget_set_size_request(widget, 80, -1); gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); #if GTK_CHECK_VERSION(2, 24, 0) compose->from = gtk_combo_box_text_new_with_entry(); #else compose->from = gtk_combo_box_entry_new_text(); #endif toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->from); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); /* paned */ vpaned = gtk_vpaned_new(); /* headers */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL( compose->h_store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER( compose->h_store_filter), _compose_on_headers_filter, compose, NULL); compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL( compose->h_store_filter)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE); compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); for(i = 0; i < sizeof(headers) / sizeof(*headers); i++) { gtk_list_store_append(compose->h_headers, &iter); gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1, headers[i], -1); } renderer = gtk_cell_renderer_combo_new(); g_object_set(renderer, "editable", TRUE, "model", compose->h_headers, "text-column", 1, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_field_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_HEADER, NULL); gtk_tree_view_column_set_min_width(column, 80); gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_VALUE, NULL); #if GTK_CHECK_VERSION(2, 4, 0) gtk_tree_view_column_set_expand(column, TRUE); #endif gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); /* default to 8-bits transfers with UTF-8 encoding */ compose_set_header(compose, "Content-Transfer-Encoding:", "8bit", FALSE); compose_set_header(compose, "Content-Type:", "text/plain; charset=UTF-8", FALSE); compose_add_field(compose, "To:", NULL); gtk_container_add(GTK_CONTAINER(widget), compose->h_view); gtk_paned_add1(GTK_PANED(vpaned), widget); /* paned */ vbox2 = gtk_vbox_new(FALSE, 0); /* subject */ toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("Subject: ")); gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); compose->subject = gtk_entry_new(); toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->subject); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0); /* view */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->view = _new_text_view(compose); compose_set_font(compose, _compose_get_font(compose)); gtk_container_add(GTK_CONTAINER(widget), compose->view); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); gtk_paned_add2(GTK_PANED(vpaned), vbox2); gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0); /* attachments */ compose->a_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF); compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL( compose->a_store)); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view), CAC_ICON); gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view), CAC_BASENAME); gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view); gtk_widget_show_all(compose->a_view); gtk_widget_set_no_show_all(compose->a_window, TRUE); gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0); /* statusbar */ compose->statusbar = gtk_statusbar_new(); compose->statusbar_id = 0; gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0); gtk_container_add(GTK_CONTAINER(compose->window), vbox); /* about dialog */ compose->ab_window = NULL; /* signature */ compose_append_signature(compose); compose_set_modified(compose, FALSE); compose_scroll_to_offset(compose, 0); /* display */ gtk_widget_grab_focus(compose->view); gtk_widget_show_all(vbox); gtk_widget_show(compose->window); return compose; }
static void lcrt_serial_show(struct lcrt_qconnect *lqconnect) { GtkWidget *vbox; GtkWidget *vbox_spec; GtkWidget *hbox1; GtkWidget *label_port; GtkWidget *combobox_port; GtkWidget *label_baud_rate; GtkWidget *combobox_baud_rate; GtkWidget *label_data_bits; GtkWidget *combobox_data_bits; GtkWidget *label_parity; GtkWidget *combobox_parity; GtkWidget *label_stop_bits; GtkWidget *combobox_stop_bits; GtkWidget *frame; GtkWidget *alignment; GtkWidget *hbox_frame; GtkWidget *checkbutton_software; GtkWidget *checkbutton_hardware; GtkWidget *label_flow_control; int i; const char *sport[LCRT_SERIAL_PORT_NUMBER] = {LCRT_SERIAL_PORT}; const struct lcrt_serial_map sbaud_rate[LCRT_SERIAL_BAUD_RATE_NUMBER] = {LCRT_SERIAL_BAUD_RATE_TABLE}; const struct lcrt_serial_map sdata_bits[LCRT_SERIAL_DATA_BITS_NUMBER] = {LCRT_SERIAL_DATA_BITS_TABLE}; const struct lcrt_serial_map sparity[LCRT_SERIAL_PARITY_NUMBER] = {LCRT_SERIAL_PARITY_TABLE}; const struct lcrt_serial_map sstop_bits[LCRT_SERIAL_STOP_BITS_NUMBER] = {LCRT_SERIAL_STOP_BITS_TABLE}; const struct lcrt_serial_map flow_control[LCRT_SEROAL_FLOW_CONTROL_NUMBER] = {LCRT_SEROAL_FLOW_CONTROL_TABLE}; static struct lcrt_serial_if slserial, *lserial = &slserial; struct lcrtc_user *user = NULL; char s_port[USERNAME_LEN]; boolean f_option = FALSE; int s_baud_rate,s_databit,s_parity,s_stopbit,s_software,s_hardware; if (lqconnect->flag == LCRT_QCONNECT_SESSION_OPTION && (user = lcrt_user_find_by_name(&lqconnect->parent->u_config, lqconnect->uname)) != NULL) { sscanf(user->password, "%s %d %d %d %d %d %d", s_port, &s_baud_rate, &s_databit, &s_parity, &s_stopbit, &s_software, &s_hardware); debug_print("SERIAL PORT: %s %d %d %d %d %d %d\n", s_port, s_baud_rate, s_databit, s_parity, s_stopbit, s_software, s_hardware); f_option = TRUE; } memset(lserial, 0, sizeof(struct lcrt_serial_if)); lqconnect->private_data = lserial; vbox = GTK_DIALOG (lqconnect->q_connect)->vbox; debug_where(); vbox_spec = gtk_vbox_new (FALSE, 0); lqconnect->q_vbox_spec = vbox_spec; gtk_widget_show (vbox_spec); gtk_box_pack_start (GTK_BOX (vbox), vbox_spec, TRUE, TRUE, 0); gtk_box_reorder_child (GTK_BOX (vbox), vbox_spec, 1); gtk_widget_set_size_request (vbox_spec, -1, 210); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_port = gtk_label_new (lqconnect->config.value[LCRT_Q_SPORT]); gtk_widget_show (label_port); gtk_box_pack_start (GTK_BOX (hbox1), label_port, FALSE, FALSE, 0); gtk_widget_set_size_request (label_port, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_port), 0, 0.5); combobox_port = gtk_combo_box_entry_new_text (); lserial->port = combobox_port; gtk_widget_show (combobox_port); gtk_box_pack_start (GTK_BOX (hbox1), combobox_port, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_port, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_PORT_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_port), sport[i]); if (f_option && strcmp(s_port, sport[i]) == 0) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_port), i); } debug_where(); //gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_port)->child), FALSE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_baud_rate = gtk_label_new (lqconnect->config.value[LCRT_Q_SBAUD_RATE]); gtk_widget_show (label_baud_rate); gtk_box_pack_start (GTK_BOX (hbox1), label_baud_rate, FALSE, FALSE, 0); gtk_widget_set_size_request (label_baud_rate, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_baud_rate), 0, 0.5); combobox_baud_rate = gtk_combo_box_entry_new_text (); lserial->baud_rate = combobox_baud_rate; gtk_widget_show (combobox_baud_rate); gtk_box_pack_start (GTK_BOX (hbox1), combobox_baud_rate, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_baud_rate, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_BAUD_RATE_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_baud_rate), sbaud_rate[i].name); if (f_option && s_baud_rate == sbaud_rate[i].data) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_baud_rate), i); } debug_where(); gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_baud_rate)->child), FALSE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_data_bits = gtk_label_new (lqconnect->config.value[LCRT_Q_SDATA_BITS]); gtk_widget_show (label_data_bits); gtk_box_pack_start (GTK_BOX (hbox1), label_data_bits, FALSE, FALSE, 0); gtk_widget_set_size_request (label_data_bits, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_data_bits), 0, 0.5); combobox_data_bits = gtk_combo_box_entry_new_text (); lserial->data_bits = combobox_data_bits; gtk_widget_show (combobox_data_bits); gtk_box_pack_start (GTK_BOX (hbox1), combobox_data_bits, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_data_bits, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_DATA_BITS_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_data_bits), sdata_bits[i].name); if (f_option && s_databit == sdata_bits[i].data) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_data_bits), i); } debug_where(); gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_data_bits)->child), FALSE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_parity = gtk_label_new (lqconnect->config.value[LCRT_Q_SPARITY]); gtk_widget_show (label_parity); gtk_box_pack_start (GTK_BOX (hbox1), label_parity, FALSE, FALSE, 0); gtk_widget_set_size_request (label_parity, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_parity), 0, 0.5); combobox_parity = gtk_combo_box_entry_new_text (); lserial->parity = combobox_parity; gtk_widget_show (combobox_parity); gtk_box_pack_start (GTK_BOX (hbox1), combobox_parity, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_parity, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_PARITY_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_parity), sparity[i].name); } if (f_option) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_parity), s_parity); debug_where(); gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_parity)->child), FALSE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_stop_bits = gtk_label_new (lqconnect->config.value[LCRT_Q_SSTOP_BITS]); gtk_widget_show (label_stop_bits); gtk_box_pack_start (GTK_BOX (hbox1), label_stop_bits, FALSE, FALSE, 0); gtk_widget_set_size_request (label_stop_bits, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_stop_bits), 0, 0.5); combobox_stop_bits = gtk_combo_box_entry_new_text (); lserial->stop_bits = combobox_stop_bits; gtk_widget_show (combobox_stop_bits); gtk_box_pack_start (GTK_BOX (hbox1), combobox_stop_bits, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_stop_bits, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_STOP_BITS_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_stop_bits), sstop_bits[i].name); } if (f_option) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_stop_bits), s_stopbit); debug_where(); gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_stop_bits)->child), FALSE); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_widget_set_size_request (frame, -1, 40); gtk_box_pack_start (GTK_BOX (vbox_spec), frame, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); hbox_frame = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox_frame); gtk_container_add (GTK_CONTAINER (alignment), hbox_frame); checkbutton_software = gtk_check_button_new_with_mnemonic (flow_control[0].name); lserial->software = checkbutton_software; gtk_widget_show (checkbutton_software); gtk_box_pack_start (GTK_BOX (hbox_frame), checkbutton_software, FALSE, FALSE, 0); gtk_widget_set_size_request (checkbutton_software, 150, -1); if (f_option) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_software), s_software); checkbutton_hardware = gtk_check_button_new_with_mnemonic (flow_control[1].name); lserial->hardware = checkbutton_hardware; gtk_widget_show (checkbutton_hardware); gtk_box_pack_start (GTK_BOX (hbox_frame), checkbutton_hardware, FALSE, FALSE, 0); gtk_widget_set_size_request (checkbutton_hardware, 150, -1); if (f_option) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_hardware), s_hardware); label_flow_control = gtk_label_new (lqconnect->config.value[LCRT_Q_SFLOW_CONTROL]); gtk_widget_show (label_flow_control); gtk_frame_set_label_widget (GTK_FRAME (frame), label_flow_control); gtk_label_set_use_markup (GTK_LABEL (label_flow_control), TRUE); if (!f_option) { gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_port), 1); //ttyS0 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_baud_rate), 10); //115200 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_data_bits), 3); //8 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_parity), 0); //None gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_stop_bits), 0); //1 debug_print("active = %d\n", gtk_combo_box_get_active(GTK_COMBO_BOX(combobox_baud_rate))); } gtk_widget_set_sensitive(lqconnect->q_bt_connect, TRUE); }
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; }
static gint t98_newdisk_dialog(GtkWidget *dialog, const int kind) { static const char *hddsizestr[] = { "20", "41", "65", "80", "128", }; char buf[32]; GtkWidget *dialog_table; GtkWidget *label; GtkWidget *hbox; GtkWidget *combo; GtkWidget *entry; const char *p; int hdsize; int minsize, maxsize; gint rv; int i; minsize = 5; switch (kind) { case 2: /* THD */ maxsize = 256; break; case 3: /* NHD */ maxsize = 512; break; default: return 0; } /* dialog table */ dialog_table = gtk_table_new(2, 3, FALSE); gtk_table_set_col_spacings(GTK_TABLE(dialog_table), 5); #if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 14) gtk_container_add( GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), dialog_table); #else gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox),dialog_table); #endif gtk_widget_show(dialog_table); /* "HDD Size" label */ label = gtk_label_new(str_hddsize); gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5); gtk_table_attach_defaults(GTK_TABLE(dialog_table), label, 0, 1, 0, 1); gtk_widget_show(label); /* HDD Size */ hbox = gtk_hbox_new(FALSE, 2); gtk_container_set_border_width(GTK_CONTAINER(hbox), 0); gtk_table_attach_defaults(GTK_TABLE(dialog_table), hbox, 1, 2, 0, 1); gtk_widget_show(hbox); combo = gtk_combo_box_entry_new_text(); for (i = 0; i < NELEMENTS(hddsizestr); ++i) { gtk_combo_box_append_text(GTK_COMBO_BOX(combo), hddsizestr[i]); } gtk_widget_set_size_request(combo, 60, -1); gtk_box_pack_start(GTK_BOX(hbox), combo, FALSE, FALSE, 5); gtk_widget_show(combo); entry = gtk_bin_get_child(GTK_BIN(combo)); gtk_editable_set_editable(GTK_EDITABLE(entry), TRUE); gtk_entry_set_max_length(GTK_ENTRY(entry), 3); gtk_entry_set_text(GTK_ENTRY(entry), ""); gtk_widget_show(entry); /* "MB" label */ label = gtk_label_new("MB"); gtk_misc_set_alignment(GTK_MISC(label), 0.1, 0.5); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_widget_show(label); /* size label */ g_snprintf(buf, sizeof(buf), "(%d-%dMB)", minsize, maxsize); label = gtk_label_new(buf); gtk_misc_set_alignment(GTK_MISC(label), 0.9, 0.5); gtk_table_attach_defaults(GTK_TABLE(dialog_table), label, 1, 2, 1, 2); gtk_widget_show(label); gtk_widget_show_all(dialog); for (;;) { rv = gtk_dialog_run(GTK_DIALOG(dialog)); if (rv == GTK_RESPONSE_CANCEL) { hdsize = 0; break; } if (rv == GTK_RESPONSE_OK) { p = gtk_entry_get_text(GTK_ENTRY(entry)); if (p && strlen(p) != 0) { hdsize = milstr_solveINT(p); if (hdsize >= minsize && hdsize <= maxsize) { return hdsize; } gtk_entry_set_text(GTK_ENTRY(entry), ""); } } } return 0; }
/* Function to open a dialog box displaying the message provided. */ GtkWidget * build_dialog_layout_variant_management(GtkWidget *parent, Distribution_Dialog *dist_dialog) { /* Create the widgets */ GtkWidget *hbox, *vbox, *dialog; dialog = gtk_dialog_new_with_buttons(_("Pick a keyboard layout"), GTK_WINDOW(parent), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); gtk_widget_set_size_request(dialog, 450, 180); dist_dialog->content = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_container_set_border_width(GTK_CONTAINER(dialog), 4); GtkFrame * frame = GTK_FRAME(gtk_frame_new(_("Distribution:"))); gtk_widget_set_size_request(GTK_WIDGET(frame), 300, 50); gtk_container_add(GTK_CONTAINER(dist_dialog->content), GTK_WIDGET(frame)); vbox = gtk_vbox_new(FALSE, INNER_SPACE); gtk_container_add(GTK_CONTAINER(frame), vbox); hbox = gtk_hbox_new(FALSE, INNER_SPACE); GtkWidget *layout_label = gtk_label_new(_("Layout:")); GtkWidget *variant_label = gtk_label_new(_("Variant: ")); gtk_container_add(GTK_CONTAINER(hbox), layout_label); gtk_container_add(GTK_CONTAINER(hbox), variant_label); gtk_container_add(GTK_CONTAINER(vbox), hbox); dist_dialog->layout_cbox = gtk_combo_box_entry_new_text(); dist_dialog->variant_cbox = gtk_combo_box_new_text(); gtk_widget_set_size_request(dist_dialog->layout_cbox, 100, 40); gtk_widget_set_size_request(dist_dialog->variant_cbox, 200, 40); fill_cbox_layouts(dist_dialog->layout_cbox); hbox = gtk_hbox_new(FALSE, INNER_SPACE); gtk_container_add(GTK_CONTAINER(hbox), dist_dialog->layout_cbox); gtk_container_add(GTK_CONTAINER(hbox), dist_dialog->variant_cbox); gtk_widget_set_size_request(dist_dialog->layout_cbox, 70, 30); gtk_widget_set_size_request(dist_dialog->variant_cbox, 70, 30); gtk_container_add(GTK_CONTAINER(vbox), hbox); g_signal_connect(G_OBJECT(dist_dialog->layout_cbox), "changed", G_CALLBACK(combo_layout_selected), dist_dialog); g_signal_connect(G_OBJECT(dist_dialog->variant_cbox), "changed", G_CALLBACK(combo_variant_selected), dist_dialog); hbox = gtk_hbox_new(FALSE, INNER_SPACE); // Testa area GtkWidget *label = gtk_label_new(_("Test here:")); dist_dialog->test_field = gtk_entry_new_with_max_length(50); gtk_container_add(GTK_CONTAINER(hbox), GTK_WIDGET(label)); gtk_container_add(GTK_CONTAINER(hbox), GTK_WIDGET(dist_dialog->test_field)); gtk_widget_set_size_request(label, 70, 30); gtk_widget_set_size_request(dist_dialog->test_field, 340, 30); gtk_container_add(GTK_CONTAINER(dist_dialog->content), GTK_WIDGET(hbox)); gtk_widget_show_all(dist_dialog->content); return dialog; }
static void alsa_make_config_widgets (alsa_driver *d) { GtkWidget *thing, *mainbox, *box2; GtkListStore *ls; GtkCellRenderer *cell; static const char *resolutionlabels[] = { "8 bits", "16 bits", NULL }; static const char *channelslabels[] = { "Mono", "Stereo", NULL }; d->configwidget = mainbox = gtk_vbox_new(FALSE, 2); thing = gtk_label_new(_("These changes won't take effect until you restart playing.")); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(mainbox), thing, FALSE, TRUE, 0); thing = gtk_hseparator_new(); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(mainbox), thing, FALSE, TRUE, 0); box2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(box2); gtk_box_pack_start(GTK_BOX(mainbox), box2, FALSE, TRUE, 0); thing = gtk_label_new(_("Device:")); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); thing = gtk_button_new_with_label("Test"); gtk_widget_show(thing); gtk_box_pack_end(GTK_BOX(box2), thing, FALSE, TRUE, 0); g_signal_connect(thing, "clicked", G_CALLBACK(device_test), d); d->alsa_device = gtk_combo_box_entry_new_text(); gtk_widget_show(d->alsa_device); gtk_box_pack_end(GTK_BOX(box2), d->alsa_device, FALSE, TRUE, 0); box2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(box2); gtk_box_pack_start(GTK_BOX(mainbox), box2, FALSE, TRUE, 0); thing = gtk_label_new(_("Resolution:")); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); add_empty_hbox(box2); make_radio_group_full(resolutionlabels, box2, d->prefs_resolution_w, FALSE, TRUE, (void(*)())prefs_resolution_changed, d); box2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(box2); gtk_box_pack_start(GTK_BOX(mainbox), box2, FALSE, TRUE, 0); thing = gtk_label_new(_("Channels:")); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); add_empty_hbox(box2); make_radio_group_full(channelslabels, box2, d->prefs_channels_w, FALSE, TRUE, (void(*)())prefs_channels_changed, d); box2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(box2); gtk_box_pack_start(GTK_BOX(mainbox), box2, FALSE, TRUE, 0); thing = gtk_label_new(_("Frequency [Hz]:")); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); ls = gtk_list_store_new(1, G_TYPE_UINT); d->model = GTK_TREE_MODEL(ls); thing = d->prefs_mixfreq = gtk_combo_box_new_with_model(GTK_TREE_MODEL(ls)); g_object_unref(ls); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(thing), cell, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(thing), cell, "text", 0, NULL); gtk_box_pack_end(GTK_BOX(box2), thing, FALSE, TRUE, 0); gtk_widget_show(thing); g_signal_connect(thing, "changed", G_CALLBACK(prefs_mixfreq_changed), d); box2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(box2); gtk_box_pack_start(GTK_BOX(mainbox), box2, FALSE, TRUE, 0); thing = gtk_label_new(_("Buffer Size:")); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); add_empty_hbox(box2); thing = gtk_label_new("2^"); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); d->bufsizespin = thing = gtk_spin_button_new_with_range(8.0, 16.0, 1.0); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); gtk_widget_show(thing); g_signal_connect(thing, "value-changed", G_CALLBACK(prefs_bufsize_changed), d); d->bufsizelabel = thing = gtk_label_new(" = "); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); gtk_widget_show(thing); box2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(box2); gtk_box_pack_start(GTK_BOX(mainbox), box2, FALSE, TRUE, 0); thing = gtk_label_new(_("Number of Periods:")); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); add_empty_hbox(box2); thing = gtk_label_new("2^"); gtk_widget_show(thing); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); d->periodspin = thing = gtk_spin_button_new_with_range(1.0, 4.0, 1.0); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); gtk_widget_show(thing); g_signal_connect(thing, "value-changed", G_CALLBACK(prefs_periods_changed), d); d->periodlabel = thing = gtk_label_new(" = "); gtk_box_pack_start(GTK_BOX(box2), thing, FALSE, TRUE, 0); gtk_widget_show(thing); box2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(box2); gtk_box_pack_start(GTK_BOX(mainbox), box2, FALSE, TRUE, 0); d->estimatelabel = thing = gtk_label_new(""); gtk_box_pack_end(GTK_BOX(box2), thing, FALSE, TRUE, 0); gtk_widget_show(thing); }
GtkWidget *a_uibuilder_new_widget ( VikLayerParam *param, VikLayerParamData data ) { // Perform pre conversion if necessary VikLayerParamData vlpd = data; if ( param->convert_to_display ) vlpd = param->convert_to_display ( data ); GtkWidget *rv = NULL; switch ( param->widget_type ) { case VIK_LAYER_WIDGET_COLOR: if ( param->type == VIK_LAYER_PARAM_COLOR ) rv = gtk_color_button_new_with_color ( &(vlpd.c) ); break; case VIK_LAYER_WIDGET_CHECKBUTTON: if ( param->type == VIK_LAYER_PARAM_BOOLEAN ) { //rv = gtk_check_button_new_with_label ( //param->title ); rv = gtk_check_button_new (); if ( vlpd.b ) gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON(rv), TRUE ); } break; case VIK_LAYER_WIDGET_COMBOBOX: if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data ) { /* Build a simple combobox */ gchar **pstr = param->widget_data; rv = vik_combo_box_text_new (); while ( *pstr ) vik_combo_box_text_append ( rv, *(pstr++) ); if ( param->extra_widget_data ) /* map of alternate uint values for options */ { /* Set the effective default value */ int i; for ( i = 0; ((const char **)param->widget_data)[i]; i++ ) if ( ((guint *)param->extra_widget_data)[i] == vlpd.u ) { /* Match default value */ gtk_combo_box_set_active ( GTK_COMBO_BOX(rv), i ); break; } } else gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), vlpd.u ); } else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && !param->extra_widget_data ) { /* Build a combobox with editable text */ gchar **pstr = param->widget_data; #if GTK_CHECK_VERSION (2, 24, 0) rv = gtk_combo_box_text_new_with_entry (); #else rv = gtk_combo_box_entry_new_text (); #endif if ( vlpd.s ) vik_combo_box_text_append ( rv, vlpd.s ); while ( *pstr ) vik_combo_box_text_append ( rv, *(pstr++) ); if ( vlpd.s ) gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 ); } else if ( param->type == VIK_LAYER_PARAM_STRING && param->widget_data && param->extra_widget_data) { /* Build a combobox with fixed selections without editable text */ gchar **pstr = param->widget_data; rv = GTK_WIDGET ( vik_combo_box_text_new () ); while ( *pstr ) vik_combo_box_text_append ( rv, *(pstr++) ); if ( vlpd.s ) { /* Set the effective default value */ /* In case of value does not exist, set the first value */ gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 ); int i; for ( i = 0; ((const char **)param->widget_data)[i]; i++ ) if ( strcmp(((const char **)param->extra_widget_data)[i], vlpd.s) == 0 ) { /* Match default value */ gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), i ); break; } } else gtk_combo_box_set_active ( GTK_COMBO_BOX ( rv ), 0 ); } break; case VIK_LAYER_WIDGET_RADIOGROUP: /* widget_data and extra_widget_data are GList */ if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data ) { rv = vik_radio_group_new ( param->widget_data ); if ( param->extra_widget_data ) /* map of alternate uint values for options */ { int i; int nb_elem = g_list_length(param->widget_data); for ( i = 0; i < nb_elem; i++ ) if ( GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, i) ) == vlpd.u ) { vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i ); break; } } else if ( vlpd.u ) /* zero is already default */ vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u ); } break; case VIK_LAYER_WIDGET_RADIOGROUP_STATIC: if ( param->type == VIK_LAYER_PARAM_UINT && param->widget_data ) { rv = vik_radio_group_new_static ( (const gchar **) param->widget_data ); if ( param->extra_widget_data ) /* map of alternate uint values for options */ { int i; for ( i = 0; ((const char **)param->widget_data)[i]; i++ ) if ( ((guint *)param->extra_widget_data)[i] == vlpd.u ) { vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), i ); break; } } else if ( vlpd.u ) /* zero is already default */ vik_radio_group_set_selected ( VIK_RADIO_GROUP(rv), vlpd.u ); } break; case VIK_LAYER_WIDGET_SPINBUTTON: if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT || param->type == VIK_LAYER_PARAM_INT) && param->widget_data ) { gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i); VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data; rv = gtk_spin_button_new ( GTK_ADJUSTMENT(gtk_adjustment_new( init_val, scale->min, scale->max, scale->step, scale->step, 0 )), scale->step, scale->digits ); } break; case VIK_LAYER_WIDGET_ENTRY: if ( param->type == VIK_LAYER_PARAM_STRING ) { rv = gtk_entry_new (); if ( vlpd.s ) gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s ); } break; case VIK_LAYER_WIDGET_PASSWORD: if ( param->type == VIK_LAYER_PARAM_STRING ) { rv = gtk_entry_new (); gtk_entry_set_visibility ( GTK_ENTRY(rv), FALSE ); if ( vlpd.s ) gtk_entry_set_text ( GTK_ENTRY(rv), vlpd.s ); gtk_widget_set_tooltip_text ( GTK_WIDGET(rv), _("Take care that this password will be stored clearly in a plain file.") ); } break; case VIK_LAYER_WIDGET_FILEENTRY: if ( param->type == VIK_LAYER_PARAM_STRING ) { rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_OPEN); if ( vlpd.s ) vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s ); } break; case VIK_LAYER_WIDGET_FOLDERENTRY: if ( param->type == VIK_LAYER_PARAM_STRING ) { rv = vik_file_entry_new (GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); if ( vlpd.s ) vik_file_entry_set_filename ( VIK_FILE_ENTRY(rv), vlpd.s ); } break; case VIK_LAYER_WIDGET_FILELIST: if ( param->type == VIK_LAYER_PARAM_STRING_LIST ) { rv = vik_file_list_new ( _(param->title) ); vik_file_list_set_files ( VIK_FILE_LIST(rv), vlpd.sl ); } break; case VIK_LAYER_WIDGET_HSCALE: if ( (param->type == VIK_LAYER_PARAM_DOUBLE || param->type == VIK_LAYER_PARAM_UINT || param->type == VIK_LAYER_PARAM_INT) && param->widget_data ) { gdouble init_val = (param->type == VIK_LAYER_PARAM_DOUBLE) ? vlpd.d : (param->type == VIK_LAYER_PARAM_UINT ? vlpd.u : vlpd.i); VikLayerParamScale *scale = (VikLayerParamScale *) param->widget_data; rv = gtk_hscale_new_with_range ( scale->min, scale->max, scale->step ); gtk_scale_set_digits ( GTK_SCALE(rv), scale->digits ); gtk_range_set_value ( GTK_RANGE(rv), init_val ); } } if ( rv && !gtk_widget_get_tooltip_text ( rv ) ) { if ( param->tooltip ) gtk_widget_set_tooltip_text ( rv, _(param->tooltip) ); } return rv; }
GtkWidget * do_combobox (GtkWidget *do_widget) { static GtkWidget *window = NULL; GtkWidget *vbox, *frame, *box, *combo; GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreePath *path; GtkTreeIter iter; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Combo boxes"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_container_set_border_width (GTK_CONTAINER (window), 10); vbox = gtk_vbox_new (FALSE, 2); gtk_container_add (GTK_CONTAINER (window), vbox); /* A combobox demonstrating cell renderers, separators and * insensitive rows */ frame = gtk_frame_new ("Some stock icons"); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); box = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (box), 5); gtk_container_add (GTK_CONTAINER (frame), box); model = create_stock_icon_store (); combo = gtk_combo_box_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (box), combo); renderer = gtk_cell_renderer_pixbuf_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, FALSE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "pixbuf", PIXBUF_COL, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), renderer, set_sensitive, NULL, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", TEXT_COL, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), renderer, set_sensitive, NULL, NULL); gtk_combo_box_set_row_separator_func (GTK_COMBO_BOX (combo), is_separator, NULL, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0); /* A combobox demonstrating trees. */ frame = gtk_frame_new ("Where are we ?"); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); box = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (box), 5); gtk_container_add (GTK_CONTAINER (frame), box); model = create_capital_store (); combo = gtk_combo_box_new_with_model (model); g_object_unref (model); gtk_container_add (GTK_CONTAINER (box), combo); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", 0, NULL); gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (combo), renderer, is_capital_sensitive, NULL, NULL); path = gtk_tree_path_new_from_indices (0, 8, -1); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo), &iter); /* A GtkComboBoxEntry */ frame = gtk_frame_new ("Editable"); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); box = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (box), 5); gtk_container_add (GTK_CONTAINER (frame), box); combo = gtk_combo_box_entry_new_text (); fill_combo_entry (combo); gtk_container_add (GTK_CONTAINER (box), combo); } if (!GTK_WIDGET_VISIBLE (window)) { gtk_widget_show_all (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
void glatex_insert_environment_dialog(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED gpointer gdata) { GtkWidget *dialog = NULL; GtkWidget *vbox = NULL; GtkWidget *label_env = NULL; GtkWidget *textbox_env = NULL; GtkWidget *table = NULL; GtkWidget *tmp_entry = NULL; GtkTreeModel *model = NULL; gint i, max; dialog = gtk_dialog_new_with_buttons(_("Insert Environment"), GTK_WINDOW(geany->main_widgets->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); vbox = ui_dialog_vbox_new(GTK_DIALOG(dialog)); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_box_set_spacing(GTK_BOX(vbox), 10); table = gtk_table_new(1, 2, FALSE); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_table_set_row_spacings(GTK_TABLE(table), 6); label_env = gtk_label_new(_("Environment:")); textbox_env = gtk_combo_box_entry_new_text(); max = glatex_count_menu_entries(glatex_environment_array, -1); for (i = 0; i < max; i++) { gtk_combo_box_append_text(GTK_COMBO_BOX(textbox_env), glatex_environment_array[i].label); } model = gtk_combo_box_get_model(GTK_COMBO_BOX(textbox_env)); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(model), 0, GTK_SORT_ASCENDING); gtk_misc_set_alignment(GTK_MISC(label_env), 0, 0.5); gtk_table_attach_defaults(GTK_TABLE(table), label_env, 0, 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), textbox_env, 1, 2, 0, 1); gtk_container_add(GTK_CONTAINER(vbox), table); tmp_entry = gtk_bin_get_child(GTK_BIN(textbox_env)); g_signal_connect(G_OBJECT(tmp_entry), "activate", G_CALLBACK(glatex_enter_key_pressed_in_entry), dialog); gtk_widget_show_all(vbox); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { gchar *env_string = NULL; env_string = g_strdup(gtk_combo_box_get_active_text( GTK_COMBO_BOX(textbox_env))); if (env_string != NULL) { glatex_insert_environment(env_string, -1); g_free(env_string); } } gtk_widget_destroy(dialog); }
static void sp_font_selector_init(SPFontSelector *fsel) { gtk_box_set_homogeneous(GTK_BOX(fsel), TRUE); gtk_box_set_spacing(GTK_BOX(fsel), 4); /* Family frame */ GtkWidget *f = gtk_frame_new(_("Font family")); gtk_widget_show (f); gtk_box_pack_start (GTK_BOX(fsel), f, TRUE, TRUE, 0); GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(sw); gtk_container_set_border_width(GTK_CONTAINER (sw), 4); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(f), sw); Inkscape::FontLister* fontlister = Inkscape::FontLister::get_instance(); fsel->family_treeview = gtk_tree_view_new (); GtkTreeViewColumn *column = gtk_tree_view_column_new (); GtkCellRenderer *cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(fsel->family_treeview), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(fsel->family_treeview), FALSE); Glib::RefPtr<Gtk::ListStore> store = fontlister->get_font_list(); gtk_tree_view_set_model (GTK_TREE_VIEW(fsel->family_treeview), GTK_TREE_MODEL (Glib::unwrap (store))); gtk_container_add(GTK_CONTAINER(sw), fsel->family_treeview); gtk_widget_show_all (sw); GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(fsel->family_treeview)); g_signal_connect (G_OBJECT(selection), "changed", G_CALLBACK (sp_font_selector_family_select_row), fsel); g_object_set_data (G_OBJECT(fsel), "family-treeview", fsel->family_treeview); /* Style frame */ f = gtk_frame_new(C_("Font selector", "Style")); gtk_widget_show(f); gtk_box_pack_start(GTK_BOX (fsel), f, TRUE, TRUE, 0); #if GTK_CHECK_VERSION(3,0,0) GtkWidget *vb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4); gtk_box_set_homogeneous(GTK_BOX(vb), FALSE); #else GtkWidget *vb = gtk_vbox_new(FALSE, 4); #endif gtk_widget_show(vb); gtk_container_set_border_width(GTK_CONTAINER (vb), 4); gtk_container_add(GTK_CONTAINER(f), vb); sw = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(sw); gtk_container_set_border_width(GTK_CONTAINER (sw), 4); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX (vb), sw, TRUE, TRUE, 0); fsel->style_treeview = gtk_tree_view_new (); column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(fsel->style_treeview), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(fsel->style_treeview), FALSE); gtk_container_add(GTK_CONTAINER(sw), fsel->style_treeview); gtk_widget_show_all (sw); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(fsel->style_treeview)); g_signal_connect (G_OBJECT(selection), "changed", G_CALLBACK (sp_font_selector_style_select_row), fsel); #if GTK_CHECK_VERSION(3,0,0) GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_set_homogeneous(GTK_BOX(hb), FALSE); #else GtkWidget *hb = gtk_hbox_new(FALSE, 4); #endif gtk_widget_show(hb); gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, 0); /* This would introduce dependency on gtk version 2.24 which is currently not available in Trisquel GNU/Linux 4.5.1 (released on May 25th, 2011) This conditional and its #else block can be deleted in the future. */ #if GTK_CHECK_VERSION(2, 24,0) fsel->size = gtk_combo_box_text_new_with_entry (); #else fsel->size = gtk_combo_box_entry_new_text (); #endif sp_font_selector_set_size_tooltip(fsel); gtk_widget_set_size_request(fsel->size, 90, -1); g_signal_connect (G_OBJECT(fsel->size), "changed", G_CALLBACK (sp_font_selector_size_changed), fsel); gtk_box_pack_end (GTK_BOX(hb), fsel->size, FALSE, FALSE, 0); GtkWidget *l = gtk_label_new(_("Font size:")); gtk_widget_show_all (l); gtk_box_pack_end(GTK_BOX (hb), l, TRUE, TRUE, 0); sp_font_selector_set_sizes(fsel); gtk_widget_show_all (fsel->size); fsel->familyidx = 0; fsel->styleidx = 0; fsel->fontsize = 10.0; fsel->fontsize_dirty = false; fsel->font = NULL; }
void create_configure_dialog(void) { GtkWidget *config_dialog; GtkWidget *main_widget; GtkWidget *cpu_hbox; GtkWidget *cpu_frame; GtkWidget *cpuframe_vbox; GtkWidget *cpuclock_hbox; GtkWidget *baseclock_combo; GtkWidget *rate_combo; GtkWidget *times_label; GtkWidget *realclock_label; GtkWidget *confirm_widget; GtkWidget *ok_button; GtkWidget *cancel_button; GtkWidget *arch_frame; GtkWidget *arch_hbox; GtkWidget *arch_radiobutton[NELEMENTS(architecture)]; GtkWidget *sound_frame; GtkWidget *soundframe_vbox; GtkWidget *soundrate_hbox; GtkWidget *rate_label; GtkWidget *rate_radiobutton[NELEMENTS(samplingrate)]; GtkWidget *soundbuffer_hbox; GtkWidget *buffer_label; GtkWidget *ms_label; gchar buf[8]; int i; uninstall_idle_process(); config_dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(config_dialog), "Configure"); gtk_window_set_position(GTK_WINDOW(config_dialog), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(config_dialog), TRUE); gtk_window_set_resizable(GTK_WINDOW(config_dialog), FALSE); gtk_container_set_border_width(GTK_CONTAINER(config_dialog), 5); g_signal_connect(GTK_OBJECT(config_dialog), "destroy", G_CALLBACK(dialog_destroy), NULL); main_widget = gtk_vbox_new(FALSE, 0); gtk_widget_show(main_widget); gtk_container_add(GTK_CONTAINER(config_dialog), main_widget); /* CPU column */ cpu_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(cpu_hbox); gtk_box_pack_start(GTK_BOX(main_widget), cpu_hbox, TRUE, TRUE, 0); /* * CPU frame */ cpu_frame = gtk_frame_new("CPU"); gtk_widget_show(cpu_frame); gtk_box_pack_start(GTK_BOX(cpu_hbox), cpu_frame, TRUE, TRUE, 0); cpuframe_vbox = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(cpuframe_vbox), 5); gtk_widget_show(cpuframe_vbox); gtk_container_add(GTK_CONTAINER(cpu_frame), cpuframe_vbox); /* cpu clock */ cpuclock_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(cpuclock_hbox); gtk_box_pack_start(GTK_BOX(cpuframe_vbox),cpuclock_hbox, TRUE, TRUE, 2); baseclock_combo = gtk_combo_box_entry_new_text(); gtk_widget_show(baseclock_combo); gtk_box_pack_start(GTK_BOX(cpuclock_hbox), baseclock_combo, TRUE, FALSE, 0); gtk_widget_set_size_request(baseclock_combo, 96, -1); for (i = 0; i < NELEMENTS(baseclock_str); i++) { gtk_combo_box_append_text(GTK_COMBO_BOX(baseclock_combo), baseclock_str[i]); } baseclock_entry = GTK_BIN(baseclock_combo)->child; gtk_widget_show(baseclock_entry); gtk_editable_set_editable(GTK_EDITABLE(baseclock_entry), FALSE); switch (np2cfg.baseclock) { default: np2cfg.baseclock = PCBASECLOCK25; sysmng_update(SYS_UPDATECFG|SYS_UPDATECLOCK); /*FALLTHROUGH*/ case PCBASECLOCK25: gtk_entry_set_text(GTK_ENTRY(baseclock_entry),baseclock_str[1]); break; case PCBASECLOCK20: gtk_entry_set_text(GTK_ENTRY(baseclock_entry),baseclock_str[0]); break; } times_label = gtk_label_new("x"); gtk_widget_show(times_label); gtk_box_pack_start(GTK_BOX(cpuclock_hbox), times_label, TRUE, FALSE, 0); gtk_misc_set_padding(GTK_MISC(times_label), 5, 0); rate_combo = gtk_combo_box_entry_new_text(); gtk_widget_show(rate_combo); gtk_box_pack_start(GTK_BOX(cpuclock_hbox), rate_combo, TRUE, FALSE, 0); gtk_widget_set_size_request(rate_combo, 48, -1); for (i = 0; i < NELEMENTS(clockmult_str); i++) { gtk_combo_box_append_text(GTK_COMBO_BOX(rate_combo), clockmult_str[i]); } clockmult_entry = GTK_BIN(rate_combo)->child; gtk_widget_show(clockmult_entry); gtk_editable_set_editable(GTK_EDITABLE(clockmult_entry), FALSE); switch (np2cfg.multiple) { case 1: case 2: case 4: case 5: case 6: case 8: case 10: case 12: case 16: case 20: g_snprintf(buf, sizeof(buf), "%d", np2cfg.multiple); gtk_entry_set_text(GTK_ENTRY(clockmult_entry), buf); break; default: gtk_entry_set_text(GTK_ENTRY(clockmult_entry), "4"); break; } /* calculated cpu clock */ realclock_label = gtk_label_new("MHz"); gtk_widget_show(realclock_label); gtk_box_pack_start(GTK_BOX(cpuframe_vbox), realclock_label, FALSE, FALSE, 2); gtk_misc_set_alignment(GTK_MISC(realclock_label), 1.0, 0.5); g_signal_connect(GTK_OBJECT(baseclock_entry), "changed", G_CALLBACK(clock_changed), (gpointer)realclock_label); g_signal_connect(GTK_OBJECT(clockmult_entry), "changed", G_CALLBACK(clock_changed), (gpointer)realclock_label); clock_changed(NULL, realclock_label); /* OK, Cancel button base widget */ confirm_widget = gtk_vbutton_box_new(); gtk_widget_show(confirm_widget); gtk_box_pack_start(GTK_BOX(cpu_hbox), confirm_widget, TRUE, TRUE, 0); gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_widget), GTK_BUTTONBOX_END); //gtk_button_box_set_spacing(GTK_BUTTON_BOX(confirm_widget), 0); /* * Architecture frame */ arch_frame = gtk_frame_new("Architecture"); gtk_widget_show(arch_frame); gtk_box_pack_start(GTK_BOX(main_widget), arch_frame, TRUE, TRUE, 0); /* architecture */ arch_hbox = gtk_hbox_new(TRUE, 0); gtk_widget_show(arch_hbox); gtk_container_add(GTK_CONTAINER(arch_frame), arch_hbox); for (i = 0; i < NELEMENTS(architecture); i++) { arch_radiobutton[i] = gtk_radio_button_new_with_label_from_widget(i > 0 ? GTK_RADIO_BUTTON(arch_radiobutton[i-1]) : NULL, architecture[i].label); gtk_widget_show(arch_radiobutton[i]); gtk_box_pack_start(GTK_BOX(arch_hbox), arch_radiobutton[i], FALSE, FALSE, 0); #if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18) gtk_widget_set_can_focus(arch_radiobutton[i], FALSE); #else GTK_WIDGET_UNSET_FLAGS(rate_radiobutton[i], GTK_CAN_FOCUS); #endif g_signal_connect(GTK_OBJECT(arch_radiobutton[i]), "clicked", G_CALLBACK(arch_radiobutton_clicked), (gpointer)architecture[i].arch); } for (i = 0; i < NELEMENTS(architecture); i++) { if (strcmp(np2cfg.model, architecture[i].arch) == 0) { break; } } if (i == NELEMENTS(architecture)) { i = 1; milstr_ncpy(np2cfg.model, "VX", sizeof(np2cfg.model)); sysmng_update(SYS_UPDATECFG); } g_signal_emit_by_name(GTK_OBJECT(arch_radiobutton[i]), "clicked"); /* * Sound frame */ sound_frame = gtk_frame_new("Sound"); gtk_widget_show(sound_frame); gtk_box_pack_start(GTK_BOX(main_widget), sound_frame, TRUE, TRUE, 0); soundframe_vbox = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(soundframe_vbox), 5); gtk_widget_show(soundframe_vbox); gtk_container_add(GTK_CONTAINER(sound_frame), soundframe_vbox); /* sampling rate */ soundrate_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(soundrate_hbox); gtk_box_pack_start(GTK_BOX(soundframe_vbox), soundrate_hbox, TRUE, TRUE, 2); rate_label = gtk_label_new("Sampling Rate"); gtk_widget_show(rate_label); gtk_box_pack_start(GTK_BOX(soundrate_hbox), rate_label, FALSE, TRUE, 3); gtk_widget_set_size_request(rate_label, 96, -1); for (i = 0; i < NELEMENTS(samplingrate); i++) { rate_radiobutton[i] = gtk_radio_button_new_with_label_from_widget((i > 0) ? GTK_RADIO_BUTTON(rate_radiobutton[i-1]) : NULL, samplingrate[i].label); gtk_widget_show(rate_radiobutton[i]); gtk_box_pack_start(GTK_BOX(soundrate_hbox), rate_radiobutton[i], FALSE, FALSE, 0); #if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18) gtk_widget_set_can_focus(rate_radiobutton[i], FALSE); #else GTK_WIDGET_UNSET_FLAGS(rate_radiobutton[i], GTK_CAN_FOCUS); #endif g_signal_connect(GTK_OBJECT(rate_radiobutton[i]), "clicked", G_CALLBACK(rate_radiobutton_clicked), GINT_TO_POINTER(samplingrate[i].rate)); } if (np2cfg.samplingrate == 11025) { i = 0; } else if (np2cfg.samplingrate == 22050) { i = 1; } else if (np2cfg.samplingrate == 44100) { i = 2; } else { i = 1; np2cfg.samplingrate = 22050; sysmng_update(SYS_UPDATECFG|SYS_UPDATERATE); } g_signal_emit_by_name(GTK_OBJECT(rate_radiobutton[i]), "clicked"); soundbuffer_hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(soundbuffer_hbox); gtk_box_pack_start(GTK_BOX(soundframe_vbox), soundbuffer_hbox, TRUE, TRUE, 2); /* buffer size */ buffer_label = gtk_label_new("Buffer"); gtk_widget_show(buffer_label); gtk_box_pack_start(GTK_BOX(soundbuffer_hbox), buffer_label, FALSE, FALSE, 0); gtk_widget_set_size_request(buffer_label, 96, -1); buffer_entry = gtk_entry_new(); gtk_widget_show(buffer_entry); gtk_box_pack_start(GTK_BOX(soundbuffer_hbox), buffer_entry, FALSE, FALSE, 0); gtk_widget_set_size_request(buffer_entry, 48, -1); if (np2cfg.delayms >= 20 && np2cfg.delayms <= 1000) { g_snprintf(buf, sizeof(buf), "%d", np2cfg.delayms); gtk_entry_set_text(GTK_ENTRY(buffer_entry), buf); } else { gtk_entry_set_text(GTK_ENTRY(buffer_entry), "500"); np2cfg.delayms = 500; sysmng_update(SYS_UPDATECFG|SYS_UPDATESBUF); soundrenewal = 1; } ms_label = gtk_label_new(" ms"); gtk_widget_show(ms_label); gtk_box_pack_start(GTK_BOX(soundbuffer_hbox),ms_label, FALSE, FALSE, 0); #if defined(SUPPORT_RESUME) /* resume */ resume_checkbutton = gtk_check_button_new_with_label("Resume"); gtk_widget_show(resume_checkbutton); gtk_box_pack_start(GTK_BOX(main_widget), resume_checkbutton, FALSE, FALSE, 1); if (np2oscfg.resume) { g_signal_emit_by_name(GTK_OBJECT(resume_checkbutton), "clicked"); } #endif #if defined(GCC_CPU_ARCH_IA32) /* Disable MMX */ disablemmx_checkbutton = gtk_check_button_new_with_label("Disable MMX"); gtk_widget_show(disablemmx_checkbutton); gtk_box_pack_start(GTK_BOX(main_widget), disablemmx_checkbutton, FALSE, FALSE, 1); if (mmxflag & MMXFLAG_NOTSUPPORT) { gtk_widget_set_sensitive(disablemmx_checkbutton, FALSE); } else if (mmxflag & MMXFLAG_DISABLE) { g_signal_emit_by_name(GTK_OBJECT(disablemmx_checkbutton), "clicked"); } #endif /* * OK, Cancel button */ ok_button = gtk_button_new_from_stock(GTK_STOCK_OK); gtk_widget_show(ok_button); gtk_container_add(GTK_CONTAINER(confirm_widget), ok_button); #if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18) gtk_widget_set_can_default(ok_button, TRUE); gtk_widget_has_default(ok_button); #else GTK_WIDGET_SET_FLAGS(ok_button, GTK_CAN_DEFAULT); GTK_WIDGET_SET_FLAGS(ok_button, GTK_HAS_DEFAULT); #endif g_signal_connect(GTK_OBJECT(ok_button), "clicked", G_CALLBACK(ok_button_clicked), (gpointer)config_dialog); gtk_widget_grab_default(ok_button); cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_widget_show(cancel_button); gtk_container_add(GTK_CONTAINER(confirm_widget), cancel_button); #if GTK_MAJOR_VERSION > 2 || (GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18) gtk_widget_set_can_default(cancel_button, TRUE); #else GTK_WIDGET_SET_FLAGS(cancel_button, GTK_CAN_DEFAULT); #endif g_signal_connect_swapped(GTK_OBJECT(cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), GTK_OBJECT(config_dialog)); gtk_widget_show_all(config_dialog); }
static GtkWidget * contacts_type_edit_widget_new (EVCardAttribute *attr, gboolean multi_line, gboolean *changed) { const TypeTuple *types; types = contacts_get_field_types (e_vcard_attribute_get_name (attr)); if (types) { guint i; GtkWidget *combo = gtk_combo_box_entry_new_text (); GtkWidget *align; gchar *first_type = ""; EVCardAttributeParam *param; EContactTypeChangeData *data; /* Retrieve all types, but we only look at the first one * TODO: A sane way of selecting multiple types, to conform * with spec? (Almost no other vCard-using apps do this, * so not high priority) */ GList *contact_types = contacts_get_types ( e_vcard_attribute_get_params (attr)); if (contact_types) { param = (EVCardAttributeParam *)contact_types->data; GList *values = e_vcard_attribute_param_get_values (param); first_type = values ? (gchar *)values->data : ""; g_list_free (contact_types); } else { param = e_vcard_attribute_param_new ("TYPE"); e_vcard_attribute_add_param_with_value ( attr, param, ""); } data = g_new (EContactTypeChangeData, 1); data->param = param; data->attr_name = e_vcard_attribute_get_name (attr); data->changed = changed; for (i = 0; types[i].index; i++) { gtk_combo_box_append_text ( GTK_COMBO_BOX (combo), _(types[i].value)); /* Note: We use a case-insensitive search here, as * specified in the spec (as the types are predefined, * we can use non-locale-friendly strcasecmp) */ if (first_type) { if (g_ascii_strcasecmp (types[i].index, first_type) == 0) { first_type = NULL; gtk_combo_box_set_active ( GTK_COMBO_BOX (combo), i); } } } /* Support custom types, as per spec */ if ((first_type) && (g_ascii_strncasecmp (first_type, "X-", 2) == 0)) { gtk_entry_set_text ( GTK_ENTRY (GTK_BIN (combo)->child), (const gchar *)(first_type+2)); first_type = NULL; } if (first_type) gtk_combo_box_set_active (GTK_COMBO_BOX (combo), i-1); gtk_widget_show (combo); if (/*(e_vcard_attribute_is_single_valued (attr)) &&*/ (multi_line == FALSE)) align = gtk_alignment_new (0, 0.5, 0, 0); else align = gtk_alignment_new (0, 0, 0, 0); /* TODO: Find something better than this? */ gtk_widget_set_size_request (combo, 80, -1); gtk_container_add (GTK_CONTAINER (align), combo); /* Connect signal for changes */ g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (contacts_type_entry_changed), data); /* Free change data structure on destruction */ g_signal_connect_swapped (G_OBJECT (align), "destroy", G_CALLBACK (g_free), data); return align; } return NULL; }