From 9c1899d30a3d50135509e11cdef2cc7a01e94a11 Mon Sep 17 00:00:00 2001 From: Derek Atkins Date: Mon, 19 May 2003 18:03:44 +0000 Subject: [PATCH] Jan Arne Petersen's gnome2 patch #7. See the ChangeLog for more info. git-svn-id: svn+ssh://svn.gnucash.org/repo/gnucash/branches/gnucash-gnome2-dev@8341 57a11ea4-9604-0410-9ed3-97b8803252fd --- ChangeLog | 31 + src/gnome-utils/Makefile.am | 4 + src/gnome-utils/gnc-amount-edit.c | 17 +- src/gnome-utils/gnc-mdi-utils.c | 10 +- src/gnome-utils/gnc-tree-model-account.c | 704 ++++++++++++++++++ src/gnome-utils/gnc-tree-model-account.h | 62 ++ .../gnc-tree-model-example-account.c | 450 +++++++++++ .../gnc-tree-model-example-account.h | 64 ++ src/gnome/dialog-commodities.c | 48 +- src/gnome/dialog-new-user.c | 4 +- src/gnome/glade/commodities.glade | 1 + src/gnome/window-acct-tree.c | 26 +- src/gnome/window-main.c | 31 +- 13 files changed, 1399 insertions(+), 53 deletions(-) create mode 100644 src/gnome-utils/gnc-tree-model-account.c create mode 100644 src/gnome-utils/gnc-tree-model-account.h create mode 100644 src/gnome-utils/gnc-tree-model-example-account.c create mode 100644 src/gnome-utils/gnc-tree-model-example-account.h diff --git a/ChangeLog b/ChangeLog index 7fbb8976cb..8ee347f50a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,34 @@ +2003-05-19 Jan Arne Petersen + + Fix some nome-mdi problems: + * src/gnome-utils/gnc-mdi-utils.c: (gnc_mdi_child_changed_cb), + (gnc_mdi_new), (gnc_app_set_title): + * src/gnome/window-acct-tree.c: (gnc_acct_tree_view_labeler), + (gnc_acct_tree_view_new), (gnc_main_window_open_accounts), + (gnc_acct_tree_find_account_from_gncmdi), + (gnc_acct_tree_window_new): + * src/gnome/window-main.c: (gnc_main_window_get_mdi_child), + (gnc_main_window_add_child_cb), (gnc_main_window_add_view_cb), + (gnc_main_window_new), (gnc_main_window_dispatch_cb), + (gnc_main_window_file_close_cb): + + Replace some gtk_signal and gtk_type methods by g_signal and g_type + methods: + * src/gnome-utils/gnc-amount-edit.c: (gnc_amount_edit_class_init), + (gnc_amount_edit_init), (gnc_amount_edit_changed), + (gnc_amount_edit_new): + * src/gnome/dialog-commodities.c: (response_cb), + (gnc_commodities_dialog_create), (close_handler): + * src/gnome/dialog-new-user.c: (gnc_ui_new_user_dialog): + * src/gnome/glade/commodities.glade: + + Add GtkTreeModel for Accounts and ExampleAccounts: + * src/gnome-utils/Makefile.am: + * src/gnome-utils/gnc-tree-model-account.c + * src/gnome-utils/gnc-tree-model-account.h + * src/gnome-utils/gnc-tree-model-example-account.c + * src/gnome-utils/gnc-tree-model-example-account.h + 2003-05-18 Derek Atkins * macros/autogen.sh: comment out intltoolize and libtoolize again diff --git a/src/gnome-utils/Makefile.am b/src/gnome-utils/Makefile.am index cb3c4aec0e..b2d65b0653 100644 --- a/src/gnome-utils/Makefile.am +++ b/src/gnome-utils/Makefile.am @@ -45,6 +45,8 @@ libgncmod_gnome_utils_la_SOURCES = \ gnc-html.c \ gnc-mdi-utils.c \ gnc-menu-extensions.c \ + gnc-tree-model-account.c \ + gnc-tree-model-example-account.c \ gncmod-gnome-utils.c \ gtkselect.c \ print-session.c \ @@ -78,6 +80,8 @@ gncinclude_HEADERS = \ gnc-html.h \ gnc-mdi-utils.h \ gnc-menu-extensions.h \ + gnc-tree-model-account.h \ + gnc-tree-model-example-account.h \ gtkselect.h \ print-session.h \ window-help.h diff --git a/src/gnome-utils/gnc-amount-edit.c b/src/gnome-utils/gnc-amount-edit.c index 0b8bbddfea..89854d911d 100644 --- a/src/gnome-utils/gnc-amount-edit.c +++ b/src/gnome-utils/gnc-amount-edit.c @@ -54,7 +54,7 @@ static gint amount_edit_signals [LAST_SIGNAL] = { 0 }; static void gnc_amount_edit_init (GNCAmountEdit *gae); static void gnc_amount_edit_class_init (GNCAmountEditClass *class); -static void gnc_amount_edit_changed (GtkEditable *gae); +static void gnc_amount_edit_changed (GtkEditable *gae, gpointer data); static gint gnc_amount_edit_key_press (GtkWidget *widget, GdkEventKey *event); @@ -98,11 +98,11 @@ gnc_amount_edit_class_init (GNCAmountEditClass *klass) { GObjectClass *object_class; GtkWidgetClass *widget_class; - GtkEditableClass *editable_class; + /* GtkEditableClass *editable_class; */ object_class = G_OBJECT_CLASS (klass); widget_class = GTK_WIDGET_CLASS (klass); - editable_class = GTK_EDITABLE_CLASS (klass); + /* editable_class = GTK_EDITABLE_CLASS (g_type_interface_peek (klass, GTK_TYPE_EDITABLE)); */ parent_class = g_type_class_peek_parent (klass); @@ -119,7 +119,7 @@ gnc_amount_edit_class_init (GNCAmountEditClass *klass) widget_class->key_press_event = gnc_amount_edit_key_press; - editable_class->changed = gnc_amount_edit_changed; + /* editable_class->changed = gnc_amount_edit_changed; */ } static void @@ -130,12 +130,15 @@ gnc_amount_edit_init (GNCAmountEdit *gae) gae->print_info = gnc_default_print_info (FALSE); gae->fraction = 0; gae->evaluate_on_enter = FALSE; + + g_signal_connect (G_OBJECT (gae), "changed", + G_CALLBACK (gnc_amount_edit_changed), NULL); } static void -gnc_amount_edit_changed (GtkEditable *editable) +gnc_amount_edit_changed (GtkEditable *editable, gpointer data) { - (* GTK_EDITABLE_CLASS (parent_class)->changed)(editable); + /*GTK_EDITABLE_CLASS (parent_class)->changed(editable);*/ GNC_AMOUNT_EDIT(editable)->need_to_parse = TRUE; } @@ -189,7 +192,7 @@ gnc_amount_edit_new (void) { GNCAmountEdit *gae; - gae = gtk_type_new (gnc_amount_edit_get_type ()); + gae = g_object_new (GNC_TYPE_AMOUNT_EDIT, NULL); return GTK_WIDGET (gae); } diff --git a/src/gnome-utils/gnc-mdi-utils.c b/src/gnome-utils/gnc-mdi-utils.c index 2017d8be3c..2410c3c4bf 100644 --- a/src/gnome-utils/gnc-mdi-utils.c +++ b/src/gnome-utils/gnc-mdi-utils.c @@ -672,14 +672,14 @@ gnc_mdi_child_changed_cb (GnomeMDI * mdi, GnomeMDIChild * prev_child, if (prev_child) { - prevwin = gtk_object_get_user_data (GTK_OBJECT(prev_child)); + prevwin = g_object_get_data (G_OBJECT(prev_child), "gnc-mdi-child-info"); if (mdi->mode != GNOME_MDI_TOPLEVEL) gnc_mdi_update_widgets(prevwin, FALSE); } if (mdi && mdi->active_child) { - childwin = gtk_object_get_user_data (GTK_OBJECT(mdi->active_child)); + childwin = g_object_get_data (G_OBJECT(mdi->active_child), "gnc-mdi-child-info"); new_app = gnome_mdi_get_app_from_view (childwin->contents); } @@ -906,11 +906,11 @@ gnc_mdi_new (const char *app_name, G_CALLBACK (gnc_mdi_destroy_cb), gnc_mdi); - g_signal_connect (G_OBJECT (gnc_mdi->mdi), "app_created", + g_signal_connect (G_OBJECT (gnc_mdi->mdi), "app-created", G_CALLBACK (gnc_mdi_app_created_cb), gnc_mdi); - g_signal_connect (G_OBJECT (gnc_mdi->mdi), "child_changed", + g_signal_connect (G_OBJECT (gnc_mdi->mdi), "child-changed", G_CALLBACK (gnc_mdi_child_changed_cb), gnc_mdi); @@ -1034,7 +1034,7 @@ gnc_app_set_title (GnomeApp *app) child = gnome_mdi_get_child_from_view (view); if (!child) return; - childwin = gtk_object_get_user_data (GTK_OBJECT (child)); + childwin = g_object_get_data (G_OBJECT (child), "gnc-mdi-child-info"); if (!childwin) return; gnc_mdi_child_set_title (childwin); diff --git a/src/gnome-utils/gnc-tree-model-account.c b/src/gnome-utils/gnc-tree-model-account.c new file mode 100644 index 0000000000..507aa422ff --- /dev/null +++ b/src/gnome-utils/gnc-tree-model-account.c @@ -0,0 +1,704 @@ +/* + * gnc-tree-model-account.c -- GtkTreeModel implementation to display accounts in a GtkTreeView. + * Copyright (C) 2003 Jan Arne Petersen + * Author: Jan Arne Petersen + */ + +#include "config.h" + +#include "gnc-tree-model-account.h" +#include "Account.h" +#include "Group.h" + +static void gnc_tree_model_account_class_init (GNCTreeModelAccountClass *klass); +static void gnc_tree_model_account_init (GNCTreeModelAccount *model); +static void gnc_tree_model_account_finalize (GObject *object); + +static void gnc_tree_model_account_tree_model_init (GtkTreeModelIface *iface); +static guint gnc_tree_model_account_get_flags (GtkTreeModel *tree_model); +static int gnc_tree_model_account_get_n_columns (GtkTreeModel *tree_model); +static GType gnc_tree_model_account_get_column_type (GtkTreeModel *tree_model, + int index); +static gboolean gnc_tree_model_account_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path); +static GtkTreePath *gnc_tree_model_account_get_path (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static void gnc_tree_model_account_get_value (GtkTreeModel *tree_model, + GtkTreeIter *iter, + int column, + GValue *value); +static gboolean gnc_tree_model_account_iter_next (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static gboolean gnc_tree_model_account_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent); +static gboolean gnc_tree_model_account_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static int gnc_tree_model_account_iter_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static gboolean gnc_tree_model_account_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + int n); +static gboolean gnc_tree_model_account_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child); + +/*static gpointer account_row_deleted (Account *account, + gpointer data);*/ +static gpointer account_row_inserted (Account *account, + gpointer data); + + +struct GNCTreeModelAccountPrivate +{ + AccountGroup *root; +}; + +static GObjectClass *parent_class = NULL; + +GType +gnc_tree_model_account_get_type (void) +{ + static GType gnc_tree_model_account_type = 0; + + if (gnc_tree_model_account_type == 0) { + static const GTypeInfo our_info = { + sizeof (GNCTreeModelAccountClass), + NULL, + NULL, + (GClassInitFunc) gnc_tree_model_account_class_init, + NULL, + NULL, + sizeof (GNCTreeModelAccount), + 0, + (GInstanceInitFunc) gnc_tree_model_account_init + }; + + static const GInterfaceInfo tree_model_info = { + (GInterfaceInitFunc) gnc_tree_model_account_tree_model_init, + NULL, + NULL + }; + + gnc_tree_model_account_type = g_type_register_static (G_TYPE_OBJECT, + "GNCTreeModelAccount", + &our_info, 0); + + g_type_add_interface_static (gnc_tree_model_account_type, + GTK_TYPE_TREE_MODEL, + &tree_model_info); + } + + return gnc_tree_model_account_type; +} + +static void +gnc_tree_model_account_class_init (GNCTreeModelAccountClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = gnc_tree_model_account_finalize; +} + +static void +gnc_tree_model_account_init (GNCTreeModelAccount *model) +{ + while (model->stamp == 0) { + model->stamp = g_random_int (); + } + + model->priv = g_new0 (GNCTreeModelAccountPrivate, 1); +} + +static void +gnc_tree_model_account_finalize (GObject *object) +{ + GNCTreeModelAccount *model; + + g_return_if_fail (object != NULL); + g_return_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (object)); + + model = GNC_TREE_MODEL_ACCOUNT (object); + + g_return_if_fail (model->priv != NULL); + + g_free (model->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +GNCTreeModelAccount * +gnc_tree_model_account_new (AccountGroup *group) +{ + GNCTreeModelAccount *model; + + model = g_object_new (GNC_TYPE_TREE_MODEL_ACCOUNT, + NULL); + + model->priv->root = group; + + return model; +} + +void +gnc_tree_model_account_set_root (GNCTreeModelAccount *model, + AccountGroup *group) +{ + GtkTreePath *path; + gint i; + + g_return_if_fail (model != NULL); + g_return_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (model)); + + if (model->priv->root != NULL) { + path = gtk_tree_path_new_first (); + for (i = 0; i < xaccGroupGetNumAccounts (model->priv->root); i++) { + gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); + } + gtk_tree_path_free (path); + } + + model->priv->root = group; + + if (model->priv->root != NULL) { + xaccGroupForEachAccount (model->priv->root, account_row_inserted, model, TRUE); + } +} + +Account * +gnc_tree_model_account_get_account (GNCTreeModelAccount *model, + GtkTreeIter *iter) +{ + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (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); + + return (Account *) iter->user_data; +} + +static void +gnc_tree_model_account_tree_model_init (GtkTreeModelIface *iface) +{ + iface->get_flags = gnc_tree_model_account_get_flags; + iface->get_n_columns = gnc_tree_model_account_get_n_columns; + iface->get_column_type = gnc_tree_model_account_get_column_type; + iface->get_iter = gnc_tree_model_account_get_iter; + iface->get_path = gnc_tree_model_account_get_path; + iface->get_value = gnc_tree_model_account_get_value; + iface->iter_next = gnc_tree_model_account_iter_next; + iface->iter_children = gnc_tree_model_account_iter_children; + iface->iter_has_child = gnc_tree_model_account_iter_has_child; + iface->iter_n_children = gnc_tree_model_account_iter_n_children; + iface->iter_nth_child = gnc_tree_model_account_iter_nth_child; + iface->iter_parent = gnc_tree_model_account_iter_parent; +} + +static guint +gnc_tree_model_account_get_flags (GtkTreeModel *tree_model) +{ + return 0; +} + +static int +gnc_tree_model_account_get_n_columns (GtkTreeModel *tree_model) +{ + return GNC_TREE_MODEL_ACCOUNT_NUM_COLUMNS; +} + +static GType +gnc_tree_model_account_get_column_type (GtkTreeModel *tree_model, + int index) +{ + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (tree_model), G_TYPE_INVALID); + g_return_val_if_fail ((index < GNC_TREE_MODEL_ACCOUNT_NUM_COLUMNS) && (index >= 0), G_TYPE_INVALID); + + switch (index) { + case GNC_TREE_MODEL_ACCOUNT_COL_TYPE: + case GNC_TREE_MODEL_ACCOUNT_COL_NAME: + case GNC_TREE_MODEL_ACCOUNT_COL_CODE: + case GNC_TREE_MODEL_ACCOUNT_COL_DESCRIPTION: + case GNC_TREE_MODEL_ACCOUNT_COL_NOTES: + case GNC_TREE_MODEL_ACCOUNT_COL_LASTNUM: + return G_TYPE_STRING; + case GNC_TREE_MODEL_ACCOUNT_COL_PLACEHOLDER: + return G_TYPE_BOOLEAN; + default: + g_assert_not_reached (); + return G_TYPE_INVALID; + } +} + +static gboolean +gnc_tree_model_account_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path) +{ + GNCTreeModelAccount *model; + Account *account = NULL; + AccountGroup *group = NULL, *children; + gint i = 0, *indices; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (tree_model), FALSE); + + model = GNC_TREE_MODEL_ACCOUNT (tree_model); + + if (model->priv->root == NULL) + return FALSE; + + children = model->priv->root; + + indices = gtk_tree_path_get_indices (path); + for (i = 0; i < gtk_tree_path_get_depth (path); i++) { + group = children; + if (indices[i] >= xaccGroupGetNumAccounts (group)) { + iter->stamp = 0; + + return FALSE; + } + + account = xaccGroupGetAccount (group, indices[i]); + children = xaccAccountGetChildren (account); + } + + if (account == NULL || group == NULL) { + iter->stamp = 0; + + return FALSE; + } + + iter->stamp = model->stamp; + iter->user_data = account; + iter->user_data2 = group; + iter->user_data3 = GINT_TO_POINTER (indices[i - 1]); + + return TRUE; +} + +static GtkTreePath * +gnc_tree_model_account_get_path (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + GNCTreeModelAccount *model = GNC_TREE_MODEL_ACCOUNT (tree_model); + Account *account; + AccountGroup *group; + GtkTreePath *path; + gint i; + gboolean found, finished = FALSE; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (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); + + if (model->priv->root == NULL) + return NULL; + + account = (Account *) iter->user_data; + group = (AccountGroup *) iter->user_data2; + + path = gtk_tree_path_new (); + + do { + found = FALSE; + for (i = 0; i < xaccGroupGetNumAccounts (group); i++) { + if (xaccGroupGetAccount (group, i) == account) { + found = TRUE; + if (group == model->priv->root) + finished = TRUE; + break; + } + } + + if (!found) { + gtk_tree_path_free (path); + return NULL; + } + + gtk_tree_path_prepend_index (path, i); + + account = xaccAccountGetParentAccount (account); + group = xaccAccountGetParent (account); + } while (!finished); + + return path; +} + +static void +gnc_tree_model_account_get_value (GtkTreeModel *tree_model, + GtkTreeIter *iter, + int column, + GValue *value) +{ + GNCTreeModelAccount *model = GNC_TREE_MODEL_ACCOUNT (tree_model); + Account *account; + + g_return_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (model)); + g_return_if_fail (iter != NULL); + g_return_if_fail (iter->user_data != NULL); + g_return_if_fail (iter->stamp == model->stamp); + + account = (Account *) iter->user_data; + + switch (column) { + case GNC_TREE_MODEL_ACCOUNT_COL_TYPE: + g_value_init (value, G_TYPE_STRING); + + g_value_set_string (value, + xaccAccountGetTypeStr (xaccAccountGetType (account))); + break; + case GNC_TREE_MODEL_ACCOUNT_COL_NAME: + g_value_init (value, G_TYPE_STRING); + + g_value_set_string (value, xaccAccountGetName (account)); + break; + case GNC_TREE_MODEL_ACCOUNT_COL_CODE: + g_value_init (value, G_TYPE_STRING); + + g_value_set_string (value, xaccAccountGetCode (account)); + break; + case GNC_TREE_MODEL_ACCOUNT_COL_DESCRIPTION: + g_value_init (value, G_TYPE_STRING); + + g_value_set_string (value, xaccAccountGetDescription (account)); + break; + case GNC_TREE_MODEL_ACCOUNT_COL_NOTES: + g_value_init (value, G_TYPE_STRING); + + g_value_set_string (value, xaccAccountGetNotes (account)); + break; + case GNC_TREE_MODEL_ACCOUNT_COL_LASTNUM: + g_value_init (value, G_TYPE_STRING); + + g_value_set_string (value, xaccAccountGetLastNum (account)); + break; + case GNC_TREE_MODEL_ACCOUNT_COL_PLACEHOLDER: + g_value_init (value, G_TYPE_BOOLEAN); + + g_value_set_boolean (value, xaccAccountGetPlaceholder (account)); + break; + default: + g_assert_not_reached (); + } +} + +static gboolean +gnc_tree_model_account_iter_next (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + GNCTreeModelAccount *model = GNC_TREE_MODEL_ACCOUNT (tree_model); + Account *account; + AccountGroup *group; + gint i; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (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->user_data2 != NULL, FALSE); + g_return_val_if_fail (iter->stamp == model->stamp, FALSE); + + group = (AccountGroup *) iter->user_data2; + i = GPOINTER_TO_INT (iter->user_data3); + + if (i > xaccGroupGetNumAccounts (group) - 2) { + iter->stamp = 0; + + return FALSE; + } + + account = xaccGroupGetAccount (group, i + 1); + + if (account == NULL) { + iter->stamp = 0; + + return FALSE; + } + + iter->user_data = account; + iter->user_data2 = group; + iter->user_data3 = GINT_TO_POINTER (i + 1); + + return TRUE; +} + +static gboolean +gnc_tree_model_account_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent) +{ + GNCTreeModelAccount *model; + Account *account; + AccountGroup *group; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (tree_model), FALSE); + + model = GNC_TREE_MODEL_ACCOUNT (tree_model); + + if (model->priv->root == NULL || xaccGroupGetNumAccounts (model->priv->root) == 0) { + iter->stamp = 0; + + return FALSE; + } + + if (parent == NULL) { + account = xaccGroupGetAccount (model->priv->root, 0); + + if (account == NULL) { + iter->stamp = 0; + + return FALSE; + } + + iter->user_data = account; + iter->user_data2 = model->priv->root; + iter->user_data3 = GINT_TO_POINTER (0); + iter->stamp = model->stamp; + + return TRUE; + } + + g_return_val_if_fail (parent != NULL, FALSE); + g_return_val_if_fail (parent->user_data != NULL, FALSE); + g_return_val_if_fail (parent->stamp == model->stamp, FALSE); + + group = xaccAccountGetChildren ((Account *) parent->user_data); + + if (group == NULL || xaccGroupGetNumAccounts (group) == 0) { + iter->stamp = 0; + + return FALSE; + } + + account = xaccGroupGetAccount (group, 0); + + if (account == NULL) { + iter->stamp = 0; + + return FALSE; + } + + iter->user_data = account; + iter->user_data2 = group; + iter->user_data3 = GINT_TO_POINTER (0); + iter->stamp = model->stamp; + + return TRUE; +} + +static gboolean +gnc_tree_model_account_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + GNCTreeModelAccount *model; + AccountGroup *group; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (tree_model), FALSE); + + model = GNC_TREE_MODEL_ACCOUNT (tree_model); + + 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); + + group = xaccAccountGetChildren ((Account *) iter->user_data); + + if (group == NULL || xaccGroupGetNumAccounts (group) == 0) { + return FALSE; + } + + return TRUE; +} + +static int +gnc_tree_model_account_iter_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + GNCTreeModelAccount *model; + AccountGroup *group; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (tree_model), FALSE); + + model = GNC_TREE_MODEL_ACCOUNT (tree_model); + + if (iter == NULL) { + return xaccGroupGetNumAccounts (model->priv->root); + } + + 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); + + group = xaccAccountGetChildren ((Account *) iter->user_data); + + return xaccGroupGetNumAccounts (group); +} + +static gboolean +gnc_tree_model_account_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + int n) +{ + GNCTreeModelAccount *model; + Account *account; + AccountGroup *group; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (tree_model), FALSE); + + model = GNC_TREE_MODEL_ACCOUNT (tree_model); + + if (parent == NULL) { + account = xaccGroupGetAccount (model->priv->root, n); + + if (account == NULL) { + iter->stamp = 0; + + return FALSE; + } + + iter->user_data = xaccGroupGetAccount (model->priv->root, n); + iter->user_data2 = model->priv->root; + iter->user_data3 = GINT_TO_POINTER (n); + iter->stamp = model->stamp; + + return TRUE; + } + + g_return_val_if_fail (parent->user_data != NULL, FALSE); + g_return_val_if_fail (parent->stamp == model->stamp, FALSE); + + group = xaccAccountGetChildren ((Account *) parent->user_data); + + if (group == NULL || xaccGroupGetNumAccounts (group) <= n) { + iter->stamp = 0; + + return FALSE; + } + + account = xaccGroupGetAccount (group, n); + + if (account == NULL) { + iter->stamp = 0; + + return FALSE; + } + + iter->user_data = account; + iter->user_data2 = group; + iter->user_data3 = GINT_TO_POINTER (n); + iter->stamp = model->stamp; + + return TRUE; +} + +static gboolean +gnc_tree_model_account_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child) +{ + GNCTreeModelAccount *model; + Account *account; + AccountGroup *group; + gint i; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_ACCOUNT (tree_model), FALSE); + + model = GNC_TREE_MODEL_ACCOUNT (tree_model); + + g_return_val_if_fail (child != NULL, FALSE); + g_return_val_if_fail (child->user_data != NULL, FALSE); + g_return_val_if_fail (child->stamp == model->stamp, FALSE); + + account = (Account *) child->user_data; + + account = xaccAccountGetParentAccount (account); + group = xaccAccountGetParent (account); + + if (account == NULL || group == NULL) { + iter->stamp = 0; + + return FALSE; + } + + for (i = 0; i < xaccGroupGetNumAccounts (group); i++) { + if (xaccGroupGetAccount (group, i) == account) { + iter->user_data = account; + iter->user_data2 = group; + iter->user_data3 = GINT_TO_POINTER (i); + iter->stamp = model->stamp; + + return TRUE; + } + } + + iter->stamp = 0; + + return FALSE; +} + +static void +iter_from_real_account (GNCTreeModelAccount *model, + Account *account, + AccountGroup *group, + GtkTreeIter *iter) +{ + gint i; + + for (i = 0; i < xaccGroupGetNumAccounts (group); i++) { + if (xaccGroupGetAccount (group, i) == account) { + break; + } + } + + iter->user_data = account; + iter->user_data2 = group; + iter->user_data3 = GINT_TO_POINTER (i); + iter->stamp = model->stamp; +} + +/* +static gpointer +account_row_deleted (Account *account, + gpointer data) +{ + AccountGroup *group; + GtkTreePath *path; + GtkTreeIter iter; + + group = xaccAccountGetParent (account); + + iter_from_real_account (GNC_TREE_MODEL_ACCOUNT (data), account, group, &iter); + + path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &iter); + + gtk_tree_model_row_deleted (GTK_TREE_MODEL (data), path); + + gtk_tree_path_free (path); + + return NULL; +} +*/ +static gpointer +account_row_inserted (Account *account, + gpointer data) +{ + AccountGroup *group; + GtkTreePath *path; + GtkTreeIter iter; + + group = xaccAccountGetParent (account); + + iter_from_real_account (GNC_TREE_MODEL_ACCOUNT (data), account, group, &iter); + + path = gtk_tree_model_get_path (GTK_TREE_MODEL (data), &iter); + + gtk_tree_model_row_inserted (GTK_TREE_MODEL (data), path, &iter); + + gtk_tree_path_free (path); + + return NULL; +} diff --git a/src/gnome-utils/gnc-tree-model-account.h b/src/gnome-utils/gnc-tree-model-account.h new file mode 100644 index 0000000000..1591f78e28 --- /dev/null +++ b/src/gnome-utils/gnc-tree-model-account.h @@ -0,0 +1,62 @@ +/* + * gnc-tree-model-account.h -- GtkTreeModel implementation to display accounts in a GtkTreeView. + * Copyright (C) 2003 Jan Arne Petersen + * Author: Jan Arne Petersen + */ + +#ifndef __GNC_TREE_MODEL_ACCOUNT_H +#define __GNC_TREE_MODEL_ACCOUNT_H + +#include + +#include "Group.h" + +G_BEGIN_DECLS + +/* type macros */ +#define GNC_TYPE_TREE_MODEL_ACCOUNT (gnc_tree_model_account_get_type ()) +#define GNC_TREE_MODEL_ACCOUNT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNC_TYPE_TREE_MODEL_ACCOUNT, GNCTreeModelAccount)) +#define GNC_TREE_MODEL_ACCOUNT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GNC_TYPE_TREE_MODEL_ACCOUNT, GNCTreeModelAccountClass)) +#define GNC_IS_TREE_MODEL_ACCOUNT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNC_TYPE_TREE_MODEL_ACCOUNT)) +#define GNC_IS_TREE_MODEL_ACCOUNT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNC_TYPE_TREE_MODEL_ACCOUNT)) +#define GNC_TREE_MODEL_ACCOUNT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GNC_TYPE_TREE_MODEL_ACCOUNT, GNCTreeModelAccountClass)) + +typedef enum { + GNC_TREE_MODEL_ACCOUNT_COL_TYPE, + GNC_TREE_MODEL_ACCOUNT_COL_NAME, + GNC_TREE_MODEL_ACCOUNT_COL_CODE, + GNC_TREE_MODEL_ACCOUNT_COL_DESCRIPTION, + GNC_TREE_MODEL_ACCOUNT_COL_NOTES, + GNC_TREE_MODEL_ACCOUNT_COL_LASTNUM, + GNC_TREE_MODEL_ACCOUNT_COL_PLACEHOLDER, + GNC_TREE_MODEL_ACCOUNT_NUM_COLUMNS +} GNCTreeModelAccountColumn; + +/* typedefs & structures */ +typedef struct GNCTreeModelAccountPrivate GNCTreeModelAccountPrivate; + +typedef struct { + GObject parent; + + GNCTreeModelAccountPrivate *priv; + + int stamp; +} GNCTreeModelAccount; + +typedef struct { + GObjectClass parent; +} GNCTreeModelAccountClass; + +/* function prototypes */ +GType gnc_tree_model_account_get_type (void); + +GNCTreeModelAccount *gnc_tree_model_account_new (AccountGroup *group); +void gnc_tree_model_account_set_root (GNCTreeModelAccount *model, + AccountGroup *group); + +Account *gnc_tree_model_account_get_account (GNCTreeModelAccount *model, + GtkTreeIter *iter); + +G_END_DECLS + +#endif /* __GNC_TREE_MODEL_ACCOUNT_H */ diff --git a/src/gnome-utils/gnc-tree-model-example-account.c b/src/gnome-utils/gnc-tree-model-example-account.c new file mode 100644 index 0000000000..7536be4668 --- /dev/null +++ b/src/gnome-utils/gnc-tree-model-example-account.c @@ -0,0 +1,450 @@ +/* + * gnc-tree-model-account.c -- GtkTreeModel implementation to display accounts in a GtkTreeView. + * Copyright (C) 2003 Jan Arne Petersen + * Author: Jan Arne Petersen + */ + +#include "config.h" + +#include "gnc-tree-model-example-account.h" +#include "io-example-account.h" +#include "Group.h" + +static void gnc_tree_model_example_account_class_init (GNCTreeModelExampleAccountClass *klass); +static void gnc_tree_model_example_account_init (GNCTreeModelExampleAccount *model); +static void gnc_tree_model_example_account_finalize (GObject *object); + +static void gnc_tree_model_example_account_tree_model_init (GtkTreeModelIface *iface); +static guint gnc_tree_model_example_account_get_flags (GtkTreeModel *tree_model); +static int gnc_tree_model_example_account_get_n_columns (GtkTreeModel *tree_model); +static GType gnc_tree_model_example_account_get_column_type (GtkTreeModel *tree_model, + int index); +static gboolean gnc_tree_model_example_account_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path); +static GtkTreePath *gnc_tree_model_example_account_get_path (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static void gnc_tree_model_example_account_get_value (GtkTreeModel *tree_model, + GtkTreeIter *iter, + int column, + GValue *value); +static gboolean gnc_tree_model_example_account_iter_next (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static gboolean gnc_tree_model_example_account_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent); +static gboolean gnc_tree_model_example_account_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static int gnc_tree_model_example_account_iter_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static gboolean gnc_tree_model_example_account_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + int n); +static gboolean gnc_tree_model_example_account_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child); + +struct GNCTreeModelExampleAccountPrivate +{ + GSList *accounts; + GSList *selections; +}; + +static GObjectClass *parent_class = NULL; + +GType +gnc_tree_model_example_account_get_type (void) +{ + static GType gnc_tree_model_example_account_type = 0; + + if (gnc_tree_model_example_account_type == 0) { + static const GTypeInfo our_info = { + sizeof (GNCTreeModelExampleAccountClass), + NULL, + NULL, + (GClassInitFunc) gnc_tree_model_example_account_class_init, + NULL, + NULL, + sizeof (GNCTreeModelExampleAccount), + 0, + (GInstanceInitFunc) gnc_tree_model_example_account_init + }; + + static const GInterfaceInfo tree_model_info = { + (GInterfaceInitFunc) gnc_tree_model_example_account_tree_model_init, + NULL, + NULL + }; + + gnc_tree_model_example_account_type = g_type_register_static (G_TYPE_OBJECT, + "GNCTreeModelExampleAccount", + &our_info, 0); + + g_type_add_interface_static (gnc_tree_model_example_account_type, + GTK_TYPE_TREE_MODEL, + &tree_model_info); + } + + return gnc_tree_model_example_account_type; +} + +static void +gnc_tree_model_example_account_class_init (GNCTreeModelExampleAccountClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = gnc_tree_model_example_account_finalize; +} + +static void +gnc_tree_model_example_account_init (GNCTreeModelExampleAccount *model) +{ + while (model->stamp == 0) { + model->stamp = g_random_int (); + } + + model->priv = g_new0 (GNCTreeModelExampleAccountPrivate, 1); +} + +static void +gnc_tree_model_example_account_finalize (GObject *object) +{ + GNCTreeModelExampleAccount *model; + + g_return_if_fail (object != NULL); + g_return_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (object)); + + model = GNC_TREE_MODEL_EXAMPLE_ACCOUNT (object); + + g_return_if_fail (model->priv != NULL); + + g_slist_free (model->priv->accounts); + g_slist_free (model->priv->selections); + g_free (model->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +GNCTreeModelExampleAccount * +gnc_tree_model_example_account_new (GSList *accounts) +{ + GNCTreeModelExampleAccount *model; + guint i, len; + + model = g_object_new (GNC_TYPE_TREE_MODEL_EXAMPLE_ACCOUNT, + NULL); + + model->priv->accounts = accounts; + model->priv->selections = NULL; + + for (i = 0, len = g_slist_length (accounts); i < len; i++) { + model->priv->selections = g_slist_prepend (model->priv->selections, + GINT_TO_POINTER (FALSE)); + } + + return model; +} + +void +gnc_tree_model_example_account_set_accounts (GNCTreeModelExampleAccount *model, + GSList *accounts) +{ + gint i, len; + + g_return_if_fail (model != NULL); + + g_slist_free (model->priv->accounts); + g_slist_free (model->priv->selections); + + model->priv->accounts = accounts; + model->priv->selections = NULL; + + for (i = 0, len = g_slist_length (accounts); i < len; i++) { + model->priv->selections = g_slist_prepend (model->priv->selections, + GINT_TO_POINTER (FALSE)); + } +} + +GncExampleAccount * +gnc_tree_model_example_account_get_account (GNCTreeModelExampleAccount *model, + GtkTreeIter *iter) +{ + g_return_val_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (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); + + return (GncExampleAccount *) ((GSList *) iter->user_data)->data; +} + +gboolean +gnc_tree_model_example_account_is_selected (GNCTreeModelExampleAccount *model, + GtkTreeIter *iter) +{ + g_return_val_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (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); + + return GPOINTER_TO_INT (((GSList *) iter->user_data2)->data); +} + +void +gnc_tree_model_example_account_set_selected (GNCTreeModelExampleAccount *model, + GtkTreeIter *iter, + gboolean selected) +{ + g_return_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (model)); + g_return_if_fail (iter != NULL); + g_return_if_fail (iter->user_data != NULL); + g_return_if_fail (iter->stamp == model->stamp); + + ((GSList *) iter->user_data2)->data = GINT_TO_POINTER (selected); + + gtk_tree_model_row_changed (GTK_TREE_MODEL (model), + gtk_tree_model_get_path (GTK_TREE_MODEL (model), iter), + iter); +} + + +static void +gnc_tree_model_example_account_tree_model_init (GtkTreeModelIface *iface) +{ + iface->get_flags = gnc_tree_model_example_account_get_flags; + iface->get_n_columns = gnc_tree_model_example_account_get_n_columns; + iface->get_column_type = gnc_tree_model_example_account_get_column_type; + iface->get_iter = gnc_tree_model_example_account_get_iter; + iface->get_path = gnc_tree_model_example_account_get_path; + iface->get_value = gnc_tree_model_example_account_get_value; + iface->iter_next = gnc_tree_model_example_account_iter_next; + iface->iter_children = gnc_tree_model_example_account_iter_children; + iface->iter_has_child = gnc_tree_model_example_account_iter_has_child; + iface->iter_n_children = gnc_tree_model_example_account_iter_n_children; + iface->iter_nth_child = gnc_tree_model_example_account_iter_nth_child; + iface->iter_parent = gnc_tree_model_example_account_iter_parent; +} + +static guint +gnc_tree_model_example_account_get_flags (GtkTreeModel *tree_model) +{ + return 0; +} + +static int +gnc_tree_model_example_account_get_n_columns (GtkTreeModel *tree_model) +{ + return GNC_TREE_MODEL_EXAMPLE_ACCOUNT_NUM_COLUMNS; +} + +static GType +gnc_tree_model_example_account_get_column_type (GtkTreeModel *tree_model, + int index) +{ + g_return_val_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model), G_TYPE_INVALID); + g_return_val_if_fail ((index < GNC_TREE_MODEL_EXAMPLE_ACCOUNT_NUM_COLUMNS) && (index >= 0), G_TYPE_INVALID); + + switch (index) { + case GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_TITLE: + case GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_SHORT_DESCRIPTION: + case GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_LONG_DESCRIPTION: + return G_TYPE_STRING; + case GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_SELECTED: + return G_TYPE_BOOLEAN; + default: + g_assert_not_reached (); + return G_TYPE_INVALID; + } +} + +static gboolean +gnc_tree_model_example_account_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path) +{ + GNCTreeModelExampleAccount *model = GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model); + gint i; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (model), FALSE); + g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE); + + if (model->priv->accounts == NULL) + return FALSE; + + i = gtk_tree_path_get_indices (path)[0]; + + g_return_val_if_fail (i >= 0 && i < g_slist_length (model->priv->accounts), FALSE); + + iter->stamp = model->stamp; + iter->user_data = g_slist_nth (model->priv->accounts, i); + iter->user_data2 = g_slist_nth (model->priv->selections, i); + + if (iter->user_data == NULL) { + iter->stamp = 0; + return FALSE; + } + + return TRUE; +} + +static GtkTreePath * +gnc_tree_model_example_account_get_path (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + GNCTreeModelExampleAccount *model = GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model); + GtkTreePath *path; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (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); + + if (model->priv->accounts == NULL) + return NULL; + + path = gtk_tree_path_new (); + + gtk_tree_path_append_index (path, g_slist_position (model->priv->accounts, iter->user_data)); + + return path; +} + +static void +gnc_tree_model_example_account_get_value (GtkTreeModel *tree_model, + GtkTreeIter *iter, + int column, + GValue *value) +{ + GNCTreeModelExampleAccount *model = GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model); + GncExampleAccount *account; + + g_return_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (model)); + g_return_if_fail (iter != NULL); + g_return_if_fail (iter->user_data != NULL); + g_return_if_fail (iter->stamp == model->stamp); + + account = (GncExampleAccount *)((GSList *) iter->user_data)->data; + + switch (column) { + case GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_TITLE: + g_value_init (value, G_TYPE_STRING); + + g_value_set_string (value, account->title); + break; + case GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_SHORT_DESCRIPTION: + g_value_init (value, G_TYPE_STRING); + + g_value_set_string (value, account->short_description); + break; + case GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_LONG_DESCRIPTION: + g_value_init (value, G_TYPE_STRING); + + g_value_set_string (value, account->long_description); + break; + case GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_SELECTED: + g_value_init (value, G_TYPE_BOOLEAN); + + g_value_set_boolean (value, GPOINTER_TO_INT (((GSList *) iter->user_data2)->data)); + break; + default: + g_assert_not_reached (); + } +} + +static gboolean +gnc_tree_model_example_account_iter_next (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + GNCTreeModelExampleAccount *model = GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model); + + g_return_val_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (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); + + if (g_list_next (iter->user_data) == NULL) + return FALSE; + + iter->user_data = g_slist_next (iter->user_data); + iter->user_data2 = g_slist_next (iter->user_data2); + + return TRUE; +} + +static gboolean +gnc_tree_model_example_account_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent) +{ + + g_return_val_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model), FALSE); + + if (parent != NULL) + return FALSE; + + iter->stamp = GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model)->stamp; + iter->user_data = GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model)->priv->accounts; + iter->user_data2 = GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model)->priv->selections; + + return TRUE; +} + +static gboolean +gnc_tree_model_example_account_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + return FALSE; +} + +static int +gnc_tree_model_example_account_iter_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + g_return_val_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model), -1); + + if (iter == NULL) + return g_slist_length (GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model)->priv->accounts); + + g_return_val_if_fail (GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model)->stamp == iter->stamp, -1); + + return 0; +} + +static gboolean +gnc_tree_model_example_account_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + int n) +{ + GNCTreeModelExampleAccount *model; + + g_return_val_if_fail (GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model), FALSE); + + if (parent != NULL) + return FALSE; + + model = GNC_TREE_MODEL_EXAMPLE_ACCOUNT (tree_model); + + g_return_val_if_fail (n >= 0 && n < g_slist_length (model->priv->accounts), FALSE); + + iter->stamp = model->stamp; + iter->user_data = g_slist_nth (model->priv->accounts, n); + iter->user_data2 = g_slist_nth (model->priv->selections, n); + + if (iter->user_data == NULL) { + iter->stamp = 0; + return FALSE; + } + + return TRUE; +} + +static gboolean +gnc_tree_model_example_account_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child) +{ + return FALSE; +} diff --git a/src/gnome-utils/gnc-tree-model-example-account.h b/src/gnome-utils/gnc-tree-model-example-account.h new file mode 100644 index 0000000000..269f062aa4 --- /dev/null +++ b/src/gnome-utils/gnc-tree-model-example-account.h @@ -0,0 +1,64 @@ +/* + * gnc-tree-model-account.h -- GtkTreeModel implementation to display accounts in a GtkTreeView. + * Copyright (C) 2003 Jan Arne Petersen + * Author: Jan Arne Petersen + */ + +#ifndef __GNC_TREE_MODEL_EXAMPLE_ACCOUNT_H +#define __GNC_TREE_MODEL_EXAMPLE_ACCOUNT_H + +#include + +#include "io-example-account.h" + +G_BEGIN_DECLS + +/* type macros */ +#define GNC_TYPE_TREE_MODEL_EXAMPLE_ACCOUNT (gnc_tree_model_example_account_get_type ()) +#define GNC_TREE_MODEL_EXAMPLE_ACCOUNT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GNC_TYPE_TREE_MODEL_EXAMPLE_ACCOUNT, GNCTreeModelExampleAccount)) +#define GNC_TREE_MODEL_EXAMPLE_ACCOUNT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GNC_TYPE_TREE_MODEL_EXAMPLE_ACCOUNT, GNCTreeModelExampleAccountClass)) +#define GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GNC_TYPE_TREE_MODEL_EXAMPLE_ACCOUNT)) +#define GNC_IS_TREE_MODEL_EXAMPLE_ACCOUNT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GNC_TYPE_TREE_MODEL_EXAMPLE_ACCOUNT)) +#define GNC_TREE_MODEL_EXAMPLE_ACCOUNT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GNC_TYPE_TREE_MODEL_EXAMPLE_ACCOUNT, GNCTreeModelExampleAccountClass)) + +typedef enum { + GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_SELECTED, + GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_TITLE, + GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_SHORT_DESCRIPTION, + GNC_TREE_MODEL_EXAMPLE_ACCOUNT_COL_LONG_DESCRIPTION, + GNC_TREE_MODEL_EXAMPLE_ACCOUNT_NUM_COLUMNS +} GNCTreeModelExampleAccountColumn; + +/* typedefs & structures */ +typedef struct GNCTreeModelExampleAccountPrivate GNCTreeModelExampleAccountPrivate; + +typedef struct { + GObject parent; + + GNCTreeModelExampleAccountPrivate *priv; + + int stamp; +} GNCTreeModelExampleAccount; + +typedef struct { + GObjectClass parent; +} GNCTreeModelExampleAccountClass; + +/* function prototypes */ +GType gnc_tree_model_example_account_get_type (void); + +GNCTreeModelExampleAccount *gnc_tree_model_example_account_new (GSList *accounts); +void gnc_tree_model_example_account_set_accounts (GNCTreeModelExampleAccount *model, + GSList *accounts); + +GncExampleAccount *gnc_tree_model_example_account_get_account (GNCTreeModelExampleAccount *model, + GtkTreeIter *iter); +gboolean gnc_tree_model_example_account_is_selected (GNCTreeModelExampleAccount *model, + GtkTreeIter *iter); +void gnc_tree_model_example_account_set_selected (GNCTreeModelExampleAccount *model, + GtkTreeIter *iter, + gboolean selected); + +G_END_DECLS + +#endif /* __GNC_TREE_MODEL_EXAMPLE_ACCOUNT_H */ diff --git a/src/gnome/dialog-commodities.c b/src/gnome/dialog-commodities.c index 2805303c26..d7a76e7146 100644 --- a/src/gnome/dialog-commodities.c +++ b/src/gnome/dialog-commodities.c @@ -203,11 +203,17 @@ window_destroy_cb (GtkObject *object, gpointer data) } static void -close_clicked (GtkWidget *widget, gpointer data) +response_cb (GtkDialog *dialog, gint response, gpointer data) { CommoditiesDialog *cd = data; - gnc_close_gui_component_by_data (DIALOG_COMMODITIES_CM_CLASS, cd); + switch (response) { + case GTK_RESPONSE_OK: + gnc_close_gui_component_by_data (DIALOG_COMMODITIES_CM_CLASS, cd); + break; + default: + g_assert_not_reached (); + } } static void @@ -372,18 +378,18 @@ gnc_commodities_dialog_create (GtkWidget * parent, CommoditiesDialog *cd) dialog = glade_xml_get_widget (xml, "Commodities Dialog"); cd->dialog = dialog; - gnome_dialog_button_connect (GNOME_DIALOG (dialog), 0, - GTK_SIGNAL_FUNC (close_clicked), cd); + g_signal_connect (G_OBJECT (dialog), "response", + G_CALLBACK (response_cb), cd); - gtk_signal_connect (GTK_OBJECT (dialog), "destroy", - GTK_SIGNAL_FUNC (window_destroy_cb), cd); + g_signal_connect (G_OBJECT (dialog), "destroy", + G_CALLBACK (window_destroy_cb), cd); /* parent */ if (parent != NULL) - gnome_dialog_set_parent (GNOME_DIALOG (dialog), GTK_WINDOW (parent)); + gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent)); /* default to ok */ - gnome_dialog_set_default (GNOME_DIALOG(dialog), 0); + gtk_dialog_set_default_response (GTK_DIALOG(dialog), GTK_RESPONSE_OK); /* commodity tree */ { @@ -392,11 +398,11 @@ gnc_commodities_dialog_create (GtkWidget * parent, CommoditiesDialog *cd) list = glade_xml_get_widget (xml, "commodity_list"); cd->commodity_list = list; - gtk_signal_connect (GTK_OBJECT(list), "select_row", - GTK_SIGNAL_FUNC(select_commodity_cb), cd); + g_signal_connect (G_OBJECT(list), "select_row", + G_CALLBACK(select_commodity_cb), cd); - gtk_signal_connect (GTK_OBJECT(list), "unselect_row", - GTK_SIGNAL_FUNC(unselect_commodity_cb), cd); + g_signal_connect (G_OBJECT(list), "unselect_row", + G_CALLBACK(unselect_commodity_cb), cd); } /* buttons */ @@ -406,24 +412,24 @@ gnc_commodities_dialog_create (GtkWidget * parent, CommoditiesDialog *cd) button = glade_xml_get_widget (xml, "edit_button"); cd->edit_button = button; - gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC (edit_clicked), cd); + g_signal_connect (G_OBJECT (button), "clicked", + G_CALLBACK (edit_clicked), cd); button = glade_xml_get_widget (xml, "remove_button"); cd->remove_button = button; - gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC (remove_clicked), cd); + g_signal_connect (G_OBJECT (button), "clicked", + G_CALLBACK (remove_clicked), cd); button = glade_xml_get_widget (xml, "add_button"); - gtk_signal_connect (GTK_OBJECT (button), "clicked", - GTK_SIGNAL_FUNC (add_clicked), cd); + g_signal_connect (G_OBJECT (button), "clicked", + G_CALLBACK (add_clicked), cd); button = glade_xml_get_widget (xml, "show_currencies_button"); - gtk_signal_connect (GTK_OBJECT (button), "toggled", - GTK_SIGNAL_FUNC (show_currencies_toggled), cd); + g_signal_connect (G_OBJECT (button), "toggled", + G_CALLBACK (show_currencies_toggled), cd); } gnc_commodities_load_commodities (cd); @@ -449,7 +455,7 @@ close_handler (gpointer user_data) gnc_save_window_size ("commodities_win", last_width, last_height); - gnome_dialog_close (GNOME_DIALOG (cd->dialog)); + gtk_widget_destroy (GTK_WIDGET (cd->dialog)); } static void diff --git a/src/gnome/dialog-new-user.c b/src/gnome/dialog-new-user.c index da23467678..f1eb56dbee 100644 --- a/src/gnome/dialog-new-user.c +++ b/src/gnome/dialog-new-user.c @@ -88,16 +88,18 @@ gnc_ui_new_user_dialog (void) } else if ((qifImportDruidFcn != NULL) && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (import_qif_button))) { qifImportDruidFcn(); + gncp_new_user_finish (); break; } else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (tutorial_button))) { helpWindow (NULL, NULL, HH_QUICKSTART); + gncp_new_user_finish (); break; } default: + g_print ("DEBUG: Response: %d", result); g_assert_not_reached (); } - gncp_new_user_finish (); gtk_widget_destroy (dialog); } diff --git a/src/gnome/glade/commodities.glade b/src/gnome/glade/commodities.glade index d967a2fe1e..a3978b264c 100644 --- a/src/gnome/glade/commodities.glade +++ b/src/gnome/glade/commodities.glade @@ -31,6 +31,7 @@ gtk-close yes yes + GTK_RESPONSE_OK diff --git a/src/gnome/window-acct-tree.c b/src/gnome/window-acct-tree.c index 1f2b200edd..d896412295 100644 --- a/src/gnome/window-acct-tree.c +++ b/src/gnome/window-acct-tree.c @@ -159,7 +159,7 @@ static GtkWidget * gnc_acct_tree_view_labeler(GnomeMDIChild * child, GtkWidget * current, gpointer user_data) { - GNCMDIChildInfo * mc = gtk_object_get_user_data(GTK_OBJECT(child)); + GNCMDIChildInfo * mc = g_object_get_data (G_OBJECT (child), "gnc-mdi-child-info"); GNCAcctTreeWin * win = NULL; char * name = NULL; @@ -244,7 +244,7 @@ gnc_acct_tree_view_new(GnomeMDIChild * child, gpointer user_data) mc->menu_tweaking = gnc_acct_tree_tweak_menu; - gtk_object_set_user_data(GTK_OBJECT(child), mc); + g_object_set_data (G_OBJECT (child), "gnc-mdi-child-info", mc); /* set the child name that will get used to save app state */ name_id = g_strdup_printf("id=%d", win->options_id); @@ -326,11 +326,9 @@ gnc_main_window_open_accounts(gboolean toplevel) GNCMDIInfo * maininfo = gnc_mdi_get_current (); GnomeMDIChild * accountchild = gnc_acct_tree_window_create_child(NULL); - g_assert (maininfo->mdi != NULL); - g_assert (accountchild != NULL); - g_assert (gnome_mdi_add_child(GNOME_MDI(maininfo->mdi), - GNOME_MDI_CHILD(accountchild))); - + gnome_mdi_add_child(GNOME_MDI(maininfo->mdi), + GNOME_MDI_CHILD(accountchild)); + if(toplevel) { gnome_mdi_add_toplevel_view(GNOME_MDI(maininfo->mdi), GNOME_MDI_CHILD(accountchild)); @@ -524,7 +522,7 @@ gnc_acct_tree_find_account_from_gncmdi(GNCMDIInfo * info) Account * account; child = gnome_mdi_get_active_child(info->mdi); - mc = gtk_object_get_user_data(GTK_OBJECT(child)); + mc = g_object_get_data (G_OBJECT (child), "gnc-mdi-child-info"); win = mc->user_data; account = gnc_acct_tree_window_get_current_account(win); @@ -1178,16 +1176,16 @@ gnc_acct_tree_window_new(const gchar * url) { treewin->odb = gnc_option_db_new(treewin->options); - gtk_signal_connect(GTK_OBJECT(treewin->account_tree), "activate_account", - GTK_SIGNAL_FUNC (gnc_acct_tree_window_activate_cb), + g_signal_connect (G_OBJECT(treewin->account_tree), "activate_account", + G_CALLBACK (gnc_acct_tree_window_activate_cb), treewin); - gtk_signal_connect(GTK_OBJECT(treewin->account_tree), "select_account", - GTK_SIGNAL_FUNC(gnc_acct_tree_window_select_cb), + g_signal_connect (G_OBJECT(treewin->account_tree), "select_account", + G_CALLBACK(gnc_acct_tree_window_select_cb), treewin); - gtk_signal_connect(GTK_OBJECT(treewin->account_tree), "unselect_account", - GTK_SIGNAL_FUNC(gnc_acct_tree_window_select_cb), + g_signal_connect (G_OBJECT(treewin->account_tree), "unselect_account", + G_CALLBACK(gnc_acct_tree_window_select_cb), treewin); /* Show everything now that it is created */ diff --git a/src/gnome/window-main.c b/src/gnome/window-main.c index 20998e8978..677f6f4271 100644 --- a/src/gnome/window-main.c +++ b/src/gnome/window-main.c @@ -102,7 +102,7 @@ gnc_main_window_get_mdi_child (void) if (!mdi || !mdi->active_child) return(NULL); - return(gtk_object_get_user_data(GTK_OBJECT(mdi->active_child))); + return g_object_get_data (G_OBJECT (mdi->active_child), "gnc-mdi-child-info"); } /******************************************************************** @@ -415,6 +415,19 @@ gnc_main_window_flip_summary_bar_cb(GtkWidget * widget, gpointer data) } } +/* GNOME 2 Port */ +static gboolean +gnc_main_window_add_child_cb (GnomeMDI *mdi, GnomeMDIChild *child, gpointer data) +{ + return TRUE; +} + +static gboolean +gnc_main_window_add_view_cb (GnomeMDI *mdi, GtkWidget *widget, gpointer data) +{ + return TRUE; +} + /******************************************************************** * gnc_main_window_new() * initialize the Gnome MDI system @@ -445,9 +458,17 @@ gnc_main_window_new (void) gnome_mdi_set_child_list_path(GNOME_MDI(retval->mdi), "_Windows/"); + /* GNOME 2 Port (tmp fix) */ + g_signal_connect (G_OBJECT(retval->mdi), "add-child", + G_CALLBACK(gnc_main_window_add_child_cb), + retval); + g_signal_connect (G_OBJECT(retval->mdi), "add-view", + G_CALLBACK(gnc_main_window_add_view_cb), + retval); + /* handle top-level signals */ - gtk_signal_connect(GTK_OBJECT(retval->mdi), "app_created", - GTK_SIGNAL_FUNC(gnc_main_window_app_created_cb), + g_signal_connect (G_OBJECT(retval->mdi), "app-created", + G_CALLBACK(gnc_main_window_app_created_cb), retval); /* handle show/hide items in view menu */ @@ -563,7 +584,7 @@ gnc_main_window_dispatch_cb(GtkWidget * widget, gpointer data) gpointer *uidata; /* How annoying. MDI overrides the user data. Get it the hard way. */ - uidata = gtk_object_get_data(GTK_OBJECT(widget), GNOMEUIINFO_KEY_UIDATA); + uidata = g_object_get_data (G_OBJECT(widget), GNOMEUIINFO_KEY_UIDATA); type = (GNCMDIDispatchType)GPOINTER_TO_UINT(uidata); g_return_if_fail(type < GNC_DISP_LAST); @@ -606,7 +627,7 @@ gnc_main_window_file_close_cb(GtkWidget * widget, gpointer data) { GNCMDIChildInfo * inf; - inf = gtk_object_get_user_data(GTK_OBJECT(mdi->active_child)); + inf = g_object_get_data (G_OBJECT (mdi->active_child), "gnc-mdi-child-info"); if (inf->toolbar) { gtk_widget_destroy (GTK_WIDGET(inf->toolbar)->parent);