static void
account_chooser_setup (EmpathyAccountChooser *chooser)
{
EmpathyAccountChooserPriv *priv;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkComboBox *combobox;
priv = GET_PRIV (chooser);
/* Set up combo box with new store */
combobox = GTK_COMBO_BOX (chooser);
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combobox));
store = gtk_list_store_new (COL_ACCOUNT_COUNT,
GDK_TYPE_PIXBUF, /* Image */
G_TYPE_STRING, /* Name */
G_TYPE_BOOLEAN, /* Enabled */
G_TYPE_UINT, /* Row type */
TP_TYPE_ACCOUNT);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store),
account_cmp, chooser, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
gtk_combo_box_set_model (combobox, GTK_TREE_MODEL (store));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"pixbuf", COL_ACCOUNT_IMAGE,
"sensitive", COL_ACCOUNT_ENABLED,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combobox), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combobox), renderer,
"text", COL_ACCOUNT_TEXT,
"sensitive", COL_ACCOUNT_ENABLED,
NULL);
/* Populate accounts */
tp_account_manager_prepare_async (priv->manager, NULL,
account_manager_prepared_cb, chooser);
g_object_unref (store);
}
// TreeView für die Tracks erstellen
void music_track_setup_tree (void)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSortable *sortable;
// TreeView holen
track_tree = GTK_TREE_VIEW (interface_get_widget ("treeview_tracks"));
// Track Nummer
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Nr.", renderer,
"text", COL_TRACK_NR, NULL);
gtk_tree_view_column_set_sort_column_id (column, COL_TRACK_NR);
gtk_tree_view_append_column (GTK_TREE_VIEW (track_tree), column);
// Titel
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Titel", renderer,
"text", COL_TRACK_TITLE, NULL);
gtk_tree_view_column_set_sort_column_id (column, COL_TRACK_TITLE);
gtk_tree_view_append_column (GTK_TREE_VIEW (track_tree), column);
// Artist
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Artist", renderer,
"text", COL_TRACK_ARTIST, NULL);
gtk_tree_view_column_set_sort_column_id (column, COL_TRACK_ARTIST);
gtk_tree_view_append_column (GTK_TREE_VIEW (track_tree), column);
// Album
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Album", renderer,
"text", COL_TRACK_ALBUM, NULL);
gtk_tree_view_column_set_sort_column_id (column, COL_TRACK_ALBUM);
gtk_tree_view_append_column (GTK_TREE_VIEW (track_tree), column);
// Store erstellen
track_store = gtk_list_store_new (COLS_TRACK, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
// Sortierung
sortable = GTK_TREE_SORTABLE (track_store);
gtk_tree_sortable_set_sort_column_id (sortable, COL_TRACK_NR, GTK_SORT_ASCENDING);
// Store dem Tree anhängen
gtk_tree_view_set_model (GTK_TREE_VIEW (track_tree),
GTK_TREE_MODEL (track_store));
}
static void trg_tree_view_sort_menu_item_toggled(GtkCheckMenuItem * w,
gpointer data)
{
GtkTreeSortable *model = GTK_TREE_SORTABLE(data);
trg_column_description *desc =
(trg_column_description *) g_object_get_data(G_OBJECT(w),
GDATA_KEY_COLUMN_DESC);
if (gtk_check_menu_item_get_active(w)) {
GtkSortType sortType;
gtk_tree_sortable_get_sort_column_id(model, NULL, &sortType);
gtk_tree_sortable_set_sort_column_id(model, desc->model_column,
sortType);
}
}
static GtkListStore *action_store_create(void)
{
GtkListStore *store;
store = gtk_list_store_new(N_COLUMNS,
G_TYPE_POINTER,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store),
COL_ID, GTK_SORT_ASCENDING);
action_store_fill(store);
g_object_weak_ref(G_OBJECT(store), sig_store_destroyed, NULL);
return store;
}
void CMatchingDlg::SetSortMode(int column)
{
m_FrameSort = column;
for (GSList *ptr=m_FrameCols; ptr!=NULL; ptr=ptr->next) {
tColData *col = (tColData*)ptr->data;
if (col->data->column == column) {
gtk_tree_view_column_set_sort_indicator(col->col, true);
GtkSortType dir = (column!=FCOL_STARS ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING);
gtk_tree_view_column_set_sort_order(col->col, dir);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_Frames), column, dir);
} else {
gtk_tree_view_column_set_sort_indicator(col->col, false);
}
}
}
static void
load_sort_order (CryptUIKeyStore *ckstore)
{
GtkSortType ord = GTK_SORT_ASCENDING;
gchar *sort = NULL;
const gchar *name;
if (ckstore->priv->sortable)
sort = _cryptui_gconf_get_string (SEAHORSE_RECIPIENTS_SORT_KEY);
name = sort ? sort : "";
/* Prefix with a minus means descending */
if (name[0] == '-') {
ord = GTK_SORT_DESCENDING;
name++;
}
/* Prefix with a plus meaning ascending */
else if (name[0] == '+') {
ord = GTK_SORT_ASCENDING;
name++;
}
if (g_ascii_strcasecmp ("name", name) == 0)
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (ckstore),
CRYPTUI_KEY_STORE_NAME, ord);
else if (g_ascii_strcasecmp ("id", name) == 0)
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (ckstore),
CRYPTUI_KEY_STORE_KEYID, ord);
else
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (ckstore),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, ord);
g_free (sort);
}
int histo_before_chunk(void *hook_data, void *call_data)
{
EventsRequest *histo_events_request = (EventsRequest*)hook_data;
LttvTraceset *histo_traceset = (LttvTraceset*)call_data;
#if 0
/* Desactivate sort */
gtk_tree_sortable_set_sort_column_id(
GTK_TREE_SORTABLE(cfd->process_list->list_store),
TRACE_COLUMN,
GTK_SORT_ASCENDING);
#endif //0
histo_drawing_chunk_begin(histo_events_request, histo_traceset);
return 0;
}
static void
fi_gui_files_sort_restore(void)
{
#if GTK_CHECK_VERSION(2,6,0)
g_return_if_fail(files_sort_depth > 0);
files_sort_depth--;
if (0 == files_sort_depth) {
if (GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID != files_sort_column) {
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store_files),
files_sort_column, files_sort_order);
}
}
#endif /* Gtk+ => 2.6.0 */
}
static void
ggg_plan_dialog_init (GggPlanDialog *self)
{
GggPlanDialogPrivate *priv;
GtkWidget *table, *image, *label;
GtkCellRenderer *cell;
priv = self->priv = GET_PRIVATE (self);
gtk_window_set_title (GTK_WINDOW (self), _("Cellular Data Connection Wizard"));
gtk_dialog_add_buttons (GTK_DIALOG (self),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
"Manual Configuration", GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
NULL);
table = gtk_table_new (2, 5, FALSE);
g_object_set (table,
"row-spacing", 6,
"column-spacing", 6,
"border-width", 6,
NULL);
gtk_widget_show (table);
image = gtk_image_new_from_stock (GTK_STOCK_NETWORK, GTK_ICON_SIZE_DIALOG);
gtk_widget_show (image);
gtk_table_attach_defaults (GTK_TABLE (table), image, 0, 1, 0, 2);
label = gtk_label_new (_("Select your 3G Plan"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_show (label);
gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 3, 0, 1);
priv->store = gtk_list_store_new (2, REST_TYPE_XML_NODE, G_TYPE_STRING);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->store), 1, GTK_SORT_ASCENDING);
priv->combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (priv->store));
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->combo), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (priv->combo), cell,
"text", 1,
NULL);
gtk_widget_show (priv->combo);
gtk_table_attach_defaults (GTK_TABLE (table), priv->combo, 1, 3, 1, 2);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (self)->vbox), table);
}
static GtkWidget*
gwy_module_browser_construct(GtkWidget *parent)
{
static const gchar *columns[] = {
N_("Module"), N_("Version"), N_("Author"),
};
GtkWidget *tree;
GtkListStore *store;
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gsize i;
store = gtk_list_store_new(MODEL_LAST,
G_TYPE_POINTER,
G_TYPE_POINTER,
G_TYPE_BOOLEAN);
gwy_module_foreach((GHFunc)gwy_module_browser_store_module, store);
_gwy_module_failure_foreach((GHFunc)gwy_module_browser_store_failure,
store);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store),
MODEL_NAME, compare_modules, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), MODEL_NAME,
GTK_SORT_ASCENDING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
g_object_unref(store);
for (i = 0; i < G_N_ELEMENTS(columns); i++) {
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_(columns[i]),
renderer, NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
gwy_module_browser_render,
GUINT_TO_POINTER(i), NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
}
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(tree, "cursor-changed",
G_CALLBACK(update_module_info_cb), parent);
return tree;
}
static void
gtk_boursorama_app_activate(GApplication *application) {
GtkBoursoramaApp* app = (GtkBoursoramaApp*) application;
app->win = gtk_boursorama_app_window_new(GTK_BOURSORAMA_APP(app));
app->win->tree_model_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(app->list_store_action_list));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(app->win->tree_model_sort), ACTION_NAME, GTK_SORT_ASCENDING);
gtk_tree_view_set_model(app->win->tree, GTK_TREE_MODEL(app->win->tree_model_sort));
g_object_unref(app->win->tree_model_sort);
gtk_window_present(GTK_WINDOW(app->win));
g_thread_new("http thread", app_logic_thread_func, app);
app->last_update_time = g_get_real_time();
g_timeout_add(500, gtk_boursorama_app_label_update, app);
}
/*
* Disable Search Stats sorting.
*/
static void
search_stats_gui_disable_sort(void)
{
#if GTK_CHECK_VERSION(2,6,0)
GtkTreeSortable *sortable;
GtkSortType order;
int column;
sortable = GTK_TREE_SORTABLE(store_search_stats);
if (gtk_tree_sortable_get_sort_column_id(sortable, &column, &order)) {
gtk_tree_sortable_set_sort_column_id(sortable,
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID,
GTK_SORT_DESCENDING);
}
#endif /* Gtk+ >= 2.6.0 */
}
/**
* Sets root
* @param root A gchar
*/
void
rs_dir_selector_set_root(RSDirSelector *selector, const gchar *root)
{
GtkTreeModel *model;
GtkTreeSortable *sortable;
model = create_and_fill_model(root);
sortable = GTK_TREE_SORTABLE(model);
gtk_tree_sortable_set_sort_column_id(sortable,
COL_NAME,
GTK_SORT_ASCENDING);
gtk_tree_view_set_model(GTK_TREE_VIEW(selector->view), model);
g_object_unref(model); /* destroy model automatically with view */
}
static void
search_gui_disable_sort(struct search *search)
{
if (search && search->sort) {
#if GTK_CHECK_VERSION(2,6,0)
GtkTreeModel *model;
GtkTreeSortable *sortable;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(search->tree));
sortable = GTK_TREE_SORTABLE(model);
if (gtk_tree_sortable_get_sort_column_id(sortable, NULL, NULL)) {
gtk_tree_sortable_set_sort_column_id(sortable,
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_DESCENDING);
}
#endif /* Gtk+ >= 2.6.0 */
}
}
GtkWidget *create_view()
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *view;
g_store = gtk_list_store_new(NB_COL, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF);
view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(g_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
g_object_unref(g_store); // destroy store automatically with view
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_FILE);
gtk_tree_view_column_set_visible(col, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
g_width_list = 200;
g_height_list = 30;
g_renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(g_renderer, "xalign", 0.0, NULL);
gtk_cell_renderer_set_fixed_size(g_renderer, g_width_list, g_height_list);
// specific to gtk-2.18 or higher
//gtk_cell_renderer_set_padding(g_renderer, 5, 5);
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, g_renderer, TRUE);
gtk_tree_view_column_add_attribute(col, g_renderer, "pixbuf", COL_SNAPSHOT);
gtk_tree_view_append_column(GTK_TREE_VIEW(view),col);
GtkTreeSortable *sortable;
sortable = GTK_TREE_SORTABLE(g_store);
gtk_tree_sortable_set_sort_column_id(sortable, COL_THEME_FILE, GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func(sortable, COL_THEME_FILE, theme_name_compare, NULL, NULL);
return view;
}
static GtkListStore *
load_icon_cat (IconBrowserData * data, gchar * cat)
{
GtkListStore *store;
GList *i, *icons;
gint size, w, h;
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
size = MIN (w, h);
store = gtk_list_store_new (2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
icons = gtk_icon_theme_list_icons (data->theme, cat);
for (i = icons; i; i = i->next)
{
GtkTreeIter iter;
GdkPixbuf *pb, *spb;
spb = pb = gtk_icon_theme_load_icon (data->theme, i->data, size, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL);
if (pb)
{
/* scale pixbuf if needed */
w = gdk_pixbuf_get_width (pb);
h = gdk_pixbuf_get_height (pb);
if (w > size || h > size)
{
pb = gdk_pixbuf_scale_simple (spb, size, size, GDK_INTERP_BILINEAR);
g_object_unref (spb);
}
}
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, pb, 1, i->data, -1);
if (pb)
g_object_unref (pb);
g_free (i->data);
}
g_list_free (icons);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), 1, GTK_SORT_ASCENDING);
return store;
}
static void client_init()
{
if(!client_tree_view)
{
client_tree_view = gtk_tree_view_new();
/* Create a client list that stores their Nick name, ID, Real Name, Website, Email*/
client_list = gtk_list_store_new(6,G_TYPE_STRING,G_TYPE_INT,G_TYPE_INT,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING);
GtkCellRenderer *client_view_rend = gtk_cell_renderer_text_new();
/* Set the 1st column to be viewable in the treeview */
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(client_tree_view),-1,"Clients",client_view_rend,"text",0,NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(client_tree_view),GTK_TREE_MODEL(client_list));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(client_list), 0, GTK_SORT_ASCENDING);
g_signal_connect(G_OBJECT(client_tree_view), "row-activated", G_CALLBACK(client_activated), NULL);
g_signal_connect(G_OBJECT(client_tree_view), "button-press-event", G_CALLBACK(client_popup_menu), NULL);
g_signal_connect(G_OBJECT(client_tree_view), "popup-menu", G_CALLBACK(client_popup_menu_key), NULL);
}
}
/* When there's a new node to display in the node treeview, call this.
| Create a new model containing the nodes of the given net, insert
| the model into the treeview and unref the old model.
*/
static void
node_model_update (LibraryMenuType * menu)
{
GtkTreeModel *model;
model = node_model;
node_model = node_model_create (menu);
gtk_tree_view_set_model (node_treeview, node_model);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (node_model),
NODE_NAME_COLUMN, GTK_SORT_ASCENDING);
/* We could be using gtk_list_store_clear() on the same model, but it's
| just as easy that we've created a new one and here unref the old one.
*/
if (model)
g_object_unref (G_OBJECT (model));
}
GtkWidget *get_widget_list (GtkWidget *box, GtkTreeSelection **sel)
{
GtkWidget *sw;
GtkWidget *event_view;
GtkCellRenderer *rend;
GtkTreeViewColumn *col;
GtkTargetEntry gte [] = {{"STRING", 0, GTK_IMHTML_DRAG_STRING}};
if (tree_list == NULL) {
tree_list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(tree_list),
0, GTK_SORT_ASCENDING);
update_widget_list (tree_list);
g_object_ref (G_OBJECT(tree_list));
}
/* List of widgets */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX(box), sw, TRUE, TRUE, 0);
event_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_list));
*sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_view));
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Widget"), rend,
"markup", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (event_view), col);
gtk_tree_view_column_set_sort_column_id (col, 0);
gtk_container_add (GTK_CONTAINER(sw), event_view);
/* Drag and Drop */
gtk_tree_view_enable_model_drag_source(
GTK_TREE_VIEW(event_view), GDK_BUTTON1_MASK, gte,
1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(event_view), "drag-data-get",
G_CALLBACK(drag_data_get_cb), tree_list);
return event_view;
}
static void
build_sources_view (GdictPrefDialog *dialog)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
if (dialog->sources_list)
return;
dialog->sources_list = gtk_list_store_new (SOURCES_N_COLUMNS,
G_TYPE_BOOLEAN, /* active */
G_TYPE_STRING, /* name */
G_TYPE_STRING /* description */);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dialog->sources_list),
SOURCES_DESCRIPTION_COLUMN,
GTK_SORT_ASCENDING);
renderer = gtk_cell_renderer_toggle_new ();
gtk_cell_renderer_toggle_set_radio (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE);
g_signal_connect (renderer, "toggled",
G_CALLBACK (source_renderer_toggled_cb),
dialog);
column = gtk_tree_view_column_new_with_attributes ("active",
renderer,
"active", SOURCES_ACTIVE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->sources_view), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("description",
renderer,
"text", SOURCES_DESCRIPTION_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->sources_view), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->sources_view), FALSE);
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->sources_view),
GTK_TREE_MODEL (dialog->sources_list));
g_signal_connect (dialog->sources_view, "row-activated",
G_CALLBACK (sources_view_row_activated_cb),
dialog);
}
// Create the Tree View
GtkWidget* ShaderSelector::createTreeView() {
// Tree model
GtkTreeStore* store = gtk_tree_store_new(N_COLUMNS,
G_TYPE_STRING, // display name in tree
G_TYPE_STRING, // full shader name
GDK_TYPE_PIXBUF);
// Instantiate the helper class that populates the tree according to the paths
gtkutil::VFSTreePopulator populator(store);
ShaderNameVisitor func(populator, _prefixes);
GlobalShaderSystem().foreachShaderName(func);
// Now visit the created GtkTreeIters to load the actual data into the tree
DataInserter inserter;
populator.forEachNode(inserter);
// Tree view
_treeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(_treeView), FALSE);
g_object_unref(store); // tree view owns the reference now
// Single visible column, containing the directory/shader name and the icon
gtk_tree_view_append_column(GTK_TREE_VIEW(_treeView),
gtkutil::IconTextColumn(_("Value"),
NAME_COL,
IMAGE_COL));
// Set the tree store to sort on this column
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), NAME_COL, GTK_SORT_ASCENDING);
// Use the TreeModel's full string search function
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(_treeView), gtkutil::TreeModel::equalFuncStringContains, NULL, NULL);
// Get selection and connect the changed callback
_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(_treeView));
g_signal_connect(G_OBJECT(_selection),
"changed",
G_CALLBACK(_onSelChange),
this);
// Pack into scrolled window and frame
return gtkutil::ScrolledFrame(_treeView);
}
static void phidias_items_classic_set_model (PhidiasItemsViewer *self, GtkTreeModel *items)
{
GtkTreeModel *sorter;
PhidiasItemsClassic *item;
item = PHIDIAS_ITEMS_CLASSIC (self);
webkit_web_view_load_html_string (WEBKIT_WEB_VIEW (item->priv->description), "", "file://");
sorter = gtk_tree_view_get_model (GTK_TREE_VIEW (item->priv->list));
if (sorter != NULL)
g_object_unref (sorter);
sorter = gtk_tree_model_sort_new_with_model (items);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sorter), ITEM_INFO_DATE, GTK_SORT_DESCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sorter), ITEM_INFO_DATE, sort_items, NULL, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (item->priv->list), sorter);
scroll_to_position (item);
}
static void
fi_gui_files_sort_save(void)
{
#if GTK_CHECK_VERSION(2,6,0)
if (0 == files_sort_depth++) {
GtkTreeSortable *sortable;
GtkSortType order;
int column;
sortable = GTK_TREE_SORTABLE(store_files);
if (gtk_tree_sortable_get_sort_column_id(sortable, &column, &order)) {
files_sort_column = column;
files_sort_order = order;
gtk_tree_sortable_set_sort_column_id(sortable,
GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, order);
}
}
#endif /* Gtk+ => 2.6.0 */
}
/**
* ephy_node_view_set_sort:
* @view: an #EphyNodeView
* @value_type: type of the value held at @prop_id by the model
* @prop_id: column id in the model
* @sort_type: the sort mode
*
* Adds a sort column to the @view corresponding to @prop_id in the model.
**/
void
ephy_node_view_set_sort (EphyNodeView *view, GType value_type, guint prop_id,
GtkSortType sort_type)
{
GtkTreeSortable *sortable = GTK_TREE_SORTABLE (view->priv->sortmodel);
int column;
column = ephy_tree_model_node_add_prop_column
(view->priv->nodemodel, value_type, prop_id);
view->priv->sort_column = column;
view->priv->sort_type = sort_type;
gtk_tree_sortable_set_default_sort_func
(sortable, (GtkTreeIterCompareFunc)ephy_node_view_sort_func,
view, NULL);
gtk_tree_sortable_set_sort_column_id
(sortable, GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
sort_type);
}
void
create_user_privileges_table (void)
{
GtkWidget *list;
GtkTreeModel *model, *filter_model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeIter iter;
list = gst_dialog_get_widget (tool->main_dialog, "user_privileges");
model = GTK_TREE_MODEL (gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_OBJECT));
filter_model = gtk_tree_model_filter_new (model, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (list), filter_model);
g_object_unref (filter_model);
g_object_unref (model);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), COL_DESCRIPTION, GTK_SORT_ASCENDING);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter_model),
privileges_table_visible_func,
NULL, NULL);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column,
renderer,
"active", COL_MEMBER,
NULL);
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (on_user_privilege_toggled), filter_model);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_end (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column,
renderer,
"text", COL_DESCRIPTION,
NULL);
gtk_tree_view_column_set_sort_column_id (column, 1);
gtk_tree_view_insert_column (GTK_TREE_VIEW (list), column, 0);
}
static void
specific_bug_300089 (void)
{
/* Test case for GNOME Bugzilla bug 300089. Written by
* Matthias Clasen.
*/
GtkTreeModel *sort_model, *child_model;
GtkTreePath *path;
GtkTreeIter iter, iter2, sort_iter;
g_test_bug ("300089");
child_model = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_STRING));
gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1);
gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "B", -1);
gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter);
gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "D", -1);
gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter);
gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "E", -1);
gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "C", -1);
sort_model = GTK_TREE_MODEL (gtk_tree_model_sort_new_with_model (child_model));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
0, GTK_SORT_ASCENDING);
path = gtk_tree_path_new_from_indices (1, 1, -1);
/* make sure a level is constructed */
gtk_tree_model_get_iter (sort_model, &sort_iter, path);
/* change the "E" row in a way that causes it to change position */
gtk_tree_model_get_iter (child_model, &iter, path);
gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1);
gtk_tree_path_free (path);
}
static void
xkb_layout_chooser_available_language_variants_fill (GtkBuilder *
chooser_dialog)
{
GtkWidget *cbl = CWID ("xkb_languages_available");
GtkWidget *cbv = CWID ("xkb_language_variants_available");
GtkListStore *list_store;
GtkTreeIter liter;
list_store = gtk_list_store_new
(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING);
if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (cbl), &liter)) {
GtkTreeModel *lm =
gtk_combo_box_get_model (GTK_COMBO_BOX (cbl));
gchar *lang_id;
AddVariantData data = { list_store, 0 };
/* Now the variants of the selected layout */
gtk_tree_model_get (lm, &liter,
COMBO_BOX_MODEL_COL_REAL_ID,
&lang_id, -1);
data.lang_id = lang_id;
xkl_config_registry_foreach_language_variant
(config_registry, lang_id, (TwoConfigItemsProcessFunc)
xkb_layout_chooser_add_variant_to_available_language_variants,
&data);
g_free (lang_id);
}
/* Turn on sorting after filling the store, since that's faster */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE
(list_store),
COMBO_BOX_MODEL_COL_SORT,
GTK_SORT_ASCENDING);
gtk_combo_box_set_model (GTK_COMBO_BOX (cbv),
GTK_TREE_MODEL (list_store));
gtk_combo_box_set_active (GTK_COMBO_BOX (cbv), 0);
}
static void
new_chatroom_dialog_model_setup (EmpathyNewChatroomDialog *dialog)
{
GtkTreeView *view;
GtkListStore *store;
GtkTreeSelection *selection;
/* View */
view = GTK_TREE_VIEW (dialog->treeview);
g_signal_connect (view, "row-activated",
G_CALLBACK (new_chatroom_dialog_model_row_activated_cb),
dialog);
/* Store/Model */
store = gtk_list_store_new (COL_COUNT,
G_TYPE_STRING, /* Invite */
G_TYPE_STRING, /* Password */
G_TYPE_STRING, /* Name */
G_TYPE_STRING, /* Room */
G_TYPE_STRING, /* Member count */
G_TYPE_INT, /* Member count int */
G_TYPE_STRING); /* Tool tip */
dialog->model = GTK_TREE_MODEL (store);
gtk_tree_view_set_model (view, dialog->model);
gtk_tree_view_set_tooltip_column (view, COL_TOOLTIP);
gtk_tree_view_set_search_column (view, COL_NAME);
/* Selection */
selection = gtk_tree_view_get_selection (view);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
COL_NAME, GTK_SORT_ASCENDING);
g_signal_connect (selection, "changed",
G_CALLBACK (new_chatroom_dialog_model_selection_changed),
dialog);
/* Columns */
new_chatroom_dialog_model_add_columns (dialog);
}
static void
goa_panel_accounts_model_constructed (GObject *object)
{
GoaPanelAccountsModel *model = GOA_PANEL_ACCOUNTS_MODEL (object);
GType types[GOA_PANEL_ACCOUNTS_MODEL_N_COLUMNS];
G_STATIC_ASSERT (5 == GOA_PANEL_ACCOUNTS_MODEL_N_COLUMNS);
types[0] = G_TYPE_STRING;
types[1] = GOA_TYPE_OBJECT;
types[2] = G_TYPE_BOOLEAN;
types[3] = G_TYPE_STRING;
types[4] = G_TYPE_ICON;
gtk_list_store_set_column_types (GTK_LIST_STORE (model),
GOA_PANEL_ACCOUNTS_MODEL_N_COLUMNS,
types);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
GOA_PANEL_ACCOUNTS_MODEL_COLUMN_SORT_KEY,
GTK_SORT_ASCENDING);
g_signal_connect (model->client,
"account-added",
G_CALLBACK (on_account_added),
model);
g_signal_connect (model->client,
"account-removed",
G_CALLBACK (on_account_removed),
model);
g_signal_connect (model->client,
"account-changed",
G_CALLBACK (on_account_changed),
model);
init_model (model);
if (G_OBJECT_CLASS (goa_panel_accounts_model_parent_class)->constructed != NULL)
G_OBJECT_CLASS (goa_panel_accounts_model_parent_class)->constructed (object);
}
static void
go_component_mime_dialog_init (GOComponentMimeDialog *dlg)
{
GtkListStore *list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
GtkWidget *w = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list));
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GSList *mime_types = go_components_get_mime_types ();
GSList *l = mime_types;
GtkTreeIter iter;
char const *mime_type;
gtk_dialog_add_buttons (&dlg->base,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_window_set_modal (GTK_WINDOW (dlg), TRUE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (dlg), TRUE);
dlg->sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (w));
g_signal_connect_swapped (w, "button-press-event", G_CALLBACK (button_press_cb), dlg);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Object type:", renderer, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (w), column);
gtk_tree_selection_set_mode (dlg->sel, GTK_SELECTION_BROWSE);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list), 0, GTK_SORT_ASCENDING);
while (l) {
mime_type = (char const *) l->data;
if (go_components_get_priority (mime_type) >= GO_MIME_PRIORITY_PARTIAL) {
gtk_list_store_append (list, &iter);
gtk_list_store_set (list, &iter,
0, go_mime_type_get_description (mime_type),
1, mime_type,
-1);
}
l = l->next;
}
dlg->list = GTK_TREE_MODEL (list);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (&dlg->base)), w);
gtk_widget_show_all (gtk_dialog_get_content_area (&dlg->base));
}
