GtkWidget *create_asklang_view(void)
{
GtkListStore *store;
GtkTreeModel *model;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *view;
store = gtk_list_store_new(COLUMN_LANG_NUMS, G_TYPE_STRING, G_TYPE_STRING);
model = GTK_TREE_MODEL(store);
view = gtk_tree_view_new_with_model(model);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
col = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_set_attributes(col, renderer, "text", COLUMN_LANG_CODE, NULL);
gtk_tree_view_column_set_title(col, "Code");
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
col = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_set_attributes(col, renderer, "text", COLUMN_LANG_NAME, NULL);
gtk_tree_view_column_set_title(col, "Name");
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
return view;
}
// Helper function to create the TreeView
GtkWidget* ModelSelector::createTreeView ()
{
loadDirectory(MODELS_FOLDER);
GtkTreeModel *model = gtk_tree_model_filter_new(GTK_TREE_MODEL(_treeStore), NULL);
GtkTreeModel *modelSorted = gtk_tree_model_sort_new_with_model(model);
GtkWidget* treeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(modelSorted));
// Single column, containing model pathname
GtkTreeViewColumn* col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Value"));
gtk_tree_view_column_set_spacing(col, 3);
GtkCellRenderer* pixRenderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col, pixRenderer, FALSE);
gtk_tree_view_column_set_attributes(col, pixRenderer, "pixbuf", IMAGE_COLUMN, NULL);
GtkCellRenderer* rend = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, rend, FALSE);
gtk_tree_view_column_set_attributes(col, rend, "text", NAME_COLUMN, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeView), col);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeView), FALSE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(modelSorted), NAME_COLUMN, GTK_SORT_ASCENDING);
// Pack treeview into a scrolled window and return
_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeView));
g_signal_connect(G_OBJECT(_selection), "changed", G_CALLBACK(callbackSelChanged), this);
// Pack treeview into a scrolled window and frame, and return
return gtkutil::ScrolledFrame(treeView);
}
static void fm_places_view_init(FmPlacesView *self)
{
GtkTreeViewColumn* col;
GtkCellRenderer* renderer;
GtkTargetList* targets;
GdkPixbuf* pix;
guint handler;
if(G_UNLIKELY(!model))
{
model = fm_places_model_new();
g_object_add_weak_pointer(G_OBJECT(model), &model);
}
else
g_object_ref(model);
gtk_tree_view_set_model(GTK_TREE_VIEW(self), model);
g_object_unref(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self), FALSE);
gtk_tree_view_set_row_separator_func(GTK_TREE_VIEW(self), (GtkTreeViewRowSeparatorFunc)sep_func, NULL, NULL );
col = gtk_tree_view_column_new();
renderer = fm_cell_renderer_pixbuf_new();
handler = g_signal_connect(fm_config, "changed::pane_icon_size", G_CALLBACK(on_renderer_icon_size_changed), renderer);
g_object_weak_ref(G_OBJECT(renderer), (GDestroyNotify)on_cell_renderer_pixbuf_destroy, GUINT_TO_POINTER(handler));
fm_cell_renderer_pixbuf_set_fixed_size(FM_CELL_RENDERER_PIXBUF(renderer), fm_config->pane_icon_size, fm_config->pane_icon_size);
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_tree_view_column_set_attributes( col, renderer,
"pixbuf", FM_PLACES_MODEL_COL_ICON, NULL );
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start( col, renderer, TRUE );
g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_attributes( col, renderer,
"text", FM_PLACES_MODEL_COL_LABEL, NULL );
renderer = gtk_cell_renderer_pixbuf_new();
self->mount_indicator_renderer = renderer;
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(col), renderer,
fm_places_model_mount_indicator_cell_data_func,
NULL, NULL);
gtk_tree_view_append_column ( GTK_TREE_VIEW(self), col );
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(self), GDK_BUTTON1_MASK,
dnd_src_targets, G_N_ELEMENTS(dnd_src_targets), GDK_ACTION_MOVE);
gtk_drag_dest_set(self, 0,
fm_default_dnd_dest_targets, N_FM_DND_DEST_DEFAULT_TARGETS,
GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK|GDK_ACTION_ASK);
targets = gtk_drag_dest_get_target_list((GtkWidget*)self);
/* add our own targets */
gtk_target_list_add_table(targets, dnd_dest_targets, G_N_ELEMENTS(dnd_dest_targets));
self->dnd_dest = fm_dnd_dest_new((GtkWidget*)self);
g_signal_connect(self->dnd_dest, "files_dropped", G_CALLBACK(on_dnd_dest_files_dropped), self);
}
/* Setup the columns in the tree view. These include a column for the GdkPixbuf,
* file name, file size, and last modification time/date. */
static void
setup_tree_view (GtkWidget *treeview)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/* Create a tree view column with an icon and file name. */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "File Browser");
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", ICON, 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", FILENAME, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
/* Insert a second tree view column that displays the file size. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes
("Size", renderer, "text", SIZE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
/* Insert a third tree view column that displays the last modified time/date. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes
("Last Modified", renderer, "text", MODIFIED, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
}
static void
create_category_view ()
{
categorymodel = gtk_list_store_new (CATEGORY_TOTAL_COLUMNS,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_POINTER, NULL);
categoryview = gtk_tree_view_new_with_model (GTK_TREE_MODEL(categorymodel));
refresh_category_model ();
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Category");
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", CATEGORY_STOCK_COLUMN, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
g_object_set (renderer, "scale", 0.9, NULL);
gtk_tree_view_column_set_attributes (column, renderer, "markup", CATEGORY_TEXT_COLUMN, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW(categoryview), column);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW(categoryview)),
"changed", G_CALLBACK(on_category_change), NULL);
}
static void
create_status_view ()
{
statusmodel = gtk_list_store_new (STATUS_TOTAL_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, NULL);
statusview = gtk_tree_view_new_with_model (GTK_TREE_MODEL(statusmodel));
/* Status */
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "Status");
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", STATUS_STOCK_COLUMN, NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
g_object_set (renderer, "scale", 0.9, "weight-set", TRUE, NULL);
gtk_tree_view_column_set_attributes (column, renderer, "markup", STATUS_TEXT_COLUMN, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW(statusview), column);
refresh_status_model ();
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW(statusview)),
"changed", G_CALLBACK(on_status_change), NULL);
}
static void
add_columns (GtkTreeView *treeview)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/* The Name column. */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", BOOK_LIST_COLUMN_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", BOOK_LIST_COLUMN_NAME,
NULL);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
}
static void
add_columns_attachment(GtkTreeView * p_treeview) {
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/*****************************************/
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, " ");
renderer = gtk_cell_renderer_toggle_new();
g_object_set(renderer, "activatable", TRUE, NULL);
g_signal_connect(renderer, "toggled", G_CALLBACK(on_search_cell_toggled), p_treeview);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"active", ATT_CHECK_COL, NULL);
gtk_tree_view_append_column(p_treeview, column);
/**************************************************/
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", ATT_FILENAME_COL, NULL);
gtk_tree_view_append_column(p_treeview, column);
}
static void
book_tree_add_columns (DhBookTree *tree)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new ();
renderer = GTK_CELL_RENDERER (gtk_cell_renderer_pixbuf_new ());
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes
(column, renderer,
"pixbuf", COL_OPEN_PIXBUF,
"pixbuf-expander-open", COL_OPEN_PIXBUF,
"pixbuf-expander-closed", COL_CLOSED_PIXBUF,
NULL);
renderer = GTK_CELL_RENDERER (gtk_cell_renderer_text_new ());
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COL_TITLE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
}
static void
xfburn_directory_browser_init (XfburnDirectoryBrowser * browser)
{
GtkListStore *model;
GtkTreeViewColumn *column_file;
GtkCellRenderer *cell_icon, *cell_file;
GtkTreeSelection *selection;
GtkTargetEntry gte[] = { {"text/plain;charset=utf-8", 0, DATA_COMPOSITION_DND_TARGET_TEXT_PLAIN} };
model = gtk_list_store_new (DIRECTORY_BROWSER_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model), DIRECTORY_BROWSER_COLUMN_FILE,
directory_tree_sortfunc, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), DIRECTORY_BROWSER_COLUMN_FILE, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (browser), GTK_TREE_MODEL (model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (browser), TRUE);
column_file = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column_file, _("File"));
cell_icon = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column_file, cell_icon, FALSE);
gtk_tree_view_column_set_attributes (column_file, cell_icon, "pixbuf", DIRECTORY_BROWSER_COLUMN_ICON, NULL);
g_object_set (cell_icon, "xalign", 0.0, "ypad", 0, NULL);
cell_file = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column_file, cell_file, TRUE);
gtk_tree_view_column_set_attributes (column_file, cell_file, "text", DIRECTORY_BROWSER_COLUMN_FILE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (browser), column_file);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (browser), -1, _("Size"), gtk_cell_renderer_text_new (),
"text", DIRECTORY_BROWSER_COLUMN_HUMANSIZE, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (browser), -1, _("Type"), gtk_cell_renderer_text_new (),
"text", DIRECTORY_BROWSER_COLUMN_TYPE, NULL);
gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 1);
gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 1);
gtk_tree_view_column_set_fixed_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 500);
gtk_tree_view_column_set_fixed_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 100);
gtk_tree_view_column_set_min_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 100);
gtk_tree_view_column_set_min_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 60);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (browser));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* set up DnD */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (browser), GDK_BUTTON1_MASK, gte,
G_N_ELEMENTS (gte), GDK_ACTION_COPY);
g_signal_connect (G_OBJECT (browser), "drag-data-get", G_CALLBACK (cb_browser_drag_data_get), browser);
}
void button77_lsgurd_fun(GtkWidget *window,gpointer data)//从文件读取守护容器的信息
{
gtk_widget_hide (data);
//GtkTreeViewColumn *image_nam;
GtkWidget *image_nam;
//GtkTreeViewColumn *id;
//GtkTreeViewColumn *nam;
GtkWidget *id;
GtkWidget *nam;
GtkBuilder *builder;
GtkTreeIter iter_gurd;
GtkCellRenderer *cell_image;
GtkListStore *list_gurd;
GtkTreeView *tree_view_lsgurd;
GtkWidget *window_lsgurd22;
GtkWidget *button_close;
builder=gtk_builder_new ();
gint gurd_ls_nu=0;
gtk_builder_add_from_file (builder,CONTAINER_MANAGE_LSGUARD_FILE,NULL);
window_lsgurd22=GTK_WIDGET(gtk_builder_get_object (builder,CONTAINER_MANAGE_LSGUARD_WINDOW));
button_close=GTK_WIDGET(gtk_builder_get_object (builder,"button2"));
image_nam=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn2"));
id=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn3"));
nam=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn4"));
gtk_tree_view_column_set_title (image_nam,_("please select image name"));
//gtk_tree_view_column_set_title (id,_("asdasd"));
gtk_tree_view_column_set_title (id,_("gurd contain ID"));
gtk_tree_view_column_set_title (nam,_("gurd contain name"));
cell_image=gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (image_nam,cell_image,TRUE);
gtk_tree_view_column_set_attributes(image_nam,cell_image,"text",0,NULL);
cell_image=gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (id,cell_image,TRUE);
gtk_tree_view_column_set_attributes(id,cell_image,"text",1,NULL);
cell_image=gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (nam,cell_image,TRUE);
gtk_tree_view_column_set_attributes(nam,cell_image,"text",2,NULL);
list_gurd=gtk_list_store_new (3,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING);
tree_view_lsgurd=GTK_WIDGET(gtk_builder_get_object (builder,"treeview_lsurd"));
gtk_tree_view_set_model(GTK_TREE_VIEW(tree_view_lsgurd),GTK_TREE_MODEL(list_gurd));
gurd_fun(list_gurd,iter_gurd);
gtk_window_set_title (window_lsgurd22,_("ls gurd contain"));
g_signal_connect(G_OBJECT(button_close),"clicked",G_CALLBACK(close_window_lsgurd22),window_lsgurd22);
g_signal_connect(G_OBJECT(window_lsgurd22),"destroy",G_CALLBACK(show_window),data);
g_object_unref (builder);
gtk_widget_show_all (window_lsgurd22);
}
SidebarIndexPage::SidebarIndexPage(Control* control) : AbstractSidebarPage(
control)
{
XOJ_INIT_TYPE(SidebarIndexPage);
this->searchTimeout = 0;
this->hasContents = false;
this->treeViewBookmarks = gtk_tree_view_new();
g_object_ref(this->treeViewBookmarks);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(treeViewBookmarks), true);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeViewBookmarks),
DOCUMENT_LINKS_COLUMN_NAME);
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeViewBookmarks),
(GtkTreeViewSearchEqualFunc) treeSearchFunction, this, NULL);
this->scrollBookmarks = gtk_scrolled_window_new(NULL, NULL);
g_object_ref(this->scrollBookmarks);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_SHADOW_IN);
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
treeViewBookmarks));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeViewBookmarks), FALSE);
gtk_container_add(GTK_CONTAINER(scrollBookmarks), treeViewBookmarks);
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeViewBookmarks), column);
GtkCellRenderer* renderer = (GtkCellRenderer*) g_object_new(
GTK_TYPE_CELL_RENDERER_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, TRUE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"markup", DOCUMENT_LINKS_COLUMN_NAME, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"text", DOCUMENT_LINKS_COLUMN_PAGE_NUMBER, NULL);
g_object_set(G_OBJECT(renderer), "style", PANGO_STYLE_ITALIC, NULL);
g_signal_connect(treeViewBookmarks, "cursor-changed",
G_CALLBACK(treeBookmarkSelected), this);
gtk_widget_show(this->treeViewBookmarks);
registerListener(control);
}
static void init_search_result( FindFile* data )
{
GtkTreeIter it;
GtkTreeViewColumn* col;
GtkCellRenderer* render;
gtk_tree_selection_set_mode( gtk_tree_view_get_selection((GtkTreeView*)data->result_view),
GTK_SELECTION_MULTIPLE );
data->result_list = gtk_list_store_new( N_RES_COLS,
GDK_TYPE_PIXBUF, /* icon */
G_TYPE_STRING, /* name */
G_TYPE_STRING, /* dir */
G_TYPE_STRING, /* type */
G_TYPE_STRING, /* size */
G_TYPE_STRING, /* mtime */
G_TYPE_POINTER /* VFSFileInfo */ );
gtk_tree_view_set_model( (GtkTreeView*)data->result_view, (GtkTreeModel*)data->result_list );
g_object_unref( data->result_list );
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title( col, _("Name") );
render = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start( col, render, FALSE );
gtk_tree_view_column_set_attributes( col, render, "pixbuf", COL_ICON, NULL );
render = gtk_cell_renderer_text_new();
g_object_set( render, "ellipsize", PANGO_ELLIPSIZE_END, NULL );
gtk_tree_view_column_pack_start( col, render, TRUE );
gtk_tree_view_column_set_attributes( col, render, "text", COL_NAME, NULL );
gtk_tree_view_column_set_expand ( col, TRUE );
gtk_tree_view_column_set_min_width( col, 200 );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
render = gtk_cell_renderer_text_new();
g_object_set( render, "ellipsize", PANGO_ELLIPSIZE_END, NULL );
col = gtk_tree_view_column_new_with_attributes( _("Folder"), render, "text", COL_DIR, NULL );
gtk_tree_view_column_set_expand ( col, TRUE );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_column_set_min_width( col, 200 );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
col = gtk_tree_view_column_new_with_attributes( _("Size"), gtk_cell_renderer_text_new(), "text", COL_SIZE, NULL );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
col = gtk_tree_view_column_new_with_attributes( _("Type"), gtk_cell_renderer_text_new(), "text", COL_TYPE, NULL );
gtk_tree_view_column_set_sizing( col, GTK_TREE_VIEW_COLUMN_FIXED );
gtk_tree_view_column_set_fixed_width ( col, 120 );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
col = gtk_tree_view_column_new_with_attributes( _("Last Modified"), gtk_cell_renderer_text_new(), "text", COL_MTIME, NULL );
gtk_tree_view_column_set_resizable ( col, TRUE );
gtk_tree_view_append_column( (GtkTreeView*)data->result_view, col );
}
static void
add_columns (GtkTreeView *treeview,
DialogData *data)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/* the name column. */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Script"));
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COLUMN_NAME,
NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
/* the shortcut column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Shortcut"));
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.5, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COLUMN_SHORTCUT,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
/* the checkbox column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Show"));
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer,
"toggled",
G_CALLBACK (cell_renderer_toggle_toggled_cb),
data);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"active", COLUMN_VISIBLE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
}
static void
file_view_init (AnjutaFileView *object)
{
GtkCellRenderer* renderer_pixbuf;
GtkCellRenderer* renderer_display;
GtkTreeViewColumn* column;
GtkTreeSelection* selection;
GtkTreeModel* sort_model;
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (object);
priv->current_selection = NULL;
priv->model = file_model_new (GTK_TREE_VIEW(object), NULL);
sort_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(priv->model));
gtk_tree_view_set_model (GTK_TREE_VIEW(object), sort_model);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE(sort_model),
file_view_sort_model,
NULL,
NULL);
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
renderer_display = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Filename"));
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_tree_view_column_pack_start (column, renderer_display, FALSE);
gtk_tree_view_column_set_attributes (column, renderer_pixbuf,
"pixbuf", COLUMN_PIXBUF,
NULL);
gtk_tree_view_column_set_attributes (column, renderer_display,
"markup", COLUMN_DISPLAY,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (object), column);
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (object));
g_signal_connect (selection, "changed",
G_CALLBACK (file_view_selection_changed), object);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (object), FALSE);
g_object_set (object, "has-tooltip", TRUE, NULL);
/* DND */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW(object),
GDK_BUTTON1_MASK,
uri_targets,
1,
GDK_ACTION_MOVE);
}
static GtkTreeStore* ctree_create(GtkWidget *widget)
{
GtkTreeView *view = GTK_TREE_VIEW(widget);
GtkTreeStore *store;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
const gchar *text[CTREE_NVCOLS] = { _("Name") };
gint i;
store = gtk_tree_store_new(CTREE_NCOLS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, -1);
model = GTK_TREE_MODEL(store);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, FALSE);
gtk_tree_view_set_rules_hint(view, FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(view, column);
gtk_tree_view_column_set_title(column, text[COL_NAME]);
renderer = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer, "active", COL_CHECK, "visible", COL_VISIBLE, NULL);
g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(renderer_toggled), widget);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer, "text", COL_NAME, NULL);
for (i = 0; i < CTREE_NVCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
return store;
}
/* Initialize a new TilemDisasmView */
static void tilem_disasm_view_init(TilemDisasmView *dv)
{
GtkTreeView *tv = GTK_TREE_VIEW(dv);
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
dv->use_logical = TRUE;
gtk_tree_view_set_enable_search(tv, FALSE);
gtk_tree_view_set_fixed_height_mode(tv, TRUE);
gtk_tree_view_set_headers_visible(tv, FALSE);
cell = gtk_cell_renderer_pixbuf_new();
col = gtk_tree_view_column_new_with_attributes(NULL, cell,
"pixbuf", COL_ICON,
NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(tv, col);
dv->icon_column = col;
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Addr"), cell,
"text", COL_ADDRESS,
NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(tv, col);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Disassembly"));
cell = gtk_cell_renderer_text_new();
g_object_set(cell, "xpad", 10, NULL);
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell,
"text", COL_MNEMONIC,
"visible", COL_SHOW_MNEMONIC,
NULL);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_attributes(col, cell,
"text", COL_ARGUMENTS,
NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_append_column(tv, col);
}
static void fm_places_view_init(FmPlacesView *self)
{
GtkTreeViewColumn* col;
GtkCellRenderer* renderer;
GtkTargetList* targets;
GdkPixbuf* pix;
guint handler;
init_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(self), model);
g_object_unref(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self), FALSE);
gtk_tree_view_set_row_separator_func(GTK_TREE_VIEW(self), (GtkTreeViewRowSeparatorFunc)sep_func, NULL, NULL );
col = gtk_tree_view_column_new();
renderer = fm_cell_renderer_pixbuf_new();
handler = g_signal_connect(fm_config, "changed::pane_icon_size", G_CALLBACK(on_renderer_icon_size_changed), renderer);
g_object_weak_ref(G_OBJECT(renderer), (GDestroyNotify)on_cell_renderer_pixbuf_destroy, GUINT_TO_POINTER(handler));
fm_cell_renderer_pixbuf_set_fixed_size(FM_CELL_RENDERER_PIXBUF(renderer), fm_config->pane_icon_size, fm_config->pane_icon_size);
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_tree_view_column_set_attributes( col, renderer,
"pixbuf", COL_ICON, NULL );
renderer = gtk_cell_renderer_text_new();
// g_signal_connect( renderer, "edited", G_CALLBACK(on_bookmark_edited), view );
gtk_tree_view_column_pack_start( col, renderer, TRUE );
gtk_tree_view_column_set_attributes( col, renderer,
"text", COL_LABEL, NULL );
gtk_tree_view_append_column ( GTK_TREE_VIEW(self), col );
/*
gtk_drag_source_set(fv->view, GDK_BUTTON1_MASK,
fm_default_dnd_src_targets, N_FM_DND_SRC_DEFAULT_TARGETS,
GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK|GDK_ACTION_ASK);
fm_dnd_src_set_widget(fv->dnd_src, fv->view);
*/
gtk_drag_dest_set(self, 0,
fm_default_dnd_dest_targets, N_FM_DND_DEST_DEFAULT_TARGETS,
GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK|GDK_ACTION_ASK);
targets = gtk_drag_dest_get_target_list((GtkWidget*)self);
/* add our own targets */
gtk_target_list_add_table(targets, dnd_dest_targets, G_N_ELEMENTS(dnd_dest_targets));
self->dnd_dest = fm_dnd_dest_new((GtkWidget*)self);
g_signal_connect(self->dnd_dest, "query-info", G_CALLBACK(on_dnd_dest_query_info), self);
g_signal_connect(self->dnd_dest, "files_dropped", G_CALLBACK(on_dnd_dest_files_dropped), self);
}
static void
create_filter_column (GtkTreeView *treeview,
GtkListStore *store,
const char *title,
int column_id)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, title);
gtk_tree_view_append_column (treeview, column);
if (column_id == FILTER_COLUMN_FILTER)
{
cell = gtk_cell_renderer_pixbuf_new ();
g_object_set (cell, "stock-id", GTK_STOCK_DIALOG_ERROR, NULL);
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, cell,
(GtkTreeCellDataFunc) filter_icon_data_func,
NULL, NULL);
}
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell, "text", column_id, NULL);
g_object_set (cell, "editable", TRUE, NULL);
g_object_set_data (G_OBJECT (cell), "filter-store-column-id", GINT_TO_POINTER (column_id));
g_signal_connect (cell, "edited", G_CALLBACK (filter_cell_edited), store);
}
GtkWidget* EClassTree::createPropertyTreeView() {
// Initialise the instance TreeStore
_propertyStore = gtk_list_store_new(NUM_PROPERTY_COLUMNS,
G_TYPE_STRING, // property
G_TYPE_STRING, // value
G_TYPE_STRING, // text colour
G_TYPE_STRING); // inherited flag
// Create the TreeView widget and link it to the model
_propertyView = GTK_TREE_VIEW(gtk_tree_view_new_with_model(
GTK_TREE_MODEL(_propertyStore))
);
// Create the Property column
GtkTreeViewColumn* nameCol = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(nameCol, _("Property"));
gtk_tree_view_column_set_sizing(nameCol, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_spacing(nameCol, 3);
GtkCellRenderer* textRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(nameCol, textRenderer, FALSE);
gtk_tree_view_column_set_attributes(nameCol, textRenderer,
"text", PROPERTY_NAME_COLUMN,
"foreground", PROPERTY_TEXT_COLOUR_COLUMN,
NULL);
//GtkTreeViewColumn* nameCol = gtkutil::TextColumn("Property", PROPERTY_NAME_COLUMN);
gtk_tree_view_column_set_sort_column_id(nameCol, PROPERTY_NAME_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(_propertyView), nameCol);
// Create the value column
GtkTreeViewColumn* valCol = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(valCol, _("Value"));
gtk_tree_view_column_set_sizing(valCol, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
GtkCellRenderer* valRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(valCol, valRenderer, TRUE);
gtk_tree_view_column_set_attributes(valCol, valRenderer,
"text", PROPERTY_VALUE_COLUMN,
"foreground", PROPERTY_TEXT_COLOUR_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(valCol, PROPERTY_VALUE_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(_propertyView), valCol);
return gtkutil::ScrolledFrame(GTK_WIDGET(_propertyView));
}
static void
file_view_init (AnjutaFileView *object)
{
GtkCellRenderer* renderer_pixbuf;
GtkCellRenderer* renderer_display;
GtkTreeViewColumn* column;
GtkTreeSelection* selection;
GtkTreeModel* sort_model;
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (object);
priv->current_selection = NULL;
priv->model = file_model_new (GTK_TREE_VIEW(object), NULL);
g_signal_connect_object (priv->model, "directory-expanded",
G_CALLBACK (file_view_directory_expanded), object, 0);
sort_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(priv->model));
gtk_tree_view_set_model (GTK_TREE_VIEW(object), sort_model);
/* set_model takes a reference so we can release the reference we got when
* the sort_model was created. */
g_object_unref (sort_model);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE(sort_model),
file_view_sort_model,
NULL,
NULL);
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
renderer_display = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Filename"));
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_tree_view_column_pack_start (column, renderer_display, FALSE);
gtk_tree_view_column_set_cell_data_func(column,
renderer_pixbuf,
file_view_render_pixbuf_with_emblem,
object, NULL);
gtk_tree_view_column_set_attributes (column, renderer_display,
"markup", COLUMN_DISPLAY,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (object), column);
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (object));
g_signal_connect (selection, "changed",
G_CALLBACK (file_view_selection_changed), object);
/* DND */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW(object),
GDK_BUTTON1_MASK,
uri_targets,
1,
GDK_ACTION_MOVE);
/* Typeahead search */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (object), COLUMN_FILENAME);
}
GtkWidget *fm_app_menu_view_new(void)
{
GtkWidget* view;
GtkTreeViewColumn* col;
GtkCellRenderer* render;
if(!store)
{
static GType menu_cache_item_type = 0;
if(G_UNLIKELY(!menu_cache_item_type))
menu_cache_item_type = g_boxed_type_register_static("MenuCacheItem",
(GBoxedCopyFunc)menu_cache_item_ref,
(GBoxedFreeFunc)menu_cache_item_unref);
store = gtk_tree_store_new(N_COLS, G_TYPE_ICON, /*GDK_TYPE_PIXBUF, */G_TYPE_STRING, menu_cache_item_type);
g_object_weak_ref(G_OBJECT(store), (GWeakNotify)destroy_store, NULL);
menu_cache = menu_cache_lookup("applications.menu");
if(menu_cache)
{
MenuCacheDir* dir = menu_cache_get_root_dir(menu_cache);
menu_cache_reload_notify = menu_cache_add_reload_notify(menu_cache, on_menu_cache_reload, NULL);
if(dir) /* content of menu is already loaded */
add_menu_items(NULL, dir);
}
}
else
g_object_ref(store);
view = gtk_tree_view_new_with_model((GtkTreeModel*)store);
render = gtk_cell_renderer_pixbuf_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Installed Applications"));
gtk_tree_view_column_pack_start(col, render, FALSE);
gtk_tree_view_column_set_attributes(col, render, "gicon", COL_ICON, NULL);
render = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, render, TRUE);
gtk_tree_view_column_set_attributes(col, render, "text", COL_TITLE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
g_object_unref(store);
return view;
}
static void
render_column(HybridInfo *info)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
/* expander columns */
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(info->treeview), column);
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_set_expander_column(GTK_TREE_VIEW(info->treeview), column);
/* main column */
column = gtk_tree_view_column_new ();
gtk_tree_view_append_column(GTK_TREE_VIEW(info->treeview), column);
gtk_tree_view_columns_autosize(GTK_TREE_VIEW(info->treeview));
/* name */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"markup", HYBRID_INFO_NAME_COLUMN,
NULL);
g_object_set(renderer, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(renderer, "wrap-width",120, NULL);
/* value */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"markup", HYBRID_INFO_VALUE_COLUMN,
"visible", HYBRID_INFO_VALUE_COLUMN_VISIBLE,
NULL);
g_object_set(renderer, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(renderer, "wrap-width",250, NULL);
/* pixbuf */
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"pixbuf", HYBRID_INFO_PIXBUF_COLUMN,
"visible", HYBRID_INFO_PIXBUF_COLUMN_VISIBLE,
NULL);
}
/* build_treeview
* Creates the necessarry data columns for the file system.
*/
void build_treeview (GtkWidget *treeview) {
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", DIR_IMAGE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer, "text", DIR_NAME, NULL);
gtk_tree_view_column_set_title(column, "Name");
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
}
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 GtkTreeViewColumn
* trg_tree_view_icontext_column_new(trg_column_description * desc,
gchar * renderer_property)
{
GtkTreeViewColumn *column = gtk_tree_view_column_new();
GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_set_title(column, desc->header);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
renderer_property,
desc->model_column_extra, 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",
desc->model_column, NULL);
return column;
}
static void
add_columns (GtkTreeView *treeview)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new ();
/* Checkbox */
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (on_service_toggled), tool);
g_object_set (G_OBJECT (renderer), "xpad", 12, NULL);
gtk_tree_view_insert_column_with_attributes (treeview,
-1, "",
renderer,
"active", COL_ACTIVE,
NULL);
/* Image */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", COL_IMAGE,
NULL);
/* Text */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"markup", COL_DESC,
NULL);
g_object_set (G_OBJECT (renderer), "yalign", 0, NULL);
gtk_tree_view_insert_column (treeview, column, -1);
gtk_tree_view_column_set_sort_column_id (column, 1);
gtk_tree_view_column_clicked (column);
}
static GtkTreeViewColumn
* trg_tree_view_fileicontext_column_new(trg_column_description * desc)
{
GtkTreeViewColumn *column = gtk_tree_view_column_new();
GtkCellRenderer *renderer = trg_cell_renderer_file_icon_new();
gtk_tree_view_column_set_title(column, desc->header);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"file-id",
desc->model_column_extra,
"file-name", desc->model_column,
NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer, "text",
desc->model_column, NULL);
return 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);
}
void texture_init() {
init_treeview(builder, "texture_list_treeview", 1);
init_treeview(builder, "selected_texture_treeview", 2);
//Initialize texture image view
GObject* tex_image_view = gtk_builder_get_object(builder, "selected_texture_images");
GtkTreeStore* store = gtk_tree_store_new(2, G_TYPE_STRING, GDK_TYPE_PIXBUF);
gtk_tree_view_set_model(GTK_TREE_VIEW(tex_image_view),
GTK_TREE_MODEL(store));
g_object_unref(store);
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_get_column(GTK_TREE_VIEW(tex_image_view), 0);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "text", 0, NULL);
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_get_column(GTK_TREE_VIEW(tex_image_view), 1);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", 1, NULL);
//Initialize face combobox
GObject* face = gtk_builder_get_object(builder, "face_combobox");
GtkTreeStore* face_store = gtk_tree_store_new(1, G_TYPE_STRING);
gtk_combo_box_set_model(GTK_COMBO_BOX(face), GTK_TREE_MODEL(face_store));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(face), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(face), renderer, "text", 0, NULL);
GtkTreeIter row;
const char* strs[] = {"Positive X", "Negative X", "Positive Y", "Negative Y", "Positive Z", "Negative Z"};
for (size_t i = 0; i < sizeof(strs)/sizeof(strs[0]); i++) {
gtk_tree_store_append(face_store, &row, NULL);
gtk_tree_store_set(face_store, &row, 0, strs[i], -1);
}
g_object_unref(face_store);
gtk_combo_box_set_active(GTK_COMBO_BOX(face), 0);
//Initialize layer
GtkSpinButton* button = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "layer_spinbutton"));
gtk_adjustment_set_upper(gtk_spin_button_get_adjustment(button), 0);
}
