static void cryptui_key_store_init (CryptUIKeyStore *ckstore) { /* init private vars */ ckstore->priv = g_new0 (CryptUIKeyStorePriv, 1); /* Our key -> row ref mapping */ ckstore->priv->rows = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, (GDestroyNotify)gtk_tree_row_reference_free); /* The base store */ ckstore->priv->store = gtk_tree_store_newv (CRYPTUI_KEY_STORE_NCOLS, (GType*)col_types); /* The filtering model */ ckstore->priv->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (GTK_TREE_MODEL (ckstore->priv->store), NULL)); gtk_tree_model_filter_set_visible_func (ckstore->priv->filter, (GtkTreeModelFilterVisibleFunc)filter_callback, ckstore, NULL); }
static void panel_addto_make_application_model(PanelAddtoDialog* dialog) { GtkTreeStore* store; MateMenuTree* tree; MateMenuTreeDirectory* root; if (dialog->filter_application_model != NULL) return; store = gtk_tree_store_new(NUMBER_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING); tree = matemenu_tree_lookup("mate-applications.menu", MATEMENU_TREE_FLAGS_NONE); matemenu_tree_set_sort_key(tree, MATEMENU_TREE_SORT_DISPLAY_NAME); if ((root = matemenu_tree_get_root_directory (tree))) { panel_addto_make_application_list(&dialog->application_list, root, "mate-applications.menu"); panel_addto_populate_application_model(store, NULL, dialog->application_list); matemenu_tree_item_unref(root); } matemenu_tree_unref(tree); tree = matemenu_tree_lookup("mate-settings.menu", MATEMENU_TREE_FLAGS_NONE); matemenu_tree_set_sort_key(tree, MATEMENU_TREE_SORT_DISPLAY_NAME); if ((root = matemenu_tree_get_root_directory(tree))) { GtkTreeIter iter; gtk_tree_store_append(store, &iter, NULL); gtk_tree_store_set(store, &iter, COLUMN_ICON, NULL, COLUMN_TEXT, NULL, COLUMN_DATA, NULL, COLUMN_SEARCH, NULL, -1); panel_addto_make_application_list(&dialog->settings_list, root, "mate-settings.menu"); panel_addto_populate_application_model(store, NULL, dialog->settings_list); matemenu_tree_item_unref(root); } matemenu_tree_unref(tree); dialog->application_model = GTK_TREE_MODEL(store); dialog->filter_application_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(dialog->application_model), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(dialog->filter_application_model), panel_addto_filter_func, dialog, NULL); }
static void cookie_manager_page_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { CookieManagerPage *cmp = COOKIE_MANAGER_PAGE(object); CookieManagerPagePrivate *priv = cmp->priv; switch (prop_id) { case PROP_STORE: { priv->store = g_value_get_object(value); /* setting filter and model */ priv->filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(priv->store), NULL); gtk_tree_model_filter_set_visible_column(GTK_TREE_MODEL_FILTER(priv->filter), COOKIE_MANAGER_COL_VISIBLE); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->treeview), GTK_TREE_MODEL(priv->filter)); g_object_unref(priv->filter); break; } case PROP_PARENT: { if (priv->parent != NULL) { g_signal_handlers_disconnect_by_func(priv->parent, cookie_manager_page_pre_cookies_change_cb, object); g_signal_handlers_disconnect_by_func(priv->parent, cookie_manager_page_cookies_changed_cb, object); g_signal_handlers_disconnect_by_func(priv->parent, cookie_manager_page_filter_changed_cb, object); } priv->parent = g_value_get_object(value); g_signal_connect(priv->parent, "pre-cookies-change", G_CALLBACK(cookie_manager_page_pre_cookies_change_cb), object); g_signal_connect(priv->parent, "cookies-changed", G_CALLBACK(cookie_manager_page_cookies_changed_cb), object); g_signal_connect(priv->parent, "filter-changed", G_CALLBACK(cookie_manager_page_filter_changed_cb), object); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
static void default_adapter_changed (GObject *gobject, GParamSpec *arg1, gpointer data) { BluetoothChooser *self = BLUETOOTH_CHOOSER (data); BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self); char *adapter; g_object_get (gobject, "default-adapter", &adapter, NULL); if (adapter == NULL) { gtk_widget_set_sensitive (GTK_WIDGET (priv->treeview), FALSE); set_search_label (self, FALSE); gtk_tree_view_set_model (GTK_TREE_VIEW(priv->treeview), NULL); } if (priv->model) { g_object_unref (priv->model); priv->model = NULL; } if (adapter == NULL) return; g_free (adapter); priv->model = bluetooth_client_get_device_model (priv->client); if (priv->model) { priv->filter = gtk_tree_model_filter_new (priv->model, NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->filter), filter_func, self, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW(priv->treeview), priv->filter); g_signal_connect (priv->filter, "row-changed", G_CALLBACK (device_model_row_changed), self); g_object_unref (priv->filter); gtk_widget_set_sensitive (GTK_WIDGET (priv->treeview), TRUE); /* Start a discovery if it was requested before we * had an adapter available */ if (priv->disco_rq != FALSE) { bluetooth_chooser_start_discovery (self); set_search_label (self, TRUE); } } }
QMetaObject::Connection gtk_combo_box_set_qmodel(GtkComboBox *box, QAbstractItemModel *qmodel, QItemSelectionModel *selection_model) { QMetaObject::Connection connection; GtkTreeModel *model; model = (GtkTreeModel *)gtk_q_tree_model_new( qmodel, 1, 0, Qt::DisplayRole, G_TYPE_STRING); /* use a filter model to remove disabled items */ GtkTreeModel *filter_model = gtk_tree_model_filter_new(model, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model), (GtkTreeModelFilterVisibleFunc)filter_disabled_items, NULL, NULL); gtk_combo_box_set_model(box, GTK_TREE_MODEL(filter_model)); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(box), renderer, FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(box), renderer, "text", 0, NULL); if (!selection_model) return connection; /* sync the initial selection */ gtk_combo_box_set_active_index(box, selection_model->currentIndex()); /* connect signals to and from the selection model */ connection = QObject::connect( selection_model, &QItemSelectionModel::currentChanged, [=](const QModelIndex current, G_GNUC_UNUSED const QModelIndex & previous) { gtk_combo_box_set_active_index(box, current); } ); g_signal_connect(box, "changed", G_CALLBACK(update_selection), selection_model); return connection; }
void create_user_privileges_table (void) { GtkWidget *list; GtkTreeModel *model, *filter_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeIter iter; list = gst_dialog_get_widget (tool->main_dialog, "user_privileges"); model = GTK_TREE_MODEL (gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_OBJECT)); filter_model = gtk_tree_model_filter_new (model, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (list), filter_model); g_object_unref (filter_model); g_object_unref (model); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), COL_DESCRIPTION, GTK_SORT_ASCENDING); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter_model), privileges_table_visible_func, NULL, NULL); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_toggle_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "active", COL_MEMBER, NULL); g_signal_connect (G_OBJECT (renderer), "toggled", G_CALLBACK (on_user_privilege_toggled), filter_model); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_end (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", COL_DESCRIPTION, NULL); gtk_tree_view_column_set_sort_column_id (column, 1); gtk_tree_view_insert_column (GTK_TREE_VIEW (list), column, 0); }
static void hildon_find_toolbar_apply_filter (HildonFindToolbar *self, GtkTreeModel *model) { GtkTreeModel *filter; HildonFindToolbarPrivate *priv = HILDON_FIND_TOOLBAR_GET_PRIVATE (self); g_assert (priv); /* Create a filter for the given model. Its only purpose is to hide the oldest entries so only "history_limit" entries are visible. */ filter = gtk_tree_model_filter_new (model, NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(filter), hildon_find_toolbar_filter, self, NULL); gtk_combo_box_set_model (GTK_COMBO_BOX (priv->entry_combo_box), filter); /* ComboBox keeps the only needed reference to the filter */ g_object_unref (filter); }
static GObject * ephy_node_view_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { GObject *object; EphyNodeView *view; EphyNodeViewPrivate *priv; GtkTreeSelection *selection; object = parent_class->constructor (type, n_construct_properties, construct_params); view = EPHY_NODE_VIEW (object); priv = EPHY_NODE_VIEW_GET_PRIVATE (object); priv->nodemodel = ephy_tree_model_node_new (priv->root); priv->filtermodel = gtk_tree_model_filter_new (GTK_TREE_MODEL (priv->nodemodel), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->filtermodel), filter_visible_func, view, NULL); priv->sortmodel = ephy_tree_model_sort_new (priv->filtermodel); gtk_tree_view_set_model (GTK_TREE_VIEW (object), GTK_TREE_MODEL (priv->sortmodel)); g_signal_connect_object (object, "button_press_event", G_CALLBACK (ephy_node_view_button_press_cb), view, 0); g_signal_connect (object, "key_press_event", G_CALLBACK (ephy_node_view_key_press_cb), view); g_signal_connect_object (object, "row_activated", G_CALLBACK (ephy_node_view_row_activated_cb), view, 0); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); g_signal_connect_object (G_OBJECT (selection), "changed", G_CALLBACK (ephy_node_view_selection_changed_cb), view, 0); return object; }
static void panel_addto_make_applet_model (PanelAddtoDialog *dialog) { GtkListStore *model; GSList *l; if (dialog->filter_applet_model != NULL) return; if (panel_profile_id_lists_are_writable ()) { dialog->applet_list = panel_addto_query_applets (dialog->applet_list); dialog->applet_list = panel_addto_prepend_internal_applets (dialog->applet_list); } dialog->applet_list = g_slist_sort (dialog->applet_list, (GCompareFunc) panel_addto_applet_info_sort_func); model = gtk_list_store_new (NUMBER_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING); if (panel_profile_id_lists_are_writable ()) { panel_addto_append_special_applets (dialog, model); if (dialog->applet_list) panel_addto_append_item (dialog, model, NULL); } for (l = dialog->applet_list; l; l = l->next) panel_addto_append_item (dialog, model, l->data); dialog->applet_model = GTK_TREE_MODEL (model); dialog->filter_applet_model = gtk_tree_model_filter_new (GTK_TREE_MODEL (dialog->applet_model), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (dialog->filter_applet_model), panel_addto_filter_func, dialog, NULL); }
/* * Crea il modello e le colonne del treeview * */ GtkTreeModel *treeview_create_model(GtkTreeView *tree_view) { GtkCellRenderer *renderer; GtkListStore *store; globalFilterString = NULL; renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "ID", renderer, "text", COL_ID, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "Codice", renderer, "text", COL_CODICE, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "READ1 M1", renderer, "text", COL_READ1M1, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "READ1 M2", renderer, "text", COL_READ1M2, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "READ2 M1", renderer, "text", COL_READ2M1, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "READ2 M2", renderer, "text", COL_READ2M2, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "M3 M1", renderer, "text", COL_READ2M3M1, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "M3 M2", renderer, "text", COL_READ2M3M2, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "VES", renderer, "text", COL_VES, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "TEMP", renderer, "text", COL_TEMP, "foreground", COL_COLOR, NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, "TYPE", renderer, "text", COL_TYPE, "foreground", COL_COLOR, NULL); store = gtk_list_store_new (NUM_COLS, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT); GtkTreeModel *model = gtk_tree_model_filter_new(GTK_TREE_MODEL(store),NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), model); return model; }
GtkWidget *create_config_tab_content(const char *column_label, GtkListStore *store) { GtkWidget *main_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); /* workflow list treeview */ GtkWidget *tv = gtk_tree_view_new(); /* column with workflow name and description */ GtkCellRenderer *renderer; GtkTreeViewColumn *column; /* add column to tree view */ renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(column_label, renderer, "markup", COLUMN_UINAME, NULL); gtk_tree_view_column_set_resizable(column, TRUE); g_object_set(G_OBJECT(renderer), "wrap-mode", PANGO_WRAP_WORD, NULL); g_object_set(G_OBJECT(renderer), "wrap-width", 440, NULL); gtk_tree_view_column_set_sort_column_id(column, COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(tv), column); /* "Please draw rows in alternating colors": */ gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tv), TRUE); // TODO: gtk_tree_view_set_headers_visible(FALSE)? We have only one column anyway... GtkTreeModel *model = gtk_tree_model_filter_new(GTK_TREE_MODEL(store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model), config_filter_func, NULL, NULL); gtk_tree_view_set_model(GTK_TREE_VIEW(tv), GTK_TREE_MODEL(model)); gtk_container_add(GTK_CONTAINER(scroll), tv); gtk_box_pack_start(GTK_BOX(main_vbox), scroll, true, true, 10); return main_vbox; }
Compose * compose_new(Config * config) { Compose * compose; GtkAccelGroup * group; GtkWidget * vbox; GtkWidget * toolbar; GtkToolItem * toolitem; GtkSizeGroup * sizegroup; GtkWidget * vpaned; GtkWidget * vbox2; GtkWidget * widget; GtkCellRenderer * renderer; GtkTreeViewColumn * column; GtkTreeIter iter; char const * headers[] = { "To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:", "Followup-To:" }; size_t i; if((compose = malloc(sizeof(*compose))) == NULL) { compose_error(NULL, strerror(errno), 0); return NULL; } compose->mime = mime_new(NULL); /* check errors */ if(compose->mime == NULL) { free(compose); return NULL; } compose->config = config; compose->standalone = FALSE; /* window */ group = gtk_accel_group_new(); compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_add_accel_group(GTK_WINDOW(compose->window), group); #ifndef EMBEDDED gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384); #else gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300); #endif gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose")); #if GTK_CHECK_VERSION(2, 6, 0) gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer"); #endif g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event", G_CALLBACK(_compose_on_closex), compose); vbox = gtk_vbox_new(FALSE, 0); /* menubar */ #ifndef EMBEDDED widget = desktop_menubar_create(_compose_menubar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); #endif /* toolbar */ toolbar = desktop_toolbar_create(_compose_toolbar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0); /* from */ sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("From: ")); gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); gtk_widget_set_size_request(widget, 80, -1); gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); #if GTK_CHECK_VERSION(2, 24, 0) compose->from = gtk_combo_box_text_new_with_entry(); #else compose->from = gtk_combo_box_entry_new_text(); #endif toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->from); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); /* paned */ vpaned = gtk_vpaned_new(); /* headers */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL( compose->h_store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER( compose->h_store_filter), _compose_on_headers_filter, compose, NULL); compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL( compose->h_store_filter)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE); compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); for(i = 0; i < sizeof(headers) / sizeof(*headers); i++) { gtk_list_store_append(compose->h_headers, &iter); gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1, headers[i], -1); } renderer = gtk_cell_renderer_combo_new(); g_object_set(renderer, "editable", TRUE, "model", compose->h_headers, "text-column", 1, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_field_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_HEADER, NULL); gtk_tree_view_column_set_min_width(column, 80); gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_VALUE, NULL); #if GTK_CHECK_VERSION(2, 4, 0) gtk_tree_view_column_set_expand(column, TRUE); #endif gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); /* default to 8-bits transfers with UTF-8 encoding */ compose_set_header(compose, "Content-Transfer-Encoding:", "8bit", FALSE); compose_set_header(compose, "Content-Type:", "text/plain; charset=UTF-8", FALSE); compose_add_field(compose, "To:", NULL); gtk_container_add(GTK_CONTAINER(widget), compose->h_view); gtk_paned_add1(GTK_PANED(vpaned), widget); /* paned */ vbox2 = gtk_vbox_new(FALSE, 0); /* subject */ toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("Subject: ")); gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); compose->subject = gtk_entry_new(); toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->subject); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0); /* view */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->view = _new_text_view(compose); compose_set_font(compose, _compose_get_font(compose)); gtk_container_add(GTK_CONTAINER(widget), compose->view); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); gtk_paned_add2(GTK_PANED(vpaned), vbox2); gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0); /* attachments */ compose->a_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF); compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL( compose->a_store)); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view), CAC_ICON); gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view), CAC_BASENAME); gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view); gtk_widget_show_all(compose->a_view); gtk_widget_set_no_show_all(compose->a_window, TRUE); gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0); /* statusbar */ compose->statusbar = gtk_statusbar_new(); compose->statusbar_id = 0; gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0); gtk_container_add(GTK_CONTAINER(compose->window), vbox); /* about dialog */ compose->ab_window = NULL; /* signature */ compose_append_signature(compose); compose_set_modified(compose, FALSE); compose_scroll_to_offset(compose, 0); /* display */ gtk_widget_grab_focus(compose->view); gtk_widget_show_all(vbox); gtk_widget_show(compose->window); return compose; }
/** * gwy_app_recent_file_list_new: * * Creates document history browser. * * There should be at most one document history browser, so this function * fails if it already exists. * * Returns: The newly created document history browser window. **/ GtkWidget* gwy_app_recent_file_list_new(void) { GtkWidget *vbox, *filterbox, *buttonbox, *list, *scroll, *button; GtkTreeModelFilter *filter; GtkTreeSelection *selection; g_return_val_if_fail(gcontrols.store, gcontrols.window); g_return_val_if_fail(gcontrols.window == NULL, gcontrols.window); gcontrols.filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(gcontrols.store), NULL); filter = GTK_TREE_MODEL_FILTER(gcontrols.filter); gtk_tree_model_filter_set_visible_func(filter, gwy_app_recent_file_list_filter, &gcontrols, NULL); gcontrols.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(gcontrols.window), _("Document History")); gtk_window_set_default_size(GTK_WINDOW(gcontrols.window), 400, 3*gdk_screen_height()/4); gwy_app_restore_window_position(GTK_WINDOW(gcontrols.window), "/app/document-history", FALSE); gwy_help_add_to_window(GTK_WINDOW(gcontrols.window), "managing-files", "document-history", GWY_HELP_DEFAULT); g_signal_connect(gcontrols.window, "unmap", G_CALLBACK(gwy_app_recent_file_list_unmapped), NULL); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(gcontrols.window), vbox); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0); list = gwy_app_recent_file_list_construct(&gcontrols); gtk_container_add(GTK_CONTAINER(scroll), list); g_object_unref(gcontrols.filter); filterbox = gwy_app_recent_file_list_filter_construct(&gcontrols); gtk_box_pack_start(GTK_BOX(vbox), filterbox, FALSE, FALSE, 0); buttonbox = gtk_hbox_new(TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(buttonbox), 2); gtk_box_pack_start(GTK_BOX(vbox), buttonbox, FALSE, FALSE, 0); gcontrols.prune = gwy_stock_like_button_new(_("_Prune"), GTK_STOCK_FIND); gtk_box_pack_start(GTK_BOX(buttonbox), gcontrols.prune, TRUE, TRUE, 0); gtk_tooltips_set_tip(gwy_app_get_tooltips(), gcontrols.prune, _("Remove entries of files that no longer exist"), NULL); g_signal_connect_swapped(gcontrols.prune, "clicked", G_CALLBACK(gwy_app_recent_file_list_prune), &gcontrols); button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_box_pack_start(GTK_BOX(buttonbox), button, TRUE, TRUE, 0); gtk_tooltips_set_tip(gwy_app_get_tooltips(), button, _("Close file list"), NULL); g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), gcontrols.window); gcontrols.open = gtk_button_new_from_stock(GTK_STOCK_OPEN); gtk_box_pack_start(GTK_BOX(buttonbox), gcontrols.open, TRUE, TRUE, 0); gtk_tooltips_set_tip(gwy_app_get_tooltips(), gcontrols.open, _("Open selected file"), NULL); g_signal_connect_swapped(gcontrols.open, "clicked", G_CALLBACK(gwy_app_recent_file_list_open), list); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list)); gtk_widget_set_sensitive(gcontrols.open, gtk_tree_selection_get_selected(selection, NULL, NULL)); g_signal_connect_swapped(gcontrols.window, "destroy", G_CALLBACK(gwy_app_recent_file_list_destroyed), &gcontrols); gwy_app_recent_file_list_filter_apply(GTK_ENTRY(gcontrols.filter_glob), &gcontrols); gtk_widget_show_all(vbox); return gcontrols.window; }
static void empathy_irc_network_chooser_dialog_constructed (GObject *object) { EmpathyIrcNetworkChooserDialog *self = (EmpathyIrcNetworkChooserDialog *) object; EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self); GtkDialog *dialog = GTK_DIALOG (self); GtkCellRenderer *renderer; GtkWidget *vbox; GtkTreeViewColumn *column; GtkWidget *scroll; g_assert (priv->settings != NULL); gtk_window_set_title (GTK_WINDOW (self), _("Choose an IRC network")); /* Create store and treeview */ priv->store = gtk_list_store_new (2, G_TYPE_OBJECT, G_TYPE_STRING); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (priv->store), COL_NETWORK_NAME, GTK_SORT_ASCENDING); priv->treeview = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (priv->treeview), FALSE); column = gtk_tree_view_column_new (); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer, "text", COL_NETWORK_NAME, NULL); /* add the treeview in a GtkScrolledWindow */ vbox = gtk_dialog_get_content_area (dialog); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (scroll), priv->treeview); gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 6); /* Live search */ priv->search = empathy_live_search_new (priv->treeview); gtk_box_pack_start (GTK_BOX (vbox), priv->search, FALSE, TRUE, 0); priv->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new ( GTK_TREE_MODEL (priv->store), NULL)); gtk_tree_model_filter_set_visible_func (priv->filter, filter_visible_func, self, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), GTK_TREE_MODEL (priv->filter)); priv->search_sig = g_signal_connect (priv->search, "notify::text", G_CALLBACK (search_text_notify_cb), self); priv->activate_sig = g_signal_connect (priv->search, "activate", G_CALLBACK (search_activate_cb), self); /* Add buttons */ gtk_dialog_add_buttons (dialog, GTK_STOCK_ADD, GTK_RESPONSE_OK, GTK_STOCK_EDIT, GTK_RESPONSE_APPLY, GTK_STOCK_REMOVE, GTK_RESPONSE_REJECT, NULL); priv->select_button = gtk_dialog_add_button (dialog, C_("verb displayed on a button to select an IRC network", "Select"), GTK_RESPONSE_CLOSE); fill_store (self); g_signal_connect (priv->treeview, "cursor-changed", G_CALLBACK (treeview_changed_cb), self); g_signal_connect (self, "response", G_CALLBACK (dialog_response_cb), self); g_signal_connect (self, "destroy", G_CALLBACK (dialog_destroy_cb), self); /* Request a side ensuring to display at least some networks */ gtk_widget_set_size_request (GTK_WIDGET (self), -1, 300); gtk_window_set_modal (GTK_WINDOW (self), TRUE); }
/* * Create a new price tree view with (optional) top level root node. * This view will be based on a model that is common to all view of * the same set of books, but will have its own private filter on that * model. */ GtkTreeView * gnc_tree_view_price_new (QofBook *book, const gchar *first_property_name, ...) { GncTreeView *view; GtkTreeModel *model, *f_model, *s_model; GtkTreeViewColumn *col; GNCPriceDB *price_db; va_list var_args; const gchar *sample_text; gchar *sample_text2; ENTER(" "); /* Create/get a pointer to the existing model for this set of books. */ price_db = gnc_pricedb_get_db(book); model = gnc_tree_model_price_new (book, price_db); /* Set up the view private filter on the common model. */ f_model = gtk_tree_model_filter_new (model, NULL); g_object_unref(G_OBJECT(model)); s_model = gtk_tree_model_sort_new_with_model (f_model); g_object_unref(G_OBJECT(f_model)); /* Create our view */ view = g_object_new (GNC_TYPE_TREE_VIEW_PRICE, "name", "price_tree", NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (view), s_model); g_object_unref(G_OBJECT(s_model)); DEBUG("model ref count is %d", G_OBJECT(model)->ref_count); DEBUG("f_model ref count is %d", G_OBJECT(f_model)->ref_count); DEBUG("s_model ref count is %d", G_OBJECT(s_model)->ref_count); sample_text = gnc_commodity_get_printname(gnc_default_currency()); sample_text2 = g_strdup_printf("%s%s", sample_text, sample_text); col = gnc_tree_view_add_text_column ( view, _("Security"), "security", NULL, sample_text2, GNC_TREE_MODEL_PRICE_COL_COMMODITY, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_name); g_free(sample_text2); col = gnc_tree_view_add_text_column ( view, _("Currency"), "currency", NULL, sample_text, GNC_TREE_MODEL_PRICE_COL_CURRENCY, GNC_TREE_MODEL_PRICE_COL_VISIBILITY, sort_by_name); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); col = gnc_tree_view_add_text_column ( view, _("Date"), "date", NULL, "2005-05-20", GNC_TREE_MODEL_PRICE_COL_DATE, GNC_TREE_MODEL_PRICE_COL_VISIBILITY, sort_by_date); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); col = gnc_tree_view_add_text_column ( view, _("Source"), "source", NULL, "Finance::Quote", GNC_TREE_MODEL_PRICE_COL_SOURCE, GNC_TREE_MODEL_PRICE_COL_VISIBILITY, sort_by_source); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); col = gnc_tree_view_add_text_column ( view, _("Type"), "type", NULL, "last", GNC_TREE_MODEL_PRICE_COL_TYPE, GNC_TREE_MODEL_PRICE_COL_VISIBILITY, sort_by_type); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); col = gnc_tree_view_add_numeric_column ( view, _("Price"), "price", "100.00000", GNC_TREE_MODEL_PRICE_COL_VALUE, GNC_TREE_VIEW_COLUMN_COLOR_NONE, GNC_TREE_MODEL_PRICE_COL_VISIBILITY, sort_by_value); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); gnc_tree_view_configure_columns(view); /* Set properties */ va_start (var_args, first_property_name); g_object_set_valist (G_OBJECT(view), first_property_name, var_args); va_end (var_args); /* Sort on the commodity column by default. This allows for a consistent * sort if commodities are removed and re-added from the model. */ if (!gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(s_model), NULL, NULL)) { gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(s_model), GNC_TREE_MODEL_PRICE_COL_COMMODITY, GTK_SORT_ASCENDING); } gtk_widget_show(GTK_WIDGET(view)); LEAVE(" %p", view); return GTK_TREE_VIEW(view); }
GtkWidget * reveal; GtkWidget * toolbar; GtkWidget * wrapper; GtkWidget * sibling; GtkToolItem * ti; struct filter_data * data; g_assert (DIRTY_KEY == 0); TEXT_KEY = g_quark_from_static_string ("tr-filter-text-key"); DIRTY_KEY = g_quark_from_static_string ("tr-filter-dirty-key"); SESSION_KEY = g_quark_from_static_string ("tr-session-key"); TORRENT_MODEL_KEY = g_quark_from_static_string ("tr-filter-torrent-model-key"); data = g_new0 (struct filter_data, 1); data->show_lb = gtk_label_new (NULL); data->filter_model = gtk_tree_model_filter_new (tmodel, NULL); data->tree_model = tmodel; data->header_bar = GTK_WIDGET (header_bar); data->filters = filters; gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (data->filter_model), is_row_visible, data, g_free); toolbar = gtk_toolbar_new (); gtk_style_context_add_class (gtk_widget_get_style_context (toolbar), "search-bar"); gtk_container_set_border_width (GTK_CONTAINER (toolbar), 0); ti = gtk_tool_item_new (); gtk_tool_item_set_expand (GTK_TOOL_ITEM (ti), TRUE); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (ti), 0);
/* Create a new dir tree view */ GtkWidget* ptk_dir_tree_view_new( PtkFileBrowser* browser, gboolean show_hidden ) { GtkTreeView * dir_tree_view; GtkTreeViewColumn* col; GtkCellRenderer* renderer; GtkTreeModel* model; GtkTreeSelection* tree_sel; GtkTreePath* tree_path; GtkTreeModel* filter; dir_tree_view = GTK_TREE_VIEW( gtk_tree_view_new () ); gtk_tree_view_set_headers_visible( dir_tree_view, FALSE ); #if GTK_CHECK_VERSION(2, 10, 0) gtk_tree_view_set_enable_tree_lines(dir_tree_view, TRUE); #endif /* FIXME: Temporarily disable drag & drop since it doesn't work right now. gtk_tree_view_enable_model_drag_dest ( dir_tree_view, drag_targets, sizeof( drag_targets ) / sizeof( GtkTargetEntry ), GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK ); gtk_tree_view_enable_model_drag_source ( dir_tree_view, ( GDK_CONTROL_MASK | GDK_BUTTON1_MASK | GDK_BUTTON3_MASK ), drag_targets, sizeof( drag_targets ) / sizeof( GtkTargetEntry ), GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK ); */ col = gtk_tree_view_column_new (); renderer = ( GtkCellRenderer* ) ptk_file_icon_renderer_new(); gtk_tree_view_column_pack_start( col, renderer, FALSE ); gtk_tree_view_column_set_attributes( col, renderer, "pixbuf", COL_DIR_TREE_ICON, "info", COL_DIR_TREE_INFO, NULL ); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start( col, renderer, TRUE ); gtk_tree_view_column_set_attributes( col, renderer, "text", COL_DIR_TREE_DISP_NAME, NULL ); gtk_tree_view_append_column ( dir_tree_view, col ); tree_sel = gtk_tree_view_get_selection( dir_tree_view ); gtk_tree_selection_set_select_function( tree_sel, sel_func, NULL, NULL ); if ( G_UNLIKELY( !dir_tree_view_data ) ) dir_tree_view_data = g_quark_from_static_string( "show_hidden" ); g_object_set_qdata( G_OBJECT( dir_tree_view ), dir_tree_view_data, ( gpointer ) show_hidden ); model = get_dir_tree_model(); filter = gtk_tree_model_filter_new( model, NULL ); g_object_unref( G_OBJECT( model ) ); gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( filter ), filter_func, dir_tree_view, NULL ); gtk_tree_view_set_model( dir_tree_view, filter ); g_object_unref( G_OBJECT( filter ) ); g_signal_connect ( dir_tree_view, "row-expanded", G_CALLBACK ( on_dir_tree_view_row_expanded ), model ); g_signal_connect_data ( dir_tree_view, "row-collapsed", G_CALLBACK ( on_dir_tree_view_row_collapsed ), model, NULL, G_CONNECT_AFTER ); g_signal_connect ( dir_tree_view, "button-press-event", G_CALLBACK ( on_dir_tree_view_button_press ), browser ); g_signal_connect ( dir_tree_view, "key-press-event", G_CALLBACK ( on_dir_tree_view_key_press ), NULL ); tree_path = gtk_tree_path_new_first(); gtk_tree_view_expand_row( dir_tree_view, tree_path, FALSE ); gtk_tree_path_free( tree_path ); g_signal_connect( dir_tree_view, "destroy", G_CALLBACK(on_destroy), NULL ); return GTK_WIDGET( dir_tree_view ); }
void filefilter_gui(Tfilter * filter) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; GList *tmplist, *reglist; GtkWidget *table, *hbox, *but, *vbox, *scrolwin; #ifdef WIN32 GList *mimelist = NULL; gchar *last_mime = NULL; #endif Tfilefiltergui *ffg = g_new0(Tfilefiltergui, 1); ffg->curfilter = filter; if (filter) { ffg->origname = g_strdup(filter->name); } if (!filter) { ffg->curfilter = g_new0(Tfilter, 1); ffg->curfilter->name = g_strdup(_("New filter")); } DEBUG_MSG("filefilter_gui, editing filter %p\n", ffg->curfilter); ffg->win = window_full2(_("Edit filter"), GTK_WIN_POS_MOUSE, 10, G_CALLBACK(filefiltergui_destroy_lcb), ffg, TRUE, NULL); gtk_window_set_default_size(GTK_WINDOW(ffg->win), 400, 400); ffg->lstore = gtk_list_store_new(3, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_BOOLEAN); /* fill the list model from the currently known filetypes */ reglist = g_content_types_get_registered(); #ifdef WIN32 tmplist = g_list_first(reglist); while (tmplist) { mimelist = g_list_prepend(mimelist, g_content_type_get_mime_type(tmplist->data)); tmplist = g_list_next(tmplist); } mimelist = g_list_reverse(g_list_sort(mimelist, (GCompareFunc) g_strcmp0)); tmplist = g_list_first(mimelist); while (tmplist) { if (!last_mime || g_strcmp0(last_mime, tmplist->data) != 0) { GtkTreeIter it; last_mime = tmplist->data; if (MIME_ISDIR(tmplist->data)) { gtk_list_store_prepend(ffg->lstore, &it); gtk_list_store_set(ffg->lstore, &it, 0, tmplist->data, 2, 0, -1); } } tmplist = g_list_next(tmplist); } /* GList *winlist = NULL; gchar *mimetype; gint llen, lpos; while(reglist) { mimetype = g_content_type_get_mime_type(reglist->data); if ((llen = g_list_length(winlist))) { tmplist = g_list_copy(winlist); for (lpos = 0; llen != -1 && lpos < llen; lpos++) { if (!g_strcmp0(mimetype, tmplist->data)) llen = -1; else tmplist = g_list_next(tmplist); } g_list_free(tmplist); } if (llen != -1) winlist = g_list_append(winlist, mimetype); reglist = g_list_next(reglist); } tmplist = g_list_first(g_list_reverse(g_list_sort(winlist, (GCompareFunc) g_strcmp0)));*/ free_stringlist(mimelist); #else tmplist = g_list_first(g_list_sort(reglist, (GCompareFunc) g_strcmp0)); while (tmplist) { GtkTreeIter it; if (!MIME_ISDIR(tmplist->data)) { gtk_list_store_prepend(ffg->lstore, &it); gtk_list_store_set(ffg->lstore, &it, 0, tmplist->data, 2, 0, -1); } tmplist = g_list_next(tmplist); } #endif g_list_foreach(reglist, (GFunc) g_free, NULL); g_list_free(reglist); /* add the patterns from the current filter */ tmplist = g_list_first(ffg->curfilter->patterns); while (tmplist) { GtkTreeIter it; Tfilterpattern *pat = (Tfilterpattern *) tmplist->data; gtk_list_store_prepend(ffg->lstore, &it); gtk_list_store_set(ffg->lstore, &it, 0, pat->pattern, 1, NULL, 2, 1, -1); tmplist = g_list_next(tmplist); } ffg->in_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(ffg->lstore), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(ffg->in_model), filefiltergui_infilter_visiblefunc, ffg, NULL); ffg->out_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(ffg->lstore), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(ffg->out_model), filefiltergui_outfilter_visiblefunc, ffg, NULL); table = gtk_table_new(5, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 5); ffg->nameentry = dialog_entry_in_table(ffg->curfilter->name, table, 0, 1, 0, 1); ffg->inversecheck = dialog_check_button_in_table(_("Hide files that match the filter"), !ffg->curfilter->mode, table, 0, 1, 1, 2); ffg->patentry = dialog_entry_in_table("*.*", table, 2, 3, 1, 2); but = gtk_button_new_with_label(_("Add pattern")); g_signal_connect(but, "clicked", G_CALLBACK(filefiltergui_addpattern_clicked_lcb), ffg); gtk_table_attach(GTK_TABLE(table), but, 3, 4, 1, 2, GTK_FILL, GTK_FILL, 0, 0); ffg->in_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ffg->in_model)); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Mime type"), renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(ffg->in_view), column); renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(_("Icon"), renderer, "pixbuf", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(ffg->in_view), column); scrolwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolwin), ffg->in_view); gtk_table_attach_defaults(GTK_TABLE(table), scrolwin, 2, 4, 2, 3); ffg->out_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ffg->out_model)); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Mime type"), renderer, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(ffg->out_view), column); renderer = gtk_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(_("Icon"), renderer, "pixbuf", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(ffg->out_view), column); scrolwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolwin), ffg->out_view); gtk_table_attach_defaults(GTK_TABLE(table), scrolwin, 0, 1, 2, 3); vbox = gtk_vbox_new(TRUE, 5); but = gtk_button_new_with_label("->"); g_signal_connect(but, "clicked", G_CALLBACK(filefiltergui_2right_clicked), ffg); gtk_box_pack_start(GTK_BOX(vbox), but, TRUE, TRUE, 0); but = gtk_button_new_with_label("<-"); g_signal_connect(but, "clicked", G_CALLBACK(filefiltergui_2left_clicked), ffg); gtk_box_pack_start(GTK_BOX(vbox), but, TRUE, TRUE, 0); gtk_table_attach(GTK_TABLE(table), vbox, 1, 2, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND, 5, 5); #if GTK_CHECK_VERSION(3,0,0) hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); #else hbox = gtk_hbutton_box_new(); #endif gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbox), 12); but = bf_stock_cancel_button(G_CALLBACK(filefiltergui_cancel_clicked), ffg); gtk_box_pack_start(GTK_BOX(hbox), but, FALSE, FALSE, 0); but = bf_stock_ok_button(G_CALLBACK(filefiltergui_ok_clicked), ffg); gtk_box_pack_start(GTK_BOX(hbox), but, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 2, 4, 4, 5, GTK_SHRINK, GTK_SHRINK, 0, 0); gtk_container_add(GTK_CONTAINER(ffg->win), table); gtk_widget_show_all(ffg->win); }
/* * Create a new commodity tree view with (optional) top level root node. * This view will be based on a model that is common to all view of * the same set of books, but will have its own private filter on that * model. */ GtkTreeView * gnc_tree_view_commodity_new (QofBook *book, const gchar *first_property_name, ...) { GncTreeView *view; GtkTreeModel *model, *f_model, *s_model; GtkTreeViewColumn *col; gnc_commodity_table *ct; va_list var_args; ENTER(" "); /* Create/get a pointer to the existing model for this set of books. */ ct = gnc_commodity_table_get_table (book); model = gnc_tree_model_commodity_new (book, ct); /* Set up the view private filter on the common model. */ f_model = gtk_tree_model_filter_new (model, NULL); g_object_unref(G_OBJECT(model)); s_model = gtk_tree_model_sort_new_with_model (f_model); g_object_unref(G_OBJECT(f_model)); /* Create our view */ view = g_object_new (GNC_TYPE_TREE_VIEW_COMMODITY, "name", "commodity_tree", NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (view), s_model); g_object_unref(G_OBJECT(s_model)); DEBUG("model ref count is %d", G_OBJECT(model)->ref_count); DEBUG("f_model ref count is %d", G_OBJECT(f_model)->ref_count); DEBUG("s_model ref count is %d", G_OBJECT(s_model)->ref_count); /* Set default visibilities */ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(view), FALSE); col = gnc_tree_view_add_text_column ( view, _("Namespace"), "namespace", NULL, "NASDAQ", GNC_TREE_MODEL_COMMODITY_COL_NAMESPACE, GNC_TREE_VIEW_COLUMN_VISIBLE_ALWAYS, sort_by_commodity_string); col = gnc_tree_view_add_text_column ( view, _("Symbol"), "symbol", NULL, "ACMEACME", GNC_TREE_MODEL_COMMODITY_COL_MNEMONIC, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_commodity_string); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); col = gnc_tree_view_add_text_column ( view, _("Name"), "name", NULL, "Acme Corporation, Inc.", GNC_TREE_MODEL_COMMODITY_COL_FULLNAME, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_commodity_string); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); col = gnc_tree_view_add_text_column ( view, _("Print Name"), "printname", NULL, "ACMEACME (Acme Corporation, Inc.)", GNC_TREE_MODEL_COMMODITY_COL_PRINTNAME, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_commodity_string); col = gnc_tree_view_add_text_column ( view, _("Display symbol"), "user_symbol", NULL, "ACME", GNC_TREE_MODEL_COMMODITY_COL_USER_SYMBOL, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_commodity_string); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); col = gnc_tree_view_add_text_column ( view, _("Unique Name"), "uniquename", NULL, "NASDAQ::ACMEACME", GNC_TREE_MODEL_COMMODITY_COL_UNIQUE_NAME, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_commodity_string); col = gnc_tree_view_add_text_column ( /* Translators: Again replace CUSIP by the name of your National Securities Identifying Number. */ view, _("ISIN/CUSIP"), "cusip_code", NULL, "QWERTYUIOP", GNC_TREE_MODEL_COMMODITY_COL_CUSIP, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_commodity_string); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); col = gnc_tree_view_add_numeric_column ( view, _("Fraction"), "fraction", "10000", GNC_TREE_MODEL_COMMODITY_COL_FRACTION, GNC_TREE_VIEW_COLUMN_COLOR_NONE, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_fraction); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); col = gnc_tree_view_add_toggle_column( view, _("Get Quotes"), /* Translators: This string has a context prefix; the translation must only contain the part after the | character. */ Q_("Column letter for 'Get Quotes'|Q"), "quote_flag", GNC_TREE_MODEL_COMMODITY_COL_QUOTE_FLAG, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_quote_flag, NULL); col = gnc_tree_view_add_text_column ( view, _("Source"), "quote_source", NULL, "yahoo", GNC_TREE_MODEL_COMMODITY_COL_QUOTE_SOURCE, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_commodity_string); col = gnc_tree_view_add_text_column ( view, _("Timezone"), "quote_timezone", NULL, "America/New_York", GNC_TREE_MODEL_COMMODITY_COL_QUOTE_TZ, GNC_TREE_MODEL_COMMODITY_COL_VISIBILITY, sort_by_commodity_string); g_object_set_data(G_OBJECT(col), DEFAULT_VISIBLE, GINT_TO_POINTER(1)); gnc_tree_view_configure_columns(view); /* Set properties */ va_start (var_args, first_property_name); g_object_set_valist (G_OBJECT(view), first_property_name, var_args); va_end (var_args); /* Sort on the name column by default. This allows for a consistent * sort if commodities are briefly removed and re-added. */ if (!gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(s_model), NULL, NULL)) { gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(s_model), GNC_TREE_MODEL_COMMODITY_COL_FULLNAME, GTK_SORT_ASCENDING); } gtk_widget_show(GTK_WIDGET(view)); LEAVE(" %p", view); return GTK_TREE_VIEW(view); }
void pragha_filter_dialog (PraghaPlaylist *playlist) { PraghaPreferences *preferences; GtkWidget *dialog, *scrollwin, *vbox, *search_entry; GtkWidget *filter_view = NULL; GtkListStore *filter_store; GtkTreeModel *filter_model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; PraghaFilterDialog *fdialog; fdialog = g_slice_new0(PraghaFilterDialog); preferences = pragha_preferences_get (); /* Crete the filter entry */ search_entry = pragha_search_entry_new(preferences); g_signal_connect (G_OBJECT(search_entry), "changed", G_CALLBACK(simple_filter_search_keyrelease_handler), fdialog); g_signal_connect (G_OBJECT(search_entry), "activate", G_CALLBACK(simple_filter_search_activate_handler), fdialog); /* Create the view */ filter_store = gtk_list_store_new (2, G_TYPE_UINT, G_TYPE_STRING); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "text", 0, NULL); gtk_tree_view_column_set_spacing (column, 4); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_attributes (column, renderer, "markup", 1, NULL); gtk_tree_view_column_set_spacing (column, 4); /* Fill the filter tree view with current playlist */ pragha_filter_dialog_fill_model (filter_store, playlist); filter_model = gtk_tree_model_filter_new(GTK_TREE_MODEL(filter_store), NULL); g_object_unref(filter_store); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter_model), (GtkTreeModelFilterVisibleFunc)filter_model_visible_func, fdialog, NULL); /* Create the tree view */ filter_view = gtk_tree_view_new_with_model(filter_model); gtk_tree_view_append_column (GTK_TREE_VIEW(filter_view), column); g_object_unref(G_OBJECT(filter_model)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(filter_view), TRUE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(filter_view), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(filter_view), FALSE); /* Store references */ fdialog->filter_view = filter_view; fdialog->filter_model = filter_model; fdialog->filter_string = NULL; fdialog->timeout_id = 0; fdialog->cplaylist = playlist; fdialog->preferences = preferences; /* The search dialog */ dialog = gtk_dialog_new_with_buttons (_("Search in playlist"), GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(playlist))), GTK_DIALOG_MODAL, _("_Close"), GTK_RESPONSE_CANCEL, NULL); gtk_dialog_add_button (GTK_DIALOG (dialog), _("Add to playback queue"), GTK_RESPONSE_ACCEPT); gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Jump to"), GTK_RESPONSE_APPLY); gtk_window_set_default_size (GTK_WINDOW (dialog), 600, 500); /* Add to the dialog's main vbox */ vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); gtk_box_pack_start (GTK_BOX(vbox), search_entry, FALSE, FALSE, 3); scrollwin = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER(scrollwin), filter_view); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrollwin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrollwin), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0); /* Connect signals */ g_signal_connect (filter_view, "row-activated", G_CALLBACK(pragha_filter_dialog_activated_cb), dialog); g_signal_connect (filter_view, "key_press_event", G_CALLBACK (pragha_filter_dialog_key_press), fdialog); g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(pragha_filter_dialog_response), fdialog); gtk_widget_show_all (dialog); }
void create_preferences_window(void) { GError *error = NULL; GtkWidget *pl3_win = playlist3_get_window(); GtkWidget *dialog; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *label; int i = 0; char *string = NULL; if (running) { if (xml_preferences_window == NULL) { running = 0; } else { dialog = (GtkWidget *) gtk_builder_get_object(xml_preferences_window, "preferences_window"); gtk_window_present(GTK_WINDOW(dialog)); return; } } plugin_last = -1; string = gmpc_get_full_glade_path("preferences.ui"); xml_preferences_window = gtk_builder_new(); gtk_builder_add_from_file(xml_preferences_window, string, &error); q_free(string); if (error) { g_log(LOG_DOMAIN, G_LOG_LEVEL_ERROR, "Failed to load preferences.ui: %s", error->message); g_error_free(error); } /* set info from struct */ /* hostname */ dialog = (GtkWidget *) gtk_builder_get_object(xml_preferences_window, "preferences_window"); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(pl3_win)); gtk_widget_show_all(GTK_WIDGET(dialog)); running = 1; plugin_store_unfiltered = gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING); /* Create a filtered list that hides the disabled plugins */ plugin_store = gtk_tree_model_filter_new(GTK_TREE_MODEL(plugin_store_unfiltered), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(plugin_store), pref_model_filter_func, NULL, NULL); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Plugins")); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_set_attributes(column, renderer, "markup", 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(gtk_builder_get_object(xml_preferences_window, "plugin_tree")), column); g_signal_connect(G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW(gtk_builder_get_object(xml_preferences_window, "plugin_tree")))), "changed", G_CALLBACK(pref_plugin_changed), NULL); gtk_tree_view_set_model(GTK_TREE_VIEW(gtk_builder_get_object(xml_preferences_window, "plugin_tree")), GTK_TREE_MODEL(plugin_store)); /* internals */ for (i = 0; i < num_plugins; i++) { if (gmpc_plugin_has_preferences(plugins[i])) { if (gmpc_plugin_is_internal(plugins[i])) { GtkTreeIter iter; gtk_list_store_append(GTK_LIST_STORE(plugin_store_unfiltered), &iter); gtk_list_store_set(GTK_LIST_STORE(plugin_store_unfiltered), &iter, 0, i, #if defined(ENABLE_NLS) && GLIB_CHECK_VERSION(2,18,0) 1, _(gmpc_plugin_get_name(plugins[i])), #else 1, gmpc_plugin_get_name(plugins[i]), #endif -1); } } } // Select the first row // TODO: Move this outside the loop. if (gtk_tree_selection_count_selected_rows (gtk_tree_view_get_selection (GTK_TREE_VIEW(gtk_builder_get_object(xml_preferences_window, "plugin_tree")))) == 0) { GtkTreeIter iter; if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(plugin_store), &iter)) { gtk_tree_selection_select_iter(gtk_tree_view_get_selection (GTK_TREE_VIEW (gtk_builder_get_object(xml_preferences_window, "plugin_tree"))), &iter); } } /* plugins */ { GtkTreeIter iter; gchar *value = g_markup_printf_escaped("<b>%s:</b>", _("Plugins")); gtk_list_store_append(GTK_LIST_STORE(plugin_store_unfiltered), &iter); gtk_list_store_set(GTK_LIST_STORE(plugin_store_unfiltered), &iter, 0, PLUGIN_STATS, 1, value, -1); g_free(value); for (i = 0; i < num_plugins; i++) { if (gmpc_plugin_has_preferences(plugins[i]) && !gmpc_plugin_is_internal(plugins[i])) { const gchar *translation_domain = gmpc_plugin_get_translation_domain(plugins[i]); gtk_list_store_append(GTK_LIST_STORE(plugin_store_unfiltered), &iter); gtk_list_store_set(GTK_LIST_STORE(plugin_store_unfiltered), &iter, 0, i, #if defined(ENABLE_NLS) && GLIB_CHECK_VERSION(2,18,0) 1, g_dgettext(translation_domain, gmpc_plugin_get_name(plugins[i])), #else 1, gmpc_plugin_get_name(plugins[i]), #endif -1); } } } { GtkWidget *widget = (GtkWidget *) gtk_builder_get_object(xml_preferences_window, "eventbox_background"); gtk_widget_modify_bg(widget, GTK_STATE_NORMAL, &(dialog->style->base[GTK_STATE_NORMAL])); } label = (GtkWidget *) gtk_builder_get_object(xml_preferences_window, "plugin_label_box"); gtk_widget_set_app_paintable(label, TRUE); g_signal_connect(G_OBJECT(label), "expose-event", G_CALLBACK(misc_header_expose_event), NULL); gtk_widget_set_state(GTK_WIDGET(label), GTK_STATE_SELECTED); gtk_widget_show(dialog); gtk_builder_connect_signals(xml_preferences_window, NULL); }
static void roster_view_gtk_init (G_GNUC_UNUSED RosterViewGtk* self) { GtkWidget *scrolled_window; GtkWidget *vbox = NULL; GtkTreeModel *filtered = NULL; GtkTreeSelection *selection = NULL; GtkTreeViewColumn *col = NULL; GtkCellRenderer *renderer = NULL; self->priv = new RosterViewGtkPrivate; self->priv->folded_groups = gm_conf_get_string_list (CONTACTS_KEY "roster_folded_groups"); self->priv->show_offline_contacts = gm_conf_get_bool (CONTACTS_KEY "show_offline_contacts"); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_container_set_border_width (GTK_CONTAINER (vbox), 0); gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 0); gtk_frame_set_shadow_type (GTK_FRAME (self), GTK_SHADOW_NONE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); self->priv->store = gtk_tree_store_new (COLUMN_NUMBER, G_TYPE_INT, // type G_TYPE_POINTER, // heap G_TYPE_POINTER, // presentity G_TYPE_STRING, // name G_TYPE_STRING, // status G_TYPE_STRING, // presence G_TYPE_STRING, // color if active G_TYPE_STRING, // group name (invisible) G_TYPE_STRING, // presence G_TYPE_BOOLEAN, // offline G_TYPE_INT); // timeout source gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self->priv->store), COLUMN_NAME, GTK_SORT_ASCENDING); filtered = gtk_tree_model_filter_new (GTK_TREE_MODEL (self->priv->store), NULL); g_object_unref (self->priv->store); self->priv->tree_view = GTK_TREE_VIEW (gtk_tree_view_new_with_model (filtered)); g_object_unref (filtered); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filtered), tree_model_filter_hide_show_offline, self, NULL); gtk_tree_view_set_headers_visible (self->priv->tree_view, FALSE); gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (vbox)); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (scrolled_window), TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (self->priv->tree_view)); /* Build the GtkTreeView */ // We hide the normal GTK+ expanders and use our own col = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_set_spacing (col, 0); gtk_tree_view_column_pack_start (col, renderer, TRUE); g_object_set (col, "visible", FALSE, NULL); gtk_tree_view_append_column (self->priv->tree_view, col); gtk_tree_view_set_expander_column (self->priv->tree_view, col); col = gtk_tree_view_column_new (); renderer = gm_cell_renderer_expander_new (); gtk_tree_view_column_pack_start (col, renderer, FALSE); g_object_set (renderer, "xalign", 0.0, "xpad", 0, "ypad", 0, "visible", TRUE, "expander-style", GTK_EXPANDER_COLLAPSED, NULL); gtk_tree_view_column_set_cell_data_func (col, renderer, expand_cell_data_func, NULL, NULL); gtk_tree_view_append_column (self->priv->tree_view, col); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_set_spacing (col, 0); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", COLUMN_NAME); gtk_tree_view_column_set_alignment (col, 0.0); g_object_set (renderer, "xalign", 0.5, "ypad", 0, NULL); g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_tree_view_column_set_cell_data_func (col, renderer, show_cell_data_func, GINT_TO_POINTER (TYPE_HEAP), NULL); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (col, renderer, TRUE); gtk_tree_view_column_add_attribute (col, renderer, "text", COLUMN_NAME); g_object_set (renderer, "weight", PANGO_WEIGHT_BOLD, NULL); gtk_tree_view_column_set_cell_data_func (col, renderer, show_cell_data_func, GINT_TO_POINTER (TYPE_GROUP), NULL); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "yalign", 0.5, "xpad", 5, NULL); gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_add_attribute (col, renderer, "icon-name", COLUMN_PRESENCE_ICON); gtk_tree_view_column_set_cell_data_func (col, renderer, show_cell_data_func, GINT_TO_POINTER (TYPE_PRESENTITY), NULL); renderer = gm_cell_renderer_bitext_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, "width-chars", 30, NULL); gtk_tree_view_column_pack_start (col, renderer, FALSE); gtk_tree_view_column_add_attribute (col, renderer, "primary-text", COLUMN_NAME); gtk_tree_view_column_add_attribute (col, renderer, "secondary-text", COLUMN_STATUS); gtk_tree_view_column_add_attribute (col, renderer, "foreground", COLUMN_ACTIVE); gtk_tree_view_column_set_cell_data_func (col, renderer, show_cell_data_func, GINT_TO_POINTER (TYPE_PRESENTITY), NULL); /* Callback when the selection has been changed */ selection = gtk_tree_view_get_selection (self->priv->tree_view); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (on_selection_changed), self); g_signal_connect (self->priv->tree_view, "event-after", G_CALLBACK (on_view_event_after), self); /* Notifiers */ self->priv->notifier = gm_conf_notifier_add (CONTACTS_KEY "show_offline_contacts", show_offline_contacts_changed_nt, self); }
static GtkWidget *bar_pane_keywords_new(const gchar *id, const gchar *title, const gchar *key, gboolean expanded) { PaneKeywordsData *pkd; GtkWidget *hbox; GtkWidget *scrolled; GtkTextBuffer *buffer; GtkTreeModel *store; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeIter iter; pkd = g_new0(PaneKeywordsData, 1); pkd->pane.pane_set_fd = bar_pane_keywords_set_fd; pkd->pane.pane_event = bar_pane_keywords_event; pkd->pane.pane_write_config = bar_pane_keywords_write_config; pkd->pane.title = bar_pane_expander_title(title); pkd->pane.id = g_strdup(id); pkd->pane.type = PANE_KEYWORDS; pkd->pane.expanded = expanded; pkd->key = g_strdup(key); pkd->expand_checked = TRUE; hbox = gtk_hbox_new(FALSE, PREF_PAD_GAP); pkd->widget = hbox; g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd); g_signal_connect(G_OBJECT(pkd->widget), "destroy", G_CALLBACK(bar_pane_keywords_destroy), pkd); gtk_widget_show(hbox); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); pkd->keyword_view = gtk_text_view_new(); gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_view); g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup", G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd); gtk_widget_show(pkd->keyword_view); buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view)); g_signal_connect(G_OBJECT(buffer), "changed", G_CALLBACK(bar_pane_keywords_changed), pkd); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0); gtk_widget_show(scrolled); if (!keyword_tree || !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_tree), &iter)) { /* keyword tree does not exist or is empty - fill with defaults */ keyword_tree_new_default(); } store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), NULL); gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store), FILTER_KEYWORD_COLUMN_COUNT, filter_keyword_column_types, bar_pane_keywords_filter_modify, pkd, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(store), bar_pane_keywords_filter_visible, store, NULL); pkd->keyword_treeview = gtk_tree_view_new_with_model(store); g_object_unref(store); gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE); // gtk_tree_view_set_search_column(GTK_TREE_VIEW(pkd->keyword_treeview), FILTER_KEYWORD_COLUMN_); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_MARK); gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); renderer = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "active", FILTER_KEYWORD_COLUMN_TOGGLE); gtk_tree_view_column_add_attribute(column, renderer, "visible", FILTER_KEYWORD_COLUMN_IS_KEYWORD); g_signal_connect(G_OBJECT(renderer), "toggled", G_CALLBACK(bar_pane_keywords_keyword_toggle), pkd); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, TRUE); gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column); gtk_tree_view_set_expander_column(GTK_TREE_VIEW(pkd->keyword_treeview), column); gtk_drag_source_set(pkd->keyword_treeview, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK, bar_pane_keywords_drag_types, n_keywords_drag_types, GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_get", G_CALLBACK(bar_pane_keywords_dnd_get), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_begin", G_CALLBACK(bar_pane_keywords_dnd_begin), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_end", G_CALLBACK(bar_pane_keywords_dnd_end), pkd); gtk_drag_dest_set(pkd->keyword_treeview, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, bar_pane_keywords_drop_types, n_keywords_drop_types, GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_received", G_CALLBACK(bar_pane_keywords_dnd_receive), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_motion", G_CALLBACK(bar_pane_keywords_dnd_motion), pkd); g_signal_connect(G_OBJECT(pkd->keyword_treeview), "button_release_event", G_CALLBACK(bar_pane_keywords_menu_cb), pkd); gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_treeview); gtk_widget_show(pkd->keyword_treeview); file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW); return pkd->widget; }
static GtkTreeModel* history_create_filter(GtkTreeModel* child) { GtkTreeModel* ret = gtk_tree_model_filter_new(child, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(ret), history_is_visible, NULL, NULL); return GTK_TREE_MODEL(ret); }
// part_browser_create // // Creates a new part browser. This is only called once per schematic window. GtkWidget * part_browser_create (SchematicView *schematic_view) { Browser *br; GtkBuilder *gui; GError *perror = NULL; char *msg; GtkWidget *w, *view; GtkCellRenderer *cell_text; GtkTreeViewColumn *cell_column; static GtkTargetEntry dnd_types[] = { { "x-application/oregano-part", 0, DRAG_PART_INFO } }; static int dnd_num_types = sizeof (dnd_types) / sizeof (dnd_types[0]); GtkTreePath *path; if ((gui = gtk_builder_new ()) == NULL) { oregano_error (_("Could not create part browser")); return NULL; } else gtk_builder_set_translation_domain (gui, NULL); br = g_new0 (Browser, 1); br->preview = NULL; br->schematic_view = schematic_view; br->hidden = FALSE; schematic_view_set_browser (schematic_view, br); if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/part-browser.ui", &perror) <= 0) { msg = perror->message; oregano_error_with_title (_("Could not create part browser"), msg); g_error_free (perror); return NULL; } view = GTK_WIDGET (gtk_builder_get_object (gui, "viewport1")); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (view), 115); w = goo_canvas_new (); gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (w)); br->canvas = w; g_signal_connect (w, "realize", (GCallback) preview_realized, br); //gtk_widget_set_size_request (w, PREVIEW_WIDTH, // PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT); goo_canvas_set_bounds (GOO_CANVAS (w), 0, 0, PREVIEW_WIDTH, (PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT)); br->description = GOO_CANVAS_TEXT (goo_canvas_text_new ( goo_canvas_get_root_item (GOO_CANVAS (br->canvas)), "", 0.0, PREVIEW_HEIGHT - 9.0, 100.0, GOO_CANVAS_ANCHOR_NORTH_WEST, "font", "sans 9", NULL)); // Set up dnd. g_signal_connect (G_OBJECT (br->canvas), "drag_data_get", G_CALLBACK (drag_data_get), br); gtk_drag_source_set (br->canvas, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK, dnd_types, dnd_num_types, GDK_ACTION_MOVE); br->filter_entry = GTK_ENTRY (gtk_builder_get_object (gui, "part_search")); g_signal_connect (G_OBJECT (br->filter_entry), "changed", G_CALLBACK (part_search_change), br); g_signal_connect (G_OBJECT (br->filter_entry), "activate", G_CALLBACK (part_search_activate), br); // Buttons. w = GTK_WIDGET (gtk_builder_get_object (gui, "place_button")); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (place_cmd), br); // Update the libraries option menu br->library = g_list_nth_data (oregano.libraries, 0); part_browser_setup_libs (br, gui); // Parts list. w = GTK_WIDGET (gtk_builder_get_object (gui, "parts_list")); br->list = w; // Create the List Model for TreeView, this is a Real model br->real_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); cell_text = gtk_cell_renderer_text_new (); cell_column = gtk_tree_view_column_new_with_attributes ( "", cell_text, "text", 0, NULL); // Create the sort model for the items, this sort the real model br->sort_model = gtk_tree_model_sort_new_with_model ( GTK_TREE_MODEL (br->real_model)); gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (br->sort_model), 0, GTK_SORT_ASCENDING); // Create the filter sorted model. This filter items based on user // request for fast item search br->filter_model = gtk_tree_model_filter_new (br->sort_model, NULL); gtk_tree_model_filter_set_visible_func ( GTK_TREE_MODEL_FILTER (br->filter_model), part_list_filter_func, br, NULL); // If we have TreeFilter use it, if not, just use sorting model only if (br->filter_model) gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->filter_model); else gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->sort_model); gtk_tree_view_append_column (GTK_TREE_VIEW (w), cell_column); update_list (br); // Set up TreeView dnd. g_signal_connect (G_OBJECT (w), "drag_data_get", G_CALLBACK (drag_data_get), br); gtk_drag_source_set (w, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK, dnd_types, dnd_num_types, GDK_ACTION_MOVE); g_signal_connect (G_OBJECT (w), "cursor_changed", G_CALLBACK (select_row), br); g_signal_connect (G_OBJECT (w), "row_activated", G_CALLBACK (part_selected), br); br->viewport = GTK_WIDGET (gtk_builder_get_object (gui, "part_browser_vbox")); path = gtk_tree_path_new_first (); gtk_tree_view_set_cursor (GTK_TREE_VIEW (w), path, NULL, FALSE); gtk_tree_path_free (path); gtk_widget_unparent (br->viewport); return br->viewport; }
static void tpaw_irc_network_chooser_dialog_constructed (GObject *object) { TpawIrcNetworkChooserDialog *self = (TpawIrcNetworkChooserDialog *) object; GtkDialog *dialog = GTK_DIALOG (self); GtkCellRenderer *renderer; GtkWidget *vbox; GtkTreeViewColumn *column; GtkWidget *scroll; GtkWidget *toolbar; GtkToolItem *item; GtkStyleContext *context; g_assert (self->priv->settings != NULL); gtk_window_set_title (GTK_WINDOW (self), _("Choose an IRC network")); /* Create store and treeview */ self->priv->store = gtk_list_store_new (2, G_TYPE_OBJECT, G_TYPE_STRING); gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (self->priv->store), COL_NETWORK_NAME, GTK_SORT_ASCENDING); self->priv->treeview = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->priv->treeview), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (self->priv->treeview), FALSE); column = gtk_tree_view_column_new (); gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), renderer, TRUE); gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer, "text", COL_NETWORK_NAME, NULL); /* add the treeview in a GtkScrolledWindow */ vbox = gtk_dialog_get_content_area (dialog); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (scroll), self->priv->treeview); gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 6); /* Treeview toolbar */ toolbar = gtk_toolbar_new (); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, TRUE, 0); item = gtk_tool_button_new (NULL, ""); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "list-add-symbolic"); g_signal_connect (item, "clicked", G_CALLBACK (add_clicked_cb), self); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, ""); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "list-remove-symbolic"); g_signal_connect (item, "clicked", G_CALLBACK (remove_clicked_cb), self); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, ""); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "preferences-system-symbolic"); g_signal_connect (item, "clicked", G_CALLBACK (edit_clicked_cb), self); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); context = gtk_widget_get_style_context (scroll); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM); context = gtk_widget_get_style_context (toolbar); gtk_style_context_add_class (context, GTK_STYLE_CLASS_INLINE_TOOLBAR); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP); /* Live search */ self->priv->search = tpaw_live_search_new (self->priv->treeview); gtk_box_pack_start (GTK_BOX (vbox), self->priv->search, FALSE, TRUE, 0); self->priv->filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new ( GTK_TREE_MODEL (self->priv->store), NULL)); gtk_tree_model_filter_set_visible_func (self->priv->filter, filter_visible_func, self, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (self->priv->treeview), GTK_TREE_MODEL (self->priv->filter)); self->priv->search_sig = g_signal_connect (self->priv->search, "notify::text", G_CALLBACK (search_text_notify_cb), self); self->priv->activate_sig = g_signal_connect (self->priv->search, "activate", G_CALLBACK (search_activate_cb), self); /* Add buttons */ gtk_dialog_add_buttons (dialog, _("Reset _Networks List"), RESPONSE_RESET, NULL); self->priv->select_button = gtk_dialog_add_button (dialog, C_("verb displayed on a button to select an IRC network", "Select"), GTK_RESPONSE_CLOSE); fill_store (self); g_signal_connect (self->priv->treeview, "cursor-changed", G_CALLBACK (treeview_changed_cb), self); g_signal_connect (self, "response", G_CALLBACK (dialog_response_cb), self); /* Request a side ensuring to display at least some networks */ gtk_widget_set_size_request (GTK_WIDGET (self), -1, 300); gtk_window_set_modal (GTK_WINDOW (self), TRUE); }
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); }
gpointer do_tree_store() { GtkWidget *window = __g_priv.window; if (!window) { GtkWidget *vbox, *tool_hbox, *grep_hbox; GtkWidget *scan_button; GtkWidget *grep_button; GtkWidget *grep_entry; GtkWidget *sw; GtkWidget *treeview; GtkTreeModel *model; GtkTreeModel *filter; /* create window, etc */ window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_screen(GTK_WINDOW(window), gtk_widget_get_screen(NULL)); gtk_window_set_title(GTK_WINDOW(window), "list"); g_signal_connect(window, "destroy", G_CALLBACK(gtk_widget_destroyed), &window); vbox = gtk_vbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(vbox), 1); gtk_container_add(GTK_CONTAINER(window), vbox); tool_hbox = gtk_hbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(tool_hbox), 1); gtk_box_pack_start(GTK_BOX(vbox), tool_hbox, FALSE, FALSE, 0); scan_button = gtk_toggle_button_new_with_mnemonic("_Rescan"); gtk_box_pack_start(GTK_BOX(tool_hbox), scan_button, FALSE, FALSE, 0); grep_button = gtk_toggle_button_new_with_mnemonic("_Search"); gtk_box_pack_end(GTK_BOX(tool_hbox), grep_button, FALSE, FALSE, 0); grep_hbox = gtk_hbox_new(FALSE, 1); gtk_container_set_border_width(GTK_CONTAINER(grep_hbox), 1); gtk_box_pack_start(GTK_BOX(vbox), grep_hbox, FALSE, FALSE, 0); grep_entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(grep_hbox), grep_entry, TRUE, TRUE, 0); g_signal_connect(G_OBJECT(grep_button), "toggled", G_CALLBACK(cb_search_toggled), GTK_ENTRY(grep_entry)); 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_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); /* create model */ model = create_model(); gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(model)); /* Create filter and set visible function */ filter = gtk_tree_model_filter_new(model, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter), (GtkTreeModelFilterVisibleFunc) filter_func, grep_entry, NULL); /* Create treeview with model */ treeview = gtk_tree_view_new_with_model(filter); fill_data(treeview, GTK_TREE_STORE(model)); g_signal_connect(G_OBJECT(grep_entry), "changed", G_CALLBACK(cb_entry_changed), GTK_TREE_VIEW(treeview)); g_object_unref(model); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(treeview), TRUE); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), GTK_SELECTION_SINGLE); add_columns(GTK_TREE_VIEW(treeview)); gtk_container_add(GTK_CONTAINER(sw), treeview); /* expand all rows after the treeview widget has been realized */ g_signal_connect(treeview, "realize", G_CALLBACK(gtk_tree_view_expand_all), NULL); gtk_window_set_default_size(GTK_WINDOW(window), 650, 400); /* set priv */ __g_priv.window = window; __g_priv.treeview = treeview; __g_priv.model = model; __g_priv.filter = filter; __g_priv.scan_button = scan_button; __g_priv.grep_button = grep_button; __g_priv.grep_entry = grep_entry; } if (!GTK_WIDGET_VISIBLE(window)) gtk_widget_show_all(window); else { gtk_widget_destroy(window); window = NULL; } return (gpointer) & __g_priv; }
static void moko_history_load_entries (MokoHistory *history) { MokoHistoryPrivate *priv; GtkListStore *store; GtkTreeModel *sorted; GtkTreeModel *filtered; GtkCellRenderer *renderer; MokoJournalEntry *entry; gint i, j, n_entries; GList *entries = NULL, *e; g_return_if_fail (MOKO_IS_HISTORY (history)); priv = history->priv; /* Create renderer and column */ renderer = jana_gtk_cell_renderer_note_new (); g_object_set (G_OBJECT (renderer), "show_created", FALSE, "show_recipient", FALSE, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview), 0, NULL, renderer, "author", DISPLAY_TEXT_COLUMN, "body", CALL_DETAILS_COLUMN, "icon", ICON_NAME_COLUMN, NULL); g_signal_connect (priv->treeview, "size-allocate", G_CALLBACK (jana_gtk_utils_treeview_resize), renderer); /* Set up the list store */ store = gtk_list_store_new (7, G_TYPE_STRING, G_TYPE_INT, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING); priv->main_model = GTK_TREE_MODEL (store); sorted = gtk_tree_model_sort_new_with_model (priv->main_model); priv->sort_model = sorted; gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sorted), DSTART_COLUMN, GTK_SORT_DESCENDING); /* Set up the filtered column */ filtered = gtk_tree_model_filter_new (sorted, NULL); priv->filter_model = filtered; gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filtered), (GtkTreeModelFilterVisibleFunc) moko_history_filter_visible_func, history, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), filtered); g_signal_connect (priv->journal, "entry_added", G_CALLBACK (on_entry_added_cb), (gpointer)history); n_entries = moko_journal_get_nb_entries (priv->journal); if (n_entries < 1) { g_debug ("The Journal is empty"); return; } i = j = 0; for (i = 0; i < n_entries; i++) { moko_journal_get_entry_at (priv->journal, i, &entry); /* We are not interested in anything other than voice entries */ if (moko_journal_entry_get_entry_type (entry) != VOICE_JOURNAL_ENTRY) continue; entries = g_list_insert_sorted (entries, (gpointer)entry, (GCompareFunc)sort_by_date); } for (e = entries; e != NULL; e = e->next) { if (history_add_entry (store, e->data)) j++; } }
static void remmina_ftp_client_init(RemminaFTPClient *client) { RemminaFTPClientPriv *priv; GtkWidget *vpaned; GtkWidget *scrolledwindow; GtkWidget *widget; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *vbox; priv = g_new0(RemminaFTPClientPriv, 1); client->priv = priv; /* Main container */ gtk_box_set_homogeneous(GTK_BOX(client), FALSE); gtk_box_set_spacing(GTK_BOX(client), 4); /* Toolbar */ remmina_ftp_client_create_toolbar(client); /* The Paned to separate File List and Task List */ #if GTK_VERSION == 3 vpaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL); #elif GTK_VERSION == 2 vpaned = gtk_vpaned_new(); #endif gtk_widget_show(vpaned); gtk_box_pack_start(GTK_BOX(client), vpaned, TRUE, TRUE, 0); priv->vpaned = vpaned; /* Remote */ #if GTK_VERSION == 3 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #elif GTK_VERSION == 2 vbox = gtk_vbox_new(FALSE, 0); #endif gtk_widget_show(vbox); gtk_paned_pack1(GTK_PANED(vpaned), vbox, TRUE, FALSE); /* Remote Directory */ widget = gtk_combo_box_text_new_with_entry(); gtk_widget_show(widget); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(widget), "/"); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0); priv->directory_combo = widget; /* Remote File List */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0); widget = gtk_tree_view_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(widget)), GTK_SELECTION_MULTIPLE); priv->file_list_view = widget; /* Remote File List - Columns */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("File Name")); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_NAME_SORT); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL); gtk_tree_view_column_set_alignment(column, 1.0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_SIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("User"), renderer, "text", REMMINA_FTP_FILE_COLUMN_USER, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_USER); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", REMMINA_FTP_FILE_COLUMN_GROUP, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_GROUP); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Permission"), renderer, "text", REMMINA_FTP_FILE_COLUMN_PERMISSION, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_permission, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_FILE_COLUMN_PERMISSION); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->file_list_view), column); /* Remote File List - Model */ priv->file_list_model = GTK_TREE_MODEL( gtk_list_store_new(REMMINA_FTP_FILE_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING)); priv->file_list_filter = gtk_tree_model_filter_new(priv->file_list_model, NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(priv->file_list_filter), (GtkTreeModelFilterVisibleFunc) remmina_ftp_client_filter_visible_func, client, NULL); priv->file_list_sort = gtk_tree_model_sort_new_with_model(priv->file_list_filter); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(priv->file_list_sort), REMMINA_FTP_FILE_COLUMN_NAME_SORT, GTK_SORT_ASCENDING); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->file_list_view), priv->file_list_sort); /* Task List */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_paned_pack2(GTK_PANED(vpaned), scrolledwindow, FALSE, TRUE); widget = gtk_tree_view_new(); gtk_widget_show(widget); gtk_container_add(GTK_CONTAINER(scrolledwindow), widget); g_object_set(widget, "has-tooltip", TRUE, NULL); priv->task_list_view = widget; /* Task List - Columns */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("File Name")); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_expand(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_NAME); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_filetype_pixbuf, NULL, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", REMMINA_FTP_FILE_COLUMN_NAME); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Remote"), renderer, "text", REMMINA_FTP_TASK_COLUMN_REMOTEDIR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_REMOTEDIR); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Local"), renderer, "text", REMMINA_FTP_TASK_COLUMN_LOCALDIR, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_LOCALDIR); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer, NULL); gtk_tree_view_column_set_alignment(column, 1.0); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_size_progress, NULL, NULL); gtk_tree_view_column_set_sort_column_id(column, REMMINA_FTP_TASK_COLUMN_SIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = gtk_cell_renderer_progress_new(); column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_cell_data_func(column, renderer, remmina_ftp_client_cell_data_progress, NULL, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); renderer = remmina_cell_renderer_pixbuf_new(); column = gtk_tree_view_column_new_with_attributes(NULL, renderer, NULL); g_object_set(G_OBJECT(renderer), "stock-id", "_Cancel", NULL); gtk_tree_view_column_set_resizable(column, FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->task_list_view), column); g_signal_connect(G_OBJECT(renderer), "activate", G_CALLBACK(remmina_ftp_client_task_list_cell_on_activate), client); /* Task List - Model */ priv->task_list_model = GTK_TREE_MODEL( gtk_list_store_new(REMMINA_FTP_TASK_N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_FLOAT, G_TYPE_STRING)); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->task_list_view), priv->task_list_model); /* Setup the internal signals */ g_signal_connect(G_OBJECT(client), "destroy", G_CALLBACK(remmina_ftp_client_destroy), NULL); g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(priv->directory_combo))), "activate", G_CALLBACK(remmina_ftp_client_dir_on_activate), client); g_signal_connect(G_OBJECT(priv->directory_combo), "changed", G_CALLBACK(remmina_ftp_client_dir_on_changed), client); g_signal_connect(G_OBJECT(priv->file_list_view), "button-press-event", G_CALLBACK(remmina_ftp_client_file_list_on_button_press), client); g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->file_list_view))), "changed", G_CALLBACK(remmina_ftp_client_file_selection_on_changed), client); g_signal_connect(G_OBJECT(priv->task_list_view), "query-tooltip", G_CALLBACK(remmina_ftp_client_task_list_on_query_tooltip), client); }