static gboolean
gnc_tree_model_owner_iter_next (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GncTreeModelOwner *model = GNC_TREE_MODEL_OWNER (tree_model);
GncTreeModelOwnerPrivate *priv;
GncOwner *owner;
gint i;
g_return_val_if_fail (GNC_IS_TREE_MODEL_OWNER (model), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (iter->user_data != NULL, FALSE);
g_return_val_if_fail (iter->stamp == model->stamp, FALSE);
ENTER("model %p, iter %s", tree_model, iter_to_string (iter));
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
/* Get the *next* sibling owner. */
i = GPOINTER_TO_INT (iter->user_data2);
owner = g_list_nth_data (priv->owner_list, i + 1);
if (owner == NULL)
{
iter->stamp = 0;
LEAVE("failed (3)");
return FALSE;
}
iter->user_data = owner;
iter->user_data2 = GINT_TO_POINTER (i + 1);
iter->user_data3 = NULL;
LEAVE("iter %s", iter_to_string(iter));
return TRUE;
}
static gboolean
gnc_tree_model_owner_iter_children (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreeIter *parent_iter)
{
GncTreeModelOwnerPrivate *priv;
GncTreeModelOwner *model;
g_return_val_if_fail (GNC_IS_TREE_MODEL_OWNER (tree_model), FALSE);
ENTER("model %p, iter %p (to be filed in), parent %s",
tree_model, iter, (parent_iter ? iter_to_string(parent_iter) : "(null)"));
model = GNC_TREE_MODEL_OWNER (tree_model);
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
/* Owner lists don't have children, so this function call only
* makes sense if no parent_iter was supplied. In that case,
* return the first owner in the list */
if (!parent_iter)
{
iter->user_data = g_list_nth_data (priv->owner_list, 0);
iter->user_data2 = GINT_TO_POINTER (0);
iter->user_data3 = NULL;
iter->stamp = model->stamp;
LEAVE("iter (2) %s", iter_to_string(iter));
return TRUE;
}
else
{
iter->stamp = 0;
LEAVE("failed (owners don't have children)");
return FALSE;
}
}
static void
gnc_tree_model_owner_dispose (GObject *object)
{
GncTreeModelOwnerPrivate *priv;
GncTreeModelOwner *model;
g_return_if_fail (object != NULL);
g_return_if_fail (GNC_IS_TREE_MODEL_OWNER (object));
ENTER("model %p", object);
model = GNC_TREE_MODEL_OWNER (object);
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
if (priv->event_handler_id)
{
qof_event_unregister_handler (priv->event_handler_id);
priv->event_handler_id = 0;
}
gnc_prefs_remove_cb_by_func(GNC_PREFS_GROUP_GENERAL, GNC_PREF_NEGATIVE_IN_RED,
gnc_tree_model_owner_update_color,
model);
if (G_OBJECT_CLASS (parent_class)->dispose)
G_OBJECT_CLASS (parent_class)->dispose (object);
LEAVE(" ");
}
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 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;
}
static GtkTreeModel *
sort_cb_setup_w_iters (GtkTreeModel *f_model,
GtkTreeIter *f_iter_a,
GtkTreeIter *f_iter_b,
GtkTreeIter *iter_a,
GtkTreeIter *iter_b,
const GncOwner **owner_a,
const GncOwner **owner_b)
{
GtkTreeModel *model;
model = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(f_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);
*owner_a = gnc_tree_model_owner_get_owner (GNC_TREE_MODEL_OWNER(model), iter_a);
*owner_b = gnc_tree_model_owner_get_owner (GNC_TREE_MODEL_OWNER(model), iter_b);
return model;
}
static int
gnc_tree_model_owner_iter_n_children (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GncTreeModelOwner *model;
GncTreeModelOwnerPrivate *priv;
g_return_val_if_fail (GNC_IS_TREE_MODEL_OWNER (tree_model), -1);
model = GNC_TREE_MODEL_OWNER (tree_model);
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE (model);
/* Owner lists don't have children, so always return 0, except for
* the special case this request comes for the special "root" iter
* (NULL). For that exception we return the size of the ower list.
*/
if (iter == NULL)
return (gint) g_list_length (priv->owner_list);
g_return_val_if_fail (
GNC_TREE_MODEL_OWNER (tree_model)->stamp == iter->stamp, -1);
return 0;
}
static gboolean
gnc_tree_model_owner_get_iter (GtkTreeModel *tree_model,
GtkTreeIter *iter,
GtkTreePath *path)
{
GncTreeModelOwnerPrivate *priv;
GncTreeModelOwner *model;
GncOwner *owner;
gint *indices;
g_return_val_if_fail (GNC_IS_TREE_MODEL_OWNER (tree_model), FALSE);
{
gchar *path_string = gtk_tree_path_to_string(path);
ENTER("model %p, iter %p, path %s", tree_model, iter, path_string);
g_free(path_string);
}
model = GNC_TREE_MODEL_OWNER (tree_model);
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
/* We keep a simple list of owners, not a tree, so only depth 1 is valid */
if (gtk_tree_path_get_depth (path) != 1)
{
LEAVE("bad depth");
return FALSE;
}
indices = gtk_tree_path_get_indices (path);
owner = g_list_nth_data (priv->owner_list, indices[0]);
if (owner == NULL)
{
iter->stamp = 0;
LEAVE("bad index");
return FALSE;
}
iter->stamp = model->stamp;
iter->user_data = owner;
iter->user_data2 = GINT_TO_POINTER (indices[0]);
iter->user_data3 = NULL;
LEAVE("iter %s", iter_to_string (iter));
return TRUE;
}
static GtkTreePath *
gnc_tree_model_owner_get_path (GtkTreeModel *tree_model,
GtkTreeIter *iter)
{
GncTreeModelOwner *model = GNC_TREE_MODEL_OWNER (tree_model);
GncTreeModelOwnerPrivate *priv;
GncOwner *owner;
GtkTreePath *path;
gint i;
g_return_val_if_fail (GNC_IS_TREE_MODEL_OWNER (model), NULL);
g_return_val_if_fail (iter != NULL, NULL);
g_return_val_if_fail (iter->user_data != NULL, NULL);
g_return_val_if_fail (iter->stamp == model->stamp, NULL);
ENTER("model %p, iter %s", model, iter_to_string(iter));
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
if (priv->owner_list == NULL)
{
LEAVE("failed (1)");
return NULL;
}
owner = (GncOwner *) iter->user_data;
path = gtk_tree_path_new ();
i = g_list_index (priv->owner_list, owner);
if (i == -1)
{
gtk_tree_path_free (path);
LEAVE("failed (3)");
return NULL;
}
gtk_tree_path_prepend_index (path, i);
{
gchar *path_string = gtk_tree_path_to_string(path);
LEAVE("path (4) %s", path_string);
g_free(path_string);
}
return path;
}
static gboolean
gnc_tree_view_owner_filter_helper (GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data)
{
GncOwner *owner;
GncTreeViewOwner *view = data;
GncTreeViewOwnerPrivate *priv;
g_return_val_if_fail (GNC_IS_TREE_MODEL_OWNER (model), FALSE);
g_return_val_if_fail (iter != NULL, FALSE);
owner = gnc_tree_model_owner_get_owner (
GNC_TREE_MODEL_OWNER(model), iter);
priv = GNC_TREE_VIEW_OWNER_GET_PRIVATE(view);
if (priv->filter_fn)
return priv->filter_fn(owner, priv->filter_data);
else return TRUE;
}
static GtkTreePath *
gnc_tree_view_owner_get_path_from_owner (GncTreeViewOwner *view,
GncOwner *owner)
{
GtkTreeModel *model, *f_model, *s_model;
GtkTreePath *path, *f_path, *s_path;
ENTER("view %p, owner %p (%s)", view, owner, gncOwnerGetName(owner));
if (owner == NULL)
{
LEAVE("no owner");
return NULL;
}
/* Reach down to the real model and get a path 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));
path = gnc_tree_model_owner_get_path_from_owner (GNC_TREE_MODEL_OWNER(model), owner);
if (path == NULL)
{
LEAVE("no path");
return NULL;
}
/* convert back to a filtered path */
f_path = gtk_tree_model_filter_convert_child_path_to_path (GTK_TREE_MODEL_FILTER (f_model), path);
gtk_tree_path_free(path);
if (!f_path)
{
LEAVE("no filter path");
return NULL;
}
/* convert back to a sorted path */
s_path = gtk_tree_model_sort_convert_child_path_to_path (GTK_TREE_MODEL_SORT (s_model), f_path);
gtk_tree_path_free(f_path);
debug_path(LEAVE, s_path);
return s_path;
}
static void
gnc_tree_model_owner_finalize (GObject *object)
{
GncTreeModelOwnerPrivate *priv;
GncTreeModelOwner *model;
g_return_if_fail (object != NULL);
g_return_if_fail (GNC_IS_TREE_MODEL_OWNER (object));
ENTER("model %p", object);
model = GNC_TREE_MODEL_OWNER (object);
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
priv->book = NULL;
priv->owner_list = NULL;
if (G_OBJECT_CLASS (parent_class)->finalize)
G_OBJECT_CLASS(parent_class)->finalize (object);
LEAVE(" ");
}
static void
gnc_tree_model_owner_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
int column,
GValue *value)
{
GncTreeModelOwner *model = GNC_TREE_MODEL_OWNER (tree_model);
GncOwner *owner;
gboolean negative; /* used to set "deficit style" also known as red numbers */
gchar *string = NULL;
g_return_if_fail (GNC_IS_TREE_MODEL_OWNER (model));
g_return_if_fail (iter != NULL);
g_return_if_fail (iter->user_data != NULL);
g_return_if_fail (iter->stamp == model->stamp);
ENTER("model %p, iter %s, col %d", tree_model,
iter_to_string(iter), column);
owner = (GncOwner *) iter->user_data;
switch (column)
{
case GNC_TREE_MODEL_OWNER_COL_NAME:
g_value_init (value, G_TYPE_STRING);
g_value_set_string (value, gncOwnerGetName (owner));
break;
case GNC_TREE_MODEL_OWNER_COL_TYPE:
g_value_init (value, G_TYPE_STRING);
g_value_set_string (value,
gncOwnerTypeToQofIdType (gncOwnerGetType (owner)));
break;
case GNC_TREE_MODEL_OWNER_COL_ID:
g_value_init (value, G_TYPE_STRING);
g_value_set_string (value, gncOwnerGetID (owner));
break;
case GNC_TREE_MODEL_OWNER_COL_CURRENCY:
g_value_init (value, G_TYPE_STRING);
g_value_set_string (value,
gnc_commodity_get_fullname(gncOwnerGetCurrency (owner)));
break;
case GNC_TREE_MODEL_OWNER_COL_ADDRESS_NAME:
g_value_init (value, G_TYPE_STRING);
string = g_strdup (gncAddressGetName (gncOwnerGetAddr (owner)));
if (string)
g_value_take_string (value, string);
else
g_value_set_static_string (value, "");
break;
case GNC_TREE_MODEL_OWNER_COL_ADDRESS_1:
g_value_init (value, G_TYPE_STRING);
string = g_strdup (gncAddressGetAddr1 (gncOwnerGetAddr (owner)));
if (string)
g_value_take_string (value, string);
else
g_value_set_static_string (value, "");
break;
case GNC_TREE_MODEL_OWNER_COL_ADDRESS_2:
g_value_init (value, G_TYPE_STRING);
string = g_strdup (gncAddressGetAddr2 (gncOwnerGetAddr (owner)));
if (string)
g_value_take_string (value, string);
else
g_value_set_static_string (value, "");
break;
case GNC_TREE_MODEL_OWNER_COL_ADDRESS_3:
g_value_init (value, G_TYPE_STRING);
string = g_strdup (gncAddressGetAddr3 (gncOwnerGetAddr (owner)));
if (string)
g_value_take_string (value, string);
else
g_value_set_static_string (value, "");
break;
case GNC_TREE_MODEL_OWNER_COL_ADDRESS_4:
g_value_init (value, G_TYPE_STRING);
string = g_strdup (gncAddressGetAddr4 (gncOwnerGetAddr (owner)));
if (string)
g_value_take_string (value, string);
else
g_value_set_static_string (value, "");
break;
case GNC_TREE_MODEL_OWNER_COL_PHONE:
g_value_init (value, G_TYPE_STRING);
string = g_strdup (gncAddressGetPhone (gncOwnerGetAddr (owner)));
if (string)
g_value_take_string (value, string);
else
g_value_set_static_string (value, "");
break;
case GNC_TREE_MODEL_OWNER_COL_FAX:
g_value_init (value, G_TYPE_STRING);
string = g_strdup (gncAddressGetFax (gncOwnerGetAddr (owner)));
if (string)
g_value_take_string (value, string);
else
g_value_set_static_string (value, "");
break;
case GNC_TREE_MODEL_OWNER_COL_EMAIL:
g_value_init (value, G_TYPE_STRING);
string = g_strdup (gncAddressGetEmail (gncOwnerGetAddr (owner)));
if (string)
g_value_take_string (value, string);
else
g_value_set_static_string (value, "");
break;
case GNC_TREE_MODEL_OWNER_COL_BALANCE:
g_value_init (value, G_TYPE_STRING);
string = gnc_ui_owner_get_print_balance(owner, &negative);
g_value_take_string (value, string);
break;
case GNC_TREE_MODEL_OWNER_COL_BALANCE_REPORT:
g_value_init (value, G_TYPE_STRING);
string = gnc_ui_owner_get_print_report_balance(owner, &negative);
g_value_take_string (value, string);
break;
case GNC_TREE_MODEL_OWNER_COL_COLOR_BALANCE:
g_value_init (value, G_TYPE_STRING);
string = gnc_ui_owner_get_print_balance(owner, &negative);
gnc_tree_model_owner_set_color(model, negative, value);
g_free(string);
break;
case GNC_TREE_MODEL_OWNER_COL_NOTES:
g_value_init (value, G_TYPE_STRING);
switch (gncOwnerGetType (owner))
{
case GNC_OWNER_NONE:
case GNC_OWNER_UNDEFINED:
case GNC_OWNER_EMPLOYEE:
case GNC_OWNER_JOB:
default:
g_value_set_static_string (value, "");
break;
case GNC_OWNER_VENDOR:
g_value_set_string (value, gncVendorGetNotes (gncOwnerGetVendor (owner)));
break;
case GNC_OWNER_CUSTOMER:
g_value_set_string (value, gncCustomerGetNotes (gncOwnerGetCustomer (owner)));
break;
}
break;
case GNC_TREE_MODEL_OWNER_COL_ACTIVE:
g_value_init (value, G_TYPE_BOOLEAN);
g_value_set_boolean (value, gncOwnerGetActive (owner));
break;
default:
g_assert_not_reached ();
}
LEAVE(" ");
}
/*
* Selects a single owner in the owner tree view. The owner
* tree must be in single selection mode.
*/
void
gnc_tree_view_owner_set_selected_owner (GncTreeViewOwner *view,
GncOwner *owner)
{
GtkTreeModel *model, *f_model, *s_model;
GtkTreePath *path, *f_path, *s_path, *parent_path;
GtkTreeSelection *selection;
ENTER("view %p, owner %p (%s)", view,
owner, gncOwnerGetName (owner));
g_return_if_fail (GNC_IS_TREE_VIEW_OWNER (view));
/* Clear any existing selection. */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_unselect_all (selection);
if (owner == NULL)
return;
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));
path = gnc_tree_model_owner_get_path_from_owner (
GNC_TREE_MODEL_OWNER(model), owner);
if (path == NULL)
{
LEAVE("no path");
return;
}
debug_path(DEBUG, path);
f_path = gtk_tree_model_filter_convert_child_path_to_path (
GTK_TREE_MODEL_FILTER (f_model), path);
gtk_tree_path_free(path);
if (f_path == NULL)
{
LEAVE("no filter path");
return;
}
debug_path(DEBUG, f_path);
s_path = gtk_tree_model_sort_convert_child_path_to_path (GTK_TREE_MODEL_SORT (s_model),
f_path);
gtk_tree_path_free(f_path);
if (s_path == NULL)
{
LEAVE("no sort path");
return;
}
gtk_tree_selection_select_path (selection, s_path);
/* give gtk+ a chance to resize the tree view first by handling pending
* configure events */
while (gtk_events_pending ())
gtk_main_iteration ();
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(view), s_path, NULL, FALSE, 0.0, 0.0);
debug_path(LEAVE, s_path);
gtk_tree_path_free(s_path);
}
