static void on_heap_updated (RosterViewGtk* self, G_GNUC_UNUSED Ekiga::ClusterPtr cluster, Ekiga::HeapPtr heap) { GtkTreeIter iter; GtkTreeIter filtered_iter; GtkTreeSelection* selection = NULL; gboolean should_emit = FALSE; roster_view_gtk_find_iter_for_heap (self, heap, &iter); selection = gtk_tree_view_get_selection (self->priv->tree_view); GtkTreeModelFilter* model = GTK_TREE_MODEL_FILTER (gtk_tree_view_get_model (self->priv->tree_view)); if (gtk_tree_model_filter_convert_child_iter_to_iter (model, &filtered_iter, &iter)) if (gtk_tree_selection_iter_is_selected (selection, &filtered_iter)) should_emit = TRUE; gtk_tree_store_set (self->priv->store, &iter, COLUMN_TYPE, TYPE_HEAP, COLUMN_HEAP, heap.get (), COLUMN_NAME, heap->get_name ().c_str (), -1); if (should_emit) g_signal_emit (self, signals[SELECTION_CHANGED_SIGNAL], 0); }
static gboolean gnc_tree_view_owner_get_iter_from_owner (GncTreeViewOwner *view, GncOwner *owner, GtkTreeIter *s_iter) { GtkTreeModel *model, *f_model, *s_model; GtkTreeIter iter, f_iter; g_return_val_if_fail(GNC_IS_TREE_VIEW_OWNER(view), FALSE); g_return_val_if_fail(owner != NULL, FALSE); g_return_val_if_fail(s_iter != NULL, FALSE); ENTER("view %p, owner %p (%s)", view, owner, gncOwnerGetName(owner)); /* Reach down to the real model and get an iter for this owner */ s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view)); f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model)); model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model)); if (!gnc_tree_model_owner_get_iter_from_owner ( GNC_TREE_MODEL_OWNER(model), owner, &iter)) { LEAVE("model_get_iter_from_owner failed"); return FALSE; } /* convert back to a sort iter */ gtk_tree_model_filter_convert_child_iter_to_iter ( GTK_TREE_MODEL_FILTER(f_model), &f_iter, &iter); gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT(s_model), s_iter, &f_iter); LEAVE(" "); return TRUE; }
/************************************************************/ #define debug_path(fn, path) { \ gchar *path_string = gtk_tree_path_to_string(path); \ fn("tree path %s", path_string); \ g_free(path_string); \ } #if 0 /* Not Used */ static gboolean gnc_tree_view_price_get_iter_from_price (GncTreeViewPrice *view, GNCPrice *price, GtkTreeIter *s_iter) { GtkTreeModel *model, *f_model, *s_model; GtkTreeIter iter, f_iter; g_return_val_if_fail(GNC_IS_TREE_VIEW_PRICE(view), FALSE); g_return_val_if_fail(price != NULL, FALSE); g_return_val_if_fail(s_iter != NULL, FALSE); ENTER("view %p, price %p", view, price); /* Reach down to the real model and get an iter for this price */ s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view)); f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model)); model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model)); if (!gnc_tree_model_price_get_iter_from_price (GNC_TREE_MODEL_PRICE(model), price, &iter)) { LEAVE("model_get_iter_from_price failed"); return FALSE; } /* convert back to a sort iter */ gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER(f_model), &f_iter, &iter); gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT(s_model), s_iter, &f_iter); LEAVE(" "); return TRUE; }
static gboolean inf_gtk_browser_model_filter_browser_iter_to_tree_iter(InfGtkBrowserModel* m, InfcBrowser* browser, InfcBrowserIter* iter, GtkTreeIter* tree_iter) { GtkTreeModel* child_model; GtkTreeIter child_iter; gboolean result; child_model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(m)); result = inf_gtk_browser_model_browser_iter_to_tree_iter( INF_GTK_BROWSER_MODEL(child_model), browser, iter, &child_iter ); if(result == TRUE) { return gtk_tree_model_filter_convert_child_iter_to_iter( GTK_TREE_MODEL_FILTER(m), tree_iter, &child_iter ); } else { return FALSE; } }
/************************************************************/ #define debug_path(fn, path) { \ gchar *path_string = gtk_tree_path_to_string(path); \ fn("tree path %s", path_string); \ g_free(path_string); \ } #if 0 /* Not Used */ static gboolean gnc_tree_view_commodity_get_iter_from_commodity (GncTreeViewCommodity *view, gnc_commodity *commodity, GtkTreeIter *s_iter) { GtkTreeModel *model, *f_model, *s_model; GtkTreeIter iter, f_iter; g_return_val_if_fail(GNC_IS_TREE_VIEW_COMMODITY(view), FALSE); g_return_val_if_fail(commodity != NULL, FALSE); g_return_val_if_fail(s_iter != NULL, FALSE); ENTER("view %p, commodity %p (%s)", view, commodity, gnc_commodity_get_mnemonic(commodity)); /* Reach down to the real model and get an iter for this commodity */ s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view)); f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model)); model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model)); if (!gnc_tree_model_commodity_get_iter_from_commodity (GNC_TREE_MODEL_COMMODITY(model), commodity, &iter)) { LEAVE("model_get_iter_from_commodity failed"); return FALSE; } /* convert back to a sort iter */ gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER(f_model), &f_iter, &iter); gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT(s_model), s_iter, &f_iter); LEAVE(" "); return TRUE; }
/* compose_add_field */ void compose_add_field(Compose * compose, char const * field, char const * value) { GtkTreeIter iter; GtkTreeIter iter2; gboolean valid; GtkTreePath * path; gtk_list_store_append(compose->h_store, &iter); gtk_list_store_set(compose->h_store, &iter, CHC_VISIBLE, TRUE, -1); if(field != NULL) gtk_list_store_set(compose->h_store, &iter, CHC_HEADER, field, -1); if(value != NULL) gtk_list_store_set(compose->h_store, &iter, CHC_VALUE, value, -1); valid = gtk_tree_model_filter_convert_child_iter_to_iter( GTK_TREE_MODEL_FILTER(compose->h_store_filter), &iter2, &iter); if(valid) { path = gtk_tree_model_get_path(GTK_TREE_MODEL( compose->h_store_filter), &iter2); gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(compose->h_view), path, NULL, TRUE, 0.0, 0.5); gtk_tree_path_free(path); } }
void feed_list_view_select (nodePtr node) { GtkTreeModel *model = gtk_tree_view_get_model (flv->treeview); if (model && node && node != feedlist_get_root ()) { GtkTreePath *path; /* in filtered mode we need to convert the iterator */ if (flv->feedlist_reduced_unread) { GtkTreeIter iter; gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (flv->filter), &iter, feed_list_view_to_iter (node->id)); path = gtk_tree_model_get_path (model, &iter); } else { path = gtk_tree_model_get_path (model, feed_list_view_to_iter (node->id)); } if (node->parent) feed_list_view_expand (node->parent); if (path) { gtk_tree_view_scroll_to_cell (flv->treeview, path, NULL, FALSE, 0.0, 0.0); gtk_tree_view_set_cursor (flv->treeview, path, NULL, FALSE); gtk_tree_path_free (path); } } else { GtkTreeSelection *selection = gtk_tree_view_get_selection (flv->treeview); gtk_tree_selection_unselect_all (selection); } }
/* Given a base iter get the treeview iter */ static void key_store_get_view_iter (CryptUIKeyStore *ckstore, const GtkTreeIter *base, GtkTreeIter *iter) { GtkTreeIter i; gtk_tree_model_filter_convert_child_iter_to_iter (ckstore->priv->filter, &i, (GtkTreeIter*)base); gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (ckstore), iter, &i); }
static VALUE rg_convert_child_iter_to_iter(VALUE self, VALUE child_iter) { GtkTreeIter filter_iter; GtkTreeModelFilter* modelfilter = _SELF(self); gtk_tree_model_filter_convert_child_iter_to_iter(modelfilter, &filter_iter, RVAL2GTKTREEITER(child_iter)); filter_iter.user_data3 = gtk_tree_model_filter_get_model(modelfilter); return GTKTREEITER2RVAL(&filter_iter); }
static GtkTreeIter iter_to_filter_iter (EmpathyIrcNetworkChooserDialog *self, GtkTreeIter *iter) { EmpathyIrcNetworkChooserDialogPriv *priv = GET_PRIV (self); GtkTreeIter filter_iter; g_assert (gtk_tree_model_filter_convert_child_iter_to_iter (priv->filter, &filter_iter, iter)); return filter_iter; }
static GtkTreeIter iter_to_filter_iter (TpawIrcNetworkChooserDialog *self, GtkTreeIter *iter) { GtkTreeIter filter_iter; g_assert ( gtk_tree_model_filter_convert_child_iter_to_iter (self->priv->filter, &filter_iter, iter)); return filter_iter; }
gboolean ephy_node_view_get_iter_for_node (EphyNodeView *view, GtkTreeIter *iter, EphyNode *node) { GtkTreeIter node_iter, filter_iter; ephy_tree_model_node_iter_from_node (EPHY_TREE_MODEL_NODE (view->priv->nodemodel), node, &node_iter); if (!gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (view->priv->filtermodel), &filter_iter, &node_iter)) return FALSE; if (!gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (view->priv->sortmodel), iter, &filter_iter)) return FALSE; return TRUE; }
/** * ephy_node_view_select_node: * @view: an #EphyNodeView * @node: the #EphyNode in the @view to be selected * * Puts the selection of @view on @node. **/ void ephy_node_view_select_node (EphyNodeView *view, EphyNode *node) { GtkTreeIter iter, iter2; g_return_if_fail (node != NULL); ephy_tree_model_node_iter_from_node (EPHY_TREE_MODEL_NODE (view->priv->nodemodel), node, &iter); gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (view->priv->filtermodel), &iter2, &iter); gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (view->priv->sortmodel), &iter, &iter2); gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW (view)), &iter); }
static void inf_gtk_browser_model_filter_set_browser_cb(InfGtkBrowserModel* model, GtkTreePath* path, GtkTreeIter* iter, InfcBrowser* browser, gpointer user_data) { GtkTreeModelFilter* model_filter; GtkTreePath* own_path; GtkTreeIter own_iter; gboolean result; model_filter = GTK_TREE_MODEL_FILTER(user_data); result = gtk_tree_model_filter_convert_child_iter_to_iter( model_filter, &own_iter, iter ); if(result == TRUE) { own_path = gtk_tree_model_filter_convert_child_path_to_path( model_filter, path ); g_assert(own_path != NULL); inf_gtk_browser_model_set_browser( INF_GTK_BROWSER_MODEL(user_data), own_path, &own_iter, browser ); gtk_tree_path_free(own_path); } }
void gtk_combo_box_set_active_index(GtkComboBox *box, const QModelIndex& idx) { if (idx.isValid()) { GtkTreeIter new_iter; GtkTreeModel *filter_model = gtk_combo_box_get_model(box); g_return_if_fail(filter_model); GtkTreeModel *model = filter_model; if (GTK_IS_TREE_MODEL_FILTER(filter_model)) model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(filter_model)); gboolean valid = FALSE; if (GTK_IS_Q_TREE_MODEL(model)) valid = gtk_q_tree_model_source_index_to_iter(GTK_Q_TREE_MODEL(model), idx, &new_iter); if (valid) { if (GTK_IS_TREE_MODEL_FILTER(filter_model)) { GtkTreeIter filter_iter; if (gtk_tree_model_filter_convert_child_iter_to_iter( GTK_TREE_MODEL_FILTER(filter_model), &filter_iter, &new_iter) ) { gtk_combo_box_set_active_iter(box, &filter_iter); } else { g_warning("failed to convert iter from source model to filter model iter"); } } else { gtk_combo_box_set_active_iter(box, &new_iter); } } else { g_warning("Given QModelIndex doesn't exist in GtkTreeModel"); } } }
/** * ephy_node_view_remove: * @view: an #EphyNodeView * * Remove the currently selected nodes from @view. **/ void ephy_node_view_remove (EphyNodeView *view) { EphyNodeViewPrivate *priv = view->priv; GList *list, *l; EphyNode *node; GtkTreeIter iter, iter2, iter3; GtkTreePath *path; GtkTreeRowReference *row_ref = NULL; GtkTreeSelection *selection; /* Before removing we try to get a reference to the next node in the view. If that is * not available we try with the previous one, and if that is absent too, * we will not select anything (which equals to select the topic "All") */ list = ephy_node_view_get_selection (view); if (list == NULL) return; node = g_list_first (list)->data; ephy_tree_model_node_iter_from_node (EPHY_TREE_MODEL_NODE (view->priv->nodemodel), node, &iter3); gtk_tree_model_filter_convert_child_iter_to_iter (GTK_TREE_MODEL_FILTER (view->priv->filtermodel), &iter2, &iter3); gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (view->priv->sortmodel), &iter, &iter2); iter2 = iter; if (gtk_tree_model_iter_next (GTK_TREE_MODEL (view->priv->sortmodel), &iter)) { path = gtk_tree_model_get_path (GTK_TREE_MODEL (view->priv->sortmodel), &iter); row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (view->priv->sortmodel), path); } else { path = gtk_tree_model_get_path (GTK_TREE_MODEL (view->priv->sortmodel), &iter2); if (gtk_tree_path_prev (path)) { row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (view->priv->sortmodel), path); } } gtk_tree_path_free (path); /* Work around bug #346662 */ priv->changing_selection = TRUE; for (l = list; l != NULL; l = l->next) { ephy_node_unref (l->data); } priv->changing_selection = FALSE; g_list_free (list); /* Fake a selection changed signal */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); g_signal_emit_by_name (selection, "changed"); /* Select the "next" node */ if (row_ref != NULL) { path = gtk_tree_row_reference_get_path (row_ref); if (path != NULL) { gtk_tree_view_set_cursor (GTK_TREE_VIEW (view), path, NULL, FALSE); gtk_tree_path_free (path); } gtk_tree_row_reference_free (row_ref); } }
static void on_presentity_added (RosterViewGtk* self, G_GNUC_UNUSED Ekiga::ClusterPtr cluster, Ekiga::HeapPtr heap, Ekiga::PresentityPtr presentity) { GtkTreeIter heap_iter; std::set<std::string> groups = presentity->get_groups (); GtkTreeSelection* selection = gtk_tree_view_get_selection (self->priv->tree_view); GtkTreeModelFilter* filtered_model = GTK_TREE_MODEL_FILTER (gtk_tree_view_get_model (self->priv->tree_view)); GtkTreeIter group_iter; GtkTreeIter iter; GtkTreeIter filtered_iter; bool active = false; bool away = false; guint timeout = 0; std::string status; gchar *old_presence = NULL; gboolean should_emit = FALSE; roster_view_gtk_find_iter_for_heap (self, heap, &heap_iter); active = presentity->get_presence () != "offline"; away = presentity->get_presence () == "away"; if (groups.empty ()) groups.insert (_("Unsorted")); for (std::set<std::string>::const_iterator group = groups.begin (); group != groups.end (); group++) { roster_view_gtk_find_iter_for_group (self, heap, &heap_iter, *group, &group_iter); roster_view_gtk_find_iter_for_presentity (self, &group_iter, presentity, &iter); if (gtk_tree_model_filter_convert_child_iter_to_iter (filtered_model, &filtered_iter, &iter)) if (gtk_tree_selection_iter_is_selected (selection, &filtered_iter)) should_emit = TRUE; // Find out what our presence was gtk_tree_model_get (GTK_TREE_MODEL (self->priv->store), &iter, COLUMN_PRESENCE, &old_presence, -1); if (old_presence && presentity->get_presence () != old_presence && presentity->get_presence () != "unknown" && presentity->get_presence () != "offline" && (!g_strcmp0 (old_presence, "unknown") || !g_strcmp0 (old_presence, "offline"))) { StatusIconInfo *info = new StatusIconInfo (); info->model = GTK_TREE_MODEL (self->priv->store); info->iter = gtk_tree_iter_copy (&iter); info->cpt = 0; timeout = g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, 1, roster_view_gtk_icon_blink_cb, (gpointer) info, (GDestroyNotify) status_icon_info_delete); gtk_tree_store_set (self->priv->store, &iter, COLUMN_TIMEOUT, timeout, -1); } else { std::string icon = "avatar-default"; if (!old_presence) { gtk_tree_store_set (self->priv->store, &iter, COLUMN_PRESENCE_ICON, icon.c_str (), -1); } else if (old_presence != presentity->get_presence ()) { if (presentity->get_presence () != "unknown") icon = "user-" + presentity->get_presence (); gtk_tree_store_set (self->priv->store, &iter, COLUMN_PRESENCE_ICON, icon.c_str (), -1); } } status = presentity->get_status (); if (status.empty ()) { if (presentity->get_presence () == "away") status = _("Away"); else if (presentity->get_presence () == "available") status = _("Available"); else if (presentity->get_presence () == "offline") status = _("Offline"); else if (presentity->get_presence () == "busy") status = _("Busy"); } gtk_tree_store_set (self->priv->store, &iter, COLUMN_TYPE, TYPE_PRESENTITY, COLUMN_OFFLINE, active, COLUMN_HEAP, heap.get (), COLUMN_PRESENTITY, presentity.get (), COLUMN_NAME, presentity->get_name ().c_str (), COLUMN_STATUS, status.c_str (), COLUMN_PRESENCE, presentity->get_presence ().c_str (), COLUMN_ACTIVE, (!active || away) ? "gray" : "black", -1); gtk_tree_model_get (GTK_TREE_MODEL (self->priv->store), &iter, COLUMN_TIMEOUT, &timeout, -1); g_free (old_presence); } GtkTreeModel* model = gtk_tree_view_get_model (self->priv->tree_view); gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model)); roster_view_gtk_update_groups (self, &heap_iter); if (should_emit) g_signal_emit (self, signals[SELECTION_CHANGED_SIGNAL], 0); }