static SyncDialog *sync_dialog_new(GtkWidget *parent) { SyncDialog *sd; GtkWidget *dialog; GtkWidget *dialog1_vbox; GtkWidget *scrolledwindow2; GtkWidget *treeview2; GtkWidget *dialog1_action_area; GtkWidget *button8; GtkWidget *button7; GtkWidget *button6; GtkWidget *label; GtkWidget *hbox; GtkTreeViewColumn *column; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *cr_text, *cr_toggle; sd = g_new0(SyncDialog, 1); sd->sna = sync_dialog_netarea_new(); dialog = gtk_dialog_new(); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent)); gtk_window_set_title(GTK_WINDOW(dialog), "Network Updater"); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_window_set_icon(GTK_WINDOW(dialog), icon_cache_get_pixbuf("syncmanager.png")); gtk_window_set_default_size(GTK_WINDOW(dialog), 420, 260); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); dialog1_vbox = GTK_DIALOG(dialog)->vbox; gtk_box_set_spacing(GTK_BOX(dialog1_vbox), 5); gtk_container_set_border_width(GTK_CONTAINER(dialog1_vbox), 4); gtk_widget_show(dialog1_vbox); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new(LABEL_SYNC_DEFAULT); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), icon_cache_get_image("syncmanager.png"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); gtk_widget_show_all(hbox); gtk_box_pack_start(GTK_BOX(dialog1_vbox), sd->sna->vbox, TRUE, TRUE, 0); scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow2); gtk_box_pack_start(GTK_BOX(dialog1_vbox), scrolledwindow2, TRUE, TRUE, 0); gtk_widget_set_size_request(scrolledwindow2, -1, 200); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); store = gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER); model = GTK_TREE_MODEL(store); treeview2 = gtk_tree_view_new_with_model(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview2), FALSE); gtk_widget_show(treeview2); gtk_container_add(GTK_CONTAINER(scrolledwindow2), treeview2); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview2), column); cr_toggle = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, cr_toggle, FALSE); g_signal_connect(cr_toggle, "toggled", G_CALLBACK(sel_toggle), model); gtk_tree_view_column_add_attribute(column, cr_toggle, "active", 0); cr_text = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cr_text, TRUE); gtk_tree_view_column_add_attribute(column, cr_text, "markup", 1); populate_store(store); dialog1_action_area = GTK_DIALOG(dialog)->action_area; gtk_widget_show(dialog1_action_area); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog1_action_area), GTK_BUTTONBOX_END); button8 = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_widget_show(button8); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button8, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT); button7 = gtk_button_new_with_mnemonic("_Synchronize"); gtk_widget_show(button7); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button7, GTK_RESPONSE_ACCEPT); GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT); button6 = gtk_button_new_from_stock(GTK_STOCK_CLOSE); g_signal_connect(G_OBJECT(button6), "clicked", (GCallback) close_clicked, NULL); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button6, GTK_RESPONSE_ACCEPT); GTK_WIDGET_SET_FLAGS(button6, GTK_CAN_DEFAULT); sd->dialog = dialog; sd->button_sync = button7; sd->button_cancel = button8; sd->button_close = button6; sd->scroll_box = scrolledwindow2; sd->label = label; return sd; }
static void setup_options (void) { MatePanelAppletsManager *manager; GList *applet_list, *l; int i; int j; char *prefs_path = NULL; char *unique_key = NULL; gboolean unique_key_found = FALSE; gchar **dconf_paths; GtkListStore *model; GtkTreeIter iter; GtkCellRenderer *renderer; model = gtk_list_store_new (NUMBER_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); gtk_combo_box_set_model (GTK_COMBO_BOX (applet_combo), GTK_TREE_MODEL (model)); manager = g_object_new (PANEL_TYPE_APPLETS_MANAGER_DBUS, NULL); applet_list = MATE_PANEL_APPLETS_MANAGER_GET_CLASS (manager)->get_applets (manager); for (l = applet_list, i = 1; l; l = g_list_next (l), i++) { MatePanelAppletInfo *info = (MatePanelAppletInfo *)l->data; gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COLUMN_TEXT, g_strdup (mate_panel_applet_info_get_name (info)), COLUMN_ITEM, g_strdup (mate_panel_applet_info_get_iid (info)), -1); } g_list_free (applet_list); g_object_unref (manager); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (applet_combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (applet_combo), renderer, "text", COLUMN_TEXT, NULL); gtk_combo_box_set_active (GTK_COMBO_BOX (applet_combo), 0); setup_combo (size_combo, size_items, "Size", G_N_ELEMENTS (size_items)); setup_combo (orient_combo, orient_items, "Orientation", G_N_ELEMENTS (orient_items)); for (i = 0; !unique_key_found; i++) { unique_key = g_strdup_printf ("mate-panel-test-applet-%d", i); unique_key_found = TRUE; dconf_paths = mate_dconf_list_subdirs ("/tmp/", TRUE); for (j = 0; dconf_paths[j] != NULL; j++) { if (g_strcmp0(unique_key, dconf_paths[j]) == 0) { unique_key_found = FALSE; break; } } if (dconf_paths) g_strfreev (dconf_paths); } prefs_path = g_strdup_printf ("/tmp/%s/", unique_key); if (unique_key) g_free (unique_key); gtk_entry_set_text (GTK_ENTRY (prefs_path_entry), prefs_path); g_free (prefs_path); }
/******************************************************* * Create the Assistant *******************************************************/ static GtkWidget * csv_import_assistant_create (CsvImportInfo *info) { GtkBuilder *builder; GtkWidget *window; GtkWidget *box, *h_box; GtkWidget *button; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gchar *mnemonic_desc = NULL; builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "assistant-csv-account-import.glade", "num_hrows_adj"); gnc_builder_add_from_file (builder, "assistant-csv-account-import.glade", "CSV Account Import Assistant"); window = GTK_WIDGET(gtk_builder_get_object (builder, "CSV Account Import Assistant")); info->window = window; /* Set the assistant colors */ gnc_assistant_set_colors (GTK_ASSISTANT (info->window)); /* Load default settings */ load_settings (info); /* Enable buttons on all page. */ gtk_assistant_set_page_complete (GTK_ASSISTANT(window), GTK_WIDGET(gtk_builder_get_object(builder, "start_page")), TRUE); gtk_assistant_set_page_complete (GTK_ASSISTANT(window), GTK_WIDGET(gtk_builder_get_object(builder, "file_page")), FALSE); gtk_assistant_set_page_complete (GTK_ASSISTANT(window), GTK_WIDGET(gtk_builder_get_object(builder, "import_tree_page")), TRUE); gtk_assistant_set_page_complete (GTK_ASSISTANT(window), GTK_WIDGET(gtk_builder_get_object(builder, "end_page")), FALSE); gtk_assistant_set_page_complete (GTK_ASSISTANT(window), GTK_WIDGET(gtk_builder_get_object(builder, "summary_page")), TRUE); /* Start Page */ /* File chooser Page */ info->file_chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN); g_signal_connect (G_OBJECT(info->file_chooser), "file-activated", G_CALLBACK(csv_import_file_chooser_confirm_cb), info); button = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_widget_set_size_request (button, 100, -1); gtk_widget_show (button); h_box = gtk_hbox_new (TRUE, 0); gtk_box_pack_start (GTK_BOX(h_box), button, FALSE, FALSE, 0); gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(info->file_chooser), h_box); g_signal_connect (G_OBJECT(button), "clicked", G_CALLBACK(csv_import_file_chooser_confirm_cb), info); box = GTK_WIDGET(gtk_builder_get_object(builder, "file_page")); gtk_box_pack_start (GTK_BOX(box), info->file_chooser, TRUE, TRUE, 6); gtk_widget_show (info->file_chooser); /* Account Tree Page */ info->header_row_spin = GTK_WIDGET(gtk_builder_get_object (builder, "num_hrows")); info->tree_view = GTK_WIDGET(gtk_builder_get_object (builder, "treeview")); /* Comma Separated file default */ info->regexp = g_string_new (""); create_regex (info->regexp, ","); /* create model and bind to view */ info->store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model (GTK_TREE_VIEW(info->tree_view), GTK_TREE_MODEL(info->store)); #define CREATE_COLUMN(description,column_id) \ renderer = gtk_cell_renderer_text_new (); \ mnemonic_desc = mnemonic_escape (_(description)); \ column = gtk_tree_view_column_new_with_attributes (mnemonic_desc, renderer, "text", column_id, NULL); \ gtk_tree_view_column_add_attribute (column, renderer, "background", ROW_COLOR); \ gtk_tree_view_column_set_resizable (column, TRUE); \ gtk_tree_view_append_column (GTK_TREE_VIEW(info->tree_view), column); \ g_free (mnemonic_desc); CREATE_COLUMN ("type", TYPE); CREATE_COLUMN ("full_name", FULL_NAME); CREATE_COLUMN ("name", NAME); CREATE_COLUMN ("code", CODE); CREATE_COLUMN ("description", DESCRIPTION); CREATE_COLUMN ("color", COLOR); CREATE_COLUMN ("notes", NOTES); CREATE_COLUMN ("commoditym", COMMODITYM); CREATE_COLUMN ("commodityn", COMMODITYN); CREATE_COLUMN ("hidden", HIDDEN); CREATE_COLUMN ("tax", TAX); CREATE_COLUMN ("place_holder", PLACE_HOLDER); /* Finish Page */ info->finish_label = GTK_WIDGET(gtk_builder_get_object (builder, "end_page")); /* Summary Page */ info->summary_label = GTK_WIDGET(gtk_builder_get_object (builder, "summary_label")); info->summary_error_view = GTK_WIDGET(gtk_builder_get_object (builder, "summary_error_view")); g_signal_connect (G_OBJECT(window), "destroy", G_CALLBACK(csv_import_assistant_destroy_cb), info); gnc_restore_window_size (GNC_PREFS_GROUP, GTK_WINDOW(info->window)); gtk_builder_connect_signals (builder, info); g_object_unref (G_OBJECT(builder)); return window; }
void clist_init(void) { GtkTreeView *view = GTK_TREE_VIEW(clist_wnd); GtkTreeModel *model = GTK_TREE_MODEL(list); GtkCellRenderer *renderer; GtkTreeSelection *selection; gint i; list = gtk_list_store_new(CLIST_NCOLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER ); model = GTK_TREE_MODEL(list); gtk_tree_view_set_model(view, model); gtk_tree_view_set_headers_visible(view, TRUE); gtk_tree_view_set_headers_clickable(view, TRUE); gtk_tree_view_set_rules_hint(view, FALSE); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_insert_column_with_attributes(view, -1, "", renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"), renderer, "text", COLUMN_NAME, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"), renderer, "text", COLUMN_TYPE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"), renderer, "text", COLUMN_SIZE, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(view, -1, _("Date"), renderer, "text", COLUMN_DATE, NULL); for (i = 0; i < CLIST_NVCOLS; i++) { GtkTreeViewColumn *col; col = gtk_tree_view_get_column(view, i); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_clickable(col, TRUE); g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view); } selection = gtk_tree_view_get_selection(view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_selection_changed), NULL); }
/*------------------------------main-----------------------------------*/ int main(int argc, char const *argv[]) { debug("main"); /*command line args*/ if(argc > 1) { if(!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) { printf("%s\n", HELPMSG); return 0; } if(!strcmp(argv[1], "-v") || !strcmp(argv[1], "--version")) { printf("%s\n", VERSION); return 0; } printf("Unknown args [%s], continue to GUI...\n", argv[1]); } /*gtk start*/ gtk_init(NULL, NULL); debug("gtk init"); /*init char*/ mark = malloc(2); word = malloc(MAX_LENGTH); /* init curl */ curl_global_init(CURL_GLOBAL_ALL); debug("curl init"); /*window*/ window = (GtkWidget *)gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_decorated(GTK_WINDOW(window), FALSE); gtk_window_set_icon_name(GTK_WINDOW(window),"accessories-dictionary"); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_gravity(GTK_WINDOW(window), GDK_GRAVITY_CENTER); g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(window, "key_press_event", G_CALLBACK(checkEsc), NULL); debug("window"); /* entry */ make_entry(); /*button*/ make_button1(); /*assemble*/ vbox1 = gtk_vbox_new(FALSE, 2); /*h**o, pad*/ hbox1 = gtk_hbox_new(FALSE, 2); hboxmain = gtk_hbox_new(FALSE, 5); gtk_widget_set_no_show_all(hboxmain, TRUE); gtk_container_add((GtkContainer *)window, vbox1); gtk_container_add((GtkContainer *)vbox1, hbox1); gtk_container_add((GtkContainer *)vbox1, hboxmain); gtk_container_add((GtkContainer *)hbox1, entry); gtk_container_add((GtkContainer *)hbox1, button1); gtk_box_set_child_packing(GTK_BOX(hbox1), GTK_WIDGET(entry), 1,/*expand*/ 1,/*fill*/ 2,/*pad*/ GTK_PACK_START/*pack type*/ ); gtk_box_set_child_packing(GTK_BOX(vbox1), hbox1, 0, 0, 1, GTK_PACK_START); gtk_box_set_child_packing(GTK_BOX(hbox1), button1, 0, 0, 1, GTK_PACK_START); debug("assemble initial view"); gtk_widget_show_all(window); debug("start the show"); #ifdef MinGW /*volatino*/ volatino = (GtkWidget *) gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_decorated(GTK_WINDOW(volatino), FALSE); gtk_widget_set_size_request(volatino, 450, 24); gtk_window_set_icon_name(GTK_WINDOW(volatino),"accessories-dictionary"); gtk_window_set_position(GTK_WINDOW(volatino), GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_gravity(GTK_WINDOW(volatino), GDK_GRAVITY_CENTER); gtk_widget_show(volatino); gtk_widget_destroy(volatino); #endif /*auto-completion*/ store = gtk_list_store_new(1, G_TYPE_STRING); model = GTK_TREE_MODEL(store); /*completion model*/ completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, model); gtk_entry_completion_set_text_column(completion, 0); /*completion style*/ gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_completion_set_inline_selection(completion, TRUE); /*commands*/ append_list(store, ":about"); append_list(store, ":help"); /*connect completion*/ gtk_entry_set_completion(GTK_ENTRY(entry), completion); debug("completion"); debug("gtk main entering"); gtk_main(); /*gtk end*/ debug("Sure."); /*clean up*/ if(curl_handle) curl_easy_cleanup(curl_handle); curl_global_cleanup(); free(s); free(rslt); free(mark); free(word); if(searchStr) free(searchStr); return 0; }
static GtkWidget * servlist_open_networks (void) { GtkWidget *servlist; GtkWidget *vbox1; GtkWidget *label2; GtkWidget *table1; GtkWidget *label3; GtkWidget *label4; GtkWidget *label5; GtkWidget *label6; GtkWidget *label7; GtkWidget *entry1; GtkWidget *entry2; GtkWidget *entry3; GtkWidget *entry4; GtkWidget *entry5; GtkWidget *vbox2; GtkWidget *label1; GtkWidget *table4; GtkWidget *scrolledwindow3; GtkWidget *treeview_networks; GtkWidget *checkbutton_skip; GtkWidget *vbuttonbox2; GtkWidget *button_add; GtkWidget *button_remove; GtkWidget *button_edit; GtkWidget *button_sort; GtkWidget *button_connect; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *renderer; servlist = mg_create_generic_tab(_("Network List"), _("conspire: Networks"), FALSE, TRUE, servlist_close_cb, NULL, 640, 480, &vbox1, NULL); label2 = bold_label (_("User Information")); gtk_box_pack_start (GTK_BOX (vbox1), label2, FALSE, FALSE, 0); table1 = gtk_table_new (5, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (table1), 8); gtk_table_set_row_spacings (GTK_TABLE (table1), 2); gtk_table_set_col_spacings (GTK_TABLE (table1), 4); label3 = gtk_label_new_with_mnemonic (_("_Nick name:")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label4 = gtk_label_new (_("Second choice:")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); label5 = gtk_label_new (_("Third choice:")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); label6 = gtk_label_new_with_mnemonic (_("_User name:")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); label7 = gtk_label_new_with_mnemonic (_("Rea_l name:")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); entry_nick1 = entry1 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry1), prefs.nick1); gtk_widget_show (entry1); gtk_table_attach (GTK_TABLE (table1), entry1, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_nick2 = entry2 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry2), prefs.nick2); gtk_widget_show (entry2); gtk_table_attach (GTK_TABLE (table1), entry2, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_nick3 = entry3 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry3), prefs.nick3); gtk_widget_show (entry3); gtk_table_attach (GTK_TABLE (table1), entry3, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_guser = entry4 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry4), prefs.username); gtk_widget_show (entry4); gtk_table_attach (GTK_TABLE (table1), entry4, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_greal = entry5 = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (entry5), prefs.realname); gtk_widget_show (entry5); gtk_table_attach (GTK_TABLE (table1), entry5, 1, 2, 4, 5, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0); label1 = bold_label (_("Networks")); gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0); table4 = gtk_table_new (2, 2, FALSE); gtk_widget_show (table4); gtk_box_pack_start (GTK_BOX (vbox2), table4, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (table4), 8); gtk_table_set_row_spacings (GTK_TABLE (table4), 2); gtk_table_set_col_spacings (GTK_TABLE (table4), 3); scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow3); gtk_table_attach (GTK_TABLE (table4), scrolledwindow3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_SHADOW_IN); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN); model = GTK_TREE_MODEL (store); networks_tree = treeview_networks = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_widget_show (treeview_networks); gtk_container_add (GTK_CONTAINER (scrolledwindow3), treeview_networks); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_networks), FALSE); renderer = gtk_cell_renderer_text_new (); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (servlist_celledit_cb), model); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (treeview_networks), -1, 0, renderer, "text", 0, "editable", 1, NULL); checkbutton_skip = gtk_check_button_new_with_mnemonic (_("Skip network list on startup")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_skip), prefs.skip_serverlist); g_signal_connect (G_OBJECT (checkbutton_skip), "toggled", G_CALLBACK (no_servlist), 0); gtk_widget_show (checkbutton_skip); gtk_table_attach (GTK_TABLE (table4), checkbutton_skip, 0, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); vbuttonbox2 = gtk_vbutton_box_new (); gtk_box_set_spacing (GTK_BOX (vbuttonbox2), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox2), GTK_BUTTONBOX_START); gtk_widget_show (vbuttonbox2); gtk_table_attach (GTK_TABLE (table4), vbuttonbox2, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); button_add = gtk_button_new_from_stock ("gtk-add"); g_signal_connect (G_OBJECT (button_add), "clicked", G_CALLBACK (servlist_addnet_cb), networks_tree); gtk_widget_show (button_add); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_add); GTK_WIDGET_SET_FLAGS (button_add, GTK_CAN_DEFAULT); button_remove = gtk_button_new_from_stock ("gtk-remove"); g_signal_connect (G_OBJECT (button_remove), "clicked", G_CALLBACK (servlist_deletenet_cb), 0); gtk_widget_show (button_remove); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_remove); GTK_WIDGET_SET_FLAGS (button_remove, GTK_CAN_DEFAULT); button_edit = gtk_button_new_with_mnemonic (_("_Edit...")); g_signal_connect (G_OBJECT (button_edit), "clicked", G_CALLBACK (servlist_edit_cb), 0); gtk_widget_show (button_edit); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_edit); GTK_WIDGET_SET_FLAGS (button_edit, GTK_CAN_DEFAULT); button_sort = gtk_button_new_with_mnemonic (_("_Sort")); add_tip (button_sort, _("Sorts the network list in alphabetical order. " "Use SHIFT-UP and SHIFT-DOWN keys to move a row.")); g_signal_connect (G_OBJECT (button_sort), "clicked", G_CALLBACK (servlist_sort), 0); gtk_widget_show (button_sort); gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_sort); GTK_WIDGET_SET_FLAGS (button_sort, GTK_CAN_DEFAULT); button_connect = gtkutil_button (vbuttonbox2, GTK_STOCK_CONNECT, NULL, servlist_connect_cb, NULL, _("C_onnect")); GTK_WIDGET_SET_FLAGS (button_connect, GTK_CAN_DEFAULT); gtk_label_set_mnemonic_widget (GTK_LABEL (label3), entry1); gtk_label_set_mnemonic_widget (GTK_LABEL (label6), entry4); gtk_label_set_mnemonic_widget (GTK_LABEL (label7), entry5); gtk_widget_grab_focus (networks_tree); return servlist; }
/*************************** * * * Encodings dialog window * * * **************************/ void gxi_edit_encodings_clicked_cb (GtkButton *button, GncXmlImportData *data) { GtkBuilder *builder; GtkWidget *dialog; GtkListStore *list_store; GtkTreeStore *tree_store; GtkTreeIter iter, parent, *parent_ptr; GList *encodings_bak, *enc_iter; const gchar *encoding; system_encoding_type *system_enc; gpointer enc_ptr; gint i, j; builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "assistant-xml-encoding.glade", "encodings_dialog"); dialog = GTK_WIDGET(gtk_builder_get_object (builder, "encodings_dialog")); data->encodings_dialog = dialog; // Set the style context for this assistant so it can be easily manipulated with css gnc_widget_set_style_context (GTK_WIDGET(dialog), "GncAssistXmlEncoding"); gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, data); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (data->assistant)); data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view")); data->custom_enc_entry = GTK_WIDGET(gtk_builder_get_object (builder, "custom_enc_entry")); /* set up selected encodings list */ data->selected_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "selected_encs_view")); list_store = gtk_list_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); for (enc_iter = data->encodings; enc_iter; enc_iter = enc_iter->next) { encoding = g_quark_to_string (GPOINTER_TO_UINT (enc_iter->data)); gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, ENC_COL_STRING, encoding, ENC_COL_QUARK, enc_iter->data, -1); } gtk_tree_view_insert_column_with_attributes ( data->selected_encs_view, -1, NULL, gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL); gtk_tree_view_set_model (data->selected_encs_view, GTK_TREE_MODEL (list_store)); g_object_unref (list_store); /* set up system encodings list */ data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view")); tree_store = gtk_tree_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); for (i = 0, system_enc = system_encodings; i < n_system_encodings; i++, system_enc++) { if (i == 0) { /* first system encoding */ parent_ptr = NULL; } else { parent_ptr = &iter; for (j = 0; j < system_enc->parent; j++) if (gtk_tree_model_iter_parent (GTK_TREE_MODEL (tree_store), &parent, &iter)) { /* go up one level */ iter = parent; } else { /* no parent to toplevel element */ parent_ptr = NULL; } } if (system_enc->encoding) enc_ptr = GUINT_TO_POINTER (g_quark_from_string (system_enc->encoding)); else enc_ptr = NULL; gtk_tree_store_append (tree_store, &iter, parent_ptr); gtk_tree_store_set (tree_store, &iter, ENC_COL_STRING, gettext (system_enc->text), ENC_COL_QUARK, enc_ptr, -1); } gtk_tree_view_insert_column_with_attributes ( data->available_encs_view, -1, NULL, gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL); gtk_tree_view_set_model (data->available_encs_view, GTK_TREE_MODEL (tree_store)); g_object_unref (tree_store); /* run the dialog */ encodings_bak = g_list_copy (data->encodings); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { g_list_free (encodings_bak); if (!g_list_find (data->encodings, GUINT_TO_POINTER (data->default_encoding))) { /* choose top level encoding then */ data->default_encoding = GPOINTER_TO_UINT (data->encodings->data); } /* update whole page */ gxi_check_file (data); gxi_update_default_enc_combo (data); gxi_update_string_box (data); gxi_update_conversion_forward (data); } else { g_list_free (data->encodings); data->encodings = encodings_bak; } g_object_unref(G_OBJECT(builder)); gtk_widget_destroy (dialog); data->encodings_dialog = NULL; }
void * userlist_create_model (void) { return gtk_list_store_new (5, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, GDK_TYPE_COLOR); }
void gui_create_tasks(GUI *appGUI) { GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table; GtkWidget *label; GtkWidget *top_scrolledwindow; GtkWidget *hseparator; GtkWidget *close_button; GtkCellRenderer *renderer; GtkWidget *top_viewport; GtkWidget *bottom_viewport; GtkTextBuffer *text_buffer; GError *error = NULL; GtkActionGroup *action_group = NULL; gchar tmpbuf[BUFFER_SIZE]; const gchar *ui_info = " <toolbar name=\"toolbar\">\n" " <toolitem name=\"add\" action=\"add\" />\n" " <toolitem name=\"delete\" action=\"delete\" />\n" " <separator name=\"sep1\" />\n" " <toolitem name=\"edit\" action=\"edit\" />\n" " </toolbar>\n"; GtkActionEntry entries[] = { { "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL }, { "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL }, { "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL }, }; guint n_entries = G_N_ELEMENTS (entries); appGUI->tsk->filter_index = 0; vbox1 = gtk_vbox_new (FALSE, 1); gtk_widget_show (vbox1); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8); sprintf(tmpbuf, "<b>%s</b>", _("Tasks")); gui_add_to_notebook (vbox1, tmpbuf, appGUI); appGUI->tsk->vbox = GTK_BOX(vbox1); /*-------------------------------------------------------------------------------------*/ action_group = gtk_action_group_new ("_actions"); gtk_action_group_add_actions (action_group, entries, n_entries, NULL); gtk_action_group_set_sensitive(action_group, TRUE); appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0); g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI); if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) { g_message ("building toolbar failed: %s", error->message); g_error_free (error); } gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget); gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS); gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips); /*-------------------------------------------------------------------------------------*/ /* assign callbacks */ g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked", G_CALLBACK(tasks_add_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked", G_CALLBACK(tasks_edit_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked", G_CALLBACK(tasks_remove_item_cb), appGUI); /*-------------------------------------------------------------------------------------*/ gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE); gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); table = gtk_table_new (1, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "<b>%s:</b>", _("Category filter")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); appGUI->tsk->cf_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->cf_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE); GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(appGUI->tsk->cf_combobox, "changed", G_CALLBACK(category_filter_cb), appGUI); g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus", G_CALLBACK(category_combo_box_focus_cb), NULL); appGUI->tsk->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->tsk->n_items_label); gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); /*-------------------------------------------------------------------------------------*/ appGUI->tsk->tasks_paned = gtk_vpaned_new(); gtk_widget_show (appGUI->tsk->tasks_paned); gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999); gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0); top_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (top_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE); gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE); top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (top_scrolledwindow); gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter), (GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb, appGUI, NULL); appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter)); appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint); gtk_widget_show (appGUI->tsk->tasks_list); GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED])); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL])); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event", G_CALLBACK(list_dbclick_cb), appGUI); appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list)); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed", G_CALLBACK(tasks_item_selected), appGUI); /* create columns */ renderer = gtk_cell_renderer_toggle_new(); appGUI->tsk->tasks_columns[COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"), renderer, "active", COLUMN_DONE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DONE]); g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"), renderer, "text", COLUMN_DUE_DATE, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE], config.visible_due_date_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_DUE_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_START_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"), renderer, "text", COLUMN_PRIORITY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_PRIORITY], config.visible_priority_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_PRIORITY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", COLUMN_CATEGORY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_CATEGORY], config.visible_category_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_CATEGORY]); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_renderer_set_fixed_size(renderer, 0, -1); appGUI->tsk->tasks_columns[COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"), renderer, "text", COLUMN_SUMMARY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_SUMMARY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", COLUMN_DESCRIPTION, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_COLOR], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_COLOR]); /* configure list options */ gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE); /* configure sorting */ gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0, (GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DUE_DATE, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_PRIORITY, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DONE, config.tasks_sorting_order); /*----------------------------------------------------------------------------*/ bottom_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (bottom_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE); gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0); gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2); appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0); gtk_widget_show(appGUI->tsk->panel_hbox); sprintf(tmpbuf, "%s:", _("Task details")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0); if (config.default_stock_icons) { close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE); } else { close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE); } GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE); gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL); gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (panel_close_desc_cb), appGUI); appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (appGUI->tsk->panel_scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_desc_textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_widget_show (appGUI->tsk->tasks_desc_textview); gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview)); gtk_text_buffer_create_tag (text_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL); appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font", "font", (gchar *) config.task_info_font, NULL); }
static void gb_book_links_construct (GbBookLinks *self) { GbBookLinksPrivate *priv; GtkWidget *swindow; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; priv = self->priv; swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow), GTK_SHADOW_IN); /* Create tree view */ priv->tree_view = gtk_tree_view_new (); gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (priv->tree_view), TRUE); g_signal_connect_swapped (priv->tree_view, "row-activated", G_CALLBACK (schedule_emit_link_activated), self); gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (priv->tree_view), FALSE); gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (priv->tree_view), 20); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE); gtk_container_add (GTK_CONTAINER (swindow), priv->tree_view); gtk_box_pack_start (GTK_BOX (self), swindow, TRUE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (self)); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), column); renderer = (GtkCellRenderer *) g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, "weight", PANGO_WEIGHT_BOLD, "xpad", 10, NULL); gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, TRUE); gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer, "markup", BOOK_LINKS_COLUMN_MARKUP, NULL); renderer = gd_styled_text_renderer_new (); gd_styled_text_renderer_add_class (GD_STYLED_TEXT_RENDERER (renderer), "dim-label"); g_object_set (renderer, "max-width-chars", 12, "scale", PANGO_SCALE_SMALL, "xalign", 1.0, "xpad", 10, NULL); gtk_tree_view_column_pack_end (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE); /* gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer, "text", BOOK_LINKS_COLUMN_LABEL, NULL); */ priv->model = (GtkTreeModel *)gtk_list_store_new (BOOK_LINKS_COLUMN_N, G_TYPE_STRING, G_TYPE_STRING); }
static void pkg_channel_page_init (PkgChannelPage *page) { PkgChannelPagePrivate *priv; gchar *path; GtkTreeViewColumn *column; GtkCellRenderer *cell; ENTRY; page->priv = G_TYPE_INSTANCE_GET_PRIVATE(page, PKG_TYPE_CHANNEL_PAGE, PkgChannelPagePrivate); priv = page->priv; #define EXTRACT_WIDGET(_n, _w) \ G_STMT_START { \ priv->_w = (gpointer)gtk_builder_get_object(priv->builder, _n); \ } G_STMT_END path = pkg_path_for_data("ui", "pkg-channel-page.ui", NULL); priv->builder = gtk_builder_new(); gtk_builder_add_from_file(priv->builder, path, NULL); g_free(path); EXTRACT_WIDGET("page-label", page_label); EXTRACT_WIDGET("channel-page", container); EXTRACT_WIDGET("target", target); EXTRACT_WIDGET("args", args); EXTRACT_WIDGET("working-dir", working_dir); EXTRACT_WIDGET("env", env); EXTRACT_WIDGET("pid", pid); EXTRACT_WIDGET("kill-pid", kill_pid); EXTRACT_WIDGET("exit-status", exit_status); EXTRACT_WIDGET("muted", muted); EXTRACT_WIDGET("sources", sources); gtk_widget_unparent(priv->container); gtk_container_add(GTK_CONTAINER(page), priv->container); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("ID")); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->sources), column); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cell, TRUE); gtk_tree_view_column_add_attribute(column, cell, "text", COLUMN_IDSTR); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Plugin")); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->sources), column); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cell, TRUE); gtk_tree_view_column_add_attribute(column, cell, "text", COLUMN_PLUGIN); priv->model = gtk_list_store_new(3, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->sources), GTK_TREE_MODEL(priv->model)); EXIT; }
int handle_lobby(GladeXML* g_lobby_xml, GladeXML* g_table_info_xml, GladeXML* g_lobby_tabs_xml, GladeXML* g_cashier_button_xml, GladeXML* g_clock_xml, GtkLayout* screen, int init) { static int s_selected_table = 0; s_screen = screen; if(init) { textdomain ("poker2d"); int i; s_lobby_xml = g_lobby_xml; s_lobby_window = gui_get_widget(g_lobby_xml, "lobby_window"); g_assert(s_lobby_window); set_nil_draw_focus(s_lobby_window); if(screen) gtk_layout_put(screen, s_lobby_window, 0, 0); s_notebook = GTK_NOTEBOOK(gui_get_widget(g_lobby_xml, "notebook")); g_assert(s_notebook); for(i = 0; i < VARIANTS_COUNT; i++) { char tmp[32]; s_variants_store[i] = gtk_list_store_new(12, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING ); snprintf(tmp, 32, "%s_treeview", s_variants_names[i]); GtkTreeView* treeview = GTK_TREE_VIEW(gui_get_widget(g_lobby_xml, tmp)); GtkTreeSelection* selection = gtk_tree_view_get_selection(treeview); g_signal_connect(selection, "changed", (GCallback)on_lobby_list_treeview_selection_changed, &s_selected_table); s_variants_selection[i] = selection; g_signal_connect(treeview, "row-activated", (GCallback)on_row_activated, &s_selected_table); gtk_tree_view_set_rules_hint(treeview, TRUE); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(s_variants_store[i])); GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new(); #define TABLE_COLUMN_ID 0 #define TABLE_COLUMN_MY 1 { GtkTreeViewColumn* column = gtk_tree_view_column_new(); GtkCellRenderer* pixbuf_renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_append_column(treeview, column); gtk_tree_view_column_set_title(column, gettext("My") ); gtk_tree_view_column_pack_start(column, pixbuf_renderer, TRUE); gtk_tree_view_column_add_attribute(column, pixbuf_renderer, "pixbuf", TABLE_COLUMN_MY); } { GError* error = 0; gchar* filename; filename = glade_xml_relative_file(g_lobby_xml, "table_bullet_my.png"); if(g_file_test(filename, G_FILE_TEST_EXISTS)) { pixbuf_table_my = gdk_pixbuf_new_from_file(filename, &error); if(pixbuf_table_my == NULL) { GtkIconTheme* theme = gtk_icon_theme_get_default(); error = 0; pixbuf_table_my = gtk_icon_theme_load_icon(theme, "stock_book_open", 16, 0, &error); if (!pixbuf_table_my) { g_warning ("Couldn't load icon: %s", error->message); } } } g_free(filename); } #define SET_COLUMN(TITLE, INDEX) \ { \ GtkTreeViewColumn* column = gtk_tree_view_column_new(); \ gtk_tree_view_append_column(treeview, column); \ gtk_tree_view_column_set_title(column, TITLE); \ gtk_tree_view_column_pack_start(column, text_renderer, TRUE); \ gtk_tree_view_column_add_attribute(column, text_renderer, "text", INDEX); \ } #define TABLE_COLUMN_NAME 2 SET_COLUMN( gettext("Name"), TABLE_COLUMN_NAME); #define TABLE_COLUMN_STRUCTURE 3 SET_COLUMN( gettext("Structure"), TABLE_COLUMN_STRUCTURE); #define TABLE_COLUMN_SEATS 4 SET_COLUMN( gettext("Seats"), TABLE_COLUMN_SEATS); #define TABLE_COLUMN_AVG_POT 5 SET_COLUMN( gettext("Avg.pot"), TABLE_COLUMN_AVG_POT); #define TABLE_COLUMN_HANDS_PER_HOUR 6 SET_COLUMN( gettext("Hands/h"), TABLE_COLUMN_HANDS_PER_HOUR); #define TABLE_COLUMN_PERCENT_FLOP 7 SET_COLUMN( gettext("Flop%"), TABLE_COLUMN_PERCENT_FLOP); #define TABLE_COLUMN_PLAYING 8 SET_COLUMN( gettext("Playing"), TABLE_COLUMN_PLAYING); #define TABLE_COLUMN_OBSERVING 9 #define TABLE_COLUMN_WAITING 10 #define TABLE_COLUMN_TIMEOUT 11 #undef SET_COLUMN } s_players_label = GTK_LABEL(gui_get_widget(g_lobby_xml, "players_label")); s_tables_label = GTK_LABEL(gui_get_widget(g_lobby_xml, "tables_label")); GUI_BRANCH(g_lobby_xml, on_all_radio_clicked); GUI_BRANCH(g_lobby_xml, on_money_one_radio_clicked); GUI_BRANCH(g_lobby_xml, on_money_two_radio_clicked); s_table_info_window = gui_get_widget(g_table_info_xml, "table_info_window"); g_assert(s_table_info_window); if(screen) gtk_layout_put(screen, s_table_info_window, 0, 0); { s_players_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); GtkTreeView* treeview = GTK_TREE_VIEW(gui_get_widget(g_table_info_xml, "players_treeview")); gtk_tree_view_set_rules_hint(treeview, TRUE); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(s_players_store)); GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new(); #define PLAYERS_COLUMN_NAME 0 { GtkTreeViewColumn* column = gtk_tree_view_column_new(); gtk_tree_view_append_column(treeview, column); gtk_tree_view_column_set_title(column, gettext("Players") ); gtk_tree_view_column_pack_start(column, text_renderer, TRUE); gtk_tree_view_column_add_attribute(column, text_renderer, "text", 0); } #define PLAYERS_COLUMN_CHIPS 1 { GtkTreeViewColumn* column = gtk_tree_view_column_new(); gtk_tree_view_append_column(treeview, column); gtk_tree_view_column_set_title(column, gettext("Chips") ); gtk_tree_view_column_pack_start(column, text_renderer, TRUE); gtk_tree_view_column_add_attribute(column, text_renderer, "text", 1); } #define PLAYERS_COLUMN_FLAG 2 } s_go_to_label = GTK_LABEL(glade_xml_get_widget(g_table_info_xml, "label_go_to")); s_go_to_button = GTK_BUTTON(glade_xml_get_widget(g_table_info_xml, "button_go_to")); g_signal_connect(GTK_OBJECT(s_go_to_button), "clicked", (GtkSignalFunc)on_go_to_clicked, &s_selected_table); s_lobby_tabs_window = gui_get_widget(g_lobby_tabs_xml, "lobby_tabs_window"); g_assert(s_lobby_tabs_window); gtk_widget_set_size_request(s_lobby_tabs_window, gui_width(screen), -1); if(screen) gtk_layout_put(screen, s_lobby_tabs_window, 0, 0); GUI_BRANCH(g_lobby_tabs_xml, on_table_toggled); GUI_BRANCH(g_lobby_tabs_xml, on_tourney_toggled); s_cashier_button_window = gui_get_widget(g_cashier_button_xml, "cashier_button_window"); g_assert(s_cashier_button_window); if(screen) gtk_layout_put(screen, s_cashier_button_window, 0, 0); s_cashier_button = GTK_BUTTON(gui_get_widget(g_cashier_button_xml, "cashier_button")); g_assert(s_cashier_button); GUI_BRANCH(g_cashier_button_xml, on_cashier_button_pressed); s_clock_window = gui_get_widget(g_clock_xml, "clock_window"); g_assert(s_clock_window); if(screen) gtk_layout_put(screen, s_clock_window, 0, 0); s_clock_label = gui_get_widget(g_clock_xml, "clock_label"); close_lobby(); } char* tag = get_string(); if(!strcmp(tag, "show")) { g_lobby_tab_state = lobby; { char* label = get_string(); gtk_button_set_label(s_cashier_button, label); g_free(label); } if (screen != NULL || s_lobby_shown == 0) { // // calculate windows position // int screen_width = gui_width(screen); int screen_height = gui_height(screen); int top_left_x = (screen_width - 1000) / 2; int top_left_y = (screen_height - 450) / 2; { static position_t position; position.x = screen_width - 610; position.y = top_left_y; gui_place(s_lobby_window, &position, screen); } { static position_t position; position.x = top_left_x; position.y = top_left_y; gui_place(s_table_info_window, &position, screen); } { static position_t position; position.x = 0; position.y = 33; gui_place(s_lobby_tabs_window, &position, screen); } { static position_t position; position.x = top_left_x; position.y = top_left_y + 435; gui_place(s_cashier_button_window, &position, screen); } s_lobby_shown = 1; } { gui_bottom_right(s_clock_window, screen); } s_selected_table = 0; { char* type = get_string(); if(!strcmp(type, "holdem")) { gtk_notebook_set_current_page(s_notebook, VARIANT_HOLDEM); } else if(!strcmp(type, "omaha")) { gtk_notebook_set_current_page(s_notebook, VARIANT_OMAHA); } else if(!strcmp(type, "omaha8")) { gtk_notebook_set_current_page(s_notebook, VARIANT_OMAHA8); } else if(!strcmp(type, "7stud")) { gtk_notebook_set_current_page(s_notebook, VARIANT_7STUD); } GtkToggleButton* button = GTK_TOGGLE_BUTTON(gui_get_widget(g_lobby_tabs_xml, type)); g_assert(button); gtk_toggle_button_set_active(button, TRUE); g_free(type); } { char* currency_serial = get_string(); char* button; GtkWidget* radio; if(!strcmp(currency_serial, "money_two")) { button = "money_two_radio"; } else if(!strcmp(currency_serial, "money_one")) { button = "money_one_radio"; } else { button = "all_radio"; } { //moneyone GtkWidget* sl = gui_get_widget(g_lobby_xml, "money_one_radio"); char* label = get_string(); gtk_button_set_label(GTK_BUTTON(sl), label); g_free(label); } { //moneytwo GtkWidget* sl = gui_get_widget(g_lobby_xml, "money_two_radio"); char* label = get_string(); gtk_button_set_label(GTK_BUTTON(sl), label); g_free(label); } s_disable_buttons = 1; radio = gui_get_widget(s_lobby_xml, button); g_assert(radio); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), TRUE); s_disable_buttons = 0; g_free(currency_serial); } } else if(!strcmp(tag, "hide")) { g_lobby_tab_state = none; close_lobby(); } else if(!strcmp(tag, "info")) { char* players_count = get_string(); char* tables_count = get_string(); gtk_label_set_text(s_players_label, players_count); gtk_label_set_text(s_tables_label, tables_count); g_free(players_count); g_free(tables_count); } else if(!strcmp(tag, "holdem") || !strcmp(tag, "omaha") || !strcmp(tag, "omaha8") || !strcmp(tag, "7stud")) { int selected = get_int(); int rows = get_int(); int i; int variant_index = VARIANT_HOLDEM; if(!strcmp(tag, "holdem")) { variant_index = VARIANT_HOLDEM; } else if(!strcmp(tag, "omaha")) { variant_index = VARIANT_OMAHA; } else if(!strcmp(tag, "omaha8")) { variant_index = VARIANT_OMAHA8; } else if(!strcmp(tag, "7stud")) { variant_index = VARIANT_7STUD; } gtk_list_store_clear(s_variants_store[variant_index]); for(i = 0; i < rows; i++) { int id = get_int(); GtkTreeIter iter; gtk_list_store_append(s_variants_store[variant_index], &iter); gtk_list_store_set(s_variants_store[variant_index], &iter, TABLE_COLUMN_ID, id, -1); if(selected == id) gtk_tree_selection_select_iter(s_variants_selection[variant_index], &iter); { char* my = get_string(); GdkPixbuf* pixbuf = 0; if(!strcmp(my, "yes")) { pixbuf = pixbuf_table_my; } gtk_list_store_set(s_variants_store[variant_index], &iter, TABLE_COLUMN_MY, pixbuf, -1); } #define SET_COLUMN(INDEX) \ { \ char* content = get_string(); \ gtk_list_store_set(s_variants_store[variant_index], &iter, INDEX, content, -1); \ g_free(content); \ } SET_COLUMN(TABLE_COLUMN_NAME); SET_COLUMN(TABLE_COLUMN_STRUCTURE); SET_COLUMN(TABLE_COLUMN_SEATS); SET_COLUMN(TABLE_COLUMN_AVG_POT); SET_COLUMN(TABLE_COLUMN_HANDS_PER_HOUR); SET_COLUMN(TABLE_COLUMN_PERCENT_FLOP); SET_COLUMN(TABLE_COLUMN_PLAYING); SET_COLUMN(TABLE_COLUMN_OBSERVING); SET_COLUMN(TABLE_COLUMN_WAITING); SET_COLUMN(TABLE_COLUMN_TIMEOUT); #undef SET_COLUMN } s_selected_table = selected; if(!selected) { gtk_list_store_clear(s_players_store); gtk_widget_set_sensitive(GTK_WIDGET(s_go_to_button), FALSE); } } else if(!strcmp(tag, "players")) { int players_count = get_int(); int i; gtk_label_set_text(s_go_to_label, gettext("GO TO TABLE") ); gtk_widget_set_sensitive(GTK_WIDGET(s_go_to_button), TRUE); gtk_list_store_clear(s_players_store); for(i = 0; i < players_count; i++) { char* name = get_string(); char* chips = get_string(); int flag = get_int(); GtkTreeIter iter; gtk_list_store_append(s_players_store, &iter); gtk_list_store_set(s_players_store, &iter, PLAYERS_COLUMN_NAME, name, PLAYERS_COLUMN_CHIPS, chips, PLAYERS_COLUMN_FLAG, flag, -1); g_free(name); g_free(chips); } } // // set clock time // { time_t _time; char date_buffer[8]; time(&_time); struct tm* _tm = gmtime(&_time); snprintf(date_buffer, sizeof (date_buffer), "%02d:%02d", _tm->tm_hour, _tm->tm_min); gtk_label_set_text(GTK_LABEL(s_clock_label), date_buffer); } g_free(tag); return TRUE; }
static GtkWidget * equalizerwin_create_list_window (Index * preset_list, const gchar *title, GtkWidget **window, GtkSelectionMode sel_mode, GtkWidget **entry, GtkWidget *button_action, GCallback action_func, GCallback select_row_func) { GtkWidget *vbox, *scrolled_window, *bbox, *view; GtkWidget *button_cancel; GtkListStore *store; GtkTreeIter iter; GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeSortable *sortable; *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(*window), title); gtk_window_set_type_hint(GTK_WINDOW(*window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_default_size(GTK_WINDOW(*window), 350, 300); gtk_container_set_border_width(GTK_CONTAINER(*window), 10); gtk_window_set_transient_for(GTK_WINDOW(*window), GTK_WINDOW(equalizerwin)); g_signal_connect(*window, "destroy", G_CALLBACK(gtk_widget_destroyed), window); audgui_destroy_on_escape (* window); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); gtk_container_add(GTK_CONTAINER(*window), vbox); scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled_window, GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); /* fill the store with the names of all available presets */ store = gtk_list_store_new(1, G_TYPE_STRING); for (int p = 0; p < index_count (preset_list); p ++) { EqualizerPreset * preset = index_get (preset_list, p); gtk_list_store_append(store, &iter); gtk_list_store_set (store, & iter, 0, preset->name, -1); } model = GTK_TREE_MODEL(store); sortable = GTK_TREE_SORTABLE(store); gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_ASCENDING); view = gtk_tree_view_new(); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, _("Presets"), renderer, "text", 0, NULL); gtk_tree_view_set_model(GTK_TREE_VIEW(view), model); g_object_unref(model); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view)); gtk_tree_selection_set_mode(selection, sel_mode); gtk_container_add(GTK_CONTAINER(scrolled_window), view); gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0); if (entry) { *entry = gtk_entry_new(); g_signal_connect(*entry, "activate", action_func, NULL); gtk_box_pack_start(GTK_BOX(vbox), *entry, FALSE, FALSE, 0); } bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(bbox), 5); gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0); button_cancel = audgui_button_new (_("Cancel"), "process-stop", NULL, NULL); g_signal_connect_swapped (button_cancel, "clicked", (GCallback) gtk_widget_destroy, * window); gtk_box_pack_start(GTK_BOX(bbox), button_cancel, TRUE, TRUE, 0); g_signal_connect(button_action, "clicked", G_CALLBACK(action_func), view); gtk_widget_set_can_default (button_action, TRUE); if (select_row_func) g_signal_connect(view, "row-activated", G_CALLBACK(select_row_func), NULL); gtk_box_pack_start(GTK_BOX(bbox), button_action, TRUE, TRUE, 0); gtk_widget_grab_default(button_action); gtk_widget_show_all(*window); return *window; }
static void prepare_list (AppearanceData *data, GtkWidget *list, ThemeType type, GCallback callback) { GtkListStore *store; GList *l, *themes = NULL; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeModel *sort_model; GdkPixbuf *thumbnail; const gchar *key; ThumbnailGenFunc generator; ThemeThumbnailFunc thumb_cb; ThemeConvData *conv_data; GSettings *settings; switch (type) { case THEME_TYPE_GTK: themes = mate_theme_info_find_by_type (MATE_THEME_GTK_2); thumbnail = data->gtk_theme_icon; settings = data->interface_settings; key = GTK_THEME_KEY; generator = (ThumbnailGenFunc) generate_gtk_theme_thumbnail_async; thumb_cb = (ThemeThumbnailFunc) gtk_theme_thumbnail_cb; break; case THEME_TYPE_WINDOW: themes = mate_theme_info_find_by_type (MATE_THEME_MARCO); thumbnail = data->window_theme_icon; settings = data->marco_settings; key = MARCO_THEME_KEY; generator = (ThumbnailGenFunc) generate_marco_theme_thumbnail_async; thumb_cb = (ThemeThumbnailFunc) marco_theme_thumbnail_cb; break; case THEME_TYPE_ICON: themes = mate_theme_icon_info_find_all (); thumbnail = data->icon_theme_icon; settings = data->interface_settings; key = ICON_THEME_KEY; generator = (ThumbnailGenFunc) generate_icon_theme_thumbnail_async; thumb_cb = (ThemeThumbnailFunc) icon_theme_thumbnail_cb; break; case THEME_TYPE_CURSOR: themes = mate_theme_cursor_info_find_all (); thumbnail = NULL; settings = data->mouse_settings; key = CURSOR_THEME_KEY; generator = NULL; thumb_cb = NULL; break; default: /* we don't deal with any other type of themes here */ return; } store = gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING); for (l = themes; l; l = g_list_next (l)) { MateThemeCommonInfo *theme = (MateThemeCommonInfo *) l->data; GtkTreeIter i; if (type == THEME_TYPE_CURSOR) { thumbnail = ((MateThemeCursorInfo *) theme)->thumbnail; } else { generator (theme, thumb_cb, data, NULL); } gtk_list_store_insert_with_values (store, &i, 0, COL_LABEL, theme->readable_name, COL_NAME, theme->name, COL_THUMBNAIL, thumbnail, -1); if (type == THEME_TYPE_CURSOR && thumbnail) { g_object_unref (thumbnail); thumbnail = NULL; } } g_list_free (themes); sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), COL_LABEL, GTK_SORT_ASCENDING); if (type == THEME_TYPE_CURSOR) gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), COL_LABEL, (GtkTreeIterCompareFunc) cursor_theme_sort_func, NULL, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (sort_model)); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "xpad", 3, "ypad", 3, NULL); column = gtk_tree_view_column_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COL_THUMBNAIL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); 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_add_attribute (column, renderer, "text", COL_LABEL); gtk_tree_view_append_column (GTK_TREE_VIEW (list), column); conv_data = g_new (ThemeConvData, 1); conv_data->data = data; conv_data->thumbnail = thumbnail; /* set useful data for callbacks */ g_object_set_data (G_OBJECT (list), THEME_DATA, conv_data); g_object_set_data (G_OBJECT (list), GSETTINGS_SETTINGS, settings); g_object_set_data (G_OBJECT (list), GSETTINGS_KEY, g_strdup(key)); /* select in treeview the theme set in gsettings */ GtkTreeModel *treemodel; treemodel = gtk_tree_view_get_model (GTK_TREE_VIEW (list)); gchar *theme = g_settings_get_string (settings, key); gchar *path = find_string_in_model (treemodel, theme, COL_NAME); if (path) { GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); GtkTreePath *treepath = gtk_tree_path_new_from_string (path); gtk_tree_selection_select_path (selection, treepath); gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (list), treepath, NULL, FALSE, 0, 0); gtk_tree_path_free (treepath); g_free (path); } if (theme) g_free (theme); /* connect to gsettings change event */ gchar *signal_name = g_strdup_printf("changed::%s", key); g_signal_connect (settings, signal_name, G_CALLBACK (treeview_gsettings_changed_callback), list); g_free (signal_name); /* connect to treeview change event */ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (list)), "changed", G_CALLBACK (treeview_selection_changed_callback), list); }
// Create and bind the tree model to the tree view for the audio track list // Also, connect up the signal that lets us know the selection has changed static void bind_audio_tree_model (signal_user_data_t *ud) { GtkCellRenderer *cell; GtkTreeViewColumn *column; GtkListStore *treestore; GtkTreeView *treeview; GtkTreeSelection *selection; GtkWidget *widget; g_debug("bind_audio_tree_model ()\n"); treeview = GTK_TREE_VIEW(GHB_WIDGET (ud->builder, "audio_list")); selection = gtk_tree_view_get_selection (treeview); // 12 columns in model. 6 are visible, the other 6 are for storing // values that I need treestore = gtk_list_store_new(6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore)); cell = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Track"), cell, "text", 0, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); gtk_tree_view_column_set_min_width (column, 200); gtk_tree_view_column_set_max_width (column, 200); cell = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Codec"), cell, "text", 1, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); gtk_tree_view_column_set_min_width (column, 110); cell = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Bitrate"), cell, "text", 2, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); gtk_tree_view_column_set_min_width (column, 50); cell = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Sample Rate"), cell, "text", 3, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); gtk_tree_view_column_set_min_width (column, 100); cell = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Mix"), cell, "text", 4, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); gtk_tree_view_column_set_min_width (column, 115); cell = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("DRC"), cell, "text", 5, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); g_signal_connect(selection, "changed", audio_list_selection_changed_cb, ud); // Need to disable remove and update buttons since there are initially // no selections widget = GHB_WIDGET (ud->builder, "audio_remove"); gtk_widget_set_sensitive(widget, FALSE); g_debug("Done\n"); }
GtkWidget * create_disk_view(ProcData *procdata) { GtkWidget *disk_box; GtkWidget *scrolled; GtkWidget *disk_tree; GtkListStore *model; GtkTreeViewColumn *col; GtkCellRenderer *cell; guint i; const gchar * const titles[] = { N_("Device"), N_("Directory"), N_("Type"), N_("Total"), N_("Free"), N_("Available"), N_("Used") }; disk_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(disk_box), scrolled, TRUE, TRUE, 0); model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */ G_TYPE_STRING, /* DISK_DEVICE */ G_TYPE_STRING, /* DISK_DIR */ G_TYPE_STRING, /* DISK_TYPE */ G_TYPE_UINT64, /* DISK_TOTAL */ G_TYPE_UINT64, /* DISK_FREE */ G_TYPE_UINT64, /* DISK_AVAIL */ G_TYPE_UINT64, /* DISK_USED */ GDK_TYPE_PIXBUF, /* DISK_ICON */ G_TYPE_INT /* DISK_USED_PERCENTAGE */ ); disk_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model)); g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL); procdata->disk_list = disk_tree; gtk_container_add(GTK_CONTAINER(scrolled), disk_tree); g_object_unref(G_OBJECT(model)); /* icon + device */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON, NULL); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE, NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE])); gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_min_width (col, 30); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); /* sizes - used */ for (i = DISK_DIR; i <= DISK_AVAIL; i++) { cell = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_title(col, _(titles[i])); gtk_tree_view_column_set_sort_column_id(col, i); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_min_width (col, 30); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); switch (i) { case DISK_TOTAL: case DISK_FREE: case DISK_AVAIL: g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_cell_data_func, GUINT_TO_POINTER(i), NULL); break; default: gtk_tree_view_column_set_attributes(col, cell, "text", i, NULL); break; } } /* used + percentage */ col = gtk_tree_view_column_new(); cell = gtk_cell_renderer_text_new(); g_object_set(cell, "xalign", 1.0f, NULL); gtk_tree_view_column_pack_start(col, cell, FALSE); gtk_tree_view_column_set_cell_data_func(col, cell, &procman::size_cell_data_func, GUINT_TO_POINTER(DISK_USED), NULL); cell = gtk_cell_renderer_progress_new(); gtk_tree_view_column_pack_start(col, cell, TRUE); gtk_tree_view_column_set_attributes(col, cell, "value", DISK_USED_PERCENTAGE, NULL); gtk_tree_view_column_set_title(col, _(titles[DISK_USED])); gtk_tree_view_column_set_sort_column_id(col, DISK_USED); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_min_width (col, 150); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings); gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col); /* numeric sort */ gtk_widget_show_all(disk_box); procman_get_tree_state(procdata->settings, disk_tree, "disktreenew"); g_signal_connect (G_OBJECT(disk_tree), "columns-changed", G_CALLBACK(cb_disk_columns_changed), procdata); return disk_box; }
// Create and bind the tree model to the tree view for the subtitle track list // Also, connect up the signal that lets us know the selection has changed static void bind_subtitle_tree_model (signal_user_data_t *ud) { GtkCellRenderer *cell; GtkTreeViewColumn *column; GtkListStore *treestore; GtkTreeView *treeview; GtkTreeSelection *selection; GtkWidget *widget; g_debug("bind_subtitle_tree_model ()\n"); treeview = GTK_TREE_VIEW(GHB_WIDGET (ud->builder, "subtitle_list")); selection = gtk_tree_view_get_selection (treeview); // 6 columns in model. 5 are visible, the other 1 is for storing // values that I need // Track, force, burn, default, type, srt offset, track short, source // force visible, burn visible, offset visible treestore = gtk_list_store_new(10, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore)); cell = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Track"), cell, "text", 0, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); gtk_tree_view_column_set_min_width (column, 350); gtk_tree_view_column_set_max_width (column, 350); cell = gtk_cell_renderer_toggle_new(); column = gtk_tree_view_column_new_with_attributes( _("Forced Only"), cell, "active", 1, "visible", 7, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); g_signal_connect(cell, "toggled", subtitle_forced_toggled_cb, ud); cell = gtk_cell_renderer_toggle_new(); gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(cell), TRUE); column = gtk_tree_view_column_new_with_attributes( _("Burned In"), cell, "active", 2, "visible", 8, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); g_signal_connect(cell, "toggled", subtitle_burned_toggled_cb, ud); cell = gtk_cell_renderer_toggle_new(); gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(cell), TRUE); column = gtk_tree_view_column_new_with_attributes( _("Default"), cell, "active", 3, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); g_signal_connect(cell, "toggled", subtitle_default_toggled_cb, ud); cell = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Srt Offset"), cell, "text", 4, "visible", 9, NULL); gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column)); g_signal_connect(selection, "changed", subtitle_list_selection_changed_cb, ud); // Need to disable remove and update buttons since there are initially // no selections widget = GHB_WIDGET (ud->builder, "subtitle_remove"); gtk_widget_set_sensitive(widget, FALSE); g_debug("Done\n"); }
void initialize_pref_controls(void) { GtkWidget *widget; GtkSpinButton *spin; GdkColor color; GtkTreeModel *model; diag_pref = glade_xml_get_widget (appdata.xml, "diag_pref"); /* Updates controls from values of variables */ widget = glade_xml_get_widget (appdata.xml, "node_radius_slider"); gtk_adjustment_set_value (GTK_RANGE (widget)->adjustment, log (pref.node_radius_multiplier) / log (10)); g_signal_emit_by_name (G_OBJECT (GTK_RANGE (widget)->adjustment), "changed"); widget = glade_xml_get_widget (appdata.xml, "link_width_slider"); gtk_adjustment_set_value (GTK_RANGE (widget)->adjustment, pref.link_node_ratio); g_signal_emit_by_name (GTK_OBJECT (GTK_RANGE (widget)->adjustment), "changed"); spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "averaging_spin")); gtk_spin_button_set_value (spin, pref.averaging_time); spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "refresh_spin")); gtk_spin_button_set_value (spin, pref.refresh_period); spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "node_to_spin")); gtk_spin_button_set_value (spin, pref.node_timeout_time/MILLI); spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "gui_node_to_spin")); gtk_spin_button_set_value (spin, pref.gui_node_timeout_time/MILLI); spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "proto_node_to_spin")); gtk_spin_button_set_value (spin, pref.proto_node_timeout_time/MILLI); spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "link_to_spin")); gtk_spin_button_set_value (spin, pref.link_timeout_time/MILLI); spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "gui_link_to_spin")); gtk_spin_button_set_value (spin, pref.gui_link_timeout_time/MILLI); spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "proto_link_to_spin")); gtk_spin_button_set_value (spin, pref.proto_link_timeout_time/MILLI); spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "proto_to_spin")); gtk_spin_button_set_value (spin, pref.proto_timeout_time/MILLI); widget = glade_xml_get_widget (appdata.xml, "diagram_only_toggle"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), pref.diagram_only); widget = glade_xml_get_widget (appdata.xml, "group_unk_check"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), pref.group_unk); widget = glade_xml_get_widget (appdata.xml, "name_res_check"); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), pref.name_res); widget = glade_xml_get_widget (appdata.xml, "stack_level"); gtk_combo_box_set_active(GTK_COMBO_BOX(widget), pref.stack_level); widget = glade_xml_get_widget (appdata.xml, "size_variable"); gtk_combo_box_set_active(GTK_COMBO_BOX(widget), pref.node_size_variable); widget = glade_xml_get_widget (appdata.xml, "size_mode"); gtk_combo_box_set_active(GTK_COMBO_BOX(widget), pref.size_mode); widget = glade_xml_get_widget (appdata.xml, "text_font"); gtk_font_button_set_font_name(GTK_FONT_BUTTON(widget), pref.fontname); widget = glade_xml_get_widget (appdata.xml, "text_color"); if (!gdk_color_parse(pref.text_color, &color)) gdk_color_parse("#ffff00", &color); gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color); widget = glade_xml_get_widget (appdata.xml, "filter_combo"); model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget)); if (!model) { GtkListStore *list_store; list_store=gtk_list_store_new (1, G_TYPE_STRING); gtk_combo_box_set_model(GTK_COMBO_BOX(widget), GTK_TREE_MODEL(list_store)); } pref_to_color_list(); /* Updates the color preferences table with pref.colors */ /* Connects signals */ widget = glade_xml_get_widget (appdata.xml, "diag_pref"); g_signal_connect (G_OBJECT (widget), "delete_event", GTK_SIGNAL_FUNC (on_cancel_pref_button_clicked ), NULL); widget = glade_xml_get_widget (appdata.xml, "node_radius_slider"); g_signal_connect (G_OBJECT (GTK_RANGE (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_node_radius_slider_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "link_width_slider"); g_signal_connect (G_OBJECT (GTK_RANGE (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_link_width_slider_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "averaging_spin"); g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_averaging_spin_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "refresh_spin"); g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_refresh_spin_adjustment_changed), glade_xml_get_widget (appdata.xml, "canvas1")); widget = glade_xml_get_widget (appdata.xml, "node_to_spin"); g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_node_to_spin_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "gui_node_to_spin"); g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_gui_node_to_spin_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "proto_node_to_spin"); g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_proto_node_to_spin_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "link_to_spin"); g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_link_to_spin_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "gui_link_to_spin"); g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_gui_link_to_spin_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "proto_link_to_spin"); g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_proto_link_to_spin_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "proto_to_spin"); g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment), "value_changed", GTK_SIGNAL_FUNC (on_proto_to_spin_adjustment_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "stack_level"); g_signal_connect (G_OBJECT (widget), "changed", GTK_SIGNAL_FUNC (on_stack_level_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "size_variable"); g_signal_connect (G_OBJECT (widget), "changed", GTK_SIGNAL_FUNC (on_size_variable_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "size_mode"); g_signal_connect (G_OBJECT (widget), "changed", GTK_SIGNAL_FUNC (on_size_mode_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "text_font"); g_signal_connect (G_OBJECT (widget), "font_set", GTK_SIGNAL_FUNC (on_text_font_changed), NULL); widget = glade_xml_get_widget (appdata.xml, "text_color"); g_signal_connect (G_OBJECT (widget), "color_set", GTK_SIGNAL_FUNC (on_text_color_changed), NULL); }
static GtkWidget * servlist_open_edit (GtkWidget *parent, ircnet *net) { GtkWidget *editwindow; GtkWidget *vbox5; GtkWidget *table3; GtkWidget *label17; GtkWidget *label16; GtkWidget *label21; GtkWidget *label22; GtkWidget *label34; GtkWidget *comboboxentry_charset; GtkWidget *hbox1; GtkWidget *scrolledwindow2; GtkWidget *treeview_servers; GtkWidget *vbuttonbox1; GtkWidget *buttonadd; GtkWidget *buttonremove; GtkWidget *buttonedit; GtkWidget *check; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *renderer; char buf[128]; char buf2[128 + 8]; char tbuf[256]; snprintf (tbuf, sizeof tbuf, _("conspire: Network Editor (%s)"), net->name); editwindow = mg_create_generic_tab(_("Network Editor"), tbuf, FALSE, TRUE, servlist_closegui, NULL, 550, 200, &vbox5, NULL); table3 = gtk_table_new (17, 3, FALSE); gtk_widget_show (table3); gtk_box_pack_start (GTK_BOX (vbox5), table3, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table3), 2); gtk_table_set_col_spacings (GTK_TABLE (table3), 8); snprintf (buf, sizeof (buf), _("Servers for %s"), net->name); snprintf (buf2, sizeof (buf2), "<b>%s</b>", buf); label16 = gtk_label_new (buf2); gtk_widget_show (label16); gtk_table_attach (GTK_TABLE (table3), label16, 0, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); gtk_label_set_use_markup (GTK_LABEL (label16), TRUE); gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5); check = servlist_create_check (0, !(net->flags & FLAG_CYCLE), table3, 2, 1, _("Connect to selected server only")); add_tip (check, _("Don't cycle through all the servers when the connection fails.")); label17 = bold_label (_("Your Details")); gtk_table_attach (GTK_TABLE (table3), label17, 0, 3, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); servlist_create_check (1, net->flags & FLAG_USE_GLOBAL, table3, 4, 1, _("Use global user information")); edit_entry_nick = servlist_create_entry (table3, _("_Nick name:"), 5, net->nick, &edit_label_nick, 0); edit_entry_nick2 = servlist_create_entry (table3, _("Second choice:"), 6, net->nick2, &edit_label_nick2, 0); edit_entry_user = servlist_create_entry (table3, _("_User name:"), 7, net->user, &edit_label_user, 0); edit_entry_real = servlist_create_entry (table3, _("Rea_l name:"), 8, net->real, &edit_label_real, 0); label21 = bold_label (_("Connecting")); gtk_table_attach (GTK_TABLE (table3), label21, 0, 3, 9, 10, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); servlist_create_check (3, net->flags & FLAG_AUTO_CONNECT, table3, 11, 1, _("Auto connect to this network at startup")); servlist_create_check (4, net->flags & FLAG_USE_PROXY, table3, 12, 1, _("Use a proxy server")); edit_entry_join = servlist_create_entry (table3, _("C_hannels to join:"), 15, net->autojoin, 0, _("Channels to join, separated by commas, but not spaces!")); edit_entry_nickserv = servlist_create_entry (table3, _("Nickserv password:"******"If your nickname requires a password, enter it here. Not all IRC networks support this.")); gtk_entry_set_visibility (GTK_ENTRY (edit_entry_nickserv), FALSE); edit_entry_pass = servlist_create_entry (table3, _("Server password:"******"Password for the server, if in doubt, leave blank.")); gtk_entry_set_visibility (GTK_ENTRY (edit_entry_pass), FALSE); edit_entry_sasl_user = servlist_create_entry (table3, _("SASL username:"******"If your network uses SASL, put your username here.")); edit_entry_sasl_pass = servlist_create_entry (table3, _("SASL password:"******"If your network uses SASL, put your password here.")); gtk_entry_set_visibility (GTK_ENTRY (edit_entry_sasl_pass), FALSE); label34 = gtk_label_new (_("Character set:")); gtk_widget_show (label34); gtk_table_attach (GTK_TABLE (table3), label34, 1, 2, 21, 22, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment (GTK_MISC (label34), 0, 0.5); comboboxentry_charset = servlist_create_charsetcombo (); ignore_changed = TRUE; gtk_entry_set_text (GTK_ENTRY (GTK_BIN (comboboxentry_charset)->child), net->encoding ? net->encoding : "System default"); ignore_changed = FALSE; gtk_widget_show (comboboxentry_charset); gtk_table_attach (GTK_TABLE (table3), comboboxentry_charset, 2, 3, 21, 22, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); label22 = bold_label (_("Perform")); gtk_table_attach (GTK_TABLE (table3), label22, 0, 3, 22, 23, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 3); edit_entry_cmd = servlist_create_textview (table3, _("Connect commands:"), 24, net->command, 0, _("Extra commands to execute after connecting. Alternatively, to run a large series of commands on connect, use LOAD -e <filename>, where <filename> is a text-file full of commands to execute.")); /*********** FINITO *************/ hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_table_attach (GTK_TABLE (table3), hbox1, 1, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow2); gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN); model = GTK_TREE_MODEL (store); edit_tree = treeview_servers = gtk_tree_view_new_with_model (model); g_object_unref (model); gtk_widget_show (treeview_servers); gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview_servers); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_servers), FALSE); renderer = gtk_cell_renderer_text_new (); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (servlist_editserver_cb), model); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (treeview_servers), -1, 0, renderer, "text", 0, "editable", 1, NULL); vbuttonbox1 = gtk_vbutton_box_new (); gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 3); gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START); gtk_widget_show (vbuttonbox1); gtk_box_pack_start (GTK_BOX (hbox1), vbuttonbox1, FALSE, FALSE, 3); buttonadd = gtk_button_new_from_stock ("gtk-add"); g_signal_connect (G_OBJECT (buttonadd), "clicked", G_CALLBACK (servlist_addserver_cb), edit_tree); gtk_widget_show (buttonadd); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonadd); GTK_WIDGET_SET_FLAGS (buttonadd, GTK_CAN_DEFAULT); buttonremove = gtk_button_new_from_stock ("gtk-remove"); g_signal_connect (G_OBJECT (buttonremove), "clicked", G_CALLBACK (servlist_deleteserver_cb), NULL); gtk_widget_show (buttonremove); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonremove); GTK_WIDGET_SET_FLAGS (buttonremove, GTK_CAN_DEFAULT); buttonedit = gtk_button_new_with_mnemonic (_("_Edit")); g_signal_connect (G_OBJECT (buttonedit), "clicked", G_CALLBACK (servlist_editserverbutton_cb), NULL); gtk_widget_show (buttonedit); gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonedit); GTK_WIDGET_SET_FLAGS (buttonedit, GTK_CAN_DEFAULT); if (net->flags & FLAG_USE_GLOBAL) { gtk_widget_hide (edit_label_nick); gtk_widget_hide (edit_entry_nick); gtk_widget_hide (edit_label_nick2); gtk_widget_hide (edit_entry_nick2); gtk_widget_hide (edit_label_user); gtk_widget_hide (edit_entry_user); gtk_widget_hide (edit_label_real); gtk_widget_hide (edit_entry_real); } return editwindow; }
void SetupHashWindow() { /* Setup window */ gui.windows.hash = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(gui.windows.hash), "Hashes"); gtk_window_set_default_size(GTK_WINDOW(gui.windows.hash), 580, 340); gtk_window_set_deletable(GTK_WINDOW(gui.windows.hash), false); gui.fixed.hash = gtk_fixed_new(); gtk_container_add(GTK_CONTAINER(gui.windows.hash), gui.fixed.hash); /* Load hashes */ gui.entries.hash = gtk_entry_new(); gtk_widget_set_size_request(gui.entries.hash, 380, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.entries.hash, 8, 8); gui.cbox.hash = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hashlist"); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hash"); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "pwdump"); gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Cain"); gtk_widget_set_size_request(gui.cbox.hash, 90, 32); gtk_combo_box_set_active(GTK_COMBO_BOX(gui.cbox.hash), 0); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.cbox.hash, 390, 8); gui.buttons.hash_load = gtk_button_new_with_label("Load"); gtk_widget_set_size_request(gui.buttons.hash_load, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_load, 485, 8); /* TreeView */ gui.hash.scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gui.hash.scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gui.hash.tree = gtk_tree_view_new(); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(gui.hash.tree), true); gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(gui.hash.tree), true); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gui.hash.tree), true); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(gui.hash.tree), true); gui.hash.store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(gui.hash.tree), GTK_TREE_MODEL(gui.hash.store)); gui.hash.render = gtk_cell_renderer_text_new(); GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes("Algorithm", gui.hash.render, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id(col, 0); gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col); col = gtk_tree_view_column_new_with_attributes("Length", gui.hash.render, "text", 1, NULL); gtk_tree_view_column_set_sort_column_id(col, 1); gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col); col = gtk_tree_view_column_new_with_attributes("Hash", gui.hash.render, "text", 2, NULL); gtk_tree_view_column_set_sort_column_id(col, 2); gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col); GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gui.hash.tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_container_add(GTK_CONTAINER(gui.hash.scroll), gui.hash.tree); gtk_widget_set_size_request(gui.hash.tree, 560, 240); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.hash.scroll, 8, 48); /* Buttons */ gui.buttons.hash_delete = gtk_button_new_with_label("Remove"); gtk_widget_set_size_request(gui.buttons.hash_delete, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_delete, 8, 300); gui.buttons.hash_clear = gtk_button_new_with_label("Clear"); gtk_widget_set_size_request(gui.buttons.hash_clear, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_clear, 100, 300); gui.buttons.hash_ok = gtk_button_new_with_label("OK"); gtk_widget_set_size_request(gui.buttons.hash_ok, 80, 32); gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_ok, 480, 300); g_signal_connect(gui.buttons.hash_load, "clicked", G_CALLBACK(LoadHashes), NULL); g_signal_connect(gui.buttons.hash_ok, "clicked", G_CALLBACK(HideHashWindow), NULL); g_signal_connect(gui.buttons.hash_delete, "clicked", G_CALLBACK(DeleteHashes), NULL); g_signal_connect(gui.buttons.hash_clear, "clicked", G_CALLBACK(ClearHashes), NULL); return; }
static void gxi_update_string_box (GncXmlImportData *data) { gchar *string; const gchar *utf8; GtkBox *vbox; GtkComboBox *combo; GtkListStore *store; GList *word_iter, *conv_iter; GtkCellRenderer *renderer; GtkTreeIter iter; GQuark chosen_encoding; GtkTreeIter *chosen_iter, *default_iter; ambiguous_type *amb; conv_type *conv; if (data->string_box) gtk_widget_destroy (data->string_box); data->string_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_set_homogeneous (GTK_BOX (data->string_box), FALSE); vbox = GTK_BOX (data->string_box); data->n_unassigned = 0; /* loop through words */ for (word_iter = data->ambiguous_list; word_iter; word_iter = word_iter->next) { store = gtk_list_store_new (WORD_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); combo = GTK_COMBO_BOX (gtk_combo_box_new_with_model ( GTK_TREE_MODEL (store))); g_object_unref (store); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer, "text", WORD_COL_STRING, NULL); /* add default string, if possible */ amb = (ambiguous_type*) word_iter->data; utf8 = get_decoded_string (amb, data->default_encoding); default_iter = NULL; if (utf8) { string = g_strdup_printf ("%s (default)", utf8); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, WORD_COL_STRING, string, WORD_COL_ENCODING, GUINT_TO_POINTER (data->default_encoding), -1); g_free (string); default_iter = gtk_tree_iter_copy (&iter); } /* user has selected this previously */ conv = (conv_type*) g_hash_table_lookup (data->choices, amb->byte_sequence); chosen_encoding = (conv) ? conv->encoding : 0; chosen_iter = NULL; /* loop through conversions */ for (conv_iter = amb->conv_list; conv_iter; conv_iter = conv_iter->next) { conv = (conv_type*) conv_iter->data; string = g_strdup_printf ("%s (%s)", conv->utf8_string, g_quark_to_string (conv->encoding)); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, WORD_COL_STRING, string, WORD_COL_ENCODING, GUINT_TO_POINTER (conv->encoding), -1); g_free (string); if (chosen_encoding && conv->encoding == chosen_encoding) { chosen_iter = gtk_tree_iter_copy (&iter); } } /* next conversion */ if (chosen_iter) { /* select previous selection again, are not we cute */ gtk_combo_box_set_active_iter (combo, chosen_iter); gtk_tree_iter_free (chosen_iter); } else { if (default_iter) { /* select default entry */ gtk_combo_box_set_active_iter (combo, default_iter); } else { /* count it */ data->n_unassigned++; } } /* wire up combo */ g_object_set_data (G_OBJECT (combo), "ambiguous", amb); g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (gxi_string_combo_changed_cb), data); gtk_box_pack_start (vbox, GTK_WIDGET (combo), FALSE, FALSE, 0); gtk_widget_show (GTK_WIDGET (combo)); } /* next word */ /* wire up whole string vbox */ gtk_container_add (GTK_CONTAINER (data->string_box_container), GTK_WIDGET (vbox)); gtk_widget_show (GTK_WIDGET (vbox)); /* update label now, n_unassigned is calculated */ if (!data->summary_label) data->summary_label = data->impossible_label; gxi_update_summary_label (data); }
void usldoks_create_list (class usldoks_data *data) { class iceb_gdite_data gdite; iceb_gdite(&gdite,0,data->window); GtkListStore *model=NULL; GtkTreeIter iter; SQLCURSOR cur; SQLCURSOR cur1; char strsql[512]; char bros[500]; int kolstr=0; SQL_str row; iceb_u_str zagolov; data->kl_shift=0; //0-отжата 1-нажата gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE)); iceb_refresh(); if(data->treeview != NULL) gtk_widget_destroy(data->treeview); data->treeview = gtk_tree_view_new(); gtk_container_add (GTK_CONTAINER (data->sw), data->treeview); g_signal_connect(data->treeview,"row_activated",G_CALLBACK(usldoks_v_row),data); GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview)); gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE); g_signal_connect(selection,"changed",G_CALLBACK(usldoks_vibor),data); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE); model = gtk_list_store_new (NUM_COLUMNS+1, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); sprintf(bros,"tp,datd,podr,kontr,nomd,nomnn,kodop,pod,pro,ktoi,nomdp,vrem,dover,nds,sumkor,sumnds,pn,mo from Usldokum"); sprintf(strsql,"select %s where datd >= '%d-01-01' order by datd asc", bros,data->gn); if(data->dn != 0) sprintf(strsql,"select %s where datd >= '%d-%02d-%02d' order by datd asc", bros,data->gn,data->mn,data->dn); if(data->dn != 0 && data->dk != 0) sprintf(strsql,"select %s where datd >= '%d-%02d-%02d' and datd <= '%d-%02d-%02d' \ order by datd asc",bros,data->gn,data->mn,data->dn,data->gk,data->mk,data->dk); data->zapros.new_plus(strsql); if((kolstr=cur.make_cursor(&bd,strsql)) < 0) { iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window); return; } //gtk_list_store_clear(model); iceb_u_str ss[NUM_COLUMNS]; data->kolzap=0; float kolstr1=0.; while(cur.read_cursor(&row) != 0) { iceb_pbar(gdite.bar,kolstr,++kolstr1); // printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]); if(usldoks_prov_row(row,data) != 0) continue; //Метка записи ss[COL_METKAZ].new_plus(""); if(row[0][0] == '1') ss[COL_METKAZ].new_plus("+"); else ss[COL_METKAZ].new_plus("-"); if(row[7][0] == '0') ss[COL_METKAZ].plus("?"); if(row[8][0] == '0') ss[COL_METKAZ].plus("*"); if(row[17][0] == '0') ss[COL_METKAZ].plus("$"); //Дата документа ss[COL_DATAD].new_plus(iceb_u_sqldata(row[1])); //Номер документа ss[COL_NOMDOK].new_plus(iceb_u_toutf(row[4])); //Контрагент ss[COL_KONTR].new_plus(iceb_u_toutf(row[3])); //Код операции ss[COL_KODOP].new_plus(iceb_u_toutf(row[6])); //код подразделения ss[COL_PODR].new_plus(iceb_u_toutf(row[2])); //Номер налоговой накладной ss[COL_NOMNALNAK].new_plus(iceb_u_toutf(row[5])); //Номер накладной парного документа ss[COL_NOMPD].new_plus(iceb_u_toutf(row[10])); //Дата и время записи ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[11]))); //Кто записал ss[COL_KTO].new_plus(iceb_kszap(row[9],0,data->window)); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_METKAZ,ss[COL_METKAZ].ravno(), COL_DATAD,ss[COL_DATAD].ravno(), COL_NOMDOK,ss[COL_NOMDOK].ravno(), COL_KONTR,ss[COL_KONTR].ravno(), COL_KODOP,ss[COL_KODOP].ravno(), COL_PODR,ss[COL_PODR].ravno(), COL_NOMNALNAK,ss[COL_NOMNALNAK].ravno(), COL_NOMPD,ss[COL_NOMPD].ravno(), COL_DATA_VREM,ss[COL_DATA_VREM].ravno(), COL_KTO,ss[COL_KTO].ravno(), NUM_COLUMNS,data->kolzap, -1); data->kolzap++; } gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model)); g_object_unref (GTK_TREE_MODEL (model)); usldoks_add_columns (GTK_TREE_VIEW (data->treeview)); if(data->kolzap == 0) { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK3]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),FALSE);//Недоступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),FALSE);//Недоступна } else { gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK3]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),TRUE);//Доступна gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),TRUE);//Доступна } gtk_widget_show (data->treeview); gtk_widget_show (data->sw); if(data->kolzap > 0) { if(data->snanomer > data->kolzap-1) data->snanomer= data->kolzap-1; if(data->snanomer < 0) data->snanomer=0; printf("poz=%d\n",data->snanomer); sprintf(strsql,"%d",data->snanomer); GtkTreePath *path=gtk_tree_path_new_from_string(strsql); // gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (data->treeview),path,NULL,TRUE,0,0); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (data->treeview),path,NULL,FALSE,0,0); gtk_tree_view_set_cursor(GTK_TREE_VIEW (data->treeview),path,NULL,FALSE); gtk_tree_path_free(path); // data->snanomer=-2; } iceb_u_str strpoi; strpoi.plus(""); if(data->poi.metka_pros == 1) strpoi.new_plus(gettext("Просмотр только неподтверждённых документов")); if(data->poi.metka_pros == 2) strpoi.new_plus(gettext("Просмотр только документов без проводок")); if(data->poi.metka_poi == 1 || data->poi.metka_opl != 0) { // printf("Формирование заголовка с реквизитами поиска.\n"); if(data->poi.metka_pros != 0) strpoi.ps_plus(gettext("Поиск")); else strpoi.new_plus(gettext("Поиск")); strpoi.plus(" !!!"); iceb_str_poisk(&strpoi,data->poi.nomdok.ravno(),gettext("Номер документа")); iceb_str_poisk(&strpoi,data->poi.datan.ravno(),gettext("Дата начала")); iceb_str_poisk(&strpoi,data->poi.datak.ravno(),gettext("Дата конца")); iceb_str_poisk(&strpoi,data->poi.kontr.ravno(),gettext("Код контрагента")); iceb_str_poisk(&strpoi,data->poi.naim_kontr.ravno(),gettext("Наименование контрагента")); iceb_str_poisk(&strpoi,data->poi.kodop.ravno(),gettext("Код операции")); iceb_str_poisk(&strpoi,data->poi.kodpod.ravno(),gettext("Код подразделения")); iceb_str_poisk(&strpoi,data->poi.nalnak.ravno(),gettext("Номер налоговой накладной")); iceb_str_poisk(&strpoi,data->poi.dover.ravno(),gettext("Доверенность")); if(data->poi.pr_ras.ravno_pr() == 1) strpoi.ps_plus(gettext("Только приходы")); if(data->poi.pr_ras.ravno_pr() == 2) strpoi.ps_plus(gettext("Только расходы")); if(data->poi.metka_opl == 1) strpoi.ps_plus(gettext("Только оплаченные")); if(data->poi.metka_opl == 2) strpoi.ps_plus(gettext("Только неоплаченные")); } if(strpoi.getdlinna() > 1) { gtk_label_set_text(GTK_LABEL(data->label_poisk),strpoi.ravno_toutf()); gtk_widget_show(data->label_poisk); } else gtk_widget_hide(data->label_poisk); zagolov.new_plus(gettext("Список документов")); sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap); zagolov.plus(strsql); gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf()); gtk_widget_show(data->label_kolstr); gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR)); }
NewStylesheetDialog::NewStylesheetDialog(const ustring & worksheet, GtkWindow *transient_parent) { myworksheet = worksheet; Shortcuts shortcuts(0); newstylesheetdialog = gtk_dialog_new(); gtk_window_set_transient_for(GTK_WINDOW(newstylesheetdialog), transient_parent); if (!worksheet.empty()) { gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New style")); } else { gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New stylesheet")); } //gtk_window_set_position(GTK_WINDOW(newstylesheetdialog), GTK_WIN_POS_CENTER_ON_PARENT); dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (newstylesheetdialog)); gtk_widget_show(dialog_vbox1); hbox2 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox2); gtk_box_pack_start(GTK_BOX(dialog_vbox1), hbox2, TRUE, TRUE, 0); vbox1 = gtk_vbox_new(FALSE, 4); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(hbox2), vbox1, TRUE, TRUE, 0); if (myworksheet.empty()) { hbox1 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, TRUE, 0); label1 = gtk_label_new(_("Name")); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0); shortcuts.label(label1); entry1 = gtk_entry_new(); gtk_widget_show(entry1); gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0); } ustring info; if (!myworksheet.empty()) info = _("Select one or more styles from the list"); label_info = gtk_label_new(info.c_str()); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(vbox1), label_info, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label_info), 0, 0.5); GSList *radiobutton_basic_group = NULL; radiobutton_basic = gtk_radio_button_new_with_mnemonic(NULL, _("Basic")); gtk_widget_show(radiobutton_basic); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_basic, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_basic), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_basic)); shortcuts.button(radiobutton_basic); radiobutton_paragraph = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph")); gtk_widget_show(radiobutton_paragraph); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_paragraph, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_paragraph), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_paragraph)); shortcuts.button(radiobutton_paragraph); radiobutton_word_note = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph, word, note")); gtk_widget_show(radiobutton_word_note); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_word_note, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_word_note), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_word_note)); shortcuts.button(radiobutton_word_note); radiobutton_sbp = gtk_radio_button_new_with_mnemonic(NULL, _("SIL best practice")); gtk_widget_show(radiobutton_sbp); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_sbp, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_sbp), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_sbp)); shortcuts.button(radiobutton_sbp); radiobutton_full = gtk_radio_button_new_with_mnemonic(NULL, _("Full")); gtk_widget_show(radiobutton_full); gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_full, FALSE, FALSE, 0); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_full), radiobutton_basic_group); radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_full)); shortcuts.button(radiobutton_full); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_full), true); if (!myworksheet.empty()) { expander1 = gtk_expander_new(NULL); gtk_widget_show(expander1); gtk_box_pack_start(GTK_BOX(vbox1), expander1, TRUE, TRUE, 0); label2 = gtk_label_new(_("Add non-standard style")); gtk_widget_show(label2); gtk_expander_set_label_widget(GTK_EXPANDER(expander1), label2); shortcuts.label(label2); hbox1 = gtk_hbox_new(FALSE, 4); gtk_widget_show(hbox1); gtk_container_add(GTK_CONTAINER(expander1), hbox1); label1 = gtk_label_new(_("Name")); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0); shortcuts.label(label1); entry1 = gtk_entry_new(); gtk_widget_show(entry1); gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0); scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow1); gtk_box_pack_start(GTK_BOX(hbox2), scrolledwindow1, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_SHADOW_IN); treeview1 = gtk_tree_view_new(); gtk_widget_show(treeview1); gtk_container_add(GTK_CONTAINER(scrolledwindow1), treeview1); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview1), FALSE); store1 = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview1), GTK_TREE_MODEL(store1)); g_object_unref(store1); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); column1 = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview1), column1); select1 = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview1)); gtk_tree_selection_set_mode(select1, GTK_SELECTION_SINGLE); } dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(newstylesheetdialog)); gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); new InDialogHelp(newstylesheetdialog, NULL, &shortcuts, "file/styles/stylesheet/new"); cancelbutton1 = gtk_button_new_from_stock("gtk-cancel"); gtk_widget_show(cancelbutton1); gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), cancelbutton1, GTK_RESPONSE_CANCEL); gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true); okbutton = gtk_button_new_from_stock("gtk-ok"); gtk_widget_show(okbutton); gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), okbutton, GTK_RESPONSE_OK); gtk_widget_set_can_default (GTK_WIDGET (okbutton), true); shortcuts.stockbutton(cancelbutton1); shortcuts.stockbutton(okbutton); shortcuts.process(); g_signal_connect((gpointer) entry1, "changed", G_CALLBACK(on_entry_changed), gpointer(this)); g_signal_connect((gpointer) radiobutton_basic, "toggled", G_CALLBACK(on_radiobutton_basic_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_paragraph, "toggled", G_CALLBACK(on_radiobutton_paragraph_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_word_note, "toggled", G_CALLBACK(on_radiobutton_word_note_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_sbp, "toggled", G_CALLBACK(on_radiobutton_sbp_toggled), gpointer(this)); g_signal_connect((gpointer) radiobutton_full, "toggled", G_CALLBACK(on_radiobutton_full_toggled), gpointer(this)); g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this)); gtk_widget_grab_focus(entry1); gtk_widget_grab_default(okbutton); gtk_label_set_mnemonic_widget(GTK_LABEL(label1), entry1); on_entry(); on_radiobutton(); }
GtkWidget *Create_Log_Area (void) { GtkWidget *Frame; GtkWidget *ScrollWindowLogList; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *PopupMenu; Frame = gtk_frame_new(_("Log")); gtk_container_set_border_width(GTK_CONTAINER(Frame), 2); /* * The ScrollWindow and the List */ ScrollWindowLogList = gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowLogList), GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(Frame),ScrollWindowLogList); /* The file list */ logListModel = gtk_list_store_new(LOG_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_COLOR, GDK_TYPE_COLOR); LogList = gtk_tree_view_new_with_model(GTK_TREE_MODEL(logListModel)); g_object_unref (logListModel); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(LogList), FALSE); gtk_container_add(GTK_CONTAINER(ScrollWindowLogList), LogList); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(LogList), FALSE); gtk_widget_set_size_request(LogList, 0, 0); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(LogList), FALSE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(LogList)),GTK_SELECTION_MULTIPLE); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(LogList), column); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "stock-id", LOG_PIXBUF, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "text", LOG_TIME_TEXT, "background-gdk", LOG_ROW_BACKGROUND, "foreground-gdk", LOG_ROW_FOREGROUND, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "text", LOG_TEXT, "background-gdk", LOG_ROW_BACKGROUND, "foreground-gdk", LOG_ROW_FOREGROUND, NULL); // Create Popup Menu on browser album list PopupMenu = gtk_ui_manager_get_widget(UIManager, "/LogPopup"); gtk_menu_attach_to_widget (GTK_MENU (PopupMenu), LogList, NULL); g_signal_connect (G_OBJECT (LogList), "button-press-event", G_CALLBACK (Log_Popup_Menu_Handler), PopupMenu); // Load pending messages in the Log list Log_Print_Tmp_List(); if (SHOW_LOG_VIEW) //gtk_widget_show_all(ScrollWindowLogList); gtk_widget_show_all(Frame); //return ScrollWindowLogList; return Frame; }
static GtkWidget *create_window(void) { // Basic window stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER); gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE); gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG); // Horizontal layout of banner and controls stwidgets.hlayout = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout); // banner { GdkPixbuf *pixbuf = load_banner(); stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf); g_object_unref((gpointer)pixbuf); } gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0); // Vertical layout of tab control and start+cancel buttons stwidgets.vlayout = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0); // Tab control stwidgets.tabs = gtk_notebook_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4); // layout table of config page stwidgets.configtlayout = gtk_table_new(6, 3, FALSE); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout); // 3D video mode LabelText stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, 0, 4, 0); // 3D video mode combo { GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); GtkCellRenderer *cell; stwidgets.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(stwidgets.vmode3dcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Fullscreen checkbox stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, 0, 4, 0); stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0); #ifdef POLYMER // Polymer checkbox stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer"); gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0); #endif // Input devices LabelText stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, 0, 4, 0); // Input devices combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.inputdevcombo = 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(stwidgets.inputdevcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2, GTK_EXPAND | GTK_FILL, 0, 4, 0); // Custom mod LabelText stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:"); gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, 0, 4, 7); // Custom mod combo { GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING); GtkCellRenderer *cell; stwidgets.custommodcombo = 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(stwidgets.custommodcombo), cell, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL); } gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3, GTK_EXPAND | GTK_FILL, 0, 4, 7); // Empty horizontal layout stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, 0, GTK_EXPAND | GTK_FILL, 4, 0); // Autoload checkbox stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, 0, 2, 2); // Always show config checkbox stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup"); gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, 0, 2, 2); // Configuration tab stwidgets.configtab = gtk_label_new("Configuration"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab); // Game data layout stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4); // Game data field LabelText stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:"); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5); // Game data scrollable area stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.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); stwidgets.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(stwidgets.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(stwidgets.gamelist), col); } gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE); // Game tab stwidgets.gametab = gtk_label_new("Game"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab); // Messages scrollable area stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); // Messages text area stwidgets.messagestext = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext); gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2); // Messages tab stwidgets.messagestab = gtk_label_new("Messages"); gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab); // Dialogue box buttons layout stwidgets.buttons = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3); gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END); // Cancel button stwidgets.cancelbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton); GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT); stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign); stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout); stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0); stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel"); gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0); // Start button stwidgets.startbutton = gtk_button_new(); gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton); GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT); gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton); stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign); stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2); gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout); stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0); stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start"); gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0); // Wire up the signals g_signal_connect((gpointer) stwidgets.startwin, "delete_event", G_CALLBACK(on_startwin_delete_event), NULL); g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed", G_CALLBACK(on_vmode3dcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled", G_CALLBACK(on_fullscreencheck_toggled), NULL); #ifdef POLYMER g_signal_connect((gpointer) stwidgets.polymercheck, "toggled", G_CALLBACK(on_polymercheck_toggled), NULL); #endif g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed", G_CALLBACK(on_inputdevcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.custommodcombo, "changed", G_CALLBACK(on_custommodcombo_changed), NULL); g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled", G_CALLBACK(on_autoloadcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled", G_CALLBACK(on_alwaysshowcheck_toggled), NULL); g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked", G_CALLBACK(on_cancelbutton_clicked), NULL); g_signal_connect((gpointer) stwidgets.startbutton, "clicked", G_CALLBACK(on_startbutton_clicked), NULL); { GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.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(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo); gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist); return stwidgets.startwin; }
static void setup_dialog(GtkBuilder* builder, PagerData* pager) { gboolean value; GtkTreeViewColumn* column; GtkCellRenderer* cell; int nr_ws, i; pager->workspaces_frame = WID("workspaces_frame"); pager->workspace_names_label = WID("workspace_names_label"); pager->workspace_names_scroll = WID("workspace_names_scroll"); pager->display_workspaces_toggle = WID("workspace_name_toggle"); setup_sensitivity(pager, builder, "workspace_name_toggle", NULL, NULL, "display_workspace_names" /* key */); pager->all_workspaces_radio = WID("all_workspaces_radio"); pager->current_only_radio = WID("current_only_radio"); setup_sensitivity(pager, builder, "all_workspaces_radio", "current_only_radio", "label_row_col", "display_all_workspaces" /* key */); pager->num_rows_spin = WID("num_rows_spin"); pager->label_row_col = WID("label_row_col"); setup_sensitivity(pager, builder, "num_rows_spin", NULL, NULL, "num_rows" /* key */); pager->num_workspaces_spin = WID("num_workspaces_spin"); setup_sensitivity(pager, builder, "num_workspaces_spin", NULL, NULL, NUM_WORKSPACES /* key */); pager->workspaces_tree = WID("workspaces_tree_view"); setup_sensitivity(pager, builder, "workspaces_tree_view", NULL, NULL, WORKSPACE_NAME /* key */); /* Display workspace names: */ g_signal_connect(G_OBJECT(pager->display_workspaces_toggle), "toggled", (GCallback) display_workspace_names_toggled, pager); if (pager->display_mode == MATEWNCK_PAGER_DISPLAY_NAME) { value = TRUE; } else { value = FALSE; } gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->display_workspaces_toggle), value); /* Display all workspaces: */ g_signal_connect(G_OBJECT(pager->all_workspaces_radio), "toggled", (GCallback) all_workspaces_toggled, pager); if (pager->display_all) { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->all_workspaces_radio), TRUE); if (!g_object_get_data(G_OBJECT(pager->num_rows_spin), NEVER_SENSITIVE)) { gtk_widget_set_sensitive(pager->num_rows_spin, TRUE); } } else { gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->current_only_radio), TRUE); gtk_widget_set_sensitive(pager->num_rows_spin, FALSE); } /* Num rows: */ g_signal_connect(G_OBJECT(pager->num_rows_spin), "value_changed", (GCallback) num_rows_value_changed, pager); gtk_spin_button_set_value(GTK_SPIN_BUTTON(pager->num_rows_spin), pager->n_rows); gtk_label_set_text(GTK_LABEL(pager->label_row_col), pager->orientation == GTK_ORIENTATION_HORIZONTAL ? _("rows") : _("columns")); g_signal_connect(pager->properties_dialog, "destroy", G_CALLBACK(properties_dialog_destroyed), pager); g_signal_connect(pager->properties_dialog, "delete_event", G_CALLBACK(delete_event), pager); g_signal_connect(pager->properties_dialog, "response", G_CALLBACK(response_cb), pager); g_signal_connect(WID("done_button"), "clicked", (GCallback) close_dialog, pager); gtk_spin_button_set_value(GTK_SPIN_BUTTON(pager->num_workspaces_spin), matewnck_screen_get_workspace_count(pager->screen)); g_signal_connect(G_OBJECT(pager->num_workspaces_spin), "value_changed", (GCallback) num_workspaces_value_changed, pager); wncklet_connect_while_alive(pager->screen, "workspace_created", G_CALLBACK(workspace_created), pager, pager->properties_dialog); wncklet_connect_while_alive(pager->screen, "workspace_destroyed", G_CALLBACK(workspace_destroyed), pager, pager->properties_dialog); g_signal_connect(G_OBJECT(pager->workspaces_tree), "focus_out_event", (GCallback) workspaces_tree_focused_out, pager); pager->workspaces_store = gtk_list_store_new(1, G_TYPE_STRING, NULL); update_workspaces_model(pager); gtk_tree_view_set_model(GTK_TREE_VIEW(pager->workspaces_tree), GTK_TREE_MODEL(pager->workspaces_store)); g_object_unref(pager->workspaces_store); cell = g_object_new(GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL); column = gtk_tree_view_column_new_with_attributes("workspace", cell, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(pager->workspaces_tree), column); g_signal_connect(cell, "edited", (GCallback) workspace_name_edited, pager); nr_ws = matewnck_screen_get_workspace_count(pager->screen); for (i = 0; i < nr_ws; i++) { wncklet_connect_while_alive(G_OBJECT(matewnck_screen_get_workspace(pager->screen, i)), "name_changed", G_CALLBACK(workspace_renamed), pager, pager->properties_dialog); } update_properties_for_wm(pager); }
/* * create target page */ void tpage_init() { page = gtk_hbox_new(FALSE, 0); GtkWidget *lbox = gtk_vbox_new(FALSE, SPACING); GtkWidget *mbox = gtk_vbox_new(FALSE, SPACING); GtkWidget *rbox = gtk_vbox_new(FALSE, SPACING); GtkWidget* separator = gtk_vseparator_new(); /* right box with Load/Save buttons */ gtk_container_set_border_width(GTK_CONTAINER(rbox), SPACING); loadbtn = gtk_button_new_from_stock(GTK_STOCK_OPEN); g_signal_connect(G_OBJECT(loadbtn), "clicked", G_CALLBACK (on_load_config), (gpointer)TRUE); savebtn = gtk_button_new_from_stock(GTK_STOCK_SAVE); g_signal_connect(G_OBJECT(savebtn), "clicked", G_CALLBACK (on_save_config), NULL); clearbtn = gtk_button_new_from_stock(GTK_STOCK_CLEAR); g_signal_connect(G_OBJECT(clearbtn), "clicked", G_CALLBACK (on_clear), NULL); gtk_box_pack_start(GTK_BOX(rbox), loadbtn, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(rbox), savebtn, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(rbox), clearbtn, FALSE, TRUE, 0); GtkWidget *hombox = gtk_hbox_new(TRUE, 0); /* left box */ gtk_container_set_border_width(GTK_CONTAINER(lbox), SPACING); /* Target frame */ GtkWidget *frame = gtk_frame_new(_("Target")); GtkWidget *vbox = gtk_vbox_new(FALSE, 0); /* filename hbox */ GtkWidget *hbox = gtk_hbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); targetname = gtk_entry_new (); button_browse = gtk_button_new_with_label(_("Browse")); g_signal_connect(G_OBJECT(button_browse), "clicked", G_CALLBACK (on_target_browse_clicked), NULL); gtk_box_pack_start(GTK_BOX(hbox), targetname, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), button_browse, FALSE, TRUE, 0); /* pack in the vertical box */ gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); /* debugger type hbox */ hbox = gtk_hbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); GtkWidget *label = gtk_label_new(_("Debugger:")); cmb_debugger = gtk_combo_box_new_text(); GList *modules = debug_get_modules(); GList *iter = modules; while (iter) { gtk_combo_box_append_text(GTK_COMBO_BOX(cmb_debugger), (gchar*)iter->data); iter = iter->next; } g_list_free(modules); gtk_combo_box_set_active(GTK_COMBO_BOX(cmb_debugger), 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), cmb_debugger, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), vbox); gtk_box_pack_start(GTK_BOX(lbox), frame, FALSE, FALSE, 0); /* Arguments frame */ frame = gtk_frame_new(_("Arguments")); hbox = gtk_vbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR); gtk_box_pack_start(GTK_BOX(hbox), textview, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_box_pack_start(GTK_BOX(lbox), frame, TRUE, TRUE, 0); /* Environment */ gtk_container_set_border_width(GTK_CONTAINER(mbox), SPACING); frame = gtk_frame_new(_("Environment variables")); hbox = gtk_hbox_new(FALSE, SPACING); gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING); store = gtk_list_store_new ( N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING); model = GTK_TREE_MODEL(store); envtree = gtk_tree_view_new_with_model (model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(envtree), TRUE); gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(envtree), GTK_TREE_VIEW_GRID_LINES_VERTICAL); g_object_set(envtree, "rules-hint", TRUE, NULL); g_signal_connect(G_OBJECT(envtree), "key-press-event", G_CALLBACK (on_envtree_keypressed), NULL); gchar *header; int char_width = get_char_width(envtree); header = _("Name"); renderer_name = gtk_cell_renderer_text_new (); g_object_set (renderer_name, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (renderer_name), "edited", G_CALLBACK (on_name_changed), NULL); column_name = create_column(header, renderer_name, FALSE, get_header_string_width(header, MW_NAME, char_width), "text", NAME); gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_name); header = _("Value"); renderer_value = gtk_cell_renderer_text_new (); column_value = create_column(header, renderer_value, TRUE, get_header_string_width(header, MW_VALUE, char_width), "text", VALUE); g_signal_connect (G_OBJECT (renderer_value), "edited", G_CALLBACK (on_value_changed), NULL); g_signal_connect (G_OBJECT (renderer_value), "editing-started", G_CALLBACK (on_value_editing_started), NULL); g_signal_connect (G_OBJECT (renderer_value), "editing-canceled", G_CALLBACK (on_value_editing_cancelled), NULL); gtk_tree_view_column_set_cell_data_func(column_value, renderer_value, on_render_value, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_value); /* add empty row */ add_empty_row(); /* set multiple selection */ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(envtree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_box_pack_start(GTK_BOX(hbox), envtree, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame), hbox); gtk_box_pack_start(GTK_BOX(mbox), frame, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hombox), lbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hombox), mbox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), hombox, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), separator, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), rbox, FALSE, TRUE, 0); /* update Load/Save config button */ tpage_on_document_activate(document_get_current()); }
static void gtk_app_chooser_widget_add_items (GtkAppChooserWidget *self) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeModel *sort; /* create list store */ self->priv->program_list_store = gtk_list_store_new (NUM_COLUMNS, G_TYPE_APP_INFO, G_TYPE_ICON, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (self->priv->program_list_store)); gtk_tree_view_set_model (GTK_TREE_VIEW (self->priv->program_list), GTK_TREE_MODEL (sort)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort), COLUMN_NAME, GTK_SORT_ASCENDING); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort), COLUMN_NAME, gtk_app_chooser_sort_func, self, NULL); gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->program_list), COLUMN_NAME); gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (self->priv->program_list), gtk_app_chooser_search_equal_func, NULL, NULL); column = gtk_tree_view_column_new (); /* initial padding */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); g_object_set (renderer, "xpad", self->priv->show_all ? 0 : 6, NULL); self->priv->padding_renderer = renderer; /* heading text renderer */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "markup", COLUMN_HEADING_TEXT, "visible", COLUMN_HEADING, NULL); g_object_set (renderer, "ypad", 6, "xpad", 0, "wrap-width", 350, "wrap-mode", PANGO_WRAP_WORD, NULL); /* padding renderer for non-heading cells */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func (column, renderer, padding_cell_renderer_func, NULL, NULL); /* app icon renderer */ renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "gicon", COLUMN_GICON, NULL); g_object_set (renderer, "stock-size", GTK_ICON_SIZE_MENU, NULL); /* app name renderer */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "markup", COLUMN_DESC, NULL); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->program_list), column); /* populate the widget */ gtk_app_chooser_widget_real_add_items (self); }
/***************************************************************************** * Run: Gtk+ thread ***************************************************************************** * this part of the interface is in a separate thread so that we can call * gtk_main() from within it without annoying the rest of the program. *****************************************************************************/ static void Run( intf_thread_t *p_intf ) { #ifndef NEED_GTK2_MAIN /* gtk_init needs to know the command line. We don't care, so we * give it an empty one */ char *p_args[] = { "", NULL }; char **pp_args = p_args; int i_args = 1; int i_dummy; #endif playlist_t *p_playlist; GtkCellRenderer *p_renderer = NULL; GtkTreeViewColumn *p_column = NULL; GtkListStore *p_filelist = NULL; GtkListStore *p_playlist_store = NULL; #ifndef NEED_GTK2_MAIN gtk_set_locale (); msg_Dbg( p_intf, "Starting pda GTK2+ interface" ); gtk_init( &i_args, &pp_args ); #else /* Initialize Gtk+ */ msg_Dbg( p_intf, "Starting pda GTK2+ interface thread" ); gdk_threads_enter(); #endif /* Create some useful widgets that will certainly be used */ /* FIXME: magic path */ add_pixmap_directory("share"); add_pixmap_directory("/usr/share/vlc"); /* Path for pixmaps under linupy 1.4 */ add_pixmap_directory("/usr/local/share/pixmaps/vlc"); /* Path for pixmaps under linupy 2.0 */ add_pixmap_directory("/usr/share/pixmaps/vlc"); p_intf->p_sys->p_window = create_pda(); if (p_intf->p_sys->p_window == NULL) { msg_Err( p_intf, "unable to create pda interface" ); } /* Store p_intf to keep an eye on it */ gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_window), "p_intf", p_intf ); /* Set the title of the main window */ gtk_window_set_title( GTK_WINDOW(p_intf->p_sys->p_window), VOUT_TITLE " (PDA Linux interface)"); /* Get the notebook object */ p_intf->p_sys->p_notebook = GTK_NOTEBOOK( gtk_object_get_data( GTK_OBJECT( p_intf->p_sys->p_window ), "notebook" ) ); /* Get the slider object */ p_intf->p_sys->p_slider = (GtkHScale*) lookup_widget( p_intf->p_sys->p_window, "timeSlider" ); p_intf->p_sys->p_slider_label = (GtkLabel*) lookup_widget( p_intf->p_sys->p_window, "timeLabel" ); if (p_intf->p_sys->p_slider == NULL) msg_Err( p_intf, "Time slider widget not found." ); if (p_intf->p_sys->p_slider_label == NULL) msg_Err( p_intf, "Time label widget not found." ); /* Connect the date display to the slider */ p_intf->p_sys->p_adj = gtk_range_get_adjustment( GTK_RANGE(p_intf->p_sys->p_slider) ); if (p_intf->p_sys->p_adj == NULL) msg_Err( p_intf, "Adjustment range not found." ); g_signal_connect( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed", G_CALLBACK( E_(GtkDisplayDate) ), p_intf ); p_intf->p_sys->f_adj_oldvalue = 0; p_intf->p_sys->i_adj_oldvalue = 0; /* BEGIN OF FILEVIEW GTK_TREE_VIEW */ p_intf->p_sys->p_tvfile = NULL; p_intf->p_sys->p_tvfile = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvFileList"); if (NULL == p_intf->p_sys->p_tvfile) msg_Err(p_intf, "Error obtaining pointer to File List"); /* Insert columns 0 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Insert columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 1, (gchar *) N_("Permissions"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); /* Insert columns 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 2, (gchar *) N_("Size"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); /* Insert columns 3 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 3, (gchar *) N_("Owner"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 3 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 3 ); gtk_tree_view_column_set_sort_column_id(p_column, 3); /* Insert columns 4 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 4, (gchar *) N_("Group"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 4 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 4 ); gtk_tree_view_column_set_sort_column_id(p_column, 4); /* Get new directory listing */ p_filelist = gtk_list_store_new (5, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* permissions */ G_TYPE_UINT64, /* File size */ G_TYPE_STRING, /* Owner */ G_TYPE_STRING);/* Group */ ReadDirectory(p_intf, p_filelist, "."); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile), GTK_TREE_MODEL(p_filelist)); g_object_unref(p_filelist); /* Model will be released by GtkTreeView */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvfile, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvfile); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile),TRUE); /* END OF FILEVIEW GTK_TREE_VIEW */ /* BEGIN OF PLAYLIST GTK_TREE_VIEW */ p_intf->p_sys->p_tvplaylist = NULL; p_intf->p_sys->p_tvplaylist = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvPlaylist"); if (NULL == p_intf->p_sys->p_tvplaylist) msg_Err(p_intf, "Error obtaining pointer to Play List"); /* Columns 1 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 0, (gchar *) N_("Filename"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 0 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 ); gtk_tree_view_column_set_sort_column_id(p_column, 0); /* Column 2 */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 1, (gchar *) N_("Time"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 1 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 ); gtk_tree_view_column_set_sort_column_id(p_column, 1); #if 0 /* Column 3 - is a hidden column used for reliable deleting items from the underlying playlist */ p_renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 2, (gchar *) N_("Index"), p_renderer, NULL); p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 2 ); gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 ); gtk_tree_view_column_set_sort_column_id(p_column, 2); #endif /* update the playlist */ p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE ); p_playlist_store = gtk_list_store_new (3, G_TYPE_STRING, /* Filename */ G_TYPE_STRING, /* Time */ G_TYPE_UINT); /* Hidden index */ PlaylistRebuildListStore(p_playlist_store, p_playlist); gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist), GTK_TREE_MODEL(p_playlist_store)); g_object_unref(p_playlist_store); vlc_object_release(p_playlist); /* Free the playlist */ gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist)),GTK_SELECTION_MULTIPLE); /* Column properties */ gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvplaylist, TRUE); gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvplaylist); gtk_tree_view_set_headers_clickable(p_intf->p_sys->p_tvplaylist, TRUE); /* END OF PLAYLIST GTK_TREE_VIEW */ /* Hide the Preference TAB for now. */ GtkWidget *p_preference_tab = NULL; p_preference_tab = gtk_notebook_get_nth_page(p_intf->p_sys->p_notebook,5); if (p_preference_tab != NULL) gtk_widget_hide(p_preference_tab); /* Show the control window */ gtk_widget_show( p_intf->p_sys->p_window ); #ifdef NEED_GTK2_MAIN msg_Dbg( p_intf, "Manage GTK keyboard events using threads" ); while( !p_intf->b_die ) { Manage( p_intf ); /* Sleep to avoid using all CPU - since some interfaces need to * access keyboard events, a 100ms delay is a good compromise */ gdk_threads_leave(); if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) msleep( INTF_IDLE_SLEEP ); else msleep( 1000 ); gdk_threads_enter(); } #else msg_Dbg( p_intf, "Manage GTK keyboard events using timeouts" ); /* Sleep to avoid using all CPU - since some interfaces needs to access * keyboard events, a 1000ms delay is a good compromise */ if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU) i_dummy = gtk_timeout_add( INTF_IDLE_SLEEP / 1000, (GtkFunction)Manage, p_intf ); else i_dummy = gtk_timeout_add( 1000, (GtkFunction)Manage, p_intf ); /* Enter Gtk mode */ gtk_main(); /* Remove the timeout */ gtk_timeout_remove( i_dummy ); #endif gtk_object_destroy( GTK_OBJECT(p_intf->p_sys->p_window) ); #ifdef NEED_GTK2_MAIN gdk_threads_leave(); #endif }
static GtkWidget *_create_cluster_combo(void) { GtkListStore *model = NULL; GtkWidget *combo = NULL; GtkTreeIter iter; ListIterator itr; slurmdb_cluster_rec_t *cluster_rec; GtkCellRenderer *renderer = NULL; bool got_db = slurm_get_is_association_based_accounting(); int count = 0, spot = 0; if (!got_db) return NULL; cluster_list = slurmdb_get_info_cluster(NULL); if (!cluster_list || !list_count(cluster_list)) { FREE_NULL_LIST(cluster_list); return NULL; } if (!orig_cluster_name) orig_cluster_name = slurm_get_cluster_name(); if (list_count(cluster_list) > 1) model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER); /* Set up the working_cluster_rec just incase we are on a node that doesn't technically belong to a cluster (like the node running the slurmdbd). */ working_cluster_rec = list_peek(cluster_list); itr = list_iterator_create(cluster_list); while ((cluster_rec = list_next(itr))) { if (model) { gtk_list_store_append(model, &iter); gtk_list_store_set(model, &iter, 0, cluster_rec->name, 1, cluster_rec, -1); } if (!xstrcmp(cluster_rec->name, orig_cluster_name)) { /* clear it since we found the current cluster */ working_cluster_rec = NULL; spot = count; } count++; } list_iterator_destroy(itr); if (model) { combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model)); g_object_unref(model); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, true); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(combo), renderer, "text", 0); gtk_combo_box_set_active(GTK_COMBO_BOX(combo), spot); g_signal_connect(combo, "changed", G_CALLBACK(_change_cluster_main), NULL); } return combo; }