static void
gtk_tree_view_column_queue_resize( GtkTreeViewColumn * column ) /* yuck */
{
const int spacing = gtk_tree_view_column_get_spacing( column );
gtk_tree_view_column_set_spacing( column, spacing + 1 );
gtk_tree_view_column_set_spacing( column, spacing );
}
// 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
panda_clist_build_children (GladeXML *xml, GtkWidget *w, GladeWidgetInfo *info,
const char *longname)
{
GList *tmp;
GtkTreeViewColumn *column;
gint col = 0;
for (tmp = info->children; tmp; tmp = tmp->next) {
GtkWidget *child = glade_xml_build_widget (xml, tmp->data,
longname);
gtk_widget_show(child);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(w), col);
gtk_tree_view_column_set_widget(column, child);
if (GTK_IS_MISC(child)) {
gtk_tree_view_column_set_alignment(column, GTK_MISC(child)->xalign);
gtk_misc_set_padding(GTK_MISC(child),0,0);
}
gtk_tree_view_column_set_clickable(column, FALSE);
gtk_tree_view_column_set_spacing(column,0);
if (!GTK_PANDA_CLIST(w)->show_titles) {
gtk_widget_hide(child);
}
col++;
}
}
// Create and bind the tree model to the tree view for the audio track list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_audio_tree_model(signal_user_data_t *ud)
{
GtkCellRenderer *source_cell;
GtkCellRenderer *arrow_cell;
GtkCellRenderer *output_cell;
GtkCellRenderer *edit_cell;
GtkCellRenderer *delete_cell;
GtkTreeViewColumn *column;
GtkTreeStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
g_debug("bind_audio_tree_model()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list_view"));
selection = gtk_tree_view_get_selection(treeview);
treestore = gtk_tree_store_new(6, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_FLOAT);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
source_cell = gtk_cell_renderer_text_new();
arrow_cell = gtk_cell_renderer_text_new();
output_cell = gtk_cell_renderer_text_new();
edit_cell = custom_cell_renderer_button_new();
delete_cell = custom_cell_renderer_button_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_spacing(column, 12);
gtk_tree_view_column_set_title(column, _("Track Information"));
gtk_tree_view_column_pack_start(column, source_cell, FALSE);
gtk_tree_view_column_add_attribute(column, source_cell, "markup", 0);
gtk_tree_view_column_add_attribute(column, source_cell, "yalign", 5);
gtk_tree_view_column_pack_start(column, arrow_cell, FALSE);
gtk_tree_view_column_add_attribute(column, arrow_cell, "text", 1);
gtk_tree_view_column_pack_start(column, output_cell, TRUE);
gtk_tree_view_column_add_attribute(column, output_cell, "markup", 2);
gtk_tree_view_column_add_attribute(column, output_cell, "yalign", 5);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_column_set_max_width(column, 400);
column = gtk_tree_view_column_new_with_attributes(
_(""), edit_cell, "icon-name", 3, NULL);
//gtk_tree_view_column_set_min_width(column, 24);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
column = gtk_tree_view_column_new_with_attributes(
_(""), delete_cell, "icon-name", 4, NULL);
//gtk_tree_view_column_set_min_width(column, 24);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(selection, "changed", audio_list_selection_changed_cb, ud);
g_signal_connect(edit_cell, "clicked", audio_edit_clicked_cb, ud);
g_signal_connect(delete_cell, "clicked", audio_remove_clicked_cb, ud);
g_debug("Done\n");
}
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;
}
GtkWidget* create_i2c_view()
{
int i = 0;
int loc_i;
int num_cols = I2C_NUM_COLS + mix_number_of_i2c_headers() - 1;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *view;
view = gtk_tree_view_new();
// --- Column #X ---
while(i < num_cols) {
col = gtk_tree_view_column_new();
loc_i = i > I2C_B ? I2C_B : i;
gtk_tree_view_column_set_spacing(col, 1);
gtk_tree_view_column_set_title(col, header[loc_i].title);
// pack tree view column into tree view
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "editable", header[loc_i].editable, NULL);
g_object_set_data(G_OBJECT(renderer), "column_index", GUINT_TO_POINTER(i));
g_signal_connect(renderer, "edited", (GCallback) i2c_edited_callback, NULL);
// pack cell renderer into tree view column
gtk_tree_view_column_pack_start(col, renderer, TRUE);
// connect 'text' property of the cell renderer to
// model column that contains the first name
gtk_tree_view_column_add_attribute(col, renderer, header[loc_i].type, i);
i++;
}
i2c_model = (GtkTreeModel*) create_i2c_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(view), i2c_model);
g_object_unref(i2c_model); // destroy model automatically with view
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(view), TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE);
return view;
}
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));
}
void
skin_view_realize(GtkTreeView * treeview)
{
GtkListStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gtk_widget_show_all(GTK_WIDGET(treeview));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
store = gtk_list_store_new(SKIN_VIEW_N_COLS, GDK_TYPE_PIXBUF,
G_TYPE_STRING , G_TYPE_STRING);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(store));
g_object_unref (store);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_spacing(column, 16);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview),
GTK_TREE_VIEW_COLUMN(column));
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer, "pixbuf",
SKIN_VIEW_COL_PREVIEW, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer, "markup",
SKIN_VIEW_COL_FORMATTEDNAME, NULL);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(treeview, "cursor-changed",
G_CALLBACK(skin_view_on_cursor_changed), NULL);
}
static void foldersel_create(void)
{
GtkWidget *vbox;
GtkWidget *scrolledwin;
GtkWidget *confirm_area;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
static GdkGeometry geometry;
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "foldersel");
gtk_window_set_title(GTK_WINDOW(window), _("Select folder"));
gtk_container_set_border_width(GTK_CONTAINER(window), 4);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
gtk_widget_realize(window);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(delete_event), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(key_pressed), NULL);
g_signal_connect(G_OBJECT(window), "size_allocate",
G_CALLBACK(foldersel_size_allocate_cb), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(window), vbox);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
tree_store = gtk_tree_store_new(N_FOLDERSEL_COLUMNS,
G_TYPE_STRING,
G_TYPE_POINTER,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_COLOR,
G_TYPE_INT);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(tree_store),
FOLDERSEL_FOLDERNAME,
foldersel_folder_name_compare,
NULL, NULL);
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_store));
g_object_unref(G_OBJECT(tree_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview),
prefs_common.use_stripes_everywhere);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview),
FOLDERSEL_FOLDERNAME);
if (prefs_common.folder_search_wildcard)
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeview),
foldersel_search_name_func, NULL, NULL);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection, foldersel_selected,
NULL, NULL);
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(foldersel_tree_activated), NULL);
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_spacing(column, 2);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes
(column, renderer,
"pixbuf", FOLDERSEL_PIXBUF,
"pixbuf-expander-open", FOLDERSEL_PIXBUF_OPEN,
"pixbuf-expander-closed", FOLDERSEL_PIXBUF,
NULL);
/* create text renderer */
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes
(column, renderer,
"text", FOLDERSEL_FOLDERNAME,
"foreground-gdk", FOLDERSEL_FOREGROUND,
"weight", FOLDERSEL_BOLD,
NULL);
g_object_set(G_OBJECT(renderer), "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
entry = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(entry), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(entry), "activate",
G_CALLBACK(foldersel_entry_activated), NULL);
gtkut_stock_button_set_create(&confirm_area,
&new_button, GTK_STOCK_NEW,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(foldersel_ok), NULL);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(foldersel_cancel), NULL);
g_signal_connect(G_OBJECT(new_button), "clicked",
G_CALLBACK(foldersel_new_folder), NULL);
if (!geometry.min_height) {
geometry.min_width = 300;
geometry.min_height = 360;
}
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_widget_set_size_request(window, prefs_common.folderselwin_width,
prefs_common.folderselwin_height);
gtk_widget_show_all(vbox);
}
void
pragha_filter_dialog (PraghaPlaylist *playlist)
{
PraghaPreferences *preferences;
GtkWidget *dialog, *scrollwin, *vbox, *search_entry;
GtkWidget *filter_view = NULL;
GtkListStore *filter_store;
GtkTreeModel *filter_model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
PraghaFilterDialog *fdialog;
fdialog = g_slice_new0(PraghaFilterDialog);
preferences = pragha_preferences_get ();
/* Crete the filter entry */
search_entry = pragha_search_entry_new(preferences);
g_signal_connect (G_OBJECT(search_entry), "changed",
G_CALLBACK(simple_filter_search_keyrelease_handler), fdialog);
g_signal_connect (G_OBJECT(search_entry), "activate",
G_CALLBACK(simple_filter_search_activate_handler), fdialog);
/* Create the view */
filter_store = gtk_list_store_new (2, G_TYPE_UINT, G_TYPE_STRING);
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer, "text", 0, NULL);
gtk_tree_view_column_set_spacing (column, 4);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer, "markup", 1, NULL);
gtk_tree_view_column_set_spacing (column, 4);
/* Fill the filter tree view with current playlist */
pragha_filter_dialog_fill_model (filter_store, playlist);
filter_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(filter_store), NULL);
g_object_unref(filter_store);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model),
(GtkTreeModelFilterVisibleFunc)filter_model_visible_func,
fdialog,
NULL);
/* Create the tree view */
filter_view = gtk_tree_view_new_with_model(filter_model);
gtk_tree_view_append_column (GTK_TREE_VIEW(filter_view), column);
g_object_unref(G_OBJECT(filter_model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(filter_view), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(filter_view), FALSE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW(filter_view), FALSE);
/* Store references */
fdialog->filter_view = filter_view;
fdialog->filter_model = filter_model;
fdialog->filter_string = NULL;
fdialog->timeout_id = 0;
fdialog->cplaylist = playlist;
fdialog->preferences = preferences;
/* The search dialog */
dialog = gtk_dialog_new_with_buttons (_("Search in playlist"),
GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(playlist))),
GTK_DIALOG_MODAL,
_("_Close"), GTK_RESPONSE_CANCEL,
NULL);
gtk_dialog_add_button (GTK_DIALOG (dialog), _("Add to playback queue"), GTK_RESPONSE_ACCEPT);
gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Jump to"), GTK_RESPONSE_APPLY);
gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 500);
/* Add to the dialog's main vbox */
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start (GTK_BOX(vbox), search_entry, FALSE, FALSE, 3);
scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER(scrollwin), filter_view);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrollwin),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
/* Connect signals */
g_signal_connect (filter_view, "row-activated",
G_CALLBACK(pragha_filter_dialog_activated_cb), dialog);
g_signal_connect (filter_view, "key_press_event",
G_CALLBACK (pragha_filter_dialog_key_press), fdialog);
g_signal_connect(G_OBJECT(dialog), "response",
G_CALLBACK(pragha_filter_dialog_response), fdialog);
gtk_widget_show_all (dialog);
}
static VALUE
tvc_set_spacing(VALUE self, VALUE spacing)
{
gtk_tree_view_column_set_spacing(_SELF(self), NUM2INT(spacing));
return self;
}
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);
}
static void
roster_view_gtk_init (G_GNUC_UNUSED RosterViewGtk* self)
{
GtkWidget *scrolled_window;
GtkWidget *vbox = NULL;
GtkTreeModel *filtered = NULL;
GtkTreeSelection *selection = NULL;
GtkTreeViewColumn *col = NULL;
GtkCellRenderer *renderer = NULL;
self->priv = new RosterViewGtkPrivate;
self->priv->folded_groups = gm_conf_get_string_list (CONTACTS_KEY "roster_folded_groups");
self->priv->show_offline_contacts = gm_conf_get_bool (CONTACTS_KEY "show_offline_contacts");
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 0);
gtk_frame_set_shadow_type (GTK_FRAME (self), GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
self->priv->store = gtk_tree_store_new (COLUMN_NUMBER,
G_TYPE_INT, // type
G_TYPE_POINTER, // heap
G_TYPE_POINTER, // presentity
G_TYPE_STRING, // name
G_TYPE_STRING, // status
G_TYPE_STRING, // presence
G_TYPE_STRING, // color if active
G_TYPE_STRING, // group name (invisible)
G_TYPE_STRING, // presence
G_TYPE_BOOLEAN, // offline
G_TYPE_INT); // timeout source
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->store),
COLUMN_NAME, GTK_SORT_ASCENDING);
filtered = gtk_tree_model_filter_new (GTK_TREE_MODEL (self->priv->store),
NULL);
g_object_unref (self->priv->store);
self->priv->tree_view =
GTK_TREE_VIEW (gtk_tree_view_new_with_model (filtered));
g_object_unref (filtered);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filtered),
tree_model_filter_hide_show_offline,
self, NULL);
gtk_tree_view_set_headers_visible (self->priv->tree_view, FALSE);
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (vbox));
gtk_box_pack_start (GTK_BOX (vbox),
GTK_WIDGET (scrolled_window), TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (scrolled_window),
GTK_WIDGET (self->priv->tree_view));
/* Build the GtkTreeView */
// We hide the normal GTK+ expanders and use our own
col = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_set_spacing (col, 0);
gtk_tree_view_column_pack_start (col, renderer, TRUE);
g_object_set (col, "visible", FALSE, NULL);
gtk_tree_view_append_column (self->priv->tree_view, col);
gtk_tree_view_set_expander_column (self->priv->tree_view, col);
col = gtk_tree_view_column_new ();
renderer = gm_cell_renderer_expander_new ();
gtk_tree_view_column_pack_start (col, renderer, FALSE);
g_object_set (renderer,
"xalign", 0.0,
"xpad", 0,
"ypad", 0,
"visible", TRUE,
"expander-style", GTK_EXPANDER_COLLAPSED,
NULL);
gtk_tree_view_column_set_cell_data_func (col, renderer, expand_cell_data_func, NULL, NULL);
gtk_tree_view_append_column (self->priv->tree_view, col);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_set_spacing (col, 0);
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer, "text", COLUMN_NAME);
gtk_tree_view_column_set_alignment (col, 0.0);
g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL);
g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_set_cell_data_func (col, renderer,
show_cell_data_func, GINT_TO_POINTER (TYPE_HEAP), NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, renderer, TRUE);
gtk_tree_view_column_add_attribute (col, renderer,
"text", COLUMN_NAME);
g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_set_cell_data_func (col, renderer,
show_cell_data_func, GINT_TO_POINTER (TYPE_GROUP), NULL);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer,
"icon-name",
COLUMN_PRESENCE_ICON);
gtk_tree_view_column_set_cell_data_func (col, renderer,
show_cell_data_func, GINT_TO_POINTER (TYPE_PRESENTITY), NULL);
renderer = gm_cell_renderer_bitext_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, "width-chars", 30, NULL);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer, "primary-text", COLUMN_NAME);
gtk_tree_view_column_add_attribute (col, renderer, "secondary-text", COLUMN_STATUS);
gtk_tree_view_column_add_attribute (col, renderer, "foreground", COLUMN_ACTIVE);
gtk_tree_view_column_set_cell_data_func (col, renderer,
show_cell_data_func, GINT_TO_POINTER (TYPE_PRESENTITY), NULL);
/* Callback when the selection has been changed */
selection = gtk_tree_view_get_selection (self->priv->tree_view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (on_selection_changed), self);
g_signal_connect (self->priv->tree_view, "event-after",
G_CALLBACK (on_view_event_after), self);
/* Notifiers */
self->priv->notifier =
gm_conf_notifier_add (CONTACTS_KEY "show_offline_contacts",
show_offline_contacts_changed_nt, self);
}
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;
}
static void
heap_view_init (HeapView* self)
{
GtkTreeViewColumn* col = NULL;
GtkCellRenderer* renderer = NULL;
GtkTreeSelection* selection = NULL;
self->priv = g_new0 (HeapViewPrivate, 1);
/* prepare the store */
self->priv->store = gtk_tree_store_new (COLUMN_NUMBER,
G_TYPE_INT, // type
G_TYPE_POINTER, // presentity
G_TYPE_STRING, // name
G_TYPE_STRING, // status
G_TYPE_STRING); // presence
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->store),
COLUMN_NAME, GTK_SORT_ASCENDING);
/* prepare the view */
self->priv->view = GTK_TREE_VIEW (gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->store)));
g_object_unref (self->priv->store);
gtk_tree_view_set_headers_visible (self->priv->view, FALSE);
/* show the name of a group */
col = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_set_spacing (col, 0);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer, "text", COLUMN_NAME);
gtk_tree_view_column_set_alignment (col, 0.0);
g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL);
g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_append_column (self->priv->view, col);
gtk_tree_view_column_set_cell_data_func (col, renderer,
hide_show_depending_on_type,
GINT_TO_POINTER (TYPE_GROUP), NULL);
/* show the name+status of a presentity */
col = gtk_tree_view_column_new ();
renderer = gm_cell_renderer_bitext_new ();
gtk_tree_view_column_set_spacing (col, 0);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer, "primary-text", COLUMN_NAME);
gtk_tree_view_column_add_attribute (col, renderer, "secondary-text", COLUMN_STATUS);
gtk_tree_view_column_set_alignment (col, 0.0);
g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL);
gtk_tree_view_append_column (self->priv->view, col);
gtk_tree_view_column_set_cell_data_func (col, renderer,
hide_show_depending_on_type,
GINT_TO_POINTER (TYPE_PRESENTITY), NULL);
/* show the presence of a presentity */
col = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL);
gtk_tree_view_column_pack_start (col, renderer, FALSE);
gtk_tree_view_column_add_attribute (col, renderer,
"stock-id",
COLUMN_PRESENCE);
gtk_tree_view_append_column (self->priv->view, col);
gtk_tree_view_column_set_cell_data_func (col, renderer,
hide_show_depending_on_type,
GINT_TO_POINTER (TYPE_PRESENTITY), NULL);
/* notify when the selection changed */
selection = gtk_tree_view_get_selection (self->priv->view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed", G_CALLBACK (on_selection_changed), self);
/* show a popup menu when right-click */
g_signal_connect (self->priv->view, "event-after", G_CALLBACK (on_right_click_in_the_view), self);
}
static GtkWidget *
create_treeview (BluetoothChooser *self)
{
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
GtkWidget *scrolled, *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/* Create the scrolled window */
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_OUT);
/* Create the tree view */
tree = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(tree), TRUE);
g_object_set (tree, "show-expanders", FALSE, NULL);
g_signal_connect (G_OBJECT (tree), "row-activated",
G_CALLBACK (row_activated_cb), self);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Device"));
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN(column), TRUE);
/* The type icon */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_set_spacing (column, 4);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"icon-name", BLUETOOTH_COLUMN_ICON, NULL);
/* The device name */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_cell_data_func (column, renderer,
alias_to_label, NULL, NULL);
/* The connected icon */
priv->connected_cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, priv->connected_cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, priv->connected_cell,
connected_to_icon, NULL, NULL);
g_object_set (G_OBJECT (priv->connected_cell), "visible", priv->show_connected, NULL);
/* The bonded icon */
priv->bonded_cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_end (column, priv->bonded_cell, FALSE);
gtk_tree_view_column_set_cell_data_func (column, priv->bonded_cell,
bonded_to_icon, NULL, NULL);
g_object_set (G_OBJECT (priv->bonded_cell), "visible", priv->show_paired, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW(tree), -1,
_("Type"), gtk_cell_renderer_text_new(),
type_to_text, NULL, NULL);
priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode (priv->selection, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT(priv->selection), "changed",
G_CALLBACK(select_browse_device_callback), self);
/* Set the model, and filter */
priv->model = bluetooth_client_get_device_model (priv->client);
if (priv->model) {
priv->filter = gtk_tree_model_filter_new (priv->model, NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->filter),
filter_func, self, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW(tree), priv->filter);
g_signal_connect (priv->filter, "row-changed",
G_CALLBACK (device_model_row_changed), self);
g_object_unref (priv->filter);
} else {
gtk_widget_set_sensitive (GTK_WIDGET (tree), FALSE);
set_search_label (self, FALSE);
}
gtk_container_add (GTK_CONTAINER(scrolled), tree);
priv->treeview = tree;
return scrolled;
}
extern "C" int addToGui(gpointer data)
{
plugData* plugdata=(plugData*)data;
GtkTreeViewColumn* column;
GtkTreeModel* model=NULL;
GtkCellRenderer* renderer;
GtkTreeIter iter;
GtkWidget* menu;
setTextDomain(true,plugdata);
menu=gtk_menu_item_get_submenu((GtkMenuItem*)plugdata->mlist.menuView);
hideMenu=gtk_menu_item_new_with_label(gettext("Hide Browser"));
g_signal_connect(G_OBJECT(hideMenu),"activate",G_CALLBACK(toggleBrowser),plugdata);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),hideMenu);
gtk_widget_show_all(plugdata->mlist.menuView);
store=gtk_tree_store_new(NUM_COLUMNS,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING);
addFolderContents("/",&iter,true);
model=GTK_TREE_MODEL(store);
treeview=gtk_tree_view_new_with_model(model);
gtk_tree_view_set_enable_tree_lines((GtkTreeView*)treeview,true);
scrollbox=gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrollbox,GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrollbox),(GtkWidget*)treeview);
gtk_box_pack_start((GtkBox*)plugdata->leftUserBox,scrollbox,true,true,0);
gtk_widget_show_all(plugdata->leftUserBox);
gtk_widget_set_size_request((GtkWidget*)scrollbox,100,-1);
//pixbuf
renderer=gtk_cell_renderer_pixbuf_new();
column=gtk_tree_view_column_new_with_attributes("path",renderer,"pixbuf",COLUMN_PIXBUF,NULL);
gtk_tree_view_column_set_resizable(column,false);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column((GtkTreeView*)treeview,column);
gtk_tree_view_column_set_spacing(column,0);
gtk_tree_view_column_set_expand(column,false);
//colom file
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(NULL,renderer,"text",COLUMN_FILENAME,NULL);
gtk_tree_view_column_set_resizable(column,true);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column((GtkTreeView*)treeview,column);
gtk_tree_view_column_set_expand(column,true);
gtk_tree_view_column_set_spacing(column,0);
gtk_tree_view_set_headers_visible((GtkTreeView*)treeview,false);
g_signal_connect(treeview,"row-expanded",G_CALLBACK(expandRow),column);
g_signal_connect(treeview,"row-collapsed",G_CALLBACK(collapseRow),column);
g_signal_connect(treeview,"row-activated",G_CALLBACK(onRowActivated),NULL);
leftBox=(GtkWidget*)plugdata->leftUserBox;
doStartUpCheck(plugdata);
showHideBrowser(plugdata,true);
if(showing==true)
showSide(true);
else
hideSide(true);
setTextDomain(false,plugdata);
return(0);
}
static void
plugin_manager_construct_tree (EomPluginManager *pm)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkListStore *model;
eom_debug (DEBUG_PLUGINS);
model = gtk_list_store_new (N_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (pm->priv->tree),
GTK_TREE_MODEL (model));
g_object_unref (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (pm->priv->tree), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pm->priv->tree), FALSE);
/* First column */
cell = gtk_cell_renderer_toggle_new ();
g_object_set (cell, "xpad", 6, NULL);
g_signal_connect (cell,
"toggled",
G_CALLBACK (active_toggled_cb),
pm);
column = gtk_tree_view_column_new_with_attributes (PLUGIN_MANAGER_ACTIVE_TITLE,
cell,
"active", ACTIVE_COLUMN,
"activatable", AVAILABLE_COLUMN,
"sensitive", AVAILABLE_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (pm->priv->tree), column);
/* Second column */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, PLUGIN_MANAGER_NAME_TITLE);
gtk_tree_view_column_set_resizable (column, TRUE);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
g_object_set (cell, "stock-size", GTK_ICON_SIZE_SMALL_TOOLBAR, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell,
plugin_manager_view_icon_cell_cb,
pm, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell,
plugin_manager_view_info_cell_cb,
pm, NULL);
gtk_tree_view_column_set_spacing (column, 6);
gtk_tree_view_append_column (GTK_TREE_VIEW (pm->priv->tree), column);
/* Sort on the plugin names */
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (model),
model_name_sort_func,
NULL,
NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
/* Enable search for our non-string column */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (pm->priv->tree),
INFO_COLUMN);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (pm->priv->tree),
name_search_cb,
NULL,
NULL);
g_signal_connect (pm->priv->tree,
"cursor_changed",
G_CALLBACK (cursor_changed_cb),
pm);
g_signal_connect (pm->priv->tree,
"row_activated",
G_CALLBACK (row_activated_cb),
pm);
g_signal_connect (pm->priv->tree,
"button-press-event",
G_CALLBACK (button_press_event_cb),
pm);
g_signal_connect (pm->priv->tree,
"popup-menu",
G_CALLBACK (popup_menu_cb),
pm);
gtk_widget_show (pm->priv->tree);
}
/* Create the window for selecting folders with checkboxes */
static void foldercheck_create_window(SpecificFolderArrayEntry *entry)
{
GtkWidget *vbox;
GtkWidget *scrolledwin;
GtkWidget *confirm_area;
GtkWidget *checkbox;
GtkWidget *cancel_button;
GtkWidget *ok_button;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
static GdkGeometry geometry;
/* Create window */
entry->window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "notification_foldercheck");
gtk_window_set_title(GTK_WINDOW(entry->window), _("Select folder(s)"));
gtk_container_set_border_width(GTK_CONTAINER(entry->window), 4);
gtk_window_set_position(GTK_WINDOW(entry->window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(entry->window), TRUE);
gtk_window_set_resizable(GTK_WINDOW(entry->window), TRUE);
gtk_window_set_wmclass
(GTK_WINDOW(entry->window), "folder_selection", "Claws Mail");
g_signal_connect(G_OBJECT(entry->window), "delete_event",
G_CALLBACK(delete_event), entry);
g_signal_connect(G_OBJECT(entry->window), "key_press_event",
G_CALLBACK(key_pressed), entry);
MANAGE_WINDOW_SIGNALS_CONNECT(entry->window);
/* vbox */
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(entry->window), vbox);
/* scrolled window */
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
/* pixbufs */
if(!folder_pixbuf)
stock_pixbuf_gdk(STOCK_PIXMAP_DIR_CLOSE,
&folder_pixbuf);
if(!folderopen_pixbuf)
stock_pixbuf_gdk(STOCK_PIXMAP_DIR_OPEN,
&folderopen_pixbuf);
if(!foldernoselect_pixbuf)
stock_pixbuf_gdk(STOCK_PIXMAP_DIR_NOSELECT_CLOSE,
&foldernoselect_pixbuf);
if(!foldernoselectopen_pixbuf)
stock_pixbuf_gdk(STOCK_PIXMAP_DIR_NOSELECT_OPEN,
&foldernoselectopen_pixbuf);
/* Tree store */
foldercheck_set_tree(entry);
gtk_tree_model_foreach(GTK_TREE_MODEL(entry->tree_store),
foldercheck_foreach_update_to_list, entry);
/* tree view */
entry->treeview =
gtk_tree_view_new_with_model(GTK_TREE_MODEL(entry->tree_store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(entry->treeview), FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(entry->treeview),
FOLDERCHECK_FOLDERNAME);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(entry->treeview),
prefs_common_get_prefs()->use_stripes_everywhere);
gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(entry->treeview), FALSE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(entry->treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection, foldercheck_selected,
NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolledwin), entry->treeview);
/* --- column 1 --- */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "sel");
gtk_tree_view_column_set_spacing(column, 2);
/* checkbox */
renderer = gtk_cell_renderer_toggle_new();
g_object_set(renderer, "xalign", 0.0, NULL);
gtk_tree_view_column_pack_start(column, renderer, TRUE);
g_signal_connect(renderer, "toggled", G_CALLBACK(folder_toggle_cb),entry);
gtk_tree_view_column_set_attributes(column, renderer,
"active", FOLDERCHECK_CHECK,NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(entry->treeview), column);
/* --- column 2 --- */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, "Folder");
gtk_tree_view_column_set_spacing(column, 2);
/* 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", FOLDERCHECK_PIXBUF,
"pixbuf-expander-open", FOLDERCHECK_PIXBUF_OPEN,
"pixbuf-expander-closed", FOLDERCHECK_PIXBUF,
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,
"text", FOLDERCHECK_FOLDERNAME,
NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(entry->treeview), column);
/* recursive */
checkbox = gtk_check_button_new_with_label( _("select recursively"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), FALSE);
g_signal_connect(G_OBJECT(checkbox), "toggled",
G_CALLBACK(foldercheck_recursive_cb), entry);
gtk_box_pack_start(GTK_BOX(vbox), checkbox, FALSE, FALSE, 10);
gtkut_stock_button_set_create(&confirm_area,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(foldercheck_ok), entry);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(foldercheck_cancel), entry);
if(!geometry.min_height) {
geometry.min_width = 360;
geometry.min_height = 360;
}
gtk_window_set_geometry_hints(GTK_WINDOW(entry->window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_tree_view_expand_all(GTK_TREE_VIEW(entry->treeview));
gtk_widget_show_all(vbox);
}
