bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title, const wxPoint &pos, const wxSize &size, int n, const wxString choices[], int majorDim, long style, const wxValidator& validator, const wxString &name ) { if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, validator, name )) { wxFAIL_MSG( wxT("wxRadioBox creation failed") ); return false; } m_widget = gtk_frame_new( wxGTK_CONV( title ) ); // majorDim may be 0 if all trailing parameters were omitted, so don't // assert here but just use the correct value for it m_majorDim = majorDim == 0 ? n : majorDim; int num_per_major = (n - 1) / m_majorDim +1; int num_of_cols = 0; int num_of_rows = 0; if (HasFlag(wxRA_SPECIFY_COLS)) { num_of_cols = m_majorDim; num_of_rows = num_per_major; } else { num_of_cols = num_per_major; num_of_rows = m_majorDim; } GtkRadioButton *m_radio = (GtkRadioButton*) NULL; GtkWidget *table = gtk_table_new( num_of_rows, num_of_cols, FALSE ); gtk_table_set_col_spacings( GTK_TABLE(table), 1 ); gtk_table_set_row_spacings( GTK_TABLE(table), 1 ); gtk_widget_show( table ); gtk_container_add( GTK_CONTAINER(m_widget), table ); wxString label; GSList *radio_button_group = (GSList *) NULL; for (int i = 0; i < n; i++) { if ( i != 0 ) radio_button_group = gtk_radio_button_group( GTK_RADIO_BUTTON(m_radio) ); label.Empty(); for ( const wxChar *pc = choices[i]; *pc; pc++ ) { if ( *pc != wxT('&') ) label += *pc; } m_radio = GTK_RADIO_BUTTON( gtk_radio_button_new_with_label( radio_button_group, wxGTK_CONV( label ) ) ); gtk_widget_show( GTK_WIDGET(m_radio) ); gtk_signal_connect( GTK_OBJECT(m_radio), "key_press_event", GTK_SIGNAL_FUNC(gtk_radiobox_keypress_callback), (gpointer)this ); m_boxes.Append( (wxObject*) m_radio ); if (HasFlag(wxRA_SPECIFY_COLS)) { int left = i%num_of_cols; int right = (i%num_of_cols) + 1; int top = i/num_of_cols; int bottom = (i/num_of_cols)+1; gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(m_radio), left, right, top, bottom, GTK_FILL, GTK_FILL, 1, 1 ); } else { int left = i/num_of_rows; int right = (i/num_of_rows) + 1; int top = i%num_of_rows; int bottom = (i%num_of_rows)+1; gtk_table_attach( GTK_TABLE(table), GTK_WIDGET(m_radio), left, right, top, bottom, GTK_FILL, GTK_FILL, 1, 1 ); } ConnectWidget( GTK_WIDGET(m_radio) ); if (!i) gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(m_radio), TRUE ); gtk_signal_connect( GTK_OBJECT(m_radio), "clicked", GTK_SIGNAL_FUNC(gtk_radiobutton_clicked_callback), (gpointer*)this ); gtk_signal_connect( GTK_OBJECT(m_radio), "focus_in_event", GTK_SIGNAL_FUNC(gtk_radiobutton_focus_in), (gpointer)this ); gtk_signal_connect( GTK_OBJECT(m_radio), "focus_out_event", GTK_SIGNAL_FUNC(gtk_radiobutton_focus_out), (gpointer)this ); } m_parent->DoAddChild( this ); SetLabel( title ); PostCreation(size); return true; }
//This function returns a table containing the elements of the page arranged GtkWidget * setPageLayout(GtkWidget* window, GtkWidget* browserForm){ GtkWidget * tableInitialing; GtkWidget *image; GtkWidget * mainSearchBox, *miniSearchBox, *centerSearchBox; GtkWidget *searchMainBut, *searchMiniBut, *searchCenterBut, *exitButton , *goBackBut, *stopBut, *frontBut; GtkWidget *scrolledWindow; GtkWidget *webView; GtkWidget *pageLayoutExpander; webView = webkit_web_view_new(); pageLayoutExpander = gtk_expander_new_with_mnemonic("V_iew page"); //creates a table with 20 rows and 17 columns tableInitialing = gtk_table_new( 30, 17, TRUE); exitButton = gtk_button_new_with_mnemonic("E_xit One click browser"); g_signal_connect_swapped( G_OBJECT(exitButton), "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer) window); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), exitButton, 0, 17, 29,30); //Start of expander setting //declaration of variables involved in setting position of tabs GtkWidget *settingExpander, *expanderVBox; GtkWidget *setTapUpRadio, *setTapDownRadio, *clearHistoryBut, *viewHistoryBut; GtkWidget *facebookLogo, *twitterLogo, *gmailLogo, *skypeLogo, *googleLogo; GtkWidget *facebookEventBox, *twitterEventBox, *gmailEventBox, *skypeEventBox, *googleEventBox; //Initialising variables setTapUpRadio = gtk_radio_button_new_with_label(NULL,"Set tab position up"); setTapDownRadio = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(setTapUpRadio), "Set tab position down"); //Initialises the clearHistoryBut and associate a callback to it clearHistoryBut = gtk_button_new_with_mnemonic("_Clear history"); g_signal_connect(G_OBJECT(clearHistoryBut), "clicked", G_CALLBACK(clearHistory), NULL); viewHistoryBut = gtk_button_new_with_mnemonic("_View history"); g_signal_connect_swapped(G_OBJECT(viewHistoryBut),"clicked", G_CALLBACK(viewHistory), NULL); //Initialises the expander and the vbox settingExpander = gtk_expander_new_with_mnemonic("_Settings"); expanderVBox = gtk_vbox_new(TRUE, 0); //Adds radio buttons to the vbox gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapUpRadio); gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapDownRadio); gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), clearHistoryBut); gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), viewHistoryBut); //Linking signals of radio buttons to the respective callbacks g_signal_connect_swapped( G_OBJECT(setTapUpRadio), "toggled", G_CALLBACK(setTapUp), browserForm); g_signal_connect_swapped( G_OBJECT(setTapDownRadio), "toggled", G_CALLBACK(setTapDown), browserForm); gtk_container_add( GTK_CONTAINER(settingExpander), expanderVBox); gtk_table_attach_defaults( GTK_TABLE(tableInitialing),settingExpander, 0,3,20,24); //End of expander setting goBackBut = gtk_button_new_with_label(" <-- "); gtk_widget_set_size_request(goBackBut, 10, 25); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), goBackBut, 1, 2, 1, 2); g_signal_connect_swapped(goBackBut, "clicked", G_CALLBACK(back), webView); stopBut = gtk_button_new_with_label(" X "); gtk_widget_set_size_request(stopBut, 10, 25); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), stopBut, 2, 3, 1, 2); g_signal_connect_swapped(stopBut, "clicked", G_CALLBACK(stop), webView); frontBut = gtk_button_new_with_label(" --> "); gtk_widget_set_size_request(frontBut, 10, 25); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), frontBut, 16, 17, 1, 2); g_signal_connect_swapped(frontBut, "clicked", G_CALLBACK(forward), webView); //This patch of code initiates autocompletion of the search box GtkEntryCompletion *completion; GtkTreeIter *iter; GtkListStore *store_list; FILE * historyPtr; store_list = gtk_list_store_new(1,G_TYPE_STRING); completion = gtk_entry_completion_new(); if( (historyPtr = fopen("History/History.htm","r+")) == NULL) g_print("Error"); gchar historyString[100]; while( !feof(historyPtr)){ fscanf(historyPtr,"%s",historyString); gtk_list_store_append(store_list, iter); gtk_list_store_set(store_list, iter, 0, historyString, -1); } fclose(historyPtr); gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(store_list)); gtk_entry_completion_set_text_column(completion, 0); mainSearchBox = gtk_entry_new(); gtk_entry_set_completion(GTK_ENTRY(mainSearchBox), completion); gtk_widget_set_size_request(mainSearchBox, 500, 25); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), mainSearchBox, 3, 15, 1, 2 ); g_signal_connect_swapped(mainSearchBox, "activate", G_CALLBACK(activate), webView); searchMainBut = gtk_button_new_with_mnemonic("Sear_ch"); gtk_widget_set_size_request(searchMainBut, 10,15); gtk_table_attach_defaults( GTK_TABLE(tableInitialing), searchMainBut, 15, 16, 1, 2 ); g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(setUri), mainSearchBox); g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(go), webView); //g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(initialiseEntryCompletion), completion); //Linking callbacks to signals emitted by webview widget g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-progress-changed",G_CALLBACK(progress),mainSearchBox); g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(finished),mainSearchBox); scrolledWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(scrolledWindow), webView); gtk_widget_show_all(scrolledWindow); //PageLayout expander //gtk_widget_set_sensitive(pageLayoutExpander, FALSE); gtk_container_add( GTK_CONTAINER(pageLayoutExpander), scrolledWindow); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), pageLayoutExpander, 0, 17, 2, 29); g_signal_connect_swapped(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(viewSearchedPage),pageLayoutExpander); image = gtk_image_new_from_file("images/OneClickLogo.png"); GtkWidget* imageEventBox = initialiseEventBox(image); g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(searchOneClick), webView); g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(logoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), imageEventBox, 3, 14, 14, 24); //Adding pictures of some social media to the browser's home page facebookLogo = gtk_image_new_from_file("images/facebook.jpg"); skypeLogo = gtk_image_new_from_file("images/skype.jpg"); twitterLogo = gtk_image_new_from_file("images/twitter.jpg"); gmailLogo = gtk_image_new_from_file("images/gmail.jpg"); googleLogo = gtk_image_new_from_file("images/google.jpg"); //Adding event handlers to images facebookEventBox = initialiseEventBox(facebookLogo); g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(searchFacebook), webView); g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(facebookLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), facebookEventBox, 4, 6, 24, 28 ); gmailEventBox = initialiseEventBox(gmailLogo); g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(searchGmail), webView); g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(gmailLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), gmailEventBox, 6, 8, 24, 28 ); twitterEventBox = initialiseEventBox(twitterLogo); g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(searchTwitter), webView); g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(twitterLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), twitterEventBox, 8, 10, 24, 28 ); skypeEventBox = initialiseEventBox(skypeLogo); g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(searchSKype), webView); g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(skypeLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), skypeEventBox, 10, 12, 24, 28 ); googleEventBox = initialiseEventBox(googleLogo); g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(searchGoogle), webView); g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(googleLogoClicked), mainSearchBox); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), googleEventBox, 12, 14, 24, 28 ); //This patch of code implements the file chooser button that opens files on the user's computer GtkWidget *openFileChooser; openFileChooser = gtk_file_chooser_button_new("Select an html document to open",GTK_FILE_CHOOSER_ACTION_OPEN); g_signal_connect_swapped(G_OBJECT(openFileChooser), "selection_changed", G_CALLBACK(openFile), webView); //gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(openFileChooser), g_get_home_dir()); gtk_table_attach_defaults(GTK_TABLE(tableInitialing), openFileChooser, 4, 12, 0, 1 ); GtkFileFilter *filter; filter = gtk_file_filter_new(); gtk_file_filter_set_name (filter, "HTML Files"); gtk_file_filter_add_pattern (filter, "*.html"); gtk_file_filter_add_pattern (filter, "*.htm"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (openFileChooser), filter); return tableInitialing; }
static GtkWidget * build_properties_area(WBPlugin *wb, const gchar *buffer, gsize length) { GError *error = NULL; GObject *area = NULL; GtkRadioButton *only_maximized, *active_window; GtkToggleButton *show_on_desktop, *sync_wm_theme; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkListStore *list_store; GtkWidget *view, *theme_name_treeview; GtkEntry *button_layout; wb->prefs->builder = gtk_builder_new(); if (gtk_builder_add_from_string(wb->prefs->builder, buffer, length, &error)) { area = gtk_builder_get_object(wb->prefs->builder, "alignment0"); if (G_LIKELY (area != NULL)) { only_maximized = GTK_RADIO_BUTTON(gtk_builder_get_object(wb->prefs->builder, "only_maximized")); active_window = GTK_RADIO_BUTTON(gtk_builder_get_object(wb->prefs->builder, "active_window")); if (G_LIKELY (only_maximized != NULL)) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(only_maximized), wb->prefs->only_maximized); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(active_window), !wb->prefs->only_maximized); g_signal_connect(only_maximized, "toggled", G_CALLBACK(on_only_maximized_toggled), wb); } else { DBG("No widget with the name \"only_maximized\" found"); } show_on_desktop = GTK_TOGGLE_BUTTON(gtk_builder_get_object(wb->prefs->builder, "show_on_desktop")); if (G_LIKELY (show_on_desktop != NULL)) { gtk_toggle_button_set_active(show_on_desktop, wb->prefs->show_on_desktop); g_signal_connect(show_on_desktop, "toggled", G_CALLBACK(on_show_on_desktop_toggled), wb); } else { DBG("No widget with the name \"show_on_desktop\" found"); } /* Style widgets */ theme_name_treeview = GTK_WIDGET (gtk_builder_get_object (wb->prefs->builder, "theme_name_treeview")); /* theme name */ { list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (list_store), COL_THEME_NAME, (GtkTreeIterCompareFunc) wckbuttons_theme_sort_func, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store), COL_THEME_NAME, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (theme_name_treeview), GTK_TREE_MODEL (list_store)); g_object_unref (G_OBJECT (list_store)); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (theme_name_treeview), 0, _("Directory"), renderer, "text", 1, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (theme_name_treeview), 0, _("Themes usable"), renderer, "text", 0, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (theme_name_treeview)); g_signal_connect (selection, "changed", G_CALLBACK (wckbuttons_theme_selection_changed), wb); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); view = GTK_WIDGET (gtk_builder_get_object (wb->prefs->builder, "theme_name_treeview")); wckbuttons_load_themes (view, wb); } sync_wm_theme = GTK_TOGGLE_BUTTON(gtk_builder_get_object(wb->prefs->builder, "sync_wm_theme")); if (G_LIKELY (sync_wm_theme != NULL)) { if (wb->wm_channel) { gtk_toggle_button_set_active(sync_wm_theme, wb->prefs->sync_wm_theme); g_signal_connect(sync_wm_theme, "toggled", G_CALLBACK(on_sync_theme_with_wm_toggled), wb); } else { gtk_widget_set_sensitive (GTK_WIDGET(sync_wm_theme), FALSE); } } else { DBG("No widget with the name \"sync_wm_theme\" found"); } button_layout = GTK_ENTRY(gtk_builder_get_object(wb->prefs->builder, "button_layout")); if (G_LIKELY (button_layout != NULL)) { gtk_entry_set_text(button_layout, wb->prefs->button_layout); g_signal_connect(GTK_EDITABLE(button_layout), "changed", G_CALLBACK(on_button_layout_changed), wb); } else { DBG("No widget with the name \"button_layout\" found"); } return GTK_WIDGET(area) ; } else { g_set_error_literal(&error, 0, 0, "No widget with the name \"contentarea\" found"); } } g_critical("Faild to construct the builder for plugin %s-%d: %s.", xfce_panel_plugin_get_name (wb->plugin), xfce_panel_plugin_get_unique_id (wb->plugin), error->message); g_error_free(error); g_object_unref(G_OBJECT (wb->prefs->builder) ); return NULL ; }
static GtkWidget * account_assistant_build_enter_or_create_page (EmpathyAccountAssistant *self) { EmpathyAccountAssistantPriv *priv = GET_PRIV (self); GtkWidget *main_vbox, *w, *chooser, *vbox, *hbox, *radio; main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_widget_show (main_vbox); w = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (w), 0, 0); gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0); gtk_widget_show (w); priv->first_label = w; w = gtk_alignment_new (0, 0, 0, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0); gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0); gtk_widget_show (w); chooser = empathy_protocol_chooser_new (); gtk_container_add (GTK_CONTAINER (w), chooser); gtk_widget_show (chooser); priv->chooser = chooser; vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_end (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); w = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); gtk_label_set_line_wrap (GTK_LABEL (w), TRUE); gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5); gtk_widget_show (w); priv->second_label = w; w = gtk_alignment_new (0, 0, 0, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0); gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); gtk_widget_show (w); hbox = gtk_hbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (w), hbox); gtk_widget_show (hbox); radio = gtk_radio_button_new_with_label (NULL, _("Yes")); gtk_box_pack_start (GTK_BOX (hbox), radio, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (radio), "response", GINT_TO_POINTER (RESPONSE_CREATE_AGAIN)); gtk_widget_show (radio); w = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio), _("No, that's all for now")); gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0); g_object_set_data (G_OBJECT (w), "response", GINT_TO_POINTER (RESPONSE_CREATE_STOP)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), TRUE); priv->create_enter_resp = RESPONSE_CREATE_STOP; priv->create_again_radio = w; gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (account_assistant_radio_create_again_clicked_cb), self); g_signal_connect (radio, "clicked", G_CALLBACK (account_assistant_radio_create_again_clicked_cb), self); return main_vbox; }
void grg_pref_dialog (GtkWidget * parent) { GtkWidget *prefs, *notebook, *tab1, *tab2, *tab3; GtkWidget *frame1, *frame2, *frame3; GtkWidget *crypt_box, *hash_box, *comp_box; GtkWidget *frame_font; GtkWidget *frame_file, *but_file, *box_file, *but_file_clear; GtkWidget *frame_save, *box_save; GtkWidget *frame_misc, *box_misc; GtkWidget *frame_xpire, *box_xpire, *xpire_lbl; GtkWidget *frame_passes, *box_passes, *lbl_passes; GtkWidget *frame_clip, *box_clip; gint response; PangoFontDescription *fdesc; if (active_flag) return; prefs = gtk_dialog_new_with_buttons (_("Preferences"), GTK_WINDOW (parent), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); //first page: algorithms tab1 = gtk_table_new (3, 2, FALSE); frame1 = gtk_frame_new (_("Encryption")); gtk_table_attach_defaults (GTK_TABLE (tab1), frame1, 0, 1, 0, 3); crypt_box = gtk_vbox_new (FALSE, GRG_PAD); gtk_container_add (GTK_CONTAINER (frame1), crypt_box); NEW_RADIO_BUTTON (rij1_but, NULL, modify_crypto, GRG_AES, "AES (Rijndael 128)", crypt_box); NEW_RADIO_BUTTON (ser_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (rij1_but)), modify_crypto, GRG_SERPENT, "Serpent", crypt_box); NEW_RADIO_BUTTON (twof_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (rij1_but)), modify_crypto, GRG_TWOFISH, "Twofish", crypt_box); NEW_RADIO_BUTTON (cast_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (rij1_but)), modify_crypto, GRG_CAST_256, "Cast 256", crypt_box); NEW_RADIO_BUTTON (safer_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (rij1_but)), modify_crypto, GRG_SAFERPLUS, "Safer+", crypt_box); NEW_RADIO_BUTTON (loki_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (rij1_but)), modify_crypto, GRG_LOKI97, "Loki97", crypt_box); NEW_RADIO_BUTTON (tdes_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (rij1_but)), modify_crypto, GRG_3DES, "3-DES", crypt_box); NEW_RADIO_BUTTON (rij2_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (rij1_but)), modify_crypto, GRG_RIJNDAEL_256, "Rijndael 256", crypt_box); NEW_ROW_SEPARATOR (crypt_box); NEW_LABEL (crypto_block_lbl, crypt_box, ""); NEW_LABEL (crypto_key_lbl, crypt_box, ""); update_crypto_label (); frame2 = gtk_frame_new (_("Hashing")); gtk_table_attach_defaults (GTK_TABLE (tab1), frame2, 1, 2, 0, 1); hash_box = gtk_vbox_new (FALSE, GRG_PAD); gtk_container_add (GTK_CONTAINER (frame2), hash_box); NEW_RADIO_BUTTON (sha_but, NULL, modify_hash, GRG_SHA1, "SHA1", hash_box); NEW_RADIO_BUTTON (ripe_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (sha_but)), modify_hash, GRG_RIPEMD_160, "RIPEMD 160", hash_box); frame3 = gtk_frame_new (_("Compression")); gtk_table_attach_defaults (GTK_TABLE (tab1), frame3, 1, 2, 1, 2); comp_box = gtk_vbox_new (FALSE, GRG_PAD); gtk_container_add (GTK_CONTAINER (frame3), comp_box); NEW_RADIO_BUTTON (zlib_but, NULL, modify_comp, GRG_ZLIB, "ZLib", comp_box); NEW_RADIO_BUTTON (bz_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (zlib_but)), modify_comp, GRG_BZIP, "BZip2", comp_box); NEW_ROW_SEPARATOR (comp_box); NEW_RADIO_BUTTON (r0_but, NULL, modify_ratio, GRG_LVL_NONE, _("None"), comp_box); NEW_RADIO_BUTTON (r3_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (r0_but)), modify_ratio, GRG_LVL_FAST, _("Fast"), comp_box); NEW_RADIO_BUTTON (r6_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (r0_but)), modify_ratio, GRG_LVL_GOOD, _("Good"), comp_box); NEW_RADIO_BUTTON (r9_but, gtk_radio_button_get_group (GTK_RADIO_BUTTON (r0_but)), modify_ratio, GRG_LVL_BEST, _("Best"), comp_box); notebook = gtk_notebook_new (); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab1, gtk_label_new (_("Algorithms"))); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (prefs)->vbox), notebook, TRUE, TRUE, GRG_PAD); //second page: General options tab2 = gtk_vbox_new (FALSE, GRG_PAD); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab2, gtk_label_new (_("General options"))); frame_font = gtk_frame_new (_("Editor font")); gtk_box_pack_start (GTK_BOX (tab2), frame_font, FALSE, TRUE, 1); but_font = gtk_button_new_with_label (_ ("Click to change the editor font")); gtk_container_add (GTK_CONTAINER (frame_font), but_font); fdesc = pango_font_description_from_string (grg_prefs_editor_font); gtk_widget_modify_font (but_font, fdesc); g_free (fdesc); g_signal_connect (G_OBJECT (but_font), "clicked", G_CALLBACK (modify_font), prefs); frame_misc = gtk_frame_new (_("Decorations")); gtk_box_pack_start (GTK_BOX (tab2), frame_misc, FALSE, TRUE, 1); box_misc = gtk_vbox_new (FALSE, GRG_PAD); gtk_container_add (GTK_CONTAINER (frame_misc), box_misc); NEW_ROW_SEPARATOR (tab2); splash_check = gtk_check_button_new_with_label (_("Splash screen")); g_signal_connect (G_OBJECT (splash_check), "toggled", G_CALLBACK (modify_splash), NULL); gtk_box_pack_start (GTK_BOX (box_misc), splash_check, FALSE, TRUE, 1); frame_file = gtk_frame_new (_("File to open at startup")); gtk_box_pack_start (GTK_BOX (tab2), frame_file, FALSE, TRUE, 1); box_file = gtk_hbox_new (FALSE, GRG_PAD); gtk_container_add (GTK_CONTAINER (frame_file), box_file); file_entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (box_file), file_entry, FALSE, TRUE, 1); but_file = gtk_button_new_from_stock (GTK_STOCK_OPEN); gtk_box_pack_start (GTK_BOX (box_file), but_file, FALSE, TRUE, 1); g_signal_connect (G_OBJECT (but_file), "clicked", G_CALLBACK (meta_open_startup_file), (gpointer) prefs); but_file_clear = gtk_button_new_from_stock (GTK_STOCK_CLEAR); gtk_box_pack_start (GTK_BOX (box_file), but_file_clear, FALSE, TRUE, 1); g_signal_connect (G_OBJECT (but_file_clear), "clicked", G_CALLBACK (clear_file), NULL); frame_save = gtk_frame_new (_("File saving")); gtk_box_pack_start (GTK_BOX (tab2), frame_save, FALSE, TRUE, 1); box_save = gtk_vbox_new (FALSE, GRG_PAD); gtk_container_add (GTK_CONTAINER (frame_save), box_save); bak_check = gtk_check_button_new_with_label (_("Make backups of files")); g_signal_connect (G_OBJECT (bak_check), "toggled", G_CALLBACK (modify_bak), NULL); gtk_box_pack_start (GTK_BOX (box_save), bak_check, FALSE, TRUE, 1); over_check = gtk_check_button_new_with_label (_ ("Ask when overwriting files")); g_signal_connect (G_OBJECT (over_check), "toggled", G_CALLBACK (modify_over), NULL); gtk_box_pack_start (GTK_BOX (box_save), over_check, FALSE, TRUE, 1); //third page: Security tab3 = gtk_vbox_new (FALSE, GRG_PAD); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), tab3, gtk_label_new (_("Security"))); frame_xpire = gtk_frame_new (_("Password expiration")); gtk_box_pack_start (GTK_BOX (tab3), frame_xpire, FALSE, TRUE, 1); box_xpire = gtk_hbox_new (FALSE, GRG_PAD); gtk_container_add (GTK_CONTAINER (frame_xpire), box_xpire); xpire_check = gtk_check_button_new_with_label (_("Password expires in")); xpire_spin = gtk_spin_button_new_with_range (EXP_TIME_MIN, EXP_TIME_MAX, 1); xpire_lbl = gtk_label_new (_("days")); g_signal_connect (G_OBJECT (xpire_check), "toggled", G_CALLBACK (modify_xpire), xpire_spin); g_signal_connect (G_OBJECT (xpire_spin), "value-changed", G_CALLBACK (modify_xpin), xpire_check); gtk_box_pack_start (GTK_BOX (box_xpire), xpire_check, FALSE, TRUE, 1); gtk_box_pack_start (GTK_BOX (box_xpire), xpire_spin, FALSE, TRUE, 1); gtk_box_pack_start (GTK_BOX (box_xpire), xpire_lbl, FALSE, TRUE, 1); //this means "passes in wiping a file", not "wipe the passes" :) frame_passes = gtk_frame_new (_("Wipe passes")); gtk_box_pack_start (GTK_BOX (tab3), frame_passes, FALSE, TRUE, 1); box_passes = gtk_hbox_new (FALSE, GRG_PAD); gtk_container_add (GTK_CONTAINER (frame_passes), box_passes); lbl_passes = gtk_label_new (_("Number of overwritings with random\n" "data, when wiping a file:")); gtk_box_pack_start (GTK_BOX (box_passes), lbl_passes, FALSE, TRUE, 1); passes_spin = gtk_spin_button_new_with_range (WIPE_PASSES_MIN, WIPE_PASSES_MAX, 1); gtk_box_pack_start (GTK_BOX (box_passes), passes_spin, FALSE, TRUE, 1); g_signal_connect (G_OBJECT (passes_spin), "value-changed", G_CALLBACK (modify_passes), NULL); frame_clip = gtk_frame_new (_("Clipboard")); gtk_box_pack_start (GTK_BOX (tab3), frame_clip, FALSE, TRUE, 1); box_clip = gtk_vbox_new (FALSE, GRG_PAD); gtk_container_add (GTK_CONTAINER (frame_clip), box_clip); cclip_check = gtk_check_button_new_with_label (_ ("Clear clipboard on closing file")); g_signal_connect (G_OBJECT (cclip_check), "toggled", G_CALLBACK (modify_cclip), NULL); gtk_box_pack_start (GTK_BOX (box_clip), cclip_check, FALSE, TRUE, 1); qclip_check = gtk_check_button_new_with_label (_ ("Clear clipboard on exit")); g_signal_connect (G_OBJECT (qclip_check), "toggled", G_CALLBACK (modify_qclip), NULL); gtk_box_pack_start (GTK_BOX (box_clip), qclip_check, FALSE, TRUE, 1); //end of last tab active_flag = TRUE; reset_values (prefs); update_buttons (); gtk_widget_show_all (prefs); while (TRUE) { gboolean exit = TRUE; response = gtk_dialog_run (GTK_DIALOG (prefs)); switch (response) { case GTK_RESPONSE_OK: apply_values (); break; case GTK_RESPONSE_APPLY: apply_values (); exit = FALSE; break; case GTK_RESPONSE_CANCEL: default: break; } if (exit) { gtk_widget_destroy (prefs); active_flag = FALSE; break; } } }
static void xpad_preferences_init (XpadPreferences *pref) { GtkWidget *hbox, *font_hbox, *vbox; const GdkColor *color; const gchar *fontname; GtkStyle *style; GtkWidget *label, *appearance_frame, *alignment, *appearance_vbox; GtkWidget *options_frame, *options_vbox, *global_vbox; gchar *text; GtkSizeGroup *size_group_labels = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); GtkRequisition req; pref->priv = XPAD_PREFERENCES_GET_PRIVATE (pref); text = g_strconcat ("<b>", _("Appearance"), "</b>", NULL); label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL, "label", text, "use-markup", TRUE, "xalign", 0.0, NULL)); g_free (text); appearance_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX, "homogeneous", FALSE, "spacing", 18, NULL)); alignment = gtk_alignment_new (1, 1, 1, 1); g_object_set (G_OBJECT (alignment), "left-padding", 12, "top-padding", 12, "child", appearance_vbox, NULL); appearance_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME, "label-widget", label, "shadow-type", GTK_SHADOW_NONE, "child", alignment, NULL)); pref->priv->textbutton = gtk_color_button_new (); pref->priv->backbutton = gtk_color_button_new (); pref->priv->fontbutton = gtk_font_button_new (); pref->priv->antifontcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use font from theme")); pref->priv->fontcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->antifontcheck), _("Use this font:")); pref->priv->anticolorcheck = gtk_radio_button_new_with_mnemonic (NULL, _("Use colors from theme")); pref->priv->colorcheck = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (pref->priv->anticolorcheck), _("Use these colors:")); font_hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (font_hbox), pref->priv->fontbutton, TRUE, TRUE, 0); pref->priv->colorbox = gtk_vbox_new (FALSE, 6); hbox = gtk_hbox_new (FALSE, 12); label = gtk_label_new_with_mnemonic (_("Background:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_size_group_add_widget (size_group_labels, label); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), pref->priv->backbutton, TRUE, TRUE, 0); g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL); hbox = gtk_hbox_new (FALSE, 12); label = gtk_label_new_with_mnemonic (_("Foreground:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_size_group_add_widget (size_group_labels, label); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), pref->priv->textbutton, TRUE, TRUE, 0); g_object_set (G_OBJECT (pref->priv->colorbox), "child", hbox, NULL); alignment = gtk_alignment_new (1, 1, 1, 1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); gtk_container_add (GTK_CONTAINER (alignment), pref->priv->colorbox); pref->priv->editcheck = gtk_check_button_new_with_mnemonic (_("_Edit lock")); pref->priv->stickycheck = gtk_check_button_new_with_mnemonic (_("_Pads start on all workspaces")); pref->priv->confirmcheck = gtk_check_button_new_with_mnemonic (_("_Confirm pad deletion")); gtk_dialog_add_button (GTK_DIALOG (pref), "gtk-close", GTK_RESPONSE_CLOSE); gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (pref), FALSE); g_signal_connect (pref, "response", G_CALLBACK (xpad_preferences_response), NULL); gtk_window_set_title (GTK_WINDOW (pref), _("Xpad Preferences")); gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->textbutton), FALSE); gtk_color_button_set_use_alpha (GTK_COLOR_BUTTON (pref->priv->backbutton), xpad_app_get_translucent ()); gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->textbutton), _("Set Foreground Color")); gtk_color_button_set_title (GTK_COLOR_BUTTON (pref->priv->backbutton), _("Set Background Color")); gtk_font_button_set_title (GTK_FONT_BUTTON (pref->priv->fontbutton), _("Set Font")); /* Set current state */ style = gtk_widget_get_default_style (); color = xpad_settings_get_back_color (xpad_settings ()); if (color) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->colorcheck), TRUE); gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), color); } else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->anticolorcheck), TRUE); gtk_widget_set_sensitive (pref->priv->colorbox, FALSE); gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->backbutton), &style->base[GTK_STATE_NORMAL]); } color = xpad_settings_get_text_color (xpad_settings ()); if (color) gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), color); else gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), &style->text[GTK_STATE_NORMAL]); fontname = xpad_settings_get_fontname (xpad_settings ()); if (fontname) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->fontcheck), TRUE); gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), fontname); } else { gchar *str; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->antifontcheck), TRUE); gtk_widget_set_sensitive (pref->priv->fontbutton, FALSE); str = pango_font_description_to_string (style->font_desc); gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), str); g_free (str); } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->editcheck), xpad_settings_get_edit_lock (xpad_settings ())); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->stickycheck), xpad_settings_get_sticky (xpad_settings ())); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->confirmcheck), xpad_settings_get_confirm_destroy (xpad_settings ())); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), pref->priv->antifontcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), font_hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), pref->priv->anticolorcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), pref->priv->colorcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (appearance_vbox), vbox, FALSE, FALSE, 0); text = g_strconcat ("<b>", _("Options"), "</b>", NULL); label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL, "label", text, "use-markup", TRUE, "xalign", 0.0, NULL)); g_free (text); options_vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX, "homogeneous", FALSE, "spacing", 6, NULL)); alignment = gtk_alignment_new (1, 1, 1, 1); g_object_set (G_OBJECT (alignment), "left-padding", 12, "top-padding", 12, "child", options_vbox, NULL); options_frame = GTK_WIDGET (g_object_new (GTK_TYPE_FRAME, "label-widget", label, "shadow-type", GTK_SHADOW_NONE, "child", alignment, NULL)); gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->editcheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->stickycheck, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (options_vbox), pref->priv->confirmcheck, FALSE, FALSE, 0); global_vbox = g_object_new (GTK_TYPE_VBOX, "border-width", 6, "homogeneous", FALSE, "spacing", 18, "child", appearance_frame, "child", options_frame, NULL); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pref)->vbox), global_vbox, FALSE, FALSE, 0); pref->priv->editcheck_handler = g_signal_connect (pref->priv->editcheck, "toggled", G_CALLBACK (change_edit_check), pref); pref->priv->stickycheck_handler = g_signal_connect (pref->priv->stickycheck, "toggled", G_CALLBACK (change_sticky_check), pref); pref->priv->confirmcheck_handler = g_signal_connect (pref->priv->confirmcheck, "toggled", G_CALLBACK (change_confirm_check), pref); pref->priv->colorcheck_handler = g_signal_connect (pref->priv->colorcheck, "toggled", G_CALLBACK (change_color_check), pref); pref->priv->fontcheck_handler = g_signal_connect (pref->priv->fontcheck, "toggled", G_CALLBACK (change_font_check), pref); pref->priv->text_handler = g_signal_connect (pref->priv->textbutton, "color-set", G_CALLBACK (change_text_color), pref); pref->priv->back_handler = g_signal_connect (pref->priv->backbutton, "color-set", G_CALLBACK (change_back_color), pref); pref->priv->font_handler = g_signal_connect (pref->priv->fontbutton, "font-set", G_CALLBACK (change_font_face), pref); pref->priv->notify_font_handler = g_signal_connect_swapped (xpad_settings (), "notify::fontname", G_CALLBACK (notify_fontname), pref); pref->priv->notify_text_handler = g_signal_connect_swapped (xpad_settings (), "notify::text-color", G_CALLBACK (notify_text_color), pref); pref->priv->notify_back_handler = g_signal_connect_swapped (xpad_settings (), "notify::back-color", G_CALLBACK (notify_back_color), pref); pref->priv->notify_sticky_handler = g_signal_connect_swapped (xpad_settings (), "notify::sticky", G_CALLBACK (notify_sticky), pref); pref->priv->notify_edit_handler = g_signal_connect_swapped (xpad_settings (), "notify::edit-lock", G_CALLBACK (notify_edit), pref); pref->priv->notify_confirm_handler = g_signal_connect_swapped (xpad_settings (), "notify::confirm-destroy", G_CALLBACK (notify_confirm), pref); g_object_unref (size_group_labels); gtk_widget_show_all (GTK_DIALOG (pref)->vbox); /* Make window not so squished */ gtk_widget_size_request (GTK_WIDGET (pref), &req); g_object_set (G_OBJECT (pref), "default-width", (gint) (req.height * 0.8), 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); }
GtkWidget * do_form_model_change (GtkWidget *do_widget) { if (!window) { GdaStatement *stmt; GtkWidget *vbox; GtkWidget *label; GdaDataModel *models [3]; window = gtk_dialog_new_with_buttons ("Changing data in a GdauiForm", GTK_WINDOW (do_widget), 0, "Close", GTK_RESPONSE_NONE, NULL); g_signal_connect (window, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 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 ("The data in the same GdauiForm widget can be change don the fly."); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); /* creating data models */ stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products ORDER BY ref, category LIMIT 15", NULL, NULL); models[0] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL); gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[0]), NULL); g_object_unref (stmt); stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products WHERE price > 20.2 ORDER BY ref, category LIMIT 10", NULL, NULL); models[1] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL); gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[1]), NULL); g_object_unref (stmt); stmt = gda_sql_parser_parse_string (demo_parser, "SELECT name, price, ref, category FROM products WHERE price > 20.2 ORDER BY name LIMIT 30", NULL, NULL); models[2] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL); gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[2]), NULL); g_object_unref (stmt); /* allow choosing which data model to display */ label = gtk_label_new (""); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_label_set_markup (GTK_LABEL (label), "<b>Choose which data model to display:</b>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); GtkWidget *layout, *rb; GSList *group = NULL; gint i; layout = gtk_grid_new (); gtk_box_pack_start (GTK_BOX (vbox), layout, FALSE, FALSE, 0); for (i = 0; i < 3; i++) { gchar *str; str = g_strdup_printf ("%d columns x %d rows", gda_data_model_get_n_columns (models[i]), gda_data_model_get_n_rows (models[i])); rb = gtk_radio_button_new_with_label (group, str); g_free (str); gtk_grid_attach (GTK_GRID (layout), rb, i, 0, 1, 1); g_signal_connect (rb, "toggled", G_CALLBACK (model_toggled_cb), models[i]); g_object_set_data_full (G_OBJECT (rb), "model", models[i], g_object_unref); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb)); } /* Create the form widget */ label = gtk_label_new (""); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_label_set_markup (GTK_LABEL (label), "<b>GdauiForm:</b>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); form = gdaui_form_new (models[0]); g_object_set (G_OBJECT (form), "info-flags", GDAUI_DATA_PROXY_INFO_CURRENT_ROW | GDAUI_DATA_PROXY_INFO_ROW_MOVE_BUTTONS | GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS, NULL); gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0); GdaDataProxy *proxy; proxy = gdaui_data_proxy_get_proxy (GDAUI_DATA_PROXY (form)); g_object_set (proxy, "cache-changes", TRUE, NULL); } gboolean visible; g_object_get (G_OBJECT (window), "visible", &visible, NULL); if (!visible) gtk_widget_show_all (window); else { gtk_widget_destroy (window); window = NULL; } return window; }
void settings_show (GtkWidget *widget, SchematicView *sv) { gint i; GtkWidget *engine_group = NULL; GtkWidget *w, *pbox, *toplevel; GtkBuilder *gui; GError *perror = NULL; gchar *msg; Settings *s; Schematic *sm; g_return_if_fail (sv != NULL); // If no engine available, stop oregano if ((g_find_program_in_path (engine[0]) == NULL) && (g_find_program_in_path (engine[1]) == NULL)) { gchar *msg; msg = g_strdup_printf ( _("No engine allowing analysis is available.\n" "You might install one, at least! \n" "Either ngspice or gnucap.")); oregano_error_with_title (_("Could not create settings dialog"), msg); g_free (msg); return; } g_return_if_fail (sv != NULL); if ((gui = gtk_builder_new ()) == NULL) { oregano_error (_("Could not create settings dialog")); return; } gtk_builder_set_translation_domain (gui, NULL); sm = schematic_view_get_schematic (sv); s = schematic_get_settings (sm); // Only allow one instance of the property box per schematic. if (GTK_WIDGET (SETTINGS (s)->pbox)) { gdk_window_raise (gtk_widget_get_window ( GTK_WIDGET (SETTINGS (s)->pbox))); return; } if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/settings.ui", &perror) <= 0) { msg = perror->message; oregano_error_with_title (_("Could not create settings dialog"), msg); g_error_free (perror); return; } w = toplevel = GTK_WIDGET (gtk_builder_get_object (gui, "toplevel")); if (!w) { oregano_error (_("Could not create settings dialog")); return; } g_signal_connect (G_OBJECT (w), "delete_event", G_CALLBACK (delete_event_callback), s); pbox = toplevel; s->pbox = GTK_WIDGET (pbox); w = GTK_WIDGET (gtk_builder_get_object (gui, "close_bt")); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (apply_callback), s); w = GTK_WIDGET (gtk_builder_get_object (gui, "splash-enable")); s->w_show_splash = w; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), oregano.show_splash); w = GTK_WIDGET (gtk_builder_get_object (gui, "compress-enable")); s->w_compress_files = w; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), oregano.compress_files); w = GTK_WIDGET (gtk_builder_get_object (gui, "log-enable")); s->w_show_log = w; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), oregano.show_log); w = GTK_WIDGET (gtk_builder_get_object (gui, "grid-size")); gtk_widget_set_sensitive (w, FALSE); w = GTK_WIDGET (gtk_builder_get_object (gui, "realtime-enable")); gtk_widget_set_sensitive (w, FALSE); w = GTK_WIDGET (gtk_builder_get_object (gui, "engine_table")); for (i = 0; i < OREGANO_ENGINE_COUNT; i++) { if (engine_group) button[i] = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (engine_group), engine[i]); else button[i] = engine_group = gtk_radio_button_new_with_label_from_widget (NULL, engine[i]); g_object_set_data (G_OBJECT (button[i]), "id", GUINT_TO_POINTER (i)); gtk_grid_attach (GTK_GRID (w), button[i], 0, i, 1, 1); g_signal_connect (G_OBJECT (button[i]), "clicked", G_CALLBACK (set_engine_name), s); } // Is the engine available? // In that case the button is active if (g_find_program_in_path (engine[oregano.engine]) != NULL) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button[oregano.engine]), TRUE); // Otherwise the button is inactive else gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button[oregano.engine]), FALSE); // If no engine available, stop oregano if ((g_find_program_in_path (engine[0]) == NULL) && (g_find_program_in_path (engine[1]) == NULL)) { gchar *msg; msg = g_strdup_printf ( _("No engine allowing analysis is available.\n" "You might install one, at least! \n" "Either ngspice or gnucap.")); oregano_error_with_title (_("Could not create settings dialog"), msg); g_free (msg); } gtk_widget_show_all (toplevel); }
//********************************************************************************* void guiControl::guiControl(void *button, void* data) { if (pos_winPid != NULL) { gtk_window_set_keep_above (GTK_WINDOW(pos_winPid),true); return; } gtkClassData* currentClassData = (gtkClassData*) data; partMover *currentPart = currentClassData->partPointer; joint = currentClassData->indexPointer; icntrl2 = currentPart->get_IControlMode2(); iinteract = currentPart->get_IInteractionMode(); ipid = currentPart->get_IPidControl(); iamp = currentPart->get_IAmplifierControl(); bool ret = true; int control_mode=VOCAB_CM_UNKNOWN; yarp::dev::InteractionModeEnum interaction_mode=VOCAB_IM_UNKNOWN; ret &= icntrl2->getControlMode(*joint, &control_mode); ret &= iinteract->getInteractionMode(*joint, &interaction_mode); if (control_mode==VOCAB_CM_HW_FAULT) { printf("WARNING: you cannot change control mode of a joint in HARDWARE FAULT\n"); return; } //GtkWidget *winPid = NULL; GtkWidget *inv = NULL; //adding a popup window pos_winPid = gtk_window_new (GTK_WINDOW_TOPLEVEL); char title[255]; sprintf(title,"Control mode JNT:%d",*joint); gtk_window_set_title (GTK_WINDOW (pos_winPid), title); //adding a set of display inv = gtk_fixed_new (); gtk_container_add (GTK_CONTAINER (pos_winPid), inv); label_title = gtk_label_new (title); sprintf(title,"Interaction mode JNT:%d",*joint); label_title2 = gtk_label_new (title); radiobutton_mode_idl = gtk_radio_button_new_with_label (NULL, "idle"); radiobutton_mode_pos = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "position"); radiobutton_mode_vel = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "velocity"); radiobutton_mode_trq = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "torque"); radiobutton_mode_imp_pos = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "impedance position"); radiobutton_mode_imp_vel = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "impedance velocity"); radiobutton_mode_open = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "openloop"); radiobutton_mode_pos_direct = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "position direct"); radiobutton_mode_mixed = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "mixed"); radiobutton_interaction_stiff = gtk_radio_button_new_with_label (NULL, "stiff mode"); radiobutton_interaction_compl = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_interaction_stiff), "compliant mode"); gtk_fixed_put (GTK_FIXED(inv), label_title, 10, 10 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_idl, 10, 30 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_pos, 10, 50 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_pos_direct, 10, 70 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_mixed, 10, 90 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_vel, 10, 110 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_trq, 10, 130 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_imp_pos, 10, 150 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_imp_vel, 10, 170 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_open, 10, 190 ); gtk_fixed_put (GTK_FIXED(inv), label_title2, 10, 210 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_interaction_stiff,10, 230 ); gtk_fixed_put (GTK_FIXED(inv), radiobutton_interaction_compl,10, 250 ); update_menu(control_mode, interaction_mode); gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_pos_direct), position_direct_enabled); gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_open), openloop_enabled); gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_imp_pos), old_impedance_enabled); gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_imp_vel), old_impedance_enabled); //Rememeber: these signal_connect MUST be placed after the update_menu! g_signal_connect (radiobutton_mode_idl, "clicked",G_CALLBACK (radio_click_idl), &radiobutton_mode_idl); g_signal_connect (radiobutton_mode_pos, "clicked",G_CALLBACK (radio_click_pos), &radiobutton_mode_pos); g_signal_connect (radiobutton_mode_pos_direct, "clicked",G_CALLBACK (radio_click_pos_direct), &radiobutton_mode_pos_direct); g_signal_connect (radiobutton_mode_mixed, "clicked",G_CALLBACK (radio_click_mode_mixed), &radiobutton_mode_mixed); g_signal_connect (radiobutton_mode_vel, "clicked",G_CALLBACK (radio_click_vel), &radiobutton_mode_vel); g_signal_connect (radiobutton_mode_trq, "clicked",G_CALLBACK (radio_click_trq), &radiobutton_mode_trq); g_signal_connect (radiobutton_mode_imp_pos, "clicked",G_CALLBACK (radio_click_imp_pos), &radiobutton_mode_imp_pos); g_signal_connect (radiobutton_mode_imp_vel, "clicked",G_CALLBACK (radio_click_imp_vel), &radiobutton_mode_imp_vel); g_signal_connect (radiobutton_mode_open, "clicked",G_CALLBACK (radio_click_open), &radiobutton_mode_open); g_signal_connect (radiobutton_interaction_stiff, "clicked",G_CALLBACK (radio_click_stiff), &radiobutton_interaction_stiff); g_signal_connect (radiobutton_interaction_compl, "clicked",G_CALLBACK (radio_click_compl), &radiobutton_interaction_compl); g_signal_connect (radiobutton_mode_idl, "key_press_event", G_CALLBACK (on_key_press), &radiobutton_mode_idl); g_signal_connect (radiobutton_mode_pos, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_pos); g_signal_connect (radiobutton_mode_pos_direct, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_pos_direct); g_signal_connect (radiobutton_mode_mixed, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_mixed); g_signal_connect (radiobutton_mode_vel, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_vel); g_signal_connect (radiobutton_mode_trq, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_trq); g_signal_connect (radiobutton_mode_imp_pos, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_imp_pos); g_signal_connect (radiobutton_mode_imp_vel, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_imp_vel); g_signal_connect (radiobutton_mode_open, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_open); g_signal_connect (radiobutton_interaction_stiff, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_interaction_stiff); g_signal_connect (radiobutton_interaction_compl, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_interaction_compl); //connection to the destroyer g_signal_connect (pos_winPid, "destroy",G_CALLBACK (destroy_main), &pos_winPid); //make it visible if (!GTK_WIDGET_VISIBLE (pos_winPid)) gtk_widget_show_all (pos_winPid); else { gtk_widget_destroy (pos_winPid); pos_winPid = NULL; } gtk_window_set_keep_above (GTK_WINDOW(pos_winPid),true); gtk_main (); return; }
int iceb_l_sklad_v(class iceb_u_str *sklad_k,GtkWidget *wpredok) { char strsql[512]; iceb_u_str kikz; class iceb_l_sklad_v data; data.sklad_i.new_plus(sklad_k->ravno()); data.rk.clear_zero(); if(data.sklad_i.getdlinna() > 1) { data.rk.kod.new_plus(data.sklad_i.ravno()); sprintf(strsql,"select * from Sklad where kod=%s",data.sklad_i.ravno()); SQL_str row; SQLCURSOR cur; if(sql_readkey(&bd,strsql,&row,&cur) < 1) { iceb_menu_soob(gettext("Не найдена запись для корректировки !"),wpredok); return(1); } data.rk.fmol.new_plus(row[2]); data.rk.dolg.new_plus(row[3]); data.rk.naim.new_plus(row[1]); kikz.plus(iceb_kikz(row[4],row[5],wpredok)); data.rk.metka_isp_skl=atoi(row[6]); } else { sprintf(strsql,"%d",iceb_get_new_kod("Sklad",0,wpredok)); // printf("%s\n",strsql); data.rk.kod.new_plus(strsql); } 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); GtkWidget *label=NULL; if(data.sklad_i.getdlinna() <= 1) { sprintf(strsql,"%s %s",name_system,gettext("Ввод новой записи")); label=gtk_label_new(gettext("Ввод новой записи")); } else { sprintf(strsql,"%s %s",name_system,gettext("Корректировка записи")); iceb_u_str repl; repl.plus(gettext("Корректировка записи")); repl.ps_plus(kikz.ravno()); label=gtk_label_new(repl.ravno_toutf()); } 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),&data.window); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(sklad_v_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); gtk_container_add (GTK_CONTAINER (vbox), label); for(int i=0; i < KOLENTER; i++) gtk_box_pack_start (GTK_BOX (vbox),hbox[i], TRUE, TRUE, 2); // gtk_container_add (GTK_CONTAINER (vbox), hbox[i]); GtkWidget *separator1=gtk_hseparator_new(); GtkWidget *separator3=gtk_hseparator_new(); gtk_box_pack_start (GTK_BOX (vbox),separator1, TRUE, TRUE, 2); //Вставляем радиокнопки data.radiobutton2[0]=gtk_radio_button_new_with_label_from_widget(NULL,gettext("Используется")); data.radiobutton2[1]=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(data.radiobutton2[0]),gettext("Неиспользуется")); gtk_box_pack_start (GTK_BOX (vbox), data.radiobutton2[0], TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX (vbox), data.radiobutton2[1], TRUE, TRUE, 1); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton2[data.rk.metka_isp_skl]),TRUE); //Устанавливем активной кнопку gtk_box_pack_start (GTK_BOX (vbox),separator3, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (vbox),hboxknop, TRUE, TRUE, 2); //gtk_container_add (GTK_CONTAINER (vbox), hboxknop); label=gtk_label_new(gettext("Код")); data.entry[E_KOD] = gtk_entry_new_with_max_length (4); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(sklad_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk.kod.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD); label=gtk_label_new(gettext("Наименование")); data.entry[E_NAIM] = gtk_entry_new_with_max_length (80); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(sklad_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk.naim.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM); label=gtk_label_new(gettext("Фамилия материально-ответственного")); data.entry[E_FIO] = gtk_entry_new_with_max_length (29); gtk_box_pack_start (GTK_BOX (hbox[E_FIO]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_FIO]), data.entry[E_FIO], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_FIO]), "activate",GTK_SIGNAL_FUNC(sklad_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_FIO]),data.rk.fmol.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_FIO]),(gpointer)E_FIO); label=gtk_label_new(gettext("Должность материально-ответственного")); data.entry[E_DOLG] = gtk_entry_new_with_max_length (29); gtk_box_pack_start (GTK_BOX (hbox[E_DOLG]), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox[E_DOLG]), data.entry[E_DOLG], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_DOLG]), "activate",GTK_SIGNAL_FUNC(sklad_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_DOLG]),data.rk.dolg.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DOLG]),(gpointer)E_DOLG); GtkTooltips *tooltips[KOL_PFK]; sprintf(strsql,"F2 %s",gettext("Запись")); data.knopka[PFK2]=gtk_button_new_with_label(strsql); tooltips[PFK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[PFK2],data.knopka[PFK2],gettext("Запись введеной в меню информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[PFK2]),"clicked",GTK_SIGNAL_FUNC(sklad_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK2]),(gpointer)PFK2); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[PFK10]=gtk_button_new_with_label(strsql); tooltips[PFK10]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[PFK10],data.knopka[PFK10],gettext("Завершение работы с меню без записи введенной информации"),NULL); gtk_signal_connect(GTK_OBJECT(data.knopka[PFK10]),"clicked",GTK_SIGNAL_FUNC(sklad_v_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[PFK10]),(gpointer)PFK10); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK2], TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[PFK10], TRUE, TRUE, 0); gtk_widget_grab_focus(data.entry[1]); gtk_widget_show_all (data.window); gtk_main(); if(data.voz == 0) sklad_k->new_plus(data.rk.kod.ravno()); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
GtkWidget *create_kbm_widget() { if (kbm_widget != NULL) fprintf(stderr, "create_kbm_widget: kbm_widget was not NULL!\n"); load_settings(); GtkWidget *vbox_top = gtk_vbox_new (FALSE, 3); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL); kbm_widget = vbox_top; GtkWidget *hbox_lr = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_lr, FALSE, FALSE, 0); GtkWidget *vbox_l = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_l), GTK_ORIENTATION_VERTICAL); gtk_container_set_border_width (GTK_CONTAINER (vbox_l), 10); gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_l, TRUE, TRUE, 10); GtkWidget *vbox_r = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_r), GTK_ORIENTATION_VERTICAL); gtk_container_set_border_width (GTK_CONTAINER (vbox_r), 10); gtk_box_pack_start (GTK_BOX (hbox_lr), vbox_r, TRUE, TRUE, 10); GtkWidget *frame_kbm = gtk_frame_new(_("鍵盤排列方式/選擇鍵/選單每列字數")); gtk_box_pack_start (GTK_BOX (vbox_l), frame_kbm, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame_kbm), 1); gtk_container_add (GTK_CONTAINER (frame_kbm), create_kbm_opts()); gtk_box_pack_start (GTK_BOX (vbox_l), create_en_pho_key_sel(_("(詞音) 切換[中/英]輸入"), 0), FALSE, FALSE, 0); GtkWidget *frame_tsin_space_opt = gtk_frame_new(_("(詞音) 鍵入空白鍵")); gtk_box_pack_start (GTK_BOX (vbox_l), frame_tsin_space_opt, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_space_opt), 1); GtkWidget *box_tsin_space_opt = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(box_tsin_space_opt), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (frame_tsin_space_opt), box_tsin_space_opt); gtk_container_set_border_width (GTK_CONTAINER (box_tsin_space_opt), 1); GSList *group_tsin_space_opt = NULL; int current_idx = get_currnet_tsin_space_option_idx(); new_select_idx_tsin_space_opt = current_idx; gsize i; for(i=0; i< tsin_space_optionsN; i++) { GtkWidget *button = gtk_radio_button_new_with_label (group_tsin_space_opt, _(tsin_space_options[i].name)); gtk_box_pack_start (GTK_BOX (box_tsin_space_opt), button, FALSE, FALSE, 0); group_tsin_space_opt = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (callback_button_clicked_tsin_space_opt), (gpointer) i); if (i==current_idx) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); } GtkWidget *hbox_tsin_phrase_pre_select = gtk_hbox_new(FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_l), hbox_tsin_phrase_pre_select , FALSE, FALSE, 1); check_button_tsin_phrase_pre_select = gtk_check_button_new_with_label(_("詞音輸入預選詞視窗")); gtk_box_pack_start (GTK_BOX (hbox_tsin_phrase_pre_select), check_button_tsin_phrase_pre_select, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_tsin_phrase_pre_select), tsin_phrase_pre_select); GtkWidget *hbox_phonetic_char_dynamic_sequence = gtk_hbox_new(FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_l), hbox_phonetic_char_dynamic_sequence , FALSE, FALSE, 1); check_button_phonetic_char_dynamic_sequence = gtk_check_button_new_with_label(_("依使用頻率調整字的順序")); gtk_box_pack_start (GTK_BOX (hbox_phonetic_char_dynamic_sequence), check_button_phonetic_char_dynamic_sequence, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_phonetic_char_dynamic_sequence), phonetic_char_dynamic_sequence); GtkWidget *hbox_pho_hide_row2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_r), hbox_pho_hide_row2 , FALSE, FALSE, 1); check_button_pho_hide_row2 = gtk_check_button_new_with_label(_("注音隱藏第二列 (注音符號)")); gtk_box_pack_start (GTK_BOX (hbox_pho_hide_row2), check_button_pho_hide_row2, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_pho_hide_row2), pho_hide_row2); GtkWidget *hbox_pho_in_row1 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_r), hbox_pho_in_row1 , FALSE, FALSE, 1); check_button_pho_in_row1 = gtk_check_button_new_with_label(_("注音符號移至第一列")); gtk_box_pack_start (GTK_BOX (hbox_pho_in_row1), check_button_pho_in_row1, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_pho_in_row1), pho_in_row1); GtkWidget *hbox_phonetic_huge_tab = gtk_hbox_new(FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_r), hbox_phonetic_huge_tab , FALSE, FALSE, 1); check_button_phonetic_huge_tab = gtk_check_button_new_with_label(_("使用巨大 UTF-8 字集")); gtk_box_pack_start (GTK_BOX (hbox_phonetic_huge_tab), check_button_phonetic_huge_tab, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_phonetic_huge_tab), phonetic_huge_tab); GtkWidget *hbox_tsin_tone_char_input = gtk_hbox_new(FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tone_char_input , FALSE, FALSE, 1); check_button_tsin_tone_char_input = gtk_check_button_new_with_label(_("(詞音) 輸入注音聲調符號")); gtk_box_pack_start (GTK_BOX (hbox_tsin_tone_char_input), check_button_tsin_tone_char_input, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_tsin_tone_char_input), tsin_tone_char_input); GtkWidget *hbox_tsin_tab_phrase_end = gtk_hbox_new(FALSE, 1); gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tab_phrase_end , FALSE, FALSE, 1); check_button_tsin_tab_phrase_end = gtk_check_button_new_with_label(_("(詞音) 使用 Escape/Tab 斷詞")); gtk_box_pack_start (GTK_BOX (hbox_tsin_tab_phrase_end), check_button_tsin_tab_phrase_end, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_tsin_tab_phrase_end), tsin_tab_phrase_end); GtkWidget *hbox_tsin_tail_select_key = gtk_hbox_new(FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_tail_select_key , FALSE, FALSE, 1); check_button_tsin_tail_select_key = gtk_check_button_new_with_label(_("選擇鍵顯示於候選字(詞)後方")); gtk_box_pack_start (GTK_BOX (hbox_tsin_tail_select_key), check_button_tsin_tail_select_key, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_tsin_tail_select_key), tsin_tail_select_key); GtkWidget *hbox_tsin_buffer_editing_mode = gtk_hbox_new(FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_buffer_editing_mode , FALSE, FALSE, 1); check_button_tsin_buffer_editing_mode = gtk_check_button_new_with_label(_("\\ 鍵可切換 jkx 鍵編輯模式")); gtk_box_pack_start (GTK_BOX (hbox_tsin_buffer_editing_mode), check_button_tsin_buffer_editing_mode, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_tsin_buffer_editing_mode), tsin_buffer_editing_mode); GtkWidget *hbox_tsin_use_pho_near = gtk_hbox_new(FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_r), hbox_tsin_use_pho_near , FALSE, FALSE, 1); check_button_tsin_use_pho_near = gtk_check_button_new_with_label(_("按下 ↑ 鍵查詢近似音")); gtk_box_pack_start (GTK_BOX (hbox_tsin_use_pho_near), check_button_tsin_use_pho_near, FALSE, FALSE, 0); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(check_button_tsin_use_pho_near), tsin_use_pho_near); GtkWidget *frame_tsin_buffer_size = gtk_frame_new(_("(詞音) 的編輯緩衝區大小")); gtk_box_pack_start (GTK_BOX (vbox_r), frame_tsin_buffer_size, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (frame_tsin_buffer_size), 1); GtkAdjustment *adj_gtab_in = (GtkAdjustment *) gtk_adjustment_new (tsin_buffer_size, 10.0, MAX_PH_BF, 1.0, 1.0, 0.0); spinner_tsin_buffer_size = gtk_spin_button_new (adj_gtab_in, 0, 0); gtk_container_add (GTK_CONTAINER (frame_tsin_buffer_size), spinner_tsin_buffer_size); return kbm_widget; }
static gboolean shoot_dialog (GdkScreen **screen) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *notebook; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *button; GtkWidget *toggle; GtkWidget *spinner; GdkPixbuf *pixbuf; GSList *radio_group = NULL; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Screenshot"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("S_nap"), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); pixbuf = gdk_pixbuf_new_from_inline (-1, screenshot_icon, FALSE, NULL); if (pixbuf) { gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_pixbuf (pixbuf)); g_object_unref (pixbuf); } main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); /* Hints */ notebook = g_object_new (GTK_TYPE_NOTEBOOK, "show-border", FALSE, "show-tabs", FALSE, NULL); gtk_box_pack_end (GTK_BOX (main_vbox), notebook, FALSE, FALSE, 0); gtk_widget_show (notebook); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_ROOT, _("After the delay, the screenshot is taken.")); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_REGION, _("After the delay, drag your mouse to select " "the region for the screenshot.")); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_WINDOW, _("At the end of the delay, click in a window " "to snap it.")); gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), shootvals.shoot_type); /* Area */ frame = gimp_frame_new (_("Area")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* single window */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Take a screenshot of " "a single _window")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_WINDOW); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_WINDOW)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); #ifdef HAVE_X11_XMU_WINUTIL_H hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); toggle = gtk_check_button_new_with_mnemonic (_("Include window _decoration")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), shootvals.decorate); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 24); gtk_widget_show (toggle); g_object_set_data (G_OBJECT (button), "set_sensitive", toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &shootvals.decorate); #endif /* HAVE_X11_XMU_WINUTIL_H */ /* whole screen */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Take a screenshot of " "the entire _screen")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_ROOT); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_ROOT)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); /* dragged region */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Select a _region to grab")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_REGION); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_REGION)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); /* Delay */ frame = gimp_frame_new (_("Delay")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); spinner = gimp_spin_button_new (&adj, shootvals.select_delay, 0.0, 100.0, 1.0, 5.0, 0.0, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0); gtk_widget_show (spinner); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &shootvals.select_delay); /* this is the unit label of a spinbutton */ label = gtk_label_new (_("seconds")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { /* get the screen on which we are running */ *screen = gtk_widget_get_screen (dialog); } gtk_widget_destroy (dialog); if (run) { /* A short timeout to give the server a chance to * redraw the area that was obscured by our dialog. */ g_timeout_add (100, shoot_quit_timeout, NULL); gtk_main (); } return run; }
dialogo_propiedades_red_t * dialogo_propiedades_red_crear() { dialogo_propiedades_red_t * dialogo_propiedades_red = (dialogo_propiedades_red_t*)malloc(sizeof(dialogo_propiedades_red_t)); dialogo_propiedades_red->rbt_ordenes_group = NULL; dialogo_propiedades_red->dlg_propiedades_red = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialogo_propiedades_red->dlg_propiedades_red), "Propiedades de la red"); dialogo_propiedades_red->dialog_vbox1 = GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red)->vbox; gtk_widget_show (dialogo_propiedades_red->dialog_vbox1); dialogo_propiedades_red->vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (dialogo_propiedades_red->vbox1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->dialog_vbox1), dialogo_propiedades_red->vbox1, TRUE, TRUE, 0); dialogo_propiedades_red->label1 = gtk_label_new_with_mnemonic ("_Ruta del archivo:"); gtk_widget_show (dialogo_propiedades_red->label1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->label1, FALSE, FALSE, 0); dialogo_propiedades_red->hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (dialogo_propiedades_red->hbox1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->hbox1, TRUE, TRUE, 0); dialogo_propiedades_red->entry_ruta = gtk_entry_new (); gtk_widget_show (dialogo_propiedades_red->entry_ruta); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox1), dialogo_propiedades_red->entry_ruta, TRUE, TRUE, 0); dialogo_propiedades_red->button1 = gtk_button_new (); gtk_widget_show (dialogo_propiedades_red->button1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox1), dialogo_propiedades_red->button1, FALSE, FALSE, 0); dialogo_propiedades_red->alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (dialogo_propiedades_red->alignment1); gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->button1), dialogo_propiedades_red->alignment1); dialogo_propiedades_red->hbox2 = gtk_hbox_new (FALSE, 2); gtk_widget_show (dialogo_propiedades_red->hbox2); gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->alignment1), dialogo_propiedades_red->hbox2); dialogo_propiedades_red->image1 = gtk_image_new_from_stock ("gtk-open", GTK_ICON_SIZE_BUTTON); gtk_widget_show (dialogo_propiedades_red->image1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox2), dialogo_propiedades_red->image1, FALSE, FALSE, 0); dialogo_propiedades_red->label4 = gtk_label_new_with_mnemonic ("_..."); gtk_widget_show (dialogo_propiedades_red->label4); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->hbox2), dialogo_propiedades_red->label4, FALSE, FALSE, 0); dialogo_propiedades_red->hseparator1 = gtk_hseparator_new (); gtk_widget_show (dialogo_propiedades_red->hseparator1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->hseparator1, TRUE, TRUE, 0); dialogo_propiedades_red->frame1 = gtk_frame_new (NULL); gtk_widget_show (dialogo_propiedades_red->frame1); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox1), dialogo_propiedades_red->frame1, TRUE, TRUE, 0); dialogo_propiedades_red->vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (dialogo_propiedades_red->vbox2); gtk_container_add (GTK_CONTAINER (dialogo_propiedades_red->frame1), dialogo_propiedades_red->vbox2); dialogo_propiedades_red->rbt_ordenes = gtk_radio_button_new_with_mnemonic (NULL, "\303\223_rdenes"); gtk_widget_show (dialogo_propiedades_red->rbt_ordenes); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox2), dialogo_propiedades_red->rbt_ordenes, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_ordenes), dialogo_propiedades_red->rbt_ordenes_group); dialogo_propiedades_red->rbt_ordenes_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_ordenes)); dialogo_propiedades_red->rbt_parametros = gtk_radio_button_new_with_mnemonic (NULL, "P_ar\303\241metros"); gtk_widget_show (dialogo_propiedades_red->rbt_parametros); gtk_box_pack_start (GTK_BOX (dialogo_propiedades_red->vbox2), dialogo_propiedades_red->rbt_parametros, FALSE, FALSE, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_parametros), dialogo_propiedades_red->rbt_ordenes_group); dialogo_propiedades_red->rbt_ordenes_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialogo_propiedades_red->rbt_parametros)); dialogo_propiedades_red->label3 = gtk_label_new ("M\303\263dulo"); gtk_widget_show (dialogo_propiedades_red->label3); gtk_frame_set_label_widget (GTK_FRAME (dialogo_propiedades_red->frame1), dialogo_propiedades_red->label3); dialogo_propiedades_red->dialog_action_area1 = GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red)->action_area; gtk_widget_show (dialogo_propiedades_red->dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialogo_propiedades_red->dialog_action_area1), GTK_BUTTONBOX_END); dialogo_propiedades_red->cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (dialogo_propiedades_red->cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red), dialogo_propiedades_red->cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (dialogo_propiedades_red->cancelbutton1, GTK_CAN_DEFAULT); dialogo_propiedades_red->okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (dialogo_propiedades_red->okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialogo_propiedades_red->dlg_propiedades_red), dialogo_propiedades_red->okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (dialogo_propiedades_red->okbutton1, GTK_CAN_DEFAULT); g_signal_connect((gpointer) dialogo_propiedades_red->button1, "clicked", G_CALLBACK(boton_abrir), dialogo_propiedades_red); return dialogo_propiedades_red; }
GtkWidget *create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *notebook1; GtkWidget *table1; GtkWidget *radioCQ; GSList *radioCQ_group = NULL; GtkWidget *radioCBR; GtkWidget *radio2Pass; GtkWidget *entryCQ; GtkWidget *entryCBR; GtkWidget *entry2Pass; GtkWidget *label1; GtkWidget *table2; GtkWidget *label5; GtkWidget *label6; GtkWidget *label7; GtkObject *spinbuttonMaxIFrame_adj; GtkWidget *spinbuttonMaxIFrame; GtkWidget *label8; GtkObject *spinbuttonMinIFrame_adj; GtkWidget *spinbuttonMinIFrame; GtkWidget *optionME; GtkWidget *menu4; GtkWidget *_0___none1; GtkWidget *_1__very_low1; GtkWidget *_2__low1; GtkWidget *_3__medium1; GtkWidget *_4__high1; GtkWidget *_5__very_high1; GtkWidget *_6__ultra_high1; GtkWidget *optionQzer; GtkWidget *menu5; GtkWidget *h263_quantizer1; GtkWidget *mpeg_quantizer1; GtkWidget *label2; GtkWidget *table3; GtkWidget *label9; GtkWidget *label10; GtkWidget *label11; GtkWidget *label12; GtkObject *spinImin_adj; GtkWidget *spinImin; GtkObject *spinImax_adj; GtkWidget *spinImax; GtkObject *spinPmin_adj; GtkWidget *spinPmin; GtkObject *spinPmax_adj; GtkWidget *spinPmax; GtkWidget *label3; GtkWidget *label13; GtkWidget *label4; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("Xvid Encoder")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); notebook1 = gtk_notebook_new (); gtk_widget_show (notebook1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), notebook1, TRUE, TRUE, 0); table1 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table1); gtk_container_add (GTK_CONTAINER (notebook1), table1); radioCQ = gtk_radio_button_new_with_mnemonic (NULL, _("Constant Quantizer")); gtk_widget_show (radioCQ); gtk_table_attach (GTK_TABLE (table1), radioCQ, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioCQ), radioCQ_group); radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioCQ)); radioCBR = gtk_radio_button_new_with_mnemonic (NULL, _("Constant Bitrate (kbps)")); gtk_widget_show (radioCBR); gtk_table_attach (GTK_TABLE (table1), radioCBR, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioCBR), radioCQ_group); radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioCBR)); radio2Pass = gtk_radio_button_new_with_mnemonic (NULL, _("Dual pass (MBytes)")); gtk_widget_show (radio2Pass); gtk_table_attach (GTK_TABLE (table1), radio2Pass, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio2Pass), radioCQ_group); radioCQ_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio2Pass)); entryCQ = gtk_entry_new (); gtk_widget_show (entryCQ); gtk_table_attach (GTK_TABLE (table1), entryCQ, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entryCBR = gtk_entry_new (); gtk_widget_show (entryCBR); gtk_table_attach (GTK_TABLE (table1), entryCBR, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry2Pass = gtk_entry_new (); gtk_widget_show (entry2Pass); gtk_table_attach (GTK_TABLE (table1), entry2Pass, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label1 = gtk_label_new (_("Basic")); gtk_widget_show (label1); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), label1); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); table2 = gtk_table_new (4, 2, FALSE); gtk_widget_show (table2); gtk_container_add (GTK_CONTAINER (notebook1), table2); label5 = gtk_label_new (_("Motion Search")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); label6 = gtk_label_new (_("Quantization")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table2), label6, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); label7 = gtk_label_new (_("Max I frame interval ")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); spinbuttonMaxIFrame_adj = gtk_adjustment_new (300, 0, 600, 1, 10, 10); spinbuttonMaxIFrame = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonMaxIFrame_adj), 1, 0); gtk_widget_show (spinbuttonMaxIFrame); gtk_table_attach (GTK_TABLE (table2), spinbuttonMaxIFrame, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonMaxIFrame), TRUE); label8 = gtk_label_new (_("Min I frame interval")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table2), label8, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); spinbuttonMinIFrame_adj = gtk_adjustment_new (1, 0, 600, 1, 10, 10); spinbuttonMinIFrame = gtk_spin_button_new (GTK_ADJUSTMENT (spinbuttonMinIFrame_adj), 1, 0); gtk_widget_show (spinbuttonMinIFrame); gtk_table_attach (GTK_TABLE (table2), spinbuttonMinIFrame, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbuttonMinIFrame), TRUE); optionME = gtk_option_menu_new (); gtk_widget_show (optionME); gtk_table_attach (GTK_TABLE (table2), optionME, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); menu4 = gtk_menu_new (); _0___none1 = gtk_menu_item_new_with_mnemonic (_("0 - None")); gtk_widget_show (_0___none1); gtk_container_add (GTK_CONTAINER (menu4), _0___none1); _1__very_low1 = gtk_menu_item_new_with_mnemonic (_("1- Very low")); gtk_widget_show (_1__very_low1); gtk_container_add (GTK_CONTAINER (menu4), _1__very_low1); _2__low1 = gtk_menu_item_new_with_mnemonic (_("2- Low")); gtk_widget_show (_2__low1); gtk_container_add (GTK_CONTAINER (menu4), _2__low1); _3__medium1 = gtk_menu_item_new_with_mnemonic (_("3- Medium")); gtk_widget_show (_3__medium1); gtk_container_add (GTK_CONTAINER (menu4), _3__medium1); _4__high1 = gtk_menu_item_new_with_mnemonic (_("4- High")); gtk_widget_show (_4__high1); gtk_container_add (GTK_CONTAINER (menu4), _4__high1); _5__very_high1 = gtk_menu_item_new_with_mnemonic (_("5- Very High")); gtk_widget_show (_5__very_high1); gtk_container_add (GTK_CONTAINER (menu4), _5__very_high1); _6__ultra_high1 = gtk_menu_item_new_with_mnemonic (_("6- Ultra High")); gtk_widget_show (_6__ultra_high1); gtk_container_add (GTK_CONTAINER (menu4), _6__ultra_high1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionME), menu4); optionQzer = gtk_option_menu_new (); gtk_widget_show (optionQzer); gtk_table_attach (GTK_TABLE (table2), optionQzer, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); menu5 = gtk_menu_new (); h263_quantizer1 = gtk_menu_item_new_with_mnemonic (_("H263 Quantizer")); gtk_widget_show (h263_quantizer1); gtk_container_add (GTK_CONTAINER (menu5), h263_quantizer1); mpeg_quantizer1 = gtk_menu_item_new_with_mnemonic (_("MPEG Quantizer")); gtk_widget_show (mpeg_quantizer1); gtk_container_add (GTK_CONTAINER (menu5), mpeg_quantizer1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionQzer), menu5); label2 = gtk_label_new (_("Advanced")); gtk_widget_show (label2); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), label2); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); table3 = gtk_table_new (4, 2, FALSE); gtk_widget_show (table3); gtk_container_add (GTK_CONTAINER (notebook1), table3); label9 = gtk_label_new (_("Min I Frame Qzer")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); label10 = gtk_label_new (_("Max I Frame Qzer")); gtk_widget_show (label10); gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5); label11 = gtk_label_new (_("Min P Frame Qzer")); gtk_widget_show (label11); gtk_table_attach (GTK_TABLE (table3), label11, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5); label12 = gtk_label_new (_("Max P Frame Qzer")); gtk_widget_show (label12); gtk_table_attach (GTK_TABLE (table3), label12, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5); spinImin_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10); spinImin = gtk_spin_button_new (GTK_ADJUSTMENT (spinImin_adj), 1, 0); gtk_widget_show (spinImin); gtk_table_attach (GTK_TABLE (table3), spinImin, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinImin), TRUE); spinImax_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10); spinImax = gtk_spin_button_new (GTK_ADJUSTMENT (spinImax_adj), 1, 0); gtk_widget_show (spinImax); gtk_table_attach (GTK_TABLE (table3), spinImax, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinImax), TRUE); spinPmin_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10); spinPmin = gtk_spin_button_new (GTK_ADJUSTMENT (spinPmin_adj), 1, 0); gtk_widget_show (spinPmin); gtk_table_attach (GTK_TABLE (table3), spinPmin, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinPmin), TRUE); spinPmax_adj = gtk_adjustment_new (2, 2, 31, 1, 10, 10); spinPmax = gtk_spin_button_new (GTK_ADJUSTMENT (spinPmax_adj), 1, 0); gtk_widget_show (spinPmax); gtk_table_attach (GTK_TABLE (table3), spinPmax, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinPmax), TRUE); label3 = gtk_label_new (_("Quantizer")); gtk_widget_show (label3); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 2), label3); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); label13 = gtk_label_new (_("Not Yet!")); gtk_widget_show (label13); gtk_container_add (GTK_CONTAINER (notebook1), label13); gtk_label_set_justify (GTK_LABEL (label13), GTK_JUSTIFY_LEFT); label4 = gtk_label_new (_("B Frames")); gtk_widget_show (label4); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 3), label4); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, notebook1, "notebook1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, radioCQ, "radioCQ"); GLADE_HOOKUP_OBJECT (dialog1, radioCBR, "radioCBR"); GLADE_HOOKUP_OBJECT (dialog1, radio2Pass, "radio2Pass"); GLADE_HOOKUP_OBJECT (dialog1, entryCQ, "entryCQ"); GLADE_HOOKUP_OBJECT (dialog1, entryCBR, "entryCBR"); GLADE_HOOKUP_OBJECT (dialog1, entry2Pass, "entry2Pass"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, table2, "table2"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonMaxIFrame, "spinbuttonMaxIFrame"); GLADE_HOOKUP_OBJECT (dialog1, label8, "label8"); GLADE_HOOKUP_OBJECT (dialog1, spinbuttonMinIFrame, "spinbuttonMinIFrame"); GLADE_HOOKUP_OBJECT (dialog1, optionME, "optionME"); GLADE_HOOKUP_OBJECT (dialog1, menu4, "menu4"); GLADE_HOOKUP_OBJECT (dialog1, _0___none1, "_0___none1"); GLADE_HOOKUP_OBJECT (dialog1, _1__very_low1, "_1__very_low1"); GLADE_HOOKUP_OBJECT (dialog1, _2__low1, "_2__low1"); GLADE_HOOKUP_OBJECT (dialog1, _3__medium1, "_3__medium1"); GLADE_HOOKUP_OBJECT (dialog1, _4__high1, "_4__high1"); GLADE_HOOKUP_OBJECT (dialog1, _5__very_high1, "_5__very_high1"); GLADE_HOOKUP_OBJECT (dialog1, _6__ultra_high1, "_6__ultra_high1"); GLADE_HOOKUP_OBJECT (dialog1, optionQzer, "optionQzer"); GLADE_HOOKUP_OBJECT (dialog1, menu5, "menu5"); GLADE_HOOKUP_OBJECT (dialog1, h263_quantizer1, "h263_quantizer1"); GLADE_HOOKUP_OBJECT (dialog1, mpeg_quantizer1, "mpeg_quantizer1"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, table3, "table3"); GLADE_HOOKUP_OBJECT (dialog1, label9, "label9"); GLADE_HOOKUP_OBJECT (dialog1, label10, "label10"); GLADE_HOOKUP_OBJECT (dialog1, label11, "label11"); GLADE_HOOKUP_OBJECT (dialog1, label12, "label12"); GLADE_HOOKUP_OBJECT (dialog1, spinImin, "spinImin"); GLADE_HOOKUP_OBJECT (dialog1, spinImax, "spinImax"); GLADE_HOOKUP_OBJECT (dialog1, spinPmin, "spinPmin"); GLADE_HOOKUP_OBJECT (dialog1, spinPmax, "spinPmax"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label13, "label13"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
gint* mooLevelSettings(GtkMenuItem *menuitem, gint* LEVEL) { GtkWidget *mooPreferences; GtkWidget *vBox; GtkWidget *vBoxRadio; GtkWidget *button; GtkWidget *l1, *l2, *l3; menu = menuitem; *LEVEL = 4; DIG_SELECTED = LEVEL; mooPreferences = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (mooPreferences, 200, 190); gtk_window_set_title (GTK_WINDOW (mooPreferences), "Select Game Level"); gtk_container_set_border_width (GTK_CONTAINER (mooPreferences), 10); gtk_window_set_position (GTK_WINDOW (mooPreferences), GTK_WIN_POS_CENTER); gtk_window_set_resizable (GTK_WINDOW (mooPreferences), FALSE); gtk_window_set_icon_name (GTK_WINDOW (mooPreferences), GTK_STOCK_PREFERENCES); g_signal_connect (G_OBJECT (mooPreferences), "delete_event", G_CALLBACK (close_settings), NULL); vBox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (mooPreferences), vBox); gtk_widget_show (vBox); vBoxRadio = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (vBoxRadio), 10); gtk_box_pack_start (GTK_BOX (vBox), vBoxRadio, TRUE, TRUE, 0); gtk_widget_show (vBoxRadio); /*Level 1*/ l1 = gtk_radio_button_new_with_label ( NULL, "Easy: 3 Digits" ); /*Level 2*/ l2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (l1), "Medium: 4 Digits"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l2), TRUE); /*Level 3*/ l3 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (l1), "Hard: 5 Digits"); gtk_box_pack_start (GTK_BOX (vBoxRadio), l1, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vBoxRadio), l2, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vBoxRadio), l3, TRUE, TRUE, 0); gtk_widget_show (l1); gtk_widget_show (l2); gtk_widget_show (l3); g_signal_connect (G_OBJECT (l1), "toggled", G_CALLBACK (radio1Clicked), NULL); g_signal_connect (G_OBJECT (l2), "toggled", G_CALLBACK (radio2Clicked), NULL); g_signal_connect (G_OBJECT (l3), "toggled", G_CALLBACK (radio3Clicked), NULL); vBoxRadio = gtk_vbox_new (FALSE, 10); gtk_container_set_border_width (GTK_CONTAINER (vBoxRadio), 10); gtk_box_pack_start (GTK_BOX (vBox), vBoxRadio, FALSE, TRUE, 0); gtk_widget_show (vBoxRadio); button = gtk_button_new_with_label ("Moo"); gtk_box_pack_start (GTK_BOX (vBoxRadio), button, TRUE, TRUE, 0); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_HALF); gtk_widget_show (button); g_signal_connect_swapped (G_OBJECT (button), "clicked", G_CALLBACK (close_settings), (gpointer)mooPreferences); gtk_widget_show (mooPreferences); return DIG_SELECTED; }
GtkWidget *AP_UnixDialog_Lists::_constructWindowContents (void) { GtkWidget *vbox2; GtkWidget *hbox2; GtkWidget *vbox4; GtkWidget *table1; GtkWidget *style_om; GtkWidget *type_om; GtkWidget *type_lb; GtkWidget *style_lb; GtkWidget *customized_cb; GtkWidget *frame1; GtkWidget *table2; GtkComboBox *font_om; GtkListStore *font_om_menu; GtkWidget *format_en; GtkWidget *decimal_en; GtkAdjustment *start_sb_adj; GtkWidget *start_sb; GtkAdjustment *text_align_sb_adj; GtkWidget *text_align_sb; GtkAdjustment *label_align_sb_adj; GtkWidget *label_align_sb; GtkWidget *format_lb; GtkWidget *font_lb; GtkWidget *delimiter_lb; GtkWidget *start_at_lb; GtkWidget *text_align_lb; GtkWidget *label_align_lb; GtkWidget *vbox3; GtkWidget *preview_lb; GtkWidget *hbox1; GSList *action_group = NULL; GtkWidget *start_list_rb; GtkWidget *apply_list_rb; GtkWidget *resume_list_rb; GtkWidget *preview_area; GtkWidget *preview_frame; const XAP_StringSet * pSS = m_pApp->getStringSet(); UT_UTF8String s; GtkWidget * wNoteBook = NULL; vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (vbox2); if(!isModal()) { // Note Book creation wNoteBook = gtk_notebook_new (); gtk_widget_show(wNoteBook); // Container for the lists pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageProperties,s); GtkWidget * lbPageLists = gtk_label_new(s.utf8_str()); gtk_widget_show(lbPageLists); gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),vbox2,lbPageLists); m_iPageLists = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),vbox2); // Container for Text Folding pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageFolding,s); GtkWidget * lbPageFolding = gtk_label_new(s.utf8_str()); GtkWidget * wFoldingTable = gtk_table_new(6,3,FALSE); gtk_widget_show(lbPageFolding); gtk_widget_show(wFoldingTable); gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),wFoldingTable,lbPageFolding); m_iPageFold = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),wFoldingTable); // Left Spacing Here GtkWidget * lbLeftSpacer = gtk_label_new(""); gtk_misc_set_padding(GTK_MISC(lbLeftSpacer),8,0); gtk_table_attach(GTK_TABLE(wFoldingTable),lbLeftSpacer,0,1,0,6,GTK_SHRINK,GTK_FILL,0,0); gtk_widget_show(lbLeftSpacer); // Bold markup GtkWidget * lbFoldHeading = gtk_label_new("<b>%s</b>"); gtk_label_set_use_markup(GTK_LABEL(lbFoldHeading),TRUE); localizeLabelMarkup(lbFoldHeading,pSS,AP_STRING_ID_DLG_Lists_FoldingLevelexp); gtk_table_attach(GTK_TABLE(wFoldingTable),lbFoldHeading,1,3,0,1,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(lbFoldHeading); // Mid Left Spacing Here GtkWidget * lbMidLeftSpacer = gtk_label_new(""); gtk_misc_set_padding(GTK_MISC(lbMidLeftSpacer),8,0); gtk_table_attach(GTK_TABLE(wFoldingTable),lbMidLeftSpacer,1,2,1,6,GTK_SHRINK,GTK_FILL,0,0); gtk_widget_show(lbMidLeftSpacer); m_vecFoldCheck.clear(); m_vecFoldID.clear(); UT_uint32 ID =0; // RadioButtons pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel0,s); GtkWidget * wF = gtk_radio_button_new_with_label(NULL, s.utf8_str()); GSList *wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF)); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"0"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,1,2,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel1,s); wF = gtk_radio_button_new_with_label(wG, s.utf8_str()); wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF)); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"1"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,2,3,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel2,s); wF = gtk_radio_button_new_with_label(wG, s.utf8_str()); wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF)); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"2"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,3,4,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel3,s); wF = gtk_radio_button_new_with_label(wG, s.utf8_str()); wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF)); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"3"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,4,5,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel4,s); wF = gtk_radio_button_new_with_label(wG, s.utf8_str()); g_object_set_data(G_OBJECT(wF),"level",(gpointer)"4"); ID = g_signal_connect(G_OBJECT(wF), "toggled", G_CALLBACK(s_FoldCheck_changed), (gpointer) this); gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,5,6,GTK_FILL,GTK_EXPAND,0,0); gtk_widget_show(wF); m_vecFoldCheck.addItem(wF); m_vecFoldID.addItem(ID); gtk_widget_show(wFoldingTable); gtk_notebook_set_current_page(GTK_NOTEBOOK(wNoteBook),m_iPageLists); } // List Page gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8); gtk_widget_show (hbox2); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0); vbox4 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_widget_show (vbox4); gtk_box_pack_start (GTK_BOX (hbox2), vbox4, FALSE, TRUE, 0); table1 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox4), table1, FALSE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table1), 4); style_om = gtk_combo_box_text_new(); gtk_widget_show (style_om); gtk_table_attach (GTK_TABLE (table1), style_om, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); m_wListStyleNone_menu = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); _fillNoneStyleMenu(m_wListStyleNone_menu.obj()); m_wListStyleNumbered_menu = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); _fillNumberedStyleMenu(m_wListStyleNumbered_menu.obj()); m_wListStyleBulleted_menu = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); _fillBulletedStyleMenu(m_wListStyleBulleted_menu.obj()); // This is the default list. Change if the list style changes // m_wListStyle_menu = m_wListStyleNumbered_menu; gtk_combo_box_set_model(GTK_COMBO_BOX (style_om), GTK_TREE_MODEL(m_wListStyleNumbered_menu.obj())); type_om = gtk_combo_box_text_new(); gtk_widget_show (type_om); gtk_table_attach (GTK_TABLE (table1), type_om, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_none,s); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str()); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_bullet,s); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str()); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_numbered,s); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str()); gtk_combo_box_set_active(GTK_COMBO_BOX(type_om), 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type,s); type_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (type_lb); gtk_table_attach (GTK_TABLE (table1), type_lb, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (type_lb), 0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Style,s); style_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (style_lb); gtk_table_attach (GTK_TABLE (table1), style_lb, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (style_lb), 0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_SetDefault,s); customized_cb = gtk_dialog_add_button (GTK_DIALOG(m_wMainWindow), s.utf8_str(), BUTTON_RESET); gtk_widget_show (customized_cb); /* todo gtk_table_attach (GTK_TABLE (table1), customized_cb, 0, 2, 2, 3, (GtkAttachOptions) (GTK_SHRINK), (GtkAttachOptions) (0), 0, 0); */ frame1 = gtk_frame_new (NULL); gtk_frame_set_shadow_type(GTK_FRAME(frame1), GTK_SHADOW_NONE); //gtk_widget_show (frame1); gtk_box_pack_start (GTK_BOX (vbox4), frame1, TRUE, TRUE, 0); table2 = gtk_table_new (6, 2, FALSE); gtk_widget_show (table2); gtk_container_add (GTK_CONTAINER (frame1), table2); gtk_container_set_border_width (GTK_CONTAINER (table2), 4); gtk_widget_set_sensitive (table2, TRUE); gtk_table_set_row_spacings (GTK_TABLE (table2), 4); gtk_table_set_col_spacings (GTK_TABLE (table2), 4); font_om_menu = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT); _fillFontMenu(font_om_menu); font_om = GTK_COMBO_BOX(gtk_combo_box_new()); gtk_combo_box_set_model(font_om, GTK_TREE_MODEL(font_om_menu)); gtk_widget_show (GTK_WIDGET(font_om)); gtk_table_attach (GTK_TABLE (table2), GTK_WIDGET(font_om), 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); format_en = gtk_entry_new (); gtk_entry_set_max_length(GTK_ENTRY(format_en), 20); gtk_widget_show (format_en); gtk_table_attach (GTK_TABLE (table2), format_en, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_entry_set_text (GTK_ENTRY (format_en), "%L"); decimal_en = gtk_entry_new (); gtk_widget_show (decimal_en); gtk_table_attach (GTK_TABLE (table2), decimal_en, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_entry_set_text (GTK_ENTRY (format_en), ""); start_sb_adj = (GtkAdjustment*)gtk_adjustment_new (1, 0, G_MAXINT32, 1, 10, 10); start_sb = gtk_spin_button_new (GTK_ADJUSTMENT (start_sb_adj), 1, 0); gtk_widget_show (start_sb); gtk_table_attach (GTK_TABLE (table2), start_sb, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); text_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0.25, 0, 10, 0.01, 0.2, 1); text_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (text_align_sb_adj), 0.05, 2); gtk_widget_show (text_align_sb); gtk_table_attach (GTK_TABLE (table2), text_align_sb, 1, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (text_align_sb), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (text_align_sb), TRUE); label_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0, 0, 10, 0.01, 0.2, 1); label_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (label_align_sb_adj), 0.05, 2); gtk_widget_show (label_align_sb); gtk_table_attach (GTK_TABLE (table2), label_align_sb, 1, 2, 5, 6, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (label_align_sb), TRUE); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (label_align_sb), TRUE); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Format,s); format_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (format_lb); gtk_table_attach (GTK_TABLE (table2), format_lb, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (format_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Font,s); font_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (font_lb); gtk_table_attach (GTK_TABLE (table2), font_lb, 0, 1, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (font_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_DelimiterString,s); delimiter_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (delimiter_lb); gtk_table_attach (GTK_TABLE (table2), delimiter_lb, 0, 1, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (delimiter_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start,s); start_at_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (start_at_lb); gtk_table_attach (GTK_TABLE (table2), start_at_lb, 0, 1, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (start_at_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Align,s); text_align_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (text_align_lb); gtk_table_attach (GTK_TABLE (table2), text_align_lb, 0, 1, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (text_align_lb), 0.0, 0.5); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Indent,s); label_align_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (label_align_lb); gtk_table_attach (GTK_TABLE (table2), label_align_lb, 0, 1, 5, 6, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label_align_lb), 0.0, 0.5); vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (vbox3); gtk_box_pack_start (GTK_BOX (hbox2), vbox3, TRUE, TRUE, 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Preview,s); preview_lb = gtk_label_new (s.utf8_str()); gtk_widget_show (preview_lb); gtk_box_pack_start (GTK_BOX (vbox3), preview_lb, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (preview_lb), 0.0, 0.5); preview_frame = gtk_frame_new (NULL); gtk_widget_show (preview_frame); gtk_box_pack_start (GTK_BOX (vbox3), preview_frame, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (preview_frame), 3); gtk_frame_set_shadow_type (GTK_FRAME (preview_frame), GTK_SHADOW_NONE); preview_area = createDrawingArea (); gtk_widget_set_size_request (preview_area,180,225); gtk_widget_show (preview_area); gtk_container_add (GTK_CONTAINER (preview_frame), preview_area); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); if(!isModal()) gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start_New,s); start_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str()); action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (start_list_rb)); if(!isModal()) gtk_widget_show (start_list_rb); gtk_box_pack_start (GTK_BOX (hbox1), start_list_rb, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (start_list_rb), TRUE); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Apply_Current,s); apply_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str()); action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (apply_list_rb)); if(!isModal()) gtk_widget_show (apply_list_rb); gtk_box_pack_start (GTK_BOX (hbox1), apply_list_rb, FALSE, FALSE, 0); pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Resume,s); resume_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str()); action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (resume_list_rb)); if(!isModal()) gtk_widget_show (resume_list_rb); gtk_box_pack_start (GTK_BOX (hbox1), resume_list_rb, FALSE, FALSE, 0); // Save useful widgets in member variables if(isModal()) { m_wContents = vbox2; } else { m_wContents = wNoteBook; } m_wStartNewList = start_list_rb; m_wStartNew_label = gtk_bin_get_child(GTK_BIN(start_list_rb)); m_wApplyCurrent = apply_list_rb; m_wStartSubList = resume_list_rb; m_wStartSub_label = gtk_bin_get_child(GTK_BIN(resume_list_rb)); m_wRadioGroup = action_group; m_wPreviewArea = preview_area; m_wDelimEntry = format_en; m_oAlignList_adj = text_align_sb_adj; m_wAlignListSpin = text_align_sb; m_oIndentAlign_adj = label_align_sb_adj; m_wIndentAlignSpin = label_align_sb; m_wDecimalEntry = decimal_en; m_oStartSpin_adj = start_sb_adj; m_wStartSpin = start_sb; m_wFontOptions = font_om; m_wFontOptions_menu = font_om_menu; m_wCustomFrame = frame1; m_wCustomLabel = customized_cb; m_wCustomTable = table2; m_wListStyleBox = GTK_COMBO_BOX(style_om); m_wListTypeBox = GTK_COMBO_BOX(type_om); m_wListType_menu = m_wListStyleNumbered_menu; // Start by hiding the Custom frame // // gtk_widget_hide(m_wCustomFrame); gtk_widget_show(m_wCustomFrame); setbisCustomized(false); return m_wContents; }
static void create_screenshot_frame (GtkWidget *outer_vbox, const gchar *frame_title) { GtkWidget *main_vbox, *vbox, *hbox; GtkWidget *align; GtkWidget *radio; GtkWidget *image; GtkWidget *spin; GtkWidget *label; GtkAdjustment *adjust; GSList *group; gchar *title; #if GTK_CHECK_VERSION (3, 0, 0) main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else main_vbox = gtk_vbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (outer_vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); title = g_strconcat ("<b>", frame_title, "</b>", NULL); label = gtk_label_new (title); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_yalign (GTK_LABEL (label), 0.5); #else gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); #endif gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (title); #if GTK_CHECK_VERSION (3, 0, 0) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else hbox = gtk_hbox_new (FALSE, 12); #endif gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); align = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_widget_set_size_request (align, 48, -1); gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, FALSE, 0); gtk_widget_show (align); image = gtk_image_new_from_stock (SCREENSHOOTER_ICON, GTK_ICON_SIZE_DIALOG); gtk_container_add (GTK_CONTAINER (align), image); gtk_widget_show (image); #if GTK_CHECK_VERSION (3, 0, 0) vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else vbox = gtk_vbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); /** Grab whole desktop **/ group = NULL; radio = gtk_radio_button_new_with_mnemonic (group, _("Grab the whole _desktop")); if (take_window_shot || take_area_shot) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), FALSE); g_signal_connect (radio, "toggled", G_CALLBACK (target_toggled_cb), GINT_TO_POINTER (TARGET_TOGGLE_DESKTOP)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); gtk_widget_show (radio); /** Grab current window **/ radio = gtk_radio_button_new_with_mnemonic (group, _("Grab the current _window")); if (take_window_shot) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE); g_signal_connect (radio, "toggled", G_CALLBACK (target_toggled_cb), GINT_TO_POINTER (TARGET_TOGGLE_WINDOW)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio)); gtk_widget_show (radio); /** Grab area of the desktop **/ radio = gtk_radio_button_new_with_mnemonic (group, _("Select _area to grab")); if (take_area_shot) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio), TRUE); g_signal_connect (radio, "toggled", G_CALLBACK (target_toggled_cb), GINT_TO_POINTER (TARGET_TOGGLE_AREA)); gtk_box_pack_start (GTK_BOX (vbox), radio, FALSE, FALSE, 0); gtk_widget_show (radio); /** Grab after delay **/ #if GTK_CHECK_VERSION (3, 0, 0) delay_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); #else delay_hbox = gtk_hbox_new (FALSE, 6); #endif gtk_widget_set_sensitive (delay_hbox, !take_area_shot); gtk_box_pack_start (GTK_BOX (vbox), delay_hbox, FALSE, FALSE, 0); gtk_widget_show (delay_hbox); /* translators: this is the first part of the "grab after a * delay of <spin button> seconds". */ label = gtk_label_new_with_mnemonic (_("Grab _after a delay of")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_yalign (GTK_LABEL (label), 0.5); #else gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); #endif gtk_box_pack_start (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); adjust = GTK_ADJUSTMENT (gtk_adjustment_new ((gdouble) delay, 0.0, 99.0, 1.0, 1.0, 0.0)); spin = gtk_spin_button_new (adjust, 1.0, 0); g_signal_connect (spin, "value-changed", G_CALLBACK (delay_spin_value_changed_cb), NULL); gtk_box_pack_start (GTK_BOX (delay_hbox), spin, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin); gtk_widget_show (spin); /* translators: this is the last part of the "grab after a * delay of <spin button> seconds". */ label = gtk_label_new (_("seconds")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_yalign (GTK_LABEL (label), 0.5); #else gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); #endif gtk_box_pack_end (GTK_BOX (delay_hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); }
/* * snap_dialog * * Bring up the GTK dialog for setting snapshot * parameters. */ static gboolean snap_dialog (void) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkObject *adj; GSList *radio_group = NULL; gint radio_pressed[2]; gint decorations; gboolean run; /* Set defaults */ radio_pressed[0] = (winsnapvals.root == FALSE); radio_pressed[1] = (winsnapvals.root == TRUE); decorations = winsnapvals.decor; /* Init GTK */ gimp_ui_init (PLUG_IN_BINARY, FALSE); /* Main Dialog */ dialog = gimp_dialog_new (PLUG_IN_PRINT_NAME, PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Grab"), GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); winsnapintf.single_button = gtk_radio_button_new_with_label (radio_group, _("Grab a single window")); gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.single_button, FALSE, FALSE, 0); g_signal_connect (winsnapintf.single_button, "toggled", G_CALLBACK (snap_toggle_update), &radio_pressed[0]); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.single_button), radio_pressed[0]); gtk_widget_show (winsnapintf.single_button); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.single_button)); winsnapintf.root_button = gtk_radio_button_new_with_label (radio_group, _("Grab the whole screen")); gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.root_button, FALSE, FALSE, 0); g_signal_connect (winsnapintf.root_button, "toggled", G_CALLBACK (snap_toggle_update), &radio_pressed[1]); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.root_button), radio_pressed[1]); gtk_widget_show (winsnapintf.root_button); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.root_button)); /* with delay */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new (_("after")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); winsnapintf.delay_spinner = gimp_spin_button_new (&adj, winsnapvals.delay, 0.0, 100.0, 1.0, 5.0, 0.0, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), winsnapintf.delay_spinner, FALSE, FALSE, 0); gtk_widget_show (winsnapintf.delay_spinner); label = gtk_label_new (_("Seconds delay")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); #ifdef CAN_SET_DECOR /* With decorations */ winsnapintf.decor_button = gtk_check_button_new_with_label (_("Include decorations")); g_signal_connect (winsnapintf.decor_button, "toggled", G_CALLBACK (snap_toggle_update), &decorations); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.decor_button), decorations); gtk_box_pack_end (GTK_BOX (vbox), winsnapintf.decor_button, FALSE, FALSE, 0); gtk_widget_set_sensitive (winsnapintf.decor_button, radio_pressed[0]); gtk_widget_show (winsnapintf.decor_button); #endif /* CAN_SET_DECOR */ gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { winsnapvals.root = radio_pressed[1]; winsnapvals.decor = decorations; winsnapvals.delay = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (winsnapintf.delay_spinner)); } gtk_widget_destroy (dialog); return run; }
static GtkWidget * message_get_properties(Message *message) { MessageDialog *prop_dialog; GtkWidget *dialog; GtkWidget *entry; GtkWidget *hbox; GtkWidget *label; GSList *group; if (properties_dialog == NULL) { prop_dialog = g_new(MessageDialog, 1); properties_dialog = prop_dialog; dialog = gtk_vbox_new(FALSE, 0); prop_dialog->dialog = dialog; hbox = gtk_hbox_new(FALSE, 5); label = gtk_label_new(_("Message:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); entry = gtk_entry_new(); prop_dialog->text = GTK_ENTRY(entry); gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0); gtk_widget_show (label); gtk_widget_show (entry); gtk_box_pack_start (GTK_BOX (dialog), hbox, TRUE, TRUE, 0); gtk_widget_show(hbox); label = gtk_hseparator_new (); gtk_box_pack_start (GTK_BOX (dialog), label, FALSE, TRUE, 0); gtk_widget_show (label); label = gtk_label_new(_("Message type:")); gtk_box_pack_start (GTK_BOX (dialog), label, FALSE, TRUE, 0); gtk_widget_show (label); /* */ prop_dialog->m_call = gtk_radio_button_new_with_label (NULL, _("Call")); gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_call, TRUE, TRUE, 0); gtk_widget_show (prop_dialog->m_call); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prop_dialog->m_call), TRUE); group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_call)); prop_dialog->m_return = gtk_radio_button_new_with_label(group, _("Return")); gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_return, TRUE, TRUE, 0); gtk_widget_show (prop_dialog->m_return); group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_return)); prop_dialog->m_send = gtk_radio_button_new_with_label(group, _("Asynchronous")); gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_send, TRUE, TRUE, 0); gtk_widget_show (prop_dialog->m_send); group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_send)); prop_dialog->m_create = gtk_radio_button_new_with_label(group, _("Create")); gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_create, TRUE, TRUE, 0); gtk_widget_show (prop_dialog->m_create); group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_create)); prop_dialog->m_destroy = gtk_radio_button_new_with_label(group, _("Destroy")); gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_destroy, TRUE, TRUE, 0); gtk_widget_show (prop_dialog->m_destroy); group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_destroy)); prop_dialog->m_simple = gtk_radio_button_new_with_label(group, _("Simple")); gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_simple, TRUE, TRUE, 0); gtk_widget_show (prop_dialog->m_simple); group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_simple)); prop_dialog->m_recursive = gtk_radio_button_new_with_label(group, _("Recursive")); gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_recursive, TRUE, TRUE, 0); gtk_widget_show (prop_dialog->m_recursive); } fill_in_dialog(message); gtk_widget_show (properties_dialog->dialog); return properties_dialog->dialog; }
static GtkWidget * account_assistant_build_introduction_page (EmpathyAccountAssistant *self) { EmpathyAccountAssistantPriv *priv = GET_PRIV (self); GtkWidget *main_vbox, *hbox_1, *w, *vbox_1; GtkWidget *radio = NULL; GdkPixbuf *pix; const gchar *str; main_vbox = gtk_vbox_new (FALSE, 12); gtk_widget_show (main_vbox); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); hbox_1 = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox_1, TRUE, TRUE, 0); gtk_widget_show (hbox_1); w = gtk_label_new ( _("With Empathy you can chat with people " "online nearby and with friends and colleagues " "who use Google Talk, AIM, Windows Live " "and many other chat programs. With a microphone " "or a webcam you can also have audio or video calls.")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (w), TRUE); gtk_box_pack_start (GTK_BOX (hbox_1), w, FALSE, FALSE, 0); gtk_widget_show (w); pix = empathy_pixbuf_from_icon_name_sized ("empathy", 80); w = gtk_image_new_from_pixbuf (pix); gtk_box_pack_start (GTK_BOX (hbox_1), w, FALSE, FALSE, 6); gtk_widget_show (w); g_object_unref (pix); w = gtk_label_new (_("Do you have an account you've been using " "with another chat program?")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0); gtk_label_set_line_wrap (GTK_LABEL (w), TRUE); gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0); gtk_widget_show (w); w = gtk_alignment_new (0, 0, 0, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0); gtk_box_pack_start (GTK_BOX (main_vbox), w, TRUE, TRUE, 0); gtk_widget_show (w); vbox_1 = gtk_vbox_new (TRUE, 0); gtk_container_add (GTK_CONTAINER (w), vbox_1); gtk_widget_show (vbox_1); if (empathy_import_accounts_to_import ()) { hbox_1 = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_1), hbox_1, TRUE, TRUE, 0); gtk_widget_show (hbox_1); radio = gtk_radio_button_new_with_label (NULL, _("Yes, import my account details from ")); gtk_box_pack_start (GTK_BOX (hbox_1), radio, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (radio), "response", GINT_TO_POINTER (RESPONSE_IMPORT)); gtk_widget_show (radio); w = gtk_combo_box_new_text (); gtk_combo_box_append_text (GTK_COMBO_BOX (w), "Pidgin"); gtk_box_pack_start (GTK_BOX (hbox_1), w, TRUE, TRUE, 0); gtk_combo_box_set_active (GTK_COMBO_BOX (w), 0); gtk_widget_show (w); g_signal_connect (radio, "clicked", G_CALLBACK (account_assistant_radio_choice_toggled_cb), self); priv->first_resp = RESPONSE_IMPORT; } else { priv->first_resp = RESPONSE_ENTER_ACCOUNT; } str = _("Yes, I'll enter my account details now"); if (radio == NULL) { radio = gtk_radio_button_new_with_label (NULL, str); w = radio; } else { w = gtk_radio_button_new_with_label_from_widget ( GTK_RADIO_BUTTON (radio), str); } gtk_box_pack_start (GTK_BOX (vbox_1), w, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (w), "response", GINT_TO_POINTER (RESPONSE_ENTER_ACCOUNT)); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (account_assistant_radio_choice_toggled_cb), self); w = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio), _("No, I want a new account")); gtk_box_pack_start (GTK_BOX (vbox_1), w, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (w), "response", GINT_TO_POINTER (RESPONSE_CREATE_ACCOUNT)); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (account_assistant_radio_choice_toggled_cb), self); w = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio), _("No, I just want to see people online nearby for now")); gtk_box_pack_start (GTK_BOX (vbox_1), w, TRUE, TRUE, 0); g_object_set_data (G_OBJECT (w), "response", GINT_TO_POINTER (RESPONSE_SALUT_ONLY)); gtk_widget_show (w); g_signal_connect (w, "clicked", G_CALLBACK (account_assistant_radio_choice_toggled_cb), self); return main_vbox; }
static void target_version_box_fill (GladeProjectProperties *properties) { GladeProjectPropertiesPrivate *priv = properties->priv; GladeProject *project = priv->project; GtkWidget *vbox = priv->toolkit_box; GtkWidget *label, *active_radio, *target_radio, *hbox; GList *list, *targets; /* Add stuff to vbox */ for (list = glade_app_get_catalogs (); list; list = g_list_next (list)) { GladeCatalog *catalog = list->data; gint minor, major; /* Skip if theres only one option */ if (g_list_length (glade_catalog_get_targets (catalog)) <= 1) continue; glade_project_get_target_version (project, glade_catalog_get_name (catalog), &major, &minor); /* Special case to mark GTK+ in upper case */ if (strcmp (glade_catalog_get_name (catalog), "gtk+") == 0) label = gtk_label_new ("GTK+"); else label = gtk_label_new (glade_catalog_get_name (catalog)); gtk_misc_set_alignment (GTK_MISC (label), 0.0F, 0.5F); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 2); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); active_radio = target_radio = NULL; for (targets = glade_catalog_get_targets (catalog); targets; targets = targets->next) { GladeTargetableVersion *version = targets->data; gchar *name = g_strdup_printf ("%d.%d", version->major, version->minor); if (!target_radio) target_radio = gtk_radio_button_new_with_label (NULL, name); else target_radio = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (target_radio), name); g_free (name); g_signal_connect (G_OBJECT (target_radio), "clicked", G_CALLBACK (target_button_clicked), properties); g_object_set_data (G_OBJECT (target_radio), "version", version); g_object_set_data (G_OBJECT (target_radio), "catalog", (gchar *) glade_catalog_get_name (catalog)); gtk_widget_show (target_radio); gtk_box_pack_end (GTK_BOX (hbox), target_radio, TRUE, TRUE, 2); if (major == version->major && minor == version->minor) active_radio = target_radio; } if (active_radio) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (active_radio), TRUE); g_hash_table_insert (priv->target_radios, g_strdup (glade_catalog_get_name (catalog)), gtk_radio_button_get_group (GTK_RADIO_BUTTON (active_radio))); } else g_warning ("Corrupt catalog versions"); gtk_widget_show (hbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2); } }
static void greeter_system_handler (GreeterItemInfo *info, gpointer user_data) { GtkWidget *w = NULL; GtkWidget *hbox = NULL; GtkWidget *main_vbox = NULL; GtkWidget *vbox = NULL; GtkWidget *cat_vbox = NULL; GtkWidget *group_radio = NULL; GtkWidget *halt_radio = NULL; GtkWidget *suspend_radio = NULL; GtkWidget *restart_radio = NULL; GtkWidget *config_radio = NULL; gchar *s; int ret; gint i; GSList *radio_group = NULL; static GtkTooltips *tooltips = NULL; /* should never be allowed by the UI */ if ( ! mdm_config_get_bool (MDM_KEY_SYSTEM_MENU) || ve_string_empty (g_getenv ("MDM_IS_LOCAL"))) return; dialog = gtk_dialog_new (); if (tooltips == NULL) tooltips = gtk_tooltips_new (); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); main_vbox = gtk_vbox_new (FALSE, 18); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox, FALSE, FALSE, 0); cat_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_vbox), cat_vbox, FALSE, FALSE, 0); s = g_strdup_printf ("<b>%s</b>", _("Choose an Action")); w = gtk_label_new (s); gtk_label_set_use_markup (GTK_LABEL (w), TRUE); g_free (s); gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (cat_vbox), w, FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (cat_vbox), hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), gtk_label_new (" "), FALSE, FALSE, 0); vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); if (MdmHaltFound) { if (group_radio != NULL) radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio)); halt_radio = gtk_radio_button_new_with_mnemonic (radio_group, _("Shut _down the computer")); group_radio = halt_radio; gtk_tooltips_set_tip (tooltips, GTK_WIDGET (halt_radio), _("Shut Down your computer so that " "you may turn it off."), NULL); g_signal_connect (G_OBJECT(halt_radio), "button_press_event", G_CALLBACK(radio_button_press_event), NULL); gtk_box_pack_start (GTK_BOX (vbox), halt_radio, FALSE, FALSE, 4); gtk_widget_show (halt_radio); } if (MdmRebootFound) { if (group_radio != NULL) radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio)); restart_radio = gtk_radio_button_new_with_mnemonic (radio_group, _("_Restart the computer")); group_radio = restart_radio; gtk_tooltips_set_tip (tooltips, GTK_WIDGET (restart_radio), _("Restart your computer"), NULL); g_signal_connect (G_OBJECT(restart_radio), "button_press_event", G_CALLBACK(radio_button_press_event), NULL); gtk_box_pack_start (GTK_BOX (vbox), restart_radio, FALSE, FALSE, 4); gtk_widget_show (restart_radio); } if (MdmSuspendFound) { if (group_radio != NULL) radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio)); suspend_radio = gtk_radio_button_new_with_mnemonic (radio_group, _("Sus_pend the computer")); group_radio = suspend_radio; gtk_tooltips_set_tip (tooltips, GTK_WIDGET (suspend_radio), _("Suspend your computer"), NULL); g_signal_connect (G_OBJECT(suspend_radio), "button_press_event", G_CALLBACK(radio_button_press_event), NULL); gtk_box_pack_start (GTK_BOX (vbox), suspend_radio, FALSE, FALSE, 4); gtk_widget_show (suspend_radio); } /* * Disable Configuration if using accessibility (AddGtkModules) since * using it with accessibility causes a hang. */ if (mdm_config_get_bool (MDM_KEY_CONFIG_AVAILABLE) && !mdm_config_get_bool (MDM_KEY_ADD_GTK_MODULES) && bin_exists (mdm_config_get_string (MDM_KEY_CONFIGURATOR))) { if (group_radio != NULL) radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (group_radio)); config_radio = gtk_radio_button_new_with_mnemonic (radio_group, _("Confi_gure the login manager")); group_radio = config_radio; gtk_tooltips_set_tip (tooltips, GTK_WIDGET (config_radio), _("Configure MDM (this login manager). " "This will require the root password."), NULL); g_signal_connect (G_OBJECT(config_radio), "button_press_event", G_CALLBACK(radio_button_press_event), NULL); gtk_box_pack_start (GTK_BOX (vbox), config_radio, FALSE, FALSE, 4); gtk_widget_show (config_radio); } gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_widget_show_all (dialog); mdm_wm_center_window (GTK_WINDOW (dialog)); mdm_wm_no_login_focus_push (); ret = gtk_dialog_run (GTK_DIALOG (dialog)); mdm_wm_no_login_focus_pop (); if (ret != GTK_RESPONSE_OK) { gtk_widget_destroy (dialog); return; } if (halt_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (halt_radio))) greeter_halt_handler (); else if (restart_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (restart_radio))) greeter_restart_handler (); else if (suspend_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (suspend_radio))) greeter_suspend_handler (); else if (config_radio != NULL && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (config_radio))) greeter_config_handler (); gtk_widget_destroy (dialog); }
void CUIHandler::ShowSettingsDlg(void) { GtkWidget* settingsDlg; GtkWidget* dialog_vbox1; GtkWidget* frame4; GtkWidget* alignment4; GtkWidget* vbox2; GtkWidget* radiobuttonBt; GtkWidget* hbox2; GtkWidget* radiobuttonInet; GtkWidget* label5; GtkWidget* inetPort; GtkWidget* label4; GtkWidget* dialog_action_area1; CUserSettings crtSettings = pSmartEngine->GetSettings(); settingsDlg = gtk_dialog_new_with_buttons("SmartCam Preferences", GTK_WINDOW(pSmartEngine->GetMainWindow()), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_window_set_type_hint(GTK_WINDOW (settingsDlg), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = GTK_DIALOG (settingsDlg)->vbox; gtk_widget_show (dialog_vbox1); frame4 = gtk_frame_new (NULL); gtk_widget_show (frame4); gtk_box_pack_start (GTK_BOX (dialog_vbox1), frame4, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame4), GTK_SHADOW_IN); alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment4); gtk_container_add (GTK_CONTAINER (frame4), alignment4); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 10, 10, 12, 12); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_add (GTK_CONTAINER (alignment4), vbox2); radiobuttonBt = gtk_radio_button_new_with_mnemonic(NULL, "Bluetooth"); gtk_box_pack_start(GTK_BOX (vbox2), radiobuttonBt, FALSE, FALSE, 0); hbox2 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox2); gtk_box_pack_start(GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0); radiobuttonInet = gtk_radio_button_new_with_mnemonic_from_widget(GTK_RADIO_BUTTON(radiobuttonBt), "TCP/IP (WiFi)"); gtk_box_pack_start(GTK_BOX (hbox2), radiobuttonInet, FALSE, FALSE, 0); label5 = gtk_label_new(" Port: "); gtk_box_pack_start(GTK_BOX(hbox2), label5, FALSE, FALSE, 0); inetPort = gtk_spin_button_new_with_range(1025, 65536, 1); gtk_box_pack_start(GTK_BOX(hbox2), inetPort, TRUE, TRUE, 0); label4 = gtk_label_new("Connection"); gtk_frame_set_label_widget(GTK_FRAME(frame4), label4); gtk_label_set_use_markup(GTK_LABEL(label4), TRUE); dialog_action_area1 = GTK_DIALOG(settingsDlg)->action_area; gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); g_signal_connect(G_OBJECT(radiobuttonBt), "toggled", G_CALLBACK(OnRadiobuttonBluetooth), inetPort); if(crtSettings.connectionType == CONN_BLUETOOTH) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), FALSE); g_object_set(G_OBJECT(inetPort), "sensitive", FALSE, NULL); } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonBt), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobuttonInet), TRUE); g_object_set(G_OBJECT(inetPort), "sensitive", TRUE, NULL); } gtk_spin_button_set_value(GTK_SPIN_BUTTON(inetPort), crtSettings.inetPort); gtk_widget_show_all(settingsDlg); if(gtk_dialog_run(GTK_DIALOG(settingsDlg)) == GTK_RESPONSE_OK) { CUserSettings newSettings = crtSettings; if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radiobuttonBt))) { newSettings.connectionType = CONN_BLUETOOTH; } else { newSettings.connectionType = CONN_INET; newSettings.inetPort = gtk_spin_button_get_value(GTK_SPIN_BUTTON(inetPort)); } pSmartEngine->SaveSettings(newSettings); } gtk_widget_destroy(settingsDlg); }
int l_kasopp_v(iceb_u_str *kodzap, //Код записи для корректировки ; возвращается код только что введённой записи GtkWidget *wpredok) { l_kasopp_v_data data; data.kodk.new_plus(kodzap->ravno()); iceb_u_str naim_shet(""); iceb_u_str naim_shetk(""); class iceb_u_str naim_kodcn(""); char strsql[512]; class iceb_u_str kikz; if(kodzap->getdlinna() > 1) { //читаем корректируемую запись SQL_str row; SQLCURSOR cur; sprintf(strsql,"select * from Kasop1 where kod='%s'",kodzap->ravno()); if(iceb_sql_readkey(strsql,&row,&cur,wpredok) != 1) { iceb_menu_soob(gettext("Не найдена запись для корректировки !"),wpredok); return(1); } data.rk.kod.new_plus(row[0]); data.rk.naim.new_plus(row[1]); data.rk.shet.new_plus(row[2]); data.rk.shetk.new_plus(row[3]); data.rk.prov=atoi(row[4]); kikz.plus(iceb_kikz(row[5],row[6],wpredok)); if(atoi(row[7]) != 0) data.rk.kod_cn.new_plus(row[7]); if(data.rk.shet.getdlinna() > 1) { //Узнаём наименование счёта sprintf(strsql,"select nais from Plansh where ns='%s'",data.rk.shet.ravno()); if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1) naim_shet.new_plus(row[0]); } if(data.rk.shetk.getdlinna() > 1) { //Узнаём наименование счёта корреспондента sprintf(strsql,"select nais from Plansh where ns='%s'",data.rk.shetk .ravno()); if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1) naim_shetk.new_plus(row[0]); } if(data.rk.kod_cn.getdlinna() > 1) { //Узнаём наименование счёта корреспондента sprintf(strsql,"select naik from Kascn where kod=%d",data.rk.kod_cn.ravno_atoi()); if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1) naim_kodcn.new_plus(row[0]); } } 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); if(kodzap->getdlinna() > 1) sprintf(strsql,"%s %s",name_system,gettext("Корректировка записи")); else sprintf(strsql,"%s %s",name_system,gettext("Ввод новой записи")); gtk_window_set_title (GTK_WINDOW (data.window),strsql); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); 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); } 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_kasopp_v_v_key_press),&data); iceb_u_str zagolov; if(kodzap->getdlinna() <= 1) zagolov.new_plus(gettext("Ввод новой записи")); else { zagolov.new_plus(gettext("Корректировка записи")); zagolov.ps_plus(kikz.ravno()); } GtkWidget *label=gtk_label_new(zagolov.ravno_toutf()); 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); gtk_box_pack_start (GTK_BOX (vbox),label, TRUE, TRUE, 1); for(int i=0; i < KOLENTER; i++) gtk_box_pack_start (GTK_BOX (vbox),hbox[i], TRUE, TRUE, 1); GtkWidget *separator1=gtk_hseparator_new(); GtkWidget *separator3=gtk_hseparator_new(); gtk_box_pack_start (GTK_BOX (vbox),separator1, TRUE, TRUE, 2); //Вставляем радиокнопки data.radiobutton2[0]=gtk_radio_button_new_with_label_from_widget(NULL,gettext("Проводки не нужно делать")); data.radiobutton2[1]=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(data.radiobutton2[0]),gettext("Проводки нужно делать")); gtk_box_pack_start (GTK_BOX (vbox), data.radiobutton2[0], TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX (vbox), data.radiobutton2[1], TRUE, TRUE, 1); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton2[data.rk.prov]),TRUE); //Устанавливем активной кнопку gtk_box_pack_start (GTK_BOX (vbox),separator3, TRUE, TRUE, 2); gtk_box_pack_start (GTK_BOX (vbox),hboxknop, TRUE, TRUE, 1); GtkTooltips *tooltips_enter[KOLENTER]; sprintf(strsql,"%s",gettext("Код операции")); label=gtk_label_new(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE, 0); data.entry[E_KOD] = gtk_entry_new_with_max_length (20); gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD],TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk.kod.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD); sprintf(strsql,"%s",gettext("Наименование операции")); label=gtk_label_new(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label,FALSE, FALSE, 0); data.entry[E_NAIM] = gtk_entry_new_with_max_length (249); gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM],TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk.naim.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM); sprintf(strsql,"%s",gettext("Счёт")); data.knopka_enter[E_SHET]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.knopka_enter[E_SHET], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_SHET]),"clicked",GTK_SIGNAL_FUNC(kasopp_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_SHET]),(gpointer)E_SHET); tooltips_enter[E_SHET]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_SHET],data.knopka_enter[E_SHET],gettext("Выбор счёта в плане счетов"),NULL); data.entry[E_SHET] = gtk_entry_new_with_max_length (19); gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.entry[E_SHET],TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_SHET]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_SHET]),data.rk.shet.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SHET]),(gpointer)E_SHET); data.label_naishet=gtk_label_new(naim_shet.ravno_toutf(20)); gtk_box_pack_start (GTK_BOX (hbox[E_SHET]), data.label_naishet,TRUE, TRUE, 0); sprintf(strsql,"%s",gettext("Счёт корреспондент")); data.knopka_enter[E_SHETK]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_SHETK]), data.knopka_enter[E_SHETK], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_SHETK]),"clicked",GTK_SIGNAL_FUNC(kasopp_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_SHETK]),(gpointer)E_SHETK); tooltips_enter[E_SHETK]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_SHETK],data.knopka_enter[E_SHETK],gettext("Выбор счёта в плане счетов"),NULL); data.entry[E_SHETK] = gtk_entry_new_with_max_length (19); gtk_box_pack_start (GTK_BOX (hbox[E_SHETK]), data.entry[E_SHETK],TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_SHETK]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_SHETK]),data.rk.shetk.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_SHETK]),(gpointer)E_SHETK); data.label_naishetk=gtk_label_new(naim_shetk.ravno_toutf(20)); gtk_box_pack_start (GTK_BOX (hbox[E_SHETK]), data.label_naishetk,TRUE, TRUE, 0); sprintf(strsql,"%s",gettext("Код целевого назначения")); data.knopka_enter[E_KOD_CN]=gtk_button_new_with_label(iceb_u_toutf(strsql)); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_CN]), data.knopka_enter[E_KOD_CN], FALSE, FALSE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KOD_CN]),"clicked",GTK_SIGNAL_FUNC(kasopp_v_e_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KOD_CN]),(gpointer)E_KOD_CN); tooltips_enter[E_KOD_CN]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips_enter[E_KOD_CN],data.knopka_enter[E_KOD_CN],gettext("Выбор кода целевого назначения"),NULL); data.entry[E_KOD_CN] = gtk_entry_new_with_max_length (19); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_CN]), data.entry[E_KOD_CN],TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_CN]), "activate",GTK_SIGNAL_FUNC(l_kasopp_v_v_vvod),&data); gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_CN]),data.rk.kod_cn.ravno_toutf()); gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_CN]),(gpointer)E_KOD_CN); data.label_naikodcn=gtk_label_new(naim_kodcn.ravno_toutf(20)); gtk_box_pack_start (GTK_BOX (hbox[E_KOD_CN]), data.label_naikodcn,TRUE, TRUE, 0); GtkTooltips *tooltips[KOL_F_KL]; 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_kasopp_v_v_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,"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_kasopp_v_v_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(data.voz == 0) kodzap->new_plus(data.rk.kod.ravno()); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); return(data.voz); }
static void setup_dialog (GtkBuilder *builder) { GSList *mode_group; GtkListStore *store; g_signal_connect (proxy_settings, "changed::" IGNORE_HOSTS_KEY, G_CALLBACK (cb_ignore_hosts_gsettings_changed), NULL); /* Mode */ proxy_mode_gsettings_changed (proxy_settings, PROXY_MODE_KEY, builder); mode_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (gtk_builder_get_object (builder, "none_radiobutton"))); connect_sensitivity_signals (builder, mode_group); g_signal_connect (proxy_settings, "changed::" PROXY_MODE_KEY, G_CALLBACK (proxy_mode_gsettings_changed), builder); /* Http */ g_settings_bind (http_proxy_settings, HTTP_PROXY_PORT_KEY, gtk_builder_get_object (builder, "http_port_spinbutton"), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (http_proxy_settings, HTTP_PROXY_HOST_KEY, gtk_builder_get_object (builder, "http_host_entry"), "text", G_SETTINGS_BIND_DEFAULT); g_signal_connect (gtk_builder_get_object (builder, "details_button"), "clicked", G_CALLBACK (cb_http_details_button_clicked), _gtk_builder_get_widget (builder, "network_dialog")); /* Secure */ g_settings_bind (https_proxy_settings, SECURE_PROXY_PORT_KEY, gtk_builder_get_object (builder, "secure_port_spinbutton"), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (https_proxy_settings, SECURE_PROXY_HOST_KEY, gtk_builder_get_object (builder, "secure_host_entry"), "text", G_SETTINGS_BIND_DEFAULT); /* Ftp */ g_settings_bind (ftp_proxy_settings, FTP_PROXY_PORT_KEY, gtk_builder_get_object (builder, "ftp_port_spinbutton"), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (ftp_proxy_settings, FTP_PROXY_HOST_KEY, gtk_builder_get_object (builder, "ftp_host_entry"), "text", G_SETTINGS_BIND_DEFAULT); /* Socks */ g_settings_bind (socks_proxy_settings, SOCKS_PROXY_PORT_KEY, gtk_builder_get_object (builder, "socks_port_spinbutton"), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind (socks_proxy_settings, SOCKS_PROXY_HOST_KEY, gtk_builder_get_object (builder, "socks_host_entry"), "text", G_SETTINGS_BIND_DEFAULT); /* Autoconfiguration */ g_settings_bind (proxy_settings, PROXY_AUTOCONFIG_URL_KEY, gtk_builder_get_object (builder, "autoconfig_entry"), "text", G_SETTINGS_BIND_DEFAULT); g_signal_connect (gtk_builder_get_object (builder, "network_dialog"), "response", G_CALLBACK (cb_dialog_response), NULL); read_ignore_hosts_from_gsettings (); model = create_listmodel(); populate_listmodel(GTK_LIST_STORE(model), ignore_hosts); config_treeview(GTK_TREE_VIEW(gtk_builder_get_object (builder, "treeview_ignore_host")), model); g_signal_connect (gtk_builder_get_object (builder, "button_add_url"), "clicked", G_CALLBACK (cb_add_url), builder); g_signal_connect (gtk_builder_get_object (builder, "entry_url"), "activate", G_CALLBACK (cb_add_url), builder); g_signal_connect (gtk_builder_get_object (builder, "button_remove_url"), "clicked", G_CALLBACK (cb_remove_url), builder); }
/* Set up the property editors in the dialog. */ static void setup_dialog (CcMousePropertiesPrivate *d) { GtkRadioButton *radio; /* Orientation radio buttons */ radio = GTK_RADIO_BUTTON (WID ("left_handed_radio")); g_settings_bind (d->mouse_settings, "left-handed", radio, "active", G_SETTINGS_BIND_DEFAULT); /* explicitly connect to button-release so that you can change orientation with either button */ g_signal_connect (WID ("right_handed_radio"), "button_release_event", G_CALLBACK (orientation_radio_button_release_event), NULL); g_signal_connect (WID ("left_handed_radio"), "button_release_event", G_CALLBACK (orientation_radio_button_release_event), NULL); /* Double-click time */ g_settings_bind (d->gsd_mouse_settings, "double-click", gtk_range_get_adjustment (GTK_RANGE (WID ("double_click_scale"))), "value", G_SETTINGS_BIND_DEFAULT); /* Mouse section */ gtk_widget_set_visible (WID ("mouse_vbox"), d->have_mouse); gtk_scale_add_mark (GTK_SCALE (WID ("pointer_speed_scale")), 0, GTK_POS_TOP, NULL); g_settings_bind (d->mouse_settings, "speed", gtk_range_get_adjustment (GTK_RANGE (WID ("pointer_speed_scale"))), "value", G_SETTINGS_BIND_DEFAULT); /* Trackpad page */ gtk_widget_set_visible (WID ("touchpad_vbox"), d->have_touchpad); gtk_widget_set_visible (WID ("touchpad_enabled_switch"), show_touchpad_enabling_switch (d)); g_settings_bind_with_mapping (d->touchpad_settings, "send-events", WID ("touchpad_enabled_switch"), "active", G_SETTINGS_BIND_DEFAULT, touchpad_enabled_get_mapping, touchpad_enabled_set_mapping, NULL, NULL); g_settings_bind_with_mapping (d->touchpad_settings, "send-events", WID ("touchpad_options_box"), "sensitive", G_SETTINGS_BIND_GET, touchpad_enabled_get_mapping, touchpad_enabled_set_mapping, NULL, NULL); g_settings_bind (d->touchpad_settings, "tap-to-click", WID ("tap_to_click_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (d->touchpad_settings, "natural-scroll", WID ("natural_scroll_toggle"), "active", G_SETTINGS_BIND_DEFAULT); gtk_scale_add_mark (GTK_SCALE (WID ("touchpad_pointer_speed_scale")), 0, GTK_POS_TOP, NULL); g_settings_bind (d->touchpad_settings, "speed", gtk_range_get_adjustment (GTK_RANGE (WID ("touchpad_pointer_speed_scale"))), "value", G_SETTINGS_BIND_DEFAULT); if (d->have_touchpad) { synaptics_check_capabilities (d); setup_scrollmethod_radios (d); } g_signal_connect (WID ("two_finger_scroll_toggle"), "toggled", G_CALLBACK (scrollmethod_changed_event), d); }
gboolean on_key_treeview_selection ( GtkTreeSelection *selection, GtkTreeModel *model, GtkTreePath *path, gboolean path_currently_selected, gpointer userdata ) /* Global input: key_list - The list containing the settings for every key Global output: selected_key - Will point to the KTKeySettings in 'key_list' that corresponds to the selected key (if a key is selected) Description: This function sets all the settings of the selected key (if one selected) to the GUI and sets 'selected_key' to the address of the selected key settings. The key settings will be found in 'key_list'. */ { GtkEntry *program_entry = NULL, *default_entry, *plugin_combo_entry, *plugin_function_combo_entry; GtkRadioButton *radiobutton, *default_radiobutton, *program_radiobutton, *special_action_radiobutton; GtkList *plugin_combo_list, *plugin_function_combo_list; GtkTreeView *key_treeview; GtkTreeIter iter; char *key_name, *program_user = "", *default_action; KTPluginInfoEntry *plugin; /* If a row was selected instead of deselected */ if (gtk_tree_model_get_iter(model, &iter, path)) { /* Get the name of the selected key */ gtk_tree_model_get (model, &iter, FIRST_COLUMN, &key_name, -1); if (key_name != NULL) /* If a listitem was selected instead of deselected */ { key_treeview = gtk_tree_selection_get_tree_view(selection); program_entry = KTGUI_program_entry(); default_entry = KTGUI_default_entry(); plugin_combo_entry = KTGUI_plugin_combo_entry(); plugin_function_combo_entry = KTGUI_plugin_function_combo_entry(); default_radiobutton = KTGUI_default_radiobutton(); program_radiobutton = KTGUI_program_radiobutton(); special_action_radiobutton = KTGUI_special_action_radiobutton(); plugin_combo_list = KTGUI_plugin_combo_list(); plugin_function_combo_list = KTGUI_plugin_function_combo_list(); /* Block the signal handlers of the entries and the radiobuttons */ g_signal_handlers_block_by_func (GTK_OBJECT(program_entry), (void *)on_program_entry_changed, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(default_radiobutton), (void *)on_default_radiobutton_toggled, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(program_radiobutton), (void *)on_program_radiobutton_toggled, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(special_action_radiobutton), (void *)on_special_action_radiobutton_toggled, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(plugin_combo_entry), (void *)on_plugin_combo_entry_changed, NULL); g_signal_handlers_block_by_func (GTK_OBJECT(plugin_function_combo_entry), (void *)on_plugin_function_combo_entry_changed, NULL); gtk_entry_set_text (plugin_combo_entry, ""); gtk_entry_set_text (plugin_function_combo_entry, ""); /* Clear the plugin function list */ gtk_list_clear_items (plugin_function_combo_list, 0, -1); /* Clear the whole list */ /* Select the key in the linked list */ selected_key = find_key_settings(key_name, &key_list); /* Read the settings of the key */ if (!memcmp(&selected_key->action, &selected_key->default_action, sizeof(KTAction))) { radiobutton = default_radiobutton; } else if (selected_key->action.type == KTActionTypeProgram) { program_user = selected_key->action.program.command; radiobutton = GTK_RADIO_BUTTON( lookup_widget(GTK_WIDGET(key_treeview), "program_radiobutton") ); } else if (selected_key->action.type == KTActionTypePlugin) { plugin = find_plugin (selected_key->action.plugin.plugin_name, &plugin_list); if (plugin_function_exists (selected_key->action.plugin.plugin_name, selected_key->action.plugin.function_name, &plugin_list)) { reload_plugin_function_list (KTGUI_plugin_function_combo_list(), GTK_OBJECT( KTGUI_plugin_function_combo_entry() ), on_plugin_function_combo_entry_changed, plugin); gtk_entry_set_text (plugin_combo_entry, selected_key->action.plugin.plugin_name); gtk_entry_set_text (plugin_function_combo_entry, selected_key->action.plugin.function_name); radiobutton = special_action_radiobutton; } else { radiobutton = default_radiobutton; } } /* Show the settings of the key */ gtk_label_set_text (KTGUI_key_name_label(), key_name); gtk_entry_set_text (GTK_ENTRY(program_entry), program_user); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(radiobutton), TRUE); if (selected_key->default_action.type == KTActionTypePlugin) { /* If the plugin is not available on this system */ if (selected_key->default_action.plugin.plugin_name == NULL) { default_action = ""; } else { default_action = (char *)g_strdup_printf ("%s - %s", selected_key->default_action.plugin.plugin_name, selected_key->default_action.plugin.function_name); } } else if (selected_key->default_action.type == KTActionTypeProgram) { default_action = (char *)g_strdup_printf( selected_key->default_action.program.command); } /* Show the default action */ gtk_entry_set_text (GTK_ENTRY(default_entry), default_action); if (default_action[0] != '\0') { g_free (default_action); } /* Unblock the signal handlers of the entries and the radiobuttons */ g_signal_handlers_unblock_by_func (GTK_OBJECT(program_entry), (void *)on_program_entry_changed, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(default_radiobutton), (void *)on_default_radiobutton_toggled, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(program_radiobutton), (void *)on_program_radiobutton_toggled, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(special_action_radiobutton), (void *)on_special_action_radiobutton_toggled, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(plugin_combo_entry), (void *)on_plugin_combo_entry_changed, NULL); g_signal_handlers_unblock_by_func (GTK_OBJECT(plugin_function_combo_entry), (void *)on_plugin_function_combo_entry_changed, NULL); g_free (key_name); } } return (TRUE); }
static void on_insert_numbers_activate(G_GNUC_UNUSED GtkMenuItem *menuitem, G_GNUC_UNUSED gpointer gdata) { InsertNumbersDialog d; GtkWidget *vbox, *label, *upper, *space, *button; GtkGrid *grid; GtkComboBoxText *combo; const char *case_tip = _("For base 11 and above"); gchar *base_text; gint result; d.dialog = gtk_dialog_new_with_buttons(_("Insert Numbers"), GTK_WINDOW(geany->main_widgets->window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); vbox = ui_dialog_vbox_new(GTK_DIALOG(d.dialog)); gtk_box_set_spacing(GTK_BOX(vbox), 9); #if GTK_CHECK_VERSION(3, 0, 0) grid = GTK_GRID(gtk_grid_new()); #else grid = GTK_TABLE(gtk_table_new(3, 6, FALSE)); #endif gtk_grid_set_row_spacing(grid, 6); gtk_grid_set_column_spacing(grid, 6); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(grid), TRUE, TRUE, 0); label = gtk_label_new_with_mnemonic(_("_Start:")); gtk_grid_attach(grid, label, 0, 0, 1, 1); d.start = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1); set_entry(d.start, RANGE_LEN, label, RANGE_TOOLTIP); gtk_grid_attach(grid, d.start, 1, 0, 2, 1); label = gtk_label_new_with_mnemonic(_("S_tep:")); gtk_grid_attach(grid, label, 3, 0, 1, 1); d.step = gtk_spin_button_new_with_range(RANGE_MIN, RANGE_MAX, 1); set_entry(d.step, RANGE_LEN, label, RANGE_TOOLTIP); gtk_grid_attach(grid, d.step, 4, 0, 2, 1); label = gtk_label_new_with_mnemonic(_("_Base:")); gtk_grid_attach(grid, label, 0, 1, 1, 1), combo = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new_with_entry()); d.base = gtk_bin_get_child(GTK_BIN(combo)); set_entry(d.base, 2, label, "2..36"); g_signal_connect(d.base, "insert-text", G_CALLBACK(on_base_insert_text), NULL); gtk_combo_box_text_append_text(combo, "2"); gtk_combo_box_text_append_text(combo, "8"); gtk_combo_box_text_append_text(combo, "10"); gtk_combo_box_text_append_text(combo, "16"); #if GTK_CHECK_VERSION(3, 0, 0) gtk_grid_attach(grid, GTK_WIDGET(combo), 1, 1, 2, 1); gtk_widget_set_hexpand(GTK_WIDGET(combo), TRUE); #else gtk_table_attach(grid, GTK_WIDGET(combo), 1, 3, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); #endif label = gtk_label_new(_("Letters:")); gtk_widget_set_tooltip_text(label, case_tip); gtk_grid_attach(grid, label, 3, 1, 1, 1); upper = gtk_radio_button_new_with_mnemonic(NULL, _("_Upper")); gtk_widget_set_tooltip_text(upper, case_tip); gtk_grid_attach(grid, upper, 4, 1, 1, 1); d.lower = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(upper)); gtk_widget_set_tooltip_text(label, case_tip); label = gtk_label_new_with_mnemonic(_("_Lower")); gtk_widget_set_tooltip_text(label, case_tip); gtk_container_add(GTK_CONTAINER(d.lower), label); gtk_grid_attach(grid, d.lower, 5, 1, 1, 1); d.prefix = gtk_check_button_new_with_mnemonic(_("Base _prefix")); gtk_widget_set_tooltip_text(d.prefix, _("0 for octal, 0x for hex, + for positive decimal")); gtk_grid_attach(grid, d.prefix, 1, 2, 2, 1); label = gtk_label_new(_("Padding:")); gtk_grid_attach(grid, label, 3, 2, 1, 1); space = gtk_radio_button_new_with_mnemonic(NULL, _("Sp_ace")); gtk_grid_attach(grid, space, 4, 2, 1, 1); d.zero = gtk_radio_button_new_from_widget(GTK_RADIO_BUTTON(space)); label = gtk_label_new_with_mnemonic(_("_Zero")); gtk_container_add(GTK_CONTAINER(d.zero), label); gtk_grid_attach(grid, d.zero, 5, 2, 1, 1); button = gtk_button_new_from_stock(GTK_STOCK_OK); g_signal_connect(button, "clicked", G_CALLBACK(on_insert_numbers_ok_clicked), &d); gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(d.dialog))), button, TRUE, TRUE, 0); #if GTK_CHECK_VERSION(2, 18, 0) gtk_widget_set_can_default(button, TRUE); #else GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); #endif gtk_widget_grab_default(button); gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.start), start_value); gtk_spin_button_set_value(GTK_SPIN_BUTTON(d.step), step_value); base_text = g_strdup_printf("%d", base_value); gtk_entry_set_text(GTK_ENTRY(d.base), base_text); g_free(base_text); gtk_button_clicked(GTK_BUTTON(lower_case ? d.lower : upper)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d.prefix), base_prefix); gtk_button_clicked(GTK_BUTTON(pad_zeros ? d.zero : space)); gtk_widget_show_all(d.dialog); result = gtk_dialog_run(GTK_DIALOG(d.dialog)); if (result == GTK_RESPONSE_ACCEPT) { if (can_insert_numbers()) { if (end_line - start_line < 1000) { /* quick version */ gtk_widget_hide(d.dialog); insert_numbers(NULL); } else { gboolean cancel = FALSE; gtk_widget_set_sensitive(GTK_WIDGET(grid), FALSE); gtk_widget_set_sensitive(button, FALSE); update_display(); g_signal_connect(d.dialog, "response", G_CALLBACK(on_insert_numbers_response), &cancel); insert_numbers(&cancel); } } else plugin_beep(); /* reloaded or something */ } gtk_widget_destroy(d.dialog); }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_radio_button_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gboolean state, indicator; gchar *group_name; GSList *group = NULL, *current_group; GbFindGroupData find_group_data; if (gb_toolbar_is_toolbar_button (widget)) { gb_toolbar_input_child_label (widget, data, Label); gb_toolbar_input_child_icon (widget, data, Icon); } else { gb_widget_input_child_label (widget, data, Label); } state = gb_widget_input_bool (data, State); if (data->apply) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), state); if (state) data->widget_data->flags |= GLADE_ACTIVE; else data->widget_data->flags &= ~GLADE_ACTIVE; } indicator = gb_widget_input_bool (data, Indicator); if (data->apply) gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (widget), indicator); /* Find any widgets in given group and set this widgets group. If group is NULL try to find radiobuttons with same parent and use their group. If these don't succeed, set group to NULL. */ group_name = gb_widget_input_combo (data, Group); if (data->apply) { if (group_name && group_name[0] == '\0') group_name = NULL; current_group = gtk_radio_button_group (GTK_RADIO_BUTTON (widget)); if (group_name == NULL) gtk_container_foreach (GTK_CONTAINER (widget->parent), (GtkCallback) find_parents_group, &group); else { find_group_data.group_name = group_name; find_group_data.group = NULL; find_group (gtk_widget_get_toplevel (widget), &find_group_data); group = find_group_data.group; } g_free (gtk_object_get_data (GTK_OBJECT (widget), Group)); gtk_object_set_data (GTK_OBJECT (widget), Group, g_strdup (group_name)); /* This crashes if we set the group to NULL, so we have to reset the group ourself. We only set the group if it has changed. */ if (group) { if (group != current_group) { if (current_group->data == widget) current_group = current_group->next; gtk_radio_button_set_group (GTK_RADIO_BUTTON (widget), group); gb_radio_button_update_radio_group (current_group); gb_radio_button_update_radio_group (gtk_radio_button_group (GTK_RADIO_BUTTON (widget))); } } else { if (g_slist_length (current_group) != 1) { current_group = gb_radio_button_reset_radio_group (widget); gb_radio_button_update_radio_group (current_group); gb_radio_button_update_radio_group (gtk_radio_button_group (GTK_RADIO_BUTTON (widget))); } } } }