GtkWidget *create_input_window() { GtkWidget *window; GtkWidget *vbox; GtkWidget *hbox1, *hbox2, *hbox3; GtkWidget *label, *label2; GtkWidget *scrollwin; GtkWidget *text_view; GtkWidget *button, *button2; GtkWidget *progress_bar; /* window */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "Typer"); gtk_window_set_default_size(GTK_WINDOW(window), 800, 400); // gtk_window_set_deletable(GTK_WINDOW(window), FALSE); gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_container_border_width(GTK_CONTAINER(window), 10); g_signal_connect( GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC(gtk_widget_hide_on_delete), NULL); vbox = gtk_vbox_new(FALSE, 10); hbox1 = gtk_hbox_new(FALSE, 10); label = gtk_label_new("Text:"); gtk_box_pack_start(GTK_BOX(hbox1), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox1, FALSE, FALSE, 0); /* center text view */ text_view = gtk_text_view_new(); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text_view), GTK_WRAP_CHAR); input_text_buffer_origin = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view)); g_object_ref(input_text_buffer_origin); scrollwin = gtk_scrolled_window_new( NULL, gtk_text_view_get_vadjustment(GTK_TEXT_VIEW(text_view))); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(scrollwin), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(scrollwin), text_view); gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); /* progress bar */ label2 = gtk_label_new("Progress: "); progress_bar = gtk_progress_bar_new(); hbox3 = gtk_hbox_new(FALSE, 10); gtk_box_pack_start(GTK_BOX(hbox3), label2, FALSE, FALSE, 0); gtk_box_pack_start( GTK_BOX(hbox3), progress_bar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, FALSE, 0); /* period setting */ GtkWidget *hbox5 = gtk_hbox_new(FALSE, 10); gtk_box_pack_start( GTK_BOX(hbox5), gtk_label_new("Period: "), FALSE, FALSE, 0); btn_prev_period = gtk_button_new_with_label("<<"); g_signal_connect( GTK_OBJECT(btn_prev_period), "clicked", GTK_SIGNAL_FUNC(prev_period), NULL); gtk_box_pack_start(GTK_BOX(hbox5), btn_prev_period, FALSE, FALSE, 0); lbl_period = gtk_label_new(NULL); load_current_period(); gtk_box_pack_start(GTK_BOX(hbox5), lbl_period, FALSE, FALSE, 0); btn_next_period = gtk_button_new_with_label(">>"); g_signal_connect( GTK_OBJECT(btn_next_period), "clicked", GTK_SIGNAL_FUNC(next_period), NULL); gtk_box_pack_start(GTK_BOX(hbox5), btn_next_period, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox5, FALSE, FALSE, 0); /* buttons on the BOTTOM */ hbox2 = gtk_hbox_new(FALSE, 10); button = gtk_button_new_with_label("Send"); gtk_widget_set_size_request(button, 100, 40); g_signal_connect( GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(send_button_clicked), NULL); gtk_box_pack_end(GTK_BOX(hbox2), button, FALSE, FALSE, 0); button2 = gtk_button_new_with_label("STOP!"); gtk_widget_set_size_request(button2, 100, 40); g_signal_connect( GTK_OBJECT(button2), "clicked", GTK_SIGNAL_FUNC(stop_button_clicked), NULL); gtk_box_pack_end(GTK_BOX(hbox2), button2, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); input_send_button = button; input_stop_button = button2; input_text_view = text_view; input_progress_bar = progress_bar; gtk_widget_show_all(window); gtk_widget_hide(button2); return window; }
int main (int argc, char **argv) { GtkWidget *window, *view, *scrolled, *box, *search; EmpathyIndividualManager *mgr; GError *error = NULL; GOptionContext *context; EmpathyRosterModel *model; gtk_init (&argc, &argv); empathy_gtk_init (); context = g_option_context_new ("- test tree model performance"); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_print ("option parsing failed: %s\n", error->message); return 1; } window = gtk_window_new (GTK_WINDOW_TOPLEVEL); empathy_set_css_provider (window); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); mgr = empathy_individual_manager_dup_singleton (); model = EMPATHY_ROSTER_MODEL (empathy_roster_model_manager_new (mgr)); view = empathy_roster_view_new (model); g_object_unref (model); g_signal_connect (view, "individual-activated", G_CALLBACK (individual_activated_cb), NULL); g_signal_connect (view, "popup-individual-menu", G_CALLBACK (popup_individual_menu_cb), NULL); g_signal_connect (view, "notify::empty", G_CALLBACK (empty_cb), NULL); g_signal_connect (view, "individual-tooltip", G_CALLBACK (individual_tooltip_cb), NULL); gtk_widget_set_has_tooltip (view, TRUE); empathy_roster_view_show_offline (EMPATHY_ROSTER_VIEW (view), show_offline); empathy_roster_view_show_groups (EMPATHY_ROSTER_VIEW (view), show_groups); g_object_unref (mgr); search = tpaw_live_search_new (view); empathy_roster_view_set_live_search (EMPATHY_ROSTER_VIEW (view), TPAW_LIVE_SEARCH (search)); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (scrolled), view); gtk_box_pack_start (GTK_BOX (box), search, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (box), scrolled, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (window), box); gtk_window_set_default_size (GTK_WINDOW (window), 300, 600); gtk_widget_show_all (window); g_signal_connect_swapped (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_main (); return 0; }
GtkWidget * do_textview (GtkWidget *do_widget) { static GtkWidget *window = NULL; if (!window) { GtkWidget *vpaned; GtkWidget *view1; GtkWidget *view2; GtkWidget *sw; GtkTextBuffer *buffer; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_default_size (GTK_WINDOW (window), 450, 450); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); gtk_window_set_title (GTK_WINDOW (window), "Multiple Views"); gtk_container_set_border_width (GTK_CONTAINER (window), 0); vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_container_set_border_width (GTK_CONTAINER(vpaned), 5); gtk_container_add (GTK_CONTAINER (window), vpaned); /* For convenience, we just use the autocreated buffer from * the first text view; you could also create the buffer * by itself with gtk_text_buffer_new(), then later create * a view widget. */ view1 = gtk_text_view_new (); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view1)); view2 = gtk_text_view_new_with_buffer (buffer); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (vpaned), sw); gtk_container_add (GTK_CONTAINER (sw), view1); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add2 (GTK_PANED (vpaned), sw); gtk_container_add (GTK_CONTAINER (sw), view2); create_tags (buffer); insert_text (buffer); attach_widgets (GTK_TEXT_VIEW (view1)); attach_widgets (GTK_TEXT_VIEW (view2)); gtk_widget_show_all (vpaned); } if (!gtk_widget_get_visible (window)) { gtk_widget_show (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
/* * plugin management */ void gtkui_plugin_mgmt(void) { GtkWidget *scrolled, *vbox; GtkCellRenderer *renderer; GtkTreeViewColumn *column; DEBUG_MSG("gtk_plugin_mgmt"); /* if the object already exist, set the focus to it */ if (plugins_window) { if(GTK_IS_WINDOW (plugins_window)) gtk_window_present(GTK_WINDOW (plugins_window)); else gtkui_page_present(plugins_window); return; } plugins_window = gtkui_page_new("Plugins", >kui_plug_destroy, >kui_plugins_detach); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER (plugins_window), vbox); gtk_widget_show(vbox); /* list */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); treeview = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER (scrolled), treeview); gtk_widget_show(treeview); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (treeview), "row_activated", G_CALLBACK (gtkui_select_plugin), NULL); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (" ", renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", 1, NULL); gtk_tree_view_column_set_sort_column_id (column, 1); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Version", renderer, "text", 2, NULL); gtk_tree_view_column_set_sort_column_id (column, 2); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Info", renderer, "text", 3, NULL); gtk_tree_view_column_set_sort_column_id (column, 3); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); /* create the array for the list widget */ /* or refreshes it if it exists */ gtkui_create_plug_array(); gtk_tree_view_set_model(GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (ls_plugins)); gtk_widget_show(plugins_window); }
int main (int argc, char **argv) { struct { char *label; void (*func) (); } buttons[] = { { "app window", create_app_helper }, { "color picker", create_color_picker }, { "date edit", create_date_edit }, { "entry", create_entry }, { "file entry", create_file_entry }, { "pixmap entry", create_pixmap_entry }, { "icon entry", create_icon_entry }, { "font picker", create_font_picker }, { "href", create_href }, { "icon list", create_icon_list }, { "about box", create_about_box } }; int nbuttons = sizeof (buttons) / sizeof (buttons[0]); GnomeProgram *program; TestGnomeApp *app; GtkWidget *box1; GtkWidget *box2; GtkWidget *button; GtkWidget *scrolled_window; int i; program = gnome_program_init ("testGNOME", VERSION, LIBGNOMEUI_MODULE, argc, argv, GNOME_PARAM_GOPTION_CONTEXT, g_option_context_new ("test-gnome"), NULL); app = create_newwin (FALSE, "testGNOME", "testGNOME"); gtk_window_set_default_size (GTK_WINDOW (app->app), 200, 300); box1 = gtk_vbox_new (FALSE, 0); bonobo_window_set_contents (BONOBO_WINDOW (app->app), box1); gtk_widget_show (box1); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 10); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); GTK_WIDGET_UNSET_FLAGS (GTK_SCROLLED_WINDOW (scrolled_window)->vscrollbar, GTK_CAN_FOCUS); gtk_box_pack_start (GTK_BOX (box1), scrolled_window, TRUE, TRUE, 0); gtk_widget_show (scrolled_window); box2 = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (box2), 10); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), box2); gtk_container_set_focus_vadjustment (GTK_CONTAINER (box2), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW(scrolled_window))); gtk_widget_show (box2); for (i = 0; i < nbuttons; i++) { button = gtk_button_new_with_label (buttons[i].label); if (buttons[i].func) g_signal_connect (button, "clicked", G_CALLBACK(buttons[i].func), NULL); else gtk_widget_set_sensitive (button, FALSE); gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0); gtk_widget_show (button); } gtk_widget_show (app->app); gtk_main (); g_object_unref (program); return 0; }
GtkWidget * do_listbox (GtkWidget *do_widget) { GtkWidget *scrolled, *listbox, *vbox, *label; GtkMessage *message; GtkMessageRow *row; GBytes *data; char **lines; int i; if (!window) { avatar_pixbuf_other = gdk_pixbuf_new_from_resource_at_scale ("/listbox/apple-red.png", 32, 32, FALSE, NULL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "List Box"); gtk_window_set_default_size (GTK_WINDOW (window), 400, 600); /* NULL window variable when window is closed */ g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new ("Messages from Gtk+ and friends"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0); listbox = gtk_list_box_new (); gtk_container_add (GTK_CONTAINER (scrolled), listbox); gtk_list_box_set_sort_func (GTK_LIST_BOX (listbox), (GtkListBoxSortFunc)gtk_message_row_sort, listbox, NULL); gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (listbox), FALSE); g_signal_connect (listbox, "row-activated", G_CALLBACK (row_activated), NULL); gtk_widget_show_all (vbox); data = g_resources_lookup_data ("/listbox/messages.txt", 0, NULL); lines = g_strsplit (g_bytes_get_data (data, NULL), "\n", 0); for (i = 0; lines[i] != NULL && *lines[i]; i++) { message = gtk_message_new (lines[i]); row = gtk_message_row_new (message); gtk_widget_show (GTK_WIDGET (row)); gtk_container_add (GTK_CONTAINER (listbox), GTK_WIDGET (row)); } g_strfreev (lines); } if (!gtk_widget_get_visible (window)) gtk_widget_show (window); else gtk_widget_destroy (window); return window; }
static void prefs_custom_header_create(void) { GtkWidget *window; GtkWidget *vbox; GtkWidget *ok_btn; GtkWidget *cancel_btn; GtkWidget *confirm_area; GtkWidget *vbox1; GtkWidget *table1; GtkWidget *hdr_label; GtkWidget *hdr_combo; GtkWidget *val_label; GtkWidget *val_entry; GtkWidget *val_btn; GtkWidget *reg_hbox; GtkWidget *btn_hbox; GtkWidget *arrow; GtkWidget *add_btn; GtkWidget *del_btn; GtkWidget *preview; GtkWidget *ch_hbox; GtkWidget *ch_scrolledwin; GtkWidget *list_view; GtkWidget *btn_vbox; GtkWidget *up_btn; GtkWidget *down_btn; debug_print("Creating custom header setting window...\n"); window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_customheader"); gtk_container_set_border_width (GTK_CONTAINER (window), 8); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW (window), TRUE); vbox = gtk_vbox_new (FALSE, 6); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (window), vbox); gtkut_stock_button_set_create(&confirm_area, &cancel_btn, GTK_STOCK_CANCEL, &ok_btn, GTK_STOCK_OK, NULL, NULL); gtk_widget_show (confirm_area); gtk_box_pack_end (GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default (ok_btn); gtk_window_set_title (GTK_WINDOW(window), _("Custom header configuration")); MANAGE_WINDOW_SIGNALS_CONNECT (window); g_signal_connect (G_OBJECT(window), "delete_event", G_CALLBACK(prefs_custom_header_deleted), NULL); g_signal_connect (G_OBJECT(window), "key_press_event", G_CALLBACK(prefs_custom_header_key_pressed), NULL); g_signal_connect (G_OBJECT(ok_btn), "clicked", G_CALLBACK(prefs_custom_header_ok), NULL); g_signal_connect (G_OBJECT(cancel_btn), "clicked", G_CALLBACK(prefs_custom_header_cancel), NULL); vbox1 = gtk_vbox_new (FALSE, VSPACING); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (vbox), vbox1, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 2); table1 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (table1), 8); gtk_table_set_col_spacings (GTK_TABLE (table1), 8); hdr_label = gtk_label_new (_("Header")); gtk_widget_show (hdr_label); gtk_table_attach (GTK_TABLE (table1), hdr_label, 0, 1, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (hdr_label), 0, 0.5); hdr_combo = combobox_text_new(TRUE, "User-Agent", "Face", "X-Face", "X-Operating-System", NULL); gtk_table_attach (GTK_TABLE (table1), hdr_combo, 0, 1, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); gtk_widget_set_size_request (hdr_combo, 150, -1); val_label = gtk_label_new (_("Value")); gtk_widget_show (val_label); gtk_table_attach (GTK_TABLE (table1), val_label, 1, 2, 0, 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); gtk_misc_set_alignment (GTK_MISC (val_label), 0, 0.5); val_entry = gtk_entry_new (); gtk_widget_show (val_entry); gtk_table_attach (GTK_TABLE (table1), val_entry, 1, 2, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); gtk_widget_set_size_request (val_entry, 200, -1); val_btn = gtkut_get_browse_file_btn(_("Bro_wse")); gtk_widget_show (val_btn); gtk_table_attach (GTK_TABLE (table1), val_btn, 2, 3, 1, 2, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0); g_signal_connect (G_OBJECT (val_btn), "clicked", G_CALLBACK (prefs_custom_header_val_from_file_cb), NULL); /* add / delete */ reg_hbox = gtk_hbox_new (FALSE, 4); gtk_widget_show (reg_hbox); gtk_box_pack_start (GTK_BOX (vbox1), reg_hbox, FALSE, FALSE, 0); arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_OUT); gtk_widget_show (arrow); gtk_box_pack_start (GTK_BOX (reg_hbox), arrow, FALSE, FALSE, 0); gtk_widget_set_size_request (arrow, -1, 16); btn_hbox = gtk_hbox_new (TRUE, 4); gtk_widget_show (btn_hbox); gtk_box_pack_start (GTK_BOX (reg_hbox), btn_hbox, FALSE, FALSE, 0); add_btn = gtk_button_new_from_stock (GTK_STOCK_ADD); gtk_widget_show (add_btn); gtk_box_pack_start (GTK_BOX (btn_hbox), add_btn, FALSE, TRUE, 0); g_signal_connect (G_OBJECT (add_btn), "clicked", G_CALLBACK (prefs_custom_header_add_cb), NULL); del_btn = gtk_button_new_from_stock (GTK_STOCK_DELETE); gtk_widget_show (del_btn); gtk_box_pack_start (GTK_BOX (btn_hbox), del_btn, FALSE, TRUE, 0); g_signal_connect (G_OBJECT (del_btn), "clicked", G_CALLBACK (prefs_custom_header_delete_cb), NULL); ch_hbox = gtk_hbox_new (FALSE, 8); gtk_widget_show (ch_hbox); gtk_box_pack_start (GTK_BOX (vbox1), ch_hbox, TRUE, TRUE, 0); ch_scrolledwin = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (ch_scrolledwin, -1, 200); gtk_widget_show (ch_scrolledwin); gtk_box_pack_start (GTK_BOX (ch_hbox), ch_scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (ch_scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); list_view = prefs_custom_header_list_view_create(); gtk_widget_show (list_view); gtk_container_add (GTK_CONTAINER (ch_scrolledwin), list_view); btn_vbox = gtk_vbox_new (FALSE, 8); gtk_widget_show (btn_vbox); gtk_box_pack_start (GTK_BOX (ch_hbox), btn_vbox, FALSE, FALSE, 0); up_btn = gtk_button_new_from_stock (GTK_STOCK_GO_UP); gtk_widget_show (up_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), up_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (up_btn), "clicked", G_CALLBACK (prefs_custom_header_up), NULL); down_btn = gtk_button_new_from_stock (GTK_STOCK_GO_DOWN); gtk_widget_show (down_btn); gtk_box_pack_start (GTK_BOX (btn_vbox), down_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (down_btn), "clicked", G_CALLBACK (prefs_custom_header_down), NULL); preview = gtk_image_new (); gtk_widget_show (preview); gtk_box_pack_start (GTK_BOX (btn_vbox), preview, FALSE, FALSE, 0); gtk_widget_show_all(window); customhdr.window = window; customhdr.ok_btn = ok_btn; customhdr.cancel_btn = cancel_btn; customhdr.preview = preview; customhdr.hdr_combo = hdr_combo; customhdr.hdr_entry = gtk_bin_get_child(GTK_BIN((hdr_combo))); customhdr.val_entry = val_entry; customhdr.list_view = list_view; }
void dialog_search (WBCGtk *wbcg) { GtkBuilder *gui; GtkDialog *dialog; DialogState *dd; GtkTable *table; char *f; g_return_if_fail (wbcg != NULL); #ifdef USE_GURU /* Only one guru per workbook. */ if (wbc_gtk_get_guru (wbcg)) return; #endif f = g_build_filename (gnm_sys_data_dir (), "ui", "search.ui", NULL); gui = go_gtk_builder_new (f, NULL, GO_CMD_CONTEXT (wbcg)); g_free (f); if (gui == NULL) return; dialog = GTK_DIALOG (gtk_builder_get_object (gui, "search_dialog")); dd = g_new (DialogState, 1); dd->wbcg = wbcg; dd->gui = gui; dd->dialog = dialog; dd->matches = g_ptr_array_new (); dd->prev_button = go_gtk_builder_get_widget (gui, "prev_button"); dd->next_button = go_gtk_builder_get_widget (gui, "next_button"); dd->notebook = GTK_NOTEBOOK (gtk_builder_get_object (gui, "notebook")); dd->notebook_matches_page = gtk_notebook_page_num (dd->notebook, go_gtk_builder_get_widget (gui, "matches_tab")); dd->rangetext = gnm_expr_entry_new (wbcg, TRUE); gnm_expr_entry_set_flags (dd->rangetext, 0, GNM_EE_MASK); table = GTK_TABLE (gtk_builder_get_object (gui, "page1-table")); gtk_table_attach (table, GTK_WIDGET (dd->rangetext), 1, 2, 6, 7, GTK_EXPAND | GTK_FILL, 0, 0, 0); { char *selection_text = selection_to_string ( wb_control_cur_sheet_view (WORKBOOK_CONTROL (wbcg)), TRUE); gnm_expr_entry_load_from_text (dd->rangetext, selection_text); g_free (selection_text); } dd->gentry = GTK_ENTRY (gtk_entry_new ()); gtk_table_attach (table, GTK_WIDGET (dd->gentry), 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_widget_grab_focus (GTK_WIDGET (dd->gentry)); gnumeric_editable_enters (GTK_WINDOW (dialog), GTK_WIDGET (dd->gentry)); dd->matches_table = make_matches_table (dd); { GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (dd->matches_table)); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (gui, "matches_vbox")), scrolled_window, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); } /* Set sensitivity of buttons. */ cursor_change (dd->matches_table, dd); g_signal_connect (G_OBJECT (dd->matches_table), "cursor_changed", G_CALLBACK (cursor_change), dd); g_signal_connect (G_OBJECT (dd->matches_table), "select_cursor_row", G_CALLBACK (cb_next), dd); go_gtk_builder_signal_connect (gui, "search_button", "clicked", G_CALLBACK (search_clicked), dd); g_signal_connect (G_OBJECT (dd->prev_button), "clicked", G_CALLBACK (prev_clicked), dd); g_signal_connect (G_OBJECT (dd->next_button), "clicked", G_CALLBACK (next_clicked), dd); go_gtk_builder_signal_connect_swapped (gui, "close_button", "clicked", G_CALLBACK (gtk_widget_destroy), dd->dialog); g_signal_connect (G_OBJECT (gnm_expr_entry_get_entry (dd->rangetext)), "focus-in-event", G_CALLBACK (range_focused), dd); go_gtk_builder_signal_connect (gui, "scope_range", "toggled", G_CALLBACK (cb_focus_on_entry), dd->rangetext); #ifdef USE_GURU wbc_gtk_attach_guru_with_unfocused_rs (wbcg, GTK_WIDGET (dialog), dd->rangetext); #endif g_object_set_data_full (G_OBJECT (dialog), "state", dd, (GDestroyNotify) free_state); gnm_dialog_setup_destroy_handlers (dialog, wbcg, GNM_DIALOG_DESTROY_SHEET_REMOVED); gnumeric_init_help_button ( go_gtk_builder_get_widget (gui, "help_button"), GNUMERIC_HELP_LINK_SEARCH); gnumeric_restore_window_geometry (GTK_WINDOW (dialog), SEARCH_KEY); go_gtk_nonmodal_dialog (wbcg_toplevel (wbcg), GTK_WINDOW (dialog)); gtk_widget_show_all (GTK_WIDGET (dialog)); }
static GtkWidget *create_window(void) { GtkWidget *startwin; GtkWidget *hlayout; GtkWidget *banner; GtkWidget *vlayout; GtkWidget *tabs; GtkWidget *configvlayout; GtkWidget *configlayout; GtkWidget *fullscreencheck; GtkWidget *vmode3dlabel; GtkWidget *inputdevlabel; GtkWidget *inputmousecheck; GtkWidget *inputjoycheck; GtkWidget *vmode3dcombo; GtkWidget *alwaysshowcheck; GtkWidget *configtab; GtkWidget *gamevlayout; GtkWidget *gamelabel; GtkWidget *gamescroll; GtkWidget *gamelist; GtkWidget *gametab; GtkWidget *messagesscroll; GtkWidget *messagestext; GtkWidget *messagestab; GtkWidget *buttons; GtkWidget *cancelbutton; GtkWidget *cancelbuttonalign; GtkWidget *cancelbuttonlayout; GtkWidget *cancelbuttonicon; GtkWidget *cancelbuttonlabel; GtkWidget *startbutton; GtkWidget *startbuttonalign; GtkWidget *startbuttonlayout; GtkWidget *startbuttonicon; GtkWidget *startbuttonlabel; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); // Basic window startwin = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (startwin), apptitle); // NOTE: use global app title gtk_window_set_position (GTK_WINDOW (startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable (GTK_WINDOW (startwin), FALSE); gtk_window_set_type_hint (GTK_WINDOW (startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls hlayout = gtk_hbox_new (FALSE, 0); gtk_widget_show (hlayout); gtk_container_add (GTK_CONTAINER (startwin), hlayout); // Banner { GdkPixbuf *pixbuf = load_banner(); banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_widget_show (banner); gtk_box_pack_start (GTK_BOX (hlayout), banner, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons vlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (vlayout); gtk_box_pack_start (GTK_BOX (hlayout), vlayout, TRUE, TRUE, 0); // Tab control tabs = gtk_notebook_new (); gtk_widget_show (tabs); gtk_box_pack_start (GTK_BOX (vlayout), tabs, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (tabs), 4); // Vertical layout of config page main body configvlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (configvlayout); gtk_container_add (GTK_CONTAINER (tabs), configvlayout); // Fixed-position layout of config page controls configlayout = gtk_fixed_new (); gtk_widget_show (configlayout); gtk_box_pack_start (GTK_BOX (configvlayout), configlayout, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (configlayout), 6); // Fullscreen checkbox fullscreencheck = gtk_check_button_new_with_mnemonic ("_Fullscreen"); gtk_widget_show (fullscreencheck); gtk_fixed_put (GTK_FIXED (configlayout), fullscreencheck, 248, 0); gtk_widget_set_size_request (fullscreencheck, 85, 29); gtk_widget_add_accelerator (fullscreencheck, "grab_focus", accel_group, GDK_F, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // 3D video mode label vmode3dlabel = gtk_label_new_with_mnemonic ("_Video mode:"); gtk_widget_show (vmode3dlabel); gtk_fixed_put (GTK_FIXED (configlayout), vmode3dlabel, 0, 0); gtk_widget_set_size_request (vmode3dlabel, 88, 29); gtk_misc_set_alignment (GTK_MISC (vmode3dlabel), 0, 0.5); inputdevlabel = gtk_label_new ("Input devices:"); gtk_widget_show (inputdevlabel); gtk_fixed_put (GTK_FIXED (configlayout), inputdevlabel, 0, 120); gtk_widget_set_size_request (inputdevlabel, 88, 20); gtk_misc_set_alignment (GTK_MISC (inputdevlabel), 0, 0.5); inputmousecheck = gtk_check_button_new_with_mnemonic ("Mo_use"); gtk_widget_show (inputmousecheck); gtk_fixed_put (GTK_FIXED (configlayout), inputmousecheck, 88, 120); gtk_widget_set_size_request (inputmousecheck, 80, 20); gtk_widget_add_accelerator (inputmousecheck, "grab_focus", accel_group, GDK_U, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); inputjoycheck = gtk_check_button_new_with_mnemonic ("_Joystick"); gtk_widget_show (inputjoycheck); gtk_fixed_put (GTK_FIXED (configlayout), inputjoycheck, 168, 120); gtk_widget_set_size_request (inputjoycheck, 80, 20); gtk_widget_add_accelerator (inputjoycheck, "grab_focus", accel_group, GDK_J, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; vmode3dcombo = gtk_combo_box_new_with_model (GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(vmode3dcombo), cell, "text", 0, NULL); } gtk_widget_show (vmode3dcombo); gtk_fixed_put (GTK_FIXED (configlayout), vmode3dcombo, 88, 0); gtk_widget_set_size_request (vmode3dcombo, 150, 29); gtk_widget_add_accelerator (vmode3dcombo, "grab_focus", accel_group, GDK_V, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Always show config checkbox alwaysshowcheck = gtk_check_button_new_with_mnemonic ("_Always show configuration on start"); gtk_widget_show (alwaysshowcheck); gtk_box_pack_start (GTK_BOX (configvlayout), alwaysshowcheck, FALSE, FALSE, 0); gtk_widget_add_accelerator (alwaysshowcheck, "grab_focus", accel_group, GDK_A, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); // Configuration tab configtab = gtk_label_new ("Configuration"); gtk_widget_show (configtab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 0), configtab); // Game data layout gamevlayout = gtk_vbox_new (FALSE, 0); gtk_widget_show (gamevlayout); gtk_container_add (GTK_CONTAINER (tabs), gamevlayout); gtk_container_set_border_width (GTK_CONTAINER (gamevlayout), 4); // Game data field label gamelabel = gtk_label_new_with_mnemonic ("_Game or addon:"); gtk_widget_show (gamelabel); gtk_box_pack_start (GTK_BOX (gamevlayout), gamelabel, FALSE, FALSE, 0); gtk_misc_set_alignment (GTK_MISC (gamelabel), 0, 0.5); // Game data scrollable area gamescroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (gamescroll); gtk_box_pack_start (GTK_BOX (gamevlayout), gamescroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (gamescroll), GTK_SHADOW_IN); // Game data list { GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); GtkCellRenderer *cell; GtkTreeViewColumn *col; gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING); gamelist = gtk_tree_view_new_with_model (GTK_TREE_MODEL(list)); g_object_unref(G_OBJECT(list)); cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL); gtk_tree_view_column_set_expand(col, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(gamelist), col); col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL); gtk_tree_view_column_set_min_width(col, 64); gtk_tree_view_append_column(GTK_TREE_VIEW(gamelist), col); } gtk_widget_show (gamelist); gtk_container_add (GTK_CONTAINER (gamescroll), gamelist); gtk_widget_add_accelerator (gamelist, "grab_focus", accel_group, GDK_G, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gamelist), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (gamelist), FALSE); // Game tab gametab = gtk_label_new ("Game"); gtk_widget_show (gametab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 1), gametab); // Messages scrollable area messagesscroll = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (messagesscroll); gtk_container_add (GTK_CONTAINER (tabs), messagesscroll); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area messagestext = gtk_text_view_new (); gtk_widget_show (messagestext); gtk_container_add (GTK_CONTAINER (messagesscroll), messagestext); gtk_text_view_set_editable (GTK_TEXT_VIEW (messagestext), FALSE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (messagestext), FALSE); gtk_text_view_set_left_margin (GTK_TEXT_VIEW (messagestext), 2); gtk_text_view_set_right_margin (GTK_TEXT_VIEW (messagestext), 2); // Messages tab messagestab = gtk_label_new ("Messages"); gtk_widget_show (messagestab); gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 2), messagestab); // Dialogue box buttons layout buttons = gtk_hbutton_box_new (); gtk_widget_show (buttons); gtk_box_pack_start (GTK_BOX (vlayout), buttons, FALSE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (buttons), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (buttons), GTK_BUTTONBOX_END); // Cancel button cancelbutton = gtk_button_new (); gtk_widget_show (cancelbutton); gtk_container_add (GTK_CONTAINER (buttons), cancelbutton); GTK_WIDGET_SET_FLAGS (cancelbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (cancelbutton, "grab_focus", accel_group, GDK_C, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (cancelbutton, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE); cancelbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (cancelbuttonalign); gtk_container_add (GTK_CONTAINER (cancelbutton), cancelbuttonalign); cancelbuttonlayout = gtk_hbox_new (FALSE, 2); gtk_widget_show (cancelbuttonlayout); gtk_container_add (GTK_CONTAINER (cancelbuttonalign), cancelbuttonlayout); cancelbuttonicon = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_widget_show (cancelbuttonicon); gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonicon, FALSE, FALSE, 0); cancelbuttonlabel = gtk_label_new_with_mnemonic ("_Cancel"); gtk_widget_show (cancelbuttonlabel); gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonlabel, FALSE, FALSE, 0); // Start button startbutton = gtk_button_new (); gtk_widget_show (startbutton); gtk_container_add (GTK_CONTAINER (buttons), startbutton); GTK_WIDGET_SET_FLAGS (startbutton, GTK_CAN_DEFAULT); gtk_widget_add_accelerator (startbutton, "grab_focus", accel_group, GDK_S, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (startbutton, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE); startbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (startbuttonalign); gtk_container_add (GTK_CONTAINER (startbutton), startbuttonalign); startbuttonlayout = gtk_hbox_new (FALSE, 2); gtk_widget_show (startbuttonlayout); gtk_container_add (GTK_CONTAINER (startbuttonalign), startbuttonlayout); startbuttonicon = gtk_image_new_from_stock ("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_widget_show (startbuttonicon); gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonicon, FALSE, FALSE, 0); startbuttonlabel = gtk_label_new_with_mnemonic ("_Start"); gtk_widget_show (startbuttonlabel); gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect ((gpointer) startwin, "delete_event", G_CALLBACK (on_startwin_delete_event), NULL); g_signal_connect ((gpointer) fullscreencheck, "toggled", G_CALLBACK (on_fullscreencheck_toggled), NULL); g_signal_connect ((gpointer) inputmousecheck, "toggled", G_CALLBACK (on_inputmousecheck_toggled), NULL); g_signal_connect ((gpointer) inputjoycheck, "toggled", G_CALLBACK (on_inputjoycheck_toggled), NULL); g_signal_connect ((gpointer) vmode3dcombo, "changed", G_CALLBACK (on_vmode3dcombo_changed), NULL); g_signal_connect ((gpointer) alwaysshowcheck, "toggled", G_CALLBACK (on_alwaysshowcheck_toggled), NULL); g_signal_connect ((gpointer) cancelbutton, "clicked", G_CALLBACK (on_cancelbutton_clicked), NULL); g_signal_connect ((gpointer) startbutton, "clicked", G_CALLBACK (on_startbutton_clicked), NULL); { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(gamelist)); gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE); g_signal_connect ((gpointer) sel, "changed", G_CALLBACK (on_gamelist_selection_changed), NULL); } // Associate labels with their controls gtk_label_set_mnemonic_widget (GTK_LABEL (vmode3dlabel), vmode3dcombo); gtk_label_set_mnemonic_widget (GTK_LABEL (gamelabel), gamelist); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (startwin, startwin, "startwin"); GLADE_HOOKUP_OBJECT (startwin, hlayout, "hlayout"); GLADE_HOOKUP_OBJECT (startwin, banner, "banner"); GLADE_HOOKUP_OBJECT (startwin, vlayout, "vlayout"); GLADE_HOOKUP_OBJECT (startwin, tabs, "tabs"); GLADE_HOOKUP_OBJECT (startwin, configvlayout, "configvlayout"); GLADE_HOOKUP_OBJECT (startwin, configlayout, "configlayout"); GLADE_HOOKUP_OBJECT (startwin, fullscreencheck, "fullscreencheck"); GLADE_HOOKUP_OBJECT (startwin, vmode3dlabel, "vmode3dlabel"); GLADE_HOOKUP_OBJECT (startwin, inputdevlabel, "inputdevlabel"); GLADE_HOOKUP_OBJECT (startwin, inputmousecheck, "inputmousecheck"); GLADE_HOOKUP_OBJECT (startwin, inputjoycheck, "inputjoycheck"); GLADE_HOOKUP_OBJECT (startwin, vmode3dcombo, "vmode3dcombo"); GLADE_HOOKUP_OBJECT (startwin, alwaysshowcheck, "alwaysshowcheck"); GLADE_HOOKUP_OBJECT (startwin, configtab, "configtab"); GLADE_HOOKUP_OBJECT (startwin, gamevlayout, "gamevlayout"); GLADE_HOOKUP_OBJECT (startwin, gamelabel, "gamelabel"); GLADE_HOOKUP_OBJECT (startwin, gamescroll, "gamescroll"); GLADE_HOOKUP_OBJECT (startwin, gamelist, "gamelist"); GLADE_HOOKUP_OBJECT (startwin, gametab, "gametab"); GLADE_HOOKUP_OBJECT (startwin, messagesscroll, "messagesscroll"); GLADE_HOOKUP_OBJECT (startwin, messagestext, "messagestext"); GLADE_HOOKUP_OBJECT (startwin, messagestab, "messagestab"); GLADE_HOOKUP_OBJECT (startwin, buttons, "buttons"); GLADE_HOOKUP_OBJECT (startwin, cancelbutton, "cancelbutton"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonalign, "cancelbuttonalign"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlayout, "cancelbuttonlayout"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonicon, "cancelbuttonicon"); GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlabel, "cancelbuttonlabel"); GLADE_HOOKUP_OBJECT (startwin, startbutton, "startbutton"); GLADE_HOOKUP_OBJECT (startwin, startbuttonalign, "startbuttonalign"); GLADE_HOOKUP_OBJECT (startwin, startbuttonlayout, "startbuttonlayout"); GLADE_HOOKUP_OBJECT (startwin, startbuttonicon, "startbuttonicon"); GLADE_HOOKUP_OBJECT (startwin, startbuttonlabel, "startbuttonlabel"); gtk_window_add_accel_group (GTK_WINDOW (startwin), accel_group); return startwin; }
//================================================================ MemObj GUI_msgwin__ (MemObj *o_par, char *opts) { //================================================================ /// \code /// create textwindow /// o_par parentBox /// opts options; (HorSiz,VertSiz) /// HorSiz,VertSiz: size in characters; default is automatic size. /// 'e' = expand widget; default is fixed size. /// negative values: size in pixels. /// Examples: "" or "10" or "10e,e" /// "10e,e" horiz. size 10 chars, hor. and vert. expandable. /// \endcode // Create ein Editfenster int pTyp; void *w_par; Obj_Unknown *go; GtkWidget *sw; GtkTextBuffer *TxBuf; GtkWidget *TxView; printf("GUI_msgwin__ |%s|\n",opts); // get gtk-widget for parentBox from MemObj w_par = GUI_obj_parent__ (&pTyp, o_par); if(!w_par) return (UME_obj_invalid_set (-3)); // get address & memspc GUI_obj_spc ((void**)&go, sizeof(Obj_Unknown)); if(!go) return (UME_obj_invalid_set (-1)); //---------------------------------------------------------------- TxView = gtk_text_view_new (); TxBuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (TxView)); gtk_text_buffer_set_text (TxBuf, "", -1); //---------------------------------------------------------------- sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_container_add (GTK_CONTAINER (sw), TxView); gtk_widget_show (TxView); gtk_text_view_set_editable ((GtkTextView *)TxView, FALSE); gtk_text_view_set_cursor_visible ((GtkTextView *)TxView, FALSE); /* // hsiz,vsiz size of window; >0=size in characters, <0=size in pixels // size if(hsiz != 0) { if(hsiz < 0) { ih = -hsiz; } else { ih = UI_fontsizX * hsiz; } } if(vsiz != 0) { if(vsiz < 0) { iv = -vsiz; } else { iv = UI_fontsizY * (vsiz + 1); } } if((ih) || (iv)) { // printf(" winSiz %d %d\n",ih,iv); GUI_siz_set (sw, ih, iv); } */ GUI_w_pack2 (pTyp, w_par, sw, opts); // gtk_container_add (GTK_CONTAINER (w_par), sw); // gtk_widget_show (sw); go->gio_typ = TYP_GUI_MsgWin; go->widget = TxView; // printf("exit GUI_msgwin__ \n"); return (((Obj_Unknown*)go)->mem_obj); }
static void anjuta_save_prompt_init(AnjutaSavePrompt *obj) { GtkWidget *vbox; GtkWidget *treeview; GtkListStore *store; GtkTreeViewColumn *col; GtkCellRenderer *renderer; GtkWidget *label; GtkWidget *scrolledwindow; obj->priv = g_new0(AnjutaSavePromptPrivate, 1); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (obj), "Uninitialized"); gtk_window_set_resizable (GTK_WINDOW (obj), TRUE); gtk_window_set_default_size (GTK_WINDOW (obj), 400, 300); vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (obj))), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); label = gtk_label_new (_("Select the items to save:")); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_misc_set_padding (GTK_MISC (label), 10, -1); gtk_misc_set_alignment (GTK_MISC (label), 0, -1); gtk_widget_show (label); store = gtk_list_store_new (N_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER); 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_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), scrolledwindow, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow), 10); gtk_widget_show (scrolledwindow); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview); gtk_widget_show (treeview); label = gtk_label_new (_("If you do not save, all your changes will be lost.")); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); gtk_misc_set_padding (GTK_MISC (label), 10, -1); gtk_misc_set_alignment (GTK_MISC (label), 0, -1); gtk_widget_show (label); renderer = gtk_cell_renderer_toggle_new (); col = gtk_tree_view_column_new_with_attributes (_("Save"), renderer, "active", COL_SAVE_ENABLE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col); renderer = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Item"), renderer, "markup", COL_LABEL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col); gtk_dialog_add_buttons (GTK_DIALOG (obj), _("_Discard changes"), ANJUTA_SAVE_PROMPT_RESPONSE_DISCARD, GTK_STOCK_CANCEL, ANJUTA_SAVE_PROMPT_RESPONSE_CANCEL, GTK_STOCK_SAVE, ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE, NULL); /* TRUE is the default and Gtk warns that this has no effect */ /* gtk_dialog_set_has_separator (GTK_DIALOG (obj), TRUE); */ gtk_dialog_set_default_response (GTK_DIALOG (obj), ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE); g_signal_connect (obj, "response", G_CALLBACK (on_dialog_response), obj); obj->priv->treeview = treeview; }
static void do_test_webkit_web_view_adjustments(gboolean with_page_cache) { char* effective_uri = g_strconcat(base_uri, "bigdiv.html", NULL); char* second_uri = g_strconcat(base_uri, "iframe.html", NULL); GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); GtkWidget* scrolled_window = gtk_scrolled_window_new(NULL, NULL); WebKitWebView* view = WEBKIT_WEB_VIEW(webkit_web_view_new()); GtkAdjustment* adjustment; double lower; double upper; if (with_page_cache) { WebKitWebSettings* settings = webkit_web_view_get_settings(view); g_object_set(settings, "enable-page-cache", TRUE, NULL); } gtk_window_set_default_size(GTK_WINDOW(window), 400, 200); gtk_container_add(GTK_CONTAINER(window), scrolled_window); gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(view)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); loop = g_main_loop_new(NULL, TRUE); g_object_connect(G_OBJECT(view), "signal::notify::load-status", idle_quit_loop_cb, NULL, NULL); /* Wait for window to show up */ gtk_widget_show_all(window); g_signal_connect(window, "map-event", G_CALLBACK(map_event_cb), loop); g_main_loop_run(loop); /* Load a page with a big div that will cause scrollbars to appear */ webkit_web_view_load_uri(view, effective_uri); g_main_loop_run(loop); /* Adjustments update asynchronously, so we must wait a bit. */ g_timeout_add(100, quit_after_short_delay_cb, loop); g_main_loop_run(loop); adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrolled_window)); g_assert_cmpfloat(gtk_adjustment_get_value(adjustment), ==, 0.0); lower = gtk_adjustment_get_lower(adjustment); upper = gtk_adjustment_get_upper(adjustment); /* Scroll the view using JavaScript */ webkit_web_view_execute_script(view, "window.scrollBy(0, 100)"); /* Adjustments update asynchronously, so we must wait a bit. */ g_timeout_add(100, quit_after_short_delay_cb, loop); g_main_loop_run(loop); /* Make sure the ScrolledWindow noticed the scroll */ g_assert_cmpfloat(gtk_adjustment_get_value(adjustment), ==, 100.0); /* Load a second URI */ webkit_web_view_load_uri(view, second_uri); g_main_loop_run(loop); /* The page loaded but the adjustments may not be updated yet. Wait a bit. */ g_timeout_add(100, quit_after_short_delay_cb, loop); g_main_loop_run(loop); /* Make sure the scrollbar has been reset */ g_assert_cmpfloat(gtk_adjustment_get_value(adjustment), ==, 0.0); /* Go back */ webkit_web_view_go_back(view); /* When using page cache, go_back will return syncronously */ if (!with_page_cache) g_main_loop_run(loop); /* Make sure GTK+ has time to process the changes in size, for the adjusments */ while (gtk_events_pending()) gtk_main_iteration(); /* Make sure upper and lower bounds have been restored correctly */ g_assert_cmpfloat(lower, ==, gtk_adjustment_get_lower(adjustment)); g_assert_cmpfloat(upper, ==, gtk_adjustment_get_upper(adjustment)); g_assert_cmpfloat(gtk_adjustment_get_value(adjustment), ==, 100.0); g_free(effective_uri); g_free(second_uri); gtk_widget_destroy(window); }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *sw; GtkWidget *tv; GtkWidget *table; GtkWidget *om; GtkWidget *menu; GtkTreeModel *model; gint i; gtk_init (&argc, &argv); our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm); #if 0 models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ()); #endif models[MODEL_LIST] = create_list_model (); models[MODEL_TREE] = create_tree_model (); model = create_list_model (); models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); model = create_tree_model (); models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model); g_object_unref (model); models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT)); models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT)); models[MODEL_NULL] = NULL; run_automated_tests (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); gtk_window_set_default_size (GTK_WINDOW (window), 430, 400); table = gtk_table_new (3, 1, FALSE); gtk_container_add (GTK_CONTAINER (window), table); tv = gtk_tree_view_new_with_model (models[0]); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv), GDK_BUTTON1_MASK, row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE | GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv), row_targets, G_N_ELEMENTS (row_targets), GDK_ACTION_MOVE | GDK_ACTION_COPY); /* Model menu */ menu = gtk_menu_new (); i = 0; while (i < MODEL_LAST) { GtkWidget *mi; const char *name; name = model_names[i]; mi = gtk_menu_item_new_with_label (name); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi); #if 0 window = create_prop_editor (G_OBJECT (models[i])); gtk_window_set_title (GTK_WINDOW (window), name); #endif ++i; } gtk_widget_show_all (menu); om = gtk_option_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu); gtk_table_attach (GTK_TABLE (table), om, 0, 1, 0, 1, 0, 0, 0, 0); g_signal_connect (om, "changed", G_CALLBACK (model_selected), tv); /* Columns menu */ menu = gtk_menu_new (); i = 0; while (i < COLUMNS_LAST) { GtkWidget *mi; const char *name; name = column_type_names[i]; mi = gtk_menu_item_new_with_label (name); gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi); ++i; } gtk_widget_show_all (menu); om = gtk_option_menu_new (); gtk_option_menu_set_menu (GTK_OPTION_MENU (om), menu); gtk_table_attach (GTK_TABLE (table), om, 0, 1, 1, 2, 0, 0, 0, 0); set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS); gtk_option_menu_set_history (GTK_OPTION_MENU (om), COLUMNS_LOTS); g_signal_connect (om, "changed", G_CALLBACK (columns_selected), tv); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_table_attach (GTK_TABLE (table), sw, 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_widget_show_all (window); gtk_main (); return 0; }
void _camera_import_dialog_new(_camera_import_dialog_t *data) { data->dialog=gtk_dialog_new_with_buttons(_("import images from camera"),NULL,GTK_DIALOG_MODAL,_("cancel"),GTK_RESPONSE_NONE,C_("camera import", "import"),GTK_RESPONSE_ACCEPT,NULL); GtkWidget *content = gtk_dialog_get_content_area (GTK_DIALOG (data->dialog)); // List - setup store data->store = gtk_list_store_new (2,GDK_TYPE_PIXBUF,G_TYPE_STRING); // IMPORT PAGE data->import.page=gtk_vbox_new(FALSE,5); gtk_container_set_border_width(GTK_CONTAINER(data->import.page),5); // Top info data->import.info=gtk_label_new( _("please wait while prefetching thumbnails of images from camera...") ); gtk_label_set_single_line_mode( GTK_LABEL(data->import.info) , FALSE ); gtk_misc_set_alignment(GTK_MISC(data->import.info), 0.0, 0.0); gtk_box_pack_start(GTK_BOX(data->import.page),data->import.info,FALSE,FALSE,0); // jobcode data->import.jobname=_camera_import_gconf_widget(data,_("jobcode"),"plugins/capture/camera/import/jobcode"); gtk_box_pack_start(GTK_BOX(data->import.page),GTK_WIDGET(data->import.jobname->widget),FALSE,FALSE,0); // Create the treview with list model data store data->import.treeview=gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview),GTK_POLICY_NEVER,GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new()); GtkTreeView *treeview=GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview))); GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new( ); GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes( _("thumbnail") , renderer,"pixbuf",0, (char *)NULL); gtk_tree_view_append_column( treeview , column); renderer = gtk_cell_renderer_text_new( ); column = gtk_tree_view_column_new_with_attributes( _("storage file"), renderer, "text", 1, (char *)NULL); gtk_tree_view_append_column( treeview , column); gtk_tree_view_column_set_expand( column, TRUE); GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview); gtk_tree_selection_set_mode(selection,GTK_SELECTION_MULTIPLE); gtk_tree_view_set_model(treeview,GTK_TREE_MODEL(data->store)); gtk_tree_view_set_headers_visible(treeview,FALSE); gtk_box_pack_start(GTK_BOX(data->import.page),data->import.treeview,TRUE,TRUE,0); // SETTINGS PAGE data->settings.page=gtk_vbox_new(FALSE,5); gtk_container_set_border_width(GTK_CONTAINER(data->settings.page),5); // general settings gtk_box_pack_start(GTK_BOX(data->settings.page),dtgtk_label_new(_("general"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT),FALSE,FALSE,0); // ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories. data->settings.general.ignore_jpeg = gtk_check_button_new_with_label (_("ignore JPEG files")); g_object_set(data->settings.general.ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+JPEG in a directory."), NULL); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->settings.general.ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs")); gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0); g_signal_connect (G_OBJECT(data->settings.general.ignore_jpeg), "clicked",G_CALLBACK (_check_button_callback),data); GtkWidget *hbox=gtk_hbox_new(FALSE,5); data->settings.general.date_override=gtk_check_button_new_with_label(_("override today's date")); gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_override,FALSE,FALSE,0); g_object_set(data->settings.general.date_override,"tooltip-text",_("check this, if you want to override the timestamp used when expanding variables:\n$(YEAR), $(MONTH), $(DAY),\n$(HOUR), $(MINUTE), $(SECONDS)"),(char *)NULL); data->settings.general.date_entry=gtk_entry_new(); gtk_widget_set_sensitive( data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override))); gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_entry,TRUE,TRUE,0); g_signal_connect (G_OBJECT (data->settings.general.date_override), "clicked",G_CALLBACK (_check_button_callback),data); gtk_box_pack_start(GTK_BOX(data->settings.page),hbox,FALSE,FALSE,0); // THE NOTEBOOK data->notebook=gtk_notebook_new(); gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->import.page,gtk_label_new(_("images"))); gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->settings.page,gtk_label_new(_("settings"))); // end gtk_box_pack_start(GTK_BOX(content),data->notebook,TRUE,TRUE,0); //gtk_widget_set_size_request(content, DT_PIXEL_APPLY_DPI(400), DT_PIXEL_APPLY_DPI(400)); }
int init_preferences(t_window * window) { /* INIT Fenetre Gestion */ window->pWindow_p = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); gtk_window_set_title(GTK_WINDOW(window->pWindow_p), "TUTTI 0.1 : Gestion"); gtk_window_set_position(GTK_WINDOW(window->pWindow_p), GTK_WIN_POS_NONE ); gtk_window_set_default_size(GTK_WINDOW(window->pWindow_p),600 , 500); g_signal_connect(G_OBJECT(window->pWindow_p), "destroy", G_CALLBACK(OnKill_p), NULL); g_signal_connect(G_OBJECT(window->pWindow_p), "delete_event", G_CALLBACK(OnKill_p), NULL); /* box principale */ window->pHBox_p = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window->pWindow_p), window->pHBox_p); /* Creation de l arbre des parametres */ window->pTreeStore_p = gtk_tree_store_new( 1, G_TYPE_STRING); int i; int j; char titres[5][20]; char ssmenu[5][3][20]; g_sprintf(titres[0], "Generale"); g_sprintf(ssmenu[0][0], "prop 1"); g_sprintf(ssmenu[0][1], "prop 2"); g_sprintf(ssmenu[0][2], "0"); g_sprintf(titres[1], "Apparence"); g_sprintf(ssmenu[1][0], "0"); g_sprintf(titres[2], "Contacts"); g_sprintf(ssmenu[2][0], "0"); g_sprintf(titres[3], "Connexion"); g_sprintf(ssmenu[3][0], "prop 1"); g_sprintf(ssmenu[3][1], "prop 2"); g_sprintf(ssmenu[3][2], "0"); g_sprintf(titres[4], "0"); GtkTreeIter pIter_p; GtkTreeIter pIter2_p; i=0; while (strcmp(titres[i],"0")){ gtk_tree_store_append(window->pTreeStore_p, &pIter_p, NULL); gtk_tree_store_set(window->pTreeStore_p, &pIter_p, 0, titres[i], -1); j = 0; while (strcmp(ssmenu[i][j], "0")){ gtk_tree_store_append(window->pTreeStore_p, &pIter2_p, &pIter_p ); gtk_tree_store_set(window->pTreeStore_p, &pIter2_p, 0, ssmenu[i][j], -1); j++; } i++; } /* creation de la vue */ window->pTreeView_p = gtk_tree_view_new_with_model(GTK_TREE_MODEL(window->pTreeStore_p)); /* Creation de la colonne */ window->pCellRenderer_p = gtk_cell_renderer_text_new(); window->pColumn_p = gtk_tree_view_column_new_with_attributes("Rubriques ~", window->pCellRenderer_p, "text", 0, NULL); /* Ajout de la colonne à la vue */ gtk_tree_view_append_column(GTK_TREE_VIEW(window->pTreeView_p), window->pColumn_p); /* Creation scrollbar contenant la liste des contacts */ window->pScrollbar_p = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(window->pHBox_p), window->pScrollbar_p, FALSE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window->pScrollbar_p), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); /* ajout de la vue a la ScrollBar */ gtk_container_add(GTK_CONTAINER(window->pScrollbar_p), window->pTreeView_p); /* Creation des rubriques */ window->pBox_rub_p = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(window->pHBox_p), window->pBox_rub_p, TRUE, TRUE, 0); /* contenue des rubriques */ window->pBox_aff_p = gtk_hbox_new(FALSE, 0); gtk_box_pack_end(GTK_BOX(window->pHBox_p), window->pBox_aff_p, TRUE, TRUE, 0); g_signal_connect(window->pTreeView_p, "row-activated", G_CALLBACK(OnDPress_rub), window); return 1 ; }
static GtkWidget * create_window (void) { GtkWidget *window; GtkWidget *hbox, *vbox, *widget; GtkWidget *swindow, *frame, *expander; GtkWidget *paper_cntl, *items_cntl; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); hbox = gtk_hbox_new (FALSE, 2); vbox = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (window), 8); gtk_widget_show (vbox); gtk_widget_show (hbox); gtk_container_add (GTK_CONTAINER (window), hbox); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); frame = gtk_frame_new ("SpreadTable"); gtk_widget_show (frame); gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (swindow); gtk_container_add (GTK_CONTAINER (frame), swindow); paper = egg_spread_table_new (GTK_ORIENTATION_VERTICAL, INITIAL_LINES); egg_spread_table_set_vertical_spacing (EGG_SPREAD_TABLE (paper), INITIAL_VSPACING); egg_spread_table_set_horizontal_spacing (EGG_SPREAD_TABLE (paper), INITIAL_HSPACING); gtk_widget_show (paper); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), paper); /* Add SpreadTable test control frame */ expander = gtk_expander_new ("SpreadTable controls"); gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE); paper_cntl = gtk_vbox_new (FALSE, 2); gtk_widget_show (paper_cntl); gtk_widget_show (expander); gtk_container_add (GTK_CONTAINER (expander), paper_cntl); gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0); /* Add Orientation control */ widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Horizontal"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Vertical"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1); gtk_widget_show (widget); gtk_widget_set_tooltip_text (widget, "Set the spread_table orientation"); gtk_box_pack_start (GTK_BOX (paper_cntl), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (orientation_changed), paper); /* Add horizontal/vertical spacing controls */ hbox = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox); widget = gtk_label_new ("H Spacing"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (0, 30, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_HSPACING); gtk_widget_show (widget); gtk_widget_set_tooltip_text (widget, "Set the horizontal spacing between children"); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL)); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL)); gtk_box_pack_start (GTK_BOX (paper_cntl), hbox, FALSE, FALSE, 0); hbox = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox); widget = gtk_label_new ("V Spacing"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (0, 30, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_VSPACING); gtk_widget_show (widget); gtk_widget_set_tooltip_text (widget, "Set the vertical spacing between children"); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL)); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (spacing_changed), GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL)); gtk_box_pack_start (GTK_BOX (paper_cntl), hbox, FALSE, FALSE, 0); /* Add lines controls */ hbox = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox); widget = gtk_label_new ("Lines"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (1, 30, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_LINES); gtk_widget_show (widget); gtk_widget_set_tooltip_text (widget, "Set the horizontal spacing between children"); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (lines_changed), NULL); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (lines_changed), NULL); gtk_box_pack_start (GTK_BOX (paper_cntl), hbox, FALSE, FALSE, 0); /* Add test items control frame */ expander = gtk_expander_new ("Test item controls"); gtk_expander_set_expanded (GTK_EXPANDER (expander), TRUE); items_cntl = gtk_vbox_new (FALSE, 2); gtk_widget_show (items_cntl); gtk_widget_show (expander); gtk_container_add (GTK_CONTAINER (expander), items_cntl); gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0); /* Add child halign control */ widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Fill"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Start"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "End"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Center"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_HALIGN); gtk_widget_show (widget); gtk_widget_set_tooltip_text (widget, "Set the children's halign property"); gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (halign_changed), paper); /* Add image control */ widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "None"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Small"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Large"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Huge"); gtk_combo_box_set_active (GTK_COMBO_BOX (widget), INITIAL_IMAGE); gtk_widget_show (widget); gtk_widget_set_tooltip_text (widget, "Use an image to test the container"); gtk_box_pack_start (GTK_BOX (items_cntl), widget, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (test_image_changed), paper); /* Add horizontal/vertical spacing controls */ hbox = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox); widget = gtk_label_new ("Image index"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); widget = gtk_spin_button_new_with_range (0, 25, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), INITIAL_IMAGE_INDEX); gtk_widget_show (widget); gtk_widget_set_tooltip_text (widget, "Set the child list index for the optional test image"); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (items_cntl), hbox, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (test_image_index_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL)); g_signal_connect (G_OBJECT (widget), "value-changed", G_CALLBACK (test_image_index_changed), GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL)); populate_spread_table_wrappy (EGG_SPREAD_TABLE (paper)); gtk_window_set_default_size (GTK_WINDOW (window), 500, 400); return window; }
/** * Format notebook fields page. * \param pageNum Page (tab) number. * \param pageLbl Page (tab) label. */ static void imp_ldif_page_fields( gint pageNum, gchar *pageLbl ) { GtkWidget *vbox; GtkWidget *vboxt; GtkWidget *vboxb; GtkWidget *table; GtkWidget *label; GtkWidget *clist_swin; GtkWidget *clist_field; GtkWidget *entryField; GtkWidget *entryAttrib; GtkWidget *checkSelect; GtkWidget *btnModify; GtkWidget *eventBox; GtkTooltips *toolTip; gint top; gchar *titles[ FIELDS_N_COLS ]; gint i; titles[ FIELD_COL_RESERVED ] = _("R"); titles[ FIELD_COL_SELECT ] = _("S"); titles[ FIELD_COL_FIELD ] = _("LDIF Field Name"); titles[ FIELD_COL_ATTRIB ] = _("Attribute Name"); vbox = gtk_vbox_new(FALSE, 8); gtk_container_add( GTK_CONTAINER( impldif_dlg.notebook ), vbox ); gtk_container_set_border_width( GTK_CONTAINER (vbox), 4 ); label = gtk_label_new( pageLbl ); gtk_widget_show( label ); gtk_notebook_set_tab_label( GTK_NOTEBOOK( impldif_dlg.notebook ), gtk_notebook_get_nth_page(GTK_NOTEBOOK( impldif_dlg.notebook ), pageNum ), label ); /* Upper area - Field list */ vboxt = gtk_vbox_new( FALSE, 4 ); gtk_container_add( GTK_CONTAINER( vbox ), vboxt ); clist_swin = gtk_scrolled_window_new( NULL, NULL ); gtk_container_add( GTK_CONTAINER(vboxt), clist_swin ); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clist_swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); clist_field = gtk_clist_new_with_titles( FIELDS_N_COLS, titles ); gtk_container_add( GTK_CONTAINER(clist_swin), clist_field ); gtk_clist_set_selection_mode( GTK_CLIST(clist_field), GTK_SELECTION_BROWSE ); gtk_clist_set_column_width( GTK_CLIST(clist_field), FIELD_COL_RESERVED, FIELDS_COL_WIDTH_RESERVED ); gtk_clist_set_column_width( GTK_CLIST(clist_field), FIELD_COL_SELECT, FIELDS_COL_WIDTH_SELECT ); gtk_clist_set_column_width( GTK_CLIST(clist_field), FIELD_COL_FIELD, FIELDS_COL_WIDTH_FIELD ); gtk_clist_set_column_width( GTK_CLIST(clist_field), FIELD_COL_ATTRIB, FIELDS_COL_WIDTH_ATTRIB ); /* Remove focus capability for column headers */ for( i = 0; i < FIELDS_N_COLS; i++ ) { GTK_WIDGET_UNSET_FLAGS( GTK_CLIST(clist_field)->column[i].button, GTK_CAN_FOCUS); } /* Lower area - Edit area */ vboxb = gtk_vbox_new( FALSE, 4 ); gtk_box_pack_end(GTK_BOX(vbox), vboxb, FALSE, FALSE, 2); /* Data entry area */ table = gtk_table_new( 3, 3, FALSE); gtk_box_pack_start(GTK_BOX(vboxb), table, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(table), 4); gtk_table_set_col_spacings(GTK_TABLE(table), 4); /* First row */ top = 0; label = gtk_label_new(_("LDIF Field")); gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); entryField = gtk_label_new( "" ); gtk_misc_set_alignment(GTK_MISC(entryField), 0.01, 0.5); gtk_table_attach(GTK_TABLE(table), entryField, 1, 3, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); /* Second row */ ++top; label = gtk_label_new(_("Attribute")); gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); entryAttrib = gtk_entry_new(); gtk_table_attach(GTK_TABLE(table), entryAttrib, 1, 3, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); toolTip = gtk_tooltips_new(); gtk_tooltips_set_tip( toolTip, entryAttrib, _( "The LDIF field can be renamed to the User Attribute name." ), NULL ); /* Next row */ ++top; label = gtk_label_new( _( "???" ) ); /* gtk_table_attach(GTK_TABLE(table), label, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0); */ gtk_misc_set_alignment(GTK_MISC(label), 0.5, 0.5); /* * Use an event box to attach some help in the form of a tooltip. * Tried this for the clist but it looked bad. */ eventBox = gtk_event_box_new(); gtk_container_add( GTK_CONTAINER(eventBox), label ); gtk_table_attach(GTK_TABLE(table), eventBox, 0, 1, top, (top + 1), GTK_FILL, 0, 0, 0); toolTip = gtk_tooltips_new(); gtk_tooltips_set_tip( toolTip, eventBox, _( "Choose the LDIF field that will be renamed or selected " \ "for import in the list above. Reserved fields (marked " \ "with a tick in the \"R\" column), are automatically " \ "imported and cannot be renamed. A single click in the " \ "Select (\"S\") column will select the field for import " \ "with a tick. A single click anywhere in the row will " \ "select that field for rename in the input area below " \ "the list. A double click anywhere in the row will also " \ "select the field for import." ), NULL ); checkSelect = gtk_check_button_new_with_label( _( "Select for Import" ) ); gtk_table_attach(GTK_TABLE(table), checkSelect, 1, 2, top, (top + 1), GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0, 0); toolTip = gtk_tooltips_new(); gtk_tooltips_set_tip( toolTip, checkSelect, _( "Select the LDIF field for import into the address book." ), NULL ); btnModify = gtk_button_new_with_label( _(" Modify ")); gtk_table_attach(GTK_TABLE(table), btnModify, 2, 3, top, (top + 1), GTK_FILL, 0, 3, 0); toolTip = gtk_tooltips_new(); gtk_tooltips_set_tip( toolTip, btnModify, _( "This button will update the list above with the data supplied." ), NULL ); gtk_widget_show_all(vbox); /* Event handlers */ gtk_signal_connect( GTK_OBJECT(clist_field), "select_row", GTK_SIGNAL_FUNC(imp_ldif_field_list_selected), NULL ); gtk_signal_connect( GTK_OBJECT(clist_field), "button_press_event", GTK_SIGNAL_FUNC(imp_ldif_field_list_toggle), NULL ); gtk_signal_connect( GTK_OBJECT(btnModify), "clicked", GTK_SIGNAL_FUNC(imp_ldif_modify_pressed), NULL ); impldif_dlg.clist_field = clist_field; impldif_dlg.entryField = entryField; impldif_dlg.entryAttrib = entryAttrib; impldif_dlg.checkSelect = checkSelect; impldif_dlg.btnModify = btnModify; }
/* * Open the window to select and type the picture properties */ void Picture_Properties_Button_Clicked (GObject *object) { GtkWidget *ScrollWindowPictureTypes, *PictureTypesWindow; GtkWidget *type, *label, *desc; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkListStore *store; GtkTreeIter type_iter_to_select, iter; GtkTreeModel *model; GtkWindow *parent_window = NULL; GList *selection_list = NULL; GList *l; gint selection_nbr, selection_i = 1; gint response; EtPictureType pic_type; g_return_if_fail (PictureEntryView != NULL); parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object))); if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window))) { g_warning("Could not get parent window\n"); return; } model = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView)); selection_list = gtk_tree_selection_get_selected_rows(selection, NULL); selection_nbr = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection)); for (l = selection_list; l != NULL; l = g_list_next (l)) { GtkTreePath *path = l->data; Picture *pic = NULL; GtkTreeSelection *selectiontype; gchar *title; GtkTreePath *rowPath; gboolean valid; // Get corresponding picture valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path); if (valid) gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1); title = g_strdup_printf (_("Image Properties %d/%d"), selection_i++, selection_nbr); PictureTypesWindow = gtk_dialog_new_with_buttons(title, parent_window, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_free(title); gtk_dialog_set_default_response(GTK_DIALOG(PictureTypesWindow), GTK_RESPONSE_OK); ScrollWindowPictureTypes = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowPictureTypes), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); store = gtk_list_store_new(PICTURE_TYPE_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_INT); type = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref (store); gtk_container_add(GTK_CONTAINER(ScrollWindowPictureTypes), type); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_title (column, _("Image Type")); gtk_tree_view_column_set_attributes(column, renderer, "text", PICTURE_TYPE_COLUMN_TEXT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(type), column); gtk_widget_set_size_request(type, 256, 256); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),ScrollWindowPictureTypes,TRUE,TRUE,0); // Behaviour following the tag type... switch (ETCore->ETFileDisplayed->ETFileDescription->TagType) { case MP4_TAG: { /* Load picture type (only Front Cover!). */ GtkTreeIter itertype; gtk_list_store_insert_with_values (store, &itertype, G_MAXINT, PICTURE_TYPE_COLUMN_TEXT, _(Picture_Type_String (ET_PICTURE_TYPE_FRONT_COVER)), PICTURE_TYPE_COLUMN_TYPE_CODE, ET_PICTURE_TYPE_FRONT_COVER, -1); /* Line to select by default. */ type_iter_to_select = itertype; break; } // Other tag types default: { // Load pictures types for (pic_type = ET_PICTURE_TYPE_OTHER; pic_type < ET_PICTURE_TYPE_UNDEFINED; pic_type++) { GtkTreeIter itertype; gtk_list_store_insert_with_values (store, &itertype, G_MAXINT, PICTURE_TYPE_COLUMN_TEXT, _(Picture_Type_String (pic_type)), PICTURE_TYPE_COLUMN_TYPE_CODE, pic_type, -1); /* Line to select by default. */ if (pic->type == pic_type) type_iter_to_select = itertype; } break; } } // Select the line by default selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type)); gtk_tree_selection_select_iter(selectiontype, &type_iter_to_select); // Set visible the current selected line rowPath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &type_iter_to_select); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(type), rowPath, NULL, FALSE, 0, 0); gtk_tree_path_free(rowPath); // Description of the picture label = gtk_label_new (_("Image Description:")); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),label,FALSE,FALSE,4); // Entry for the description desc = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),desc,FALSE,FALSE,0); if (pic->description) { gchar *tmp = Try_To_Validate_Utf8_String(pic->description); gtk_entry_set_text(GTK_ENTRY(desc), tmp); g_free(tmp); } // Behaviour following the tag type... switch (ETCore->ETFileDisplayed->ETFileDescription->TagType) { case MP4_TAG: { gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(desc), FALSE); break; } // Other tag types default: { break; } } gtk_widget_show_all(PictureTypesWindow); response = gtk_dialog_run(GTK_DIALOG(PictureTypesWindow)); if (response == GTK_RESPONSE_OK) { GtkTreeModel *modeltype; GtkTreeIter itertype; modeltype = gtk_tree_view_get_model(GTK_TREE_VIEW(type)); selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type)); if (gtk_tree_selection_get_selected(selectiontype, &modeltype, &itertype)) { gchar *buffer, *pic_info; gint t; gtk_tree_model_get(modeltype, &itertype, PICTURE_TYPE_COLUMN_TYPE_CODE, &t, -1); pic->type = t; buffer = g_strdup(gtk_entry_get_text(GTK_ENTRY(desc))); Strip_String(buffer); if (pic->description) g_free(pic->description); /* If the entry was empty, buffer will be the empty string "". * This can be safely passed to the underlying * FLAC__metadata_object_picture_set_description(). See * https://bugs.launchpad.net/ubuntu/+source/easytag/+bug/558804 * and https://bugzilla.redhat.com/show_bug.cgi?id=559828 for * downstream bugs when 0 was passed instead. */ pic->description = buffer; // Update value in the PictureEntryView pic_info = Picture_Info(pic); gtk_list_store_set(GTK_LIST_STORE(model), &iter, PICTURE_COLUMN_TEXT, pic_info, -1); g_free(pic_info); } } gtk_widget_destroy(PictureTypesWindow); } g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free); }
GtkWidget* create_windowMain () { GtkWidget *vbox1; GtkWidget *hpaned1; GtkWidget *scrolledwindow1; GtkWidget *hbuttonbox1; GtkWidget *buttonRefresh; GtkWidget *buttonConfigure; GtkWidget *buttonClose; GtkWidget *buttonAbout; GdkPixbuf *icon; GtkCellRenderer *treeRenderer; GtkTreeViewColumn *treeColumn; windowMain = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (windowMain, "windowMain"); gtk_window_set_title (GTK_WINDOW (windowMain), "USB Viewer"); gtk_window_set_default_size (GTK_WINDOW (windowMain), 600, 300); icon = gdk_pixbuf_new_from_xpm_data((const char **)usbview_icon); gtk_window_set_icon(GTK_WINDOW(windowMain), icon); vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_set_name (vbox1, "vbox1"); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (windowMain), vbox1); hpaned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_name (hpaned1, "hpaned1"); gtk_widget_show (hpaned1); gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0); treeStore = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, /* NAME_COLUMN */ G_TYPE_INT, /* DEVICE_ADDR_COLUMN */ G_TYPE_STRING /* COLOR_COLUMN */); treeUSB = gtk_tree_view_new_with_model (GTK_TREE_MODEL (treeStore)); treeRenderer = gtk_cell_renderer_text_new (); treeColumn = gtk_tree_view_column_new_with_attributes ( "USB devices", treeRenderer, "text", NAME_COLUMN, "foreground", COLOR_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeUSB), treeColumn); gtk_widget_set_name (treeUSB, "treeUSB"); gtk_widget_show (treeUSB); gtk_paned_pack1 (GTK_PANED (hpaned1), treeUSB, FALSE, FALSE); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_name (scrolledwindow1, "scrolledwindow1"); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_show (scrolledwindow1); gtk_paned_pack2 (GTK_PANED (hpaned1), scrolledwindow1, TRUE, FALSE); textDescriptionBuffer = gtk_text_buffer_new(NULL); //textDescription = gtk_text_new (NULL, NULL); textDescriptionView = gtk_text_view_new_with_buffer(textDescriptionBuffer); gtk_widget_set_name (textDescriptionView, "textDescription"); gtk_text_view_set_editable(GTK_TEXT_VIEW(textDescriptionView), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textDescriptionView), FALSE); gtk_widget_show (textDescriptionView); gtk_container_add (GTK_CONTAINER (scrolledwindow1), textDescriptionView); hbuttonbox1 = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_name (hbuttonbox1, "hbuttonbox1"); gtk_widget_show (hbuttonbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, FALSE, 5); //gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10); //gtk_button_box_set_child_size (GTK_BUTTON_BOX (hbuttonbox1), 50, 25); //gtk_button_box_set_child_ipadding (GTK_BUTTON_BOX (hbuttonbox1), 25, 10); buttonRefresh = gtk_button_new_with_label("Refresh"); gtk_widget_set_name (buttonRefresh, "buttonRefresh"); gtk_widget_show (buttonRefresh); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonRefresh); gtk_container_set_border_width (GTK_CONTAINER (buttonRefresh), 4); gtk_widget_set_can_default (buttonRefresh, TRUE); buttonConfigure = gtk_button_new_with_label ("Configure..."); gtk_widget_set_name (buttonConfigure, "buttonConfigure"); gtk_widget_show (buttonConfigure); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonConfigure); gtk_container_set_border_width (GTK_CONTAINER (buttonConfigure), 4); gtk_widget_set_can_default (buttonConfigure, TRUE); buttonAbout = gtk_button_new_with_label("About"); gtk_widget_set_name (buttonAbout, "buttonAbout"); gtk_widget_show (buttonAbout); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonAbout); gtk_container_set_border_width (GTK_CONTAINER (buttonAbout), 4); gtk_widget_set_can_default (buttonAbout, TRUE); buttonClose = gtk_button_new_with_label("Quit"); gtk_widget_set_name (buttonClose, "buttonClose"); gtk_widget_show (buttonClose); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonClose); gtk_container_set_border_width (GTK_CONTAINER (buttonClose), 4); gtk_widget_set_can_default (buttonClose, TRUE); g_signal_connect (G_OBJECT (windowMain), "delete_event", G_CALLBACK (on_window1_delete_event), NULL); g_signal_connect (G_OBJECT (buttonRefresh), "clicked", G_CALLBACK (on_buttonRefresh_clicked), NULL); g_signal_connect (G_OBJECT (buttonConfigure), "clicked", G_CALLBACK (on_buttonConfigure_clicked), NULL); g_signal_connect (G_OBJECT (buttonAbout), "clicked", G_CALLBACK (on_buttonAbout_clicked), NULL); g_signal_connect (G_OBJECT (buttonClose), "clicked", G_CALLBACK (on_buttonClose_clicked), NULL); /* create our timer */ //timer = gtk_timeout_add (2000, on_timer_timeout, 0); return windowMain; }
gint main (gint argc, gchar * argv[]) { IconBrowserData *data; gchar **themes = NULL; GList *ic, *icat; GtkListStore *store; GtkTreeSelection *sel; GtkTreeViewColumn *col; GtkCellRenderer *r; GtkWidget *w, *p, *box, *t; GOptionEntry entrs[] = { {G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &themes, NULL, NULL}, {NULL} }; data = g_new0 (IconBrowserData, 1); #ifdef ENABLE_NLS bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); #endif data = g_new0 (IconBrowserData, 1); /* initialize GTK+ and parse the command line arguments */ gtk_init_with_args (&argc, &argv, _("- Icon browser"), entrs, GETTEXT_PACKAGE, NULL); /* load icon theme */ if (themes && themes[0]) { data->theme = gtk_icon_theme_new (); gtk_icon_theme_set_custom_theme (data->theme, themes[0]); } else data->theme = gtk_icon_theme_get_default (); /* create interface */ data->win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (data->win), _("Icon browser")); gtk_window_set_icon_name (GTK_WINDOW (data->win), "gtk-info"); gtk_window_set_default_size (GTK_WINDOW (data->win), 500, 400); g_signal_connect (G_OBJECT (data->win), "delete-event", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (G_OBJECT (data->win), "key-press-event", G_CALLBACK (key_press_cb), NULL); #if !GTK_CHECK_VERSION(3,0,0) box = gtk_vbox_new (FALSE, 5); #else box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); #endif gtk_container_add (GTK_CONTAINER (data->win), box); gtk_container_set_border_width (GTK_CONTAINER (data->win), 5); /* create icon info box */ #if !GTK_CHECK_VERSION(3,0,0) t = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (t), 5); gtk_table_set_row_spacings (GTK_TABLE (t), 5); #else t = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (t), 5); gtk_grid_set_column_spacing (GTK_GRID (t), 5); #endif gtk_box_pack_start (GTK_BOX (box), t, FALSE, FALSE, 2); data->image = gtk_image_new_from_stock ("gtk-missing-image", GTK_ICON_SIZE_DIALOG); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), data->image, 0, 1, 0, 3, GTK_FILL, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), data->image, 0, 0, 1, 3); #endif w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), _("<b>Name:</b>")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), w, 1, 2, 0, 1, GTK_FILL, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), w, 1, 0, 1, 1); #endif data->lname = gtk_label_new (NULL); gtk_label_set_selectable (GTK_LABEL (data->lname), TRUE); gtk_misc_set_alignment (GTK_MISC (data->lname), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), data->lname, 2, 3, 0, 1, GTK_FILL | GTK_EXPAND, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), data->lname, 2, 0, 1, 1); gtk_widget_set_hexpand (data->lname, TRUE); #endif w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), _("<b>Sizes:</b>")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), w, 1, 2, 1, 2, GTK_FILL, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), w, 1, 1, 1, 1); #endif data->lsize = gtk_label_new (NULL); gtk_label_set_selectable (GTK_LABEL (data->lsize), TRUE); gtk_misc_set_alignment (GTK_MISC (data->lsize), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), data->lsize, 2, 3, 1, 2, GTK_FILL | GTK_EXPAND, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), data->lsize, 2, 1, 1, 1); gtk_widget_set_hexpand (data->lsize, TRUE); #endif w = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (w), _("<b>Filename:</b>")); gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), w, 1, 2, 2, 3, GTK_FILL, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), w, 1, 2, 1, 1); #endif data->lfile = gtk_label_new (NULL); gtk_label_set_selectable (GTK_LABEL (data->lfile), TRUE); gtk_misc_set_alignment (GTK_MISC (data->lfile), 0, 0.5); #if !GTK_CHECK_VERSION(3,0,0) gtk_table_attach (GTK_TABLE (t), data->lfile, 2, 3, 2, 3, GTK_FILL | GTK_EXPAND, 0, 0, 0); #else gtk_grid_attach (GTK_GRID (t), data->lfile, 2, 2, 1, 1); gtk_widget_set_hexpand (data->lfile, TRUE); #endif /* create icon browser */ #if !GTK_CHECK_VERSION(3,0,0) p = gtk_hpaned_new (); #else p = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); #endif gtk_paned_set_position (GTK_PANED (p), 150); gtk_box_pack_start (GTK_BOX (box), p, TRUE, TRUE, 2); /* create category list */ w = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN); gtk_paned_add1 (GTK_PANED (p), w); store = gtk_list_store_new (1, G_TYPE_STRING); data->cat_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (data->cat_list), TRUE); gtk_container_add (GTK_CONTAINER (w), data->cat_list); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->cat_list)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (select_cat), data); r = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (_("Category"), r, "text", 0, NULL); gtk_tree_view_column_set_expand (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (data->cat_list), col); /* load icons category */ data->icons = g_hash_table_new (g_direct_hash, g_direct_equal); icat = gtk_icon_theme_list_contexts (data->theme); for (ic = icat; ic; ic = ic->next) { GtkTreeIter iter; gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, 0, ic->data, -1); g_free (ic->data); } g_list_free (icat); /* create icons list */ w = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN); gtk_paned_add2 (GTK_PANED (p), w); data->icon_list = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (data->icon_list), TRUE); gtk_container_add (GTK_CONTAINER (w), data->icon_list); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->icon_list)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (select_icon), data); col = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (col, _("Icons")); gtk_tree_view_column_set_sort_column_id (col, 1); r = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (col, r, FALSE); gtk_tree_view_column_set_attributes (col, r, "pixbuf", 0, NULL); r = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, r, FALSE); gtk_tree_view_column_set_attributes (col, r, "text", 1, NULL); gtk_tree_view_column_set_expand (col, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (data->icon_list), col); gtk_widget_show_all (data->win); /* run it */ gtk_main (); return 0; }
static void games_scores_dialog_init (GamesScoresDialog *self) { GtkWidget *vbox; GtkWidget *scroll; GtkWidget *listview; GtkTreeViewColumn *column; GtkTreeViewColumn *timecolumn; GtkCellRenderer *renderer; GtkCellRenderer *timerenderer; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GAMES_TYPE_SCORES_DIALOG, GamesScoresDialogPrivate); self->priv->style = GAMES_SCORES_STYLE_PLAIN_DESCENDING; /* These two hashes are the reverse of each other. As an optimisation * they share the same set of strings (as keys in the first case and * as data in the second). The first hash is responsible for * deallocating the memory for the strings. These two are only * valid as a pair. */ self->priv->categories = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); self->priv->catindices = g_hash_table_new (g_direct_hash, g_direct_equal); self->priv->catcounter = 0; self->priv->hilight = 0; gtk_container_set_border_width (GTK_CONTAINER (self), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), 2); g_signal_connect (G_OBJECT (self), "show", G_CALLBACK (games_scores_dialog_show), NULL); g_signal_connect (G_OBJECT (self), "hide", G_CALLBACK (games_scores_dialog_hide), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), vbox, TRUE, TRUE, 0); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scroll, 200, 265); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_ETCHED_IN); gtk_box_pack_end (GTK_BOX (vbox), scroll, TRUE, TRUE, 0); self->priv->message = gtk_label_new (""); gtk_label_set_use_markup (GTK_LABEL (self->priv->message), TRUE); gtk_label_set_justify (GTK_LABEL (self->priv->message), GTK_JUSTIFY_CENTER); gtk_box_pack_start (GTK_BOX (vbox), self->priv->message, FALSE, FALSE, 0); self->priv->hdiv = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), self->priv->hdiv, FALSE, FALSE, 0); self->priv->catbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), self->priv->catbar, FALSE, FALSE, 0); self->priv->label = gtk_label_new (NULL); gtk_label_set_use_markup (GTK_LABEL (self->priv->label), TRUE); gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->label, FALSE, FALSE, 0); self->priv->combo = gtk_combo_box_text_new (); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (self->priv->combo), FALSE); gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->combo, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (self->priv->label), self->priv->combo); g_signal_connect (G_OBJECT (self->priv->combo), "changed", G_CALLBACK (games_scores_dialog_change_category), self); self->priv->list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); listview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->list)); self->priv->treeview = GTK_TREE_VIEW (listview); timerenderer = gtk_cell_renderer_text_new (); timecolumn = gtk_tree_view_column_new_with_attributes (/* Score dialog column header for the date the score was recorded */ _("Date"), timerenderer, "text", 0, NULL); g_object_set (G_OBJECT (timerenderer), "xalign", 1.0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (listview), GTK_TREE_VIEW_COLUMN (timecolumn)); self->priv->timecolumn = timecolumn; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", 1, NULL); g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (listview), GTK_TREE_VIEW_COLUMN (column)); self->priv->column = column; gtk_container_add (GTK_CONTAINER (scroll), listview); games_scores_dialog_set_buttons (self, GAMES_SCORES_CLOSE_BUTTON); gtk_window_set_destroy_with_parent (GTK_WINDOW (self), TRUE); gtk_widget_grab_focus (self->priv->combo); gtk_widget_show_all (vbox); gtk_widget_hide (self->priv->hdiv); gtk_widget_hide (self->priv->message); }
/* functions */ GtkWidget * gmdb_table_data_new(MdbCatalogEntry *entry) { MdbTableDef *table; MdbColumn *col; GtkWidget *clist; GtkWidget *scroll; int i, rownum; long row, maxrow; gchar *bound_data[256]; GMdbDataWindow *dataw = NULL; /* do we have an active window for this object? if so raise it */ for (i=0;i<g_list_length(window_list);i++) { dataw = g_list_nth_data(window_list, i); if (!strcmp(dataw->table_name, entry->object_name)) { gdk_window_raise (dataw->window->window); return dataw->window; } } dataw = g_malloc(sizeof(GMdbDataWindow)); strcpy(dataw->table_name, entry->object_name); dataw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(dataw->window), entry->object_name); gtk_widget_set_usize(dataw->window, 300,200); gtk_widget_set_uposition(dataw->window, 50,50); gtk_widget_show(dataw->window); gtk_signal_connect (GTK_OBJECT (dataw->window), "delete_event", GTK_SIGNAL_FUNC (gmdb_table_data_close), dataw); scroll = gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (scroll); gtk_container_add(GTK_CONTAINER(dataw->window), scroll); /* read table */ table = mdb_read_table(entry); mdb_read_columns(table); mdb_rewind_table(table); clist = gtk_clist_new(table->num_cols); gtk_widget_show(clist); gtk_container_add(GTK_CONTAINER(scroll),clist); for (i=0;i<table->num_cols;i++) { /* bind columns */ bound_data[i] = (char *) g_malloc0(MDB_BIND_SIZE); mdb_bind_column(table, i+1, bound_data[i], NULL); /* display column titles */ col=g_ptr_array_index(table->columns,i); gtk_clist_set_column_title(GTK_CLIST(clist), i, col->name); } gtk_clist_column_titles_show(GTK_CLIST(clist)); maxrow = gmdb_prefs_get_maxrows(); /* fetch those rows! */ row = 0; while(mdb_fetch_row(table) && (!maxrow || (row < maxrow))) { row++; rownum = gtk_clist_append(GTK_CLIST(clist), bound_data); } /* free the memory used to bind */ for (i=0;i<table->num_cols;i++) { g_free(bound_data[i]); } /* add this one to the window list */ window_list = g_list_append(window_list, dataw); return dataw->window; }
static void cv_tree_init (chanview *cv) { GtkWidget *view, *win; GtkCellRenderer *renderer; GtkTreeViewColumn *col; int wid1, wid2; static const GtkTargetEntry dnd_src_target[] = { {"HEXCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 } }; static const GtkTargetEntry dnd_dest_target[] = { {"HEXCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 } }; win = gtk_scrolled_window_new (0, 0); /*gtk_container_set_border_width (GTK_CONTAINER (win), 1);*/ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (win), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (cv->box), win); gtk_widget_show (win); view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (cv->store)); gtk_widget_set_name (view, "hexchat-tree"); if (cv->style) gtk_widget_set_style (view, cv->style); /*gtk_widget_modify_base (view, GTK_STATE_NORMAL, &colors[COL_BG]);*/ GTK_WIDGET_UNSET_FLAGS (view, GTK_CAN_FOCUS); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE); if (prefs.hex_gui_tab_dots) { gtk_tree_view_set_enable_tree_lines (GTK_TREE_VIEW (view), TRUE); } /* Indented channels with no server looks silly, but we still want expanders */ if (!prefs.hex_gui_tab_server) { gtk_widget_style_get (view, "expander-size", &wid1, "horizontal-separator", &wid2, NULL); gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (view), -wid1 - wid2); } gtk_container_add (GTK_CONTAINER (win), view); col = gtk_tree_view_column_new(); /* icon column */ if (cv->use_icons) { renderer = gtk_cell_renderer_pixbuf_new (); if (prefs.hex_gui_compact) g_object_set (G_OBJECT (renderer), "ypad", 0, NULL); gtk_tree_view_column_pack_start(col, renderer, FALSE); gtk_tree_view_column_set_attributes (col, renderer, "pixbuf", COL_PIXBUF, NULL); } /* main column */ renderer = gtk_cell_renderer_text_new (); if (prefs.hex_gui_compact) g_object_set (G_OBJECT (renderer), "ypad", 0, NULL); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_set_attributes (col, renderer, "text", COL_NAME, "attributes", COL_ATTR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (view))), "changed", G_CALLBACK (cv_tree_sel_cb), cv); g_signal_connect (G_OBJECT (view), "button-press-event", G_CALLBACK (cv_tree_click_cb), cv); g_signal_connect (G_OBJECT (view), "row-activated", G_CALLBACK (cv_tree_activated_cb), NULL); gtk_drag_dest_set (view, GTK_DEST_DEFAULT_ALL, dnd_dest_target, 1, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK); gtk_drag_source_set (view, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_COPY); #ifndef WIN32 g_signal_connect (G_OBJECT (view), "drag_begin", G_CALLBACK (mg_drag_begin_cb), NULL); g_signal_connect (G_OBJECT (view), "drag_drop", G_CALLBACK (mg_drag_drop_cb), NULL); g_signal_connect (G_OBJECT (view), "drag_motion", G_CALLBACK (mg_drag_motion_cb), NULL); g_signal_connect (G_OBJECT (view), "drag_end", G_CALLBACK (mg_drag_end_cb), NULL); #endif ((treeview *)cv)->tree = GTK_TREE_VIEW (view); ((treeview *)cv)->scrollw = win; gtk_widget_show (view); }
int destination_address(struct navit *nav) { GtkWidget *window2, *keyboard, *vbox, *table; GtkWidget *label_country; GtkWidget *label_postal, *label_city, *label_district; GtkWidget *label_street, *label_number; GtkWidget *hseparator1,*hseparator2; GtkWidget *button1,*button2,*button3; int i; struct search_param *search=&search_param; struct attr search_attr, country_name, *country_attr; struct tracking *tracking; struct country_search *cs; struct item *item; search->nav=nav; search->ms=navit_get_mapset(nav); search->sl=search_list_new(search->ms); window2 = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window2),_("Enter Destination")); gtk_window_set_wmclass (GTK_WINDOW (window2), "navit", "Navit"); vbox = gtk_vbox_new(FALSE, 0); table = gtk_table_new(3, 8, FALSE); search->entry_country = gtk_entry_new(); label_country = gtk_label_new(_("Country")); search->entry_postal = gtk_entry_new(); gtk_widget_set_sensitive(GTK_WIDGET(search->entry_postal), FALSE); label_postal = gtk_label_new(_("Zip Code")); search->entry_city = gtk_entry_new(); label_city = gtk_label_new(_("City")); search->entry_district = gtk_entry_new(); gtk_widget_set_sensitive(GTK_WIDGET(search->entry_district), FALSE); label_district = gtk_label_new(_("District/Township")); hseparator1 = gtk_vseparator_new(); search->entry_street = gtk_entry_new(); label_street = gtk_label_new(_("Street")); search->entry_number = gtk_entry_new(); label_number = gtk_label_new(_("Number")); search->treeview=gtk_tree_view_new(); search->listbox = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (search->listbox), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(search->listbox),search->treeview); { GType types[COL_COUNT+1]; for(i=0;i<COL_COUNT;i++) types[i]=G_TYPE_STRING; types[i]=G_TYPE_POINTER; search->liststore=gtk_list_store_newv(COL_COUNT+1,types); search->liststore2=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(search->liststore)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 3, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), GTK_TREE_MODEL(search->liststore2)); } hseparator2 = gtk_vseparator_new(); button1 = gtk_button_new_with_label(_("Map")); button2 = gtk_button_new_with_label(_("Bookmark")); button3 = gtk_button_new_with_label(_("Destination")); gtk_table_attach(GTK_TABLE(table), label_country, 0, 1, 0, 1, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_postal, 1, 2, 0, 1, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_city, 2, 3, 0, 1, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_country, 0, 1, 1, 2, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_postal, 1, 2, 1, 2, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_city, 2, 3, 1, 2, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_district, 0, 1, 2, 3, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_street, 1, 2, 2, 3, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), label_number, 2, 3, 2, 3, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_district, 0, 1, 3, 4, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_street, 1, 2, 3, 4, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->entry_number, 2, 3, 3, 4, 0, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), search->listbox, 0, 3, 4, 5, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0); gtk_table_attach(GTK_TABLE(table), button1, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), button2, 1, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0); gtk_table_attach(GTK_TABLE(table), button3, 2, 3, 5, 6, GTK_FILL, GTK_FILL, 0, 0); g_signal_connect(G_OBJECT(search->entry_country), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_postal), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_city), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_district), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_street), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(search->entry_number), "changed", G_CALLBACK(changed), search); g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(button_map), search); g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(button_bookmark), search); g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(button_destination), search); g_signal_connect(G_OBJECT(search->treeview), "button-release-event", G_CALLBACK(tree_view_button_release), search); g_signal_connect(G_OBJECT(search->treeview), "row_activated", G_CALLBACK(row_activated), search); gtk_widget_grab_focus(search->entry_city); gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0); keyboard=gtk_socket_new(); gtk_box_pack_end(GTK_BOX(vbox), keyboard, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(window2), vbox); #if 0 g_signal_connect(G_OBJECT(listbox), "select-row", G_CALLBACK(select_row), NULL); #endif gtk_widget_show_all(window2); #ifndef _WIN32 gtk_socket_steal(GTK_SOCKET(keyboard), spawn_xkbd("xkbd","-geometry 200x100")); #endif country_attr=country_default(); tracking=navit_get_tracking(nav); if (tracking && tracking_get_attr(tracking, attr_country_id, &search_attr, NULL)) country_attr=&search_attr; if (country_attr) { cs=country_search_new(country_attr, 0); item=country_search_get_item(cs); if (item && item_attr_get(item, attr_country_name, &country_name)) gtk_entry_set_text(GTK_ENTRY(search->entry_country), country_name.u.str); country_search_destroy(cs); } else { dbg(0,"warning: no default country found\n"); } search->partial=1; return 0; }
static void create_categories_section (GtkWidget *categories_vbox, GUI *appGUI) { GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkWidget *table, *scrolledwindow, *treeview; table = gtk_table_new (4, 3, FALSE); gtk_box_pack_start (GTK_BOX (categories_vbox), table, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (table), 8); gtk_table_set_row_spacings (GTK_TABLE (table), 8); gtk_table_set_col_spacings (GTK_TABLE (table), 4); appGUI->opt->tasks_category_entry = gtk_entry_new (); gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_category_entry, 0, 1, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (G_OBJECT (appGUI->opt->tasks_category_entry), "key_release_event", G_CALLBACK (tasks_category_entry_key_release_cb), appGUI); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_table_attach (GTK_TABLE (table), scrolledwindow, 0, 3, 0, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (appGUI->opt->tasks_category_store)); gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview); gtk_container_set_border_width (GTK_CONTAINER (treeview), 4); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), TRUE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (treeview), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview), FALSE); gtk_widget_set_size_request (treeview, -1, 120); appGUI->opt->tasks_category_treeview = treeview; appGUI->opt->tasks_category_select = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (G_OBJECT (appGUI->opt->tasks_category_select), "changed", G_CALLBACK (tasks_category_selected_cb), appGUI); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "editable", TRUE, "editable-set", TRUE, NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (tasks_category_cell_edited_cb), appGUI); column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", TC_COLUMN_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_column_set_expand (column, TRUE); renderer = gtk_cell_renderer_toggle_new (); /* Show in calendar */ column = gtk_tree_view_column_new_with_attributes(_("Calendar"), renderer, "active", TC_COLUMN_CALENDAR, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_calendar_toggled), appGUI); renderer = gtk_cell_renderer_toggle_new (); /* Show in tasks list */ column = gtk_tree_view_column_new_with_attributes (_("Tasks"), renderer, "active", TC_COLUMN_TASKS, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); g_signal_connect (renderer, "toggled", G_CALLBACK (tsk_show_in_tasks_list_toggled), appGUI); if (config.default_stock_icons) appGUI->opt->tasks_category_add_button = utl_gui_stock_button (GTK_STOCK_ADD, FALSE); else appGUI->opt->tasks_category_add_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_ADD, FALSE); gtk_widget_set_sensitive (appGUI->opt->tasks_category_add_button, FALSE); gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_category_add_button, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (appGUI->opt->tasks_category_add_button, "clicked", G_CALLBACK (tasks_category_add_cb), appGUI); if (config.default_stock_icons) appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (GTK_STOCK_REMOVE, FALSE); else appGUI->opt->tasks_category_remove_button = utl_gui_stock_button (OSMO_STOCK_BUTTON_REMOVE, FALSE); gtk_widget_set_sensitive (appGUI->opt->tasks_category_remove_button, FALSE); gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_category_remove_button, 2, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); g_signal_connect (appGUI->opt->tasks_category_remove_button, "clicked", G_CALLBACK (tasks_category_remove_cb), appGUI); }
/************************************************************************** * Dialog Building Functions **************************************************************************/ static GtkWidget * setup_tree(PidginXferDialog *dialog) { GtkWidget *sw; GtkWidget *tree; GtkListStore *model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; /* Create the scrolled window. */ sw = gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show(sw); /* Build the tree model */ /* Transfer type, Progress Bar, Filename, Size, Remaining */ model = gtk_list_store_new(NUM_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_DOUBLE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); dialog->model = model; /* Create the treeview */ dialog->tree = tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); /* gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); */ gtk_widget_show(tree); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selection_changed_cb), dialog); g_object_unref(G_OBJECT(model)); /* Columns */ /* Transfer Type column */ renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "pixbuf", COLUMN_STATUS, NULL); gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width(GTK_TREE_VIEW_COLUMN(column), 25); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); /* Progress bar column */ renderer = pidgin_cell_renderer_progress_new(); column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, "percentage", COLUMN_PROGRESS, NULL); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); /* Filename column */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Filename"), renderer, "text", COLUMN_FILENAME, NULL); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); /* File Size column */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, "text", COLUMN_SIZE, NULL); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); /* Bytes Remaining column */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Remaining"), renderer, "text", COLUMN_REMAINING, NULL); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); gtk_tree_view_columns_autosize(GTK_TREE_VIEW(tree)); gtk_container_add(GTK_CONTAINER(sw), tree); gtk_widget_show(tree); return sw; }
void l_prov_xdk(char *tablica,GtkWidget *wpredok) { class prov_xdk_data data; char strsql[400]; SQL_str row; SQLCURSOR cur; strcpy(data.tablica,tablica); if(iceb_u_SRAV(data.tablica,"Pltp",0) == 0) { data.pods=4; strcpy(data.metkasys,gettext("ПЛТ")); data.imaf_np.new_plus("avtprodok.alx"); } if(iceb_u_SRAV(data.tablica,"Pltt",0) == 0) { data.pods=5; strcpy(data.metkasys,gettext("ТРЕ")); data.imaf_np.new_plus("avtprodokt.alx"); } memset(data.shet,'\0',sizeof(data.shet)); if(iceb_poldan(rec.nsh.ravno(),data.shet,data.imaf_np.ravno(),wpredok) != 0) { iceb_menu_soob(gettext("Не найден бухгалтерский счёт расчётного счёта !"),wpredok); } //strcpy(data.metkasys,gettext("КО")); //Читаем наименование операции if(iceb_u_SRAV(data.tablica,"Pltp",0) == 0) sprintf(strsql,"select naik from Opltp where kod='%s'",rec.kodop.ravno()); if(iceb_u_SRAV(data.tablica,"Pltt",0) == 0) sprintf(strsql,"select naik from Opltt where kod='%s'",rec.kodop.ravno()); if(iceb_sql_readkey(strsql,&row,&cur,wpredok) == 1) data.naim_kodop.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); sprintf(strsql,"%s %s",name_system, gettext("Работа с проводками (платёжные документы)")); gtk_window_set_title (GTK_WINDOW (data.window),iceb_u_toutf(strsql)); gtk_container_set_border_width (GTK_CONTAINER (data.window), 5); 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); 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_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(prov_xdk_key_press),&data); gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift); GtkWidget *hbox = gtk_hbox_new (FALSE, 1); gtk_container_add (GTK_CONTAINER (data.window), hbox); GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1); GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1); gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); gtk_widget_show_all(hbox); data.label_kolstr=gtk_label_new (""); iceb_u_str stroka; prov_xdk_sapka_menu(&data); gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0); gtk_widget_show(vbox1); gtk_widget_show(vbox2); data.sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); //gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0); GtkWidget *hboxradio = gtk_hbox_new (TRUE, 0); //Вставляем радиокнопки GSList *group; data.radiobutton[0]=gtk_radio_button_new_with_label(NULL,gettext("Дебет")); // gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton[0]),TRUE); //Устанавливем активной кнопку gtk_box_pack_start (GTK_BOX (hboxradio),data.radiobutton[0], TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.radiobutton[0]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_radio0),&data); //gtk_object_set_user_data(GTK_OBJECT(data.radiobutton0),(gpointer)"0"); group=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton[0])); sprintf(strsql,"%s",gettext("Кредит")); data.radiobutton[1]=gtk_radio_button_new_with_label(group,strsql); // gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton[1]),TRUE); //Устанавливем активной кнопку gtk_signal_connect(GTK_OBJECT(data.radiobutton[1]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_radio1),&data); gtk_box_pack_start (GTK_BOX (hboxradio),data.radiobutton[1], TRUE, TRUE, 0); group=gtk_radio_button_group(GTK_RADIO_BUTTON(data.radiobutton[1])); sprintf(strsql,"%s",gettext("Все")); data.radiobutton[2]=gtk_radio_button_new_with_label(group,strsql); // gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data.radiobutton[2]),TRUE); //Устанавливем активной кнопку gtk_signal_connect(GTK_OBJECT(data.radiobutton[2]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_radio2),&data); gtk_box_pack_start (GTK_BOX (hboxradio),data.radiobutton[2], TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vbox2), hboxradio, FALSE,FALSE, 0); gtk_widget_show_all(hboxradio); //Кнопки GtkTooltips *tooltips[KOL_F_KL]; sprintf(strsql,"F2 %s",gettext("Ввести")); data.knopka[FK2]=gtk_button_new_with_label(strsql); gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_knopka),&data); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2],TRUE,TRUE, 0); tooltips[FK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой проводки"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2); gtk_widget_show(data.knopka[FK2]); sprintf(strsql,"%sF2 %s",RFK,gettext("Корректировать")); data.knopka[SFK2]=gtk_button_new_with_label(strsql); gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_knopka),&data); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0); tooltips[SFK2]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2); gtk_widget_show(data.knopka[SFK2]); sprintf(strsql,"F3 %s",gettext("Удалить")); data.knopka[FK3]=gtk_button_new_with_label(strsql); gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_knopka),&data); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0); tooltips[FK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удалить выбранную запись"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3); gtk_widget_show(data.knopka[FK3]); sprintf(strsql,"%sF3 %s",RFK,gettext("Удалить")); data.knopka[SFK3]=gtk_button_new_with_label(strsql); gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_knopka),&data); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0); tooltips[SFK3]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Удалить все проводки"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3); gtk_widget_show(data.knopka[SFK3]); sprintf(strsql,"F4 %s",gettext("Проводки")); data.knopka[FK4]=gtk_button_new_with_label(strsql); gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_knopka),&data); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0); tooltips[FK4]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Выполнить все нужные проводки"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4); gtk_widget_show(data.knopka[FK4]); sprintf(strsql,"F5 %s",gettext("Печать")); data.knopka[FK5]=gtk_button_new_with_label(strsql); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_knopka),&data); tooltips[FK5]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка проводок"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5); gtk_widget_show(data.knopka[FK5]); sprintf(strsql,"F7 %s",gettext("Настройка")); data.knopka[FK7]=gtk_button_new_with_label(strsql); gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK7],TRUE,TRUE, 0); gtk_signal_connect(GTK_OBJECT(data.knopka[FK7]), "clicked",GTK_SIGNAL_FUNC(prov_xdk_knopka),&data); tooltips[FK7]=gtk_tooltips_new(); gtk_tooltips_set_tip(tooltips[FK7],data.knopka[FK7],gettext("Насторойка автоматического выполнения проводок"),NULL); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK7]),(gpointer)FK7); gtk_widget_show(data.knopka[FK7]); sprintf(strsql,"F10 %s",gettext("Выход")); data.knopka[FK10]=gtk_button_new_with_label(strsql); gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0); 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(prov_xdk_knopka),&data); gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10); gtk_widget_show(data.knopka[FK10]); gtk_widget_realize(data.window); gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR)); gtk_widget_grab_focus(data.knopka[FK10]); prov_xdk_create_list(&data); //gtk_window_maximize(GTK_WINDOW(data.window)); //gtk_window_fullscreen(GTK_WINDOW(data.window)); gtk_widget_show(data.window); gtk_main(); if(wpredok != NULL) gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR)); }
void OnDPress_rub(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, t_window *window) { column = column; tree_view = tree_view; char *tmp ; GtkTreeIter iter; /* Clear zone d affichage */ gtk_container_foreach(GTK_CONTAINER(window->pBox_aff_p), (GtkCallback)OnClear_HBox_p, window); GtkWidget *pTable = gtk_table_new(5, 5, TRUE); gtk_box_pack_start(GTK_BOX(window->pBox_aff_p), pTable, TRUE, TRUE, 0); /* nom de la rub 2clique */ gtk_tree_model_get_iter (GTK_TREE_MODEL(window->pTreeStore_p), &iter, path); gtk_tree_model_get(GTK_TREE_MODEL(window->pTreeStore_p), &iter, 0, &tmp, -1); if (!strcmp(tmp,"Contacts")) { GtkListStore* pListstore; GtkWidget *pListView; GtkCellRenderer *pCellRenderer; GtkTreeViewColumn *pColumn; GtkWidget *pScrollbar; pListstore = gtk_list_store_new(N_COLUMN, GDK_TYPE_PIXBUF, G_TYPE_STRING); /*** Insertion contact ***/ GdkPixbuf *pPixBufA; GtkTreeIter pIter; t_contact *p; p = window->contacts; while (p!= NULL){ gtk_list_store_append(pListstore, &pIter); pPixBufA = gdk_pixbuf_new_from_file(p->pic, NULL); gtk_list_store_set(pListstore, &pIter, PIX_COLUMN, pPixBufA, TEXT_COLUMN, p->name, -1); p = p->next; } /**************************/ /* Creation de la vue */ pListView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pListstore)); /* Creation de la premiere colonne */ pCellRenderer = gtk_cell_renderer_pixbuf_new(); pColumn = gtk_tree_view_column_new_with_attributes("B", pCellRenderer, "pixbuf", PIX_COLUMN, NULL); /* Ajout de la colonne à la vue */ gtk_tree_view_append_column(GTK_TREE_VIEW(pListView), pColumn); /* Creation de la deuxieme colonne */ pCellRenderer = gtk_cell_renderer_text_new(); pColumn = gtk_tree_view_column_new_with_attributes("login", pCellRenderer, "text", TEXT_COLUMN, NULL); /* Ajout de la colonne à la vue*/ gtk_tree_view_append_column(GTK_TREE_VIEW(pListView), pColumn); /* scrollbar */ pScrollbar = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(pScrollbar), pListView); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrollbar), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); /*BOUTONS*/ GtkWidget *pVBox = gtk_vbox_new(FALSE, 0); /* ajouter*/ GtkWidget *pBajouter = gtk_button_new_with_label("Ajouter"); g_signal_connect(G_OBJECT(pBajouter), "clicked", G_CALLBACK(OnButton_contact_ajouter), window); gtk_box_pack_start(GTK_BOX(pVBox), pBajouter, FALSE, FALSE, 0); /*supprimer*/ GtkWidget *pBsupprimer = gtk_button_new_with_label("Supprimer"); g_signal_connect(G_OBJECT(pBsupprimer), "clicked", G_CALLBACK(OnButton_contact_supprimer), window); gtk_box_pack_start(GTK_BOX(pVBox), pBsupprimer, FALSE, FALSE, 0); /*modifier*/ GtkWidget *pBmodifier = gtk_button_new_with_label("Modifier"); g_signal_connect(G_OBJECT(pBmodifier), "clicked", G_CALLBACK(OnButton_contact_modifier), window); gtk_box_pack_start(GTK_BOX(pVBox), pBmodifier, FALSE, FALSE, 0); /* mis dans la zone d affichage */ GtkWidget *label; label = gtk_label_new(" Gestion des contacts "); gtk_table_attach_defaults(GTK_TABLE(pTable), label, 1,4, 0,1); gtk_table_attach_defaults(GTK_TABLE(pTable), pScrollbar, 0,4, 1,5); gtk_table_attach_defaults(GTK_TABLE(pTable), pVBox, 4,5, 1,5); /*affichage */ gtk_widget_show_all(GTK_WIDGET(window->pHBox_p)); } if (!strcmp(tmp,"Apparence")) { GtkWidget *label; label = gtk_label_new(" Choisir un theme : "); gtk_table_attach_defaults(GTK_TABLE(pTable), label, 0,2, 0,1); GtkWidget *pbred = gtk_button_new_with_label("red"); gtk_table_attach_defaults(GTK_TABLE(pTable), pbred, 0,1, 1,2); g_signal_connect(G_OBJECT(pbred), "clicked", G_CALLBACK(OnButton_red), window); GtkWidget *pbdual = gtk_button_new_with_label("dual"); gtk_table_attach_defaults(GTK_TABLE(pTable), pbdual, 1,2, 1,2); g_signal_connect(G_OBJECT(pbdual), "clicked", G_CALLBACK(OnButton_dual), window); GtkWidget *pblogo = gtk_button_new_with_label("logo"); gtk_table_attach_defaults(GTK_TABLE(pTable), pblogo, 2,3, 1,2); g_signal_connect(G_OBJECT(pblogo), "clicked", G_CALLBACK(OnButton_logo), window); gtk_widget_show_all(GTK_WIDGET(window->pHBox_p)); } }
int main (int argc, char **argv) { int i; GtkWidget *window; GtkWidget *vbox; GtkWidget *combo_box; GtkWidget *sw; GtkWidget *tree_view; GtkWidget *button; gtk_init (&argc, &argv); /* Window and box */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 640, 480); g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); gtk_container_add (GTK_CONTAINER (window), vbox); /* Option menu contents */ combo_box = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), NO_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), SINGLE_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), MULTI_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), LAST_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), BORDER_EXPAND); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), ALL_EXPAND); gtk_box_pack_start (GTK_BOX (vbox), combo_box, FALSE, FALSE); /* Scrolled window and tree view */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE); tree_view = gtk_tree_view_new_with_model (create_model ()); gtk_container_add (GTK_CONTAINER (sw), tree_view); for (i = 0; i < 5; i++) { GtkTreeViewColumn *column; gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), i, "Header", gtk_cell_renderer_text_new (), "text", i, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), i); gtk_tree_view_column_set_resizable (column, TRUE); } /* Toggle button for long content row */ button = gtk_toggle_button_new_with_label ("Toggle long content row"); g_signal_connect (button, "toggled", G_CALLBACK (toggle_long_content_row), tree_view); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE); /* Set up option menu callback and default item */ g_signal_connect (combo_box, "changed", G_CALLBACK (combo_box_changed), tree_view); gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0); /* Done */ gtk_widget_show_all (window); gtk_main (); return 0; }
/** * crée la boite de dialogue initiale avec le GtkIconView * * \param nom de l'icône * * \return le nouveau nom de l'icône ou NULL * */ gchar * gsb_select_icon_create_window ( gchar *name_icon ) { GtkWidget *content_area; GtkWidget *hbox; GtkWidget *chooser_button; GtkWidget *scroll; GtkWidget *icon_view; gint result; devel_debug ( name_icon ); if ( new_icon && strlen ( new_icon ) > 0 ) g_free ( new_icon ); new_icon = g_strdup ( name_icon ); path_icon = g_path_get_dirname ( name_icon ); dialog = gtk_dialog_new_with_buttons ( _("Browse icons"), GTK_WINDOW ( run.window ), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); gtk_window_set_position ( GTK_WINDOW ( dialog ), GTK_WIN_POS_CENTER_ON_PARENT ); gtk_window_set_resizable ( GTK_WINDOW ( dialog ), TRUE ); bouton_OK = gtk_dialog_add_button (GTK_DIALOG ( dialog ), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT); gtk_widget_set_size_request ( dialog, 400, 450 ); content_area = GTK_DIALOG ( dialog ) -> vbox; /* création hbox pour GtkEntry répertoire et bouton sélection des répertoires */ hbox = gtk_hbox_new ( FALSE, 5); gtk_container_set_border_width ( GTK_CONTAINER( hbox ), 6 ); gtk_box_pack_start ( GTK_BOX ( content_area ), hbox, FALSE, FALSE, 5 ); /* création du GtkComboBoxEntry pour la saisie du répertoire */ entry_text = gsb_select_icon_create_entry_text ( name_icon ); gtk_box_pack_start ( GTK_BOX ( hbox ), entry_text, TRUE, TRUE, 0 ); /* création du bouton de sélection des répertoires */ chooser_button = gtk_button_new_with_label ( _("Browse") ); gtk_box_pack_start ( GTK_BOX ( hbox ), chooser_button, FALSE, FALSE, 0 ); /* création de la vue pour les icônes */ scroll = gtk_scrolled_window_new ( NULL, NULL); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW ( scroll ), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start ( GTK_BOX ( content_area ), scroll, TRUE, TRUE, 0 ); icon_view = gsb_select_icon_create_icon_view ( name_icon ); gtk_container_set_border_width ( GTK_CONTAINER( scroll ), 6 ); gtk_container_add ( GTK_CONTAINER ( scroll ), icon_view ); /* gestion des signaux */ g_signal_connect ( G_OBJECT ( icon_view ), "selection-changed", G_CALLBACK( gsb_select_icon_selection_changed ), NULL ); g_signal_connect ( G_OBJECT ( chooser_button ), "clicked", G_CALLBACK(gsb_select_icon_create_file_chooser), NULL ); g_signal_connect ( G_OBJECT( entry_text ), "changed", G_CALLBACK( gsb_select_icon_entry_text_changed ), NULL ); gtk_widget_show_all ( dialog ); result = gtk_dialog_run (GTK_DIALOG (dialog)); switch (result) { case GTK_RESPONSE_ACCEPT: devel_debug ( "réponse OK" ); break; default: devel_debug ( "réponse Non OK" ); if ( new_icon && strlen ( new_icon ) > 0 ) g_free ( new_icon ); new_icon = NULL; break; } gtk_widget_destroy (dialog); return new_icon; }