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; }