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