static void
panel_addto_drag_begin_cb (GtkWidget *widget,
GdkDragContext *context,
gpointer data)
{
GtkTreeModel *filter_model;
GtkTreeModel *child_model;
GtkTreePath *path;
GtkTreeIter iter;
GtkTreeIter filter_iter;
gchar *icon_name;
filter_model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
gtk_tree_view_get_cursor (GTK_TREE_VIEW (widget), &path, NULL);
gtk_tree_model_get_iter (filter_model, &filter_iter, path);
gtk_tree_path_free (path);
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (filter_model),
&iter, &filter_iter);
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
gtk_tree_model_get (child_model, &iter,
COLUMN_ICON_NAME, &icon_name,
-1);
gtk_drag_set_icon_name (context, icon_name, 0, 0);
g_free (icon_name);
}
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;
}
}
static gboolean
get_prices (GtkTreeModel *f_model,
GtkTreeIter *f_iter_a,
GtkTreeIter *f_iter_b,
GNCPrice **price_a,
GNCPrice **price_b)
{
GncTreeModelPrice *model;
GtkTreeModel *tree_model;
GtkTreeIter iter_a, iter_b;
tree_model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
model = GNC_TREE_MODEL_PRICE(tree_model);
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER(f_model),
&iter_a,
f_iter_a);
/* The iters must point to prices for this to be meaningful */
if (!gnc_tree_model_price_iter_is_price (model, &iter_a))
return FALSE;
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER(f_model),
&iter_b,
f_iter_b);
*price_a = gnc_tree_model_price_get_price (model, &iter_a);
*price_b = gnc_tree_model_price_get_price (model, &iter_b);
return TRUE;
}
static void
panel_addto_drag_begin_cb (GtkWidget *widget,
GdkDragContext *context,
gpointer data)
{
GtkTreeModel *filter_model;
GtkTreeModel *child_model;
GtkTreePath *path;
GtkTreeIter iter;
GtkTreeIter filter_iter;
GdkPixbuf *pixbuf;
filter_model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
gtk_tree_view_get_cursor (GTK_TREE_VIEW (widget), &path, NULL);
gtk_tree_model_get_iter (filter_model, &filter_iter, path);
gtk_tree_path_free (path);
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (filter_model),
&iter, &filter_iter);
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
gtk_tree_model_get (child_model, &iter,
COLUMN_ICON, &pixbuf,
-1);
gtk_drag_set_icon_pixbuf (context, pixbuf, 0, 0);
g_object_unref (pixbuf);
}
/************************************************************/
#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
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;
}
/*
If m is not a base TreeModel type (ie, is a filter or sorter) then
convert OP to a TreePath for the base and return it.
The return value must be freed by the caller.
*/
static GtkTreePath *
get_base_tree_path (GtkTreeModel *m, GtkTreePath *op)
{
GtkTreePath *p = gtk_tree_path_copy (op);
while ( ! PSPPIRE_IS_DICT (m))
{
GtkTreePath *oldp = p;
if (GTK_IS_TREE_MODEL_FILTER (m))
{
p = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER (m), oldp);
m = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (m));
}
else if (GTK_IS_TREE_MODEL_SORT (m))
{
p = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT (m), oldp);
m = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (m));
}
else
{
g_error ("Unexpected model type: %s", G_OBJECT_TYPE_NAME (m));
}
gtk_tree_path_free (oldp);
}
return p;
}
void bar_pane_keywords_filter_modify(GtkTreeModel *model, GtkTreeIter *iter, GValue *value, gint column, gpointer data)
{
PaneKeywordsData *pkd = data;
GtkTreeModel *keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
GtkTreeIter child_iter;
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, iter);
memset(value, 0, sizeof (GValue));
switch (column)
{
case FILTER_KEYWORD_COLUMN_TOGGLE:
{
GList *keywords = keyword_list_pull(pkd->keyword_view);
gboolean set = keyword_tree_is_set(keyword_tree, &child_iter, keywords);
string_list_free(keywords);
g_value_init(value, G_TYPE_BOOLEAN);
g_value_set_boolean(value, set);
break;
}
case FILTER_KEYWORD_COLUMN_MARK:
gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_MARK, value);
break;
case FILTER_KEYWORD_COLUMN_NAME:
gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_NAME, value);
break;
case FILTER_KEYWORD_COLUMN_IS_KEYWORD:
gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_IS_KEYWORD, value);
break;
}
return;
}
static void
ethernet_set_active (NmnModel *self,
gboolean active)
{
GtkTreeModel *child_model;
GtkTreeIter iter;
gboolean valid;
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (self));
valid = gtk_tree_model_get_iter_first (child_model, &iter);
while (valid) {
NMListItem *item = NULL;
gtk_tree_model_get (child_model, &iter, NM_LIST_MODEL_COL_ITEM, &item, -1);
if (item) {
if (NM_IS_ETHERNET_ITEM (item)) {
gboolean disconnected = nm_list_item_get_status (item) == NM_LIST_ITEM_STATUS_DISCONNECTED;
if (active && disconnected)
nm_list_item_connect (item);
else if (!active && !disconnected)
nm_list_item_disconnect (item);
}
g_object_unref (item);
}
valid = gtk_tree_model_iter_next (child_model, &iter);
}
}
static void bar_pane_keywords_connect_mark_cb(GtkWidget *menu_widget, gpointer data)
{
PaneKeywordsData *pkd = data;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreeModel *keyword_tree;
GtkTreeIter kw_iter;
gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_widget), "mark")) - 1;
model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
if (!pkd->click_tpath) return;
if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
meta_data_connect_mark_with_keyword(keyword_tree, &kw_iter, mark);
file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
// bar_pane_keywords_update(pkd);
}
static gint
sort_namespace (GtkTreeModel *f_model,
GtkTreeIter *f_iter_a,
GtkTreeIter *f_iter_b)
{
GncTreeModelCommodity *model;
GtkTreeModel *tree_model;
GtkTreeIter iter_a, iter_b;
gnc_commodity_namespace *ns_a, *ns_b;
tree_model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
model = GNC_TREE_MODEL_COMMODITY(tree_model);
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER(f_model),
&iter_a,
f_iter_a);
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER(f_model),
&iter_b,
f_iter_b);
ns_a = gnc_tree_model_commodity_get_namespace (model, &iter_a);
ns_b = gnc_tree_model_commodity_get_namespace (model, &iter_b);
return safe_utf8_collate (gnc_commodity_namespace_get_gui_name (ns_a),
gnc_commodity_namespace_get_gui_name (ns_b));
}
int
_pygtk_tree_model_remove_row(GtkTreeModel *model, GtkTreeIter *iter)
{
GtkTreeModel *child;
GtkTreeIter citer;
if (GTK_IS_LIST_STORE(model)) {
gtk_list_store_remove(GTK_LIST_STORE(model), iter);
return 0;
}
if (GTK_IS_TREE_STORE(model)) {
gtk_tree_store_remove(GTK_TREE_STORE(model), iter);
return 0;
}
if (GTK_IS_TREE_MODEL_SORT(model)) {
child = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
gtk_tree_model_sort_convert_iter_to_child_iter(
GTK_TREE_MODEL_SORT(model), &citer, iter);
return _pygtk_tree_model_remove_row(child, &citer);
}
if (GTK_IS_TREE_MODEL_FILTER(model)) {
child = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(model), &citer, iter);
return _pygtk_tree_model_remove_row(child, &citer);
}
PyErr_SetString(PyExc_TypeError,
"cannot remove rows in this tree model");
return -1;
}
static gint
sort_ns_or_cm (GtkTreeModel *f_model,
GtkTreeIter *f_iter_a,
GtkTreeIter *f_iter_b)
{
GncTreeModelPrice *model;
GtkTreeModel *tree_model;
GtkTreeIter iter_a, iter_b;
gnc_commodity_namespace *ns_a, *ns_b;
gnc_commodity *comm_a, *comm_b;
tree_model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
model = GNC_TREE_MODEL_PRICE(tree_model);
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER(f_model),
&iter_a,
f_iter_a);
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER(f_model),
&iter_b,
f_iter_b);
if (gnc_tree_model_price_iter_is_namespace (model, &iter_a))
{
ns_a = gnc_tree_model_price_get_namespace (model, &iter_a);
ns_b = gnc_tree_model_price_get_namespace (model, &iter_b);
return safe_utf8_collate (gnc_commodity_namespace_get_name (ns_a),
gnc_commodity_namespace_get_name (ns_b));
}
comm_a = gnc_tree_model_price_get_commodity (model, &iter_a);
comm_b = gnc_tree_model_price_get_commodity (model, &iter_b);
return safe_utf8_collate (gnc_commodity_get_mnemonic (comm_a),
gnc_commodity_get_mnemonic (comm_b));
}
static void
modems_deactive (NmnModel *self)
{
GtkTreeModel *child_model;
GtkTreeIter iter;
gboolean valid;
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (self));
valid = gtk_tree_model_get_iter_first (child_model, &iter);
while (valid) {
NMListItem *item = NULL;
gtk_tree_model_get (child_model, &iter, NM_LIST_MODEL_COL_ITEM, &item, -1);
if (item) {
if ((NM_IS_GSM_ITEM (item) || NM_IS_CDMA_ITEM (item)) &&
nm_list_item_get_status (item) != NM_LIST_ITEM_STATUS_DISCONNECTED)
nm_list_item_disconnect (item);
g_object_unref (item);
}
valid = gtk_tree_model_iter_next (child_model, &iter);
}
}
static void
on_user_privilege_toggled (GtkCellRendererToggle *cell, gchar *path_str, gpointer data)
{
GtkTreeModel *model, *child_model;
GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
GtkTreeIter iter, child_iter;
OobsGroup *group;
gboolean value;
model = (GtkTreeModel*) data;
if (gtk_tree_model_get_iter (model, &iter, path)) {
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model),
&child_iter, &iter);
gtk_tree_model_get (child_model, &child_iter,
COL_MEMBER, &value,
COL_GROUP, &group, -1);
/* check that current user should be allowed to lose admin rights,
* possibly showing a warning/error dialog */
if (!value || strcmp (oobs_group_get_name (group), ADMIN_GROUP) != 0
|| user_settings_check_revoke_admin_rights ())
gtk_list_store_set (GTK_LIST_STORE (child_model), &child_iter, COL_MEMBER, !value, -1);
g_object_unref (group);
}
gtk_tree_path_free (path);
}
void
privileges_table_set_from_profile (GstUserProfile *profile)
{
GtkWidget *table;
GtkTreeModel *model, *child_model;
GtkTreeIter iter;
gboolean valid;
OobsGroup *group;
table = gst_dialog_get_widget (tool->main_dialog, "user_privileges");
model = gtk_tree_view_get_model (GTK_TREE_VIEW (table));
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
valid = gtk_tree_model_get_iter_first (child_model, &iter);
while (valid) {
gtk_tree_model_get (child_model, &iter,
COL_GROUP, &group,
-1);
gtk_list_store_set (GTK_LIST_STORE (child_model), &iter,
COL_MEMBER, find_group_in_profile (group, profile),
-1);
g_object_unref (group);
valid = gtk_tree_model_iter_next (child_model, &iter);
}
}
void
privileges_table_save (OobsUser *user)
{
GtkWidget *table;
GtkTreeModel *model, *child_model;
GtkTreeIter iter;
OobsGroup *group;
gboolean valid, member;
table = gst_dialog_get_widget (tool->main_dialog, "user_privileges");
model = gtk_tree_view_get_model (GTK_TREE_VIEW (table));
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
valid = gtk_tree_model_get_iter_first (child_model, &iter);
while (valid) {
gtk_tree_model_get (child_model, &iter,
COL_GROUP, &group,
COL_MEMBER, &member,
-1);
if (member)
oobs_group_add_user (group, user);
else
oobs_group_remove_user (group, user);
valid = gtk_tree_model_iter_next (child_model, &iter);
}
}
void
privileges_table_set_from_user (OobsUser *user)
{
GtkWidget *table;
GtkTreeModel *model, *child_model;
GtkTreeIter iter;
gboolean valid;
OobsGroup *group;
GList *users;
table = gst_dialog_get_widget (tool->main_dialog, "user_privileges");
model = gtk_tree_view_get_model (GTK_TREE_VIEW (table));
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
valid = gtk_tree_model_get_iter_first (child_model, &iter);
while (valid) {
gtk_tree_model_get (child_model, &iter,
COL_GROUP, &group,
-1);
users = oobs_group_get_users (group);
gtk_list_store_set (GTK_LIST_STORE (child_model), &iter,
COL_MEMBER, (g_list_find (users, user) != NULL),
-1);
g_list_free (users);
g_object_unref (group);
valid = gtk_tree_model_iter_next (child_model, &iter);
}
}
/*
* Retrieve the selected commodity from an commodity tree view. The
* commodity tree must be in single selection mode.
*/
gnc_commodity *
gnc_tree_view_commodity_get_selected_commodity (GncTreeViewCommodity *view)
{
GtkTreeSelection *selection;
GtkTreeModel *model, *f_model, *s_model;
GtkTreeIter iter, f_iter, s_iter;
gnc_commodity *commodity;
g_return_val_if_fail (GNC_IS_TREE_VIEW_COMMODITY (view), NULL);
ENTER("view %p", view);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
if (!gtk_tree_selection_get_selected (selection, &s_model, &s_iter))
{
LEAVE("no commodity, get_selected failed");
return FALSE;
}
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (s_model),
&f_iter, &s_iter);
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (f_model),
&iter, &f_iter);
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
commodity = gnc_tree_model_commodity_get_commodity (GNC_TREE_MODEL_COMMODITY(model),
&iter);
LEAVE("commodity %p (%s)", commodity,
commodity ? gnc_commodity_get_mnemonic(commodity) : "");
return commodity;
}
/************************************************************/
#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;
}
QModelIndex
gtk_combo_box_get_index(GtkComboBox *box)
{
GtkTreeIter filter_iter;
GtkTreeIter child_iter;
GtkTreeModel *filter_model = gtk_combo_box_get_model(box);
GtkTreeModel *model = filter_model;
GtkTreeIter *iter = NULL;
if (GTK_IS_TREE_MODEL_FILTER(filter_model))
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(filter_model));
if (gtk_combo_box_get_active_iter(box, &filter_iter)) {
if (GTK_IS_TREE_MODEL_FILTER(filter_model)) {
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER(filter_model),
&child_iter,
&filter_iter);
iter = &child_iter;
} else {
iter = &filter_iter;
}
if (GTK_IS_Q_TREE_MODEL(model))
return gtk_q_tree_model_get_source_idx(GTK_Q_TREE_MODEL(model), iter);
}
return QModelIndex();
}
GncOwner *
gnc_tree_view_owner_get_owner_from_iter (GtkTreeModel *s_model,
GtkTreeIter *s_iter)
{
GtkTreeModel *model, *f_model;
GtkTreeIter iter, f_iter;
GncOwner *owner;
g_return_val_if_fail (GTK_IS_TREE_MODEL_SORT(s_model), NULL);
g_return_val_if_fail (s_iter != NULL, NULL);
ENTER("model %p, iter %p", s_model, s_iter);
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT(s_model),
&f_iter,
s_iter);
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
gtk_tree_model_filter_convert_iter_to_child_iter (
GTK_TREE_MODEL_FILTER(f_model), &iter, &f_iter);
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
owner = gnc_tree_model_owner_get_owner (
GNC_TREE_MODEL_OWNER(model), &iter);
LEAVE("owner %p (%s)", owner, gncOwnerGetName (owner));
return owner;
}
static void
ecal_objects_removed (ECalView *ecalview, GList *uids,
DatesNavigatorModel * nav)
{
ECal *ecal = e_cal_view_get_client (ecalview);
GtkTreeIter iter;
GtkListStore * store =
GTK_LIST_STORE (gtk_tree_model_filter_get_model (
GTK_TREE_MODEL_FILTER (nav)));
for (; uids; uids = uids->next)
{
gchar *uri_uid;
#ifdef HAVE_CID_TYPE
ECalComponentId *id = uids->data;
uri_uid = g_strconcat (e_cal_get_uri (ecal), id->uid, NULL);
#else
uri_uid = g_strconcat (e_cal_get_uri (ecal), uids->data, NULL);
#endif
if (find_item (store, uri_uid, &iter))
gtk_list_store_remove (store, &iter);
g_free (uri_uid);
}
}
/*
* Retrieve the selected price from an price tree view. The
* price tree must be in single selection mode.
*/
GNCPrice *
gnc_tree_view_price_get_selected_price (GncTreeViewPrice *view)
{
GtkTreeSelection *selection;
GtkTreeModel *model, *f_model, *s_model;
GtkTreeIter iter, f_iter, s_iter;
GNCPrice *price;
ENTER("view %p", view);
g_return_val_if_fail (GNC_IS_TREE_VIEW_PRICE (view), NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
if (!gtk_tree_selection_get_selected (selection, &s_model, &s_iter))
{
LEAVE("no price, get_selected failed");
return FALSE;
}
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (s_model),
&f_iter, &s_iter);
f_model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(s_model));
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (f_model),
&iter, &f_iter);
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_model));
price = gnc_tree_model_price_get_price (GNC_TREE_MODEL_PRICE(model),
&iter);
LEAVE("price %p", price);
return price;
}
/* settings_get_model */
static GtkTreeModel * _settings_get_model(Settings * settings)
{
GtkTreeModel * model;
model = gtk_icon_view_get_model(GTK_ICON_VIEW(settings->view));
model = gtk_tree_model_sort_get_model(GTK_TREE_MODEL_SORT(model));
return gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
}
static GtkTreeModel*
hildon_find_toolbar_get_list_model (HildonFindToolbarPrivate *priv)
{
GtkTreeModel *filter_model =
gtk_combo_box_get_model (GTK_COMBO_BOX (priv->entry_combo_box));
return filter_model == NULL ? NULL :
gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (filter_model));
}
/* FIXME: should this API be put here? Maybe it belongs to prk-dir-tree.c */
char* ptk_dir_view_get_dir_path( GtkTreeModel* model, GtkTreeIter* it )
{
GtkTreeModel * tree;
GtkTreeIter real_it;
gtk_tree_model_filter_convert_iter_to_child_iter(
GTK_TREE_MODEL_FILTER( model ), &real_it, it );
tree = gtk_tree_model_filter_get_model( GTK_TREE_MODEL_FILTER( model ) );
return ptk_dir_tree_get_dir_path( PTK_DIR_TREE( tree ), &real_it );
}
static VALUE
rg_convert_iter_to_child_iter(VALUE self, VALUE filtered_iter)
{
GtkTreeIter child_iter;
GtkTreeModelFilter* modelfilter = _SELF(self);
gtk_tree_model_filter_convert_iter_to_child_iter(modelfilter, &child_iter,
RVAL2GTKTREEITER(filtered_iter));
child_iter.user_data3 = gtk_tree_model_filter_get_model(modelfilter);
return GTKTREEITER2RVAL(&child_iter);
}
static void
ecal_objects_changed (ECalView * cview, GList *objects,
DatesNavigatorModel * nav)
{
ECal *ecal = e_cal_view_get_client (cview);
GtkListStore * store =
GTK_LIST_STORE (gtk_tree_model_filter_get_model (
GTK_TREE_MODEL_FILTER (nav)));
for (; objects; objects = objects->next)
{
const char *uid = icalcomponent_get_uid (objects->data);
gchar *uri_uid;
GtkTreeIter iter;
const gchar * summary;
gchar * s = NULL;
gchar time[100];
gchar * folded = NULL;
if (!uid)
continue;
uri_uid = g_strconcat (e_cal_get_uri (ecal), uid, NULL);
if (!find_item (store, uri_uid, &iter))
gtk_list_store_append (store, &iter);
summary = icalcomponent_get_summary (objects->data);
if (summary)
folded = g_utf8_casefold (summary, -1);
/* use only first 15 chars of the summary */
if (summary && g_utf8_strlen (summary, -1) > 15)
{
s = g_strdup (summary);
gchar * p = g_utf8_offset_to_pointer (s, 15);
*p = 0;
summary = s;
}
event_time (objects->data, (gchar*)&time, sizeof(time),
nav->priv->format);
gtk_list_store_set (store, &iter,
DN_Name, summary,
DN_Time, time,
DN_Uid, uri_uid,
DN_NameFolded, folded,
-1);
g_free (uri_uid);
g_free (s);
g_free (folded);
}
}
void
privileges_table_clear (void)
{
GtkWidget *table;
GtkTreeModel *model, *child_model;
table = gst_dialog_get_widget (tool->main_dialog, "user_privileges");
model = gtk_tree_view_get_model (GTK_TREE_VIEW (table));
child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
gtk_list_store_clear (GTK_LIST_STORE (child_model));
}
