/* Create list */ static GtkWidget* create_list(void) { GtkListStore *list_store; GtkWidget *list; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSortable *sortable; GtkTreeView *list_view; GtkTreeSelection *selection; /* Create the store */ list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX*/ G_TYPE_UINT, /* Op Code */ G_TYPE_STRING, /* Operation Name */ G_TYPE_UINT, /* Count */ G_TYPE_UINT, /* Total Bytes */ G_TYPE_FLOAT); /* Avg Bytes */ /* Create a view */ list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); list_view = GTK_TREE_VIEW(list); sortable = GTK_TREE_SORTABLE(list_store); /* Speed up the list display */ gtk_tree_view_set_fixed_height_mode(list_view, TRUE); /* Setup the sortable columns */ gtk_tree_sortable_set_sort_column_id(sortable, OP_CODE_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_headers_clickable(list_view, FALSE); /* The view now holds a reference. We can get rid of our own reference */ g_object_unref (G_OBJECT (list_store)); /* * Create the first column packet, associating the "text" attribute of the * cell_renderer to the first column of the model */ /* 1:st column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Op Code", renderer, "text", OP_CODE_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, present_as_hex_func, GINT_TO_POINTER(OP_CODE_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, OP_CODE_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 60); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); /* 2:nd column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Operation Name", renderer, "text", OP_CODE_NAME_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, OP_CODE_NAME_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 290); gtk_tree_view_append_column (list_view, column); /* 3:d column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Count", renderer, "text", COUNT_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, COUNT_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 50); gtk_tree_view_append_column (list_view, column); /* 4:th column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Total Bytes", renderer, "text", TOT_BYTES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, TOT_BYTES_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 100); gtk_tree_view_append_column (list_view, column); /* 10:th column.. Avg Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer, "text", AVG_BYTES_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func, GINT_TO_POINTER(AVG_BYTES_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 50); gtk_tree_view_append_column (list_view, column); /* Now enable the sorting of each column */ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE); /* Setup the selection handler */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); return list; }
void fi_gui_init(void) { fi_sources = htable_create(HASH_KEY_SELF, 0); { GtkTreeViewColumn *column; GtkTreeView *tv; tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_aliases")); treeview_download_aliases = tv; store_aliases = gtk_list_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_aliases)); column = gtk_tree_view_column_new_with_attributes(_("Aliases"), create_text_cell_renderer(0.0), "text", 0, NULL_PTR); configure_column(column); gtk_tree_view_column_set_sort_column_id(column, 0); gtk_tree_view_append_column(tv, column); tree_view_set_fixed_height_mode(tv, TRUE); drag_attach_text(GTK_WIDGET(tv), fi_gui_get_alias); } { static const struct { enum c_src id; const char *title; } tab[] = { { c_src_host, N_("Host"), }, { c_src_country, N_("Country"), }, { c_src_server, N_("Server"), }, { c_src_range, N_("Range"), }, { c_src_progress, N_("Progress"), }, { c_src_status, N_("Status"), }, }; GtkTreeView *tv; unsigned i; STATIC_ASSERT(c_src_num == N_ITEMS(tab)); tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_sources")); treeview_download_sources = tv; store_sources = gtk_list_store_new(1, G_TYPE_POINTER); gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_sources)); for (i = 0; i < N_ITEMS(tab); i++) { GtkCellRenderer *renderer; renderer = tab[i].id == c_src_progress ? gtk_cell_renderer_progress_new() : NULL; (void) add_column(tv, tab[i].id, _(tab[i].title), 0.0, renderer, render_sources); } gtk_tree_view_set_headers_clickable(tv, FALSE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv), GTK_SELECTION_MULTIPLE); tree_view_restore_widths(tv, PROP_SOURCES_COL_WIDTHS); tree_view_set_fixed_height_mode(tv, TRUE); widget_add_popup_menu(GTK_WIDGET(tv), fi_gui_sources_get_popup_menu); } fi_gui_details_treeview_init(); fi_gui_common_init(); { uint32 page; GtkNotebook *notebook_downloads_info = GTK_NOTEBOOK(gui_main_window_lookup("notebook_downloads_info")); gui_prop_get_guint32_val(PROP_DOWNLOADS_INFO_NOTEBOOK_TAB, &page); if (page >= NUM_DOWNLOADS_INFO_NB_PAGES) page = DOWNLOADS_INFO_NB_PAGE_DETAILS; notebook_downloads_info_current_page = page; gtk_notebook_set_current_page(notebook_downloads_info, page); gui_signal_connect(notebook_downloads_info, "switch-page", on_notebook_downloads_info_switch_page, NULL); } }
/** * create_bookmarks_window: * * Create a new bookmark-editing window. * @list: The CajaBookmarkList that this window will edit. * * Return value: A pointer to the new window. **/ GtkWindow * create_bookmarks_window (CajaBookmarkList *list, CajaWindow *window_source) { GtkWidget *window; GtkTreeViewColumn *col; GtkCellRenderer *rend; GtkBuilder *builder; bookmarks = list; builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UIDIR "/caja-bookmarks-window.ui", NULL)) { return NULL; } window = (GtkWidget *)gtk_builder_get_object (builder, "bookmarks_dialog"); bookmark_list_widget = (GtkTreeView *)gtk_builder_get_object (builder, "bookmark_tree_view"); remove_button = (GtkWidget *)gtk_builder_get_object (builder, "bookmark_delete_button"); jump_button = (GtkWidget *)gtk_builder_get_object (builder, "bookmark_jump_button"); application = window_source->application; if (CAJA_IS_NAVIGATION_WINDOW (window_source)) { parent_is_browser_window = TRUE; } else { parent_is_browser_window = FALSE; } set_up_close_accelerator (window); gtk_window_set_wmclass (GTK_WINDOW (window), "bookmarks", "Caja"); caja_bookmarks_window_restore_geometry (window); g_object_weak_ref (G_OBJECT (window_source), edit_bookmarks_dialog_reset_signals, window_source); bookmark_list_widget = GTK_TREE_VIEW (gtk_builder_get_object (builder, "bookmark_tree_view")); rend = gtk_cell_renderer_pixbuf_new (); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "pixbuf", BOOKMARK_LIST_COLUMN_ICON, NULL); gtk_tree_view_append_column (bookmark_list_widget, GTK_TREE_VIEW_COLUMN (col)); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), CAJA_ICON_SIZE_SMALLER); rend = gtk_cell_renderer_text_new (); g_object_set (rend, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "text", BOOKMARK_LIST_COLUMN_NAME, "style", BOOKMARK_LIST_COLUMN_STYLE, NULL); gtk_tree_view_append_column (bookmark_list_widget, GTK_TREE_VIEW_COLUMN (col)); bookmark_list_store = create_bookmark_store (); setup_empty_list (); gtk_tree_view_set_model (bookmark_list_widget, GTK_TREE_MODEL (bookmark_empty_list_store)); bookmark_selection = GTK_TREE_SELECTION (gtk_tree_view_get_selection (bookmark_list_widget)); name_field = caja_entry_new (); gtk_widget_show (name_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_name_placeholder")), name_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_name_label")), name_field); uri_field = caja_entry_new (); gtk_widget_show (uri_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_location_placeholder")), uri_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_location_label")), uri_field); bookmark_list_changed_signal_id = g_signal_connect (bookmarks, "contents_changed", G_CALLBACK (on_bookmark_list_changed), NULL); row_changed_signal_id = g_signal_connect (bookmark_list_store, "row_changed", G_CALLBACK (on_row_changed), NULL); row_deleted_signal_id = g_signal_connect (bookmark_list_store, "row_deleted", G_CALLBACK (on_row_deleted), NULL); row_activated_signal_id = g_signal_connect (bookmark_list_widget, "row_activated", G_CALLBACK (on_row_activated), window_source); button_pressed_signal_id = g_signal_connect (bookmark_list_widget, "button_press_event", G_CALLBACK (on_button_pressed), NULL); key_pressed_signal_id = g_signal_connect (bookmark_list_widget, "key_press_event", G_CALLBACK (on_key_pressed), NULL); selection_changed_id = g_signal_connect (bookmark_selection, "changed", G_CALLBACK (on_selection_changed), NULL); g_signal_connect (window, "delete_event", G_CALLBACK (on_window_delete_event), NULL); g_signal_connect (window, "hide", G_CALLBACK (on_window_hide_event), NULL); g_signal_connect (window, "destroy", G_CALLBACK (on_window_destroy_event), NULL); g_signal_connect (window, "response", G_CALLBACK (caja_bookmarks_window_response_callback), NULL); name_field_changed_signal_id = g_signal_connect (name_field, "changed", G_CALLBACK (on_name_field_changed), NULL); g_signal_connect (name_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), NULL); g_signal_connect (name_field, "activate", G_CALLBACK (name_or_uri_field_activate), NULL); uri_field_changed_signal_id = g_signal_connect (uri_field, "changed", G_CALLBACK (on_uri_field_changed), NULL); g_signal_connect (uri_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), NULL); g_signal_connect (uri_field, "activate", G_CALLBACK (name_or_uri_field_activate), NULL); g_signal_connect (remove_button, "clicked", G_CALLBACK (on_remove_button_clicked), NULL); jump_button_signal_id = g_signal_connect (jump_button, "clicked", G_CALLBACK (on_jump_button_clicked), window_source); gtk_tree_selection_set_mode (bookmark_selection, GTK_SELECTION_BROWSE); /* Fill in list widget with bookmarks, must be after signals are wired up. */ repopulate(); g_object_unref (builder); return GTK_WINDOW (window); }
static void setup_profile_pages (GtrPreferencesDialog *dlg) { GtkTreeViewColumn *name_column, *toggle_column; GtkCellRenderer *text_renderer, *toggle_renderer; GtkListStore *model; model = gtk_list_store_new (PROFILE_N_COLUMNS, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_POINTER); gtk_tree_view_set_model (GTK_TREE_VIEW (dlg->priv->profile_treeview), GTK_TREE_MODEL (model)); g_object_unref (model); text_renderer = gtk_cell_renderer_text_new (); toggle_renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (toggle_renderer, "toggled", G_CALLBACK (active_toggled_cb), dlg); gtk_cell_renderer_toggle_set_activatable (GTK_CELL_RENDERER_TOGGLE (toggle_renderer), TRUE); gtk_cell_renderer_toggle_set_radio (GTK_CELL_RENDERER_TOGGLE (toggle_renderer), TRUE); name_column = gtk_tree_view_column_new_with_attributes (_("Profile"), text_renderer, "text", PROFILE_NAME_COLUMN, NULL); toggle_column = gtk_tree_view_column_new_with_attributes (_("Active"), toggle_renderer, "active", ACTIVE_PROFILE_COLUMN, NULL); gtk_tree_view_column_set_resizable (toggle_column, TRUE); gtk_tree_view_column_set_resizable (name_column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->profile_treeview), name_column); gtk_tree_view_append_column (GTK_TREE_VIEW (dlg->priv->profile_treeview), toggle_column); gtk_tree_view_column_set_expand (name_column, TRUE); fill_profile_treeview (dlg, GTK_TREE_MODEL (model)); /* Connect the signals */ g_signal_connect (dlg->priv->add_button, "clicked", G_CALLBACK (add_button_clicked), dlg); g_signal_connect (dlg->priv->delete_button, "clicked", G_CALLBACK (delete_button_clicked), dlg); g_signal_connect (dlg->priv->edit_button, "clicked", G_CALLBACK (edit_button_clicked), dlg); }
/** * Configure GtkTreeView with the right columns bound to * renderers, and a data model. **/ static void dcc_gnome_make_proc_view (GtkTreeModel *proc_model, GtkWidget **align_return) { GtkCellRenderer *text_renderer, *chart_renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkWidget *align, *proc_scroll; chart_treeview = gtk_tree_view_new_with_model (proc_model); gtk_object_set (GTK_OBJECT (chart_treeview), "headers-visible", TRUE, NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (chart_treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_NONE); /* we can't create the gcs until the widget is first realized */ g_signal_connect_after (chart_treeview, "realize", G_CALLBACK (dcc_create_state_gcs), NULL); text_renderer = gtk_cell_renderer_text_new (); chart_renderer = dcc_cell_renderer_chart_new (); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (chart_treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_NONE); /* Host */ column = gtk_tree_view_column_new_with_attributes ("Host", text_renderer, "text", COLUMN_HOST, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (chart_treeview), column); /* gtk_tree_view_column_set_sort_column_id (column, COLUMN_HOST); */ column = gtk_tree_view_column_new_with_attributes ("Slot", text_renderer, "text", COLUMN_SLOT, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (chart_treeview), column); /* File */ column = gtk_tree_view_column_new_with_attributes ("File", text_renderer, "text", COLUMN_FILE, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (chart_treeview), column); column = gtk_tree_view_column_new_with_attributes ("State", text_renderer, "text", COLUMN_STATE, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (chart_treeview), column); /* Tasks - for each cell, rebind the stock-id property onto that value from the table model */ column = gtk_tree_view_column_new_with_attributes ("Tasks", chart_renderer, "history", COLUMN_HISTORY, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (chart_treeview), column); proc_scroll = gtk_scrolled_window_new (NULL, NULL); /* no horizontal scrolling; let the table stretch */ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (proc_scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (proc_scroll), chart_treeview); /* Expands to fill all space */ align = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_container_add (GTK_CONTAINER (align), proc_scroll); *align_return = align; }
static void admin_user_add_columns (GtkTreeView *treeview) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; // GtkTreeModel *model = gtk_tree_view_get_model (treeview); /***************/ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (gettext("Хост"), renderer, "text", COL_HOST, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_HOST); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (gettext("База"), renderer, "text", COL_BAZA, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_BAZA); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (gettext("Логин"), renderer, "text", COL_LOGIN, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_LOGIN); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (gettext("Кодировка"), renderer, "text", COL_KODIROVKA, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_KODIROVKA); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (gettext("Организация"), renderer, "text", COL_NAIM_ORG, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_NAIM_ORG); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Select", renderer, "text", COL_SELECT, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_SELECT); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Insert", renderer, "text", COL_INSERT, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_INSERT); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Update", renderer, "text", COL_UPDATE, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_UPDATE); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Delete", renderer, "text", COL_DELETE, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_DELETE); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Create", renderer, "text", COL_CREATE, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_CREATE); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Drop", renderer, "text", COL_DROP, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_DROP); gtk_tree_view_append_column (treeview, column); /* ********** */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Grant", renderer, "text", COL_GRANT, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_GRANT); gtk_tree_view_append_column (treeview, column); }
void on_final_account_prepare (hierarchy_data *data) { GSList *actlist; GtkTreeView *tree_view; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gnc_commodity *com; /* Anything to do? */ if (!data->category_set_changed) return; data->category_set_changed = FALSE; gnc_suspend_gui_refresh (); /* Delete any existing account tree */ if (data->final_account_tree) { gtk_widget_destroy(GTK_WIDGET(data->final_account_tree)); data->final_account_tree = NULL; } delete_our_account_tree (data); /* Build a new account list */ actlist = get_selected_account_list (data->categories_tree); com = gnc_currency_edit_get_currency (GNC_CURRENCY_EDIT(data->currency_selector)); data->our_account_tree = hierarchy_merge_accounts (actlist, com); /* Now build a new account tree */ data->final_account_tree = GNC_TREE_VIEW_ACCOUNT(gnc_tree_view_account_new_with_root (data->our_account_tree, FALSE)); tree_view = GTK_TREE_VIEW(data->final_account_tree); gnc_tree_view_account_set_name_edited(data->final_account_tree, gnc_tree_view_account_name_edited_cb); gnc_tree_view_account_set_code_edited(data->final_account_tree, gnc_tree_view_account_code_edited_cb); gnc_tree_view_account_set_description_edited(data->final_account_tree, gnc_tree_view_account_description_edited_cb); gnc_tree_view_account_set_notes_edited(data->final_account_tree, gnc_tree_view_account_notes_edited_cb); gtk_tree_view_set_headers_visible (tree_view, TRUE); column = gnc_tree_view_find_column_by_name ( GNC_TREE_VIEW(data->final_account_tree), "type"); g_object_set_data(G_OBJECT(column), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); gnc_tree_view_configure_columns (GNC_TREE_VIEW(data->final_account_tree)); gnc_tree_view_set_show_column_menu (GNC_TREE_VIEW(data->final_account_tree), FALSE); selection = gtk_tree_view_get_selection (tree_view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); // This is a re-definition of the placeholder that the account-tree model // provides, reflecting the to-be-created state of the account tree // post-merge. { renderer = gtk_cell_renderer_toggle_new(); g_object_set(G_OBJECT (renderer), "activatable", FALSE, "sensitive", FALSE, NULL); column = gtk_tree_view_column_new_with_attributes(_("Placeholder"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, placeholder_cell_data_func, (gpointer)data, NULL); gnc_tree_view_append_column (GNC_TREE_VIEW(tree_view), column); } { renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "xalign", 1.0, (char *)NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (balance_cell_edited), data); column = gtk_tree_view_column_new_with_attributes (_("Opening Balance"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, balance_cell_data_func, (gpointer)data, NULL); gnc_tree_view_append_column (GNC_TREE_VIEW(tree_view), column); } // only in the case where there *are* existing accounts... if (gnc_account_n_descendants(gnc_book_get_root_account(gnc_get_current_book())) > 0) { GList *renderers; column = gnc_tree_view_add_text_column(GNC_TREE_VIEW(tree_view), _("Use Existing"), NULL, NULL, "yes", GNC_TREE_VIEW_COLUMN_DATA_NONE, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, NULL); renderers = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column)); g_object_set(G_OBJECT(renderer), "xalign", 1.0, (char*)NULL); gtk_tree_view_column_set_cell_data_func(column, GTK_CELL_RENDERER(renderers->data), use_existing_account_data_func, (gpointer)data, NULL); g_list_free(renderers); } gtk_container_add(GTK_CONTAINER(data->final_account_tree_container), GTK_WIDGET(data->final_account_tree)); /* Expand the entire tree */ gtk_tree_view_expand_all (tree_view); gtk_widget_show(GTK_WIDGET(data->final_account_tree)); gnc_resume_gui_refresh (); }
static void impl_constructed (GObject *object) { RBPodcastAddDialog *dialog; GtkBuilder *builder; GtkWidget *widget; GtkWidget *paned; GtkTreeViewColumn *column; GtkCellRenderer *renderer; RBEntryView *episodes; RBShellPlayer *shell_player; RhythmDBQuery *query; RhythmDBQueryModel *query_model; const char *episode_strings[3]; RB_CHAIN_GOBJECT_METHOD (rb_podcast_add_dialog_parent_class, constructed, object); dialog = RB_PODCAST_ADD_DIALOG (object); g_object_get (dialog->priv->podcast_mgr, "db", &dialog->priv->db, NULL); builder = rb_builder_load ("podcast-add-dialog.ui", NULL); dialog->priv->info_bar_message = gtk_label_new (""); dialog->priv->info_bar = gtk_info_bar_new (); g_object_set (dialog->priv->info_bar, "spacing", 0, NULL); gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar))), dialog->priv->info_bar_message); gtk_widget_set_no_show_all (dialog->priv->info_bar, TRUE); gtk_box_pack_start (GTK_BOX (dialog), dialog->priv->info_bar, FALSE, FALSE, 0); gtk_widget_show (dialog->priv->info_bar_message); dialog->priv->subscribe_button = GTK_WIDGET (gtk_builder_get_object (builder, "subscribe-button")); g_signal_connect_object (dialog->priv->subscribe_button, "clicked", G_CALLBACK (subscribe_clicked_cb), dialog, 0); gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE); dialog->priv->feed_view = GTK_WIDGET (gtk_builder_get_object (builder, "feed-view")); g_signal_connect (dialog->priv->feed_view, "row-activated", G_CALLBACK (feed_activated_cb), dialog); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)), "changed", G_CALLBACK (feed_selection_changed_cb), dialog); dialog->priv->search_entry = rb_search_entry_new (FALSE); gtk_widget_set_size_request (GTK_WIDGET (dialog->priv->search_entry), 400, -1); g_object_set (dialog->priv->search_entry,"explicit-mode", TRUE, NULL); g_signal_connect (dialog->priv->search_entry, "search", G_CALLBACK (search_cb), dialog); g_signal_connect (dialog->priv->search_entry, "activate", G_CALLBACK (search_cb), dialog); gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "search-entry-box")), GTK_WIDGET (dialog->priv->search_entry)); g_signal_connect (gtk_builder_get_object (builder, "close-button"), "clicked", G_CALLBACK (close_clicked_cb), dialog); dialog->priv->feed_model = gtk_list_store_new (7, G_TYPE_STRING, /* name */ G_TYPE_STRING, /* author */ GDK_TYPE_PIXBUF, /* image */ G_TYPE_FILE, /* image file */ G_TYPE_INT, /* episode count */ G_TYPE_POINTER, /* RBPodcastChannel */ G_TYPE_ULONG); /* date */ gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->feed_view), GTK_TREE_MODEL (dialog->priv->feed_model)); column = gtk_tree_view_column_new_with_attributes (_("Title"), gtk_cell_renderer_pixbuf_new (), "pixbuf", FEED_COLUMN_IMAGE, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", FEED_COLUMN_TITLE, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", FEED_COLUMN_AUTHOR, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Episodes"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, episode_count_column_cell_data_func, NULL, NULL); episode_strings[0] = "0000"; episode_strings[1] = _("Episodes"); episode_strings[2] = NULL; rb_set_tree_view_column_fixed_width (dialog->priv->feed_view, column, renderer, episode_strings, 6); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast-add-dialog")); gtk_box_pack_start (GTK_BOX (dialog), widget, TRUE, TRUE, 0); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dialog->priv->feed_view), TRUE); /* set up episode view */ g_object_get (dialog->priv->shell, "shell-player", &shell_player, NULL); episodes = rb_entry_view_new (dialog->priv->db, G_OBJECT (shell_player), TRUE, FALSE); g_object_unref (shell_player); g_signal_connect (episodes, "entry-activated", G_CALLBACK (episode_entry_activated_cb), dialog); /* date column */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); { const char *sample_strings[3]; sample_strings[0] = _("Date"); sample_strings[1] = rb_entry_view_get_time_date_column_sample (); sample_strings[2] = NULL; rb_entry_view_set_fixed_column_width (episodes, column, renderer, sample_strings); } gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) podcast_post_date_cell_data_func, dialog, NULL); rb_entry_view_append_column_custom (episodes, column, _("Date"), "Date", (GCompareDataFunc) podcast_post_date_sort_func, 0, NULL); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_DURATION, TRUE); rb_entry_view_set_sorting_order (RB_ENTRY_VIEW (episodes), "Date", GTK_SORT_DESCENDING); g_signal_connect (episodes, "notify::sort-order", G_CALLBACK (episodes_sort_changed_cb), dialog); query = rhythmdb_query_parse (dialog->priv->db, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH, RHYTHMDB_QUERY_END); query_model = rhythmdb_query_model_new_empty (dialog->priv->db); rb_entry_view_set_model (episodes, query_model); rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (query_model), query); rhythmdb_query_free (query); g_object_unref (query_model); paned = GTK_WIDGET (gtk_builder_get_object (builder, "paned")); g_signal_connect (paned, "size-allocate", G_CALLBACK (paned_size_allocate_cb), dialog); gtk_paned_pack2 (GTK_PANED (paned), GTK_WIDGET (episodes), TRUE, FALSE); gtk_widget_show_all (GTK_WIDGET (dialog)); g_object_unref (builder); }
GtkWindow* PrefsDlg::BuildDialog(){ PreferencesDialog_addInterfacePreferences( FreeCaller1<PreferencesPage&, Interface_constructPreferences>() ); Mouse_registerPreferencesPage(); GtkWindow* dialog = create_floating_window( "NetRadiant Preferences", m_parent ); { GtkWidget* mainvbox = gtk_vbox_new( FALSE, 5 ); gtk_container_add( GTK_CONTAINER( dialog ), mainvbox ); gtk_container_set_border_width( GTK_CONTAINER( mainvbox ), 5 ); gtk_widget_show( mainvbox ); { GtkWidget* hbox = gtk_hbox_new( FALSE, 5 ); gtk_widget_show( hbox ); gtk_box_pack_end( GTK_BOX( mainvbox ), hbox, FALSE, TRUE, 0 ); { GtkButton* button = create_dialog_button( "OK", G_CALLBACK( dialog_button_ok ), &m_modal ); gtk_box_pack_end( GTK_BOX( hbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 ); } { GtkButton* button = create_dialog_button( "Cancel", G_CALLBACK( dialog_button_cancel ), &m_modal ); gtk_box_pack_end( GTK_BOX( hbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 ); } { GtkButton* button = create_dialog_button( "Clean", G_CALLBACK( OnButtonClean ), this ); gtk_box_pack_end( GTK_BOX( hbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 ); } } { GtkWidget* hbox = gtk_hbox_new( FALSE, 5 ); gtk_box_pack_start( GTK_BOX( mainvbox ), hbox, TRUE, TRUE, 0 ); gtk_widget_show( hbox ); { GtkWidget* sc_win = gtk_scrolled_window_new( 0, 0 ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( sc_win ), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC ); gtk_box_pack_start( GTK_BOX( hbox ), sc_win, FALSE, FALSE, 0 ); gtk_widget_show( sc_win ); gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( sc_win ), GTK_SHADOW_IN ); // prefs pages notebook m_notebook = gtk_notebook_new(); // hide the notebook tabs since its not supposed to look like a notebook gtk_notebook_set_show_tabs( GTK_NOTEBOOK( m_notebook ), FALSE ); gtk_box_pack_start( GTK_BOX( hbox ), m_notebook, TRUE, TRUE, 0 ); gtk_widget_show( m_notebook ); { GtkTreeStore* store = gtk_tree_store_new( 2, G_TYPE_STRING, G_TYPE_POINTER ); GtkWidget* view = gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) ); gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE ); { GtkCellRenderer* renderer = gtk_cell_renderer_text_new(); GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "Preferences", renderer, "text", 0, NULL ); gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column ); } { GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( view ) ); g_signal_connect( G_OBJECT( selection ), "changed", G_CALLBACK( treeSelection ), this ); } gtk_widget_show( view ); gtk_container_add( GTK_CONTAINER( sc_win ), view ); { /********************************************************************/ /* Add preference tree options */ /********************************************************************/ // Front page... //GtkWidget* front = PreferencePages_addPage( m_notebook, "Front Page" ); { GtkWidget* global = PreferencePages_addPage( m_notebook, "Global Preferences" ); { PreferencesPage preferencesPage( *this, getVBox( global ) ); Global_constructPreferences( preferencesPage ); } GtkTreeIter group = PreferenceTree_appendPage( store, 0, "Global", global ); { GtkWidget* game = PreferencePages_addPage( m_notebook, "Game" ); PreferencesPage preferencesPage( *this, getVBox( game ) ); g_GamesDialog.CreateGlobalFrame( preferencesPage ); PreferenceTree_appendPage( store, &group, "Game", game ); } } { GtkWidget* interfacePage = PreferencePages_addPage( m_notebook, "Interface Preferences" ); { PreferencesPage preferencesPage( *this, getVBox( interfacePage ) ); PreferencesPageCallbacks_constructPage( g_interfacePreferences, preferencesPage ); } GtkTreeIter group = PreferenceTree_appendPage( store, 0, "Interface", interfacePage ); PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group ); PreferenceGroupCallbacks_constructGroup( g_interfaceCallbacks, preferenceGroup ); } { GtkWidget* display = PreferencePages_addPage( m_notebook, "Display Preferences" ); { PreferencesPage preferencesPage( *this, getVBox( display ) ); PreferencesPageCallbacks_constructPage( g_displayPreferences, preferencesPage ); } GtkTreeIter group = PreferenceTree_appendPage( store, 0, "Display", display ); PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group ); PreferenceGroupCallbacks_constructGroup( g_displayCallbacks, preferenceGroup ); } { GtkWidget* settings = PreferencePages_addPage( m_notebook, "General Settings" ); { PreferencesPage preferencesPage( *this, getVBox( settings ) ); PreferencesPageCallbacks_constructPage( g_settingsPreferences, preferencesPage ); } GtkTreeIter group = PreferenceTree_appendPage( store, 0, "Settings", settings ); PreferenceTreeGroup preferenceGroup( *this, m_notebook, store, group ); PreferenceGroupCallbacks_constructGroup( g_settingsCallbacks, preferenceGroup ); } } gtk_tree_view_expand_all( GTK_TREE_VIEW( view ) ); g_object_unref( G_OBJECT( store ) ); } } } } gtk_notebook_set_page( GTK_NOTEBOOK( m_notebook ), 0 ); return dialog; }
bool gtkui_archive_handle(const char *filename, char *reqfile, size_t reqsize) { // Select a filename to pull out of the archive struct archive *a; struct archive_entry *entry; int r, numarchives = 0; cancelled = false; a = archive_read_new(); archive_read_support_filter_all(a); archive_read_support_format_all(a); r = archive_read_open_filename(a, filename, 10240); // Test if it's actually an archive if (r != ARCHIVE_OK) { r = archive_read_free(a); return false; } // If it is an archive, handle it else { // Don't try to bring up a GUI selector if the GUI is disabled if (conf.misc_disable_gui) { // Fill the treestore with the filenames while (archive_read_next_header(a, &entry) == ARCHIVE_OK) { const char *currentfile = archive_entry_pathname(entry); if (nst_archive_checkext(currentfile)) { snprintf(reqfile, reqsize, "%s", currentfile); break; } } archive_read_data_skip(a); // Free the archive r = archive_read_free(a); return true; } // Set up the archive window GtkTreeIter iter; GtkTreeModel *model; GtkTreeSelection *selection; archivewindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(archivewindow), "Choose File from Archive"); gtk_window_set_modal(GTK_WINDOW(archivewindow), TRUE); GtkWidget *archivebox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(archivewindow), archivebox); gtk_widget_show(archivebox); GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(archivebox), scrolledwindow, TRUE, TRUE, 0); gtk_widget_set_size_request(scrolledwindow, 340, 340); gtk_widget_show(scrolledwindow); GtkWidget *buttonbox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL); gtk_box_pack_start(GTK_BOX(archivebox), buttonbox, FALSE, TRUE, 0); gtk_widget_show(buttonbox); GtkWidget *treeview = gtk_tree_view_new(); gtk_container_add(GTK_CONTAINER(scrolledwindow), treeview); gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (treeview), FALSE); gtk_widget_show(treeview); GtkTreeStore *treestore = gtk_tree_store_new(1, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore)); // Fill the treestore with the filenames while (archive_read_next_header(a, &entry) == ARCHIVE_OK) { const char *currentfile = archive_entry_pathname(entry); if (nst_archive_checkext(currentfile)) { gtk_tree_store_append(treestore, &iter, NULL); gtk_tree_store_set(treestore, &iter, 0, currentfile, -1); numarchives++; snprintf(reqfile, reqsize, "%s", currentfile); } archive_read_data_skip(a); } // Free the archive r = archive_read_free(a); // If there are no valid files in the archive, return if (numarchives == 0) { return false; } // If there's only one file, don't bring up the selector else if (numarchives == 1) { return true; } GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes( "NES file", renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW (treeview), column); GtkWidget *cancelbutton = gtk_widget_new( GTK_TYPE_BUTTON, "label", GTK_STOCK_CANCEL, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_button_set_use_stock(GTK_BUTTON(cancelbutton), TRUE); gtk_box_pack_start(GTK_BOX(buttonbox), cancelbutton, FALSE, FALSE, 0); gtk_widget_show(cancelbutton); GtkWidget *okbutton = gtk_widget_new( GTK_TYPE_BUTTON, "label", GTK_STOCK_OK, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL); gtk_button_set_use_stock(GTK_BUTTON(okbutton), TRUE); gtk_box_pack_start(GTK_BOX(buttonbox), okbutton, FALSE, FALSE, 0); gtk_widget_show(okbutton); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); g_signal_connect(G_OBJECT(okbutton), "clicked", G_CALLBACK(gtkui_archive_ok), NULL); g_signal_connect(G_OBJECT(cancelbutton), "clicked", G_CALLBACK(gtkui_archive_cancel), NULL); g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(gtkui_archive_ok), NULL); g_signal_connect(G_OBJECT(archivewindow), "destroy", G_CALLBACK(gtkui_archive_cancel), NULL); gtk_widget_show(archivewindow); // Freeze the rest of the program until a selection is made windowopen = true; while (windowopen) { gtk_main_iteration_do(TRUE); if (cancelled) { return false; } } gchar *reqbuf; selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); gtk_tree_selection_get_selected(selection, &model, &iter); gtk_tree_model_get(model, &iter, 0, &reqbuf, -1); gtk_widget_destroy(archivewindow); snprintf(reqfile, reqsize, "%s", reqbuf); return true; } return false; }
void properties_cb (GtkAction *action, EyesApplet *eyes_applet) { GtkWidget *pbox, *hbox; GtkWidget *vbox, *indent; GtkWidget *categories_vbox; GtkWidget *category_vbox, *control_vbox; GtkWidget *tree; GtkWidget *scrolled; GtkWidget *label; GtkListStore *model; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeSelection *selection; GtkTreeIter iter; DIR *dfd; struct dirent *dp; int i; #ifdef PATH_MAX gchar filename [PATH_MAX]; #else gchar *filename; #endif gchar *title; if (eyes_applet->prop_box.pbox) { gtk_window_set_screen ( GTK_WINDOW (eyes_applet->prop_box.pbox), gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet))); gtk_window_present (GTK_WINDOW (eyes_applet->prop_box.pbox)); return; } pbox = gtk_dialog_new_with_buttons (_("Geyes Preferences"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_window_set_screen (GTK_WINDOW (pbox), gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet))); gtk_widget_set_size_request (GTK_WIDGET (pbox), 300, 200); gtk_dialog_set_default_response(GTK_DIALOG (pbox), GTK_RESPONSE_CLOSE); gtk_dialog_set_has_separator (GTK_DIALOG (pbox), FALSE); gtk_container_set_border_width (GTK_CONTAINER (pbox), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), 2); g_signal_connect (pbox, "response", G_CALLBACK (presponse_cb), eyes_applet); vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_widget_show (vbox); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), vbox, TRUE, TRUE, 0); categories_vbox = gtk_vbox_new (FALSE, 18); gtk_box_pack_start (GTK_BOX (vbox), categories_vbox, TRUE, TRUE, 0); gtk_widget_show (categories_vbox); category_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (categories_vbox), category_vbox, TRUE, TRUE, 0); gtk_widget_show (category_vbox); title = g_strconcat ("<span weight=\"bold\">", _("Themes"), "</span>", NULL); label = gtk_label_new (_(title)); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (category_vbox), label, FALSE, FALSE, 0); g_free (title); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (category_vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); indent = gtk_label_new (HIG_IDENTATION); gtk_label_set_justify (GTK_LABEL (indent), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX (hbox), indent, FALSE, FALSE, 0); gtk_widget_show (indent); control_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), control_vbox, TRUE, TRUE, 0); gtk_widget_show (control_vbox); label = gtk_label_new_with_mnemonic (_("_Select a theme:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_box_pack_start (GTK_BOX (control_vbox), label, FALSE, FALSE, 0); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); model = gtk_list_store_new (TOTAL_COLS, G_TYPE_STRING, G_TYPE_STRING); tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree), FALSE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), tree); g_object_unref (model); gtk_container_add (GTK_CONTAINER (scrolled), tree); cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("not used", cell, "text", COL_THEME_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree)); g_signal_connect (selection, "changed", G_CALLBACK (theme_selected_cb), eyes_applet); if ( ! key_writable (eyes_applet->applet, "theme_path")) { gtk_widget_set_sensitive (tree, FALSE); gtk_widget_set_sensitive (label, FALSE); } for (i = 0; i < NUM_THEME_DIRECTORIES; i++) { if ((dfd = opendir (theme_directories[i])) != NULL) { while ((dp = readdir (dfd)) != NULL) { if (dp->d_name[0] != '.') { gchar *theme_dir; gchar *theme_name; #ifdef PATH_MAX strcpy (filename, theme_directories[i]); strcat (filename, dp->d_name); #else asprintf (&filename, theme_directories[i], dp->d_name); #endif theme_dir = g_strdup_printf ("%s/", filename); theme_name = g_path_get_basename (filename); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, COL_THEME_DIR, &filename, COL_THEME_NAME, theme_name, -1); if (!g_ascii_strncasecmp (eyes_applet->theme_dir, theme_dir, strlen (theme_dir))) { GtkTreePath *path; path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree), path, NULL, FALSE); gtk_tree_path_free (path); } g_free (theme_name); g_free (theme_dir); } } closedir (dfd); } } #ifndef PATH_MAX g_free (filename); #endif gtk_box_pack_start (GTK_BOX (control_vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show_all (pbox); eyes_applet->prop_box.pbox = pbox; return; }
static void games_scores_dialog_init (GamesScoresDialog *self) { GtkWidget *vbox; GtkWidget *scroll; GtkWidget *listview; GtkTreeViewColumn *column; GtkTreeViewColumn *timecolumn; GtkCellRenderer *renderer; GtkCellRenderer *timerenderer; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GAMES_TYPE_SCORES_DIALOG, GamesScoresDialogPrivate); self->priv->style = GAMES_SCORES_STYLE_PLAIN_DESCENDING; /* These two hashes are the reverse of each other. As an optimisation * they share the same set of strings (as keys in the first case and * as data in the second). The first hash is responsible for * deallocating the memory for the strings. These two are only * valid as a pair. */ self->priv->categories = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); self->priv->catindices = g_hash_table_new (g_direct_hash, g_direct_equal); self->priv->catcounter = 0; self->priv->hilight = 0; gtk_container_set_border_width (GTK_CONTAINER (self), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), 2); g_signal_connect (G_OBJECT (self), "show", G_CALLBACK (games_scores_dialog_show), NULL); g_signal_connect (G_OBJECT (self), "hide", G_CALLBACK (games_scores_dialog_hide), NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 5); gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), vbox, TRUE, TRUE, 0); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scroll, 200, 265); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_ETCHED_IN); gtk_box_pack_end (GTK_BOX (vbox), scroll, TRUE, TRUE, 0); self->priv->message = gtk_label_new (""); gtk_label_set_use_markup (GTK_LABEL (self->priv->message), TRUE); gtk_label_set_justify (GTK_LABEL (self->priv->message), GTK_JUSTIFY_CENTER); gtk_box_pack_start (GTK_BOX (vbox), self->priv->message, FALSE, FALSE, 0); self->priv->hdiv = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), self->priv->hdiv, FALSE, FALSE, 0); self->priv->catbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), self->priv->catbar, FALSE, FALSE, 0); self->priv->label = gtk_label_new (NULL); gtk_label_set_use_markup (GTK_LABEL (self->priv->label), TRUE); gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->label, FALSE, FALSE, 0); self->priv->combo = gtk_combo_box_text_new (); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (self->priv->combo), FALSE); gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->combo, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (self->priv->label), self->priv->combo); g_signal_connect (G_OBJECT (self->priv->combo), "changed", G_CALLBACK (games_scores_dialog_change_category), self); self->priv->list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); listview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->list)); self->priv->treeview = GTK_TREE_VIEW (listview); timerenderer = gtk_cell_renderer_text_new (); timecolumn = gtk_tree_view_column_new_with_attributes (/* Score dialog column header for the date the score was recorded */ _("Date"), timerenderer, "text", 0, NULL); g_object_set (G_OBJECT (timerenderer), "xalign", 1.0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (listview), GTK_TREE_VIEW_COLUMN (timecolumn)); self->priv->timecolumn = timecolumn; renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", 1, NULL); g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (listview), GTK_TREE_VIEW_COLUMN (column)); self->priv->column = column; gtk_container_add (GTK_CONTAINER (scroll), listview); games_scores_dialog_set_buttons (self, GAMES_SCORES_CLOSE_BUTTON); gtk_window_set_destroy_with_parent (GTK_WINDOW (self), TRUE); gtk_widget_grab_focus (self->priv->combo); gtk_widget_show_all (vbox); gtk_widget_hide (self->priv->hdiv); gtk_widget_hide (self->priv->message); }
static TBEditorWidget *tb_editor_create_dialog(MidoriBrowser *parent) { GtkWidget *dialog, *vbox, *hbox, *vbox_buttons, *button_add, *button_remove; GtkWidget *swin_available, *swin_used, *tree_available, *tree_used, *label; GtkCellRenderer *text_renderer, *icon_renderer; GtkTreeViewColumn *column; TBEditorWidget *tbw = g_new(TBEditorWidget, 1); dialog = gtk_dialog_new_with_buttons(_("Customize Toolbar"), GTK_WINDOW(parent), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); vbox = (GTK_DIALOG(dialog))->vbox; gtk_box_set_spacing(GTK_BOX(vbox), 6); gtk_widget_set_name(dialog, "GeanyDialog"); gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE); tbw->store_available = gtk_list_store_new(TB_EDITOR_COLS_MAX, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); tbw->store_used = gtk_list_store_new(TB_EDITOR_COLS_MAX, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); label = gtk_label_new( _("Select items to be displayed on the toolbar. Items can be reodered by drag and drop.")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); tree_available = gtk_tree_view_new(); gtk_tree_view_set_model(GTK_TREE_VIEW(tree_available), GTK_TREE_MODEL(tbw->store_available)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_available), TRUE); gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE(tbw->store_available), TB_EDITOR_COL_LABEL, GTK_SORT_ASCENDING); icon_renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes( NULL, icon_renderer, "stock-id", TB_EDITOR_COL_ICON, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column); text_renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Available Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column); swin_available = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_available), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_available), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(swin_available), tree_available); tree_used = gtk_tree_view_new(); gtk_tree_view_set_model(GTK_TREE_VIEW(tree_used), GTK_TREE_MODEL(tbw->store_used)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_used), TRUE); gtk_tree_view_set_reorderable(GTK_TREE_VIEW(tree_used), TRUE); icon_renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes( NULL, icon_renderer, "stock-id", TB_EDITOR_COL_ICON, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column); text_renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Displayed Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column); swin_used = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_used), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_used), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(swin_used), tree_used); /* drag'n'drop */ gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_available), GDK_BUTTON1_MASK, tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_available), tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE); g_signal_connect(tree_available, "drag-data-get", G_CALLBACK(tb_editor_drag_data_get_cb), tbw); g_signal_connect(tree_available, "drag-data-received", G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw); g_signal_connect(tree_available, "drag-motion", G_CALLBACK(tb_editor_drag_motion_cb), tbw); gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_used), GDK_BUTTON1_MASK, tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE); gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_used), tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE); g_signal_connect(tree_used, "drag-data-get", G_CALLBACK(tb_editor_drag_data_get_cb), tbw); g_signal_connect(tree_used, "drag-data-received", G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw); g_signal_connect(tree_used, "drag-motion", G_CALLBACK(tb_editor_drag_motion_cb), tbw); button_add = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(button_add), gtk_image_new_from_stock(GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON)); button_remove = gtk_button_new(); g_signal_connect(button_add, "clicked", G_CALLBACK(tb_editor_btn_add_clicked_cb), tbw); gtk_button_set_image(GTK_BUTTON(button_remove), gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON)); g_signal_connect(button_remove, "clicked", G_CALLBACK(tb_editor_btn_remove_clicked_cb), tbw); vbox_buttons = gtk_vbox_new(FALSE, 6); /* FIXME this is a little hack'ish, any better ideas? */ gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_buttons), button_add, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_buttons), button_remove, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(hbox), swin_available, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox_buttons, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), swin_used, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 6); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); gtk_widget_show_all(vbox); g_object_unref(tbw->store_available); g_object_unref(tbw->store_used); tbw->dialog = dialog; tbw->tree_available = GTK_TREE_VIEW(tree_available); tbw->tree_used = GTK_TREE_VIEW(tree_used); tbw->last_drag_path = NULL; return tbw; }
void init_action_tree (GtkWidget *actions, const char *act, int ctx) { GtkTreeViewColumn *hk_act_col1 = gtk_tree_view_column_new_with_attributes (_("Action"), gtk_cell_renderer_text_new (), "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (actions), hk_act_col1); // traverse all plugins and collect all exported actions to treeview // column0: title // column1: ID (invisible) // column2: ctx (invisible GtkTreeStore *actions_store = gtk_tree_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); GtkTreeIter action_main_iter; gtk_tree_store_append (actions_store, &action_main_iter, NULL); gtk_tree_store_set (actions_store, &action_main_iter, 0, _("Main"), -1); GtkTreeIter action_selection_iter; gtk_tree_store_append (actions_store, &action_selection_iter, NULL); gtk_tree_store_set (actions_store, &action_selection_iter, 0, _("Selected track(s)"), -1); GtkTreeIter action_playlist_iter; gtk_tree_store_append (actions_store, &action_playlist_iter, NULL); gtk_tree_store_set (actions_store, &action_playlist_iter, 0, _("Current playlist"), -1); GtkTreeIter action_nowplaying_iter; gtk_tree_store_append (actions_store, &action_nowplaying_iter, NULL); gtk_tree_store_set (actions_store, &action_nowplaying_iter, 0, _("Now playing"), -1); DB_plugin_t **plugins = deadbeef->plug_get_list (); for (int i = 0; plugins[i]; i++) { DB_plugin_t *p = plugins[i]; if (p->get_actions) { DB_plugin_action_t *actions = p->get_actions (NULL); while (actions) { if (actions->name && actions->title) { // only add actions with both the name and the title char title[100]; GtkTreeIter iter; const char *t; if (actions->flags & DB_ACTION_COMMON) { t = action_tree_append (actions->title, actions_store, &action_main_iter, &iter); unescape_forward_slash (t, title, sizeof (title)); gtk_tree_store_set (actions_store, &iter, 0, title, 1, actions->name, 2, DDB_ACTION_CTX_MAIN, -1); } if (actions->flags & (DB_ACTION_SINGLE_TRACK | DB_ACTION_MULTIPLE_TRACKS | DB_ACTION_CAN_MULTIPLE_TRACKS)) { t = action_tree_append (actions->title, actions_store, &action_selection_iter, &iter); unescape_forward_slash (t, title, sizeof (title)); gtk_tree_store_set (actions_store, &iter, 0, title, 1, actions->name, 2, DDB_ACTION_CTX_SELECTION, -1); t = action_tree_append (actions->title, actions_store, &action_playlist_iter, &iter); unescape_forward_slash (t, title, sizeof (title)); gtk_tree_store_set (actions_store, &iter, 0, title, 1, actions->name, 2, DDB_ACTION_CTX_PLAYLIST, -1); t = action_tree_append (actions->title, actions_store, &action_nowplaying_iter, &iter); unescape_forward_slash (t, title, sizeof (title)); gtk_tree_store_set (actions_store, &iter, 0, title, 1, actions->name, 2, DDB_ACTION_CTX_NOWPLAYING, -1); } } else { // fprintf (stderr, "WARNING: action %s/%s from plugin %s is missing name and/or title\n", actions->name, actions->title, p->name); } actions = actions->next; } } } gtk_tree_view_set_model (GTK_TREE_VIEW (actions), GTK_TREE_MODEL (actions_store)); if (act && ctx != -1) { actionbinding_t binding = { .name = act, .ctx = ctx, .treeview = actions }; gtk_tree_model_foreach (GTK_TREE_MODEL (actions_store), set_current_action, (void*)&binding); }
gint gui_contact_open_by_dial(const gchar *dial) { debug("gui_contact_open_by_dial\n"); store_contact_struct *contact=NULL; store_contact_match(&contact,dial); if(!contact) return -1; store_contact_load_details(contact); GtkWidget *window=gtk_window_new(GTK_WINDOW_TOPLEVEL); if(contact->name) gtk_window_set_title(GTK_WINDOW(window),contact->name); else gtk_window_set_title(GTK_WINDOW(window),"<Unknown>"); gtk_window_set_default_size(GTK_WINDOW(window),400,220); GtkWidget *notebook=gtk_notebook_new(); GtkWidget *v1=gtk_vbox_new(FALSE,0); GtkWidget *title_bar=gtk_hbox_new(FALSE,0); GdkPixbuf *pixbuf=NULL; if(contact->name==NULL && contact->picture==NULL) pixbuf=utils_get_photo_unknown(); else if(contact->picture==NULL) pixbuf=utils_get_photo_default(); else pixbuf=utils_get_photo(contact->picture); GtkWidget *picture=gtk_image_new_from_pixbuf(pixbuf); GtkWidget *name; if(contact->name){ name=gtk_label_new (contact->name); }else{ name=gtk_label_new ("<Unknown>"); } gtk_box_pack_start(GTK_BOX(title_bar), picture, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(title_bar), name, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(v1), title_bar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(v1), gtk_hseparator_new(), FALSE, FALSE, 5); GList *dials=contact->dials; debug("Dials %p\n",dials); while(dials){ gchar *dial=((store_dial_struct*)dials->data)->dial; GtkWidget *label=gtk_label_new(dial); GtkWidget *button_sms=gtk_button_new (); GtkWidget *button_voice=gtk_button_new (); GtkWidget *h_dial=gtk_hbox_new(FALSE,0); GtkWidget *sms=gtk_image_new_from_pixbuf(utils_get_icon("sms.png")); GtkWidget *voice=gtk_image_new_from_pixbuf(utils_get_icon("voice.png")); g_signal_connect(G_OBJECT(button_sms),"clicked", G_CALLBACK(gui_contact_send_sms_callback),label); g_signal_connect(G_OBJECT(button_voice),"clicked", G_CALLBACK(gui_contact_dial_callback),label); gtk_container_add (GTK_CONTAINER(button_sms),sms); gtk_container_add (GTK_CONTAINER(button_voice),voice); gtk_misc_set_alignment(GTK_MISC(label),0,0.5); debug("gui_contact_open_by_dial add dial %d\n",dial); gtk_box_pack_start(GTK_BOX(h_dial), label, TRUE, TRUE, 20); gtk_box_pack_start(GTK_BOX(h_dial), button_sms, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(h_dial), button_voice, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(v1), h_dial, FALSE, FALSE, 0); dials=g_list_next(dials); } gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Details")); // Call history GtkWidget *scroll; GtkWidget *calls_view = gtk_tree_view_new(); gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE); GtkCellRenderer *renderer; GtkTreeViewColumn *column; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL); gtk_tree_view_column_set_fixed_width(column,70); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_STATUS, NULL); gtk_tree_view_column_set_fixed_width(column,70); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL); gtk_tree_view_column_set_expand(column,TRUE); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL); gtk_tree_view_column_set_fixed_width(column,80); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Duration", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_DURACTION, NULL); gtk_tree_view_column_set_fixed_width(column,70); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE); scroll = gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER(scroll),calls_view); //g_signal_connect_after(G_OBJECT(g_gui_calls.dials_view),"cursor-changed", G_CALLBACK(gui_dialer_book_click_callback),NULL); SphoneStoreTreeModel *calls; if(contact->name!=NULL){ // known contact gchar contactid[20]; sprintf(contactid,"%d",contact->id); debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID query='%s'\n",contactid); calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID, contactid); }else{ gchar dialid[20]; sprintf(dialid,"%d",store_dial_get_id(dial)); debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID query='%s'\n",dialid); calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID, dialid); } gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls)); g_object_unref(G_OBJECT(calls)); gtk_notebook_append_page(GTK_NOTEBOOK(notebook),scroll,gtk_label_new("Calls")); // SMS history v1=gtk_vbox_new(FALSE,0); calls_view = gtk_tree_view_new(); gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL); gtk_tree_view_column_set_fixed_width(column,70); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL); gtk_tree_view_column_set_expand(column,TRUE); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL); gtk_tree_view_column_set_fixed_width(column,80); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes("Text", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_SMS_TEXT, NULL); gtk_tree_view_column_set_expand(column,TRUE); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE); scroll = gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER(scroll),calls_view); GtkWidget *sms_content=gtk_label_new (NULL); gtk_label_set_selectable(GTK_LABEL(sms_content), TRUE); gtk_label_set_line_wrap(GTK_LABEL(sms_content), TRUE); g_signal_connect_after(G_OBJECT(calls_view),"cursor-changed", G_CALLBACK(gui_contact_sms_selected_callback),sms_content); if(contact->name!=NULL){ // known contact gchar contactid[20]; sprintf(contactid,"%d",contact->id); debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID query='%s'\n",contactid); calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID, contactid); }else{ gchar dialid[20]; sprintf(dialid,"%d",store_dial_get_id(dial)); debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID query='%s'\n",dialid); calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID, dialid); } gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls)); g_object_unref(G_OBJECT(calls)); gtk_container_add (GTK_CONTAINER(v1),scroll); gtk_container_add (GTK_CONTAINER(v1),sms_content); gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Messages")); gtk_container_add(GTK_CONTAINER(window),notebook); gtk_widget_show_all(window); store_contact_free(contact); return 0; }
/** * vik_trw_layer_waypoint_list_internal: * @dialog: The dialog to create the widgets in * @waypoints_and_layers: The list of waypoints (and it's layer) to be shown * @show_layer_names: Show the layer names that each waypoint belongs to * * Create a table of waypoints with corresponding waypoint information * This table does not support being actively updated */ static void vik_trw_layer_waypoint_list_internal ( GtkWidget *dialog, GList *waypoints_and_layers, gboolean show_layer_names ) { if ( !waypoints_and_layers ) return; // It's simple storing the gdouble values in the tree store as the sort works automatically // Then apply specific cell data formatting (rather default double is to 6 decimal places!) // However not storing any doubles for waypoints ATM // TODO: Consider adding the waypoint icon into this store for display in the list GtkTreeStore *store = gtk_tree_store_new ( WPT_LIST_COLS, G_TYPE_STRING, // 0: Layer Name G_TYPE_STRING, // 1: Waypoint Name G_TYPE_STRING, // 2: Date G_TYPE_BOOLEAN, // 3: Visible G_TYPE_STRING, // 4: Comment G_TYPE_INT, // 5: Height GDK_TYPE_PIXBUF, // 6: Symbol Icon G_TYPE_POINTER, // 7: TrackWaypoint Layer pointer G_TYPE_POINTER ); // 8: Waypoint pointer //gtk_tree_selection_set_select_function ( gtk_tree_view_get_selection (GTK_TREE_VIEW(vt)), vik_treeview_selection_filter, vt, NULL ); vik_units_height_t height_units = a_vik_get_units_height (); //GList *gl = get_waypoints_and_layers_cb ( vl, user_data ); //g_list_foreach ( waypoints_and_layers, (GFunc) trw_layer_waypoint_list_add, store ); GList *gl = waypoints_and_layers; while ( gl ) { trw_layer_waypoint_list_add ( (vik_trw_waypoint_list_t*)gl->data, store, height_units ); gl = g_list_next ( gl ); } GtkWidget *view = gtk_tree_view_new(); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL); GtkTreeViewColumn *column; GtkTreeViewColumn *sort_by_column; gint column_runner = 0; if ( show_layer_names ) { // Insert column for the layer name when viewing multi layers column = my_new_column_text ( _("Layer"), renderer, view, column_runner++ ); g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_set_expand ( column, TRUE ); // remember the layer column so we can sort by it later sort_by_column = column; } else column_runner++; column = my_new_column_text ( _("Name"), renderer, view, column_runner++ ); gtk_tree_view_column_set_expand ( column, TRUE ); if ( !show_layer_names ) // remember the name column so we can sort by it later sort_by_column = column; column = my_new_column_text ( _("Date"), renderer, view, column_runner++ ); gtk_tree_view_column_set_resizable ( column, TRUE ); GtkCellRenderer *renderer_toggle = gtk_cell_renderer_toggle_new (); column = gtk_tree_view_column_new_with_attributes ( _("Visible"), renderer_toggle, "active", column_runner, NULL ); gtk_tree_view_column_set_sort_column_id ( column, column_runner ); gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column ); column_runner++; column = my_new_column_text ( _("Comment"), renderer, view, column_runner++ ); gtk_tree_view_column_set_expand ( column, TRUE ); if ( height_units == VIK_UNITS_HEIGHT_FEET ) (void)my_new_column_text ( _("Max Height\n(Feet)"), renderer, view, column_runner++ ); else (void)my_new_column_text ( _("Max Height\n(Metres)"), renderer, view, column_runner++ ); GtkCellRenderer *renderer_pixbuf = gtk_cell_renderer_pixbuf_new (); g_object_set (G_OBJECT (renderer_pixbuf), "xalign", 0.5, NULL); column = gtk_tree_view_column_new_with_attributes ( _("Symbol"), renderer_pixbuf, "pixbuf", column_runner++, NULL ); // Special sort required for pixbufs gtk_tree_sortable_set_sort_func ( GTK_TREE_SORTABLE(store), column_runner, sort_pixbuf_compare_func, NULL, NULL ); gtk_tree_view_column_set_sort_column_id ( column, column_runner ); gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column ); gtk_tree_view_set_model ( GTK_TREE_VIEW(view), GTK_TREE_MODEL(store) ); gtk_tree_selection_set_mode ( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE ); gtk_tree_view_set_rules_hint ( GTK_TREE_VIEW(view), TRUE ); g_object_unref(store); GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL ); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_container_add ( GTK_CONTAINER(scrolledwindow), view ); g_object_set ( view, "has-tooltip", TRUE, NULL); g_signal_connect ( view, "query-tooltip", G_CALLBACK (trw_layer_waypoint_tooltip_cb), NULL ); //g_signal_connect ( gtk_tree_view_get_selection (GTK_TREE_VIEW(view)), "changed", G_CALLBACK(trw_layer_waypoint_select_cb), view ); g_signal_connect ( view, "popup-menu", G_CALLBACK(trw_layer_waypoint_menu_popup), waypoints_and_layers ); g_signal_connect ( view, "button-press-event", G_CALLBACK(trw_layer_waypoint_button_pressed), waypoints_and_layers ); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolledwindow, TRUE, TRUE, 0); // Set ordering of the initial view by one of the name columns gtk_tree_view_column_clicked ( sort_by_column ); // Ensure a reasonable number of items are shown // TODO: may be save window size, column order, sorted by between invocations. gtk_window_set_default_size ( GTK_WINDOW(dialog), show_layer_names ? 700 : 500, 400 ); }
static void initialize_treeview (NMConnectionList *self) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; ConnectionTypeData *types; GtkTreeIter iter; char *id; int i; /* Model */ self->model = GTK_TREE_MODEL (gtk_tree_store_new (6, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_OBJECT, G_TYPE_GTYPE, G_TYPE_INT)); /* Filter */ self->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (self->model, NULL)); gtk_tree_model_filter_set_visible_func (self->filter, tree_model_visible_func, self, NULL); /* Sortable */ self->sortable = GTK_TREE_SORTABLE (gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (self->filter))); gtk_tree_sortable_set_default_sort_func (self->sortable, NULL, NULL, NULL); gtk_tree_sortable_set_sort_func (self->sortable, COL_TIMESTAMP, timestamp_sort_func, self->sortable, NULL); gtk_tree_sortable_set_sort_func (self->sortable, COL_ID, id_sort_func, self->sortable, NULL); gtk_tree_sortable_set_sort_column_id (self->sortable, COL_TIMESTAMP, GTK_SORT_ASCENDING); gtk_tree_view_set_model (self->connection_list, GTK_TREE_MODEL (self->sortable)); /* Name column */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "markup", COL_ID, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_sort_column_id (column, COL_ID); g_signal_connect (column, "clicked", G_CALLBACK (column_header_clicked_cb), GINT_TO_POINTER (COL_ID)); gtk_tree_view_append_column (self->connection_list, column); /* Last Used column */ renderer = g_object_new (GTK_TYPE_CELL_RENDERER_TEXT, "foreground", "SlateGray", NULL); column = gtk_tree_view_column_new_with_attributes (_("Last Used"), renderer, "text", COL_LAST_USED, NULL); gtk_tree_view_column_set_sort_column_id (column, COL_TIMESTAMP); g_signal_connect (column, "clicked", G_CALLBACK (column_header_clicked_cb), GINT_TO_POINTER (COL_TIMESTAMP)); gtk_tree_view_append_column (self->connection_list, column); /* Selection */ selection = gtk_tree_view_get_selection (self->connection_list); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* Fill in connection types */ types = get_connection_type_list (); for (i = 0; types[i].name; i++) { id = g_strdup_printf ("<b>%s</b>", types[i].name); gtk_tree_store_append (GTK_TREE_STORE (self->model), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (self->model), &iter, COL_ID, id, COL_GTYPE, types[i].setting_type, COL_ORDER, i, -1); g_free (id); } }
static void CappletSetup (MatekbdIndicatorPluginsCapplet * gipc) { GtkBuilder *builder; GError *error = NULL; GtkWidget *button; GtkWidget *capplet; GtkWidget *activePlugins; GtkTreeModel *activePluginsModel; GtkCellRenderer *renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ()); GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", 0, NULL); GtkTreeSelection *selection; builder = gtk_builder_new (); gtk_window_set_default_icon_name ("input-keyboard"); /* default domain! */ if (!gtk_builder_add_from_file (builder, UIDIR "/matekbd-indicator-plugins.ui", &error)) { g_warning ("Could not load builder file: %s", error->message); g_error_free(error); return; } gipc->capplet = capplet = GTK_WIDGET (gtk_builder_get_object (builder, "matekbd_indicator_plugins")); gtk_builder_connect_signals (builder, NULL); g_object_set_data (G_OBJECT (capplet), "uiData", builder); #if GTK_CHECK_VERSION(3, 0, 0) g_signal_connect_swapped(G_OBJECT(capplet), "destroy", G_CALLBACK(g_object_unref), builder); #else g_signal_connect_swapped(GTK_OBJECT(capplet), "destroy", G_CALLBACK(g_object_unref), builder); #endif g_signal_connect_swapped (G_OBJECT (capplet), "unrealize", G_CALLBACK (g_main_loop_quit), loop); #if GTK_CHECK_VERSION(3, 0, 0) g_signal_connect(G_OBJECT(capplet), "response", G_CALLBACK(CappletResponse), NULL); #else g_signal_connect(GTK_OBJECT(capplet), "response", G_CALLBACK(CappletResponse), NULL); #endif button = GTK_WIDGET (gtk_builder_get_object (builder, "btnUp")); g_signal_connect (button, "clicked", G_CALLBACK (CappletPromotePlugin), gipc); button = GTK_WIDGET (gtk_builder_get_object (builder, "btnDown")); g_signal_connect (button, "clicked", G_CALLBACK (CappletDemotePlugin), gipc); button = GTK_WIDGET (gtk_builder_get_object (builder, "btnAdd")); g_signal_connect (button, "clicked", G_CALLBACK (CappletEnablePlugin), gipc); button = GTK_WIDGET (gtk_builder_get_object (builder, "btnRemove")); g_signal_connect (button, "clicked", G_CALLBACK (CappletDisablePlugin), gipc); button = GTK_WIDGET (gtk_builder_get_object (builder, "btnProperties")); g_signal_connect (button, "clicked", G_CALLBACK (CappletConfigurePlugin), gipc); activePlugins = CappletGetUiWidget (gipc, "activePlugins"); activePluginsModel = GTK_TREE_MODEL (gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING)); gtk_tree_view_set_model (GTK_TREE_VIEW (activePlugins), activePluginsModel); gtk_tree_view_append_column (GTK_TREE_VIEW (activePlugins), column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (activePlugins)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (CappletActivePluginsSelectionChanged), gipc); CappletFillActivePluginList (gipc); CappletActivePluginsSelectionChanged (selection, gipc); gtk_widget_show_all (capplet); }
static void account_categories_tree_view_prepare (hierarchy_data *data) { GSList *list; gchar *gnc_accounts_dir; gchar *locale_dir; GtkTreeView *tree_view; GtkListStore *model; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreePath *path; gnc_accounts_dir = gnc_path_get_accountsdir (); locale_dir = gnc_get_ea_locale_dir (gnc_accounts_dir); list = gnc_load_example_account_list (locale_dir); g_free (gnc_accounts_dir); g_free (locale_dir); /* Prepare the account_categories GtkTreeView with a model and with some columns */ tree_view = data->categories_tree; model = gtk_list_store_new(NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL(model)); g_object_unref (model); g_slist_foreach(list, (GFunc)add_one_category, data); g_signal_connect (G_OBJECT (model), "row_changed", G_CALLBACK (categories_selection_changed), data); renderer = gtk_cell_renderer_toggle_new (); g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL); column = gtk_tree_view_column_new_with_attributes (_("Selected"), renderer, "active", COL_CHECKED, NULL); gtk_tree_view_append_column (tree_view, column); gtk_tree_view_column_set_sort_column_id (column, COL_CHECKED); g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (category_checkbox_toggled), model); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Account Types"), renderer, "text", COL_TITLE, NULL); gtk_tree_view_append_column (tree_view, column); gtk_tree_view_column_set_sort_column_id (column, COL_TITLE); // renderer = gtk_cell_renderer_text_new (); // column = gtk_tree_view_column_new_with_attributes (_("Description"), // renderer, // "text", COL_SHORT_DESCRIPTION, // NULL); // gtk_tree_view_append_column (tree_view, column); // gtk_tree_view_column_set_sort_column_id (column, COL_SHORT_DESCRIPTION); gtk_tree_view_set_headers_clickable(tree_view, TRUE); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(model), COL_TITLE, GTK_SORT_ASCENDING); if (data->initial_category) { path = gtk_tree_row_reference_get_path(data->initial_category); selection = gtk_tree_view_get_selection(tree_view); gtk_tree_view_scroll_to_cell(tree_view, path, NULL, TRUE, 0.5, 0.5); gtk_tree_selection_select_path(selection, path); gtk_tree_path_free(path); } }
/**************************************************************** Create spy's tech stealing dialog *****************************************************************/ static void create_advances_list(struct player *pplayer, struct player *pvictim) { GtkWidget *sw, *label, *vbox, *view; GtkListStore *store; GtkCellRenderer *rend; GtkTreeViewColumn *col; spy_tech_shell = gtk_dialog_new_with_buttons(_("Steal Technology"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Steal"), GTK_RESPONSE_ACCEPT, NULL); setup_dialog(spy_tech_shell, toplevel); gtk_window_set_position(GTK_WINDOW(spy_tech_shell), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response(GTK_DIALOG(spy_tech_shell), GTK_RESPONSE_ACCEPT); label = gtk_frame_new(_("Select Advance to Steal")); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(spy_tech_shell))), label); vbox = gtk_grid_new(); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing(GTK_GRID(vbox), 6); gtk_container_add(GTK_CONTAINER(label), vbox); store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_widget_set_hexpand(view, TRUE); gtk_widget_set_vexpand(view, TRUE); g_object_unref(store); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes(NULL, rend, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", view, "label", _("_Advances:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_container_add(GTK_CONTAINER(vbox), label); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(sw), view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_set_size_request(sw, -1, 200); gtk_container_add(GTK_CONTAINER(vbox), sw); /* Now populate the list */ if (pvictim) { /* you don't want to know what lag can do -- Syela */ GtkTreeIter it; GValue value = { 0, }; advance_index_iterate(A_FIRST, i) { if(player_invention_state(pvictim, i)==TECH_KNOWN && (player_invention_state(pplayer, i)==TECH_UNKNOWN || player_invention_state(pplayer, i)==TECH_PREREQS_KNOWN)) { gtk_list_store_append(store, &it); g_value_init(&value, G_TYPE_STRING); g_value_set_static_string(&value, advance_name_for_player(client.conn.playing, i)); gtk_list_store_set_value(store, &it, 0, &value); g_value_unset(&value); gtk_list_store_set(store, &it, 1, i, -1); } } advance_index_iterate_end; gtk_list_store_append(store, &it); g_value_init(&value, G_TYPE_STRING); { struct astring str = ASTRING_INIT; /* TRANS: %s is a unit name, e.g., Spy */ astr_set(&str, _("At %s's Discretion"), unit_name_translation(game_unit_by_number(diplomat_id))); g_value_set_string(&value, astr_str(&str)); astr_free(&str); } gtk_list_store_set_value(store, &it, 0, &value); g_value_unset(&value); gtk_list_store_set(store, &it, 1, A_UNSET, -1); } gtk_dialog_set_response_sensitive(GTK_DIALOG(spy_tech_shell), GTK_RESPONSE_ACCEPT, FALSE); gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(spy_tech_shell))); g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), "changed", G_CALLBACK(spy_advances_callback), NULL); g_signal_connect(spy_tech_shell, "response", G_CALLBACK(spy_advances_response), NULL); steal_advance = 0; gtk_tree_view_focus(GTK_TREE_VIEW(view)); }
NedMidiRecordConfigDialog::NedMidiRecordConfigDialog(GtkWindow *parent, int num, int denom, int midi_pgm, int tempo_inverse, int volume, bool triplet, bool f_piano, bool dnt_split, int keysig) : m_num(num), m_denom(denom), m_pgm(midi_pgm), m_tempo_inverse(tempo_inverse), m_metro_volume(volume), m_triplet(triplet), m_f_piano(f_piano), m_dnt_split(dnt_split), m_keysig(keysig) { int i; GtkWidget *dialog; GtkWidget *time_signature_frame; GtkWidget *numerator_label; GtkWidget *denominator_label; GtkWidget *time_signature_vbox; GtkWidget *time_signature_upper_hbox; GtkWidget *time_signature_lower_hbox; GtkWidget *right_vbox; GtkWidget *instrument_scroll; GtkWidget *upper_hbox; GtkListStore *instrumend_list_store; GtkTreeIter iter; GtkCellRenderer *instrument_renderer; GtkTreeViewColumn *instrument_column; GtkTreeViewColumn *instrument_num_column; GtkTreePath* instrument_tree_path; GtkWidget *tempo_frame; GtkWidget *key_frame; GtkWidget *key_frame_left_vbox; GtkWidget *key_frame_right_vbox; GtkWidget *radio_hbox; GtkWidget *main_vbox; GtkWidget *metro_volume_frame; char Str[128]; dialog = gtk_dialog_new_with_buttons(_("Config Record"), parent, (GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL); g_signal_connect(dialog, "response", G_CALLBACK (OnClose), (void *) this); time_signature_frame = gtk_frame_new(_("time signature")); time_signature_vbox = gtk_vbox_new(FALSE, 5); time_signature_upper_hbox = gtk_hbox_new(FALSE, 5); time_signature_lower_hbox = gtk_hbox_new(FALSE, 5); numerator_label = gtk_label_new(_("Numerator:")); denominator_label = gtk_label_new(_("Denominator:")); m_numerator = gtk_spin_button_new_with_range (1.0, 20.0, 1.0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(m_numerator), m_num); m_denominator = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "2"); gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "4"); gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "8"); gtk_combo_box_append_text(GTK_COMBO_BOX(m_denominator), "16"); if (m_denom < 4) { gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 0); } else if (m_denom < 8) { gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 1); } else if (m_denom < 16) { gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 2); } else { gtk_combo_box_set_active(GTK_COMBO_BOX(m_denominator), 3); } gtk_box_pack_start (GTK_BOX (time_signature_upper_hbox), numerator_label, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (time_signature_upper_hbox), m_numerator, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (time_signature_lower_hbox), denominator_label, FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (time_signature_lower_hbox), m_denominator, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (time_signature_vbox), time_signature_upper_hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (time_signature_vbox), time_signature_lower_hbox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER(time_signature_frame), time_signature_vbox); m_with_triplet_button = gtk_toggle_button_new_with_label(_("triplet recognition")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_with_triplet_button), m_triplet); m_force_piano_button = gtk_toggle_button_new_with_label(_("force piano")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_force_piano_button), m_f_piano); m_dont_split_button = gtk_toggle_button_new_with_label(_("don't split tracks")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_dont_split_button), m_dnt_split); if (m_dnt_split) { gtk_widget_set_sensitive(m_force_piano_button, FALSE); } else if (m_f_piano) { gtk_widget_set_sensitive(m_dont_split_button, FALSE); } g_signal_connect(m_force_piano_button, "toggled", G_CALLBACK (OnPianoForcePressed), (void *) this); g_signal_connect(m_dont_split_button, "toggled", G_CALLBACK (OnDontSplitPressed), (void *) this); right_vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX(right_vbox), time_signature_frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(right_vbox), m_with_triplet_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(right_vbox), m_force_piano_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(right_vbox), m_dont_split_button, FALSE, FALSE, 0); instrumend_list_store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING); for (i = 0; i < NedResource::getNumInstruments(); i++) { gtk_list_store_append (instrumend_list_store, &iter); gtk_list_store_set (instrumend_list_store, &iter, 0, i, 1, gettext(NedResource::GM_Instruments[i]), -1); } m_instrument_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(instrumend_list_store)); instrument_renderer = gtk_cell_renderer_text_new (); instrument_num_column = gtk_tree_view_column_new_with_attributes (_("no"), instrument_renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (m_instrument_list), instrument_num_column); instrument_column = gtk_tree_view_column_new_with_attributes (_("instruments"), instrument_renderer, "text", 1, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (m_instrument_list), instrument_column); m_instrument_adjustment = gtk_adjustment_new (0.0, 0.0, NedResource::getNumInstruments(), 1.0, 10.0, 10.0); instrument_scroll = gtk_vscrollbar_new(GTK_ADJUSTMENT(m_instrument_adjustment)); gtk_tree_view_set_vadjustment (GTK_TREE_VIEW (m_instrument_list), GTK_ADJUSTMENT(m_instrument_adjustment)); gtk_widget_set_size_request(m_instrument_list, INSTRUMENTS_WIDGET_WIDTH, MIDI_RECORD_CONFIG_SHOW_WINDOW_HEIGHT); sprintf(Str, "%d", m_pgm); instrument_tree_path = gtk_tree_path_new_from_string(Str); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (m_instrument_list), instrument_tree_path, NULL, FALSE, 0.0, 0.0); gtk_tree_view_set_cursor(GTK_TREE_VIEW (m_instrument_list), instrument_tree_path, NULL, FALSE); g_signal_connect(dialog, "scroll-event", G_CALLBACK (OnScroll), (void *) this); tempo_frame = gtk_frame_new(_("tempo")); m_tempo_scale = gtk_vscale_new_with_range(0.1 * 60.0, 2.4 * 60.0, 0.4 * 60.0); gtk_range_set_inverted(GTK_RANGE(m_tempo_scale), TRUE); gtk_range_set_value(GTK_RANGE(m_tempo_scale), 60.0 * (double) m_tempo_inverse / 100000.0); gtk_container_add (GTK_CONTAINER(tempo_frame), m_tempo_scale); metro_volume_frame = gtk_frame_new(_("volume")); m_metro_volume_scale = gtk_vscale_new_with_range(0.0, 127.0, 1.0); gtk_range_set_inverted(GTK_RANGE(m_metro_volume_scale), TRUE); gtk_range_set_value(GTK_RANGE(m_metro_volume_scale), m_metro_volume); gtk_container_add (GTK_CONTAINER(metro_volume_frame), m_metro_volume_scale); key_frame = gtk_frame_new(_("key")); radio_hbox = gtk_hbox_new(FALSE, 2); key_frame_left_vbox = gtk_vbox_new(FALSE, 2); key_frame_right_vbox = gtk_vbox_new(FALSE, 2); m_sig_radio_buttons[0] = gtk_radio_button_new_with_label (NULL, gettext(NedStaffContextDialog::m_keyTab[0])); gtk_box_pack_start (GTK_BOX (key_frame_left_vbox), m_sig_radio_buttons[0], FALSE, FALSE, 0); for (i = -5; i < 7; i++) { m_sig_radio_buttons[i+6] = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (m_sig_radio_buttons[0]), gettext(NedStaffContextDialog::m_keyTab[i+6])); if (i < 0) { gtk_box_pack_start (GTK_BOX (key_frame_left_vbox), m_sig_radio_buttons[i+6], FALSE, FALSE, 0); } else { gtk_box_pack_start (GTK_BOX (key_frame_right_vbox), m_sig_radio_buttons[i+6], FALSE, FALSE, 0); } } gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_sig_radio_buttons[keysig+6]), TRUE); gtk_box_pack_start (GTK_BOX (radio_hbox), key_frame_left_vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (radio_hbox), key_frame_right_vbox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER(key_frame), radio_hbox); upper_hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX(upper_hbox), m_instrument_list, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX(upper_hbox), instrument_scroll, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(upper_hbox), right_vbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(upper_hbox), tempo_frame, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX(upper_hbox), metro_volume_frame, FALSE, FALSE, 0); main_vbox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start (GTK_BOX(main_vbox), upper_hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX(main_vbox), key_frame, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (GTK_DIALOG(dialog)->vbox), main_vbox); gtk_widget_show_all (dialog); gtk_dialog_run(GTK_DIALOG(dialog)); }
/**************************************************************** Creates spy's building sabotaging dialog *****************************************************************/ static void create_improvements_list(struct player *pplayer, struct city *pcity) { GtkWidget *sw, *label, *vbox, *view; GtkListStore *store; GtkCellRenderer *rend; GtkTreeViewColumn *col; GtkTreeIter it; spy_sabotage_shell = gtk_dialog_new_with_buttons(_("Sabotage Improvements"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Sabotage"), GTK_RESPONSE_ACCEPT, NULL); setup_dialog(spy_sabotage_shell, toplevel); gtk_window_set_position(GTK_WINDOW(spy_sabotage_shell), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response(GTK_DIALOG(spy_sabotage_shell), GTK_RESPONSE_ACCEPT); label = gtk_frame_new(_("Select Improvement to Sabotage")); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(spy_sabotage_shell))), label); vbox = gtk_grid_new(); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing(GTK_GRID(vbox), 6); gtk_container_add(GTK_CONTAINER(label), vbox); store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_widget_set_hexpand(view, TRUE); gtk_widget_set_vexpand(view, TRUE); g_object_unref(store); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes(NULL, rend, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", view, "label", _("_Improvements:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_container_add(GTK_CONTAINER(vbox), label); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(sw), view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sw), 200); gtk_container_add(GTK_CONTAINER(vbox), sw); /* Now populate the list */ gtk_list_store_append(store, &it); gtk_list_store_set(store, &it, 0, _("City Production"), 1, -1, -1); city_built_iterate(pcity, pimprove) { if (pimprove->sabotage > 0) { gtk_list_store_append(store, &it); gtk_list_store_set(store, &it, 0, city_improvement_name_translation(pcity, pimprove), 1, improvement_number(pimprove), -1); } } city_built_iterate_end; gtk_list_store_append(store, &it); { struct astring str = ASTRING_INIT; /* TRANS: %s is a unit name, e.g., Spy */ astr_set(&str, _("At %s's Discretion"), unit_name_translation(game_unit_by_number(diplomat_id))); gtk_list_store_set(store, &it, 0, astr_str(&str), 1, B_LAST, -1); astr_free(&str); } gtk_dialog_set_response_sensitive(GTK_DIALOG(spy_sabotage_shell), GTK_RESPONSE_ACCEPT, FALSE); gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(spy_sabotage_shell))); g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), "changed", G_CALLBACK(spy_improvements_callback), NULL); g_signal_connect(spy_sabotage_shell, "response", G_CALLBACK(spy_improvements_response), NULL); sabotage_improvement = -2; gtk_tree_view_focus(GTK_TREE_VIEW(view)); }
static GObject * gdict_speller_constructor (GType type, guint n_params, GObjectConstructParam *params) { GObject *object; GdictSpeller *speller; GdictSpellerPrivate *priv; GtkWidget *sw; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *hbox; object = G_OBJECT_CLASS (gdict_speller_parent_class)->constructor (type, n_params, params); speller = GDICT_SPELLER (object); priv = speller->priv; gtk_widget_push_composite_child (); sw = gtk_scrolled_window_new (NULL, NULL); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_set_vexpand (sw, TRUE); #endif gtk_widget_set_composite_name (sw, "gdict-speller-scrolled-window"); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (speller), sw, TRUE, TRUE, 0); gtk_widget_show (sw); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("matches", renderer, "text", MATCH_COLUMN_WORD, NULL); priv->treeview = gtk_tree_view_new (); gtk_widget_set_composite_name (priv->treeview, "gdict-speller-treeview"); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), GTK_TREE_MODEL (priv->store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column); g_signal_connect (priv->treeview, "row-activated", G_CALLBACK (row_activated_cb), speller); gtk_container_add (GTK_CONTAINER (sw), priv->treeview); gtk_widget_show (priv->treeview); #if GTK_CHECK_VERSION (3, 0, 0) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new (FALSE, 0); #endif priv->clear_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (priv->clear_button), gtk_image_new_from_icon_name ("edit-clear", GTK_ICON_SIZE_SMALL_TOOLBAR)); g_signal_connect (priv->clear_button, "clicked", G_CALLBACK (clear_button_clicked_cb), speller); gtk_box_pack_start (GTK_BOX (hbox), priv->clear_button, FALSE, FALSE, 0); gtk_widget_show (priv->clear_button); gtk_widget_set_tooltip_text (priv->clear_button, _("Clear the list of similar words")); gtk_box_pack_end (GTK_BOX (speller), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); gtk_widget_pop_composite_child (); return object; }
static void fcitx_im_widget_init(FcitxImWidget* self) { gtk_orientable_set_orientation(GTK_ORIENTABLE(self), GTK_ORIENTATION_VERTICAL); GtkCellRenderer* renderer; GtkTreeViewColumn* column; GtkWidget* hbox; GtkToolItem* separator; self->imstore = gtk_list_store_new(IM_N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER); self->imview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->imstore)); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes( _("Input Method"), renderer, "text", IM_LIST_IM_STRING, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(self->imview), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self->imview), FALSE); GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->imview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(_fcitx_im_widget_im_selection_changed), self); GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolledwindow), self->imview); g_object_set(G_OBJECT(scrolledwindow), "shadow-type", GTK_SHADOW_IN, NULL); GtkWidget* toolbar = gtk_toolbar_new(); gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), 1); gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolbar), false); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); GtkToolItem* item; /* add and remove */ self->addimbutton = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(self->addimbutton), gtk_image_new_from_icon_name("list-add-symbolic", GTK_ICON_SIZE_BUTTON)); self->delimbutton = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(self->delimbutton), gtk_image_new_from_icon_name("list-remove-symbolic", GTK_ICON_SIZE_BUTTON)); gtk_widget_set_sensitive(self->delimbutton, FALSE); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start(GTK_BOX(hbox), self->addimbutton, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), self->delimbutton, FALSE, FALSE, 0); item = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(item), hbox); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1); /* separator */ separator = gtk_separator_tool_item_new(); g_object_set(G_OBJECT(separator), "draw", false, NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), separator, -1); /* move up and move down */ self->moveupbutton = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(self->moveupbutton), gtk_image_new_from_icon_name("go-up-symbolic", GTK_ICON_SIZE_BUTTON)); gtk_widget_set_sensitive(self->moveupbutton, FALSE); self->movedownbutton = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(self->movedownbutton), gtk_image_new_from_icon_name("go-down-symbolic", GTK_ICON_SIZE_BUTTON)); gtk_widget_set_sensitive(self->movedownbutton, FALSE); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start(GTK_BOX(hbox), self->moveupbutton, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), self->movedownbutton, FALSE, FALSE, 0); item = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(item), hbox); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1); /* separator */ separator = gtk_separator_tool_item_new(); g_object_set(G_OBJECT(separator), "draw", false, NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), separator, -1); /* configure */ self->configurebutton = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(self->configurebutton), gtk_image_new_from_icon_name("preferences-system-symbolic", GTK_ICON_SIZE_BUTTON)); gtk_widget_set_sensitive(self->configurebutton, FALSE); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start(GTK_BOX(hbox), self->configurebutton, FALSE, FALSE, 0); item = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(item), hbox); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1); GtkStyleContext* context; context = gtk_widget_get_style_context (scrolledwindow); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM); context = gtk_widget_get_style_context (toolbar); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP); gtk_style_context_add_class (context, "inline-toolbar"); gtk_box_pack_start(GTK_BOX(self), scrolledwindow, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self), toolbar, FALSE, TRUE, 0); g_object_set(G_OBJECT(self), "margin", 5, NULL); g_signal_connect(G_OBJECT(self->addimbutton), "clicked", G_CALLBACK(_fcitx_im_widget_addim_button_clicked), self); g_signal_connect(G_OBJECT(self->delimbutton), "clicked", G_CALLBACK(_fcitx_im_widget_delim_button_clicked), self); g_signal_connect(G_OBJECT(self->moveupbutton), "clicked", G_CALLBACK(_fcitx_im_widget_moveup_button_clicked), self); g_signal_connect(G_OBJECT(self->movedownbutton), "clicked", G_CALLBACK(_fcitx_im_widget_movedown_button_clicked), self); g_signal_connect(G_OBJECT(self->configurebutton), "clicked", G_CALLBACK(_fcitx_im_widget_configure_button_clicked), self); _fcitx_im_widget_connect(self); }
static GtkWidget *create_list(void) { GtkListStore *list_store; GtkWidget * list; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeView *list_view; GtkTreeSelection *selection; list_store = gtk_list_store_new(N_COLUMN, G_TYPE_UINT, /* Port1*/ G_TYPE_UINT, /* Port2*/ G_TYPE_UINT, /* number of packets */ G_TYPE_STRING, /* checksum type */ G_TYPE_UINT, /* number of checksum errors */ G_TYPE_UINT, /* number of data chunks */ G_TYPE_UINT, /* number of data bytes */ G_TYPE_UINT, /* vtag1 */ G_TYPE_UINT); /* vtag2 */ /* Create a view */ list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store)); list_view = GTK_TREE_VIEW(list); /* Speed up the list display */ gtk_tree_view_set_fixed_height_mode(list_view, TRUE); gtk_tree_view_set_headers_clickable(list_view, TRUE); /* The view now holds a reference. We can get rid of our own reference */ g_object_unref(G_OBJECT(list_store)); /* * Create the first column packet, associating the "text" attribute of the * cell_renderer to the first column of the model */ /* 1:st column */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Port 1", renderer, "text", PORT1_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, PORT1_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 80); /* Add the column to the view. */ gtk_tree_view_append_column(list_view, column); /* 2:nd column... */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Port 2", renderer, "text", PORT2_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, PORT2_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 80); gtk_tree_view_append_column(list_view, column); /* 3:d column... */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("No of Packets", renderer, "text", PACKETS_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, PACKETS_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 120); gtk_tree_view_append_column(list_view, column); /* 4:th column... */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Checksum", renderer, "text", CHECKSUM_TYPE_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, CHECKSUM_TYPE_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 120); gtk_tree_view_append_column(list_view, column); /* 5:th column... */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("No of Errors", renderer, "text", CHECKSUM_ERRORS_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, CHECKSUM_ERRORS_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 120); gtk_tree_view_append_column(list_view, column); /* 6:th column... */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Data Chunks", renderer, "text", DATA_CHUNKS_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, DATA_CHUNKS_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 120); gtk_tree_view_append_column(list_view, column); /* 7:th column... */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Data Bytes", renderer, "text", DATA_BYTES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, DATA_BYTES_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 120); gtk_tree_view_append_column(list_view, column); /* 8:th column... */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("VTag 1", renderer, "text", VTAG1_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, VTAG1_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 120); gtk_tree_view_append_column(list_view, column); /* 9:th column... */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("VTag 2", renderer, "text", VTAG2_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, VTAG2_COLUMN); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_min_width(column, 120); gtk_tree_view_append_column(list_view, column); /* Now enable the sorting of each column */ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE); gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE); /* Setup the selection handler */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); g_signal_connect(selection, "changed", G_CALLBACK(sctp_stat_on_select_row), NULL); return list; }
/* create the "open with" dialog. */ void dlg_open_with (FrWindow *window, GList *file_list) { DialogData *data; GAppInfo *app; GList *scan, *app_names = NULL; char **editors; int i; GtkWidget *cancel_button; GtkTreeIter iter; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkIconTheme *theme; int icon_size; if (file_list == NULL) return; data = g_new0 (DialogData, 1); data->settings = g_settings_new (ENGRAMPA_SCHEMA_GENERAL); data->builder = _gtk_builder_new_from_file ("open-with.ui"); if (data->builder == NULL) { g_free (data); return; } data->file_list = path_list_dup (file_list); data->window = window; /* Get the widgets. */ data->dialog = _gtk_builder_get_widget (data->builder, "open_with_dialog"); data->o_app_tree_view = _gtk_builder_get_widget (data->builder, "o_app_list_tree_view"); data->o_recent_tree_view = _gtk_builder_get_widget (data->builder, "o_recent_tree_view"); data->o_app_entry = _gtk_builder_get_widget (data->builder, "o_app_entry"); data->o_del_button = _gtk_builder_get_widget (data->builder, "o_del_button"); data->ok_button = _gtk_builder_get_widget (data->builder, "o_ok_button"); cancel_button = _gtk_builder_get_widget (data->builder, "o_cancel_button"); gtk_widget_set_sensitive (data->ok_button, FALSE); /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (open_with__destroy_cb), data); g_signal_connect (G_OBJECT (data->o_app_entry), "changed", G_CALLBACK (app_entry__changed_cb), data); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_app_tree_view))), "changed", G_CALLBACK (app_list_selection_changed_cb), data); g_signal_connect (G_OBJECT (data->o_app_tree_view), "row_activated", G_CALLBACK (app_activated_cb), data); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->o_recent_tree_view))), "changed", G_CALLBACK (recent_list_selection_changed_cb), data); g_signal_connect (G_OBJECT (data->o_recent_tree_view), "row_activated", G_CALLBACK (recent_activated_cb), data); g_signal_connect (G_OBJECT (data->ok_button), "clicked", G_CALLBACK (open_cb), data); g_signal_connect_swapped (G_OBJECT (cancel_button), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (data->dialog)); g_signal_connect (G_OBJECT (data->o_del_button), "clicked", G_CALLBACK (delete_recent_cb), data); /* Set data. */ /* * registered applications list. */ data->app_list = NULL; for (scan = data->file_list; scan; scan = scan->next) { const char *mime_type; const char *name = scan->data; mime_type = get_file_mime_type_for_path (name, FALSE); if ((mime_type != NULL) && ! g_content_type_is_unknown (mime_type)) data->app_list = g_list_concat (data->app_list, g_app_info_get_all_for_type (mime_type)); } data->app_model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->app_model), TEXT_COLUMN, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_app_tree_view), data->app_model); g_object_unref (G_OBJECT (data->app_model)); theme = gtk_icon_theme_get_default (); icon_size = get_folder_pixbuf_size_for_list (GTK_WIDGET (data->dialog)); for (scan = data->app_list; scan; scan = scan->next) { gboolean found; char *utf8_name; GdkPixbuf *icon_image = NULL; app = scan->data; found = FALSE; if (app_names != NULL) { GList *p; for (p = app_names; p && !found; p = p->next) if (strcmp ((char*)p->data, g_app_info_get_executable (app)) == 0) found = TRUE; } if (found) continue; app_names = g_list_prepend (app_names, (char*) g_app_info_get_executable (app)); utf8_name = g_locale_to_utf8 (g_app_info_get_name (app), -1, NULL, NULL, NULL); icon_image = get_icon_pixbuf (g_app_info_get_icon (app), icon_size, theme); gtk_list_store_append (GTK_LIST_STORE (data->app_model), &iter); gtk_list_store_set (GTK_LIST_STORE (data->app_model), &iter, ICON_COLUMN, icon_image, TEXT_COLUMN, utf8_name, DATA_COLUMN, app, -1); g_free (utf8_name); } column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", ICON_COLUMN, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", TEXT_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_app_tree_view), column); if (app_names) g_list_free (app_names); /* * recent editors list. */ data->recent_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (data->recent_model), 0, GTK_SORT_ASCENDING); gtk_tree_view_set_model (GTK_TREE_VIEW (data->o_recent_tree_view), data->recent_model); g_object_unref (G_OBJECT (data->recent_model)); editors = g_settings_get_strv (data->settings, PREF_GENERAL_EDITORS); for (i = 0; editors[i] != NULL; i++) { gtk_list_store_append (GTK_LIST_STORE (data->recent_model), &iter); gtk_list_store_set (GTK_LIST_STORE (data->recent_model), &iter, 0, editors[i], -1); } g_strfreev (editors); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (NULL, renderer, "text", 0, NULL); gtk_tree_view_column_set_sort_column_id (column, 0); gtk_tree_view_append_column (GTK_TREE_VIEW (data->o_recent_tree_view), column); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (window)); gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE); gtk_widget_show_all (data->dialog); }
static void setup_search (GnomeControlCenter *shell) { GtkWidget *search_view, *widget; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GnomeControlCenterPrivate *priv = shell->priv; g_return_if_fail (priv->store != NULL); /* create the search filter */ priv->search_filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (priv->store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->search_filter), (GtkTreeModelFilterVisibleFunc) model_filter_func, priv, NULL); /* set up the search view */ priv->search_view = search_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (search_view), FALSE); gtk_tree_view_set_model (GTK_TREE_VIEW (search_view), GTK_TREE_MODEL (priv->search_filter)); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "follow-state", TRUE, "xpad", 15, "ypad", 10, "stock-size", GTK_ICON_SIZE_DIALOG, NULL); column = gtk_tree_view_column_new_with_attributes ("Icon", renderer, "gicon", COL_GICON, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 0, NULL); column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", COL_NAME, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 15, NULL); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", COL_DESCRIPTION, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); priv->search_scrolled = W (priv->builder, "search-scrolled-window"); gtk_container_add (GTK_CONTAINER (priv->search_scrolled), search_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->search_view)), "changed", G_CALLBACK (on_search_selection_changed), shell); /* setup the search entry widget */ widget = (GtkWidget*) gtk_builder_get_object (priv->builder, "search-entry"); priv->search_entry = widget; priv->filter_string = g_strdup (""); g_signal_connect (widget, "changed", G_CALLBACK (search_entry_changed_cb), shell); g_signal_connect (widget, "key-press-event", G_CALLBACK (search_entry_key_press_event_cb), priv); gtk_widget_show (priv->search_view); }
gint gui_history_sms(void) { SphoneStoreTreeModel *calls; static GtkWidget *calls_view=NULL; debug("gui_history_sms\n"); if(sms_window){ calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_ALL, NULL); gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls)); g_object_unref(G_OBJECT(calls)); gtk_window_present(GTK_WINDOW(sms_window)); return 0; } sms_window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(sms_window),"SMS History"); gtk_window_set_default_size(GTK_WINDOW(sms_window),600,220); GtkWidget *v1=gtk_vbox_new(FALSE,0); GtkWidget *scroll; calls_view = gtk_tree_view_new(); gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE); GtkCellRenderer *renderer; GtkTreeViewColumn *column; renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes("", renderer, "pixbuf", SPHONE_STORE_TREE_MODEL_COLUMN_PICTURE, NULL); gtk_tree_view_column_set_fixed_width(column,40); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL); gtk_tree_view_column_set_fixed_width(column,70); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes("Name", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_NAME, NULL); gtk_tree_view_column_set_expand(column,TRUE); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL); gtk_tree_view_column_set_expand(column,TRUE); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL); gtk_tree_view_column_set_fixed_width(column,80); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes("Text", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_SMS_TEXT, NULL); gtk_tree_view_column_set_expand(column,TRUE); gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column); gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE); scroll = gtk_scrolled_window_new(NULL,NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); GtkWidget *sms_content=gtk_label_new (NULL); gtk_label_set_selectable(GTK_LABEL(sms_content), TRUE); gtk_label_set_line_wrap(GTK_LABEL(sms_content), TRUE); g_signal_connect_after(G_OBJECT(calls_view),"cursor-changed", G_CALLBACK(gui_contact_sms_selected_callback),sms_content); g_signal_connect_after(G_OBJECT(calls_view),"row-activated", G_CALLBACK(gui_contact_book_double_click_callback),NULL); gtk_container_add (GTK_CONTAINER(scroll),calls_view); gtk_container_add (GTK_CONTAINER(v1),scroll); gtk_container_add (GTK_CONTAINER(v1),sms_content); gtk_container_add (GTK_CONTAINER(sms_window),v1); g_signal_connect(G_OBJECT(sms_window),"delete-event", G_CALLBACK(gui_contact_make_null),&sms_window); calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_ALL, NULL); gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls)); g_object_unref(G_OBJECT(calls)); gtk_widget_show_all(sms_window); return 0; }
void show_track_properties_dlg (int ctx, ddb_playlist_t *plt) { last_ctx = ctx; deadbeef->plt_ref (plt); if (last_plt) { deadbeef->plt_unref (last_plt); } last_plt = plt; trkproperties_free_track_list (&tracks, &numtracks); trkproperties_build_track_list_for_ctx (plt, ctx, &tracks, &numtracks); GtkTreeView *tree; GtkTreeView *proptree; if (!trackproperties) { trackproperties = create_trackproperties (); gtk_window_set_transient_for (GTK_WINDOW (trackproperties), GTK_WINDOW (mainwin)); wingeom_restore (trackproperties, "trkproperties", -1, -1, 300, 400, 0); // metadata tree tree = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist")); store = gtk_list_store_new (5, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING); gtk_tree_view_set_model (tree, GTK_TREE_MODEL (store)); GtkCellRenderer *rend_text = gtk_cell_renderer_text_new (); rend_text2 = GTK_CELL_RENDERER (ddb_cell_renderer_text_multiline_new ()); g_signal_connect ((gpointer)rend_text2, "edited", G_CALLBACK (on_metadata_edited), store); GtkTreeViewColumn *col1 = gtk_tree_view_column_new_with_attributes (_("Key"), rend_text, "text", 0, NULL); GtkTreeViewColumn *col2 = gtk_tree_view_column_new_with_attributes (_("Value"), rend_text2, "text", 1, NULL); //gtk_tree_view_column_set_cell_data_func (col2, rend_text2, meta_value_transform_func, NULL, NULL); gtk_tree_view_append_column (tree, col1); gtk_tree_view_append_column (tree, col2); // properties tree proptree = GTK_TREE_VIEW (lookup_widget (trackproperties, "properties")); propstore = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model (proptree, GTK_TREE_MODEL (propstore)); GtkCellRenderer *rend_propkey = gtk_cell_renderer_text_new (); GtkCellRenderer *rend_propvalue = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (rend_propvalue), "editable", TRUE, NULL); col1 = gtk_tree_view_column_new_with_attributes (_("Key"), rend_propkey, "text", 0, NULL); col2 = gtk_tree_view_column_new_with_attributes (_("Value"), rend_propvalue, "text", 1, NULL); gtk_tree_view_append_column (proptree, col1); gtk_tree_view_append_column (proptree, col2); } else { tree = GTK_TREE_VIEW (lookup_widget (trackproperties, "metalist")); store = GTK_LIST_STORE (gtk_tree_view_get_model (tree)); gtk_list_store_clear (store); proptree = GTK_TREE_VIEW (lookup_widget (trackproperties, "properties")); propstore = GTK_LIST_STORE (gtk_tree_view_get_model (proptree)); gtk_list_store_clear (propstore); } if (numtracks == 1) { deadbeef->pl_lock (); gtk_entry_set_text (GTK_ENTRY (lookup_widget (trackproperties, "filename")), deadbeef->pl_find_meta_raw (tracks[0], ":URI")); deadbeef->pl_unlock (); } else { gtk_entry_set_text (GTK_ENTRY (lookup_widget (trackproperties, "filename")), _("[Multiple values]")); } g_object_set (G_OBJECT (rend_text2), "editable", TRUE, NULL); GtkWidget *widget = trackproperties; GtkWidget *w; const char *meta; trkproperties_fill_metadata (); gtk_widget_set_sensitive (lookup_widget (widget, "write_tags"), TRUE); gtk_widget_show (widget); gtk_window_present (GTK_WINDOW (widget)); }
/*! \brief Creates the hotkeys dialog * \par Function Description * This function creates the hotkey dialog and puts the list of hotkeys * into it. */ void x_dialog_hotkeys (GschemToplevel *w_current) { GtkWidget *vbox, *scrolled_win; GtkTreeModel *store; GtkWidget *treeview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; if (!w_current->hkwindow) { w_current->hkwindow = gschem_dialog_new_with_buttons(_("Hotkeys"), GTK_WINDOW(w_current->main_window), 0, /* not modal */ "hotkeys", w_current, GTK_STOCK_CLOSE, GTK_RESPONSE_REJECT, NULL); gtk_window_set_position (GTK_WINDOW (w_current->hkwindow), GTK_WIN_POS_NONE); g_signal_connect (G_OBJECT (w_current->hkwindow), "response", G_CALLBACK (x_dialog_hotkeys_response), w_current); gtk_dialog_set_default_response(GTK_DIALOG(w_current->hkwindow), GTK_RESPONSE_ACCEPT); gtk_container_set_border_width (GTK_CONTAINER (w_current->hkwindow), DIALOG_BORDER_SPACING); gtk_widget_set_size_request (w_current->hkwindow, 300, 300); vbox = GTK_DIALOG(w_current->hkwindow)->vbox; gtk_box_set_spacing(GTK_BOX(vbox), DIALOG_V_SPACING); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* the model */ store = GTK_TREE_MODEL (gschem_hotkey_store_new ()); /* the tree view */ treeview = gtk_tree_view_new_with_model (store); gtk_container_add(GTK_CONTAINER(scrolled_win), treeview); /* the columns */ /* The first column contains the action's icon (if one was set) * and its label. */ renderer = gtk_cell_renderer_pixbuf_new (); column = gtk_tree_view_column_new_with_attributes (_("Action"), renderer, "stock-id", GSCHEM_HOTKEY_STORE_COLUMN_ICON, NULL); /* Fix things up to show stock icons *and* theme icons. */ g_signal_connect (renderer, "notify::stock-id", G_CALLBACK (x_dialog_hotkeys_cell_stock_id_notify), 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", GSCHEM_HOTKEY_STORE_COLUMN_LABEL, NULL); /* The second column contains the action's keybinding */ gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); column = gtk_tree_view_column_new_with_attributes (_("Keystroke(s)"), renderer, "text", GSCHEM_HOTKEY_STORE_COLUMN_KEYS, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); /* show all recursively */ gtk_widget_show_all(w_current->hkwindow); } else { /* dialog already created */ gtk_window_present(GTK_WINDOW(w_current->hkwindow)); } }