void wxCheckListBox::DoCreateCheckList() { //Create the checklist in our treeview and set up events for it GtkCellRenderer* renderer = gtk_cell_renderer_toggle_new(); GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "", renderer, "active", 0, NULL ); gtk_tree_view_column_set_fixed_width(column, 22); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_clickable(column, TRUE); g_signal_connect (renderer, "toggled", G_CALLBACK (gtk_checklist_toggled), this); gtk_tree_view_append_column(m_treeview, column); }
void skin_view_realize(GtkTreeView * treeview) { GtkListStore *store; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; gtk_widget_show_all(GTK_WIDGET(treeview)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); store = gtk_list_store_new(SKIN_VIEW_N_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING , G_TYPE_STRING); gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store)); g_object_unref (store); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_spacing(column, 16); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), GTK_TREE_VIEW_COLUMN(column)); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", SKIN_VIEW_COL_PREVIEW, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes(column, renderer, "markup", SKIN_VIEW_COL_FORMATTEDNAME, NULL); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect(treeview, "cursor-changed", G_CALLBACK(skin_view_on_cursor_changed), NULL); }
static void contact_widget_model_populate_columns (EmpathyContactWidget *information) { GtkTreeView *view; GtkTreeModel *model; GtkTreeViewColumn *column; GtkCellRenderer *renderer; guint col_offset; view = GTK_TREE_VIEW (information->treeview_groups); model = gtk_tree_view_get_model (view); renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (contact_widget_cell_toggled), information); column = gtk_tree_view_column_new_with_attributes (_("Select"), renderer, "active", COL_ENABLED, NULL); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (column, 50); gtk_tree_view_append_column (view, column); renderer = gtk_cell_renderer_text_new (); col_offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Group"), renderer, "text", COL_NAME, /* "editable", COL_EDITABLE, */ NULL); g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COL_NAME)); column = gtk_tree_view_get_column (view, col_offset - 1); gtk_tree_view_column_set_sort_column_id (column, COL_NAME); gtk_tree_view_column_set_resizable (column,FALSE); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); }
static void fx_many_create_selected_column(FxMany* fxmany) { GtkCellRenderer* renderer; GtkTreeViewColumn *col0 , *col1; renderer = gtk_cell_renderer_pixbuf_new(); col0 = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col0, renderer , FALSE); gtk_tree_view_column_add_attribute(col0, renderer, "pixbuf", C_PIXBUF_COL); gtk_tree_view_append_column(GTK_TREE_VIEW(fxmany->selected), col0); renderer = gtk_cell_renderer_text_new(); col1 = gtk_tree_view_column_new(); gtk_tree_view_column_pack_start(col1, renderer , FALSE); gtk_tree_view_column_add_attribute(col1, renderer, "text", C_NAME_COL); gtk_tree_view_append_column(GTK_TREE_VIEW(fxmany->selected), col1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (col1) , GTK_TREE_VIEW_COLUMN_FIXED); }
static void chanlist_add_column (GtkWidget *tree, int textcol, int size, char *title, gboolean right_justified) { GtkCellRenderer *renderer; GtkTreeViewColumn *col; renderer = gtk_cell_renderer_text_new (); if (right_justified) g_object_set (G_OBJECT (renderer), "xalign", (gfloat) 1.0, NULL); g_object_set (G_OBJECT (renderer), "ypad", (gint) 0, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree), -1, title, renderer, "text", textcol, NULL); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1); col = gtk_tree_view_get_column (GTK_TREE_VIEW (tree), textcol); gtk_tree_view_column_set_sort_column_id (col, textcol); gtk_tree_view_column_set_resizable (col, TRUE); if (textcol != COL_TOPIC) { gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (col, size); } }
void set_pixbuf_tree_view_column_autogrow(GtkWidget * parent_widget, GtkTreeViewColumn * column) { if (gtk_major_version == 2 && (gtk_minor_version >= 5 && gtk_minor_version <= 6)) { gint horizontal_separator, focus_line_width, icon_width; gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_widget_style_get(parent_widget, "horizontal_separator", &horizontal_separator, "focus-line-width", &focus_line_width, NULL); gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &icon_width, NULL); gtk_tree_view_column_set_fixed_width(column, icon_width + 2 * horizontal_separator + focus_line_width); } }
/* sortcolidx == -1 means 'sortcolidx = colidx' */ static void append_col (GtkTreeView * treeview, const char *label, int colidx, int sortcolidx, gint maxwidth) { GtkTreeViewColumn *col; GtkCellRenderer *renderer; renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); col = gtk_tree_view_column_new_with_attributes (label, renderer, "text", colidx, NULL); g_object_set (G_OBJECT (col), "resizable", TRUE, NULL); gtk_tree_view_column_set_sort_indicator (col, TRUE); if (sortcolidx == -1) sortcolidx = colidx; gtk_tree_view_column_set_sort_column_id (col, sortcolidx); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED); if (maxwidth) { gtk_tree_view_column_set_fixed_width (col, maxwidth); gtk_tree_view_column_set_expand (col, FALSE); } else gtk_tree_view_column_set_expand (col, TRUE); gtk_tree_view_column_set_cell_data_func (col, renderer, (GtkTreeCellDataFunc) treecell_func, NULL, NULL); gtk_tree_view_append_column (treeview, col); gtk_tree_view_columns_autosize (treeview); gtk_tree_view_set_fixed_height_mode (treeview, TRUE); }
void setup_test_item_view() { GtkCellRenderer *renderer; GtkTreeViewColumn *column; column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Content"); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_attributes(column, renderer, "stock-id", ICON, 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", CONTENT, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width(column, 400); gtk_tree_view_append_column(GTK_TREE_VIEW(test_item_view), column); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Result"); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes(column, renderer, "stock-id", RESULT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(test_item_view), column); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, ""); gtk_tree_view_append_column(GTK_TREE_VIEW(test_item_view), column); }
static void add_clicked (GtkWidget *button, gpointer data) { static gint i = 0; GtkTreeIter iter; GtkTreeViewColumn *column; GtkTreeSelection *selection; GtkCellRenderer *cell; gchar *label = g_strdup_printf ("Column %d", i); cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (label, cell, "text", 0, NULL); g_object_set_data_full (G_OBJECT (column), column_data, label, g_free); gtk_tree_view_column_set_reorderable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_GROW_ONLY); gtk_tree_view_column_set_resizable (column, TRUE); gtk_list_store_append (GTK_LIST_STORE (left_tree_model), &iter); gtk_list_store_set (GTK_LIST_STORE (left_tree_model), &iter, 0, label, 1, column, -1); i++; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)); gtk_tree_selection_select_iter (selection, &iter); }
/* * Public API */ GtkWidget * addressbook_window_new (boost::shared_ptr<Ekiga::ContactCore> core) { AddressBookWindow *self = NULL; boost::signals::connection conn; GtkWidget *menu_bar = NULL; GtkWidget *frame = NULL; GtkWidget *vbox = NULL; GtkWidget *hpaned = NULL; GtkCellRenderer *cell = NULL; GtkTreeViewColumn *column = NULL; GtkTreeStore *store = NULL; self = (AddressBookWindow *) g_object_new (ADDRESSBOOK_WINDOW_TYPE, NULL); self->priv = new AddressBookWindowPrivate (core); gtk_window_set_title (GTK_WINDOW (self), _("Address Book")); gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER); gtk_window_set_icon_name (GTK_WINDOW (self), "x-office-address-book"); /* Start building the window */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); /* The menu */ menu_bar = gtk_menu_bar_new (); self->priv->accel = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel); g_object_unref (self->priv->accel); self->priv->menu_item_core = gtk_menu_item_new_with_mnemonic (_("Address _Book")); gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), self->priv->menu_item_core); g_object_ref (self->priv->menu_item_core); conn = core->updated.connect (boost::bind (&on_core_updated, (gpointer) self)); self->priv->connections.add (conn); on_core_updated (self); // This will add static and dynamic actions self->priv->menu_item_view = gtk_menu_item_new_with_mnemonic (_("_Action")); gtk_widget_set_sensitive (self->priv->menu_item_view, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), self->priv->menu_item_view); g_object_ref (self->priv->menu_item_view); gtk_container_add (GTK_CONTAINER (vbox), menu_bar); gtk_box_set_child_packing (GTK_BOX (vbox), menu_bar, FALSE, FALSE, 2, GTK_PACK_START); gtk_container_add (GTK_CONTAINER (self), vbox); /* A hpaned to put the list of Books and their content */ hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_container_set_border_width (GTK_CONTAINER (hpaned), 6); gtk_container_add (GTK_CONTAINER (vbox), hpaned); gtk_box_set_child_packing (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0, GTK_PACK_START); /* The store listing the Books */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); store = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_OBJECT); self->priv->tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (store); gtk_container_add (GTK_CONTAINER (frame), self->priv->tree_view); gtk_widget_set_size_request (GTK_WIDGET (self->priv->tree_view), 185, -1); gtk_paned_pack1 (GTK_PANED (hpaned), frame, TRUE, TRUE); /* Several renderers for one column */ column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_add_attribute (column, cell, "icon-name", COLUMN_PIXBUF); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "text", COLUMN_NAME, NULL); gtk_tree_view_column_set_title (column, _("Category")); gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), true); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->tree_view), GTK_TREE_VIEW_COLUMN (column)); self->priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->tree_view)); gtk_tree_selection_set_mode (GTK_TREE_SELECTION (self->priv->selection), GTK_SELECTION_SINGLE); g_signal_connect (self->priv->selection, "changed", G_CALLBACK (on_book_selection_changed), self); g_signal_connect (self->priv->tree_view, "event-after", G_CALLBACK (on_book_clicked), self); /* The notebook containing the books */ self->priv->notebook = gtk_notebook_new (); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self->priv->notebook), FALSE); g_signal_connect (self->priv->notebook, "realize", G_CALLBACK (on_notebook_realize), self); gtk_paned_pack2 (GTK_PANED (hpaned), self->priv->notebook, TRUE, TRUE); conn = core->source_added.connect (boost::bind (&on_source_added, _1, (gpointer) self)); self->priv->connections.add (conn); conn = core->book_updated.connect (boost::bind (&on_book_updated, _1, _2, (gpointer) self)); self->priv->connections.add (conn); conn = core->book_added.connect (boost::bind (&on_book_added, _1, _2, (gpointer) self)); self->priv->connections.add (conn); conn = core->book_removed.connect (boost::bind (&on_book_removed, _1, _2, (gpointer) self)); self->priv->connections.add (conn); conn = core->questions.connect (boost::bind (&on_handle_questions, _1, (gpointer) self)); self->priv->connections.add (conn); core->visit_sources (boost::bind (on_visit_sources, _1, (gpointer) self)); return GTK_WIDGET (self); }
/** * create the page to manually associate the transactions to the reconciles * show a complete list of orphans transactions, and for each of them, we propose * to link them to a reconcile * * \param assistant * * \return a GtkWidget, the page to the assistant * */ static GtkWidget *gsb_assistant_reconcile_config_page_manually_associate ( GtkWidget *assistant ) { GtkWidget *page; GtkWidget *label; GtkWidget *separator; GtkWidget *scrolled_window; gint i; GtkWidget *button; GtkWidget *hbox; GtkListStore *store; gchar *titles[] = { _("Date"), _("Payee"), _("Amount"), _("Account") }; gfloat alignment[] = { COLUMN_CENTER, COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER }; page = gtk_box_new ( GTK_ORIENTATION_VERTICAL, 0 ); gtk_container_set_border_width ( GTK_CONTAINER(page), 12 ); /* the number of transactions to link */ label_transactions_to_link_3 = gtk_label_new (NULL); gtk_box_pack_start ( GTK_BOX (page), label_transactions_to_link_3, FALSE, FALSE, 0 ); separator = gtk_separator_new ( GTK_ORIENTATION_HORIZONTAL ); gtk_box_pack_start ( GTK_BOX (page), separator, FALSE, FALSE, 0 ); /* now we can show the list of orphans transactions */ label = gtk_label_new (_("Select the transaction(s) you want to associate with a reconciliation: ")); gtk_misc_set_alignment ( GTK_MISC ( label ), 0.0, 0.0 ); gtk_box_pack_start ( GTK_BOX (page), label, FALSE, FALSE, 10 ); scrolled_window = gtk_scrolled_window_new (FALSE, FALSE); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_box_pack_start ( GTK_BOX (page), scrolled_window, TRUE, TRUE, 0 ); gtk_widget_show (scrolled_window); /* set up the tree view */ store = gtk_list_store_new ( TRANSACTION_NB_COL, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT ); treeview_transactions_to_link = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); g_object_unref (G_OBJECT(store)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview_transactions_to_link), TRUE); gtk_tree_selection_set_mode ( gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview_transactions_to_link)), GTK_SELECTION_MULTIPLE ); gtk_container_add ( GTK_CONTAINER (scrolled_window), treeview_transactions_to_link ); gtk_widget_show (treeview_transactions_to_link); /* set the columns */ for (i=TRANSACTION_DATE ; i<TRANSACTION_NUMBER ; i++) { GtkTreeViewColumn *column; GtkCellRenderer *cell; cell = gtk_cell_renderer_text_new (); g_object_set ( G_OBJECT (cell), "xalign", alignment[i], NULL ); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_sizing ( column, GTK_TREE_VIEW_COLUMN_AUTOSIZE ); gtk_tree_view_column_set_alignment ( column, alignment[i] ); gtk_tree_view_column_pack_start ( column, cell, TRUE ); gtk_tree_view_column_set_title ( column, titles[i] ); gtk_tree_view_column_set_attributes (column, cell, "text", i, NULL); gtk_tree_view_column_set_expand ( column, TRUE ); gtk_tree_view_column_set_resizable ( column, TRUE ); gtk_tree_view_append_column ( GTK_TREE_VIEW(treeview_transactions_to_link), column); } /* set the button to associate */ hbox = gtk_box_new ( GTK_ORIENTATION_HORIZONTAL, 0 ); gtk_box_set_homogeneous ( GTK_BOX ( hbox ), TRUE ); gtk_box_pack_start ( GTK_BOX (page), hbox, FALSE, FALSE, 10 ); button = gtk_button_new_with_label ( _("Link the selection to a reconciliation...")); g_signal_connect ( G_OBJECT (button), "clicked", G_CALLBACK (gsb_assistant_reconcile_config_lauch_manu_asso), assistant ); gtk_box_pack_start ( GTK_BOX (hbox), button, TRUE, TRUE, 0 ); gtk_widget_show_all (page); return page; }
/* 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_STRING, /* SI */ G_TYPE_INT, /* Num MSUs */ G_TYPE_STRING, /* MSUs/sec */ G_TYPE_INT, /* Num Bytes */ G_TYPE_STRING, /* Bytes/MSU */ G_TYPE_STRING); /* Bytes/sec */ /* 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, SI_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 ("SI", renderer, "text", SI_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, SI_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, 110); /* 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 ("Num MSUs", renderer, "text", NUM_MSUS_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_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); /* 3:d column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("MSUs/sec", renderer, "text", NUM_MSUS_SEC_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_SEC_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); /* 4:d column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer, "text", NUM_BYTES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_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); /* 5:th column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Bytes/MSU", renderer, "text", NUM_BYTES_MSU_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_MSU_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); /* 6:th column... */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Bytes/sec", renderer, "text", NUM_BYTES_SEC_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_SEC_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); /* 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; }
gboolean completion_create(GtkTreeModel *model, CompletionSelectFunc selfunc, gboolean back) { GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkRequisition size; GtkTreePath *path; GtkTreeIter iter; int height, width; /* if there is only one match - don't build the tree view */ if (gtk_tree_model_iter_n_children(model, NULL) == 1) { char *value; path = gtk_tree_path_new_from_indices(0, -1); if (gtk_tree_model_get_iter(model, &iter, path)) { gtk_tree_model_get(model, &iter, COMPLETION_STORE_FIRST, &value, -1); /* call the select function */ selfunc(value); g_free(value); g_object_unref(model); return false; } } comp.selfunc = selfunc; /* prepare the tree view */ comp.win = gtk_scrolled_window_new(NULL, NULL); comp.tree = gtk_tree_view_new(); #ifndef HAS_GTK3 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(comp.win), GTK_POLICY_NEVER, GTK_POLICY_NEVER); #endif gtk_box_pack_end(GTK_BOX(vb.gui.box), comp.win, false, false, 0); gtk_container_add(GTK_CONTAINER(comp.win), comp.tree); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(comp.tree), false); /* we have only on line per item so we can use the faster fixed heigh mode */ gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(comp.tree), true); gtk_tree_view_set_model(GTK_TREE_VIEW(comp.tree), model); g_object_unref(model); VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_fg[VB_COMP_NORMAL]); VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_bg[VB_COMP_NORMAL]); VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_fg[VB_COMP_ACTIVE]); VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_bg[VB_COMP_ACTIVE]); VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_fg[VB_COMP_ACTIVE]); VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_bg[VB_COMP_ACTIVE]); /* prepare the selection */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(comp.tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function(selection, tree_selection_func, NULL, NULL); /* get window dimension */ gtk_window_get_size(GTK_WINDOW(vb.gui.window), &width, &height); /* prepare first column */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "font-desc", vb.style.comp_font, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL ); gtk_tree_view_column_pack_start(column, renderer, true); gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_FIRST); gtk_tree_view_column_set_min_width(column, 2 * width/3); /* prepare second column */ #ifdef FEATURE_TITLE_IN_COMPLETION column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "font-desc", vb.style.comp_font, "ellipsize", PANGO_ELLIPSIZE_END, NULL ); gtk_tree_view_column_pack_start(column, renderer, true); gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_SECOND); #endif /* to set the height for the treeview the tree must be realized first */ gtk_widget_show(comp.tree); /* this prevents the first item to be placed out of view if the completion * is shown */ while (gtk_events_pending()) { gtk_main_iteration(); } /* use max 1/3 of window height for the completion */ #ifdef HAS_GTK3 gtk_widget_get_preferred_size(comp.tree, NULL, &size); height /= 3; gtk_scrolled_window_set_min_content_height( GTK_SCROLLED_WINDOW(comp.win), size.height > height ? height : size.height ); #else gtk_widget_size_request(comp.tree, &size); height /= 3; if (size.height > height) { gtk_widget_set_size_request(comp.win, -1, height); } #endif vb.mode->flags |= FLAG_COMPLETION; /* set to -1 to have the cursor on first or last item set in move_cursor */ comp.active = -1; completion_next(back); gtk_widget_show(comp.win); return true; }
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); /* 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); }
void library_view_init(library_view_t* view) { // library view. GObject* object = gtk_builder_get_object(view->builder,"view_library"); g_object_set_data(object, "library_view_t", (gpointer) view); // playlists (initially not viewed) //GtkWidget* scw_playlists = GTK_WIDGET(gtk_builder_get_object(view->builder,"scw_playlists")); //gtk_widget_hide(scw_playlists); // library list GtkTreeView* tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_library")); view->tview = tview; GtkTreeViewColumn *col; GtkCellRenderer* renderer; renderer = gtk_cell_renderer_text_new(); view->cols = (GtkTreeViewColumn**) mc_malloc(sizeof(GtkTreeViewColumn*) * PLAYLIST_MODEL_N_COLUMNS); playlist_column_enum e; for(e = PLAYLIST_MODEL_COL_NR; e < PLAYLIST_MODEL_N_COLUMNS; ++e) { col = gtk_tree_view_column_new_with_attributes(i18n_column_name(e), renderer, "text", e, NULL); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); char path [500]; sprintf(path, "library.column.%s.width", column_id(e)); int width = el_config_get_int(btb_config(view->btb), path, 100); if (width < 10) { width = 100; } g_object_set_data(G_OBJECT(col), "column_id", (gpointer) column_id(e)); gtk_tree_view_column_set_fixed_width(col, width); gtk_tree_view_column_set_reorderable(col, TRUE); gtk_tree_view_column_set_resizable(col, TRUE); gtk_tree_view_column_set_clickable(col, TRUE); g_signal_connect(col, "clicked", (GCallback) library_view_library_col_sort, view); g_signal_connect (col, "notify::width", G_CALLBACK (library_view_col_width_set), view); view->cols[e] = col; g_object_ref(view->cols[e]); gtk_tree_view_append_column(tview, col); } gtk_tree_view_set_model(tview, GTK_TREE_MODEL(playlist_model_gtk_model(view->playlist_model))); // Aspect lists int width; // Genres tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_genre_aspect")); col = gtk_tree_view_column_new_with_attributes(_("Genre"), renderer, "text", 0, NULL); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); //width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200); //gtk_tree_view_column_set_fixed_width(col, width); gtk_tree_view_append_column(tview, col); gtk_tree_view_set_model(tview, string_model_gtk_model(view->genre_model)); // Artists tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_artist_aspect")); col = gtk_tree_view_column_new_with_attributes(_("Artists"), renderer, "text", 0, NULL); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); //width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200); //gtk_tree_view_column_set_fixed_width(col, width); gtk_tree_view_append_column(tview, col); gtk_tree_view_set_model(tview, string_model_gtk_model(view->artist_model)); // Albums tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_album_aspect")); col = gtk_tree_view_column_new_with_attributes(_("Artists"), renderer, "text", 0, NULL); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); //width = el_config_get_int(btb_config(view->btb), "library.aspects.column_width", 200); //gtk_tree_view_column_set_fixed_width(col, width); gtk_tree_view_append_column(tview, col); gtk_tree_view_set_model(tview, string_model_gtk_model(view->album_model)); // Activate genres library_view_aspect_page(view, GENRE_ASPECT); GtkToggleToolButton* g_btn = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(view->builder, "tbtn_genres")); gtk_toggle_tool_button_set_active(g_btn, TRUE); // playback scale, song info GtkScale* sc_playback = GTK_SCALE(gtk_builder_get_object(view->builder, "sc_library_playback")); gtk_range_set_range(GTK_RANGE(sc_playback), 0.0, 100.0); { char ss[300]; sprintf(ss,"<span size=\"x-small\"><i><b> </b></i></span>"); GtkLabel* lbl = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_song_info")); gtk_label_set_markup(lbl, ss); } // Set logo { char *path = backtobasics_logo(view->btb); file_info_t* info = file_info_new(path); mc_free(path); if (file_info_is_file(info)) { GError *err = NULL; GdkPixbuf* pb = gdk_pixbuf_new_from_file_at_scale(file_info_path(info), view->img_w, view->img_h, TRUE, &err ); GtkImage* img = GTK_IMAGE(gtk_builder_get_object(view->builder, "img_art")); gtk_widget_set_size_request(GTK_WIDGET(img), view->img_w, view->img_h); if (pb != NULL) { gtk_image_set_from_pixbuf(img, pb); g_object_unref(pb); } else { log_error3("error loading image art: %d, %s", err->code, err->message); //g_free(err); } } file_info_destroy(info); } // Playlists tview = GTK_TREE_VIEW(gtk_builder_get_object(view->builder, "tv_playlists")); col = gtk_tree_view_column_new_with_attributes(_("Playlist"), renderer, "text", 0, NULL); gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED); width = el_config_get_int(btb_config(view->btb), "library.playlists.column_width", 200); gtk_tree_view_column_set_fixed_width(col, width); gtk_tree_view_append_column(tview, col); gtk_tree_view_set_model(tview, playlists_model_gtk_model(view->playlists_model)); // Lyric view view->lyric_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); view->lbl_lyric_track = GTK_LABEL(gtk_builder_get_object(view->builder, "lbl_lyric_track")); GtkScrolledWindow* scw_lyric = GTK_SCROLLED_WINDOW(gtk_builder_get_object(view->builder, "scw_lyric")); gtk_container_add(GTK_CONTAINER(scw_lyric), GTK_WIDGET(view->lyric_view)); // visibility of columns { const char* names[] = { "chk_col_nr", "chk_col_title", "chk_col_artist", "chk_col_composer", "chk_col_piece", "chk_col_album", "chk_col_albumartist", "chk_col_genre", "chk_col_year", "chk_col_length", NULL }; const playlist_column_enum es[] = { PLAYLIST_MODEL_COL_NR, PLAYLIST_MODEL_COL_TITLE, PLAYLIST_MODEL_COL_ARTIST, PLAYLIST_MODEL_COL_COMPOSER, PLAYLIST_MODEL_COL_PIECE, PLAYLIST_MODEL_COL_ALBUM_TITLE, PLAYLIST_MODEL_COL_ALBUM_ARTIST, PLAYLIST_MODEL_COL_GENRE, PLAYLIST_MODEL_COL_YEAR, PLAYLIST_MODEL_COL_LENGTH, PLAYLIST_MODEL_N_COLUMNS }; int i; for(i = 0;names[i] != NULL; ++i) { GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(gtk_builder_get_object(view->builder, names[i])); gtk_widget_set_name(GTK_WIDGET(item), names[i]); char cfgitem[100]; sprintf(cfgitem, "library.cols.%s", names[i]); int yes = el_config_get_int(btb_config(view->btb), cfgitem, 1); gtk_check_menu_item_set_active(item, yes); gtk_tree_view_column_set_visible(view->cols[es[i]], yes); } } // Start timeout every 250 ms g_timeout_add(250, (GSourceFunc) library_view_update_info, view); }
static void add_columns (GtkTreeView *treeview) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeModel *model = gtk_tree_view_get_model (treeview); /* column for fixed toggles */ renderer = gtk_cell_renderer_toggle_new (); g_signal_connect (renderer, "toggled", G_CALLBACK (fixed_toggled), model); column = gtk_tree_view_column_new_with_attributes ("Fixed?", renderer, "active", COLUMN_FIXED, NULL); /* set this column to a fixed sizing (of 50 pixels) */ gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 50); gtk_tree_view_append_column (treeview, column); /* column for bug numbers */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Bug number", renderer, "text", COLUMN_NUMBER, NULL); gtk_tree_view_column_set_sort_column_id (column, COLUMN_NUMBER); gtk_tree_view_append_column (treeview, column); /* column for severities */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Severity", renderer, "text", COLUMN_SEVERITY, NULL); gtk_tree_view_column_set_sort_column_id (column, COLUMN_SEVERITY); gtk_tree_view_append_column (treeview, column); /* column for description */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", COLUMN_DESCRIPTION, NULL); gtk_tree_view_column_set_sort_column_id (column, COLUMN_DESCRIPTION); gtk_tree_view_append_column (treeview, column); /* column for spinner */ renderer = gtk_cell_renderer_spinner_new (); column = gtk_tree_view_column_new_with_attributes ("Spinning", renderer, "pulse", COLUMN_PULSE, "active", COLUMN_ACTIVE, NULL); gtk_tree_view_column_set_sort_column_id (column, COLUMN_PULSE); gtk_tree_view_append_column (treeview, column); /* column for symbolic icon */ renderer = gtk_cell_renderer_pixbuf_new (); column = gtk_tree_view_column_new_with_attributes ("Symbolic icon", renderer, "icon-name", COLUMN_ICON, "sensitive", COLUMN_SENSITIVE, NULL); gtk_tree_view_column_set_sort_column_id (column, COLUMN_ICON); gtk_tree_view_append_column (treeview, column); }
static PanelAddtoDialog * panel_addto_dialog_new (PanelWidget *panel_widget) { PanelAddtoDialog *dialog; GtkWidget *dialog_vbox; GtkWidget *inner_vbox; GtkWidget *find_hbox; GtkWidget *sw; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; dialog = g_new0 (PanelAddtoDialog, 1); g_object_set_qdata_full (G_OBJECT (panel_widget->toplevel), panel_addto_dialog_quark, dialog, (GDestroyNotify) panel_addto_dialog_free); dialog->panel_widget = panel_widget; dialog->name_notify = panel_profile_toplevel_notify_add ( dialog->panel_widget->toplevel, "name", (MateConfClientNotifyFunc) panel_addto_name_notify, dialog); dialog->addto_dialog = gtk_dialog_new (); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP); dialog->back_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_GO_BACK, PANEL_ADDTO_RESPONSE_BACK); dialog->add_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_ADD, PANEL_ADDTO_RESPONSE_ADD); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), FALSE); gtk_dialog_set_has_separator (GTK_DIALOG (dialog->addto_dialog), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (dialog->addto_dialog), PANEL_ADDTO_RESPONSE_ADD); gtk_container_set_border_width (GTK_CONTAINER (dialog->addto_dialog), 5); dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog->addto_dialog)); gtk_box_set_spacing (GTK_BOX (dialog_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5); g_signal_connect (G_OBJECT (dialog->addto_dialog), "response", G_CALLBACK (panel_addto_dialog_response), dialog); g_signal_connect (dialog->addto_dialog, "destroy", G_CALLBACK (panel_addto_dialog_destroy), dialog); inner_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0); find_hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (inner_vbox), find_hbox, FALSE, FALSE, 0); dialog->label = gtk_label_new_with_mnemonic (""); gtk_misc_set_alignment (GTK_MISC (dialog->label), 0.0, 0.5); gtk_label_set_use_markup (GTK_LABEL (dialog->label), TRUE); gtk_box_pack_start (GTK_BOX (find_hbox), dialog->label, FALSE, FALSE, 0); dialog->search_entry = gtk_entry_new (); g_signal_connect (G_OBJECT (dialog->search_entry), "changed", G_CALLBACK (panel_addto_search_entry_changed), dialog); g_signal_connect (G_OBJECT (dialog->search_entry), "activate", G_CALLBACK (panel_addto_search_entry_activated), dialog); gtk_box_pack_end (GTK_BOX (find_hbox), dialog->search_entry, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (dialog->label), dialog->search_entry); sw = gtk_scrolled_window_new (NULL, NULL); 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 (inner_vbox), sw, TRUE, TRUE, 0); dialog->tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view), FALSE); gtk_tree_view_expand_all (GTK_TREE_VIEW (dialog->tree_view)); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "xpad", 4, "ypad", 4, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "pixbuf", COLUMN_ICON, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "markup", COLUMN_TEXT, NULL); //FIXME use the same search than the one for the search entry? gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_SEARCH); gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (dialog->tree_view), panel_addto_separator_func, GINT_TO_POINTER (COLUMN_TEXT), NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_TEXT); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect (selection, "changed", G_CALLBACK (panel_addto_selection_changed), dialog); g_signal_connect (dialog->tree_view, "row-activated", G_CALLBACK (panel_addto_selection_activated), dialog); gtk_container_add (GTK_CONTAINER (sw), dialog->tree_view); gtk_widget_show_all (dialog_vbox); panel_toplevel_push_autohide_disabler (dialog->panel_widget->toplevel); panel_widget_register_open_dialog (panel_widget, dialog->addto_dialog); panel_addto_name_change (dialog, panel_toplevel_get_name (dialog->panel_widget->toplevel)); return dialog; }
/** * create the tree wich contains the fyear list * * \param * * \return a GtkTreeView */ GtkWidget *gsb_fyear_config_create_list () { GtkListStore *model; GtkWidget *treeview; gint i; gchar *title[] = { _("Name"), _("Begin date"), _("End date"), _("Invalid"), }; GtkCellRenderer *cell_renderer; /* Create tree store */ model = gtk_list_store_new ( NUM_FYEARS_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT ); /* Create tree tree_view */ treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL(model)); g_object_unref (G_OBJECT(model)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE); /* for all the columns it's a text */ cell_renderer = gtk_cell_renderer_text_new (); g_object_set ( G_OBJECT ( cell_renderer), "xalign", 0.5, NULL ); /* fill the columns : set FYEAR_NUMBER_COLUMN and not NUM_FYEARS_COLUMNS because * the last value of the model mustn't be to text... * so FYEAR_NUMBER_COLUMN must be the first column after the last column showed */ for (i=0 ; i<FYEAR_NUMBER_COLUMN ; i++ ) { GtkTreeViewColumn *column; if ( i == FYEAR_INVALID_COLUMN ) { column = gtk_tree_view_column_new_with_attributes ( title[i], gtk_cell_renderer_pixbuf_new (), "stock-id", i, NULL ); } else { column = gtk_tree_view_column_new_with_attributes ( title[i], cell_renderer, "text", i, NULL ); gtk_tree_view_column_set_sizing ( column, GTK_TREE_VIEW_COLUMN_AUTOSIZE ); gtk_tree_view_column_set_expand ( column, TRUE ); } gtk_tree_view_append_column ( GTK_TREE_VIEW(treeview), column ); } /* Sort columns accordingly */ gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(model), FYEAR_NAME_COLUMN, GTK_SORT_ASCENDING); return treeview; }
static void create_panel (void) { GtkWidget *frame; GtkWidget *box; GtkWidget *scroll; GtkTreeViewColumn *col; GtkCellRenderer *cell; plugin_data.panel = g_object_new (GTK_TYPE_WINDOW, "decorated", FALSE, "default-width", 500, "default-height", 200, "transient-for", geany_data->main_widgets->window, "window-position", GTK_WIN_POS_CENTER_ON_PARENT, "type-hint", GDK_WINDOW_TYPE_HINT_DIALOG, "skip-taskbar-hint", TRUE, "skip-pager-hint", TRUE, NULL); g_signal_connect (plugin_data.panel, "focus-out-event", G_CALLBACK (gtk_widget_hide), NULL); g_signal_connect (plugin_data.panel, "show", G_CALLBACK (on_panel_show), NULL); g_signal_connect (plugin_data.panel, "hide", G_CALLBACK (on_panel_hide), NULL); g_signal_connect (plugin_data.panel, "key-press-event", G_CALLBACK (on_panel_key_press_event), NULL); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (plugin_data.panel), frame); box = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), box); plugin_data.entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (box), plugin_data.entry, FALSE, TRUE, 0); plugin_data.store = gtk_list_store_new (COL_COUNT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, GTK_TYPE_WIDGET, G_TYPE_POINTER); plugin_data.sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (plugin_data.store)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (plugin_data.sort), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); scroll = g_object_new (GTK_TYPE_SCROLLED_WINDOW, "hscrollbar-policy", GTK_POLICY_AUTOMATIC, "vscrollbar-policy", GTK_POLICY_AUTOMATIC, NULL); gtk_box_pack_start (GTK_BOX (box), scroll, TRUE, TRUE, 0); plugin_data.view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (plugin_data.sort)); gtk_widget_set_can_focus (plugin_data.view, FALSE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (plugin_data.view), FALSE); #ifdef DISPLAY_SCORE cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_cell_data_func(col, cell, score_cell_data, col, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (plugin_data.view), col); #endif cell = gtk_cell_renderer_text_new (); g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL); col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup", COL_LABEL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (plugin_data.view), col); g_signal_connect (plugin_data.view, "row-activated", G_CALLBACK (on_view_row_activated), NULL); gtk_container_add (GTK_CONTAINER (scroll), plugin_data.view); /* connect entry signals after the view is created as they use it */ g_signal_connect (plugin_data.entry, "notify::text", G_CALLBACK (on_entry_text_notify), NULL); g_signal_connect (plugin_data.entry, "activate", G_CALLBACK (on_entry_activate), NULL); gtk_widget_show_all (frame); }
static void report_gui_list_clicked(report_gui_t *rg) { report_gui_list_t *rgl = &(rg->list); GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; int i; if ( rgl->window == NULL ) { rgl->window = create_report_list_window(); /* Create list display widget */ rgl->view = GTK_TREE_VIEW(lookup_widget(rgl->window, "report_list_view")); rgl->model = gtk_list_store_new(REPORT_LIST_NCOLS, /* Node Name */ G_TYPE_STRING, /* Verdict */ GDK_TYPE_PIXBUF, /* Verdict Value */ G_TYPE_INT, /* Def. Crit. */ G_TYPE_STRING, /* Def. Crit. Color */ G_TYPE_STRING, /* Def. Crit. Value */ G_TYPE_INT, /* Criticity */ G_TYPE_STRING, /* Crit. Color */ G_TYPE_STRING, /* Criticity Value */ G_TYPE_INT, /* Key */ G_TYPE_ULONG); rgl->model_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(rgl->model)); gtk_tree_view_set_model(rgl->view, rgl->model_sort); /* Setup tree selection handler */ report_gui_list_select_clear(rgl); selection = gtk_tree_view_get_selection(rgl->view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE); gtk_tree_selection_set_select_function(selection, (GtkTreeSelectionFunc) report_gui_list_select, &(rg->list), NULL); /* Column #0: Test Case name */ renderer = gtk_cell_renderer_text_new(); gtk_tree_view_insert_column_with_attributes(rgl->view, -1, "Test Case", renderer, "text", REPORT_LIST_COL_NAME, NULL); column = gtk_tree_view_get_column(rgl->view, 0); gtk_tree_view_column_set_clickable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REPORT_LIST_SORT_NAME); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_expand(column, TRUE); /* Column #1: Default criticity */ renderer = gtk_cell_renderer_text_new(); gtk_object_set(GTK_OBJECT(renderer), "scale", 0.7, NULL); gtk_tree_view_insert_column_with_attributes(rgl->view, -1, "Def. Criticity", renderer, "text", REPORT_LIST_COL_CRITICITY_DEFAULT, "foreground", REPORT_LIST_COL_CRITICITY_DEFAULT_COLOR, NULL); column = gtk_tree_view_get_column(rgl->view, 1); gtk_tree_view_column_set_clickable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REPORT_LIST_SORT_CRITICITY); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); /* Column #2: Verdict and Criticity */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, "Verdict"); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", REPORT_LIST_COL_VERDICT); renderer = gtk_cell_renderer_text_new(); gtk_object_set(GTK_OBJECT(renderer), "scale", 0.7, NULL); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", REPORT_LIST_COL_CRITICITY); gtk_tree_view_column_add_attribute(column, renderer, "foreground", REPORT_LIST_COL_CRITICITY_COLOR); gtk_tree_view_column_set_clickable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REPORT_LIST_SORT_VERDICT); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(rgl->view, column); /* Setup list sort functions */ for (i = 0; i < REPORT_LIST_NSORTS; i++) gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(rgl->model_sort), i, (GtkTreeIterCompareFunc) report_gui_list_sort, GINT_TO_POINTER(i), NULL); /* Setup spot buttons */ rgl->spot_tree = lookup_widget(rgl->window, "report_list_tree"); gtk_widget_set_sensitive(rgl->spot_tree, 0); gtk_signal_connect_object(GTK_OBJECT(rgl->spot_tree), "clicked", (GtkSignalFunc) report_gui_list_tree_clicked, rg); rgl->spot_log = lookup_widget(rgl->window, "report_list_log"); gtk_widget_set_sensitive(rgl->spot_log, 0); gtk_signal_connect_object(GTK_OBJECT(rgl->spot_log), "clicked", (GtkSignalFunc) report_gui_list_log_clicked, rg); /* Setup termination events */ gtk_signal_connect_object(GTK_OBJECT(rgl->window), "destroy", (GtkSignalFunc) report_gui_list_destroyed, rg); gtk_signal_connect_object(GTK_OBJECT(lookup_widget(rgl->window, "report_list_close")), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(rgl->window)); /* Feed the list */ report_gui_list_feed(rg); gtk_widget_show(rgl->window); gtk_tree_selection_unselect_all(selection); } else { gtk_window_present(GTK_WINDOW(rgl->window)); } }
static void set_up_global_variables_view (SnippetsManagerPlugin *snippets_manager_plugin, GtkTreeView *global_vars_view) { GtkCellRenderer *cell = NULL; GtkTreeViewColumn *col = NULL; GtkTreeModel *global_vars_model = NULL; /* Assertions */ global_vars_model = snippets_db_get_global_vars_model (snippets_manager_plugin->snippets_db); g_return_if_fail (GTK_IS_TREE_MODEL (global_vars_model)); g_return_if_fail (GTK_IS_TREE_VIEW (global_vars_view)); /* Set up the model */ gtk_tree_view_set_model (global_vars_view, global_vars_model); /* Set up the name cell */ cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (col, "Name"); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_column_pack_start (col, cell, FALSE); gtk_tree_view_column_set_cell_data_func (col, cell, global_vars_view_name_data_func, NULL, NULL); gtk_tree_view_append_column (global_vars_view, col); g_signal_connect (GTK_OBJECT (cell), "edited", GTK_SIGNAL_FUNC (on_global_vars_name_changed), snippets_manager_plugin->snippets_db); /* Set up the type cell */ cell = gtk_cell_renderer_toggle_new (); col = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (col, "Command?"); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_column_pack_start (col, cell, FALSE); gtk_tree_view_column_set_cell_data_func (col, cell, global_vars_view_type_data_func, NULL, NULL); gtk_tree_view_append_column (global_vars_view, col); g_signal_connect (GTK_OBJECT (cell), "toggled", GTK_SIGNAL_FUNC (on_global_vars_type_toggled), snippets_manager_plugin->snippets_db); /* Set up the text cell */ cell = gtk_cell_renderer_text_new (); col = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (col, "Variable text"); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_column_pack_start (col, cell, FALSE); gtk_tree_view_column_set_cell_data_func (col, cell, global_vars_view_text_data_func, snippets_manager_plugin->snippets_db, NULL); gtk_tree_view_append_column (global_vars_view, col); g_signal_connect (GTK_OBJECT (cell), "edited", GTK_SIGNAL_FUNC (on_global_vars_text_changed), snippets_manager_plugin->snippets_db); /* Set up the instant value cell */ cell = gtk_cell_renderer_text_new (); g_object_set (cell, "editable", FALSE, NULL); col = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (col, "Instant value"); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable (col, TRUE); gtk_tree_view_column_pack_start (col, cell, FALSE); gtk_tree_view_column_set_cell_data_func (col, cell, global_vars_view_value_data_func, snippets_manager_plugin->snippets_db, NULL); gtk_tree_view_append_column (global_vars_view, col); }
static pid_t attach_process_show (AttachProcess * ap, GtkWindow *parent) { GtkTreeView *view; GtkTreeStore *store; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkCheckButton *checkb_hide_paths; GtkCheckButton *checkb_hide_params; GtkCheckButton *checkb_process_tree; gint i, res; pid_t selected_pid = -1; g_return_val_if_fail (ap != NULL, -1); if (!ap->dialog) { GtkBuilder *bxml; bxml = anjuta_util_builder_new (GLADE_FILE, NULL); if (!bxml) return 0; anjuta_util_builder_get_objects (bxml, "attach_process_dialog", &ap->dialog, "attach_process_tv", &ap->treeview, "checkb_hide_paths", &checkb_hide_paths, "checkb_hide_params", &checkb_hide_params, "checkb_process_tree", &checkb_process_tree, NULL); g_object_unref (bxml); view = GTK_TREE_VIEW (ap->treeview); store = gtk_tree_store_new (COLUMNS_NB, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model (view, GTK_TREE_MODEL (store)); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (view), GTK_SELECTION_SINGLE); g_object_unref (G_OBJECT (store)); renderer = gtk_cell_renderer_text_new (); for (i = PID_COLUMN; i < COLUMNS_NB; i++) { GtkTreeViewColumn *column; column = gtk_tree_view_column_new_with_attributes (column_names[i], renderer, "text", i, NULL); gtk_tree_view_column_set_sort_column_id(column, i); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column (view, column); if (i == COMMAND_COLUMN) gtk_tree_view_set_expander_column(view, column); } gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), PID_COLUMN, sort_pid, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), START_COLUMN, GTK_SORT_DESCENDING); ap->hide_paths = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (checkb_hide_paths)); ap->hide_params = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (checkb_hide_params)); ap->process_tree = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (checkb_process_tree)); attach_process_update (ap); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (ap->treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (on_selection_changed), ap); g_signal_connect (G_OBJECT (ap->dialog), "delete_event", G_CALLBACK (on_delete_event), ap); g_signal_connect (checkb_hide_paths, "toggled", G_CALLBACK (on_toggle_hide_paths), ap); g_signal_connect (checkb_hide_params, "toggled", G_CALLBACK (on_toggle_hide_params), ap); g_signal_connect (checkb_process_tree, "toggled", G_CALLBACK (on_toggle_process_tree), ap); } gtk_window_set_transient_for (GTK_WINDOW (ap->dialog), GTK_WINDOW (parent)); /* gtk_widget_show (ap->dialog); */ res = gtk_dialog_run (GTK_DIALOG (ap->dialog)); while (res == GTK_RESPONSE_APPLY) { attach_process_update (ap); res = gtk_dialog_run (GTK_DIALOG (ap->dialog)); } if (res == GTK_RESPONSE_OK) { selected_pid = ap->pid; } attach_process_clear (ap, CLEAR_FINAL); return selected_pid; }
static void plugin_manager_create(void) { GtkWidget *window; GtkWidget *vbox; #ifdef USE_UPDATE_CHECK_PLUGIN GtkWidget *update_check_btn; #endif GtkWidget *close_btn; GtkWidget *confirm_area; GtkWidget *scrolledwin; GtkWidget *treeview; GtkListStore *store; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), _("Plug-in manager")); gtk_widget_set_size_request(window, 600, 400); gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, TRUE); gtk_container_set_border_width(GTK_CONTAINER(window), 8); vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(window), vbox); gtkut_stock_button_set_create(&confirm_area, #ifdef USE_UPDATE_CHECK_PLUGIN &update_check_btn, _("Check for _update"), &close_btn, GTK_STOCK_CLOSE, NULL, NULL); gtkut_box_set_reverse_order(GTK_BOX(confirm_area), TRUE); #else &close_btn, GTK_STOCK_CLOSE, NULL, NULL, NULL, NULL); #endif gtk_widget_show(confirm_area); gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(close_btn); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(plugin_manager_deleted), NULL); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(key_pressed), NULL); #ifdef USE_UPDATE_CHECK_PLUGIN g_signal_connect(G_OBJECT(update_check_btn), "clicked", G_CALLBACK(plugin_manager_update_check), NULL); #endif g_signal_connect(G_OBJECT(close_btn), "clicked", G_CALLBACK(plugin_manager_deleted), NULL); scrolledwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwin); gtk_widget_set_size_request(scrolledwin, -1, -1); gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin), GTK_SHADOW_IN); store = gtk_list_store_new(N_COLS, G_TYPE_STRING); treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); g_object_unref(G_OBJECT(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COL_INFO); #if GTK_CHECK_VERSION(2, 10, 0) gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(treeview), GTK_TREE_VIEW_GRID_LINES_HORIZONTAL); #endif selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes (_("Plug-in information"), renderer, "text", COL_INFO, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column); gtk_widget_show(treeview); gtk_container_add(GTK_CONTAINER(scrolledwin), treeview); gtk_widget_show_all(window); pm_window.window = window; pm_window.close_btn = close_btn; pm_window.treeview = treeview; pm_window.store = store; pm_window.selection = selection; }
/* 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, /* ID */ G_TYPE_STRING, /* Operation Code */ G_TYPE_INT, /* Invokes */ G_TYPE_INT, /* Num Bytes */ G_TYPE_FLOAT, /* Avg Bytes */ G_TYPE_INT, /* RetResult */ G_TYPE_INT, /* Num Bytes */ G_TYPE_FLOAT, /* Avg Bytes */ G_TYPE_INT, /* 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, ID_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 ("ID", renderer, "text", ID_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, ID_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, 40); /* Add the column to the view. */ gtk_tree_view_append_column (list_view, column); /* 2:nd column..Operation Code. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Operation Code", renderer, "text", 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, 210); gtk_tree_view_append_column (list_view, column); /* 3:d column..Invokes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Invokes", renderer, "text", INVOKES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, INVOKES_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); gtk_tree_view_append_column (list_view, column); /* 4:th column.. Num Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer, "text", NUM_BYTES_FWD_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_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); /* 5:th column.. Avg Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer, "text", AVG_BYTES_FWD_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func, GINT_TO_POINTER(AVG_BYTES_FWD_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_FWD_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); /* 6:d column..Invokes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("ReturnResult", renderer, "text", RET_RES_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, RET_RES_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); gtk_tree_view_append_column (list_view, column); /* 7:th column.. Num Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer, "text", NUM_BYTES_REV_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_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); /* 8:th column.. Avg Bytes. */ renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer, "text", AVG_BYTES_REV_COLUMN, NULL); gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func, GINT_TO_POINTER(AVG_BYTES_REV_COLUMN), NULL); gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_REV_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); /* 9:th column.. Total Bytes. */ 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, NUM_BYTES_FWD_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, 60); 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; }
GtkWidget *discard_build_page(void) { GtkWidget *vbox; GtkWidget *label; GtkWidget *alignment; GtkWidget *scroll_win; GtkCellRenderer *renderer; GtkTreeViewColumn *column; vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox); alignment = gtk_alignment_new(0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 3, 3); gtk_widget_show(alignment); gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, FALSE, 0); label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(label), /* Caption for list of player that must discard cards */ _("<b>Waiting for players to discard</b>")); gtk_widget_show(label); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_container_add(GTK_CONTAINER(alignment), label); scroll_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scroll_win), GTK_SHADOW_IN); gtk_widget_show(scroll_win); gtk_box_pack_start(GTK_BOX(vbox), scroll_win, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); discard_store = gtk_list_store_new(DISCARD_COLUMN_LAST, GDK_TYPE_PIXBUF, /* player icon */ G_TYPE_INT, /* player number */ G_TYPE_STRING, /* text */ G_TYPE_INT); /* amount to discard */ discard_widget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(discard_store)); column = gtk_tree_view_column_new_with_attributes("", gtk_cell_renderer_pixbuf_new (), "pixbuf", DISCARD_COLUMN_PLAYER_ICON, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY); gtk_tree_view_append_column(GTK_TREE_VIEW(discard_widget), column); column = gtk_tree_view_column_new_with_attributes("", gtk_cell_renderer_text_new (), "text", DISCARD_COLUMN_PLAYER_NAME, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_append_column(GTK_TREE_VIEW(discard_widget), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", DISCARD_COLUMN_AMOUNT, NULL); g_object_set(renderer, "xalign", 1.0f, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY); gtk_tree_view_append_column(GTK_TREE_VIEW(discard_widget), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(discard_widget), FALSE); gtk_widget_show(discard_widget); gtk_container_add(GTK_CONTAINER(scroll_win), discard_widget); return vbox; }
static void editor_list_window_create(void) { GtkWidget *win_vbox; GtkWidget *hbox; GtkWidget *button; GtkWidget *scrolled; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkTreeModel *store; GtkTreeSortable *sortable; EditorListWindow *ewl; editor_list_window = ewl = g_new0(EditorListWindow, 1); ewl->window = window_new(GTK_WINDOW_TOPLEVEL, "editors", PIXBUF_INLINE_ICON_CONFIG, NULL, _("Editors")); gtk_window_set_type_hint(GTK_WINDOW(ewl->window), GDK_WINDOW_TYPE_HINT_DIALOG); g_signal_connect(G_OBJECT(ewl->window), "delete_event", G_CALLBACK(editor_list_window_delete), NULL); gtk_window_set_default_size(GTK_WINDOW(ewl->window), CONFIG_WINDOW_DEF_WIDTH, CONFIG_WINDOW_DEF_HEIGHT); gtk_window_set_resizable(GTK_WINDOW(ewl->window), TRUE); gtk_container_set_border_width(GTK_CONTAINER(ewl->window), PREF_PAD_BORDER); win_vbox = gtk_vbox_new(FALSE, PREF_PAD_SPACE); gtk_container_add(GTK_CONTAINER(ewl->window), win_vbox); gtk_widget_show(win_vbox); hbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbox), PREF_PAD_BUTTON_GAP); gtk_box_pack_end(GTK_BOX(win_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show(hbox); button = pref_button_new(NULL, GTK_STOCK_NEW, NULL, FALSE, G_CALLBACK(editor_list_window_new_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_show(button); button = pref_button_new(NULL, GTK_STOCK_EDIT, NULL, FALSE, G_CALLBACK(editor_list_window_edit_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_set_sensitive(button, FALSE); gtk_widget_show(button); ewl->edit_button = button; button = pref_button_new(NULL, GTK_STOCK_DELETE, NULL, FALSE, G_CALLBACK(editor_list_window_delete_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_set_sensitive(button, FALSE); gtk_widget_show(button); ewl->delete_button = button; button = pref_button_new(NULL, GTK_STOCK_CLOSE, NULL, FALSE, G_CALLBACK(editor_list_window_close_cb), ewl); gtk_container_add(GTK_CONTAINER(hbox), button); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_widget_show(button); 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); gtk_box_pack_start(GTK_BOX(win_vbox), scrolled, TRUE, TRUE, 5); gtk_widget_show(scrolled); ewl->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(desktop_file_list)); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ewl->view)); gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE); g_signal_connect(selection, "changed", G_CALLBACK(editor_list_window_selection_changed_cb), ewl); gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ewl->view), FALSE); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Name")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_NAME); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Hidden")); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_HIDDEN); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_HIDDEN); gtk_tree_view_column_set_alignment(column, 0.5); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Desktop file")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_KEY); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_KEY); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Path")); gtk_tree_view_column_set_resizable(column, TRUE); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", DESKTOP_FILE_COLUMN_PATH); gtk_tree_view_append_column(GTK_TREE_VIEW(ewl->view), column); gtk_tree_view_column_set_sort_column_id(column, DESKTOP_FILE_COLUMN_PATH); /* set up sorting */ store = gtk_tree_view_get_model(GTK_TREE_VIEW(ewl->view)); sortable = GTK_TREE_SORTABLE(store); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_KEY, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_KEY), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_HIDDEN, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_HIDDEN), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_NAME, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_NAME), NULL); gtk_tree_sortable_set_sort_func(sortable, DESKTOP_FILE_COLUMN_PATH, editor_list_window_sort_cb, GINT_TO_POINTER(DESKTOP_FILE_COLUMN_PATH), NULL); /* set initial sort order */ //gtk_tree_sortable_set_sort_column_id(sortable, DESKTOP_FILE_COLUMN_KEY, GTK_SORT_ASCENDING); gtk_container_add(GTK_CONTAINER(scrolled), ewl->view); gtk_widget_show(ewl->view); gtk_widget_show(ewl->window); }
static GtkWidget * key_dialog_treeview_new (GtkWidget *box) { GtkWidget *scroll; GtkListStore *store, *combostore; GtkTreeViewColumn *col; GtkWidget *view; GtkCellRenderer *render; int i; scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); g_return_val_if_fail (store != NULL, NULL); view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE); g_signal_connect (G_OBJECT (view), "key-press-event", G_CALLBACK (key_dialog_keypress), NULL); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW(view))), "changed", G_CALLBACK (key_dialog_selection_changed), NULL); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE); render = gtk_cell_renderer_accel_new (); g_object_set (render, "editable", TRUE, #ifndef WIN32 "accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER, #endif NULL); g_signal_connect (G_OBJECT (render), "accel-edited", G_CALLBACK (key_dialog_set_key), NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), KEY_COLUMN, "Key", render, "text", KEY_COLUMN, NULL); render = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), ACCEL_COLUMN, "Accel", render, "text", ACCEL_COLUMN, NULL); combostore = gtk_list_store_new (1, G_TYPE_STRING); for (i = 0; i <= KEY_MAX_ACTIONS; i++) { GtkTreeIter iter; if (key_actions[i].name[0]) { gtk_list_store_append (combostore, &iter); gtk_list_store_set (combostore, &iter, 0, key_actions[i].name, -1); } } render = gtk_cell_renderer_combo_new (); g_object_set (G_OBJECT (render), "model", combostore, "has-entry", FALSE, "editable", TRUE, "text-column", 0, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (ACTION_COLUMN)); g_signal_connect (G_OBJECT (render), "changed", G_CALLBACK (key_dialog_combo_changed), combostore); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), ACTION_COLUMN, "Action", render, "text", ACTION_COLUMN, NULL); render = gtk_cell_renderer_text_new (); g_object_set (render, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D1_COLUMN)); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), D1_COLUMN, "Data1", render, "text", D1_COLUMN, NULL); render = gtk_cell_renderer_text_new (); g_object_set (render, "editable", TRUE, NULL); g_signal_connect (G_OBJECT (render), "edited", G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D2_COLUMN)); gtk_tree_view_insert_column_with_attributes ( GTK_TREE_VIEW (view), D2_COLUMN, "Data2", render, "text", D2_COLUMN, NULL); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), KEY_COLUMN); gtk_tree_view_column_set_fixed_width (col, 200); gtk_tree_view_column_set_resizable (col, TRUE); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACCEL_COLUMN); gtk_tree_view_column_set_visible (col, FALSE); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACTION_COLUMN); gtk_tree_view_column_set_fixed_width (col, 160); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D1_COLUMN); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_min_width (col, 80); gtk_tree_view_column_set_resizable (col, TRUE); col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D2_COLUMN); gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_min_width (col, 80); gtk_tree_view_column_set_resizable (col, TRUE); gtk_container_add (GTK_CONTAINER (scroll), view); gtk_container_add (GTK_CONTAINER (box), scroll); return view; }
static void add_columns (GtkTreeView *treeview) { gint col_offset; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeModel *model = gtk_tree_view_get_model (treeview); /* column for holiday names */ renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xalign", 0.0, NULL); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Holiday", renderer, "text", HOLIDAY_NAME_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* alex column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)ALEX_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Alex", renderer, "active", ALEX_COLUMN, "visible", VISIBLE_COLUMN, "activatable", WORLD_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* havoc column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)HAVOC_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Havoc", renderer, "active", HAVOC_COLUMN, "visible", VISIBLE_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* tim column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)TIM_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Tim", renderer, "active", TIM_COLUMN, "visible", VISIBLE_COLUMN, "activatable", WORLD_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* owen column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)OWEN_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Owen", renderer, "active", OWEN_COLUMN, "visible", VISIBLE_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); /* dave column */ renderer = gtk_cell_renderer_toggle_new (); g_object_set (renderer, "xalign", 0.0, NULL); g_object_set_data (G_OBJECT (renderer), "column", (gint *)DAVE_COLUMN); g_signal_connect (renderer, "toggled", G_CALLBACK (item_toggled), model); col_offset = gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview), -1, "Dave", renderer, "active", DAVE_COLUMN, "visible", VISIBLE_COLUMN, NULL); column = gtk_tree_view_get_column (GTK_TREE_VIEW (treeview), col_offset - 1); gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column), GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE); }
/** * query_favorite_selector_new * * Returns: a new #GtkWidget */ GtkWidget * query_favorite_selector_new (TConnection *tcnc) { QueryFavoriteSelector *tsel; GdaTreeManager *manager; g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL); tsel = QUERY_FAVORITE_SELECTOR (g_object_new (QUERY_FAVORITE_SELECTOR_TYPE, NULL)); tsel->priv->tcnc = g_object_ref (tcnc); g_signal_connect (t_connection_get_favorites (tsel->priv->tcnc), "favorites-changed", G_CALLBACK (favorites_changed_cb), tsel); /* create tree managers */ tsel->priv->tree = gda_tree_new (); manager = mgr_favorites_new (tcnc, T_FAVORITES_QUERIES, ORDER_KEY_QUERIES); gda_tree_add_manager (tsel->priv->tree, manager); g_object_unref (manager); /* update the tree's contents */ if (! gda_tree_update_all (tsel->priv->tree, NULL)) { if (tsel->priv->idle_update_favorites == 0) tsel->priv->idle_update_favorites = g_idle_add ((GSourceFunc) idle_update_favorites, tsel); } /* header */ GtkWidget *label; gchar *str; str = g_strdup_printf ("<b>%s</b>", _("Favorites")); label = gdaui_bar_new (str); g_free (str); gdaui_bar_set_icon_from_resource (GDAUI_BAR (label), "/images/gda-browser-bookmark.png"); gtk_box_pack_start (GTK_BOX (tsel), label, FALSE, FALSE, 0); gtk_widget_show (label); /* tree model */ GtkTreeModel *model; GtkWidget *treeview; GtkCellRenderer *renderer; GtkTreeViewColumn *column; model = gdaui_tree_store_new (tsel->priv->tree, 7, G_TYPE_INT, MGR_FAVORITES_POSITION_ATT_NAME, G_TYPE_OBJECT, "icon", G_TYPE_STRING, MGR_FAVORITES_CONTENTS_ATT_NAME, G_TYPE_UINT, MGR_FAVORITES_TYPE_ATT_NAME, G_TYPE_INT, MGR_FAVORITES_ID_ATT_NAME, G_TYPE_STRING, MGR_FAVORITES_NAME_ATT_NAME, G_TYPE_STRING, "summary"); treeview = ui_make_tree_view (model); tsel->priv->treeview = treeview; g_object_unref (model); /* icon */ 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_add_attribute (column, renderer, "pixbuf", COLUMN_ICON); g_object_set ((GObject*) renderer, "yalign", 0., NULL); /* text */ renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) cell_data_func, NULL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); /* scrolled window packing */ GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw), treeview); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); gtk_box_pack_start (GTK_BOX (tsel), sw, TRUE, TRUE, 0); gtk_widget_show_all (sw); g_signal_connect (G_OBJECT (treeview), "row-activated", G_CALLBACK (selection_changed_cb), tsel); g_signal_connect (G_OBJECT (treeview), "key-press-event", G_CALLBACK (key_press_event_cb), tsel); g_signal_connect (G_OBJECT (treeview), "popup-menu", G_CALLBACK (popup_menu_cb), tsel); g_signal_connect (G_OBJECT (treeview), "button-press-event", G_CALLBACK (button_press_event_cb), tsel); /* DnD */ gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (treeview), dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY); gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (treeview), GDK_BUTTON1_MASK, dbo_table, G_N_ELEMENTS (dbo_table), GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect (model, "drag-drop", G_CALLBACK (tree_store_drag_drop_cb), tsel); g_signal_connect (model, "drag-can-drag", G_CALLBACK (tree_store_drag_can_drag_cb), tsel); g_signal_connect (model, "drag-get", G_CALLBACK (tree_store_drag_get_cb), tsel); return (GtkWidget*) tsel; }
void search_playlist_dialog(void) { GtkWidget * vbox; GtkWidget * hbox; GtkWidget * label; GtkWidget * button; GtkWidget * table; GtkWidget * hbuttonbox; GtkWidget * search_viewport; GtkWidget * search_scrwin; GtkWidget * search_list; GtkCellRenderer * search_renderer; GtkTreeViewColumn * search_column; if (search_window != NULL) { return; } search_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(search_window), _("Search the Playlist")); gtk_window_set_position(GTK_WINDOW(search_window), GTK_WIN_POS_CENTER_ON_PARENT); if (options.playlist_is_embedded) { gtk_window_set_transient_for(GTK_WINDOW(search_window), GTK_WINDOW(main_window)); } else { gtk_window_set_transient_for(GTK_WINDOW(search_window), GTK_WINDOW(playlist_window)); } g_signal_connect(G_OBJECT(search_window), "delete_event", G_CALLBACK(search_window_close), NULL); g_signal_connect(G_OBJECT(search_window), "key_press_event", G_CALLBACK(search_window_key_pressed), NULL); gtk_container_set_border_width(GTK_CONTAINER(search_window), 5); vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(search_window), vbox); hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 3); label = gtk_label_new(_("Key: ")); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); searchkey_entry = gtk_entry_new(); gtk_widget_show(searchkey_entry); gtk_box_pack_start(GTK_BOX(hbox), searchkey_entry, TRUE, TRUE, 5); table = gtk_table_new(4, 2, FALSE); gtk_widget_show(table); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, TRUE, 3); check_case = gtk_check_button_new_with_label(_("Case sensitive")); gtk_widget_show(check_case); gtk_widget_set_name(check_case, "check_on_window"); gtk_table_attach(GTK_TABLE(table), check_case, 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 1, 4); check_exact = gtk_check_button_new_with_label(_("Exact matches only")); gtk_widget_show(check_exact); gtk_widget_set_name(check_exact, "check_on_window"); gtk_table_attach(GTK_TABLE(table), check_exact, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_FILL, 1, 4); check_sfac = gtk_check_button_new_with_label(_("Select first and close window")); gtk_widget_show(check_sfac); gtk_widget_set_name(check_sfac, "check_on_window"); g_signal_connect(G_OBJECT(check_sfac), "clicked", G_CALLBACK(sfac_clicked), NULL); gtk_table_attach(GTK_TABLE(table), check_sfac, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 1, 4); hbox = sres_list = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox); gtk_container_set_border_width(GTK_CONTAINER(hbox), 3); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 3); search_viewport = gtk_viewport_new(NULL, NULL); gtk_widget_show(search_viewport); gtk_box_pack_start(GTK_BOX(hbox), search_viewport, TRUE, TRUE, 0); search_scrwin = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(search_scrwin); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(search_scrwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(search_viewport), search_scrwin); search_store = gtk_list_store_new(4, G_TYPE_STRING, /* title */ G_TYPE_POINTER, /* GtkTreePath */ G_TYPE_STRING, /* playlist name */ G_TYPE_POINTER); /* playlist_t pointer */ gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(search_store), 0, GTK_SORT_ASCENDING); search_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(search_store)); gtk_widget_show(search_list); gtk_widget_set_size_request(search_list, 400, 200); gtk_container_add(GTK_CONTAINER(search_scrwin), search_list); search_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(search_list)); gtk_tree_selection_set_mode(search_select, GTK_SELECTION_SINGLE); g_signal_connect(G_OBJECT(search_select), "changed", G_CALLBACK(search_selection_changed), NULL); search_renderer = gtk_cell_renderer_text_new(); search_column = gtk_tree_view_column_new_with_attributes(_("Playlist"), search_renderer, "text", 2, NULL); gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(search_column), GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(search_column), TRUE); gtk_tree_view_column_set_sort_column_id(GTK_TREE_VIEW_COLUMN(search_column), 2); gtk_tree_view_append_column(GTK_TREE_VIEW(search_list), search_column); search_renderer = gtk_cell_renderer_text_new(); search_column = gtk_tree_view_column_new_with_attributes(_("Title"), search_renderer, "text", 0, NULL); gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(search_column), GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(search_column), TRUE); gtk_tree_view_column_set_sort_column_id(GTK_TREE_VIEW_COLUMN(search_column), 0); gtk_tree_view_append_column(GTK_TREE_VIEW(search_list), search_column); hbuttonbox = gtk_hbutton_box_new(); gtk_widget_show (hbuttonbox); gtk_box_set_spacing(GTK_BOX(hbuttonbox), 8); gtk_box_pack_end(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox), GTK_BUTTONBOX_END); button = gui_stock_label_button(_("Search"), GTK_STOCK_FIND); gtk_widget_show(button); gtk_container_add(GTK_CONTAINER(hbuttonbox), button); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(search_button_clicked), NULL); button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); gtk_widget_show(button); gtk_container_add(GTK_CONTAINER(hbuttonbox), button); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(close_button_clicked), NULL); if (options.search_pl_flags & SEARCH_F_CS) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_case), TRUE); if (options.search_pl_flags & SEARCH_F_EM) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_exact), TRUE); if (options.search_pl_flags & SEARCH_F_SF) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check_sfac), TRUE); gtk_widget_show(search_window); }