static void
_glade_adaptor_chooser_widget_constructed (GObject *object)
{
_GladeAdaptorChooserWidget *chooser = GLADE_ADAPTOR_CHOOSER_WIDGET (object);
_GladeAdaptorChooserWidgetPrivate *priv = GET_PRIVATE (chooser);
/* Set cell data function: this save us from alocating name and icon name for each adaptor. */
gtk_tree_view_column_set_cell_data_func (priv->column_icon,
priv->icon_cell,
adaptor_icon_cell_data_func,
NULL, NULL);
gtk_tree_view_column_set_cell_data_func (priv->column_adaptor,
priv->adaptor_cell,
adaptor_text_cell_data_func,
NULL, NULL);
/* Set tree model filter function */
gtk_tree_model_filter_set_visible_func (priv->treemodelfilter,
treemodelfilter_visible_func,
chooser, NULL);
/* Set completion match function */
gtk_entry_completion_set_match_func (priv->entrycompletion,
entrycompletion_match_func,
chooser, NULL);
/* Enable Drag & Drop */
gtk_tree_view_enable_model_drag_source (priv->treeview, GDK_BUTTON1_MASK,
_glade_dnd_get_target (), 1, 0);
g_signal_connect_after (priv->treeview, "drag-begin",
G_CALLBACK (glade_adaptor_chooser_widget_drag_begin),
NULL);
g_signal_connect (priv->treeview, "drag-data-get",
G_CALLBACK (glade_adaptor_chooser_widget_drag_data_get),
NULL);
}
static void fm_places_view_init(FmPlacesView *self)
{
GtkTreeViewColumn* col;
GtkCellRenderer* renderer;
GtkTargetList* targets;
GdkPixbuf* pix;
guint handler;
if(G_UNLIKELY(!model))
{
model = fm_places_model_new();
g_object_add_weak_pointer(G_OBJECT(model), &model);
}
else
g_object_ref(model);
gtk_tree_view_set_model(GTK_TREE_VIEW(self), model);
g_object_unref(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(self), FALSE);
gtk_tree_view_set_row_separator_func(GTK_TREE_VIEW(self), (GtkTreeViewRowSeparatorFunc)sep_func, NULL, NULL );
col = gtk_tree_view_column_new();
renderer = fm_cell_renderer_pixbuf_new();
handler = g_signal_connect(fm_config, "changed::pane_icon_size", G_CALLBACK(on_renderer_icon_size_changed), renderer);
g_object_weak_ref(G_OBJECT(renderer), (GDestroyNotify)on_cell_renderer_pixbuf_destroy, GUINT_TO_POINTER(handler));
fm_cell_renderer_pixbuf_set_fixed_size(FM_CELL_RENDERER_PIXBUF(renderer), fm_config->pane_icon_size, fm_config->pane_icon_size);
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_tree_view_column_set_attributes( col, renderer,
"pixbuf", FM_PLACES_MODEL_COL_ICON, NULL );
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start( col, renderer, TRUE );
g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_attributes( col, renderer,
"text", FM_PLACES_MODEL_COL_LABEL, NULL );
renderer = gtk_cell_renderer_pixbuf_new();
self->mount_indicator_renderer = renderer;
gtk_tree_view_column_pack_start( col, renderer, FALSE );
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(col), renderer,
fm_places_model_mount_indicator_cell_data_func,
NULL, NULL);
gtk_tree_view_append_column ( GTK_TREE_VIEW(self), col );
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(self), GDK_BUTTON1_MASK,
dnd_src_targets, G_N_ELEMENTS(dnd_src_targets), GDK_ACTION_MOVE);
gtk_drag_dest_set(self, 0,
fm_default_dnd_dest_targets, N_FM_DND_DEST_DEFAULT_TARGETS,
GDK_ACTION_COPY|GDK_ACTION_MOVE|GDK_ACTION_LINK|GDK_ACTION_ASK);
targets = gtk_drag_dest_get_target_list((GtkWidget*)self);
/* add our own targets */
gtk_target_list_add_table(targets, dnd_dest_targets, G_N_ELEMENTS(dnd_dest_targets));
self->dnd_dest = fm_dnd_dest_new((GtkWidget*)self);
g_signal_connect(self->dnd_dest, "files_dropped", G_CALLBACK(on_dnd_dest_files_dropped), self);
}
static void
xfburn_directory_browser_init (XfburnDirectoryBrowser * browser)
{
GtkListStore *model;
GtkTreeViewColumn *column_file;
GtkCellRenderer *cell_icon, *cell_file;
GtkTreeSelection *selection;
GtkTargetEntry gte[] = { {"text/plain;charset=utf-8", 0, DATA_COMPOSITION_DND_TARGET_TEXT_PLAIN} };
model = gtk_list_store_new (DIRECTORY_BROWSER_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (model), DIRECTORY_BROWSER_COLUMN_FILE,
directory_tree_sortfunc, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), DIRECTORY_BROWSER_COLUMN_FILE, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (browser), GTK_TREE_MODEL (model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (browser), TRUE);
column_file = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column_file, _("File"));
cell_icon = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column_file, cell_icon, FALSE);
gtk_tree_view_column_set_attributes (column_file, cell_icon, "pixbuf", DIRECTORY_BROWSER_COLUMN_ICON, NULL);
g_object_set (cell_icon, "xalign", 0.0, "ypad", 0, NULL);
cell_file = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column_file, cell_file, TRUE);
gtk_tree_view_column_set_attributes (column_file, cell_file, "text", DIRECTORY_BROWSER_COLUMN_FILE, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (browser), column_file);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (browser), -1, _("Size"), gtk_cell_renderer_text_new (),
"text", DIRECTORY_BROWSER_COLUMN_HUMANSIZE, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (browser), -1, _("Type"), gtk_cell_renderer_text_new (),
"text", DIRECTORY_BROWSER_COLUMN_TYPE, NULL);
gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 1);
gtk_tree_view_column_set_resizable (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 1);
gtk_tree_view_column_set_fixed_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 500);
gtk_tree_view_column_set_fixed_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 100);
gtk_tree_view_column_set_min_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_FILE - 1)), 100);
gtk_tree_view_column_set_min_width (gtk_tree_view_get_column (GTK_TREE_VIEW (browser),
(DIRECTORY_BROWSER_COLUMN_HUMANSIZE - 1)), 60);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (browser));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
/* set up DnD */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (browser), GDK_BUTTON1_MASK, gte,
G_N_ELEMENTS (gte), GDK_ACTION_COPY);
g_signal_connect (G_OBJECT (browser), "drag-data-get", G_CALLBACK (cb_browser_drag_data_get), browser);
}
// Create and bind the tree model to the tree view for the queue list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_queue_tree_model (signal_user_data_t *ud)
{
GtkCellRenderer *cell, *textcell;
GtkTreeViewColumn *column;
GtkTreeStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkTargetEntry SrcEntry;
SrcEntry.target = "DATA";
SrcEntry.flags = GTK_TARGET_SAME_WIDGET;
g_debug("bind_queue_tree_model ()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET (ud->builder, "queue_list"));
selection = gtk_tree_view_get_selection (treeview);
treestore = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title (column, _("Job Information"));
cell = gtk_cell_renderer_pixbuf_new();
g_object_set(cell, "yalign", 0.0, NULL);
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_add_attribute (column, cell, "icon-name", 0);
textcell = gtk_cell_renderer_text_new();
g_object_set(textcell, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(textcell, "wrap-width", 500, NULL);
gtk_tree_view_column_pack_start (column, textcell, TRUE);
gtk_tree_view_column_add_attribute (column, textcell, "markup", 1);
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, 550);
cell = custom_cell_renderer_button_new();
g_object_set(cell, "yalign", 0.0, NULL);
column = gtk_tree_view_column_new_with_attributes(
_(""), cell, "icon-name", 2, NULL);
gtk_tree_view_column_set_min_width (column, 24);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_enable_model_drag_dest (treeview, &SrcEntry, 1,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (treeview, GDK_BUTTON1_MASK,
&SrcEntry, 1, GDK_ACTION_MOVE);
g_signal_connect(selection, "changed", queue_list_selection_changed_cb, ud);
g_signal_connect(cell, "clicked", queue_remove_clicked_cb, ud);
g_signal_connect(treeview, "size-allocate", queue_list_size_allocate_cb,
textcell);
g_signal_connect(treeview, "drag_data_received", queue_drag_cb, ud);
g_signal_connect(treeview, "drag_motion", queue_drag_motion_cb, ud);
// Work around silly treeview display bug. If the treeview
// hasn't been shown yet, the width request doesn't seem
// to work right. Cells get badly formatted.
GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
gtk_widget_show (widget);
gtk_widget_hide (widget);
}
static void dest_dnd_init(Dest_Data *dd)
{
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(dd->d_view), GDK_BUTTON1_MASK,
dest_drag_types, dest_drag_types_n,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK);
g_signal_connect(G_OBJECT(dd->d_view), "drag_data_get",
G_CALLBACK(dest_dnd_set_data), dd);
if (dd->f_view)
{
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(dd->f_view), GDK_BUTTON1_MASK,
dest_drag_types, dest_drag_types_n,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK);
g_signal_connect(G_OBJECT(dd->f_view), "drag_data_get",
G_CALLBACK(dest_dnd_set_data), dd);
}
}
static void
file_view_init (AnjutaFileView *object)
{
GtkCellRenderer* renderer_pixbuf;
GtkCellRenderer* renderer_display;
GtkTreeViewColumn* column;
GtkTreeSelection* selection;
GtkTreeModel* sort_model;
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (object);
priv->current_selection = NULL;
priv->model = file_model_new (GTK_TREE_VIEW(object), NULL);
g_signal_connect_object (priv->model, "directory-expanded",
G_CALLBACK (file_view_directory_expanded), object, 0);
sort_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(priv->model));
gtk_tree_view_set_model (GTK_TREE_VIEW(object), sort_model);
/* set_model takes a reference so we can release the reference we got when
* the sort_model was created. */
g_object_unref (sort_model);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE(sort_model),
file_view_sort_model,
NULL,
NULL);
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
renderer_display = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Filename"));
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_tree_view_column_pack_start (column, renderer_display, FALSE);
gtk_tree_view_column_set_cell_data_func(column,
renderer_pixbuf,
file_view_render_pixbuf_with_emblem,
object, NULL);
gtk_tree_view_column_set_attributes (column, renderer_display,
"markup", COLUMN_DISPLAY,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (object), column);
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (object));
g_signal_connect (selection, "changed",
G_CALLBACK (file_view_selection_changed), object);
/* DND */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW(object),
GDK_BUTTON1_MASK,
uri_targets,
1,
GDK_ACTION_MOVE);
/* Typeahead search */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (object), COLUMN_FILENAME);
}
// Create and bind the tree model to the tree view for the queue list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_queue_tree_model(signal_user_data_t *ud)
{
GtkCellRenderer *cell, *textcell;
GtkTreeViewColumn *column;
GtkTreeStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkTargetEntry SrcEntry;
SrcEntry.target = "DATA";
SrcEntry.flags = GTK_TARGET_SAME_WIDGET;
g_debug("bind_queue_tree_model()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "queue_list"));
selection = gtk_tree_view_get_selection(treeview);
treestore = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Job Information"));
cell = gtk_cell_renderer_spinner_new();
gtk_tree_view_column_pack_start(column, cell, FALSE);
gtk_tree_view_column_add_attribute(column, cell, "active", 0);
gtk_tree_view_column_add_attribute(column, cell, "pulse", 4);
cell = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, cell, FALSE);
gtk_tree_view_column_add_attribute(column, cell, "icon-name", 1);
textcell = gtk_cell_renderer_text_new();
g_object_set(textcell, "wrap-mode", PANGO_WRAP_CHAR, NULL);
g_object_set(textcell, "wrap-width", 500, NULL);
gtk_tree_view_column_pack_start(column, textcell, TRUE);
gtk_tree_view_column_add_attribute(column, textcell, "markup", 2);
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, 550);
g_signal_connect(treeview, "size-allocate", queue_list_size_allocate_cb,
textcell);
cell = custom_cell_renderer_button_new();
column = gtk_tree_view_column_new_with_attributes(
_(""), 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));
gtk_tree_view_enable_model_drag_dest(treeview, &SrcEntry, 1,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source(treeview, GDK_BUTTON1_MASK,
&SrcEntry, 1, GDK_ACTION_MOVE);
g_signal_connect(selection, "changed", queue_list_selection_changed_cb, ud);
g_signal_connect(cell, "clicked", queue_remove_clicked_cb, ud);
g_signal_connect(treeview, "drag_data_received", queue_drag_cb, ud);
g_signal_connect(treeview, "drag_motion", queue_drag_motion_cb, ud);
}
static GtkWidget *
create_accounts_list(AccountsWindow *dialog)
{
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeSelection *sel;
GtkTargetEntry gte[] = {{"PURPLE_ACCOUNT", GTK_TARGET_SAME_APP, 0}};
/* Create the scrolled window. */
sw = gtk_scrolled_window_new(0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_IN);
gtk_widget_show(sw);
/* Create the list model. */
dialog->model = gtk_list_store_new(NUM_COLUMNS,
GDK_TYPE_PIXBUF, G_TYPE_STRING,
G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER,
G_TYPE_POINTER);
/* And now the actual treeview */
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dialog->model));
dialog->treeview = treeview;
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
g_signal_connect(G_OBJECT(sel), "changed",
G_CALLBACK(account_selected_cb), dialog);
gtk_container_add(GTK_CONTAINER(sw), treeview);
gtk_widget_show(treeview);
add_columns(treeview, dialog);
populate_accounts_list(dialog);
/* Setup DND. I wanna be an orc! */
gtk_tree_view_enable_model_drag_source(
GTK_TREE_VIEW(treeview), GDK_BUTTON1_MASK, gte,
1, GDK_ACTION_COPY);
gtk_tree_view_enable_model_drag_dest(
GTK_TREE_VIEW(treeview), gte, 1,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect(G_OBJECT(treeview), "drag-data-received",
G_CALLBACK(drag_data_received_cb), dialog);
g_signal_connect(G_OBJECT(treeview), "drag-data-get",
G_CALLBACK(drag_data_get_cb), dialog);
return sw;
}
int artistlist_init(GladeXML *xml)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *select;
artistlist = gtk_list_store_new (ARTIST_N_COLUMNS,
G_TYPE_POINTER, /* artist ptr */
G_TYPE_STRING /* artist */
);
artisttreeview = GTK_TREE_VIEW(glade_xml_get_widget(xml, "artist"));
gtk_tree_view_set_model(artisttreeview, GTK_TREE_MODEL(artistlist));
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Artist",
renderer,
"text", ARTIST_COLUMN,
NULL);
gtk_tree_view_append_column (artisttreeview, column);
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(artistlist),
artistlist_default_sort,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(artistlist),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(artisttreeview));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK(on_artist_selection_changed),
NULL);
/* set it up as a drag source */
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(artisttreeview),
GDK_BUTTON1_MASK,
artistlist_src_targets,
artistlist_src_n_targets,
GDK_ACTION_LINK);
g_signal_connect(G_OBJECT(artisttreeview), "drag-begin",
G_CALLBACK(on_artist_drag_begin),
NULL);
g_signal_connect(G_OBJECT(artisttreeview), "drag-data-get",
G_CALLBACK(on_artist_drag_data_get),
NULL);
g_signal_connect(G_OBJECT(artisttreeview), "drag-end",
G_CALLBACK(on_artist_drag_end),
NULL);
return 1;
}
static void
file_view_init (AnjutaFileView *object)
{
GtkCellRenderer* renderer_pixbuf;
GtkCellRenderer* renderer_display;
GtkTreeViewColumn* column;
GtkTreeSelection* selection;
GtkTreeModel* sort_model;
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (object);
priv->current_selection = NULL;
priv->model = file_model_new (GTK_TREE_VIEW(object), NULL);
sort_model = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(priv->model));
gtk_tree_view_set_model (GTK_TREE_VIEW(object), sort_model);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE(sort_model),
file_view_sort_model,
NULL,
NULL);
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
renderer_display = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Filename"));
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_tree_view_column_pack_start (column, renderer_display, FALSE);
gtk_tree_view_column_set_attributes (column, renderer_pixbuf,
"pixbuf", COLUMN_PIXBUF,
NULL);
gtk_tree_view_column_set_attributes (column, renderer_display,
"markup", COLUMN_DISPLAY,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (object), column);
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (object));
g_signal_connect (selection, "changed",
G_CALLBACK (file_view_selection_changed), object);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (object), FALSE);
g_object_set (object, "has-tooltip", TRUE, NULL);
/* DND */
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW(object),
GDK_BUTTON1_MASK,
uri_targets,
1,
GDK_ACTION_MOVE);
}
static void rc_gui_list1_tree_view_set_drag()
{
static GtkTargetEntry entry[2];
entry[0].target = "RhythmCat/ListItem";
entry[0].flags = GTK_TARGET_SAME_WIDGET;
entry[0].info = 0;
entry[1].target = "RhythmCat/MusicItem";
entry[1].flags = GTK_TARGET_SAME_APP;
entry[1].info = 1;
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(
rc_ui->list1_tree_view), GDK_BUTTON1_MASK, entry, 1,
GDK_ACTION_COPY);
gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(
rc_ui->list1_tree_view), entry, 2, GDK_ACTION_COPY |
GDK_ACTION_MOVE | GDK_ACTION_LINK);
}
// Create and bind the tree model to the tree view for the preset list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_presets_tree_model(signal_user_data_t *ud)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
GtkTreeStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkWidget *widget;
GtkTargetEntry SrcEntry;
SrcEntry.target = "DATA";
SrcEntry.flags = GTK_TARGET_SAME_WIDGET;
g_debug("bind_presets_tree_model()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "presets_list"));
selection = gtk_tree_view_get_selection(treeview);
treestore = gtk_tree_store_new(6, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Preset Name"), cell,
"text", 0, "weight", 1, "style", 2,
"foreground", 3, "editable", 5, NULL);
g_signal_connect(cell, "edited", preset_edited_cb, ud);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_set_tooltip_column(treeview, 4);
gtk_tree_view_enable_model_drag_dest(treeview, &SrcEntry, 1,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source(treeview, GDK_BUTTON1_MASK,
&SrcEntry, 1, GDK_ACTION_MOVE);
g_signal_connect(treeview, "drag_data_received", presets_drag_cb, ud);
g_signal_connect(treeview, "drag_motion", presets_drag_motion_cb, ud);
g_signal_connect(treeview, "row_expanded", presets_row_expanded_cb, ud);
g_signal_connect(treeview, "row_collapsed", presets_row_expanded_cb, ud);
g_signal_connect(selection, "changed", presets_list_selection_changed_cb, ud);
widget = GHB_WIDGET(ud->builder, "presets_remove");
gtk_widget_set_sensitive(widget, FALSE);
g_debug("Done\n");
}
static VALUE
rg_enable_model_drag_source(VALUE self, VALUE rbstart_button_mask, VALUE rbtargets, VALUE rbactions)
{
GtkTreeView *view = _SELF(self);
GdkModifierType start_button_mask = RVAL2GFLAGS(rbstart_button_mask, GDK_TYPE_MODIFIER_TYPE);
GdkDragAction actions = RVAL2GFLAGS(rbactions, GDK_TYPE_DRAG_ACTION);
long n;
GtkTargetEntry *targets = RVAL2GTKTARGETENTRIES_ACCEPT_NIL(rbtargets, &n);
if (targets == NULL)
return self;
gtk_tree_view_enable_model_drag_source(view, start_button_mask, targets, n, actions);
g_free(targets);
return self;
}
GtkWidget *get_widget_list (GtkWidget *box, GtkTreeSelection **sel)
{
GtkWidget *sw;
GtkWidget *event_view;
GtkCellRenderer *rend;
GtkTreeViewColumn *col;
GtkTargetEntry gte [] = {{"STRING", 0, GTK_IMHTML_DRAG_STRING}};
if (tree_list == NULL) {
tree_list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(tree_list),
0, GTK_SORT_ASCENDING);
update_widget_list (tree_list);
g_object_ref (G_OBJECT(tree_list));
}
/* List of widgets */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX(box), sw, TRUE, TRUE, 0);
event_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(tree_list));
*sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_view));
rend = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Widget"), rend,
"markup", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (event_view), col);
gtk_tree_view_column_set_sort_column_id (col, 0);
gtk_container_add (GTK_CONTAINER(sw), event_view);
/* Drag and Drop */
gtk_tree_view_enable_model_drag_source(
GTK_TREE_VIEW(event_view), GDK_BUTTON1_MASK, gte,
1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(event_view), "drag-data-get",
G_CALLBACK(drag_data_get_cb), tree_list);
return event_view;
}
/**
* Assemble the list view.
*/
static GtkTreeView* get_tree_view(GDeviceSetup *gds)
{
GtkTreeStore *ts = query_devices(gds);
GtkTreeView *tv;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkTargetEntry dnd_targets[] = {{"DEV_LIST", GTK_TARGET_SAME_WIDGET, 0xFF}};
int dnd_ntargets = sizeof(dnd_targets)/sizeof(GtkTargetEntry);
tv = (GtkTreeView*)gtk_tree_view_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, ("Input Device Hierarchy"));
gtk_tree_view_append_column(tv, col);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col, renderer, FALSE);
gtk_tree_view_column_set_attributes(col, renderer, "pixbuf", COL_ICON, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_NAME);
gtk_tree_view_set_model(tv, GTK_TREE_MODEL(ts));
g_object_unref(ts);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv),
GTK_SELECTION_SINGLE);
gtk_tree_view_enable_model_drag_source(tv,
GDK_BUTTON1_MASK,
dnd_targets,
dnd_ntargets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest(tv,
dnd_targets,
dnd_ntargets,
GDK_ACTION_MOVE);
gtk_tree_view_expand_all(tv);
g_signal_connect(tv, "drag_data_received",
G_CALLBACK(signal_dnd_recv), gds);
g_signal_connect(tv, "button-press-event",
G_CALLBACK(signal_button_press), gds);
return tv;
}
GtkWidget *PluginManageDlg::create_plugin_list()
{
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
plugin_tree_model = gtk_tree_store_new(7, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_BOOLEAN);
init_tree_model(plugin_tree_model);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL(plugin_tree_model));
g_object_unref (G_OBJECT (plugin_tree_model));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
g_signal_connect (G_OBJECT (treeview), "button_press_event", G_CALLBACK (on_treeview_button_press), this);
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed", G_CALLBACK (on_plugin_treeview_selection_changed), this);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled", G_CALLBACK (on_plugin_enable_toggled), this);
column = gtk_tree_view_column_new_with_attributes (_("Enable"), renderer, "visible", 0, "active", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN (column), FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), FALSE);
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Plug-in Name"), renderer, "markup", 2, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), FALSE);
GtkTargetEntry gte[] = {{(gchar *)"STARDICT_PLUGINMANAGE", GTK_TARGET_SAME_APP, 0}};
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(treeview), GDK_BUTTON1_MASK, gte, 1, GDK_ACTION_COPY);
gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(treeview), gte, 1, (GdkDragAction)(GDK_ACTION_COPY | GDK_ACTION_MOVE));
g_signal_connect(G_OBJECT(treeview), "drag-data-received", G_CALLBACK(drag_data_received_cb), this);
g_signal_connect(G_OBJECT(treeview), "drag-data-get", G_CALLBACK(drag_data_get_cb), this);
gtk_tree_view_expand_all(GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
return sw;
}
/****************************************************************
Reset worklist for city
*****************************************************************/
void reset_city_worklist(GtkWidget *editor, struct city *pcity)
{
struct worklist_data *ptr;
ptr = g_object_get_data(G_OBJECT(editor), "data");
ptr->global_worklist_id = -1;
ptr->pcity = pcity;
gtk_list_store_clear(ptr->src);
gtk_list_store_clear(ptr->dst);
g_object_set(ptr->src_col, "visible", TRUE, NULL);
g_object_set(ptr->dst_col, "visible", TRUE, NULL);
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(ptr->src_view),
GDK_BUTTON1_MASK,
wl_dnd_targets,
G_N_ELEMENTS(wl_dnd_targets),
GDK_ACTION_COPY);
}
static void
panel_addto_setup_drag (GtkTreeView *tree_view,
const GtkTargetEntry *target,
const char *text)
{
if (!text || panel_lockdown_get_locked_down ())
return;
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tree_view),
GDK_BUTTON1_MASK|GDK_BUTTON2_MASK,
target, 1, GDK_ACTION_COPY);
g_signal_connect_data (G_OBJECT (tree_view), "drag_data_get",
G_CALLBACK (panel_addto_drag_data_get_cb),
g_strdup (text),
(GClosureNotify) g_free,
0 /* connect_flags */);
g_signal_connect_after (G_OBJECT (tree_view), "drag-begin",
G_CALLBACK (panel_addto_drag_begin_cb),
NULL);
}
static void select_callback(GtkTreeSelection *selection, gpointer user_data)
{
GtkTreeView *tree = user_data;
GtkTreeModel *model;
GtkTreeIter iter;
gboolean selected, favorite = FALSE;
selected = gtk_tree_selection_get_selected(selection, &model, &iter);
if (selected == TRUE)
gtk_tree_model_get(model, &iter,
CONNMAN_COLUMN_FAVORITE, &favorite, -1);
if (favorite == TRUE) {
gtk_tree_view_enable_model_drag_source(tree, GDK_BUTTON1_MASK,
row_targets, G_N_ELEMENTS(row_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest(tree,
row_targets, G_N_ELEMENTS(row_targets),
GDK_ACTION_MOVE);
} else {
gtk_tree_view_unset_rows_drag_source(tree);
gtk_tree_view_unset_rows_drag_dest(tree);
}
}
static void
git_log_pane_init (GitLogPane *self)
{
gchar *objects[] = {"log_pane",
"log_branch_combo_model",
"log_loading_model",
"find_button_image",
NULL};
GError *error = NULL;
GtkWidget *log_pane;
GtkWidget *path_entry;
GtkTreeView *log_view;
GtkTreeViewColumn *ref_icon_column;
GtkTreeViewColumn *graph_column;
GtkTreeViewColumn *short_log_column;
GtkTreeViewColumn *author_column;
GtkTreeViewColumn *date_column;
GtkCellRenderer *ref_icon_renderer;
GtkCellRenderer *short_log_renderer;
GtkCellRenderer *author_renderer;
GtkCellRenderer *date_renderer;
GtkTreeViewColumn *loading_spinner_column;
GtkCellRenderer *loading_spinner_renderer;
GtkCellRenderer *loading_indicator_renderer;
GtkComboBox *branch_combo;
GtkTreeSelection *selection;
self->priv = g_new0 (GitLogPanePriv, 1);
self->priv->builder = gtk_builder_new ();
if (!gtk_builder_add_objects_from_file (self->priv->builder, BUILDER_FILE,
objects,
&error))
{
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
}
log_pane = GTK_WIDGET (gtk_builder_get_object (self->priv->builder,
"log_pane"));
path_entry = GTK_WIDGET (gtk_builder_get_object (self->priv->builder,
"path_entry"));
log_view = GTK_TREE_VIEW (gtk_builder_get_object (self->priv->builder,
"log_view"));
ref_icon_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"ref_icon_column"));
graph_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"graph_column"));
short_log_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"short_log_column"));
author_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"author_column"));
date_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"date_column"));
ref_icon_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder,
"ref_icon_renderer"));
author_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder,
"author_renderer"));
date_renderer = GTK_CELL_RENDERER (gtk_builder_get_object (self->priv->builder,
"date_renderer"));
branch_combo = GTK_COMBO_BOX (gtk_builder_get_object (self->priv->builder,
"branch_combo"));
loading_spinner_column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (self->priv->builder,
"loading_spinner_column"));
selection = gtk_tree_view_get_selection (log_view);
/* Path entry */
g_signal_connect (G_OBJECT (path_entry), "icon-release",
G_CALLBACK (on_path_entry_icon_release),
self);
/* Set up the log model */
self->priv->log_model = gtk_list_store_new (1, GIT_TYPE_REVISION);
/* Ref icon column */
gtk_tree_view_column_set_cell_data_func (ref_icon_column, ref_icon_renderer,
(GtkTreeCellDataFunc) ref_icon_cell_function,
self, NULL);
/* Graph column */
self->priv->graph_renderer = giggle_graph_renderer_new ();
gtk_tree_view_column_pack_start (graph_column, self->priv->graph_renderer,
TRUE);
gtk_tree_view_column_add_attribute (graph_column, self->priv->graph_renderer,
"revision", 0);
/* Short log column. We have to create this render ouselves becuause Glade
* doesn't seem to give us to option to pack it with expand */
short_log_renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (short_log_renderer), "ellipsize",
PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start (short_log_column, short_log_renderer,
TRUE);
gtk_tree_view_column_set_cell_data_func (short_log_column, short_log_renderer,
(GtkTreeCellDataFunc) short_log_cell_function,
NULL, NULL);
/* Author column */
gtk_tree_view_column_set_cell_data_func (author_column, author_renderer,
(GtkTreeCellDataFunc) author_cell_function,
NULL, NULL);
/* Date column */
gtk_tree_view_column_set_cell_data_func (date_column, date_renderer,
(GtkTreeCellDataFunc) date_cell_function,
NULL, NULL);
gtk_tree_view_set_model (log_view, GTK_TREE_MODEL (self->priv->log_model));
/* Ref icon tooltip */
g_signal_connect (G_OBJECT (log_view), "query-tooltip",
G_CALLBACK (on_log_view_query_tooltip),
self);
/* Loading indicator. The loading indicator is a second tree view display
* that looks just like the real log display, except that it displays a
* spinner renderer and the text "Loading..." in the Short Log column. */
self->priv->log_loading_model = GTK_LIST_STORE (gtk_builder_get_object (self->priv->builder,
"log_loading_model"));
loading_spinner_renderer = gtk_cell_renderer_spinner_new ();
loading_indicator_renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (loading_spinner_renderer), "active", TRUE, NULL);
gtk_tree_view_column_pack_start (loading_spinner_column,
loading_spinner_renderer, FALSE);
gtk_tree_view_column_pack_start (loading_spinner_column,
loading_indicator_renderer, TRUE);
gtk_tree_view_column_add_attribute (loading_spinner_column,
loading_spinner_renderer,
"pulse", LOADING_COL_PULSE);
gtk_tree_view_column_add_attribute (loading_spinner_column,
loading_indicator_renderer,
"text", LOADING_COL_INDICATOR);
/* DnD source */
gtk_tree_view_enable_model_drag_source (log_view,
GDK_BUTTON1_MASK,
drag_source_targets,
G_N_ELEMENTS (drag_source_targets),
GDK_ACTION_COPY);
g_signal_connect (G_OBJECT (log_view), "drag-data-get",
G_CALLBACK (on_log_view_drag_data_get),
self);
/* DnD target. Use this as a means of selecting a file to view the
* log of. Files or folders would normally be dragged in from the file
* manager, but they can come from any source that supports URI's. */
gtk_drag_dest_set (log_pane,
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT,
drag_target_targets,
G_N_ELEMENTS (drag_target_targets),
GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect (G_OBJECT (log_pane), "drag-data-received",
G_CALLBACK (on_log_pane_drag_data_received),
self);
g_signal_connect (G_OBJECT (log_pane), "drag-drop",
G_CALLBACK (on_log_pane_drag_drop),
self);
/* Pop up menu */
g_signal_connect (G_OBJECT (log_view), "button-press-event",
G_CALLBACK (on_log_view_button_press_event),
self);
/* The loading view always has one row. Cache a copy of its iter for easy
* access. */
gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->priv->log_loading_model),
&(self->priv->spinner_iter));
/* FIXME: GtkSpinner doesn't have those anymore */
self->priv->spin_cycle_duration = 1000;
self->priv->spin_cycle_steps = 12;
g_object_set (G_OBJECT (loading_spinner_renderer), "active", TRUE, NULL);
/* Log message display */
gtk_tree_selection_set_select_function (selection,
(GtkTreeSelectionFunc) on_log_view_row_selected,
self, NULL);
/* Branch handling */
self->priv->branches_table = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free,
(GDestroyNotify) gtk_tree_path_free);
g_signal_connect (G_OBJECT (branch_combo), "changed",
G_CALLBACK (on_branch_combo_changed),
self);
}
static void
history_dialog_setup_view (HistoryDialog *dialog)
{
GtkTreeView *treeview = dialog->priv->treeview;
GtkTreeStore *treestore;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
/* set tree model */
treestore = gtk_tree_store_new (8,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_POINTER,
G_TYPE_INT,
G_TYPE_INT);
dialog->priv->model = GTK_TREE_MODEL(treestore);
gtk_tree_view_set_model (treeview,
GTK_TREE_MODEL (treestore));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview),
TRUE);
g_signal_connect (treeview, "row_activated",
G_CALLBACK (history_dialog_row_activated_cb),
dialog);
selection = gtk_tree_view_get_selection (treeview);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_enable_model_drag_source (treeview,
GDK_BUTTON1_MASK,
url_drag_types,
G_N_ELEMENTS (url_drag_types),
GDK_ACTION_COPY);
g_signal_connect (G_OBJECT(treeview),
"drag_data_get",
G_CALLBACK(treeview_drag_data_get_cb),
dialog);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (treeview,
0, _("Title"),
renderer,
"text", 0,
NULL);
column = gtk_tree_view_get_column (treeview, 0);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_min_width (column, 20);
gtk_tree_view_column_set_max_width (column, 400);
gtk_tree_view_column_set_sort_column_id (column, 0);
gtk_tree_view_insert_column_with_attributes (treeview,
1, _("URL"),
renderer,
"text", 1,
NULL);
column = gtk_tree_view_get_column (treeview, 1);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_reorderable (column, TRUE);
gtk_tree_view_column_set_min_width (column, 20);
gtk_tree_view_column_set_max_width (column, 500);
gtk_tree_view_column_set_sort_column_id (column, 1);
gtk_tree_view_insert_column_with_attributes (treeview,
2, _("Last visited"),
renderer,
"text", 2,
NULL);
column = gtk_tree_view_get_column (treeview, 2);
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, 6);
gtk_tree_view_insert_column_with_attributes (treeview,
3, _("First visited"),
renderer,
"text", 3,
NULL);
column = gtk_tree_view_get_column (treeview, 3);
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, 7);
gtk_tree_view_insert_column_with_attributes (treeview,
4, _("Times visited"),
renderer,
"text", 4,
NULL);
column = gtk_tree_view_get_column (treeview, 4);
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, 4);
}
static void
kinetic_scrolling (void)
{
GtkWidget *window, *swindow, *grid;
GtkWidget *label;
GtkWidget *button_grid, *button;
GtkWidget *treeview;
GtkCellRenderer *renderer;
GtkListStore *store;
GtkWidget *textview;
gint i;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
gtk_window_set_default_size (GTK_WINDOW (window), 400, 400);
g_signal_connect (window, "delete_event",
G_CALLBACK (gtk_main_quit), NULL);
grid = gtk_grid_new ();
label = gtk_label_new ("Non scrollable widget using viewport");
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_show (label);
label = gtk_label_new ("Scrollable widget: TreeView");
gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1);
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_show (label);
label = gtk_label_new ("Scrollable widget: TextView");
gtk_grid_attach (GTK_GRID (grid), label, 2, 0, 1, 1);
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_show (label);
button_grid = gtk_grid_new ();
for (i = 0; i < 80; i++)
{
gchar *label = g_strdup_printf ("Button number %d", i);
button = gtk_button_new_with_label (label);
gtk_grid_attach (GTK_GRID (button_grid), button, 0, i, 1, 1);
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_show (button);
g_signal_connect (button, "clicked",
G_CALLBACK (on_button_clicked),
GINT_TO_POINTER (i));
g_free (label);
}
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_kinetic_scrolling (GTK_SCROLLED_WINDOW (swindow), TRUE);
gtk_scrolled_window_set_capture_button_press (GTK_SCROLLED_WINDOW (swindow), TRUE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), button_grid);
gtk_widget_show (button_grid);
gtk_grid_attach (GTK_GRID (grid), swindow, 0, 1, 1, 1);
gtk_widget_show (swindow);
treeview = gtk_tree_view_new ();
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (treeview),
GDK_BUTTON1_MASK,
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (treeview),
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "editable", TRUE, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
0, "Title",
renderer,
"text", 0,
NULL);
store = gtk_list_store_new (1, G_TYPE_STRING);
for (i = 0; i < 80; i++)
{
GtkTreeIter iter;
gchar *label = g_strdup_printf ("Row number %d", i);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, 0, label, -1);
g_free (label);
}
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (store));
g_object_unref (store);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_kinetic_scrolling (GTK_SCROLLED_WINDOW (swindow), TRUE);
gtk_scrolled_window_set_capture_button_press (GTK_SCROLLED_WINDOW (swindow), TRUE);
gtk_container_add (GTK_CONTAINER (swindow), treeview);
gtk_widget_show (treeview);
gtk_grid_attach (GTK_GRID (grid), swindow, 1, 1, 1, 1);
gtk_widget_set_hexpand (swindow, TRUE);
gtk_widget_set_vexpand (swindow, TRUE);
gtk_widget_show (swindow);
textview = gtk_text_view_new ();
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_kinetic_scrolling (GTK_SCROLLED_WINDOW (swindow), TRUE);
gtk_scrolled_window_set_capture_button_press (GTK_SCROLLED_WINDOW (swindow), TRUE);
gtk_container_add (GTK_CONTAINER (swindow), textview);
gtk_widget_show (textview);
gtk_grid_attach (GTK_GRID (grid), swindow, 2, 1, 1, 1);
gtk_widget_set_hexpand (swindow, TRUE);
gtk_widget_set_vexpand (swindow, TRUE);
gtk_widget_show (swindow);
gtk_container_add (GTK_CONTAINER (window), grid);
gtk_widget_show (grid);
gtk_widget_show (window);
}
void gui_init(dt_lib_module_t *self)
{
/* initialize ui widgets */
dt_lib_keywords_t *d = (dt_lib_keywords_t *)g_malloc(sizeof(dt_lib_keywords_t));
memset(d,0,sizeof(dt_lib_keywords_t));
self->data = (void *)d;
self->widget = gtk_vbox_new(FALSE, 5);
/* Create a new scrolled window, with scrollbars only if needed */
GtkWidget *scrolled_window;
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
/* add the treeview to show hirarchy tags*/
GtkCellRenderer *renderer;
d->view = GTK_TREE_VIEW (gtk_tree_view_new());
gtk_widget_set_size_request(GTK_WIDGET(d->view), -1, 300);
gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(d->view));
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(d->view,
-1,
"",
renderer,
"text", 0,
NULL);
gtk_tree_view_set_headers_visible(d->view, FALSE);
/* setup dnd source and destination within treeview */
static const GtkTargetEntry dnd_target = { "keywords-reorganize",
GTK_TARGET_SAME_WIDGET, 0
};
gtk_tree_view_enable_model_drag_source(d->view,
GDK_BUTTON1_MASK,
&dnd_target, 1, GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest(d->view, &dnd_target, 1, GDK_ACTION_MOVE);
/* setup drag and drop signals */
g_signal_connect(G_OBJECT(d->view),"drag-data-received",
G_CALLBACK(_lib_keywords_drag_data_received_callback),
self);
g_signal_connect(G_OBJECT(d->view),"drag-data-get",
G_CALLBACK(_lib_keywords_drag_data_get_callback),
self);
/* add callback when keyword is activated */
g_signal_connect(G_OBJECT(d->view), "row-activated",
G_CALLBACK(_lib_keywords_add_collection_rule), self);
gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scrolled_window), TRUE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(d->view));
dt_control_signal_connect(darktable.signals,
DT_SIGNAL_TAG_CHANGED,
G_CALLBACK(_lib_tag_gui_update),
self);
/* raise signal of tags change to refresh keywords tree */
dt_control_signal_raise(darktable.signals, DT_SIGNAL_TAG_CHANGED);
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *paned, *tv;
GtkWidget *window, *icon_list, *scrolled_window;
GtkWidget *vbox, *bbox;
GtkWidget *button;
GtkWidget *prop_editor;
GtkTreeModel *model;
GtkCellRenderer *cell;
GtkTreeViewColumn *tvc;
gtk_init (&argc, &argv);
/* to test rtl layout, set RTL=1 in the environment */
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 700, 400);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0);
icon_list = gtk_icon_view_new ();
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_list), GTK_SELECTION_MULTIPLE);
tv = gtk_tree_view_new ();
tvc = gtk_tree_view_column_new ();
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), tvc);
g_signal_connect_after (icon_list, "button_press_event",
G_CALLBACK (button_press_event_handler), NULL);
g_signal_connect (icon_list, "selection_changed",
G_CALLBACK (selection_changed), NULL);
g_signal_connect (icon_list, "popup_menu",
G_CALLBACK (popup_menu_handler), NULL);
g_signal_connect (icon_list, "item_activated",
G_CALLBACK (item_activated), NULL);
model = create_model ();
gtk_icon_view_set_model (GTK_ICON_VIEW (icon_list), model);
gtk_tree_view_set_model (GTK_TREE_VIEW (tv), model);
fill_model (model);
#if 0
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_list), 0);
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_list), 1);
#else
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell, "activatable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "active", 4, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell,
"follow-state", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "pixbuf", 0, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell,
"editable", TRUE,
"xalign", 0.5,
"wrap-mode", PANGO_WRAP_WORD_CHAR,
"wrap-width", 100,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "text", 1, NULL);
g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
/* now the tree view... */
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell, "activatable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "active", 4, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell,
"follow-state", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "pixbuf", 0, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell, "editable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "text", 1, NULL);
g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
#endif
/* Allow DND between the icon view and the tree view */
gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (icon_list),
GDK_BUTTON1_MASK,
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_icon_view_enable_model_drag_dest (GTK_ICON_VIEW (icon_list),
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
GDK_BUTTON1_MASK,
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
prop_editor = create_prop_editor (G_OBJECT (icon_list), 0);
gtk_widget_show_all (prop_editor);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (paned), scrolled_window);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), tv);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Add some");
g_signal_connect (button, "clicked", G_CALLBACK (add_some), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Add many");
g_signal_connect (button, "clicked", G_CALLBACK (add_many), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Add large");
g_signal_connect (button, "clicked", G_CALLBACK (add_large), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Remove selected");
g_signal_connect (button, "clicked", G_CALLBACK (foreach_selected_remove), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Swap");
g_signal_connect (button, "clicked", G_CALLBACK (swap_rows), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Select all");
g_signal_connect (button, "clicked", G_CALLBACK (select_all), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Unselect all");
g_signal_connect (button, "clicked", G_CALLBACK (unselect_all), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Select nonexisting");
g_signal_connect (button, "clicked", G_CALLBACK (select_nonexisting), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
icon_list = gtk_icon_view_new ();
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
int
main (int argc,
char **argv)
{
GtkWidget *window;
GtkWidget *sw;
GtkWidget *tv;
GtkWidget *box;
GtkWidget *combo_box;
GtkTreeModel *model;
gint i;
gtk_init (&argc, &argv);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
our_pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) book_closed_xpm);
#if 0
models[MODEL_TYPES] = GTK_TREE_MODEL (gtk_tree_model_types_new ());
#endif
models[MODEL_LIST] = create_list_model ();
models[MODEL_TREE] = create_tree_model ();
model = create_list_model ();
models[MODEL_SORTED_LIST] = gtk_tree_model_sort_new_with_model (model);
g_object_unref (model);
model = create_tree_model ();
models[MODEL_SORTED_TREE] = gtk_tree_model_sort_new_with_model (model);
g_object_unref (model);
models[MODEL_EMPTY_LIST] = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_INT));
models[MODEL_EMPTY_TREE] = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT));
models[MODEL_NULL] = NULL;
run_automated_tests ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 430, 400);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box);
tv = gtk_tree_view_new_with_model (models[0]);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
GDK_BUTTON1_MASK,
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
row_targets,
G_N_ELEMENTS (row_targets),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
/* Model menu */
combo_box = gtk_combo_box_text_new ();
gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER);
for (i = 0; i < MODEL_LAST; i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), model_names[i]);
gtk_container_add (GTK_CONTAINER (box), combo_box);
g_signal_connect (combo_box,
"changed",
G_CALLBACK (model_selected),
tv);
/* Columns menu */
combo_box = gtk_combo_box_text_new ();
gtk_widget_set_halign (combo_box, GTK_ALIGN_CENTER);
for (i = 0; i < COLUMNS_LAST; i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), column_type_names[i]);
gtk_container_add (GTK_CONTAINER (box), combo_box);
set_columns_type (GTK_TREE_VIEW (tv), COLUMNS_LOTS);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), COLUMNS_LOTS);
g_signal_connect (combo_box,
"changed",
G_CALLBACK (columns_selected),
tv);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_hexpand (sw, TRUE);
gtk_widget_set_vexpand (sw, TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (box), sw);
gtk_container_add (GTK_CONTAINER (sw), tv);
create_prop_editor (G_OBJECT (tv), GTK_TYPE_TREE_VIEW);
create_prop_editor (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (tv))), GTK_TYPE_TREE_SELECTION);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static GtkWidget *cm_tree_prepare(CookieManagerPage *cmp)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *sel;
GtkWidget *item;
GtkWidget *menu;
GtkWidget *treeview;
CookieManagerPagePrivate *priv = cmp->priv;
treeview = priv->treeview = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Name"), renderer, "text", COOKIE_MANAGER_COL_NAME, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, COOKIE_MANAGER_COL_NAME);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
(GtkTreeCellDataFunc) cm_tree_render_text_cb, NULL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COOKIE_MANAGER_COL_NAME);
/* selection handling */
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
/* signals */
g_signal_connect(sel, "changed", G_CALLBACK(cm_tree_selection_changed_cb), cmp);
g_signal_connect(treeview, "key-press-event", G_CALLBACK(cm_tree_key_press_cb), cmp);
g_signal_connect(treeview, "button-press-event", G_CALLBACK(cm_tree_button_press_event_cb), cmp);
g_signal_connect(treeview, "button-release-event", G_CALLBACK(cm_tree_button_release_event_cb), cmp);
g_signal_connect(treeview, "popup-menu", G_CALLBACK(cm_tree_popup_menu_cb), cmp);
/* tooltips */
gtk_widget_set_has_tooltip(treeview, TRUE);
g_signal_connect(treeview, "query-tooltip", G_CALLBACK(cm_tree_query_tooltip), cmp);
/* drag'n'drop */
gtk_tree_view_enable_model_drag_source(
GTK_TREE_VIEW(treeview),
GDK_BUTTON1_MASK,
NULL,
0,
GDK_ACTION_COPY
);
gtk_drag_source_add_text_targets(treeview);
g_signal_connect(treeview, "drag-data-get", G_CALLBACK(cm_tree_drag_data_get_cb), cmp);
/* popup menu */
priv->popup_menu = menu = gtk_menu_new();
item = gtk_image_menu_item_new_from_stock(GTK_STOCK_DELETE, NULL);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(cm_button_delete_clicked_cb), cmp);
priv->delete_popup_button = item;
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
item = gtk_image_menu_item_new_with_mnemonic(_("_Expand All"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(cm_tree_popup_expand_activate_cb), cmp);
priv->expand_buttons[2] = item;
item = gtk_image_menu_item_new_with_mnemonic(_("_Collapse All"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
gtk_image_new_from_icon_name(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect(item, "activate", G_CALLBACK(cm_tree_popup_collapse_activate_cb), cmp);
priv->expand_buttons[3] = item;
return treeview;
}
static TBEditorWidget *tb_editor_create_dialog(MarlinViewWindow *mvw)
{
GtkWidget *dialog, *vbox, *hbox, *vbox_buttons, *button_add, *button_remove;
GtkWidget *swin_available, *swin_used, *tree_available, *tree_used, *label;
GtkCellRenderer *text_renderer, *icon_renderer;
GtkTreeViewColumn *column;
TBEditorWidget *tbw = g_new(TBEditorWidget, 1);
dialog = gtk_dialog_new_with_buttons(_("Customize Toolbar"),
GTK_WINDOW (mvw),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_widget_set_name(dialog, "GeanyDialog");
gtk_window_set_default_size(GTK_WINDOW(dialog), 400, 300);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
tbw->store_available = gtk_list_store_new(TB_EDITOR_COLS_MAX,
G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF);
tbw->store_used = gtk_list_store_new(TB_EDITOR_COLS_MAX,
G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF);
label = gtk_label_new(_("Select items to be displayed on the toolbar. Items can be reordered by drag and drop."));
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
tree_available = gtk_tree_view_new();
gtk_tree_view_set_model(GTK_TREE_VIEW(tree_available), GTK_TREE_MODEL(tbw->store_available));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_available), TRUE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(tbw->store_available), TB_EDITOR_COL_LABEL, GTK_SORT_ASCENDING);
icon_renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", TB_EDITOR_COL_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column);
text_renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Available Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column);
swin_available = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_available),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_available), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(swin_available), tree_available);
tree_used = gtk_tree_view_new();
gtk_tree_view_set_model(GTK_TREE_VIEW(tree_used), GTK_TREE_MODEL(tbw->store_used));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_used), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(tree_used), TRUE);
icon_renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(NULL, icon_renderer, "pixbuf", TB_EDITOR_COL_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column);
text_renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Displayed Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column);
swin_used = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_used),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_used), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(swin_used), tree_used);
/* drag'n'drop */
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_available), GDK_BUTTON1_MASK,
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_available),
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
g_signal_connect(tree_available, "drag-data-get",
G_CALLBACK(tb_editor_drag_data_get_cb), tbw);
g_signal_connect(tree_available, "drag-data-received",
G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw);
g_signal_connect(tree_available, "drag-motion",
G_CALLBACK(tb_editor_drag_motion_cb), tbw);
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_used), GDK_BUTTON1_MASK,
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_used),
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
g_signal_connect(tree_used, "drag-data-get",
G_CALLBACK(tb_editor_drag_data_get_cb), tbw);
g_signal_connect(tree_used, "drag-data-received",
G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw);
g_signal_connect(tree_used, "drag-motion",
G_CALLBACK(tb_editor_drag_motion_cb), tbw);
button_add = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(button_add),
gtk_image_new_from_stock(GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON));
button_remove = gtk_button_new();
g_signal_connect(button_add, "clicked", G_CALLBACK(tb_editor_btn_add_clicked_cb), tbw);
gtk_button_set_image(GTK_BUTTON(button_remove),
gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON));
g_signal_connect(button_remove, "clicked", G_CALLBACK(tb_editor_btn_remove_clicked_cb), tbw);
vbox_buttons = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
/* FIXME this is a little hack'ish, any better ideas? */
gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_buttons), button_add, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_buttons), button_remove, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(hbox), swin_available, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox_buttons, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), swin_used, TRUE, TRUE, 0);
g_object_set (label, "margin", 5, NULL);
g_object_set (hbox, "margin", 5, NULL);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show_all(vbox);
g_object_unref(tbw->store_available);
g_object_unref(tbw->store_used);
tbw->dialog = dialog;
tbw->tree_available = GTK_TREE_VIEW(tree_available);
tbw->tree_used = GTK_TREE_VIEW(tree_used);
tbw->last_drag_path = NULL;
return tbw;
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *hbox, *vbox;
GtkWidget *vbox2, *bbox;
GtkWidget *button;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkWidget *swindow;
GtkTreeModel *sample_model;
GdkContentFormats *targets;
gint i;
gtk_init ();
/* First initialize all the models for signal purposes */
left_tree_model = (GtkTreeModel *) gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
sample_model = (GtkTreeModel *) gtk_list_store_new (1, G_TYPE_STRING);
sample_tree_view_top = gtk_tree_view_new_with_model (sample_model);
sample_tree_view_bottom = gtk_tree_view_new_with_model (sample_model);
top_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_top));
bottom_right_tree_model = (GtkTreeModel *) view_column_model_new (GTK_TREE_VIEW (sample_tree_view_bottom));
top_right_tree_view = gtk_tree_view_new_with_model (top_right_tree_model);
bottom_right_tree_view = gtk_tree_view_new_with_model (bottom_right_tree_model);
for (i = 0; i < 10; i++)
{
GtkTreeIter iter;
gchar *string = g_strdup_printf ("%d", i);
gtk_list_store_append (GTK_LIST_STORE (sample_model), &iter);
gtk_list_store_set (GTK_LIST_STORE (sample_model), &iter, 0, string, -1);
g_free (string);
}
/* Set up the test windows. */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
gtk_window_set_title (GTK_WINDOW (window), "Top Window");
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), swindow);
gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_top);
gtk_widget_show (window);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
gtk_window_set_title (GTK_WINDOW (window), "Bottom Window");
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), swindow);
gtk_container_add (GTK_CONTAINER (swindow), sample_tree_view_bottom);
gtk_widget_show (window);
/* Set up the main window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 500, 300);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
/* Left Pane */
cell = gtk_cell_renderer_text_new ();
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
left_tree_view = gtk_tree_view_new_with_model (left_tree_model);
gtk_container_add (GTK_CONTAINER (swindow), left_tree_view);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (left_tree_view), -1,
"Unattached Columns", cell, "text", 0, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), left_tree_view);
column = gtk_tree_view_column_new_with_attributes ("Visible", cell, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (left_tree_view), column);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_box_pack_start (GTK_BOX (hbox), swindow);
/* Middle Pane */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_box_pack_start (GTK_BOX (hbox), vbox2);
bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start (GTK_BOX (vbox2), bbox);
button = gtk_button_new_with_mnemonic ("<< (_Q)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), top_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (top_right_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button);
button = gtk_button_new_with_mnemonic (">> (_W)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), top_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button);
bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_SPREAD);
gtk_box_pack_start (GTK_BOX (vbox2), bbox);
button = gtk_button_new_with_mnemonic ("<< (_E)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_left_clicked), bottom_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (bottom_right_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button);
button = gtk_button_new_with_mnemonic (">> (_R)");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (button, "clicked", G_CALLBACK (add_right_clicked), bottom_right_tree_view);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (left_tree_view)),
"changed", G_CALLBACK (selection_changed), button);
gtk_box_pack_start (GTK_BOX (bbox), button);
/* Right Pane */
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_box_pack_start (GTK_BOX (hbox), vbox2);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (top_right_tree_view), FALSE);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (top_right_tree_view), -1,
NULL, cell, "text", 0, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), top_right_tree_view);
column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (top_right_tree_view), column);
gtk_container_add (GTK_CONTAINER (swindow), top_right_tree_view);
gtk_box_pack_start (GTK_BOX (vbox2), swindow);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (bottom_right_tree_view), FALSE);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (bottom_right_tree_view), -1,
NULL, cell, "text", 0, NULL);
cell = gtk_cell_renderer_toggle_new ();
g_signal_connect (cell, "toggled", G_CALLBACK (set_visible), bottom_right_tree_view);
column = gtk_tree_view_column_new_with_attributes (NULL, cell, NULL);
gtk_tree_view_column_set_cell_data_func (column, cell, get_visible, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (bottom_right_tree_view), column);
gtk_container_add (GTK_CONTAINER (swindow), bottom_right_tree_view);
gtk_box_pack_start (GTK_BOX (vbox2), swindow);
/* Drag and Drop */
targets = gdk_content_formats_new (row_targets, G_N_ELEMENTS (row_targets));
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (left_tree_view),
GDK_BUTTON1_MASK,
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (left_tree_view),
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (top_right_tree_view),
GDK_BUTTON1_MASK,
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (top_right_tree_view),
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (bottom_right_tree_view),
GDK_BUTTON1_MASK,
targets,
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (bottom_right_tree_view),
targets,
GDK_ACTION_MOVE);
gdk_content_formats_unref (targets);
gtk_box_pack_start (GTK_BOX (vbox), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
button = gtk_button_new_with_mnemonic ("_Add new Column");
g_signal_connect (button, "clicked", G_CALLBACK (add_clicked), left_tree_model);
gtk_box_pack_start (GTK_BOX (hbox), button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
/**
* query_favorite_selector_new
*
* Returns: a new #GtkWidget
*/
GtkWidget *
query_favorite_selector_new (TConnection *tcnc)
{
QueryFavoriteSelector *tsel;
GdaTreeManager *manager;
g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);
tsel = QUERY_FAVORITE_SELECTOR (g_object_new (QUERY_FAVORITE_SELECTOR_TYPE, NULL));
tsel->priv->tcnc = g_object_ref (tcnc);
g_signal_connect (t_connection_get_favorites (tsel->priv->tcnc), "favorites-changed",
G_CALLBACK (favorites_changed_cb), tsel);
/* create tree managers */
tsel->priv->tree = gda_tree_new ();
manager = mgr_favorites_new (tcnc, T_FAVORITES_QUERIES, ORDER_KEY_QUERIES);
gda_tree_add_manager (tsel->priv->tree, manager);
g_object_unref (manager);
/* update the tree's contents */
if (! gda_tree_update_all (tsel->priv->tree, NULL)) {
if (tsel->priv->idle_update_favorites == 0)
tsel->priv->idle_update_favorites = g_idle_add ((GSourceFunc) idle_update_favorites, tsel);
}
/* header */
GtkWidget *label;
gchar *str;
str = g_strdup_printf ("<b>%s</b>", _("Favorites"));
label = gdaui_bar_new (str);
g_free (str);
gdaui_bar_set_icon_from_resource (GDAUI_BAR (label), "/images/gda-browser-bookmark.png");
gtk_box_pack_start (GTK_BOX (tsel), label, FALSE, FALSE, 0);
gtk_widget_show (label);
/* tree model */
GtkTreeModel *model;
GtkWidget *treeview;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
model = gdaui_tree_store_new (tsel->priv->tree, 7,
G_TYPE_INT, MGR_FAVORITES_POSITION_ATT_NAME,
G_TYPE_OBJECT, "icon",
G_TYPE_STRING, MGR_FAVORITES_CONTENTS_ATT_NAME,
G_TYPE_UINT, MGR_FAVORITES_TYPE_ATT_NAME,
G_TYPE_INT, MGR_FAVORITES_ID_ATT_NAME,
G_TYPE_STRING, MGR_FAVORITES_NAME_ATT_NAME,
G_TYPE_STRING, "summary");
treeview = ui_make_tree_view (model);
tsel->priv->treeview = treeview;
g_object_unref (model);
/* icon */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COLUMN_ICON);
g_object_set ((GObject*) renderer, "yalign", 0., NULL);
/* text */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) cell_data_func,
NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
/* scrolled window packing */
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (sw), treeview);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
gtk_box_pack_start (GTK_BOX (tsel), sw, TRUE, TRUE, 0);
gtk_widget_show_all (sw);
g_signal_connect (G_OBJECT (treeview), "row-activated",
G_CALLBACK (selection_changed_cb), tsel);
g_signal_connect (G_OBJECT (treeview), "key-press-event",
G_CALLBACK (key_press_event_cb), tsel);
g_signal_connect (G_OBJECT (treeview), "popup-menu",
G_CALLBACK (popup_menu_cb), tsel);
g_signal_connect (G_OBJECT (treeview), "button-press-event",
G_CALLBACK (button_press_event_cb), tsel);
/* DnD */
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (treeview), dbo_table, G_N_ELEMENTS (dbo_table),
GDK_ACTION_COPY);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (treeview), GDK_BUTTON1_MASK,
dbo_table, G_N_ELEMENTS (dbo_table),
GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect (model, "drag-drop",
G_CALLBACK (tree_store_drag_drop_cb), tsel);
g_signal_connect (model, "drag-can-drag",
G_CALLBACK (tree_store_drag_can_drag_cb), tsel);
g_signal_connect (model, "drag-get",
G_CALLBACK (tree_store_drag_get_cb), tsel);
return (GtkWidget*) tsel;
}
MimeView *mimeview_create(void)
{
MimeView *mimeview;
GtkWidget *paned;
GtkWidget *scrolledwin;
GtkWidget *treeview;
GtkTreeStore *store;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkWidget *mime_vbox;
GtkWidget *popupmenu;
GtkItemFactory *popupfactory;
gint n_entries;
GtkWidget *reply_separator;
GtkWidget *reply_menuitem;
GList *child;
debug_print(_("Creating MIME view...\n"));
mimeview = g_new0(MimeView, 1);
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_widget_set_size_request(scrolledwin, -1, 80);
store = gtk_tree_store_new(N_COLS, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER);
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeview), COL_NAME);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(treeview), FALSE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Data type"), renderer, "text", COL_MIMETYPE, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "xalign", 1.0, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Size"), renderer, "text", COL_SIZE, NULL);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Name"), renderer, "text", COL_NAME, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_tree_view_enable_model_drag_source
(GTK_TREE_VIEW(treeview), GDK_BUTTON1_MASK,
mimeview_mime_types, 1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(mimeview_selection_changed), mimeview);
g_signal_connect(G_OBJECT(treeview), "button_press_event",
G_CALLBACK(mimeview_button_pressed), mimeview);
g_signal_connect(G_OBJECT(treeview), "key_press_event",
G_CALLBACK(mimeview_key_pressed), mimeview);
g_signal_connect_after(G_OBJECT (treeview),"drag-begin",
G_CALLBACK (mimeview_drag_begin), mimeview);
g_signal_connect(G_OBJECT (treeview),"drag-end",
G_CALLBACK (mimeview_drag_end), mimeview);
g_signal_connect(G_OBJECT(treeview), "drag-data-get",
G_CALLBACK(mimeview_drag_data_get), mimeview);
mime_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_set_reallocate_redraws(GTK_CONTAINER(mime_vbox), TRUE);
paned = gtk_vpaned_new();
gtk_paned_add1(GTK_PANED(paned), scrolledwin);
gtk_paned_add2(GTK_PANED(paned), mime_vbox);
n_entries = sizeof(mimeview_popup_entries) /
sizeof(mimeview_popup_entries[0]);
popupmenu = menu_create_items(mimeview_popup_entries, n_entries,
"<MimeView>", &popupfactory, mimeview);
reply_menuitem = gtk_item_factory_get_item(popupfactory, "/Reply");
child = g_list_find(GTK_MENU_SHELL(popupmenu)->children,
reply_menuitem);
reply_separator = GTK_WIDGET(child->prev->data);
mimeview->paned = paned;
mimeview->scrolledwin = scrolledwin;
mimeview->treeview = treeview;
mimeview->store = store;
mimeview->selection = selection;
mimeview->mime_vbox = mime_vbox;
mimeview->popupmenu = popupmenu;
mimeview->popupfactory = popupfactory;
mimeview->reply_separator = reply_separator;
mimeview->reply_menuitem = reply_menuitem;
mimeview->type = -1;
return mimeview;
}
