static void _new_contents(Helper * helper)
{
GtkWidget * widget;
GtkTreeModel * model;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
model = gtk_tree_model_filter_new(GTK_TREE_MODEL(helper->store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),
_helper_filter_contents, NULL, NULL);
model = gtk_tree_model_sort_new_with_model(model);
helper->contents = gtk_tree_view_new_with_model(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(helper->contents),
FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(helper->contents),
HSC_CONTENTS_PACKAGE);
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
"pixbuf", HSC_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(helper->contents), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Package"),
renderer, "text", HSC_CONTENTS_PACKAGE, NULL);
gtk_tree_view_column_set_sort_column_id(column, HSC_CONTENTS_PACKAGE);
gtk_tree_view_append_column(GTK_TREE_VIEW(helper->contents), column);
gtk_tree_view_column_clicked(column);
g_signal_connect(helper->contents, "row-activated", G_CALLBACK(
_helper_on_contents_row_activated), helper);
gtk_container_add(GTK_CONTAINER(widget), helper->contents);
gtk_notebook_append_page(GTK_NOTEBOOK(helper->notebook), widget,
gtk_label_new(_("Contents")));
}
static void
adblock_ui_build_treeview (AdblockUI *dialog)
{
GtkCellRenderer *renderer;
dialog->priv->store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING);
renderer = gtk_cell_renderer_text_new ();
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect(renderer,
"edited",
(GCallback) adblock_ui_cell_edited_cb,
(gpointer)dialog);
gtk_tree_view_insert_column_with_attributes (dialog->priv->treeview,
COL_FILTER_URI, _("Filter URI"),
renderer,
"text", COL_FILTER_URI,
NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dialog->priv->store),
COL_FILTER_URI,
GTK_SORT_ASCENDING);
gtk_tree_view_set_model (dialog->priv->treeview, GTK_TREE_MODEL (dialog->priv->store));
gtk_tree_view_set_search_column (dialog->priv->treeview, COL_FILTER_URI);
g_object_unref (dialog->priv->store);
dialog->priv->selection = gtk_tree_view_get_selection (dialog->priv->treeview);
gtk_tree_selection_set_mode (dialog->priv->selection, GTK_SELECTION_SINGLE);
dialog->priv->dirty = FALSE;
}
/**
* Create a new GtkTreeView for search results.
*/
GtkWidget *
search_gui_create_tree(void)
{
GtkTreeModel *model = create_results_model();
GtkTreeSelection *selection;
GtkTreeView *tv;
tv = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
g_object_unref(model);
selection = gtk_tree_view_get_selection(tv);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_headers_clickable(tv, TRUE);
gtk_tree_view_set_headers_visible(tv, TRUE);
gtk_tree_view_set_enable_search(tv, TRUE);
gtk_tree_view_set_search_column(tv, 0);
gtk_tree_view_set_rules_hint(tv, TRUE);
gtk_tree_view_set_search_equal_func(tv, search_by_regex, NULL, NULL);
tree_view_set_fixed_height_mode(tv, TRUE);
/* add columns to the tree view */
add_results_columns(tv);
tree_view_restore_visibility(tv, PROP_SEARCH_RESULTS_COL_VISIBLE);
tree_view_restore_widths(tv, PROP_SEARCH_RESULTS_COL_WIDTHS);
gui_signal_connect(tv,
"cursor-changed", on_tree_view_search_results_select_row, tv);
gui_signal_connect(tv, "leave-notify-event", on_leave_notify, NULL);
return GTK_WIDGET(tv);
}
static void trg_peers_tree_view_setup_columns(TrgPeersTreeView * self, TrgPeersModel *model)
{
TrgTreeView *ttv = TRG_TREE_VIEW(self);
trg_column_description *desc;
desc =
trg_tree_view_reg_column(ttv, TRG_COLTYPE_ICONTEXT,
PEERSCOL_IP, _("IP"), "ip", 0);
desc->model_column_extra = PEERSCOL_ICON;
trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_HOST,
_("Host"), "host", 0);
#ifdef HAVE_GEOIP
if (trg_peers_model_has_country_db(model))
trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_COUNTRY,
_("Country"), "country", 0);
if (trg_peers_model_has_city_db(model))
trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_CITY,
_("City"), "city", 0);
#endif
trg_tree_view_reg_column(ttv, TRG_COLTYPE_SPEED, PEERSCOL_DOWNSPEED,
_("Down Speed"), "down-speed", 0);
trg_tree_view_reg_column(ttv, TRG_COLTYPE_SPEED, PEERSCOL_UPSPEED,
_("Up Speed"), "up-speed", 0);
trg_tree_view_reg_column(ttv, TRG_COLTYPE_PROG, PEERSCOL_PROGRESS,
_("Progress"), "progress", 0);
trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_FLAGS,
_("Flags"), "flags", 0);
trg_tree_view_reg_column(ttv, TRG_COLTYPE_TEXT, PEERSCOL_CLIENT,
_("Client"), "client", 0);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(self), PEERSCOL_HOST);
}
/*
* Return a GtkTreeView* populated with data from all desktop entries.
*/
GtkWidget *
apps_tree_new()
{
GtkWidget *apps_tree;
GtkListStore *apps;
GtkTreeViewColumn *name_col;
GValue g_3 = G_VALUE_INIT;
GtkCellRenderer *cellr;
g_value_init(&g_3, G_TYPE_INT);
g_value_set_int(&g_3, 3);
if ((apps = collect_apps()) == NULL)
return NULL;
apps_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(apps));
cellr = bs_cell_renderer_entry_new();
name_col = gtk_tree_view_column_new_with_attributes(
"Entry", cellr,
"name", NAME_COLUMN,
"exec", EXEC_COLUMN,
"icon", ICON_COLUMN,
NULL);
g_object_set_property(G_OBJECT(cellr), "xpad", &g_3);
g_object_set_property(G_OBJECT(cellr), "ypad", &g_3);
gtk_tree_view_append_column(GTK_TREE_VIEW(apps_tree), name_col);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(apps_tree), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(apps_tree), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(apps_tree), 0);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(apps),
NAME_COLUMN, GTK_SORT_ASCENDING);
return apps_tree;
}
void
MergeWinState(struct SubWin *d, int state)
{
if (d->Win) {
sub_window_set_visibility(d, state);
return;
}
if (! state) {
return;
}
list_sub_window_create(d, "Merge Window", MERG_WIN_COL_NUM, Mlist, Mergewin_xpm, Mergewin48_xpm);
d->data.data->update = MergeWinUpdate;
d->data.data->setup_dialog = MergeDialog;
d->data.data->dialog = &DlgMerge;
d->data.data->obj = chkobject("merge");
sub_win_create_popup_menu(d->data.data, POPUP_ITEM_NUM, Popup_list, G_CALLBACK(popup_show_cb));
init_dnd(d);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(d->data.data->text), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(d->data.data->text), MERG_WIN_COL_FILE);
tree_view_set_tooltip_column(GTK_TREE_VIEW(d->data.data->text), MERG_WIN_COL_FILE);
}
static void LoadCheatListItems(int index) {
GtkListStore *store = gtk_list_store_new(2, G_TYPE_BOOLEAN, G_TYPE_STRING);
GtkTreeIter iter;
GtkWidget *widget;
int i;
widget = gtk_builder_get_object(builder, "GtkCList_Cheat");
for (i = 0; i < NumCheats; i++) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, Cheats[i].Enabled, 1, Cheats[i].Descr, -1);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(widget), GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(widget), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(widget), 1);
gtk_widget_show(widget);
if (index >= NumCheats) {
index = NumCheats - 1;
}
if (index >= 0) {
GtkTreePath *path;
GtkTreeSelection *sel;
path = gtk_tree_path_new_from_indices(index, -1);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
gtk_tree_selection_select_path(sel, path);
gtk_tree_path_free(path);
}
}
static void
build_search_entry(GitgWindow *window, GtkBuilder *builder)
{
GtkWidget *box = GTK_WIDGET(gtk_builder_get_object(builder, "hbox_top"));
GtkWidget *entry = sexy_icon_entry_new();
GtkImage *image = GTK_IMAGE(gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU));
sexy_icon_entry_set_icon(SEXY_ICON_ENTRY(entry), SEXY_ICON_ENTRY_PRIMARY, image);
gtk_tree_view_set_search_entry(window->priv->tree_view, GTK_ENTRY(entry));
gtk_widget_show(entry);
gtk_box_pack_end(GTK_BOX(box), entry, FALSE, FALSE, 0);
GtkBuilder *b = gitg_utils_new_builder( "gitg-menus.xml");
GtkUIManager *manager = GTK_UI_MANAGER(gtk_builder_get_object(b, "uiman"));
window->priv->search_popup = GTK_WIDGET(g_object_ref(gtk_ui_manager_get_widget(manager, "/ui/search_popup")));
gtk_builder_connect_signals(b, window);
g_object_unref(b);
g_signal_connect(entry, "icon-pressed", G_CALLBACK(on_search_icon_pressed), window);
gtk_tree_view_set_search_column(window->priv->tree_view, 1);
gtk_tree_view_set_search_equal_func(window->priv->tree_view, search_equal_func, window, NULL);
GtkAccelGroup *group = gtk_accel_group_new();
GClosure *closure = g_cclosure_new(G_CALLBACK(focus_search), entry, NULL);
gtk_accel_group_connect(group, GDK_f, GDK_CONTROL_MASK, 0, closure);
gtk_window_add_accel_group(GTK_WINDOW(window), group);
}
void
search_column_activate(GtkAction *action, gint column, GtkTreeView *tree_view)
{
if (!gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action)))
return;
gtk_tree_view_set_search_column(tree_view, column);
}
void iopen_init(GtkWidget *window) {
parent_window = window;
GtkWidget *main_vbox = gtk_vbox_new(false, 0);
iopen_buffer = buffer_create();
iopen_buffer->single_line = true;
load_empty(iopen_buffer);
iopen_editor = new_editor(iopen_buffer, true);
buffer_set_onchange(iopen_buffer, iopen_buffer_onchange);
config_set(&(iopen_buffer->config), CFG_AUTOWRAP, "0");
config_set(&(iopen_buffer->config), CFG_AUTOCOMPL_POPUP, "0");
iopen_editor->single_line_escape = &iopen_escape;
iopen_editor->single_line_return = &iopen_enter;
iopen_editor->single_line_other_keys = &iopen_other_keys;
gtk_box_pack_start(GTK_BOX(main_vbox), GTK_WIDGET(iopen_editor), FALSE, FALSE, 0);
results_list = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_DOUBLE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(results_list), 3, GTK_SORT_ASCENDING);
results_tree = gtk_tree_view_new();
crt = gtk_cell_renderer_text_new();
iopen_recoloring();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(results_tree), -1, "Show", crt, "markup", 0, NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(results_tree), GTK_TREE_MODEL(results_list));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(results_tree), FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(results_tree), 1);
g_signal_connect(G_OBJECT(results_tree), "row-activated", G_CALLBACK(result_activated_callback), NULL);
GtkWidget *results_scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(results_scroll), results_tree);
gtk_box_pack_start(GTK_BOX(main_vbox), frame_piece(TRUE), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(main_vbox), results_scroll, TRUE, TRUE, 0);
iopen_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated(GTK_WINDOW(iopen_window), TRUE);
gtk_window_set_default_size(GTK_WINDOW(iopen_window), 640, 480);
g_signal_connect(G_OBJECT(iopen_window), "delete-event", G_CALLBACK(delete_callback), NULL);
g_signal_connect(G_OBJECT(iopen_window), "map_event", G_CALLBACK(map_callback), NULL);
gtk_container_add(GTK_CONTAINER(iopen_window), main_vbox);
file_recursor_requests = g_async_queue_new();
tags_requests = g_async_queue_new();
buffers_requests = g_async_queue_new();
g_thread_new("iopen file recursion", iopen_recursor_thread, NULL);
g_thread_new("tags iteration", iopen_tags_thread, NULL);
g_thread_new("buffer iteration", iopen_buffer_thread, NULL);
}
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);
}
/* Static functions */
static void
gal_view_instance_save_as_dialog_set_instance (GalViewInstanceSaveAsDialog *dialog,
GalViewInstance *instance)
{
GtkListStore *store;
GtkCellRenderer *renderer;
gint ii, view_count;
dialog->instance = instance;
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
view_count = gal_view_collection_get_count (instance->collection);
for (ii = 0; ii < view_count; ii++) {
GalViewCollectionItem *item;
GtkTreeIter iter;
gchar *title = NULL;
item = gal_view_collection_get_view_item (
instance->collection, ii);
title = e_str_without_underscores (item->title);
gtk_list_store_append (store, &iter);
gtk_list_store_set (
store, &iter,
COL_GALVIEW_NAME, title,
COL_GALVIEW_DATA, item,
-1);
g_free (title);
}
gtk_tree_sortable_set_sort_column_id (
GTK_TREE_SORTABLE (store),
COL_GALVIEW_NAME, GTK_SORT_ASCENDING);
/* attaching treeview to model */
gtk_tree_view_set_model (dialog->treeview, GTK_TREE_MODEL (store));
gtk_tree_view_set_search_column (dialog->treeview, COL_GALVIEW_NAME);
dialog->model = GTK_TREE_MODEL (store);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (
dialog->treeview,
COL_GALVIEW_NAME, _("Name"),
renderer, "text", COL_GALVIEW_NAME,
NULL);
/* set sort column */
gtk_tree_sortable_set_sort_column_id (
GTK_TREE_SORTABLE (dialog->model),
COL_GALVIEW_NAME, GTK_SORT_ASCENDING);
}
static gboolean serverstats_idle_handler(ss_str * s)
{
GtkTreeIter iter;
MpdDBStats *stats = NULL;
if (s->data == NULL || !mpd_check_connected(connection) || cancel_query)
{
if (gtk_tree_model_get_iter_first(s->model, &iter))
{
do
{
guint d;
gulong i;
gchar *value = NULL;
gtk_tree_model_get(s->model, &iter, 0, &i, -1);
d = (guint) 100 *(i / (double)s->max_i);
value = format_time_real(i, "");
gtk_list_store_set(GTK_LIST_STORE(s->model), &iter, 2, d, 3, value, -1);
g_free(value);
} while (gtk_tree_model_iter_next(s->model, &iter));
}
if (s->data)
mpd_data_free(s->data);
gtk_tree_view_set_model(GTK_TREE_VIEW(serverstats_tree), s->model);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(serverstats_tree), 1);
gtk_widget_set_sensitive(GTK_WIDGET(s->box), TRUE);
gtk_widget_hide(gtk_widget_get_parent(s->pb));
if (cancel_query)
gtk_list_store_clear(GTK_LIST_STORE(s->model));
g_free(s);
cancel_query = FALSE;
return FALSE;
}
mpd_database_search_stats_start(connection);
mpd_database_search_add_constraint(connection, s->tag, s->data->tag);
stats = mpd_database_search_stats_commit(connection);
if (stats)
{
gtk_list_store_prepend(GTK_LIST_STORE(s->model), &iter);
gtk_list_store_set(GTK_LIST_STORE(s->model), &iter, 0, (unsigned long)(stats->playTime), 1, s->data->tag, -1);
s->max_i = MAX(s->max_i, stats->playTime);
mpd_database_search_free_stats(stats);
}
/* limit the amount of updating to 0.2 % */
if ((int)((1000 * s->hits) / s->total) % 5 == 0)
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(s->pb), s->hits / (double)s->total);
}
s->hits++;
s->data = mpd_data_get_next(s->data);
return TRUE;
}
SidebarIndexPage::SidebarIndexPage(Control* control) : AbstractSidebarPage(
control)
{
XOJ_INIT_TYPE(SidebarIndexPage);
this->searchTimeout = 0;
this->hasContents = false;
this->treeViewBookmarks = gtk_tree_view_new();
g_object_ref(this->treeViewBookmarks);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(treeViewBookmarks), true);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(treeViewBookmarks),
DOCUMENT_LINKS_COLUMN_NAME);
gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(treeViewBookmarks),
(GtkTreeViewSearchEqualFunc) treeSearchFunction, this, NULL);
this->scrollBookmarks = gtk_scrolled_window_new(NULL, NULL);
g_object_ref(this->scrollBookmarks);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollBookmarks),
GTK_SHADOW_IN);
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
treeViewBookmarks));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeViewBookmarks), FALSE);
gtk_container_add(GTK_CONTAINER(scrollBookmarks), treeViewBookmarks);
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeViewBookmarks), column);
GtkCellRenderer* renderer = (GtkCellRenderer*) g_object_new(
GTK_TYPE_CELL_RENDERER_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column), renderer, TRUE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"markup", DOCUMENT_LINKS_COLUMN_NAME, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(GTK_TREE_VIEW_COLUMN(column), renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column), renderer,
"text", DOCUMENT_LINKS_COLUMN_PAGE_NUMBER, NULL);
g_object_set(G_OBJECT(renderer), "style", PANGO_STYLE_ITALIC, NULL);
g_signal_connect(treeViewBookmarks, "cursor-changed",
G_CALLBACK(treeBookmarkSelected), this);
gtk_widget_show(this->treeViewBookmarks);
registerListener(control);
}
static void
logview_loglist_init (LogviewLoglist *list)
{
GtkTreeStore *model;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkCellRenderer *cell;
list->priv = GET_PRIVATE (list);
list->priv->has_day_selection = FALSE;
list->priv->selection = NULL;
model = gtk_tree_store_new (5, LOGVIEW_TYPE_LOG, G_TYPE_STRING, G_TYPE_INT,
G_TYPE_BOOLEAN, G_TYPE_POINTER);
gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (model));
list->priv->model = model;
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list), FALSE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed",
G_CALLBACK (tree_selection_changed_cb), list);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text", LOG_NAME,
"weight-set", LOG_WEIGHT_SET,
"weight", LOG_WEIGHT,
NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list->priv->model), LOG_NAME, GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (list->priv->model),
LOG_NAME,
(GtkTreeIterCompareFunc) loglist_sort_func,
list, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (list), -1);
list->priv->manager = logview_manager_get ();
g_signal_connect (list->priv->manager, "log-added",
G_CALLBACK (manager_log_added_cb), list);
g_signal_connect (list->priv->manager, "log-closed",
G_CALLBACK (manager_log_closed_cb), list);
g_signal_connect_after (list->priv->manager, "active-changed",
G_CALLBACK (manager_active_changed_cb), list);
g_signal_connect (list, "row-expanded",
G_CALLBACK (row_expanded_cb), list);
}
static void
gtk_app_chooser_widget_init (GtkAppChooserWidget *self)
{
GtkTreeSelection *selection;
GtkTreeModel *sort;
GtkGesture *gesture;
self->priv = gtk_app_chooser_widget_get_instance_private (self);
gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
gtk_widget_init_template (GTK_WIDGET (self));
/* Various parts of the GtkTreeView code need custom code to setup, mostly
* because we lack signals to connect to, or properties to set.
*/
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_selection_set_select_function (selection, gtk_app_chooser_selection_func,
self, NULL);
sort = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->program_list));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
gtk_app_chooser_sort_func,
self, NULL);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->program_list), COLUMN_NAME);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (self->priv->program_list),
gtk_app_chooser_search_equal_func,
NULL, NULL);
gtk_tree_view_column_set_cell_data_func (self->priv->column,
self->priv->secondary_padding,
padding_cell_renderer_func,
NULL, NULL);
self->priv->monitor = g_app_info_monitor_get ();
g_signal_connect (self->priv->monitor, "changed",
G_CALLBACK (app_info_changed), self);
gesture = gtk_gesture_multi_press_new ();
gtk_gesture_single_set_button (GTK_GESTURE_SINGLE (gesture), GDK_BUTTON_SECONDARY);
g_signal_connect (gesture, "pressed",
G_CALLBACK (gtk_app_chooser_row_pressed_cb), self);
gtk_widget_add_controller (self->priv->program_list, GTK_EVENT_CONTROLLER (gesture));
}
void
gucharmap_chapters_view_set_model (GucharmapChaptersView *view,
GucharmapChaptersModel *model)
{
GucharmapChaptersViewPrivate *priv = view->priv;
GtkTreeView *tree_view = GTK_TREE_VIEW (view);
priv->model = model;
gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL (model));
if (!model)
return;
gtk_tree_view_column_set_title (priv->column, gucharmap_chapters_model_get_title (model));
/* Need to re-set this here since it's set to -1 when the tree view model changes! */
gtk_tree_view_set_search_column (tree_view, GUCHARMAP_CHAPTERS_MODEL_COLUMN_LABEL);
}
int main(int argc, char *argv[]) {
gtk_init(&argc, &argv);
gchar *dirname = g_path_get_dirname(argv[0]);
gchar *dataFilename = g_build_filename(dirname, "phonebook.dat", NULL);
base_t *ctx = base_new(dataFilename);
g_free(dirname);
g_free(dataFilename);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "PSP1Beleg");
gtk_window_set_default_size(GTK_WINDOW(window), 640, 480);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
gbase_list_singleton = gbase_list_new(ctx);
tree_view_singleton = gtk_tree_view_new_with_model(GTK_TREE_MODEL(gbase_list_singleton));
g_object_unref(gbase_list_singleton);
//fill_model(gbase_list_singleton);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(tree_view_singleton), GBASE_LIST_COL_NUMBER);
g_signal_connect(G_OBJECT(tree_view_singleton), "key-press-event", G_CALLBACK(on_key_press), NULL);
append_column(GBASE_LIST_COL_NUMBER, "Phone Number");
append_column(GBASE_LIST_COL_NAME, "Surname");
append_column(GBASE_LIST_COL_FORENAME, "Forename");
GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrolled_window), tree_view_singleton);
gtk_container_add(GTK_CONTAINER(window), scrolled_window);
gtk_widget_show_all(window);
gtk_main();
bool ok = base_save(ctx);
base_delete(ctx);
return ok ? 0 : 1;
}
void
treeview2_set_up_constants(GtkTreeView *treeview, gint type)
{
#ifdef DEBUG
printf("treeview2_set_up_constants\n");
#endif
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
gchar *titles[2] =
{_("Name"),
_("Value")};
gint i;
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(treeview),
GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(treeview, TRUE);
gtk_tree_view_set_rules_hint(treeview, TRUE);
gtk_tree_view_set_search_column(treeview, 0);
gtk_tree_view_set_search_equal_func(treeview,
treeview_helper_search_equal_strings,
NULL, NULL);
for(i = 0; i < 2; i++)
{
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, titles[i]);
gtk_tree_view_append_column(treeview, col);
renderer = treeview_helper_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer,
"text", i);
if(i == 1)
{
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect (renderer,
"edited",
(type == CONSTANTS_TYPE_APP) ?
G_CALLBACK (treeview_helper_constants_app_editing_done) :
G_CALLBACK (treeview_helper_constants_editing_done),
treeview);
}
}
}
static void bar_exif_advanced_build_view(ExifBar *eb)
{
GtkListStore *store;
if (eb->listview) return;
store = gtk_list_store_new(7, G_TYPE_BOOLEAN,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
eb->listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(eb->listview), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(eb->listview), TRUE);
if (eb->allow_search)
{
gtk_tree_view_set_search_column(GTK_TREE_VIEW(eb->listview), EXIF_ADVCOL_NAME);
}
else
{
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(eb->listview), FALSE);
}
bar_exif_add_column_check(eb->listview, "", EXIF_ADVCOL_ENABLED);
bar_exif_add_column(eb->listview, _("Tag"), EXIF_ADVCOL_TAG, FALSE);
bar_exif_add_column(eb->listview, _("Name"), EXIF_ADVCOL_NAME, FALSE);
bar_exif_add_column(eb->listview, _("Value"), EXIF_ADVCOL_VALUE, TRUE);
bar_exif_add_column(eb->listview, _("Format"), EXIF_ADVCOL_FORMAT, FALSE);
bar_exif_add_column(eb->listview, _("Elements"), EXIF_ADVCOL_ELEMENTS, FALSE);
bar_exif_add_column(eb->listview, _("Description"), EXIF_ADVCOL_DESCRIPTION, FALSE);
eb->advanced_scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(eb->advanced_scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(eb->advanced_scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(eb->vbox), eb->advanced_scrolled, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(eb->advanced_scrolled), eb->listview);
gtk_widget_show(eb->listview);
}
static void
new_chatroom_dialog_model_setup (EmpathyNewChatroomDialog *dialog)
{
GtkTreeView *view;
GtkListStore *store;
GtkTreeSelection *selection;
/* View */
view = GTK_TREE_VIEW (dialog->treeview);
g_signal_connect (view, "row-activated",
G_CALLBACK (new_chatroom_dialog_model_row_activated_cb),
dialog);
/* Store/Model */
store = gtk_list_store_new (COL_COUNT,
G_TYPE_STRING, /* Invite */
G_TYPE_STRING, /* Password */
G_TYPE_STRING, /* Name */
G_TYPE_STRING, /* Room */
G_TYPE_STRING, /* Member count */
G_TYPE_INT, /* Member count int */
G_TYPE_STRING); /* Tool tip */
dialog->model = GTK_TREE_MODEL (store);
gtk_tree_view_set_model (view, dialog->model);
gtk_tree_view_set_tooltip_column (view, COL_TOOLTIP);
gtk_tree_view_set_search_column (view, COL_NAME);
/* Selection */
selection = gtk_tree_view_get_selection (view);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
COL_NAME, GTK_SORT_ASCENDING);
g_signal_connect (selection, "changed",
G_CALLBACK (new_chatroom_dialog_model_selection_changed),
dialog);
/* Columns */
new_chatroom_dialog_model_add_columns (dialog);
}
static void apply_window_create_list_view_columns(GtkWidget *list_view)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
column = gtk_tree_view_column_new_with_attributes
(_("Tag"),
renderer,
"text", TAG_NAME,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(list_view), column);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(list_view),
TAG_NAME);
g_signal_connect(G_OBJECT(renderer), "edited",
G_CALLBACK(tag_apply_selected_edited),
list_view);
}
static GtkWidget *pluginwindow_list_view_create(PluginWindow *pluginwindow)
{
GtkTreeView *list_view;
GtkTreeSelection *selector;
GtkTreeModel *model;
model = GTK_TREE_MODEL(pluginwindow_create_data_store());
list_view = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
g_object_unref(model);
gtk_tree_view_set_rules_hint(list_view, prefs_common.use_stripes_everywhere);
gtk_tree_view_set_search_column (list_view, 0);
selector = gtk_tree_view_get_selection(list_view);
gtk_tree_selection_set_mode(selector, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selector, pluginwindow_selected,
pluginwindow, NULL);
/* create the columns */
pluginwindow_create_list_view_columns(GTK_WIDGET(list_view));
return GTK_WIDGET(list_view);
}
static void prepare_file_view(void)
{
GtkCellRenderer *text_renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
PangoFontDescription *pfd;
file_store = gtk_list_store_new(FILEVIEW_N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(file_view), GTK_TREE_MODEL(file_store));
text_renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(column, text_renderer, TRUE);
gtk_tree_view_column_set_attributes(column, text_renderer, "text", FILEVIEW_COLUMN_NAME,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(file_view), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(file_view), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(file_view), TRUE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(file_view), FILEVIEW_COLUMN_NAME);
pfd = pango_font_description_from_string(geany_data->interface_prefs->tagbar_font);
gtk_widget_modify_font(file_view, pfd);
pango_font_description_free(pfd);
/* selection handling */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(file_view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(file_view), "button-release-event",
G_CALLBACK(on_button_release), NULL);
g_signal_connect(G_OBJECT(file_view), "button-press-event",
G_CALLBACK(on_button_press), NULL);
g_signal_connect(G_OBJECT(file_view), "key-press-event", G_CALLBACK(on_key_press), NULL);
}
BookmarkList *
bookmark_list_new (gboolean menu_icons)
{
BookmarkList *book_list;
GtkWidget *scrolled;
GtkTreeView *list_view;
book_list = g_new0 (BookmarkList, 1);
book_list->list = NULL;
book_list->menu_icons = menu_icons;
/* Create the widgets. */
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_ETCHED_IN);
book_list->list_store = gtk_list_store_new (BOOK_LIST_NUM_COLUMNS,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_STRING);
list_view = (GtkTreeView*) gtk_tree_view_new_with_model (GTK_TREE_MODEL (book_list->list_store));
gtk_tree_view_set_rules_hint (list_view, FALSE);
add_columns (list_view);
gtk_tree_view_set_headers_visible (list_view, FALSE);
gtk_tree_view_set_enable_search (list_view, TRUE);
gtk_tree_view_set_search_column (list_view, BOOK_LIST_COLUMN_NAME);
book_list->list_view = (GtkWidget*) list_view;
gtk_container_add (GTK_CONTAINER (scrolled), book_list->list_view);
book_list->root_widget = scrolled;
return book_list;
}
static PanelAddtoDialog *
panel_addto_dialog_new (PanelWidget *panel_widget)
{
PanelAddtoDialog *dialog;
GtkWidget *dialog_vbox;
GtkWidget *inner_vbox;
GtkWidget *find_hbox;
GtkWidget *sw;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
dialog = g_new0 (PanelAddtoDialog, 1);
g_object_set_qdata_full (G_OBJECT (panel_widget->toplevel),
panel_addto_dialog_quark,
dialog,
(GDestroyNotify) panel_addto_dialog_free);
dialog->panel_widget = panel_widget;
dialog->name_notify =
panel_profile_toplevel_notify_add (
dialog->panel_widget->toplevel,
"name",
(MateConfClientNotifyFunc) panel_addto_name_notify,
dialog);
dialog->addto_dialog = gtk_dialog_new ();
gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_HELP, GTK_RESPONSE_HELP);
dialog->back_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_GO_BACK,
PANEL_ADDTO_RESPONSE_BACK);
dialog->add_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_ADD,
PANEL_ADDTO_RESPONSE_ADD);
gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE);
gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), FALSE);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog->addto_dialog),
FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog->addto_dialog),
PANEL_ADDTO_RESPONSE_ADD);
gtk_container_set_border_width (GTK_CONTAINER (dialog->addto_dialog), 5);
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog->addto_dialog));
gtk_box_set_spacing (GTK_BOX (dialog_vbox), 12);
gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
g_signal_connect (G_OBJECT (dialog->addto_dialog), "response",
G_CALLBACK (panel_addto_dialog_response), dialog);
g_signal_connect (dialog->addto_dialog, "destroy",
G_CALLBACK (panel_addto_dialog_destroy), dialog);
inner_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0);
find_hbox = gtk_hbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (inner_vbox), find_hbox, FALSE, FALSE, 0);
dialog->label = gtk_label_new_with_mnemonic ("");
gtk_misc_set_alignment (GTK_MISC (dialog->label), 0.0, 0.5);
gtk_label_set_use_markup (GTK_LABEL (dialog->label), TRUE);
gtk_box_pack_start (GTK_BOX (find_hbox), dialog->label,
FALSE, FALSE, 0);
dialog->search_entry = gtk_entry_new ();
g_signal_connect (G_OBJECT (dialog->search_entry), "changed",
G_CALLBACK (panel_addto_search_entry_changed), dialog);
g_signal_connect (G_OBJECT (dialog->search_entry), "activate",
G_CALLBACK (panel_addto_search_entry_activated), dialog);
gtk_box_pack_end (GTK_BOX (find_hbox), dialog->search_entry,
TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (dialog->label),
dialog->search_entry);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (inner_vbox), sw, TRUE, TRUE, 0);
dialog->tree_view = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view),
FALSE);
gtk_tree_view_expand_all (GTK_TREE_VIEW (dialog->tree_view));
renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF,
"xpad", 4,
"ypad", 4,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view),
-1, NULL,
renderer,
"pixbuf", COLUMN_ICON,
NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view),
-1, NULL,
renderer,
"markup", COLUMN_TEXT,
NULL);
//FIXME use the same search than the one for the search entry?
gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->tree_view),
COLUMN_SEARCH);
gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (dialog->tree_view),
panel_addto_separator_func,
GINT_TO_POINTER (COLUMN_TEXT),
NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->tree_view),
COLUMN_TEXT);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
g_signal_connect (selection, "changed",
G_CALLBACK (panel_addto_selection_changed),
dialog);
g_signal_connect (dialog->tree_view, "row-activated",
G_CALLBACK (panel_addto_selection_activated),
dialog);
gtk_container_add (GTK_CONTAINER (sw), dialog->tree_view);
gtk_widget_show_all (dialog_vbox);
panel_toplevel_push_autohide_disabler (dialog->panel_widget->toplevel);
panel_widget_register_open_dialog (panel_widget,
dialog->addto_dialog);
panel_addto_name_change (dialog,
panel_toplevel_get_name (dialog->panel_widget->toplevel));
return dialog;
}
static void plugin_manager_create(void)
{
GtkWidget *window;
GtkWidget *vbox;
#ifdef USE_UPDATE_CHECK_PLUGIN
GtkWidget *update_check_btn;
#endif
GtkWidget *close_btn;
GtkWidget *confirm_area;
GtkWidget *scrolledwin;
GtkWidget *treeview;
GtkListStore *store;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), _("Plug-in manager"));
gtk_widget_set_size_request(window, 600, 400);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, TRUE);
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtkut_stock_button_set_create(&confirm_area,
#ifdef USE_UPDATE_CHECK_PLUGIN
&update_check_btn, _("Check for _update"),
&close_btn, GTK_STOCK_CLOSE,
NULL, NULL);
gtkut_box_set_reverse_order(GTK_BOX(confirm_area), TRUE);
#else
&close_btn, GTK_STOCK_CLOSE,
NULL, NULL,
NULL, NULL);
#endif
gtk_widget_show(confirm_area);
gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0);
gtk_widget_grab_default(close_btn);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(plugin_manager_deleted), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(key_pressed), NULL);
#ifdef USE_UPDATE_CHECK_PLUGIN
g_signal_connect(G_OBJECT(update_check_btn), "clicked",
G_CALLBACK(plugin_manager_update_check), NULL);
#endif
g_signal_connect(G_OBJECT(close_btn), "clicked",
G_CALLBACK(plugin_manager_deleted), NULL);
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwin);
gtk_widget_set_size_request(scrolledwin, -1, -1);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwin, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_SHADOW_IN);
store = gtk_list_store_new(N_COLS, G_TYPE_STRING);
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_INFO);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(treeview),
GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
#endif
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes
(_("Plug-in information"), renderer, "text", COL_INFO, NULL);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
gtk_widget_show(treeview);
gtk_container_add(GTK_CONTAINER(scrolledwin), treeview);
gtk_widget_show_all(window);
pm_window.window = window;
pm_window.close_btn = close_btn;
pm_window.treeview = treeview;
pm_window.store = store;
pm_window.selection = selection;
}
void Config_macros(GtkAction *action, gpointer data)
{
GtkWidget *vbox, *hbox;
GtkWidget *sw;
GtkTreeModel *model;
GtkWidget *treeview;
GtkWidget *button;
GtkWidget *separator;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), _("Configure Macros"));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
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_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create tree model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
COLUMN_SHORTCUT);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* add columns to the tree view */
add_columns (GTK_TREE_VIEW (treeview));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic (_("_Add"));
g_signal_connect(button, "clicked", G_CALLBACK(Add_shortcut), (gpointer)model);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_mnemonic (_("_Delete"));
g_signal_connect(button, "clicked", G_CALLBACK(Delete_shortcut), (gpointer)treeview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_mnemonic (_("_Capture Shortcut"));
g_signal_connect(button, "clicked", G_CALLBACK(Capture_shortcut), (gpointer)treeview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_HELP);
g_signal_connect(button, "clicked", G_CALLBACK(Help_screen), (gpointer)window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
g_signal_connect(button, "clicked", G_CALLBACK(Save_shortcuts), (gpointer)treeview);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer)window);
gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer)window);
gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW(window), 300, 400);
gtk_widget_show_all(window);
}
static GtkWidget *
input_chooser_new (GtkWindow *main_window,
GtkListStore *active_sources)
{
GtkBuilder *builder;
GtkWidget *chooser;
GtkWidget *filtered_list;
GtkWidget *filter_entry;
GtkTreeViewColumn *visible_column;
GtkTreeSelection *selection;
GtkListStore *model;
GtkTreeModelFilter *filtered_model;
GtkTreeIter iter;
GError *error = NULL;
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder,
"/ui/gnome-region-panel-input-chooser.ui",
&error);
if (error)
g_error ("Problem parsing ui file %s", error->message);
chooser = WID ("input_source_chooser");
input_chooser = chooser;
g_object_add_weak_pointer (G_OBJECT (chooser), (gpointer *) &input_chooser);
g_object_set_data_full (G_OBJECT (chooser), "builder", builder, g_object_unref);
filtered_list = WID ("filtered_input_source_list");
filter_entry = WID ("input_source_filter");
g_object_set_data (G_OBJECT (chooser),
"filtered_input_source_list", filtered_list);
visible_column =
gtk_tree_view_column_new_with_attributes ("Input Sources",
gtk_cell_renderer_text_new (),
"text", NAME_COLUMN,
NULL);
gtk_window_set_transient_for (GTK_WINDOW (chooser), main_window);
gtk_tree_view_append_column (GTK_TREE_VIEW (filtered_list),
visible_column);
/* We handle searching ourselves, thank you. */
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (filtered_list), FALSE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (filtered_list), -1);
g_signal_connect_swapped (G_OBJECT (filter_entry), "activate",
G_CALLBACK (entry_activated), builder);
g_signal_connect_swapped (G_OBJECT (filter_entry), "notify::text",
G_CALLBACK (filter_changed), builder);
g_signal_connect (G_OBJECT (filter_entry), "icon-release",
G_CALLBACK (filter_clear), NULL);
filtered_model = GTK_TREE_MODEL_FILTER (gtk_builder_get_object (builder, "filtered_input_source_model"));
model = GTK_LIST_STORE (gtk_builder_get_object (builder, "input_source_model"));
populate_model (model, active_sources);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
NAME_COLUMN, GTK_SORT_ASCENDING);
gtk_tree_model_filter_set_visible_func (filtered_model,
filter_func,
NULL, NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (filtered_list));
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (selection_changed), builder);
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (filtered_model), &iter))
gtk_tree_selection_select_iter (selection, &iter);
g_signal_connect (G_OBJECT (filtered_list), "row-activated",
G_CALLBACK (row_activated), builder);
gtk_widget_grab_focus (filter_entry);
gtk_widget_show (chooser);
return chooser;
}
GtkWidget *
gimp_action_view_new (GimpUIManager *manager,
const gchar *select_action,
gboolean show_shortcuts)
{
GtkTreeView *view;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeStore *store;
GtkTreeModel *filter;
GtkAccelGroup *accel_group;
GList *list;
GtkTreePath *select_path = NULL;
g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL);
store = gtk_tree_store_new (GIMP_ACTION_VIEW_N_COLUMNS,
G_TYPE_BOOLEAN, /* COLUMN_VISIBLE */
GTK_TYPE_ACTION, /* COLUMN_ACTION */
G_TYPE_STRING, /* COLUMN_STOCK_ID */
G_TYPE_STRING, /* COLUMN_LABEL */
G_TYPE_STRING, /* COLUMN_LABEL_CASEFOLD */
G_TYPE_STRING, /* COLUMN_NAME */
G_TYPE_UINT, /* COLUMN_ACCEL_KEY */
GDK_TYPE_MODIFIER_TYPE, /* COLUMN_ACCEL_MASK */
G_TYPE_CLOSURE); /* COLUMN_ACCEL_CLOSURE */
accel_group = gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (manager));
for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager));
list;
list = g_list_next (list))
{
GimpActionGroup *group = list->data;
GList *actions;
GList *list2;
GtkTreeIter group_iter;
gtk_tree_store_append (store, &group_iter, NULL);
gtk_tree_store_set (store, &group_iter,
GIMP_ACTION_VIEW_COLUMN_STOCK_ID, group->stock_id,
GIMP_ACTION_VIEW_COLUMN_LABEL, group->label,
-1);
actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group));
actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare);
for (list2 = actions; list2; list2 = g_list_next (list2))
{
GtkAction *action = list2->data;
const gchar *name = gtk_action_get_name (action);
const gchar *stock_id = gtk_action_get_stock_id (action);
gchar *label;
gchar *label_casefold;
guint accel_key = 0;
GdkModifierType accel_mask = 0;
GClosure *accel_closure = NULL;
GtkTreeIter action_iter;
if (strstr (name, "-menu") ||
strstr (name, "-popup") ||
name[0] == '<')
continue;
label = gimp_strip_uline (gtk_action_get_label (action));
if (! (label && strlen (label)))
{
g_free (label);
label = g_strdup (name);
}
label_casefold = g_utf8_casefold (label, -1);
if (show_shortcuts)
{
accel_closure = gtk_action_get_accel_closure (action);
if (accel_closure)
{
GtkAccelKey *key;
key = gtk_accel_group_find (accel_group,
gimp_action_view_accel_find_func,
accel_closure);
if (key &&
key->accel_key &&
key->accel_flags & GTK_ACCEL_VISIBLE)
{
accel_key = key->accel_key;
accel_mask = key->accel_mods;
}
}
}
gtk_tree_store_append (store, &action_iter, &group_iter);
gtk_tree_store_set (store, &action_iter,
GIMP_ACTION_VIEW_COLUMN_VISIBLE, TRUE,
GIMP_ACTION_VIEW_COLUMN_ACTION, action,
GIMP_ACTION_VIEW_COLUMN_STOCK_ID, stock_id,
GIMP_ACTION_VIEW_COLUMN_LABEL, label,
GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, label_casefold,
GIMP_ACTION_VIEW_COLUMN_NAME, name,
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, accel_key,
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, accel_mask,
GIMP_ACTION_VIEW_COLUMN_ACCEL_CLOSURE, accel_closure,
-1);
g_free (label);
g_free (label_casefold);
if (select_action && ! strcmp (select_action, name))
{
select_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store),
&action_iter);
}
}
g_list_free (actions);
}
filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
g_object_unref (store);
view = g_object_new (GIMP_TYPE_ACTION_VIEW,
"model", filter,
"rules-hint", TRUE,
NULL);
g_object_unref (filter);
gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter),
GIMP_ACTION_VIEW_COLUMN_VISIBLE);
GIMP_ACTION_VIEW (view)->manager = g_object_ref (manager);
GIMP_ACTION_VIEW (view)->show_shortcuts = show_shortcuts;
gtk_tree_view_set_search_column (GTK_TREE_VIEW (view),
GIMP_ACTION_VIEW_COLUMN_LABEL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Action"));
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"stock-id",
GIMP_ACTION_VIEW_COLUMN_STOCK_ID,
NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text",
GIMP_ACTION_VIEW_COLUMN_LABEL,
NULL);
gtk_tree_view_append_column (view, column);
if (show_shortcuts)
{
g_signal_connect (view, "button-press-event",
G_CALLBACK (gimp_action_view_button_press),
NULL);
g_signal_connect (accel_group, "accel-changed",
G_CALLBACK (gimp_action_view_accel_changed),
view);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Shortcut"));
cell = gtk_cell_renderer_accel_new ();
g_object_set (cell,
"mode", GTK_CELL_RENDERER_MODE_EDITABLE,
"editable", TRUE,
NULL);
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"accel-key",
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY,
"accel-mods",
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK,
NULL);
g_signal_connect (cell, "accel-edited",
G_CALLBACK (gimp_action_view_accel_edited),
view);
g_signal_connect (cell, "accel-cleared",
G_CALLBACK (gimp_action_view_accel_cleared),
view);
gtk_tree_view_append_column (view, column);
}
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Name"));
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text",
GIMP_ACTION_VIEW_COLUMN_NAME,
NULL);
gtk_tree_view_append_column (view, column);
if (select_path)
{
gimp_action_view_select_path (GIMP_ACTION_VIEW (view), select_path);
gtk_tree_path_free (select_path);
}
return GTK_WIDGET (view);
}
