static void
attachment_icon_view_constructed (GObject *object)
{
GtkCellLayout *cell_layout;
GtkCellRenderer *renderer;
cell_layout = GTK_CELL_LAYOUT (object);
/* This needs to happen after constructor properties are set
* so that GtkCellLayout.get_area() returns something valid. */
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "stock-size", icon_size, NULL);
gtk_cell_layout_pack_start (cell_layout, renderer, FALSE);
gtk_cell_layout_add_attribute (
cell_layout, renderer, "gicon",
E_ATTACHMENT_STORE_COLUMN_ICON);
renderer = gtk_cell_renderer_text_new ();
g_object_set (
renderer, "alignment", PANGO_ALIGN_CENTER,
"wrap-mode", PANGO_WRAP_WORD, "wrap-width", 150,
"yalign", 0.0, NULL);
gtk_cell_layout_pack_start (cell_layout, renderer, FALSE);
gtk_cell_layout_add_attribute (
cell_layout, renderer, "text",
E_ATTACHMENT_STORE_COLUMN_CAPTION);
renderer = gtk_cell_renderer_progress_new ();
g_object_set (renderer, "text", _("Loading"), NULL);
gtk_cell_layout_pack_start (cell_layout, renderer, TRUE);
gtk_cell_layout_add_attribute (
cell_layout, renderer, "value",
E_ATTACHMENT_STORE_COLUMN_PERCENT);
gtk_cell_layout_add_attribute (
cell_layout, renderer, "visible",
E_ATTACHMENT_STORE_COLUMN_LOADING);
renderer = gtk_cell_renderer_progress_new ();
g_object_set (renderer, "text", _("Saving"), NULL);
gtk_cell_layout_pack_start (cell_layout, renderer, TRUE);
gtk_cell_layout_add_attribute (
cell_layout, renderer, "value",
E_ATTACHMENT_STORE_COLUMN_PERCENT);
gtk_cell_layout_add_attribute (
cell_layout, renderer, "visible",
E_ATTACHMENT_STORE_COLUMN_SAVING);
e_extensible_load_extensions (E_EXTENSIBLE (object));
}
void cgraphics_listview_widget_create_columns( widget_t *widget )
{
listview_widget_t *lvw = (listview_widget_t *)widget;
GtkCellRenderer *renderer;
GType *types;
GtkTreeModel *model;
int a;
types = (GType *)malloc( sizeof(GType) * (lvw->widget.columns+1) );
for ( a = 0; a < lvw->widget.columns; a++ )
{
if ( lvw->widget.coltypes[a] == CLIST_TYPE_STRING )
types[a] = G_TYPE_STRING;
else if ( lvw->widget.coltypes[a] == CLIST_TYPE_UINT )
types[a] = G_TYPE_UINT;
else if ( lvw->widget.coltypes[a] == CLIST_TYPE_DOUBLE )
types[a] = G_TYPE_DOUBLE;
else
{
printf( "Bad error: invalid type found (%d)\n", lvw->widget.coltypes[a] );
exit( 0 );
}
}
types[a] = G_TYPE_UINT;
model = (GtkTreeModel *)gtk_list_store_newv( lvw->widget.columns + 1, types );
free( types );
gtk_tree_view_set_model( GTK_TREE_VIEW(widget->container), model );
g_object_unref( model );
for ( a = 0; a < lvw->widget.columns; a++ )
{
if ( lvw->widget.coltypes[a] == CLIST_TYPE_STRING )
{
renderer = gtk_cell_renderer_text_new( );
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(widget->container),
-1, lvw->titles[a], renderer, "text", a, NULL );
}
else if ( lvw->widget.coltypes[a] == CLIST_TYPE_UINT )
{
cgcelldata *cgcd = (cgcelldata *)malloc( sizeof(cgcelldata) ); /* FIXME: free me somewhere. */
renderer = gtk_cell_renderer_toggle_new( );
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(widget->container),
-1, lvw->titles[a], renderer, "active", a, NULL );
cgcd->widget = widget;
cgcd->column = a;
g_signal_connect( G_OBJECT(renderer), "toggled", G_CALLBACK(cgraphics_listview_toggled_handler), cgcd );
}
else if ( lvw->widget.coltypes[a] == CLIST_TYPE_DOUBLE )
{
renderer = gtk_cell_renderer_progress_new( );
gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(widget->container),
-1, lvw->titles[a], renderer, "value", a, NULL );
}
}
}
static void
treeview_download_files_init(void)
{
GtkTreeView *tv;
unsigned i;
STATIC_ASSERT(FILEINFO_VISIBLE_COLUMNS == c_fi_num);
tv = GTK_TREE_VIEW(gtk_tree_view_new());
treeview_download_files = tv;
for (i = 0; i < c_fi_num; i++) {
add_column(tv, i,
fi_gui_files_column_title(i),
fi_gui_files_column_justify_right(i) ? 1.0 : 0.0,
c_fi_progress == i ? gtk_cell_renderer_progress_new() : NULL,
render_files);
}
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv),
GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_headers_visible(tv, TRUE);
gtk_tree_view_set_headers_clickable(tv, TRUE);
gtk_tree_view_set_enable_search(tv, FALSE);
gtk_tree_view_set_rules_hint(tv, TRUE);
tree_view_set_fixed_height_mode(tv, TRUE);
gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_files));
tree_view_restore_visibility(tv, PROP_FILE_INFO_COL_VISIBLE);
tree_view_restore_widths(tv, PROP_FILE_INFO_COL_WIDTHS);
gui_signal_connect(tv,
"cursor-changed", on_treeview_download_files_cursor_changed, NULL);
}
static void
brasero_medium_selection_set_show_used_space (BraseroMediumSelection *selector)
{
GtkCellRenderer *renderer;
gtk_cell_layout_clear (GTK_CELL_LAYOUT (selector));
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "follow-state", TRUE, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer,
"gicon", ICON_COL,
NULL);
renderer = gtk_cell_renderer_progress_new ();
g_object_set (renderer, "xpad", 4, "text-xalign", 0.0, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer,
"text", NAME_COL,
"value", USED_COL,
"visible", VISIBLE_PROGRESS_COL,
NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xpad", 4, NULL);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selector), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selector), renderer,
"markup", NAME_COL,
"visible", VISIBLE_TEXT_COL,
NULL);
}
static void add_columns(GtkWidget *treeview)
{
GtkCellRenderer *rend;
GtkTreeViewColumn *column;
/* Done */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Done");
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
rend = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(column, rend, TRUE);
gtk_tree_view_column_add_attribute(column, rend, "active", TODO_DONE);
/* Description */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Description");
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
rend = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, rend, TRUE);
gtk_tree_view_column_add_attribute(column, rend, "text", TODO_TEXT);
/* Progress */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Progress");
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
rend = gtk_cell_renderer_progress_new();
gtk_tree_view_column_pack_start(column, rend, TRUE);
gtk_tree_view_column_add_attribute(column, rend, "value", TODO_PROGRESS);
}
static void
connection_essids_combo_init (GtkComboBoxEntry *combo)
{
GtkTreeModel *model;
GtkCellRenderer *renderer;
model = GTK_TREE_MODEL (gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT));
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), model);
g_object_unref (model);
/* add "crypted" renderer */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo),
renderer, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo),
renderer, "pixbuf", 0);
gtk_cell_layout_reorder (GTK_CELL_LAYOUT (combo), renderer, 0);
/* add "quality" renderer */
renderer = gtk_cell_renderer_progress_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo),
renderer, FALSE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (combo),
renderer, "value", 2);
/* reuse text cell renderer for the essid */
gtk_combo_box_entry_set_text_column (combo, 1);
g_signal_connect (gtk_bin_get_child (GTK_BIN (combo)), "changed",
G_CALLBACK (on_dialog_changed), tool);
}
static void
manager_init (Manager *self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE((self), MANAGER_TYPE, ManagerPrivate);
self->priv->builder = gtk_builder_new ();
gtk_builder_add_from_file (self->priv->builder,
SHARE_DIR "/ui/main.ui", NULL);
self->priv->window = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "main_window"));
self->priv->view = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "main_view"));
self->priv->status = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "main_status"));
self->priv->store = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_OBJECT));
gtk_tree_view_set_model (GTK_TREE_VIEW (self->priv->view), self->priv->store);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_progress_new ();
column = gtk_tree_view_column_new_with_attributes ("Progress", renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc) progress_column_func, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->view), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Download", renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc) title_column_func, NULL, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->view), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("remaining", renderer, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
(GtkTreeCellDataFunc) time_column_func, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->view), column);
g_signal_connect (self->priv->window, "destroy", G_CALLBACK (manager_stop), NULL);
self->priv->icon = gtk_status_icon_new_from_stock (GTK_STOCK_GO_DOWN);
gtk_widget_show_all (self->priv->window);
self->priv->new_id = 1;
self->priv->group = download_group_new ("Primary");
self->priv->conn = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
self->priv->proxy = dbus_g_proxy_new_for_name (self->priv->conn,
DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
org_freedesktop_DBus_request_name (self->priv->proxy,
MANAGER_DBUS_SERVICE, DBUS_NAME_FLAG_DO_NOT_QUEUE, NULL, NULL);
dbus_g_connection_register_g_object (self->priv->conn,
MANAGER_DBUS_PATH, G_OBJECT (self));
}
/**
* a_background_init:
*
* Initialize background feature.
*/
void a_background_init()
{
/* initialize thread pool */
gint max_threads = 10; /* limit maximum number of threads running at one time */
gint maxt;
if ( a_settings_get_integer ( VIK_SETTINGS_BACKGROUND_MAX_THREADS, &maxt ) )
max_threads = maxt;
thread_pool = g_thread_pool_new ( (GFunc) thread_helper, NULL, max_threads, FALSE, NULL );
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *scrolled_window;
g_debug(__FUNCTION__);
/* store & treeview */
bgstore = gtk_list_store_new ( N_COLUMNS, G_TYPE_STRING, G_TYPE_DOUBLE, G_TYPE_POINTER );
bgtreeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL(bgstore) );
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (bgtreeview), TRUE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (bgtreeview)),
GTK_SELECTION_SINGLE);
/* add columns */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ( _("Job"), renderer, "text", TITLE_COLUMN, NULL );
gtk_tree_view_append_column ( GTK_TREE_VIEW(bgtreeview), column );
renderer = gtk_cell_renderer_progress_new ();
column = gtk_tree_view_column_new_with_attributes ( _("Progress"), renderer, "value", PROGRESS_COLUMN, NULL );
gtk_tree_view_append_column ( GTK_TREE_VIEW(bgtreeview), column );
/* setup window */
scrolled_window = gtk_scrolled_window_new ( NULL, NULL );
gtk_container_add ( GTK_CONTAINER(scrolled_window), bgtreeview );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
bgwindow = gtk_dialog_new_with_buttons ( "", NULL, 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_DELETE, 1, GTK_STOCK_CLEAR, 2, NULL );
gtk_dialog_set_default_response ( GTK_DIALOG(bgwindow), GTK_RESPONSE_ACCEPT );
GtkWidget *response_w = NULL;
#if GTK_CHECK_VERSION (2, 20, 0)
response_w = gtk_dialog_get_widget_for_response ( GTK_DIALOG(bgwindow), GTK_RESPONSE_ACCEPT );
#endif
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(bgwindow))), scrolled_window, TRUE, TRUE, 0 );
gtk_window_set_default_size ( GTK_WINDOW(bgwindow), 400, 400 );
gtk_window_set_title ( GTK_WINDOW(bgwindow), _("Viking Background Jobs") );
if ( response_w )
gtk_widget_grab_focus ( response_w );
/* don't destroy win */
g_signal_connect ( G_OBJECT(bgwindow), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL );
g_signal_connect ( G_OBJECT(bgwindow), "response", G_CALLBACK(bgwindow_response), 0 );
}
static void
add_columns (GtkTreeView *treeview,
GtkTreeModel *items_model,
GtkTreeModel *numbers_model)
{
GtkCellRenderer *renderer;
/* number column */
renderer = gtk_cell_renderer_combo_new ();
g_object_set (renderer,
"model", numbers_model,
"text-column", COLUMN_NUMBER_TEXT,
"has-entry", FALSE,
"editable", TRUE,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (cell_edited), items_model);
g_signal_connect (renderer, "editing-started",
G_CALLBACK (editing_started), NULL);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_NUMBER));
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Number", renderer,
"text", COLUMN_ITEM_NUMBER,
NULL);
/* product column */
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer,
"editable", TRUE,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (cell_edited), items_model);
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_PRODUCT));
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Product", renderer,
"text", COLUMN_ITEM_PRODUCT,
NULL);
/* yummy column */
renderer = gtk_cell_renderer_progress_new ();
g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (COLUMN_ITEM_YUMMY));
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
-1, "Yummy", renderer,
"value", COLUMN_ITEM_YUMMY,
NULL);
}
static GtkTreeViewColumn *new_column(int type, int width, const char *title, ...){
GtkTreeViewColumn *col;
GtkCellRenderer *render=NULL;
col=gtk_tree_view_column_new();
switch(type){
case 0:
render=gtk_cell_renderer_text_new();
#if GTK_MAJOR_VERSION>=3 || GTK_MINOR_VERSION >= 18
gtk_cell_renderer_set_padding(render, 1, 1);
gtk_cell_renderer_set_alignment(render, 1, 0.5);
#endif
break;
case 1:
render=gtk_cell_renderer_progress_new();
break;
case 2:
render=gtk_cell_renderer_pixbuf_new();
break;
default:
error("Invalid\n");
}
gtk_tree_view_column_set_title(col, title);
gtk_tree_view_column_set_spacing(col, 2);
gtk_tree_view_column_set_alignment(col, 1);
gtk_tree_view_column_set_resizable(col, TRUE);
//gtk_tree_view_column_set_clickable(col, TRUE);
//gtk_tree_view_column_set_expand(col,FALSE);
if(width>0){//Adjustable columns
//Do not set min_width if set resizable.
//gtk_tree_view_column_set_min_width(col, width);
gtk_tree_view_column_set_expand(col,TRUE);
//resizable is not good if expand
gtk_tree_view_column_set_resizable(col, FALSE);
if(type==0){
g_object_set(G_OBJECT(render),"ellipsize",PANGO_ELLIPSIZE_START,NULL);
}
}else if(width<0){/*max width*/
gtk_tree_view_column_set_min_width(col,-width/10);
gtk_tree_view_column_set_max_width(col,-width);
}
gtk_tree_view_column_pack_start(col,render,TRUE);
va_list ap;
va_start(ap, title);
const char *att=NULL;
while((att=va_arg(ap, const char *))){
gtk_tree_view_column_add_attribute(col, render, att, va_arg(ap,int));
}
va_end(ap);
return col;
}
static GtkWidget * create_batchlist_treeview()
{
batchlist_treeview = gtk_tree_view_new ();
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(batchlist_treeview), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (batchlist_treeview), TRUE);
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(batchlist_treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE);
/* For touch screen, better to use "cursor-changed", instead of "row-activated" */
g_signal_connect (G_OBJECT(batchlist_treeview), "cursor-changed",
G_CALLBACK (batchlist_treeview_row_selected), NULL);
batchlist_treeview_sw = new_scrolled_window (NULL);
gtk_container_add (GTK_CONTAINER (batchlist_treeview_sw), batchlist_treeview);
/* add columns to the tree view */
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
int i;
for (i=COL_BL_LEVELS; i<=COL_BL_FAILED_PERCENT; i++) {
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (batchlist_col_names[i], cell, "text", i, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col);
}
/* cancel column */
cell = clickable_cell_renderer_pixbuf_new();
col = gtk_tree_view_column_new_with_attributes("", cell, "pixbuf", COL_BL_CANCEL, NULL);
g_signal_connect (G_OBJECT (cell), "clicked", G_CALLBACK (cancel_batch_button_clicked), NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col);
gtk_tree_view_column_set_fixed_width(col, 16);
cell = gtk_cell_renderer_progress_new();
col = gtk_tree_view_column_new_with_attributes (batchlist_col_names[COL_BL_DONE_PERCENT],
cell, "value", COL_BL_DONE_PERCENT, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(batchlist_treeview), col);
batchlist_store = gtk_list_store_new (COL_BL_COUNT,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_PIXBUF,
G_TYPE_INT, G_TYPE_POINTER);
gtk_tree_view_set_model(GTK_TREE_VIEW(batchlist_treeview), GTK_TREE_MODEL(batchlist_store));
return batchlist_treeview_sw;
}
static GtkTreeView* nsgtk_download_tree_view_new(GtkBuilder *gladeFile)
{
GtkTreeView *treeview;
GtkCellRenderer *renderer;
treeview = GTK_TREE_VIEW(gtk_builder_get_object(gladeFile, "treeDownloads"));
/* Progress column */
renderer = gtk_cell_renderer_progress_new();
gtk_tree_view_insert_column_with_attributes (treeview, -1,
messages_get("gtkProgress"), renderer, "value",
NSGTK_DOWNLOAD_PROGRESS, "pulse", NSGTK_DOWNLOAD_PULSE,
"text", NSGTK_DOWNLOAD_STATUS, NULL);
/* Information column */
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "wrap-mode", PANGO_WRAP_WORD_CHAR,
"wrap-width", 300, NULL);
gtk_tree_view_insert_column_with_attributes (treeview, -1,
messages_get("gtkDetails"), renderer, "text",
NSGTK_DOWNLOAD_INFO, NULL);
gtk_tree_view_column_set_expand(gtk_tree_view_get_column(treeview,
NSGTK_DOWNLOAD_INFO), TRUE);
/* Time remaining column */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes (treeview, -1,
messages_get("gtkRemaining"), renderer, "text",
NSGTK_DOWNLOAD_REMAINING, NULL);
/* Speed column */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes (treeview, -1,
messages_get("gtkSpeed"), renderer, "text",
NSGTK_DOWNLOAD_SPEED, NULL);
return treeview;
}
static GtkWidget *create_tree(void)
{
GtkWidget *tree;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
tree = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(tree),
GTK_TREE_VIEW_GRID_LINES_NONE);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_spacing(column, 6);
gtk_tree_view_column_set_min_width(column, 250);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer,
"icon-name", CONNMAN_COLUMN_ICON);
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,
service_to_text, NULL, NULL);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
security_to_icon, NULL, NULL);
renderer = gtk_cell_renderer_progress_new();
gtk_cell_renderer_set_fixed_size(renderer, 100, -1);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
strength_to_value, NULL, NULL);
model = connman_client_get_model(client);
gtk_tree_view_set_model(GTK_TREE_VIEW(tree), model);
g_object_unref(model);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(tree),
CONNMAN_COLUMN_NAME);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(select_callback), tree);
g_signal_connect(G_OBJECT(tree), "button-press-event",
G_CALLBACK(button_pressed), NULL);
g_signal_connect(G_OBJECT(tree), "popup-menu",
G_CALLBACK(popup_callback), NULL);
g_signal_connect(G_OBJECT(tree), "drag-drop",
G_CALLBACK(drag_drop), NULL);
g_signal_connect(G_OBJECT(tree), "drag-data-get",
G_CALLBACK(drag_data_get), selection);
g_signal_connect(G_OBJECT(tree), "drag-data-received",
G_CALLBACK(drag_data_received), model);
return tree;
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *tree_view;
GtkTreeModel *tree_model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gtk_init (&argc, &argv);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GtkTreeView editing sample");
g_signal_connect (window, "destroy", gtk_main_quit, NULL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (window), scrolled_window);
tree_model = create_model ();
tree_view = gtk_tree_view_new_with_model (tree_model);
g_signal_connect (tree_view, "button_press_event", G_CALLBACK (button_press_event), NULL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), TRUE);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "String");
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", PIXBUF_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", STRING_COLUMN,
"editable", IS_EDITABLE_COLUMN,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (edited), tree_model);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", STRING_COLUMN,
"editable", IS_EDITABLE_COLUMN,
NULL);
g_signal_connect (renderer, "edited",
G_CALLBACK (edited), tree_model);
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", PIXBUF_COLUMN, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (toggled), tree_model);
g_object_set (renderer,
"xalign", 0.0,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Editable",
renderer,
"active", IS_EDITABLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_progress_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Progress",
renderer,
"value", PROGRESS_COLUMN,
NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
gtk_window_set_default_size (GTK_WINDOW (window),
800, 175);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
void
fi_gui_init(void)
{
fi_sources = htable_create(HASH_KEY_SELF, 0);
{
GtkTreeViewColumn *column;
GtkTreeView *tv;
tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_aliases"));
treeview_download_aliases = tv;
store_aliases = gtk_list_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_aliases));
column = gtk_tree_view_column_new_with_attributes(_("Aliases"),
create_text_cell_renderer(0.0),
"text", 0,
NULL_PTR);
configure_column(column);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_append_column(tv, column);
tree_view_set_fixed_height_mode(tv, TRUE);
drag_attach_text(GTK_WIDGET(tv), fi_gui_get_alias);
}
{
static const struct {
enum c_src id;
const char *title;
} tab[] = {
{ c_src_host, N_("Host"), },
{ c_src_country, N_("Country"), },
{ c_src_server, N_("Server"), },
{ c_src_range, N_("Range"), },
{ c_src_progress, N_("Progress"), },
{ c_src_status, N_("Status"), },
};
GtkTreeView *tv;
unsigned i;
STATIC_ASSERT(c_src_num == N_ITEMS(tab));
tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_sources"));
treeview_download_sources = tv;
store_sources = gtk_list_store_new(1, G_TYPE_POINTER);
gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_sources));
for (i = 0; i < N_ITEMS(tab); i++) {
GtkCellRenderer *renderer;
renderer = tab[i].id == c_src_progress
? gtk_cell_renderer_progress_new()
: NULL;
(void) add_column(tv, tab[i].id, _(tab[i].title), 0.0,
renderer, render_sources);
}
gtk_tree_view_set_headers_clickable(tv, FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv),
GTK_SELECTION_MULTIPLE);
tree_view_restore_widths(tv, PROP_SOURCES_COL_WIDTHS);
tree_view_set_fixed_height_mode(tv, TRUE);
widget_add_popup_menu(GTK_WIDGET(tv), fi_gui_sources_get_popup_menu);
}
fi_gui_details_treeview_init();
fi_gui_common_init();
{
uint32 page;
GtkNotebook *notebook_downloads_info =
GTK_NOTEBOOK(gui_main_window_lookup("notebook_downloads_info"));
gui_prop_get_guint32_val(PROP_DOWNLOADS_INFO_NOTEBOOK_TAB, &page);
if (page >= NUM_DOWNLOADS_INFO_NB_PAGES)
page = DOWNLOADS_INFO_NB_PAGE_DETAILS;
notebook_downloads_info_current_page = page;
gtk_notebook_set_current_page(notebook_downloads_info, page);
gui_signal_connect(notebook_downloads_info,
"switch-page", on_notebook_downloads_info_switch_page, NULL);
}
}
void
fi_gui_init(void)
{
fi_sources = g_hash_table_new(NULL, NULL);
{
GtkTreeViewColumn *column;
GtkTreeView *tv;
tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_aliases"));
treeview_download_aliases = tv;
store_aliases = gtk_list_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_aliases));
column = gtk_tree_view_column_new_with_attributes(_("Aliases"),
create_text_cell_renderer(0.0),
"text", 0,
(void *) 0);
configure_column(column);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_append_column(tv, column);
tree_view_set_fixed_height_mode(tv, TRUE);
drag_attach_text(GTK_WIDGET(tv), fi_gui_get_alias);
}
{
static const struct {
enum c_src id;
const char *title;
} tab[] = {
{ c_src_host, N_("Host"), },
{ c_src_country, N_("Country"), },
{ c_src_server, N_("Server"), },
{ c_src_range, N_("Range"), },
{ c_src_progress, N_("Progress"), },
{ c_src_status, N_("Status"), },
};
GtkTreeView *tv;
unsigned i;
STATIC_ASSERT(c_src_num == G_N_ELEMENTS(tab));
tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_sources"));
treeview_download_sources = tv;
store_sources = gtk_list_store_new(1, G_TYPE_POINTER);
gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_sources));
for (i = 0; i < G_N_ELEMENTS(tab); i++) {
GtkCellRenderer *renderer;
renderer = tab[i].id == c_src_progress
? gtk_cell_renderer_progress_new()
: NULL;
add_column(tv, tab[i].id, _(tab[i].title), 0.0,
renderer, render_sources);
}
gtk_tree_view_set_headers_clickable(tv, FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv),
GTK_SELECTION_MULTIPLE);
tree_view_restore_widths(tv, PROP_SOURCES_COL_WIDTHS);
tree_view_set_fixed_height_mode(tv, TRUE);
widget_add_popup_menu(GTK_WIDGET(tv), fi_gui_sources_get_popup_menu);
}
fi_gui_details_treeview_init();
fi_gui_common_init();
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *tree_view;
GtkWidget *vbox, *hbox, *cntl_vbox;
GtkTreeModel *tree_model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkCellArea *area;
CallbackData callback[4];
gtk_init (&argc, &argv);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GtkTreeView editing sample");
g_signal_connect (window, "destroy", gtk_main_quit, NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (window), vbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
tree_model = create_model ();
tree_view = gtk_tree_view_new_with_model (tree_model);
g_signal_connect (tree_view, "button_press_event", G_CALLBACK (button_press_event), NULL);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), TRUE);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "String");
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"icon-name", ICON_NAME_COLUMN,
"sensitive", IS_SENSITIVE_COLUMN,
NULL);
callback[0].area = area;
callback[0].renderer = renderer;
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", STRING_COLUMN,
"editable", IS_EDITABLE_COLUMN,
"sensitive", IS_SENSITIVE_COLUMN,
NULL);
callback[1].area = area;
callback[1].renderer = renderer;
g_signal_connect (renderer, "edited",
G_CALLBACK (edited), tree_model);
g_object_set (renderer,
"placeholder-text", "Type here",
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", STRING_COLUMN,
"editable", IS_EDITABLE_COLUMN,
"sensitive", IS_SENSITIVE_COLUMN,
NULL);
callback[2].area = area;
callback[2].renderer = renderer;
g_signal_connect (renderer, "edited",
G_CALLBACK (edited), tree_model);
g_object_set (renderer,
"placeholder-text", "Type here too",
NULL);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer,
"xalign", 0.0,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"icon-name", LAST_ICON_NAME_COLUMN,
"sensitive", IS_SENSITIVE_COLUMN,
NULL);
callback[3].area = area;
callback[3].renderer = renderer;
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (editable_toggled), tree_model);
g_object_set (renderer,
"xalign", 0.0,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Editable",
renderer,
"active", IS_EDITABLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (sensitive_toggled), tree_model);
g_object_set (renderer,
"xalign", 0.0,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Sensitive",
renderer,
"active", IS_SENSITIVE_COLUMN,
NULL);
renderer = gtk_cell_renderer_progress_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Progress",
renderer,
"value", PROGRESS_COLUMN,
NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
gtk_window_set_default_size (GTK_WINDOW (window),
800, 250);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* Alignment controls */
cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (cntl_vbox);
gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE, 0);
create_control (cntl_vbox, 1, CNTL_ALIGN, &callback[0]);
create_control (cntl_vbox, 2, CNTL_ALIGN, &callback[1]);
create_control (cntl_vbox, 3, CNTL_ALIGN, &callback[2]);
create_control (cntl_vbox, 4, CNTL_ALIGN, &callback[3]);
/* Expand controls */
cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (cntl_vbox);
gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE, 0);
create_control (cntl_vbox, 1, CNTL_EXPAND, &callback[0]);
create_control (cntl_vbox, 2, CNTL_EXPAND, &callback[1]);
create_control (cntl_vbox, 3, CNTL_EXPAND, &callback[2]);
create_control (cntl_vbox, 4, CNTL_EXPAND, &callback[3]);
/* Fixed controls */
cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (cntl_vbox);
gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE, 0);
create_control (cntl_vbox, 1, CNTL_FIXED, &callback[0]);
create_control (cntl_vbox, 2, CNTL_FIXED, &callback[1]);
create_control (cntl_vbox, 3, CNTL_FIXED, &callback[2]);
create_control (cntl_vbox, 4, CNTL_FIXED, &callback[3]);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *tree_view;
GtkTreeModel *tree_model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkCellArea *area;
gtk_init (&argc, &argv);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Vertical cells in GtkTreeViewColumn example");
g_signal_connect (window, "destroy", gtk_main_quit, NULL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (window), scrolled_window);
tree_model = create_model ();
tree_view = gtk_tree_view_new_with_model (tree_model);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
/* First column */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "stock-size", GTK_ICON_SIZE_DIALOG, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"stock-id", ICON_COLUMN, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "scale", 1.2F, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", INFO_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
/* Second (vertical) column */
column = gtk_tree_view_column_new ();
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
gtk_orientable_set_orientation (GTK_ORIENTABLE (area), GTK_ORIENTATION_VERTICAL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, "editable", TRUE, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", DESCRIPTION_COLUMN,
NULL);
renderer = gtk_cell_renderer_progress_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"value", PROGRESS_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "scale", 0.6F, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", FINE_PRINT_COLUMN,
"foreground", FINE_PRINT_COLOR_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
gtk_window_set_default_size (GTK_WINDOW (window),
800, 400);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static VALUE
rg_initialize(VALUE self)
{
RBGTK_INITIALIZE(self, gtk_cell_renderer_progress_new());
return Qnil;
}
static void
trg_tree_view_add_column_after(TrgTreeView * tv,
trg_column_description * desc,
gint64 width, GtkTreeViewColumn * after_col)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column = NULL;
GtkButton *column_button = NULL;
switch (desc->type) {
case TRG_COLTYPE_TEXT:
renderer =
desc->customRenderer ? desc->customRenderer :
gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer, "text",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_SPEED:
renderer = trg_cell_renderer_speed_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"speed-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_EPOCH:
renderer = trg_cell_renderer_epoch_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"epoch-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_ETA:
renderer = trg_cell_renderer_eta_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"eta-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_SIZE:
renderer = trg_cell_renderer_size_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"size-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_PROG:
renderer = gtk_cell_renderer_progress_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_RATIO:
renderer = trg_cell_renderer_ratio_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"ratio-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_WANTED:
column = gtk_tree_view_column_new();
renderer = trg_cell_renderer_wanted_new();
/*gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), 0.5f,
0.0); */
gtk_tree_view_column_set_title(column, desc->header);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer,
"wanted-value",
desc->model_column, NULL);
break;
case TRG_COLTYPE_ICONTEXT:
column = trg_tree_view_icontext_column_new(desc, "icon-name");
break;
case TRG_COLTYPE_FILEICONTEXT:
column = trg_tree_view_fileicontext_column_new(desc);
break;
case TRG_COLTYPE_PRIO:
renderer = trg_cell_renderer_priority_new();
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"priority-value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_NUMGTZERO:
renderer = trg_cell_renderer_numgteqthan_new(1);
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"value",
desc->
model_column,
NULL);
break;
case TRG_COLTYPE_NUMGTEQZERO:
renderer = trg_cell_renderer_numgteqthan_new(0);
column = gtk_tree_view_column_new_with_attributes(desc->header,
renderer,
"value",
desc->
model_column,
NULL);
break;
default:
g_critical("unknown TrgTreeView column");
return;
}
//gtk_tree_view_column_set_min_width(column, 0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, desc->model_column);
gtk_tree_view_column_set_expand(column, TRUE);
/*gtk_tree_view_column_set_sizing(column,
GTK_TREE_VIEW_COLUMN_FIXED);*/
if (width > 0) {
//gtk_tree_view_column_set_fixed_width(column, width);
}
g_object_set_data(G_OBJECT(column), GDATA_KEY_COLUMN_DESC, desc);
gtk_tree_view_append_column(GTK_TREE_VIEW(tv), column);
if (after_col)
gtk_tree_view_move_column_after(GTK_TREE_VIEW(tv), column,
after_col);
column_button = GTK_BUTTON(gtk_tree_view_column_get_button(column));
g_signal_connect(column_button,
"button-press-event", G_CALLBACK(col_onButtonPressed),
desc);
if (desc->out)
*(desc->out) = column;
desc->flags |= TRG_COLUMN_SHOWING;
}
GtkWidget *
create_disk_view(ProcData *procdata)
{
GtkWidget *disk_box;
GtkWidget *label;
GtkWidget *scrolled;
GtkWidget *disk_tree;
GtkListStore *model;
GtkTreeViewColumn *col;
GtkCellRenderer *cell;
guint i;
const gchar * const titles[] = {
N_("Device"),
N_("Directory"),
N_("Type"),
N_("Total"),
N_("Free"),
N_("Available"),
N_("Used")
};
disk_box = gtk_vbox_new(FALSE, 6);
gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12);
label = make_title_label(_("File Systems"));
gtk_box_pack_start(GTK_BOX(disk_box), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(disk_box), scrolled, TRUE, TRUE, 0);
model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */
G_TYPE_STRING, /* DISK_DEVICE */
G_TYPE_STRING, /* DISK_DIR */
G_TYPE_STRING, /* DISK_TYPE */
G_TYPE_UINT64, /* DISK_TOTAL */
G_TYPE_UINT64, /* DISK_FREE */
G_TYPE_UINT64, /* DISK_AVAIL */
G_TYPE_UINT64, /* DISK_USED */
GDK_TYPE_PIXBUF, /* DISK_ICON */
G_TYPE_INT /* DISK_USED_PERCENTAGE */
);
disk_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL);
procdata->disk_list = disk_tree;
gtk_container_add(GTK_CONTAINER(scrolled), disk_tree);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(disk_tree), TRUE);
g_object_unref(G_OBJECT(model));
/* icon + device */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON,
NULL);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE,
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE]));
gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
/* sizes - used */
for (i = DISK_DIR; i <= DISK_AVAIL; i++) {
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_title(col, _(titles[i]));
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, i);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
switch (i) {
case DISK_TOTAL:
case DISK_FREE:
case DISK_AVAIL:
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_cell_data_func,
GUINT_TO_POINTER(i),
NULL);
break;
default:
gtk_tree_view_column_set_attributes(col, cell,
"text", i,
NULL);
break;
}
}
/* used + percentage */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_text_new();
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_cell_data_func,
GUINT_TO_POINTER(DISK_USED),
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_USED]));
cell = gtk_cell_renderer_progress_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_attributes(col, cell, "value",
DISK_USED_PERCENTAGE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, DISK_USED);
gtk_tree_view_column_set_reorderable(col, TRUE);
/* numeric sort */
gtk_widget_show_all(disk_box);
procman_get_tree_state(procdata->client, disk_tree,
"/apps/procman/disktreenew");
g_signal_connect (G_OBJECT(disk_tree), "columns-changed",
G_CALLBACK(cb_disk_columns_changed), procdata);
return disk_box;
}
/* main */
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *table;
GtkWidget *button;
GtkCellRenderer *cell;
Data data;
/* initialition */
gtk_init(&argc, &argv);
/* main window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "GtkComboBox");
gtk_widget_set_size_request(window, 640, 320);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
/* table */
table = gtk_table_new(4, 3, FALSE);
gtk_container_add(GTK_CONTAINER(window), table);
/* create combox box */
data.combo = gtk_combo_box_new();
g_signal_connect(data.combo, "changed", G_CALLBACK(cb_changed), &data);
gtk_table_attach(GTK_TABLE(table), data.combo, 0, 3, 0, 1,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
/* create data store */
data.store = create_model(&data);
/* add data store to combo box */
gtk_combo_box_set_model(GTK_COMBO_BOX(data.combo), data.store);
g_object_unref(data.store);
/* create pixbuf cell renderer */
cell = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(data.combo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(data.combo), cell,
"stock-id", PIXBUF_C,
"visible", PIXBUF_VIS_C,
NULL);
/* create text cell renderer */
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(data.combo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(data.combo), cell,
"text", TEXT_C,
"visible", TEXT_VIS_C,
"foreground", TEXT_COL_C,
NULL);
/* create progress cell renderer */
cell = gtk_cell_renderer_progress_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(data.combo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(data.combo), cell,
"value", PROGRESS_C,
"visible", PROGRESS_VIS_C,
NULL);
/* create check buttons for controling visibility */
data.vis_pixbuf = gtk_check_button_new_with_label("image visible");
gtk_table_attach(GTK_TABLE(table), data.vis_pixbuf, 0, 1, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
data.vis_text = gtk_check_button_new_with_label("text visible");
gtk_table_attach(GTK_TABLE(table), data.vis_text, 1, 2, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
data.vis_progress = gtk_check_button_new_with_label("progress visible");
gtk_table_attach(GTK_TABLE(table), data.vis_progress, 2, 3, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
/* create entries for modifying values */
data.e_pixbuf = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), data.e_pixbuf, 0, 1, 2, 3,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
data.e_text = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), data.e_text, 1, 2, 2, 3,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
data.e_progress = gtk_spin_button_new_with_range(0, 100, 1);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(data.e_progress), TRUE);
gtk_table_attach(GTK_TABLE(table), data.e_progress, 2, 3, 2, 3,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
/* create button for applying changes */
button = gtk_button_new_from_stock(GTK_STOCK_APPLY);
g_signal_connect(button, "clicked", G_CALLBACK(cb_clicked), &data);
gtk_table_attach(GTK_TABLE(table), button, 0, 3, 3, 4,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
/* manually call cb_changed function to set controllers to right state */
cb_changed(GTK_COMBO_BOX(data.combo), &data);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void
ft_manager_build_ui (EmpathyFTManager *manager)
{
GtkBuilder *gui;
GtkTreeView *view;
GtkListStore *liststore;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gchar *filename;
EmpathyFTManagerPriv *priv = GET_PRIV (manager);
filename = empathy_file_lookup ("empathy-ft-manager.ui", "src");
gui = tpaw_builder_get_file (filename,
"ft_manager_dialog", &priv->window,
"ft_list", &priv->treeview,
"clear_button", &priv->clear_button,
"open_button", &priv->open_button,
"abort_button", &priv->abort_button,
NULL);
g_free (filename);
tpaw_builder_connect (gui, manager,
"ft_manager_dialog", "destroy", ft_manager_destroy_cb,
"ft_manager_dialog", "response", ft_manager_response_cb,
"ft_manager_dialog", "delete-event", ft_manager_delete_event_cb,
"ft_manager_dialog", "key-press-event", ft_manager_key_press_event_cb,
NULL);
tpaw_builder_unref_and_keep_widget (gui, priv->window);
/* Window geometry. */
empathy_geometry_bind (GTK_WINDOW (priv->window), "ft-manager");
/* Setup the tree view */
view = GTK_TREE_VIEW (priv->treeview);
selection = gtk_tree_view_get_selection (view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed",
G_CALLBACK (ft_manager_selection_changed), manager);
g_signal_connect (view, "button-press-event",
G_CALLBACK (ft_view_button_press_event_cb),
manager);
gtk_tree_view_set_headers_visible (view, TRUE);
gtk_tree_view_set_enable_search (view, FALSE);
/* Setup the model */
liststore = gtk_list_store_new (5,
G_TYPE_INT, /* percent */
G_TYPE_ICON, /* icon */
G_TYPE_STRING, /* message */
G_TYPE_STRING, /* remaining */
G_TYPE_OBJECT); /* ft_handler */
gtk_tree_view_set_model (view, GTK_TREE_MODEL (liststore));
priv->model = GTK_TREE_MODEL (liststore);
g_object_unref (liststore);
/* Progress column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("%"));
gtk_tree_view_column_set_sort_column_id (column, COL_PERCENT);
gtk_tree_view_insert_column (view, column, -1);
renderer = gtk_cell_renderer_progress_new ();
g_object_set (renderer, "xalign", 0.5, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer,
ft_manager_progress_cell_data_func, NULL, NULL);
/* Icon and filename column*/
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("File"));
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, COL_MESSAGE);
gtk_tree_view_column_set_spacing (column, 3);
gtk_tree_view_insert_column (view, column, -1);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "xpad", 3,
"stock-size", GTK_ICON_SIZE_DND, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"gicon", COL_ICON, 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", COL_MESSAGE, NULL);
/* Remaining time column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Remaining"));
gtk_tree_view_column_set_sort_column_id (column, COL_REMAINING);
gtk_tree_view_insert_column (view, column, -1);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.5, NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COL_REMAINING, NULL);
/* clear button should be sensitive only if there are completed/cancelled
* handlers in the store.
*/
gtk_widget_set_sensitive (priv->clear_button, FALSE);
}
void
create_disk_view(GsmApplication *app, GtkBuilder *builder)
{
GtkScrolledWindow *scrolled;
GsmTreeView *disk_tree;
GtkListStore *model;
GtkTreeViewColumn *col;
GtkCellRenderer *cell;
guint i;
init_volume_monitor (app);
const gchar * const titles[] = {
N_("Device"),
N_("Directory"),
N_("Type"),
N_("Total"),
N_("Free"),
N_("Available"),
N_("Used")
};
scrolled = GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "disks_scrolled"));
model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */
G_TYPE_STRING, /* DISK_DEVICE */
G_TYPE_STRING, /* DISK_DIR */
G_TYPE_STRING, /* DISK_TYPE */
G_TYPE_UINT64, /* DISK_TOTAL */
G_TYPE_UINT64, /* DISK_FREE */
G_TYPE_UINT64, /* DISK_AVAIL */
G_TYPE_UINT64, /* DISK_USED */
GDK_TYPE_PIXBUF, /* DISK_ICON */
G_TYPE_INT /* DISK_USED_PERCENTAGE */
);
disk_tree = gsm_tree_view_new (g_settings_get_child (app->settings->gobj(), GSM_SETTINGS_CHILD_DISKS), TRUE);
gtk_tree_view_set_model (GTK_TREE_VIEW (disk_tree), GTK_TREE_MODEL (model));
g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL);
app->disk_list = disk_tree;
gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET (disk_tree));
g_object_unref(G_OBJECT(model));
/* icon + device */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON,
NULL);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE,
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE]));
gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col);
/* sizes - used */
for (i = DISK_DIR; i <= DISK_AVAIL; i++) {
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_title(col, _(titles[i]));
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, i);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col);
switch (i) {
case DISK_TOTAL:
case DISK_FREE:
case DISK_AVAIL:
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_si_cell_data_func,
GUINT_TO_POINTER(i),
NULL);
break;
default:
gtk_tree_view_column_set_attributes(col, cell,
"text", i,
NULL);
break;
}
}
/* used + percentage */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_text_new();
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_si_cell_data_func,
GUINT_TO_POINTER(DISK_USED),
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_USED]));
cell = gtk_cell_renderer_progress_new();
gtk_cell_renderer_set_padding(cell, 4.0f, 4.0f);
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_attributes(col, cell, "value",
DISK_USED_PERCENTAGE, NULL);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_sort_column_id(col, DISK_USED);
gtk_tree_view_column_set_reorderable(col, TRUE);
gsm_tree_view_append_and_bind_column (GSM_TREE_VIEW (disk_tree), col);
/* numeric sort */
gsm_tree_view_load_state (GSM_TREE_VIEW (disk_tree));
g_signal_connect (G_OBJECT(disk_tree), "destroy",
G_CALLBACK(cb_disk_list_destroying),
app);
g_signal_connect (G_OBJECT(disk_tree), "columns-changed",
G_CALLBACK(cb_disk_columns_changed), app);
g_signal_connect (G_OBJECT (model), "sort-column-changed",
G_CALLBACK (cb_sort_changed), app);
app->settings->signal_changed(GSM_SETTING_SHOW_ALL_FS).connect ([app](const Glib::ustring&) { disks_update (app); disks_reset_timeout (app); });
gtk_widget_show (GTK_WIDGET (disk_tree));
}
static void remmina_ftp_client_init(RemminaFTPClient *client)
{
RemminaFTPClientPriv *priv;
GtkWidget *vpaned;
GtkWidget *scrolledwindow;
GtkWidget *widget;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *vbox;
priv = g_new0(RemminaFTPClientPriv, 1);
client->priv = priv;
/* Main container */
gtk_box_set_homogeneous(GTK_BOX(client), FALSE);
gtk_box_set_spacing(GTK_BOX(client), 4);
/* Toolbar */
remmina_ftp_client_create_toolbar(client);
/* The Paned to separate File List and Task List */
#if GTK_VERSION == 3
vpaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
#elif GTK_VERSION == 2
vpaned = gtk_vpaned_new();
#endif
gtk_widget_show(vpaned);
gtk_box_pack_start(GTK_BOX(client), vpaned, TRUE, TRUE, 0);
priv->vpaned = vpaned;
/* Remote */
#if GTK_VERSION == 3
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#elif GTK_VERSION == 2
vbox = gtk_vbox_new(FALSE, 0);
#endif
gtk_widget_show(vbox);
gtk_paned_pack1(GTK_PANED(vpaned), vbox, TRUE, FALSE);
/* Remote Directory */
widget = gtk_combo_box_text_new_with_entry();
gtk_widget_show(widget);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "/");
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
priv->directory_combo = widget;
/* Remote File List */
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
widget = gtk_tree_view_new();
gtk_widget_show(widget);
gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)), GTK_SELECTION_MULTIPLE);
priv->file_list_view = widget;
/* Remote File List - Columns */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("File Name"));
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_NAME_SORT);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size, NULL, NULL);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_SIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("User"), renderer, "text", REMMINA_FTP_FILE_COLUMN_USER, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_USER);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", REMMINA_FTP_FILE_COLUMN_GROUP, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_GROUP);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Permission"), renderer, "text", REMMINA_FTP_FILE_COLUMN_PERMISSION,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_permission, NULL, NULL);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_PERMISSION);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column);
/* Remote File List - Model */
priv->file_list_model = GTK_TREE_MODEL(
gtk_list_store_new(REMMINA_FTP_FILE_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING));
priv->file_list_filter = gtk_tree_model_filter_new(priv->file_list_model, NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(priv->file_list_filter),
(GtkTreeModelFilterVisibleFunc) remmina_ftp_client_filter_visible_func, client, NULL);
priv->file_list_sort = gtk_tree_model_sort_new_with_model(priv->file_list_filter);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(priv->file_list_sort), REMMINA_FTP_FILE_COLUMN_NAME_SORT,
GTK_SORT_ASCENDING);
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->file_list_view), priv->file_list_sort);
/* Task List */
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_paned_pack2(GTK_PANED(vpaned), scrolledwindow, FALSE, TRUE);
widget = gtk_tree_view_new();
gtk_widget_show(widget);
gtk_container_add(GTK_CONTAINER(scrolledwindow), widget);
g_object_set(widget, "has-tooltip", TRUE, NULL);
priv->task_list_view = widget;
/* Task List - Columns */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("File Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_NAME);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress_pixbuf, NULL, NULL);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Remote"), renderer, "text", REMMINA_FTP_TASK_COLUMN_REMOTEDIR,
NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_REMOTEDIR);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Local"), renderer, "text", REMMINA_FTP_TASK_COLUMN_LOCALDIR, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_LOCALDIR);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size_progress, NULL, NULL);
gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_SIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = gtk_cell_renderer_progress_new();
column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress, NULL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
renderer = remmina_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(NULL, renderer, NULL);
g_object_set(G_OBJECT(renderer), "stock-id", "_Cancel", NULL);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column);
g_signal_connect(G_OBJECT(renderer), "activate", G_CALLBACK(remmina_ftp_client_task_list_cell_on_activate), client);
/* Task List - Model */
priv->task_list_model = GTK_TREE_MODEL(
gtk_list_store_new(REMMINA_FTP_TASK_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT,
G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_STRING));
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->task_list_view), priv->task_list_model);
/* Setup the internal signals */
g_signal_connect(G_OBJECT(client), "destroy", G_CALLBACK(remmina_ftp_client_destroy), NULL);
g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(priv->directory_combo))), "activate",
G_CALLBACK(remmina_ftp_client_dir_on_activate), client);
g_signal_connect(G_OBJECT(priv->directory_combo), "changed", G_CALLBACK(remmina_ftp_client_dir_on_changed), client);
g_signal_connect(G_OBJECT(priv->file_list_view), "button-press-event",
G_CALLBACK(remmina_ftp_client_file_list_on_button_press), client);
g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view))), "changed",
G_CALLBACK(remmina_ftp_client_file_selection_on_changed), client);
g_signal_connect(G_OBJECT(priv->task_list_view), "query-tooltip",
G_CALLBACK(remmina_ftp_client_task_list_on_query_tooltip), client);
}
static void serverstats_init(void)
{
/** Get an allready exposed widgets to grab theme colors from. */
GtkWidget *colw = (GtkWidget *) playlist3_get_category_tree_view();
GtkWidget *label = NULL;
GtkWidget *table = NULL;
GtkWidget *hbox = NULL;
GtkWidget *event = NULL;
GtkWidget *serverstats_vbox = gtk_vbox_new(FALSE, 0);
GtkWidget *serverstats_event;
gchar *markup = NULL;
int i = 0;
serverstats_sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(serverstats_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
serverstats_event = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(serverstats_event), TRUE);
gtk_container_add(GTK_CONTAINER(serverstats_event), serverstats_vbox);
{
GtkStyleContext *cs = gtk_widget_get_style_context(GTK_WIDGET(serverstats_event));
gtk_style_context_add_class(cs, GTK_STYLE_CLASS_VIEW);
}
/* wrap in event box to set bg color */
event = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), TRUE);
//gtk_widget_set_state(GTK_WIDGET(event), GTK_STATE_SELECTED);
{
GtkStyleContext *cs = gtk_widget_get_style_context(GTK_WIDGET(serverstats_event));
gtk_style_context_add_class(cs, GTK_STYLE_CLASS_HEADER);
}
//gtk_widget_modify_bg(serverstats_event, GTK_STATE_NORMAL, &(colw->style->base[GTK_STATE_NORMAL]));
g_signal_connect(G_OBJECT(serverstats_vbox), "style-set", G_CALLBACK(serverstats_header_style_changed),
serverstats_event);
/* set label and padding */
hbox = gtk_hbox_new(FALSE, 6);
label = gtk_image_new_from_icon_name("mpd", GTK_ICON_SIZE_DND);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='xx-large' weight='bold'>%s</span>", _("Server Information"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(event), hbox);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
gtk_box_pack_start(GTK_BOX(serverstats_vbox), event, FALSE, TRUE, 0);
gtk_widget_show_all(event);
label = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(serverstats_vbox), label, FALSE, TRUE, 0);
gtk_widget_show(label);
/**
* Data list
*/
table = gtk_grid_new();//(SERVERSTATS_NUM_FIELDS + 2, 2, FALSE);
gtk_grid_set_column_spacing(GTK_GRID(table), 6);
gtk_grid_set_row_spacing(GTK_GRID(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 12);
/** Database */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Server"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_grid_attach(GTK_GRID(table), label, 0,0,2,1);
i = 1;
/** Mpd version */
serverstats_add_entry(table, i++, _("Version"), SERVERSTATS_MPD_VERSION);
serverstats_add_entry(table, i++, _("Uptime"), SERVERSTATS_MPD_UPTIME);
serverstats_add_entry(table, i++, _("Time Playing"), SERVERSTATS_MPD_PLAYTIME);
/** Database */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Database"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_grid_attach(GTK_GRID(table), label, 0, i, 2, 1);
i++;
/** Mpd Playtime */
serverstats_add_entry(table, i++, _("Total Playtime"), SERVERSTATS_MPD_DB_PLAYTIME);
/** Mpd Artists*/
serverstats_add_entry(table, i++, _("Number of artists"), SERVERSTATS_MPD_DB_ARTISTS);
/** Mpd Albums */
serverstats_add_entry(table, i++, _("Number of albums"), SERVERSTATS_MPD_DB_ALBUMS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("Number of songs"), SERVERSTATS_MPD_DB_SONGS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("URL Handlers"), SERVERSTATS_MPD_URLHANDLERS);
/** Mpd Songs */
serverstats_add_entry(table, i++, _("Tag Types"), SERVERSTATS_MPD_TAG_TYPES);
/** Stats */
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
markup = g_markup_printf_escaped("<span size='x-large' weight='bold'>%s</span>", _("Tag statistics"));
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_grid_attach(GTK_GRID(table), label, 0, i, 2, 1);
i++;
gtk_widget_show_all(table);
/**
* Stats treeview
*/
{
int j;
GtkWidget *combo = NULL;
GtkWidget *sw = NULL, *cancel;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkWidget *pb = gtk_progress_bar_new();
combo = gtk_combo_box_text_new();
for (j = 0; j < MPD_TAG_NUM_OF_ITEM_TYPES - 1; j++)
{
if (mpd_server_tag_supported(connection, j))
{
gtk_combo_box_text_append(GTK_COMBO_BOX(combo),NULL, mpdTagItemKeys[j]);
}
}
gtk_grid_attach(GTK_GRID(table), combo, 0, i, 2, 1);
i++;
gtk_widget_show(combo);
hbox = gtk_hbox_new(FALSE, 6);
cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect(G_OBJECT(cancel), "clicked", G_CALLBACK(cancel_clicked), NULL);
gtk_box_pack_start(GTK_BOX(hbox), pb, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), cancel, FALSE, TRUE, 0);
gtk_grid_attach(GTK_GRID(table), hbox, 0, i, 2, 1);
i++;
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(serverstats_combo_changed), pb);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
gtk_container_set_border_width(GTK_CONTAINER(sw), 6);
store = gtk_list_store_new(4, G_TYPE_ULONG, G_TYPE_STRING, G_TYPE_ULONG, G_TYPE_STRING);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), 0, GTK_SORT_DESCENDING);
serverstats_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(serverstats_tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(serverstats_tree), TRUE);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, "width-chars", 30,
NULL);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree), -1, "", renderer, "text", 1, NULL);
renderer = gtk_cell_renderer_progress_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(serverstats_tree),
-1, "", renderer, "value", 2, "text", 3, NULL);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(serverstats_tree), 1);
gtk_container_add(GTK_CONTAINER(sw), serverstats_tree);
gtk_grid_attach(GTK_GRID(table), sw, 0, i, 2, 1);
i++;
gtk_widget_show_all(sw);
}
/**
* Add table
*/
gtk_box_pack_start(GTK_BOX(serverstats_vbox), table, TRUE, TRUE, 0);
/* maintain my own reference to the widget, so it won't get destroyed removing
* from view
*/
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(serverstats_sw), serverstats_event);
gtk_widget_show(serverstats_vbox);
gtk_widget_show(serverstats_event);
gtk_widget_show(serverstats_sw);
g_object_ref_sink(serverstats_sw);
}
