IntenseFinance/gnucash
3
0
Fork 0
mirror of https://github.com/Gnucash/gnucash.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge Jean Laroche's 'fix_autocompletion_master' into master.

Browse Source
This commit is contained in:
John Ralls 2020-03-29 14:49:00 -07:00
commit f74d7c52da
7 changed files with 796 additions and 648 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
gnucash/gnome-utils/account-quickfill.c
View File

@ -30,8 +30,10 @@
/* This static indicates the debugging module that this .o belongs to. */ /* This static indicates the debugging module that this .o belongs to. */
static QofLogModule log_module = GNC_MOD_REGISTER; static QofLogModule log_module = GNC_MOD_REGISTER;
static void shared_quickfill_pref_changed (gpointer prefs, gchar *pref, gpointer qfb); static void shared_quickfill_pref_changed (gpointer prefs, gchar* pref,
static void listen_for_account_events (QofInstance *entity, QofEventId event_type, gpointer qfb);
static void listen_for_account_events (QofInstance* entity,
QofEventId event_type,
gpointer user_data, gpointer event_data); gpointer user_data, gpointer event_data);
/* Column indices for the list store */ /* Column indices for the list store */
@ -51,20 +53,23 @@ static void listen_for_account_events (QofInstance *entity, QofEventId event_typ
typedef struct typedef struct
{ {
QuickFill *qf; QuickFill* qf;
gboolean load_list_store; gboolean load_list_store;
GtkListStore *list_store; GtkListStore* list_store;
QofBook *book; /* For the type-ahead search, we need two lists, list_store contains the accounts that
Account *root; match the search. list_store_full contain the original full list of accounts. */
GtkListStore* list_store_full;
QofBook* book;
Account* root;
gint listener; gint listener;
AccountBoolCB dont_add_cb; AccountBoolCB dont_add_cb;
gpointer dont_add_data; gpointer dont_add_data;
} QFB; } QFB;
static void static void
shared_quickfill_destroy (QofBook *book, gpointer key, gpointer user_data) shared_quickfill_destroy (QofBook* book, gpointer key, gpointer user_data)
{ {
QFB *qfb = user_data; QFB* qfb = user_data;
gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL, gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
GNC_PREF_ACCOUNT_SEPARATOR, GNC_PREF_ACCOUNT_SEPARATOR,
shared_quickfill_pref_changed, shared_quickfill_pref_changed,
@ -75,6 +80,7 @@ shared_quickfill_destroy (QofBook *book, gpointer key, gpointer user_data)
qfb); qfb);
gnc_quickfill_destroy (qfb->qf); gnc_quickfill_destroy (qfb->qf);
g_object_unref (qfb->list_store); g_object_unref (qfb->list_store);
g_object_unref (qfb->list_store_full);
qof_event_unregister_handler (qfb->listener); qof_event_unregister_handler (qfb->listener);
g_free (qfb); g_free (qfb);
} }
@ -82,20 +88,20 @@ shared_quickfill_destroy (QofBook *book, gpointer key, gpointer user_data)
typedef struct find_data typedef struct find_data
{ {
GList *accounts; GList* accounts;
GList *refs; GList* refs;
} find_data; } find_data;
static gboolean static gboolean
shared_quickfill_find_accounts (GtkTreeModel *model, shared_quickfill_find_accounts (GtkTreeModel* model,
GtkTreePath *path, GtkTreePath* path,
GtkTreeIter *iter, GtkTreeIter* iter,
gpointer user_data) gpointer user_data)
{ {
Account *account = NULL; Account* account = NULL;
find_data *data = user_data; find_data* data = user_data;
GtkTreeRowReference* ref; GtkTreeRowReference* ref;
GList *tmp; GList* tmp;
gtk_tree_model_get (model, iter, ACCOUNT_POINTER, &account, -1); gtk_tree_model_get (model, iter, ACCOUNT_POINTER, &account, -1);
for (tmp = data->accounts; tmp; tmp = g_list_next (tmp)) for (tmp = data->accounts; tmp; tmp = g_list_next (tmp))
@ -114,10 +120,10 @@ shared_quickfill_find_accounts (GtkTreeModel *model,
/* Splat the account name into the shared quickfill object */ /* Splat the account name into the shared quickfill object */
static void static void
load_shared_qf_cb (Account *account, gpointer data) load_shared_qf_cb (Account* account, gpointer data)
{ {
QFB *qfb = data; QFB* qfb = data;
char *name; char* name;
GtkTreeIter iter; GtkTreeIter iter;
if (qfb->dont_add_cb) if (qfb->dont_add_cb)
@ -138,19 +144,25 @@ load_shared_qf_cb (Account *account, gpointer data)
ACCOUNT_NAME, name, ACCOUNT_NAME, name,
ACCOUNT_POINTER, account, ACCOUNT_POINTER, account,
-1); -1);
gtk_list_store_append (qfb->list_store_full, &iter);
gtk_list_store_set (qfb->list_store_full, &iter,
ACCOUNT_NAME, name,
ACCOUNT_POINTER, account,
-1);
} }
g_free (name); g_free (name);
} }
static void static void
shared_quickfill_pref_changed (gpointer prefs, gchar *pref, gpointer user_data) shared_quickfill_pref_changed (gpointer prefs, gchar* pref, gpointer user_data)
{ {
QFB *qfb = user_data; QFB* qfb = user_data;
/* Reload the quickfill */ /* Reload the quickfill */
gnc_quickfill_purge (qfb->qf); gnc_quickfill_purge (qfb->qf);
gtk_list_store_clear (qfb->list_store); gtk_list_store_clear (qfb->list_store);
gtk_list_store_clear (qfb->list_store_full);
qfb->load_list_store = TRUE; qfb->load_list_store = TRUE;
gnc_account_foreach_descendant (qfb->root, load_shared_qf_cb, qfb); gnc_account_foreach_descendant (qfb->root, load_shared_qf_cb, qfb);
qfb->load_list_store = FALSE; qfb->load_list_store = FALSE;
@ -160,22 +172,24 @@ shared_quickfill_pref_changed (gpointer prefs, gchar *pref, gpointer user_data)
/* Build the quickfill list out of account names. /* Build the quickfill list out of account names.
* Essentially same loop as in gnc_load_xfer_cell() above. * Essentially same loop as in gnc_load_xfer_cell() above.
*/ */
static QFB * static QFB*
build_shared_quickfill (QofBook *book, Account *root, const char * key, build_shared_quickfill (QofBook* book, Account* root, const char* key,
AccountBoolCB cb, gpointer data) AccountBoolCB cb, gpointer data)
{ {
QFB *qfb; QFB* qfb;
qfb = g_new0 (QFB, 1); qfb = g_new0 (QFB, 1);
qfb->qf = gnc_quickfill_new (); qfb->qf = gnc_quickfill_new();
qfb->book = book; qfb->book = book;
qfb->root = root; qfb->root = root;
qfb->listener = 0; qfb->listener = 0;
qfb->dont_add_cb = cb; qfb->dont_add_cb = cb;
qfb->dont_add_data = data; qfb->dont_add_data = data;
qfb->load_list_store = TRUE; qfb->load_list_store = TRUE;
qfb->list_store = gtk_list_store_new (NUM_ACCOUNT_COLUMNS, qfb->list_store = gtk_list_store_new (NUM_ACCOUNT_COLUMNS,
G_TYPE_STRING, G_TYPE_POINTER); G_TYPE_STRING, G_TYPE_POINTER);
qfb->list_store_full = gtk_list_store_new (NUM_ACCOUNT_COLUMNS,
G_TYPE_STRING, G_TYPE_POINTER);
gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL, gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
GNC_PREF_ACCOUNT_SEPARATOR, GNC_PREF_ACCOUNT_SEPARATOR,
@ -197,12 +211,12 @@ build_shared_quickfill (QofBook *book, Account *root, const char * key,
return qfb; return qfb;
} }
QuickFill * QuickFill*
gnc_get_shared_account_name_quickfill (Account *root, const char * key, gnc_get_shared_account_name_quickfill (Account* root, const char* key,
AccountBoolCB cb, gpointer cb_data) AccountBoolCB cb, gpointer cb_data)
{ {
QFB *qfb; QFB* qfb;
QofBook *book; QofBook* book;
book = gnc_account_get_book (root); book = gnc_account_get_book (root);
qfb = qof_book_get_data (book, key); qfb = qof_book_get_data (book, key);
@ -214,12 +228,12 @@ gnc_get_shared_account_name_quickfill (Account *root, const char * key,
return qfb->qf; return qfb->qf;
} }
GtkListStore * GtkListStore*
gnc_get_shared_account_name_list_store (Account *root, const char * key, gnc_get_shared_account_name_list_store (Account* root, const char* key,
AccountBoolCB cb, gpointer cb_data) AccountBoolCB cb, gpointer cb_data)
{ {
QFB *qfb; QFB* qfb;
QofBook *book; QofBook* book;
book = gnc_account_get_book (root); book = gnc_account_get_book (root);
qfb = qof_book_get_data (book, key); qfb = qof_book_get_data (book, key);
@ -231,58 +245,76 @@ gnc_get_shared_account_name_list_store (Account *root, const char * key,
return qfb->list_store; return qfb->list_store;
} }
GtkListStore*
gnc_get_shared_account_name_list_store_full (Account* root, const char* key,
AccountBoolCB cb, gpointer cb_data)
{
QFB* qfb;
QofBook* book;
book = gnc_account_get_book (root);
qfb = qof_book_get_data (book, key);
if (qfb)
return qfb->list_store_full;
qfb = build_shared_quickfill (book, root, key, cb, cb_data);
return qfb->list_store_full;
}
/* Since we are maintaining a 'global' quickfill list, we need to /* Since we are maintaining a 'global' quickfill list, we need to
* update it whenever the user creates a new account. So listen * update it whenever the user creates a new account. So listen
* for account modification events, and add new accounts. * for account modification events, and add new accounts.
*/ */
static void static void
listen_for_account_events (QofInstance *entity, QofEventId event_type, listen_for_account_events (QofInstance* entity, QofEventId event_type,
gpointer user_data, gpointer event_data) gpointer user_data, gpointer event_data)
{ {
QFB *qfb = user_data; QFB* qfb = user_data;
QuickFill *qf = qfb->qf; QuickFill* qf = qfb->qf;
QuickFill *match; QuickFill* match;
char * name; char* name;
const char *match_str; const char* match_str;
Account *account; Account* account;
GtkTreeIter iter; GtkTreeIter iter;
find_data data = { 0 }; find_data data = { 0 };
GtkTreePath *path; GtkTreePath* path;
GList *tmp; GList* tmp;
gboolean valid;
if (0 == (event_type & (QOF_EVENT_MODIFY | QOF_EVENT_ADD | QOF_EVENT_REMOVE))) if (0 == (event_type & (QOF_EVENT_MODIFY | QOF_EVENT_ADD | QOF_EVENT_REMOVE)))
return; return;
if (!GNC_IS_ACCOUNT(entity)) if (!GNC_IS_ACCOUNT (entity))
return; return;
account = GNC_ACCOUNT(entity); account = GNC_ACCOUNT (entity);
ENTER("entity %p, event type %x, user data %p, ecent data %p", ENTER ("entity %p, event type %x, user data %p, ecent data %p",
entity, event_type, user_data, event_data); entity, event_type, user_data, event_data);
if (gnc_account_get_root(account) != qfb->root) if (gnc_account_get_root (account) != qfb->root)
{ {
LEAVE("root account mismatch"); LEAVE ("root account mismatch");
return; return;
} }
name = gnc_get_account_name_for_register (account); name = gnc_get_account_name_for_register (account);
if (NULL == name) if (NULL == name)
{ {
LEAVE("account has no name"); LEAVE ("account has no name");
return; return;
} }
switch (event_type) switch (event_type)
{ {
case QOF_EVENT_MODIFY: case QOF_EVENT_MODIFY:
DEBUG("modify %s", name); DEBUG ("modify %s", name);
/* Find the account (and all its descendants) in the model. The /* Find the account (and all its descendants) in the model. The
* full name of all these accounts has changed. */ * full name of all these accounts has changed. */
data.accounts = gnc_account_get_descendants (account); data.accounts = gnc_account_get_descendants (account);
data.accounts = g_list_prepend (data.accounts, account); data.accounts = g_list_prepend (data.accounts, account);
gtk_tree_model_foreach (GTK_TREE_MODEL(qfb->list_store), gtk_tree_model_foreach (GTK_TREE_MODEL (qfb->list_store_full),
shared_quickfill_find_accounts, &data); shared_quickfill_find_accounts, &data);
/* Update the existing items in the list store. Its possible /* Update the existing items in the list store. Its possible
@ -291,17 +323,17 @@ listen_for_account_events (QofInstance *entity, QofEventId event_type,
* store. Otherwise its a simple update of the name string. */ * store. Otherwise its a simple update of the name string. */
for (tmp = data.refs; tmp; tmp = g_list_next (tmp)) for (tmp = data.refs; tmp; tmp = g_list_next (tmp))
{ {
gchar *old_name, *new_name; gchar* old_name, *new_name;
path = gtk_tree_row_reference_get_path (tmp->data); path = gtk_tree_row_reference_get_path (tmp->data);
gtk_tree_row_reference_free (tmp->data); gtk_tree_row_reference_free (tmp->data);
if (!gtk_tree_model_get_iter (GTK_TREE_MODEL(qfb->list_store), if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (qfb->list_store_full),
&iter, path)) &iter, path))
{ {
gtk_tree_path_free (path); gtk_tree_path_free (path);
continue; continue;
} }
gtk_tree_path_free (path); gtk_tree_path_free (path);
gtk_tree_model_get (GTK_TREE_MODEL(qfb->list_store), &iter, gtk_tree_model_get (GTK_TREE_MODEL (qfb->list_store_full), &iter,
ACCOUNT_POINTER, &account, ACCOUNT_POINTER, &account,
ACCOUNT_NAME, &old_name, ACCOUNT_NAME, &old_name,
-1); -1);
@ -314,15 +346,15 @@ listen_for_account_events (QofInstance *entity, QofEventId event_type,
gnc_quickfill_remove (qf, old_name, QUICKFILL_ALPHA); gnc_quickfill_remove (qf, old_name, QUICKFILL_ALPHA);
if (qfb->dont_add_cb && if (qfb->dont_add_cb &&
qfb->dont_add_cb (account, qfb->dont_add_data)) qfb->dont_add_cb (account, qfb->dont_add_data))
{ {
gnc_quickfill_remove (qf, new_name, QUICKFILL_ALPHA); gnc_quickfill_remove (qf, new_name, QUICKFILL_ALPHA);
gtk_list_store_remove (qfb->list_store, &iter); gtk_list_store_remove (qfb->list_store_full, &iter);
} }
else else
{ {
gnc_quickfill_insert (qf, new_name, QUICKFILL_ALPHA); gnc_quickfill_insert (qf, new_name, QUICKFILL_ALPHA);
gtk_list_store_set (qfb->list_store, &iter, gtk_list_store_set (qfb->list_store_full, &iter,
ACCOUNT_NAME, new_name, ACCOUNT_NAME, new_name,
-1); -1);
} }
@ -344,8 +376,8 @@ listen_for_account_events (QofInstance *entity, QofEventId event_type,
} }
} }
gnc_quickfill_insert (qf, name, QUICKFILL_ALPHA); gnc_quickfill_insert (qf, name, QUICKFILL_ALPHA);
gtk_list_store_append (qfb->list_store, &iter); gtk_list_store_append (qfb->list_store_full, &iter);
gtk_list_store_set (qfb->list_store, &iter, gtk_list_store_set (qfb->list_store_full, &iter,
ACCOUNT_NAME, name, ACCOUNT_NAME, name,
ACCOUNT_POINTER, account, ACCOUNT_POINTER, account,
-1); -1);
@ -353,14 +385,14 @@ listen_for_account_events (QofInstance *entity, QofEventId event_type,
break; break;
case QOF_EVENT_REMOVE: case QOF_EVENT_REMOVE:
DEBUG("remove %s", name); DEBUG ("remove %s", name);
/* Remove from qf */ /* Remove from qf */
gnc_quickfill_remove (qfb->qf, name, QUICKFILL_ALPHA); gnc_quickfill_remove (qfb->qf, name, QUICKFILL_ALPHA);
/* Does the account exist in the model? */ /* Does the account exist in the model? */
data.accounts = g_list_append (NULL, account); data.accounts = g_list_append (NULL, account);
gtk_tree_model_foreach (GTK_TREE_MODEL(qfb->list_store), gtk_tree_model_foreach (GTK_TREE_MODEL (qfb->list_store_full),
shared_quickfill_find_accounts, &data); shared_quickfill_find_accounts, &data);
/* Remove from list store */ /* Remove from list store */
@ -368,20 +400,20 @@ listen_for_account_events (QofInstance *entity, QofEventId event_type,
{ {
path = gtk_tree_row_reference_get_path (tmp->data); path = gtk_tree_row_reference_get_path (tmp->data);
gtk_tree_row_reference_free (tmp->data); gtk_tree_row_reference_free (tmp->data);
if (gtk_tree_model_get_iter (GTK_TREE_MODEL(qfb->list_store), if (gtk_tree_model_get_iter (GTK_TREE_MODEL (qfb->list_store_full),
&iter, path)) &iter, path))
{ {
gtk_list_store_remove (qfb->list_store, &iter); gtk_list_store_remove (qfb->list_store_full, &iter);
} }
gtk_tree_path_free (path); gtk_tree_path_free (path);
} }
break; break;
case QOF_EVENT_ADD: case QOF_EVENT_ADD:
DEBUG("add %s", name); DEBUG ("add %s", name);
if (qfb->dont_add_cb && if (qfb->dont_add_cb &&
qfb->dont_add_cb (account, qfb->dont_add_data)) qfb->dont_add_cb (account, qfb->dont_add_data))
break; break;
match = gnc_quickfill_get_string_match (qf, name); match = gnc_quickfill_get_string_match (qf, name);
@ -397,24 +429,43 @@ listen_for_account_events (QofInstance *entity, QofEventId event_type,
PINFO ("insert new account %s into qf=%p", name, qf); PINFO ("insert new account %s into qf=%p", name, qf);
gnc_quickfill_insert (qf, name, QUICKFILL_ALPHA); gnc_quickfill_insert (qf, name, QUICKFILL_ALPHA);
gtk_list_store_append (qfb->list_store, &iter); gtk_list_store_append (qfb->list_store_full, &iter);
gtk_list_store_set (qfb->list_store, &iter, gtk_list_store_set (qfb->list_store_full, &iter,
ACCOUNT_NAME, name, ACCOUNT_NAME, name,
ACCOUNT_POINTER, account, ACCOUNT_POINTER, account,
-1); -1);
break; break;
default: default:
DEBUG("other %s", name); DEBUG ("other %s", name);
break; break;
} }
/* Now that qfb->list_store_full has been updated, qfb->list_store also needs to be updated in
case we're using the regular search. */
gtk_list_store_clear (qfb->list_store);
g_debug ("Replicate shared_store_full\n");
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (qfb->list_store_full),
&iter);
while (valid)
{
gchar* str_data = NULL;
GtkTreeIter iter2;
gtk_tree_model_get (GTK_TREE_MODEL (qfb->list_store_full), &iter, 0, &str_data,
-1);
gtk_list_store_append (qfb->list_store, &iter2);
gtk_list_store_set (qfb->list_store, &iter2, 0, str_data, -1);
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (qfb->list_store_full),
&iter);
g_free (str_data);
}
if (data.accounts) if (data.accounts)
g_list_free (data.accounts); g_list_free (data.accounts);
if (data.refs) if (data.refs)
g_list_free (data.refs); g_list_free (data.refs);
g_free (name); g_free (name);
LEAVE(" "); LEAVE (" ");
} }
/* ====================== END OF FILE ================================== */ /* ====================== END OF FILE ================================== */

13
gnucash/gnome-utils/account-quickfill.h
View File

@ -45,7 +45,7 @@
#include "Account.h" #include "Account.h"
#include "QuickFill.h" #include "QuickFill.h"
typedef gboolean (*AccountBoolCB) (Account *, gpointer); typedef gboolean (*AccountBoolCB) (Account*, gpointer);
/** Create/fetch a quickfill of account names. /** Create/fetch a quickfill of account names.
* *
@ -68,12 +68,15 @@ typedef gboolean (*AccountBoolCB) (Account *, gpointer);
* it). This code does not currently listen to account-destroy * it). This code does not currently listen to account-destroy
* events. * events.
*/ */
QuickFill * QuickFill*
gnc_get_shared_account_name_quickfill (Account *root, const char * key, gnc_get_shared_account_name_quickfill (Account* root, const char* key,
AccountBoolCB skip_cb, gpointer cb_data); AccountBoolCB skip_cb, gpointer cb_data);
GtkListStore * GtkListStore*
gnc_get_shared_account_name_list_store (Account *root, const char * key, gnc_get_shared_account_name_list_store (Account* root, const char* key,
AccountBoolCB cb, gpointer cb_data); AccountBoolCB cb, gpointer cb_data);
GtkListStore*
gnc_get_shared_account_name_list_store_full (Account* root, const char* key,
AccountBoolCB cb, gpointer cb_data);
#endif #endif

168
gnucash/register/ledger-core/gncEntryLedgerLoad.c
View File

@ -45,43 +45,43 @@
static const QofLogModule log_module = "Business Entry Ledger"; static const QofLogModule log_module = "Business Entry Ledger";
/* XXX: This should go elsewhere */ /* XXX: This should go elsewhere */
const char * gnc_entry_ledger_type_string_getter (char flag) const char* gnc_entry_ledger_type_string_getter (char flag)
{ {
switch (flag) switch (flag)
{ {
case '1': case '1':
return _("$"); return _ ("$");
case '2': case '2':
return _("%"); return _ ("%");
default: default:
break; break;
}; };
return "?"; return "?";
} }
const char * gnc_entry_ledger_how_string_getter (char flag) const char* gnc_entry_ledger_how_string_getter (char flag)
{ {
switch (flag) switch (flag)
{ {
case '1': case '1':
return _("<"); return _ ("<");
case '2': case '2':
return _("="); return _ ("=");
case '3': case '3':
return _(">"); return _ (">");
default: default:
break; break;
}; };
return "?"; return "?";
} }
static void load_discount_type_cells (GncEntryLedger *ledger) static void load_discount_type_cells (GncEntryLedger* ledger)
{ {
RecnCell *cell; RecnCell* cell;
if (!ledger) return; if (!ledger) return;
cell = (RecnCell *) cell = (RecnCell*)
gnc_table_layout_get_cell (ledger->table->layout, ENTRY_DISTYPE_CELL); gnc_table_layout_get_cell (ledger->table->layout, ENTRY_DISTYPE_CELL);
if (!cell) return; if (!cell) return;
@ -91,13 +91,13 @@ static void load_discount_type_cells (GncEntryLedger *ledger)
gnc_recn_cell_set_string_getter (cell, gnc_entry_ledger_type_string_getter); gnc_recn_cell_set_string_getter (cell, gnc_entry_ledger_type_string_getter);
} }
static void load_discount_how_cells (GncEntryLedger *ledger) static void load_discount_how_cells (GncEntryLedger* ledger)
{ {
RecnCell *cell; RecnCell* cell;
if (!ledger) return; if (!ledger) return;
cell = (RecnCell *) cell = (RecnCell*)
gnc_table_layout_get_cell (ledger->table->layout, ENTRY_DISHOW_CELL); gnc_table_layout_get_cell (ledger->table->layout, ENTRY_DISHOW_CELL);
if (!cell) return; if (!cell) return;
@ -107,14 +107,14 @@ static void load_discount_how_cells (GncEntryLedger *ledger)
gnc_recn_cell_set_string_getter (cell, gnc_entry_ledger_how_string_getter); gnc_recn_cell_set_string_getter (cell, gnc_entry_ledger_how_string_getter);
} }
static void load_payment_type_cells (GncEntryLedger *ledger) static void load_payment_type_cells (GncEntryLedger* ledger)
{ {
ComboCell *cell; ComboCell* cell;
const GncOwner *owner; const GncOwner* owner;
GncEmployee *employee; GncEmployee* employee;
cell = (ComboCell *) gnc_table_layout_get_cell (ledger->table->layout, cell = (ComboCell*) gnc_table_layout_get_cell (ledger->table->layout,
ENTRY_PAYMENT_CELL); ENTRY_PAYMENT_CELL);
if (!cell) return; if (!cell) return;
if (!ledger->invoice) return; if (!ledger->invoice) return;
@ -127,25 +127,25 @@ static void load_payment_type_cells (GncEntryLedger *ledger)
g_return_if_fail (employee); g_return_if_fail (employee);
gnc_combo_cell_clear_menu (cell); gnc_combo_cell_clear_menu (cell);
gnc_combo_cell_add_menu_item (cell, _("Cash")); gnc_combo_cell_add_menu_item (cell, _ ("Cash"));
if (gncEmployeeGetCCard (employee)) if (gncEmployeeGetCCard (employee))
gnc_combo_cell_add_menu_item (cell, _("Charge")); gnc_combo_cell_add_menu_item (cell, _ ("Charge"));
} }
/* ==================================================================== */ /* ==================================================================== */
/* Return TRUE if we don't want to add this account to the xfer menu */ /* Return TRUE if we don't want to add this account to the xfer menu */
static gboolean static gboolean
skip_expense_acct_cb (Account *account, gpointer user_data) skip_expense_acct_cb (Account* account, gpointer user_data)
{ {
GNCAccountType type; GNCAccountType type;
/* Don't add A/R, A/P, Bank, Cash, or Equity accounts */ /* Don't add A/R, A/P, Bank, Cash, or Equity accounts */
type = xaccAccountGetType (account); type = xaccAccountGetType (account);
if (type == ACCT_TYPE_PAYABLE || type == ACCT_TYPE_RECEIVABLE || if (type == ACCT_TYPE_PAYABLE || type == ACCT_TYPE_RECEIVABLE ||
type == ACCT_TYPE_CASH || type == ACCT_TYPE_BANK || type == ACCT_TYPE_CASH || type == ACCT_TYPE_BANK ||
type == ACCT_TYPE_EQUITY || type == ACCT_TYPE_TRADING) type == ACCT_TYPE_EQUITY || type == ACCT_TYPE_TRADING)
{ {
return TRUE; return TRUE;
} }
@ -160,15 +160,15 @@ skip_expense_acct_cb (Account *account, gpointer user_data)
} }
static gboolean static gboolean
skip_income_acct_cb (Account *account, gpointer user_data) skip_income_acct_cb (Account* account, gpointer user_data)
{ {
GNCAccountType type; GNCAccountType type;
/* Don't add A/R, A/P, Bank, Cash, or Equity accounts */ /* Don't add A/R, A/P, Bank, Cash, or Equity accounts */
type = xaccAccountGetType (account); type = xaccAccountGetType (account);
if (type == ACCT_TYPE_PAYABLE || type == ACCT_TYPE_RECEIVABLE || if (type == ACCT_TYPE_PAYABLE || type == ACCT_TYPE_RECEIVABLE ||
type == ACCT_TYPE_CASH || type == ACCT_TYPE_BANK || type == ACCT_TYPE_CASH || type == ACCT_TYPE_BANK ||
type == ACCT_TYPE_EQUITY || type == ACCT_TYPE_TRADING) type == ACCT_TYPE_EQUITY || type == ACCT_TYPE_TRADING)
{ {
return TRUE; return TRUE;
} }
@ -189,12 +189,13 @@ skip_income_acct_cb (Account *account, gpointer user_data)
#define IKEY "Income Business entry quickfill" #define IKEY "Income Business entry quickfill"
static void static void
load_xfer_type_cells (GncEntryLedger *ledger) load_xfer_type_cells (GncEntryLedger* ledger)
{ {
Account *root; Account* root;
ComboCell *cell; ComboCell* cell;
QuickFill *qf = NULL; QuickFill* qf = NULL;
GtkListStore *store = NULL; GtkListStore* store = NULL;
GtkListStore* store_full = NULL;
root = gnc_book_get_root_account (ledger->book); root = gnc_book_get_root_account (ledger->book);
if (root == NULL) return; if (root == NULL) return;
@ -212,9 +213,11 @@ load_xfer_type_cells (GncEntryLedger *ledger)
case GNCENTRY_CUST_CREDIT_NOTE_ENTRY: case GNCENTRY_CUST_CREDIT_NOTE_ENTRY:
case GNCENTRY_CUST_CREDIT_NOTE_VIEWER: case GNCENTRY_CUST_CREDIT_NOTE_VIEWER:
qf = gnc_get_shared_account_name_quickfill (root, IKEY, qf = gnc_get_shared_account_name_quickfill (root, IKEY,
skip_expense_acct_cb, NULL); skip_expense_acct_cb, NULL);
store = gnc_get_shared_account_name_list_store (root, IKEY, store = gnc_get_shared_account_name_list_store (root, IKEY,
skip_expense_acct_cb, NULL); skip_expense_acct_cb, NULL);
store_full = gnc_get_shared_account_name_list_store_full (root, IKEY,
skip_expense_acct_cb, NULL);
break; break;
case GNCENTRY_BILL_ENTRY: case GNCENTRY_BILL_ENTRY:
@ -227,49 +230,51 @@ load_xfer_type_cells (GncEntryLedger *ledger)
case GNCENTRY_EMPL_CREDIT_NOTE_VIEWER: case GNCENTRY_EMPL_CREDIT_NOTE_VIEWER:
case GNCENTRY_NUM_REGISTER_TYPES: case GNCENTRY_NUM_REGISTER_TYPES:
qf = gnc_get_shared_account_name_quickfill (root, EKEY, qf = gnc_get_shared_account_name_quickfill (root, EKEY,
skip_income_acct_cb, NULL); skip_income_acct_cb, NULL);
store = gnc_get_shared_account_name_list_store (root, EKEY, store = gnc_get_shared_account_name_list_store (root, EKEY,
skip_income_acct_cb, NULL); skip_income_acct_cb, NULL);
store_full = gnc_get_shared_account_name_list_store_full (root, EKEY,
skip_income_acct_cb, NULL);
break; break;
default: default:
PWARN ("Bad GncEntryLedgerType"); PWARN ("Bad GncEntryLedgerType");
break; break;
} }
cell = (ComboCell *) cell = (ComboCell*)
gnc_table_layout_get_cell (ledger->table->layout, ENTRY_IACCT_CELL); gnc_table_layout_get_cell (ledger->table->layout, ENTRY_IACCT_CELL);
gnc_combo_cell_use_quickfill_cache (cell, qf); gnc_combo_cell_use_quickfill_cache (cell, qf);
gnc_combo_cell_use_list_store_cache (cell, store); gnc_combo_cell_use_list_store_cache (cell, store, store_full);
cell = (ComboCell *) cell = (ComboCell*)
gnc_table_layout_get_cell (ledger->table->layout, ENTRY_BACCT_CELL); gnc_table_layout_get_cell (ledger->table->layout, ENTRY_BACCT_CELL);
gnc_combo_cell_use_quickfill_cache (cell, qf); gnc_combo_cell_use_quickfill_cache (cell, qf);
gnc_combo_cell_use_list_store_cache (cell, store); gnc_combo_cell_use_list_store_cache (cell, store, store_full);
} }
/* ===================================================================== */ /* ===================================================================== */
static void load_taxtable_type_cells (GncEntryLedger *ledger) static void load_taxtable_type_cells (GncEntryLedger* ledger)
{ {
GList *list; GList* list;
ComboCell *cell; ComboCell* cell;
cell = (ComboCell *) cell = (ComboCell*)
gnc_table_layout_get_cell (ledger->table->layout, ENTRY_TAXTABLE_CELL); gnc_table_layout_get_cell (ledger->table->layout, ENTRY_TAXTABLE_CELL);
gnc_combo_cell_clear_menu (cell); gnc_combo_cell_clear_menu (cell);
list = gncTaxTableGetTables (ledger->book); list = gncTaxTableGetTables (ledger->book);
for ( ; list ; list = list->next ) for (; list ; list = list->next)
{ {
GncTaxTable *table = list->data; GncTaxTable* table = list->data;
const char *name = gncTaxTableGetName (table); const char* name = gncTaxTableGetName (table);
if (name != NULL) if (name != NULL)
gnc_combo_cell_add_menu_item (cell, (char*)name); gnc_combo_cell_add_menu_item (cell, (char*)name);
} }
} }
static void static void
gnc_entry_ledger_show_entry (GncEntryLedger *ledger, gnc_entry_ledger_show_entry (GncEntryLedger* ledger,
VirtualCellLocation start_loc) VirtualCellLocation start_loc)
{ {
VirtualCellLocation end_loc; VirtualCellLocation end_loc;
@ -286,10 +291,10 @@ gnc_entry_ledger_show_entry (GncEntryLedger *ledger,
#define DESC_QF_KEY_BILLS "ENTRY_DESC_CELL_QF_BILLS" #define DESC_QF_KEY_BILLS "ENTRY_DESC_CELL_QF_BILLS"
static void static void
load_description_cell (GncEntryLedger *ledger) load_description_cell (GncEntryLedger* ledger)
{ {
QuickFill *shared_quickfill; QuickFill* shared_quickfill;
QuickFillCell *cell; QuickFillCell* cell;
switch (ledger->type) switch (ledger->type)
{ {
@ -297,19 +302,21 @@ load_description_cell (GncEntryLedger *ledger)
case GNCENTRY_INVOICE_VIEWER: case GNCENTRY_INVOICE_VIEWER:
case GNCENTRY_CUST_CREDIT_NOTE_ENTRY: case GNCENTRY_CUST_CREDIT_NOTE_ENTRY:
case GNCENTRY_CUST_CREDIT_NOTE_VIEWER: case GNCENTRY_CUST_CREDIT_NOTE_VIEWER:
shared_quickfill = gnc_get_shared_entry_desc_quickfill(ledger->book, DESC_QF_KEY_INVOICES, TRUE); shared_quickfill = gnc_get_shared_entry_desc_quickfill (ledger->book,
DESC_QF_KEY_INVOICES, TRUE);
break; break;
default: default:
shared_quickfill = gnc_get_shared_entry_desc_quickfill(ledger->book, DESC_QF_KEY_BILLS, FALSE); shared_quickfill = gnc_get_shared_entry_desc_quickfill (ledger->book,
DESC_QF_KEY_BILLS, FALSE);
break; break;
}; };
cell = (QuickFillCell *) cell = (QuickFillCell*)
gnc_table_layout_get_cell (ledger->table->layout, ENTRY_DESC_CELL); gnc_table_layout_get_cell (ledger->table->layout, ENTRY_DESC_CELL);
gnc_quickfill_cell_use_quickfill_cache (cell, shared_quickfill); gnc_quickfill_cell_use_quickfill_cache (cell, shared_quickfill);
} }
void gnc_entry_ledger_load_xfer_cells (GncEntryLedger *ledger) void gnc_entry_ledger_load_xfer_cells (GncEntryLedger* ledger)
{ {
load_xfer_type_cells (ledger); load_xfer_type_cells (ledger);
load_taxtable_type_cells (ledger); load_taxtable_type_cells (ledger);
@ -323,14 +330,14 @@ void gnc_entry_ledger_load_xfer_cells (GncEntryLedger *ledger)
* the split-register should be generalized to the point where a cut-n-paste * the split-register should be generalized to the point where a cut-n-paste
* like this isn't required, and this should be trashed. * like this isn't required, and this should be trashed.
*/ */
void gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list) void gnc_entry_ledger_load (GncEntryLedger* ledger, GList* entry_list)
{ {
GncEntry *blank_entry, *find_entry; GncEntry* blank_entry, *find_entry;
CursorBuffer *cursor_buffer; CursorBuffer* cursor_buffer;
Table *table; Table* table;
GList *node; GList* node;
CellBlock *cursor_header, *cursor; CellBlock* cursor_header, *cursor;
VirtualCellLocation vcell_loc; VirtualCellLocation vcell_loc;
VirtualLocation save_loc; VirtualLocation save_loc;
gboolean start_primary_color = TRUE; gboolean start_primary_color = TRUE;
@ -361,29 +368,30 @@ void gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list)
case GNCENTRY_VEND_CREDIT_NOTE_ENTRY: case GNCENTRY_VEND_CREDIT_NOTE_ENTRY:
case GNCENTRY_EMPL_CREDIT_NOTE_ENTRY: case GNCENTRY_EMPL_CREDIT_NOTE_ENTRY:
gnc_suspend_gui_refresh (); gnc_suspend_gui_refresh();
blank_entry = gncEntryCreate (ledger->book); blank_entry = gncEntryCreate (ledger->book);
gncEntrySetDateGDate (blank_entry, &ledger->last_date_entered); gncEntrySetDateGDate (blank_entry, &ledger->last_date_entered);
ledger->blank_entry_guid = *gncEntryGetGUID (blank_entry); ledger->blank_entry_guid = *gncEntryGetGUID (blank_entry);
gnc_resume_gui_refresh (); gnc_resume_gui_refresh();
/* The rest of this does not apply to expense vouchers */ /* The rest of this does not apply to expense vouchers */
if (ledger->type != GNCENTRY_EXPVOUCHER_ENTRY) if (ledger->type != GNCENTRY_EXPVOUCHER_ENTRY)
{ {
const GncOwner *owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (ledger->invoice)); const GncOwner* owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (
GncTaxTable *table = NULL; ledger->invoice));
GncTaxTable* table = NULL;
GncTaxIncluded taxincluded_p = GNC_TAXINCLUDED_USEGLOBAL; GncTaxIncluded taxincluded_p = GNC_TAXINCLUDED_USEGLOBAL;
gboolean taxincluded = FALSE; gboolean taxincluded = FALSE;
gnc_numeric discount = gnc_numeric_zero (); gnc_numeric discount = gnc_numeric_zero();
gnc_numeric price = gnc_numeric_zero (); gnc_numeric price = gnc_numeric_zero();
/* Determine the Price from Customer's or Vendor's Job */ /* Determine the Price from Customer's or Vendor's Job */
switch (gncOwnerGetType (gncInvoiceGetOwner (ledger->invoice))) switch (gncOwnerGetType (gncInvoiceGetOwner (ledger->invoice)))
{ {
case GNC_OWNER_JOB: case GNC_OWNER_JOB:
price = gncJobGetRate( gncOwnerGetJob (gncInvoiceGetOwner (ledger->invoice))); price = gncJobGetRate (gncOwnerGetJob (gncInvoiceGetOwner (ledger->invoice)));
break; break;
default: default:
break; break;
@ -466,7 +474,7 @@ void gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list)
break; break;
default: default:
ledger->blank_entry_guid = *guid_null (); ledger->blank_entry_guid = *guid_null();
break; break;
} }
ledger->blank_entry_edited = FALSE; ledger->blank_entry_edited = FALSE;
@ -488,16 +496,16 @@ void gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list)
} }
else else
{ {
find_entry = gnc_entry_ledger_get_current_entry(ledger); find_entry = gnc_entry_ledger_get_current_entry (ledger);
/* XXX: get current entry (cursor_hint_xxx) */ /* XXX: get current entry (cursor_hint_xxx) */
} }
/* If the current cursor has changed we save the values for later /* If the current cursor has changed we save the values for later
* possible restoration. */ * possible restoration. */
if (gnc_table_current_cursor_changed (table, TRUE) && if (gnc_table_current_cursor_changed (table, TRUE) &&
(find_entry == gnc_entry_ledger_get_current_entry (ledger))) (find_entry == gnc_entry_ledger_get_current_entry (ledger)))
{ {
cursor_buffer = gnc_cursor_buffer_new (); cursor_buffer = gnc_cursor_buffer_new();
gnc_table_save_current_cursor (table, cursor_buffer); gnc_table_save_current_cursor (table, cursor_buffer);
} }
else else
@ -535,7 +543,7 @@ void gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list)
/* Populate the table */ /* Populate the table */
for (node = entry_list; node; node = node->next) for (node = entry_list; node; node = node->next)
{ {
GncEntry *entry = node->data; GncEntry* entry = node->data;
/* Don't load the blank entry */ /* Don't load the blank entry */
if (entry == blank_entry) if (entry == blank_entry)
@ -599,14 +607,14 @@ void gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list)
/* Set completion character */ /* Set completion character */
gnc_combo_cell_set_complete_char gnc_combo_cell_set_complete_char
((ComboCell *) ((ComboCell*)
gnc_table_layout_get_cell (table->layout, ENTRY_IACCT_CELL), gnc_table_layout_get_cell (table->layout, ENTRY_IACCT_CELL),
gnc_get_account_separator ()); gnc_get_account_separator());
gnc_combo_cell_set_complete_char gnc_combo_cell_set_complete_char
((ComboCell *) ((ComboCell*)
gnc_table_layout_get_cell (table->layout, ENTRY_BACCT_CELL), gnc_table_layout_get_cell (table->layout, ENTRY_BACCT_CELL),
gnc_get_account_separator ()); gnc_get_account_separator());
/* enable callback for cursor user-driven moves */ /* enable callback for cursor user-driven moves */
gnc_table_control_allow_move (table->control, TRUE); gnc_table_control_allow_move (table->control, TRUE);

348
gnucash/register/ledger-core/split-register-load.c
View File

@ -46,36 +46,36 @@
static QofLogModule log_module = GNC_MOD_LEDGER; static QofLogModule log_module = GNC_MOD_LEDGER;
static void gnc_split_register_load_xfer_cells (SplitRegister *reg, static void gnc_split_register_load_xfer_cells (SplitRegister* reg,
Account *base_account); Account* base_account);
static void static void
gnc_split_register_load_recn_cells (SplitRegister *reg) gnc_split_register_load_recn_cells (SplitRegister* reg)
{ {
RecnCell *cell; RecnCell* cell;
const char * s; const char* s;
if (!reg) return; if (!reg) return;
cell = (RecnCell *) cell = (RecnCell*)
gnc_table_layout_get_cell (reg->table->layout, RECN_CELL); gnc_table_layout_get_cell (reg->table->layout, RECN_CELL);
if (!cell) return; if (!cell) return;
s = gnc_get_reconcile_valid_flags (); s = gnc_get_reconcile_valid_flags();
gnc_recn_cell_set_valid_flags (cell, s, *s); gnc_recn_cell_set_valid_flags (cell, s, *s);
gnc_recn_cell_set_flag_order (cell, gnc_get_reconcile_flag_order ()); gnc_recn_cell_set_flag_order (cell, gnc_get_reconcile_flag_order());
gnc_recn_cell_set_string_getter (cell, gnc_get_reconcile_str); gnc_recn_cell_set_string_getter (cell, gnc_get_reconcile_str);
} }
static void static void
gnc_split_register_load_associate_cells (SplitRegister *reg) gnc_split_register_load_associate_cells (SplitRegister* reg)
{ {
RecnCell *cell; RecnCell* cell;
if (!reg) return; if (!reg) return;
cell = (RecnCell *) cell = (RecnCell*)
gnc_table_layout_get_cell (reg->table->layout, ASSOC_CELL); gnc_table_layout_get_cell (reg->table->layout, ASSOC_CELL);
if (!cell) return; if (!cell) return;
@ -87,13 +87,13 @@ gnc_split_register_load_associate_cells (SplitRegister *reg)
} }
static void static void
gnc_split_register_load_type_cells (SplitRegister *reg) gnc_split_register_load_type_cells (SplitRegister* reg)
{ {
RecnCell *cell; RecnCell* cell;
if (!reg) return; if (!reg) return;
cell = (RecnCell *) cell = (RecnCell*)
gnc_table_layout_get_cell (reg->table->layout, TYPE_CELL); gnc_table_layout_get_cell (reg->table->layout, TYPE_CELL);
if (!cell) return; if (!cell) return;
@ -166,24 +166,24 @@ gnc_split_register_load_type_cells (SplitRegister *reg)
* will be changed to the row below the last row filled. * will be changed to the row below the last row filled.
*/ */
static void static void
gnc_split_register_add_transaction (SplitRegister *reg, gnc_split_register_add_transaction (SplitRegister* reg,
Transaction *trans, Transaction* trans,
Split *split, Split* split,
CellBlock *lead_cursor, CellBlock* lead_cursor,
CellBlock *split_cursor, CellBlock* split_cursor,
gboolean visible_splits, gboolean visible_splits,
gboolean start_primary_color, gboolean start_primary_color,
gboolean add_empty, gboolean add_empty,
Transaction *find_trans, Transaction* find_trans,
Split *find_split, Split* find_split,
CursorClass find_class, CursorClass find_class,
int *new_split_row, int* new_split_row,
VirtualCellLocation *vcell_loc) VirtualCellLocation* vcell_loc)
{ {
GList *node; GList* node;
g_return_if_fail(reg); g_return_if_fail (reg);
g_return_if_fail(vcell_loc); g_return_if_fail (vcell_loc);
if (split == find_split) if (split == find_split)
*new_split_row = vcell_loc->virt_row; *new_split_row = vcell_loc->virt_row;
@ -197,9 +197,9 @@ gnc_split_register_add_transaction (SplitRegister *reg,
* split in the transaction. */ * split in the transaction. */
for (node = xaccTransGetSplitList (trans); node; node = node->next) for (node = xaccTransGetSplitList (trans); node; node = node->next)
{ {
Split *secondary = node->data; Split* secondary = node->data;
if (!xaccTransStillHasSplit(trans, secondary)) continue; if (!xaccTransStillHasSplit (trans, secondary)) continue;
if (secondary == find_split && find_class == CURSOR_CLASS_SPLIT) if (secondary == find_split && find_class == CURSOR_CLASS_SPLIT)
*new_split_row = vcell_loc->virt_row; *new_split_row = vcell_loc->virt_row;
@ -213,81 +213,82 @@ gnc_split_register_add_transaction (SplitRegister *reg,
if (add_empty) if (add_empty)
{ {
if (find_trans == trans && find_split == NULL && if (find_trans == trans && find_split == NULL &&
find_class == CURSOR_CLASS_SPLIT) find_class == CURSOR_CLASS_SPLIT)
*new_split_row = vcell_loc->virt_row; *new_split_row = vcell_loc->virt_row;
gnc_table_set_vcell(reg->table, split_cursor, xaccSplitGetGUID(NULL), gnc_table_set_vcell (reg->table, split_cursor, xaccSplitGetGUID (NULL),
FALSE, TRUE, *vcell_loc); FALSE, TRUE, *vcell_loc);
vcell_loc->virt_row++; vcell_loc->virt_row++;
} }
} }
static gint static gint
_find_split_with_parent_txn(gconstpointer a, gconstpointer b) _find_split_with_parent_txn (gconstpointer a, gconstpointer b)
{ {
Split *split = (Split*)a; Split* split = (Split*)a;
Transaction *txn = (Transaction*)b; Transaction* txn = (Transaction*)b;
return xaccSplitGetParent(split) == txn ? 0 : 1; return xaccSplitGetParent (split) == txn ? 0 : 1;
} }
static void add_quickfill_completions(TableLayout *layout, Transaction *trans, static void add_quickfill_completions (TableLayout* layout, Transaction* trans,
Split *split, gboolean has_last_num) Split* split, gboolean has_last_num)
{ {
Split *s; Split* s;
int i = 0; int i = 0;
gnc_quickfill_cell_add_completion( gnc_quickfill_cell_add_completion (
(QuickFillCell *) gnc_table_layout_get_cell(layout, DESC_CELL), (QuickFillCell*) gnc_table_layout_get_cell (layout, DESC_CELL),
xaccTransGetDescription(trans)); xaccTransGetDescription (trans));
gnc_quickfill_cell_add_completion( gnc_quickfill_cell_add_completion (
(QuickFillCell *) gnc_table_layout_get_cell(layout, NOTES_CELL), (QuickFillCell*) gnc_table_layout_get_cell (layout, NOTES_CELL),
xaccTransGetNotes(trans)); xaccTransGetNotes (trans));
if (!has_last_num) if (!has_last_num)
gnc_num_cell_set_last_num( gnc_num_cell_set_last_num (
(NumCell *) gnc_table_layout_get_cell(layout, NUM_CELL), (NumCell*) gnc_table_layout_get_cell (layout, NUM_CELL),
gnc_get_num_action(trans, split)); gnc_get_num_action (trans, split));
while ((s = xaccTransGetSplit(trans, i)) != NULL) while ((s = xaccTransGetSplit (trans, i)) != NULL)
{ {
gnc_quickfill_cell_add_completion( gnc_quickfill_cell_add_completion (
(QuickFillCell *) gnc_table_layout_get_cell(layout, MEMO_CELL), (QuickFillCell*) gnc_table_layout_get_cell (layout, MEMO_CELL),
xaccSplitGetMemo(s)); xaccSplitGetMemo (s));
i++; i++;
} }
} }
static Split* static Split*
create_blank_split (Account *default_account, SRInfo *info) create_blank_split (Account* default_account, SRInfo* info)
{ {
Transaction *new_trans; Transaction* new_trans;
gboolean currency_from_account = TRUE; gboolean currency_from_account = TRUE;
Split *blank_split = NULL; Split* blank_split = NULL;
/* Determine the proper currency to use for this transaction. /* Determine the proper currency to use for this transaction.
* if default_account != NULL and default_account->commodity is * if default_account != NULL and default_account->commodity is
* a currency, then use that. Otherwise use the default currency. * a currency, then use that. Otherwise use the default currency.
*/ */
gnc_commodity * currency = gnc_account_or_default_currency(default_account, &currency_from_account); gnc_commodity* currency = gnc_account_or_default_currency (default_account,
&currency_from_account);
if (default_account != NULL && !currency_from_account) if (default_account != NULL && !currency_from_account)
{ {
/* If we don't have a currency then pop up a warning dialog */ /* If we don't have a currency then pop up a warning dialog */
gnc_info_dialog(NULL, "%s", gnc_info_dialog (NULL, "%s",
_("Could not determine the account currency. " _ ("Could not determine the account currency. "
"Using the default currency provided by your system.")); "Using the default currency provided by your system."));
} }
gnc_suspend_gui_refresh (); gnc_suspend_gui_refresh();
new_trans = xaccMallocTransaction (gnc_get_current_book ()); new_trans = xaccMallocTransaction (gnc_get_current_book());
xaccTransBeginEdit (new_trans); xaccTransBeginEdit (new_trans);
xaccTransSetCurrency (new_trans, currency); xaccTransSetCurrency (new_trans, currency);
xaccTransSetDatePostedSecsNormalized(new_trans, info->last_date_entered); xaccTransSetDatePostedSecsNormalized (new_trans, info->last_date_entered);
blank_split = xaccMallocSplit (gnc_get_current_book ()); blank_split = xaccMallocSplit (gnc_get_current_book());
xaccSplitSetParent(blank_split, new_trans); xaccSplitSetParent (blank_split, new_trans);
/* We don't want to commit this transaction yet, because the split /* We don't want to commit this transaction yet, because the split
doesn't even belong to an account yet. But, we don't want to doesn't even belong to an account yet. But, we don't want to
set this transaction as the pending transaction either, because set this transaction as the pending transaction either, because
@ -299,34 +300,34 @@ create_blank_split (Account *default_account, SRInfo *info)
info->blank_split_guid = *xaccSplitGetGUID (blank_split); info->blank_split_guid = *xaccSplitGetGUID (blank_split);
info->blank_split_edited = FALSE; info->blank_split_edited = FALSE;
info->auto_complete = FALSE; info->auto_complete = FALSE;
DEBUG("created new blank_split=%p", blank_split); DEBUG ("created new blank_split=%p", blank_split);
gnc_resume_gui_refresh (); gnc_resume_gui_refresh();
return blank_split; return blank_split;
} }
static void static void
change_account_separator (SRInfo *info, Table *table, SplitRegister *reg) change_account_separator (SRInfo* info, Table* table, SplitRegister* reg)
{ {
info->separator_changed = FALSE; info->separator_changed = FALSE;
/* set the completion character for the xfer cells */ /* set the completion character for the xfer cells */
gnc_combo_cell_set_complete_char( gnc_combo_cell_set_complete_char (
(ComboCell *) gnc_table_layout_get_cell(table->layout, MXFRM_CELL), (ComboCell*) gnc_table_layout_get_cell (table->layout, MXFRM_CELL),
gnc_get_account_separator()); gnc_get_account_separator());
gnc_combo_cell_set_complete_char( gnc_combo_cell_set_complete_char (
(ComboCell *) gnc_table_layout_get_cell(table->layout, XFRM_CELL), (ComboCell*) gnc_table_layout_get_cell (table->layout, XFRM_CELL),
gnc_get_account_separator()); gnc_get_account_separator());
/* set the confirmation callback for the reconcile cell */ /* set the confirmation callback for the reconcile cell */
gnc_recn_cell_set_confirm_cb( gnc_recn_cell_set_confirm_cb (
(RecnCell *) gnc_table_layout_get_cell(table->layout, RECN_CELL), (RecnCell*) gnc_table_layout_get_cell (table->layout, RECN_CELL),
gnc_split_register_recn_cell_confirm, reg); gnc_split_register_recn_cell_confirm, reg);
} }
static void static void
update_info (SRInfo *info, SplitRegister *reg) update_info (SRInfo* info, SplitRegister* reg)
{ {
/* Set up the hint transaction, split, transaction split, and column. */ /* Set up the hint transaction, split, transaction split, and column. */
info->cursor_hint_trans = gnc_split_register_get_current_trans (reg); info->cursor_hint_trans = gnc_split_register_get_current_trans (reg);
@ -343,26 +344,26 @@ update_info (SRInfo *info, SplitRegister *reg)
} }
void void
gnc_split_register_load (SplitRegister *reg, GList * slist, gnc_split_register_load (SplitRegister* reg, GList* slist,
Account *default_account) Account* default_account)
{ {
SRInfo *info; SRInfo* info;
Transaction *pending_trans; Transaction* pending_trans;
CursorBuffer *cursor_buffer; CursorBuffer* cursor_buffer;
GHashTable *trans_table = NULL; GHashTable* trans_table = NULL;
CellBlock *cursor_header; CellBlock* cursor_header;
CellBlock *lead_cursor; CellBlock* lead_cursor;
CellBlock *split_cursor; CellBlock* split_cursor;
Transaction *blank_trans; Transaction* blank_trans;
Transaction *find_trans; Transaction* find_trans;
Transaction *trans; Transaction* trans;
CursorClass find_class; CursorClass find_class;
Split *find_trans_split; Split* find_trans_split;
Split *blank_split; Split* blank_split;
Split *find_split; Split* find_split;
Split *split; Split* split;
Table *table; Table* table;
GList *node; GList* node;
gboolean start_primary_color = TRUE; gboolean start_primary_color = TRUE;
gboolean found_pending = FALSE; gboolean found_pending = FALSE;
@ -373,9 +374,11 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
gboolean multi_line; gboolean multi_line;
gboolean dynamic; gboolean dynamic;
gboolean we_own_slist = FALSE; gboolean we_own_slist = FALSE;
gboolean use_autoreadonly = qof_book_uses_autoreadonly(gnc_get_current_book()); gboolean use_autoreadonly = qof_book_uses_autoreadonly (
gboolean future_after_blank = gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL_REGISTER, gnc_get_current_book());
GNC_PREF_FUTURE_AFTER_BLANK); gboolean future_after_blank = gnc_prefs_get_bool (
GNC_PREFS_GROUP_GENERAL_REGISTER,
GNC_PREF_FUTURE_AFTER_BLANK);
gboolean added_blank_trans = FALSE; gboolean added_blank_trans = FALSE;
VirtualCellLocation vcell_loc; VirtualCellLocation vcell_loc;
@ -386,42 +389,42 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
int new_split_row = -1; int new_split_row = -1;
time64 present, autoreadonly_time = 0; time64 present, autoreadonly_time = 0;
g_return_if_fail(reg); g_return_if_fail (reg);
table = reg->table; table = reg->table;
g_return_if_fail(table); g_return_if_fail (table);
info = gnc_split_register_get_info (reg); info = gnc_split_register_get_info (reg);
g_return_if_fail(info); g_return_if_fail (info);
ENTER("reg=%p, slist=%p, default_account=%p", reg, slist, default_account); ENTER ("reg=%p, slist=%p, default_account=%p", reg, slist, default_account);
blank_split = xaccSplitLookup (&info->blank_split_guid, blank_split = xaccSplitLookup (&info->blank_split_guid,
gnc_get_current_book ()); gnc_get_current_book());
pending_trans = xaccTransLookup (&info->pending_trans_guid, pending_trans = xaccTransLookup (&info->pending_trans_guid,
gnc_get_current_book ()); gnc_get_current_book());
/* Bug 742089: Set the debit and credit cells' print_info to the account */ /* Bug 742089: Set the debit and credit cells' print_info to the account */
gnc_price_cell_set_print_info gnc_price_cell_set_print_info
((PriceCell *) gnc_table_layout_get_cell (table->layout, DEBT_CELL), ((PriceCell*) gnc_table_layout_get_cell (table->layout, DEBT_CELL),
gnc_account_print_info (default_account, FALSE)); gnc_account_print_info (default_account, FALSE));
gnc_price_cell_set_print_info gnc_price_cell_set_print_info
((PriceCell *) gnc_table_layout_get_cell (table->layout, CRED_CELL), ((PriceCell*) gnc_table_layout_get_cell (table->layout, CRED_CELL),
gnc_account_print_info (default_account, FALSE)); gnc_account_print_info (default_account, FALSE));
/* make sure we have a blank split */ /* make sure we have a blank split */
if (blank_split == NULL) if (blank_split == NULL)
{ {
/* Wouldn't it be a bug to open the new transaction if there was /* Wouldn't it be a bug to open the new transaction if there was
* already a pending transaction? * already a pending transaction?
*/ */
g_assert(pending_trans == NULL); g_assert (pending_trans == NULL);
blank_split = create_blank_split (default_account, info); blank_split = create_blank_split (default_account, info);
} }
blank_trans = xaccSplitGetParent (blank_split); blank_trans = xaccSplitGetParent (blank_split);
DEBUG("blank_split=%p, blank_trans=%p, pending_trans=%p", DEBUG ("blank_split=%p, blank_trans=%p, pending_trans=%p",
blank_split, blank_trans, pending_trans); blank_split, blank_trans, pending_trans);
info->default_account = *xaccAccountGetGUID (default_account); info->default_account = *xaccAccountGetGUID (default_account);
@ -454,9 +457,9 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
/* If the current cursor has changed we save the values for later /* If the current cursor has changed we save the values for later
* possible restoration. */ * possible restoration. */
if (gnc_table_current_cursor_changed (table, TRUE) && if (gnc_table_current_cursor_changed (table, TRUE) &&
(find_split == gnc_split_register_get_current_split (reg))) (find_split == gnc_split_register_get_current_split (reg)))
{ {
cursor_buffer = gnc_cursor_buffer_new (); cursor_buffer = gnc_cursor_buffer_new();
gnc_table_save_current_cursor (table, cursor_buffer); gnc_table_save_current_cursor (table, cursor_buffer);
} }
else else
@ -470,7 +473,7 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
{ {
VirtualLocation virt_loc; VirtualLocation virt_loc;
gnc_virtual_location_init(&virt_loc); gnc_virtual_location_init (&virt_loc);
gnc_table_move_cursor_gui (table, virt_loc); gnc_table_move_cursor_gui (table, virt_loc);
} }
@ -482,26 +485,26 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
vcell_loc.virt_row++; vcell_loc.virt_row++;
/* get the current time and reset the dividing row */ /* get the current time and reset the dividing row */
present = gnc_time64_get_today_end (); present = gnc_time64_get_today_end();
if (use_autoreadonly) if (use_autoreadonly)
{ {
GDate *d = qof_book_get_autoreadonly_gdate(gnc_get_current_book()); GDate* d = qof_book_get_autoreadonly_gdate (gnc_get_current_book());
// "d" is NULL if use_autoreadonly is FALSE // "d" is NULL if use_autoreadonly is FALSE
autoreadonly_time = d ? gdate_to_time64 (*d) : 0; autoreadonly_time = d ? gdate_to_time64 (*d) : 0;
g_date_free(d); g_date_free (d);
} }
if (info->first_pass) if (info->first_pass)
{ {
if (default_account) if (default_account)
{ {
const char *last_num = xaccAccountGetLastNum (default_account); const char* last_num = xaccAccountGetLastNum (default_account);
if (last_num) if (last_num)
{ {
NumCell *cell; NumCell* cell;
cell = (NumCell *) gnc_table_layout_get_cell(table->layout, NUM_CELL); cell = (NumCell*) gnc_table_layout_get_cell (table->layout, NUM_CELL);
gnc_num_cell_set_last_num (cell, last_num); gnc_num_cell_set_last_num (cell, last_num);
has_last_num = TRUE; has_last_num = TRUE;
} }
@ -515,7 +518,7 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
} }
if (info->separator_changed) if (info->separator_changed)
change_account_separator (info, table, reg); change_account_separator (info, table, reg);
table->model->dividing_row_upper = -1; table->model->dividing_row_upper = -1;
table->model->dividing_row = -1; table->model->dividing_row = -1;
@ -525,24 +528,24 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
// list we're about to load. // list we're about to load.
if (pending_trans != NULL) if (pending_trans != NULL)
{ {
for (node = xaccTransGetSplitList(pending_trans); node; node = node->next) for (node = xaccTransGetSplitList (pending_trans); node; node = node->next)
{ {
Split *pending_split = (Split*)node->data; Split* pending_split = (Split*)node->data;
if (!xaccTransStillHasSplit(pending_trans, pending_split)) continue; if (!xaccTransStillHasSplit (pending_trans, pending_split)) continue;
if (g_list_find(slist, pending_split) != NULL) if (g_list_find (slist, pending_split) != NULL)
continue; continue;
if (g_list_find_custom(slist, pending_trans, if (g_list_find_custom (slist, pending_trans,
_find_split_with_parent_txn) != NULL) _find_split_with_parent_txn) != NULL)
continue; continue;
if (!we_own_slist) if (!we_own_slist)
{ {
// lazy-copy // lazy-copy
slist = g_list_copy(slist); slist = g_list_copy (slist);
we_own_slist = TRUE; we_own_slist = TRUE;
} }
slist = g_list_append(slist, pending_split); slist = g_list_append (slist, pending_split);
} }
} }
@ -555,18 +558,18 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
split = node->data; split = node->data;
trans = xaccSplitGetParent (split); trans = xaccSplitGetParent (split);
if (!xaccTransStillHasSplit(trans, split)) if (!xaccTransStillHasSplit (trans, split))
continue; continue;
if (pending_trans == trans) if (pending_trans == trans)
found_pending = TRUE; found_pending = TRUE;
/* If the transaction has only one split, and it's not our /* If the transaction has only one split, and it's not our
* pending_trans, then it's another register's blank split and * pending_trans, then it's another register's blank split and
* we don't want to see it. * we don't want to see it.
*/ */
else if (xaccTransCountSplits (trans) == 1 && else if (xaccTransCountSplits (trans) == 1 &&
xaccSplitGetAccount (split) == NULL) xaccSplitGetAccount (split) == NULL)
continue; continue;
/* Do not load splits from the blank transaction. */ /* Do not load splits from the blank transaction. */
@ -583,8 +586,8 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
} }
if (info->show_present_divider && if (info->show_present_divider &&
use_autoreadonly && use_autoreadonly &&
!found_divider_upper) !found_divider_upper)
{ {
if (xaccTransGetDate (trans) >= autoreadonly_time) if (xaccTransGetDate (trans) >= autoreadonly_time)
{ {
@ -598,8 +601,8 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
} }
if (info->show_present_divider && if (info->show_present_divider &&
!found_divider && !found_divider &&
(xaccTransGetDate (trans) > present)) (xaccTransGetDate (trans) > present))
{ {
table->model->dividing_row = vcell_loc.virt_row; table->model->dividing_row = vcell_loc.virt_row;
found_divider = TRUE; found_divider = TRUE;
@ -621,13 +624,13 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
} }
gnc_split_register_add_transaction (reg, gnc_split_register_add_transaction (reg,
blank_trans, blank_split, blank_trans, blank_split,
lead_cursor, split_cursor, lead_cursor, split_cursor,
multi_line, start_primary_color, multi_line, start_primary_color,
info->blank_split_edited, info->blank_split_edited,
find_trans, find_split, find_trans, find_split,
find_class, &new_split_row, find_class, &new_split_row,
&vcell_loc); &vcell_loc);
table->model->dividing_row_lower = vcell_loc.virt_row; table->model->dividing_row_lower = vcell_loc.virt_row;
@ -641,7 +644,7 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
/* If this is the first load of the register, /* If this is the first load of the register,
* fill up the quickfill cells. */ * fill up the quickfill cells. */
if (info->first_pass) if (info->first_pass)
add_quickfill_completions(reg->table->layout, trans, split, has_last_num); add_quickfill_completions (reg->table->layout, trans, split, has_last_num);
if (trans == find_trans) if (trans == find_trans)
new_trans_row = vcell_loc.virt_row; new_trans_row = vcell_loc.virt_row;
@ -669,8 +672,8 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
/* No upper divider yet? Store it now */ /* No upper divider yet? Store it now */
if (info->show_present_divider && if (info->show_present_divider &&
use_autoreadonly && use_autoreadonly &&
!found_divider_upper && need_divider_upper) !found_divider_upper && need_divider_upper)
{ {
table->model->dividing_row_upper = vcell_loc.virt_row; table->model->dividing_row_upper = vcell_loc.virt_row;
} }
@ -679,7 +682,7 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
* from the account. */ * from the account. */
if (!found_pending) if (!found_pending)
{ {
info->pending_trans_guid = *guid_null (); info->pending_trans_guid = *guid_null();
if (xaccTransIsOpen (pending_trans)) if (xaccTransIsOpen (pending_trans))
xaccTransCommitEdit (pending_trans); xaccTransCommitEdit (pending_trans);
else if (pending_trans) else if (pending_trans)
@ -740,12 +743,12 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
trans_split_loc = save_loc; trans_split_loc = save_loc;
gnc_split_register_get_trans_split (reg, save_loc.vcell_loc, gnc_split_register_get_trans_split (reg, save_loc.vcell_loc,
&trans_split_loc.vcell_loc); &trans_split_loc.vcell_loc);
if (dynamic || multi_line || info->trans_expanded) if (dynamic || multi_line || info->trans_expanded)
{ {
gnc_table_set_virt_cell_cursor( gnc_table_set_virt_cell_cursor (
table, trans_split_loc.vcell_loc, table, trans_split_loc.vcell_loc,
gnc_split_register_get_active_cursor (reg)); gnc_split_register_get_active_cursor (reg));
gnc_split_register_set_trans_visible (reg, trans_split_loc.vcell_loc, gnc_split_register_set_trans_visible (reg, trans_split_loc.vcell_loc,
@ -773,7 +776,7 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
update_info (info, reg); update_info (info, reg);
gnc_split_register_set_cell_fractions( gnc_split_register_set_cell_fractions (
reg, gnc_split_register_get_current_split (reg)); reg, gnc_split_register_get_current_split (reg));
gnc_table_refresh_gui (table, TRUE); gnc_table_refresh_gui (table, TRUE);
@ -784,9 +787,9 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
gnc_table_control_allow_move (table->control, TRUE); gnc_table_control_allow_move (table->control, TRUE);
if (we_own_slist) if (we_own_slist)
g_list_free(slist); g_list_free (slist);
LEAVE(" "); LEAVE (" ");
} }
/* ===================================================================== */ /* ===================================================================== */
@ -794,7 +797,7 @@ gnc_split_register_load (SplitRegister *reg, GList * slist,
#define QKEY "split_reg_shared_quickfill" #define QKEY "split_reg_shared_quickfill"
static gboolean static gboolean
skip_cb (Account *account, gpointer x) skip_cb (Account* account, gpointer x)
{ {
/* commented out as per Bug#340885 Comments 1 and 2, option (2). /* commented out as per Bug#340885 Comments 1 and 2, option (2).
if (xaccAccountIsHidden(account)) if (xaccAccountIsHidden(account))
@ -804,15 +807,16 @@ skip_cb (Account *account, gpointer x)
} }
static void static void
gnc_split_register_load_xfer_cells (SplitRegister *reg, Account *base_account) gnc_split_register_load_xfer_cells (SplitRegister* reg, Account* base_account)
{ {
Account *root = NULL; Account* root = NULL;
QuickFill *qf; QuickFill* qf;
ComboCell *cell; ComboCell* cell;
GtkListStore *store; GtkListStore* store;
GtkListStore* store_full;
if (base_account) if (base_account)
root = gnc_account_get_root(base_account); root = gnc_account_get_root (base_account);
if (root == NULL) if (root == NULL)
root = gnc_get_current_root_account(); root = gnc_get_current_root_account();
if (root == NULL) if (root == NULL)
@ -820,16 +824,18 @@ gnc_split_register_load_xfer_cells (SplitRegister *reg, Account *base_account)
qf = gnc_get_shared_account_name_quickfill (root, QKEY, skip_cb, NULL); qf = gnc_get_shared_account_name_quickfill (root, QKEY, skip_cb, NULL);
store = gnc_get_shared_account_name_list_store (root, QKEY, skip_cb, NULL); store = gnc_get_shared_account_name_list_store (root, QKEY, skip_cb, NULL);
store_full = gnc_get_shared_account_name_list_store_full (root, QKEY, skip_cb,
NULL);
cell = (ComboCell *) cell = (ComboCell*)
gnc_table_layout_get_cell (reg->table->layout, XFRM_CELL); gnc_table_layout_get_cell (reg->table->layout, XFRM_CELL);
gnc_combo_cell_use_quickfill_cache (cell, qf); gnc_combo_cell_use_quickfill_cache (cell, qf);
gnc_combo_cell_use_list_store_cache (cell, store); gnc_combo_cell_use_list_store_cache (cell, store, store_full);
cell = (ComboCell *) cell = (ComboCell*)
gnc_table_layout_get_cell (reg->table->layout, MXFRM_CELL); gnc_table_layout_get_cell (reg->table->layout, MXFRM_CELL);
gnc_combo_cell_use_quickfill_cache (cell, qf); gnc_combo_cell_use_quickfill_cache (cell, qf);
gnc_combo_cell_use_list_store_cache (cell, store); gnc_combo_cell_use_list_store_cache (cell, store, store_full);
} }
/* ====================== END OF FILE ================================== */ /* ====================== END OF FILE ================================== */

37
gnucash/register/register-core/combocell.h
View File

@ -49,44 +49,48 @@ typedef struct
{ {
BasicCell cell; BasicCell cell;
gpointer shared_store; gpointer shared_store;
gpointer shared_store_full;
} ComboCell; } ComboCell;
BasicCell * gnc_combo_cell_new (void); BasicCell* gnc_combo_cell_new (void);
void gnc_combo_cell_init (ComboCell *cell); void gnc_combo_cell_init (ComboCell* cell);
void gnc_combo_cell_set_value (ComboCell *cell, const char *value); void gnc_combo_cell_set_value (ComboCell* cell, const char* value);
void gnc_combo_cell_clear_menu (ComboCell *cell); void gnc_combo_cell_clear_menu (ComboCell* cell);
/** Add a menu item to the list. */ /** Add a menu item to the list. */
void gnc_combo_cell_add_menu_item (ComboCell *cell, const char * menustr); void gnc_combo_cell_add_menu_item (ComboCell* cell,
const char* menustr);
/** Add a 'account name' menu item to the list. When testing for /** Add a 'account name' menu item to the list. When testing for
* equality with the currently selected item, this function will * equality with the currently selected item, this function will
* ignore the characters normally used to separate account names. */ * ignore the characters normally used to separate account names. */
void gnc_combo_cell_add_account_menu_item (ComboCell *cell, char * menustr); void gnc_combo_cell_add_account_menu_item (ComboCell* cell,
char* menustr);
/** Enable sorting of the menu item's contents. Loading the item is /** Enable sorting of the menu item's contents. Loading the item is
* much faster with sorting disabled. */ * much faster with sorting disabled. */
void gnc_combo_cell_set_sort_enabled (ComboCell *cell, gboolean enabled); void gnc_combo_cell_set_sort_enabled (ComboCell* cell,
gboolean enabled);
/** Determines whether the cell will accept strings not in the /** Determines whether the cell will accept strings not in the
* menu. Defaults to strict, i.e., only menu items are accepted. */ * menu. Defaults to strict, i.e., only menu items are accepted. */
void gnc_combo_cell_set_strict (ComboCell *cell, gboolean strict); void gnc_combo_cell_set_strict (ComboCell* cell, gboolean strict);
/** Sets a character used for special completion processing. */ /** Sets a character used for special completion processing. */
void gnc_combo_cell_set_complete_char (ComboCell *cell, void gnc_combo_cell_set_complete_char (ComboCell* cell,
gunichar complete_char); gunichar complete_char);
/** Add a string to a list of strings which, if the cell has that value, /** Add a string to a list of strings which, if the cell has that value,
* will cause the cell to be uneditable on 'enter'. */ * will cause the cell to be uneditable on 'enter'. */
void gnc_combo_cell_add_ignore_string (ComboCell *cell, void gnc_combo_cell_add_ignore_string (ComboCell* cell,
const char *ignore_string); const char* ignore_string);
/** Determines whether the popup list autosizes itself or uses /** Determines whether the popup list autosizes itself or uses
* all available space. FALSE by default. */ * all available space. FALSE by default. */
void gnc_combo_cell_set_autosize (ComboCell *cell, gboolean autosize); void gnc_combo_cell_set_autosize (ComboCell* cell, gboolean autosize);
/** Tell the combocell to use a shared QuickFill object. Using this routine /** Tell the combocell to use a shared QuickFill object. Using this routine
* can dramatically improve performance when creating combocells with a * can dramatically improve performance when creating combocells with a
@ -97,9 +101,10 @@ void gnc_combo_cell_set_autosize (ComboCell *cell, gboolean autosize);
* nor delete the quickfill; it is the users resonsibility to manage the * nor delete the quickfill; it is the users resonsibility to manage the
* quickfill object. The combocell will *not* make a copy of the quickfill. * quickfill object. The combocell will *not* make a copy of the quickfill.
*/ */
void gnc_combo_cell_use_quickfill_cache (ComboCell *cell, QuickFill *shared_qf); void gnc_combo_cell_use_quickfill_cache (ComboCell* cell,
QuickFill* shared_qf);
void gnc_combo_cell_use_list_store_cache (ComboCell * cell, gpointer data); void gnc_combo_cell_use_list_store_cache (ComboCell* cell, gpointer data,
gpointer data2);
/** @} */ /** @} */
#endif #endif

451
gnucash/register/register-gnome/combocell-gnome.c
View File

@ -46,15 +46,16 @@
#include "gnucash-sheet.h" #include "gnucash-sheet.h"
#include "gnucash-sheetP.h" #include "gnucash-sheetP.h"
#include "table-allgui.h" #include "table-allgui.h"
#include "Account.h"
#define GNC_PREF_AUTO_RAISE_LISTS "auto-raise-lists" #define GNC_PREF_AUTO_RAISE_LISTS "auto-raise-lists"
typedef struct _PopBox typedef struct _PopBox
{ {
GnucashSheet *sheet; GnucashSheet* sheet;
GncItemEdit *item_edit; GncItemEdit* item_edit;
GncItemList *item_list; GncItemList* item_list;
GtkListStore *tmp_store; GtkListStore* tmp_store;
gboolean signals_connected; /* list signals connected? */ gboolean signals_connected; /* list signals connected? */
@ -62,7 +63,7 @@ typedef struct _PopBox
gboolean autosize; gboolean autosize;
QuickFill *qf; QuickFill* qf;
gboolean use_quickfill_cache; /* If TRUE, we don't own the qf */ gboolean use_quickfill_cache; /* If TRUE, we don't own the qf */
gboolean in_list_select; gboolean in_list_select;
@ -71,26 +72,26 @@ typedef struct _PopBox
gunichar complete_char; /* char to be used for auto-completion */ gunichar complete_char; /* char to be used for auto-completion */
GList *ignore_strings; GList* ignore_strings;
} PopBox; } PopBox;
static void gnc_combo_cell_gui_realize (BasicCell *bcell, gpointer w); static void gnc_combo_cell_gui_realize (BasicCell* bcell, gpointer w);
static void gnc_combo_cell_gui_move (BasicCell *bcell); static void gnc_combo_cell_gui_move (BasicCell* bcell);
static void gnc_combo_cell_gui_destroy (BasicCell *bcell); static void gnc_combo_cell_gui_destroy (BasicCell* bcell);
static gboolean gnc_combo_cell_enter (BasicCell *bcell, static gboolean gnc_combo_cell_enter (BasicCell* bcell,
int *cursor_position, int* cursor_position,
int *start_selection, int* start_selection,
int *end_selection); int* end_selection);
static void gnc_combo_cell_leave (BasicCell *bcell); static void gnc_combo_cell_leave (BasicCell* bcell);
static void gnc_combo_cell_destroy (BasicCell *bcell); static void gnc_combo_cell_destroy (BasicCell* bcell);
static GOnce auto_pop_init_once = G_ONCE_INIT; static GOnce auto_pop_init_once = G_ONCE_INIT;
static gboolean auto_pop_combos = FALSE; static gboolean auto_pop_combos = FALSE;
static void static void
gnc_combo_cell_set_autopop (gpointer prefs, gchar *pref, gpointer user_data) gnc_combo_cell_set_autopop (gpointer prefs, gchar* pref, gpointer user_data)
{ {
auto_pop_combos = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL_REGISTER, auto_pop_combos = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL_REGISTER,
GNC_PREF_AUTO_RAISE_LISTS); GNC_PREF_AUTO_RAISE_LISTS);
@ -112,12 +113,12 @@ gnc_combo_cell_autopop_init (gpointer unused)
return NULL; return NULL;
} }
BasicCell * BasicCell*
gnc_combo_cell_new (void) gnc_combo_cell_new (void)
{ {
ComboCell * cell; ComboCell* cell;
g_once(&auto_pop_init_once, gnc_combo_cell_autopop_init, NULL); g_once (&auto_pop_init_once, gnc_combo_cell_autopop_init, NULL);
cell = g_new0 (ComboCell, 1); cell = g_new0 (ComboCell, 1);
@ -127,11 +128,11 @@ gnc_combo_cell_new (void)
} }
void void
gnc_combo_cell_init (ComboCell *cell) gnc_combo_cell_init (ComboCell* cell)
{ {
PopBox *box; PopBox* box;
gnc_basic_cell_init (&(cell->cell)); gnc_basic_cell_init (& (cell->cell));
cell->cell.is_popup = TRUE; cell->cell.is_popup = TRUE;
@ -150,9 +151,10 @@ gnc_combo_cell_init (ComboCell *cell)
box->list_popped = FALSE; box->list_popped = FALSE;
box->autosize = FALSE; box->autosize = FALSE;
cell->shared_store_full = NULL;
cell->cell.gui_private = box; cell->cell.gui_private = box;
box->qf = gnc_quickfill_new (); box->qf = gnc_quickfill_new();
box->use_quickfill_cache = FALSE; box->use_quickfill_cache = FALSE;
box->in_list_select = FALSE; box->in_list_select = FALSE;
@ -165,10 +167,10 @@ gnc_combo_cell_init (ComboCell *cell)
} }
static void static void
select_item_cb (GncItemList *item_list, char *item_string, gpointer data) select_item_cb (GncItemList* item_list, char* item_string, gpointer data)
{ {
ComboCell *cell = data; ComboCell* cell = data;
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
box->in_list_select = TRUE; box->in_list_select = TRUE;
gnucash_sheet_modify_current_cell (box->sheet, item_string); gnucash_sheet_modify_current_cell (box->sheet, item_string);
@ -179,10 +181,10 @@ select_item_cb (GncItemList *item_list, char *item_string, gpointer data)
} }
static void static void
change_item_cb (GncItemList *item_list, char *item_string, gpointer data) change_item_cb (GncItemList* item_list, char* item_string, gpointer data)
{ {
ComboCell *cell = data; ComboCell* cell = data;
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
box->in_list_select = TRUE; box->in_list_select = TRUE;
gnucash_sheet_modify_current_cell (box->sheet, item_string); gnucash_sheet_modify_current_cell (box->sheet, item_string);
@ -190,20 +192,20 @@ change_item_cb (GncItemList *item_list, char *item_string, gpointer data)
} }
static void static void
activate_item_cb (GncItemList *item_list, char *item_string, gpointer data) activate_item_cb (GncItemList* item_list, char* item_string, gpointer data)
{ {
ComboCell *cell = data; ComboCell* cell = data;
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
gnc_item_edit_hide_popup (box->item_edit); gnc_item_edit_hide_popup (box->item_edit);
box->list_popped = FALSE; box->list_popped = FALSE;
} }
static void static void
key_press_item_cb (GncItemList *item_list, GdkEventKey *event, gpointer data) key_press_item_cb (GncItemList* item_list, GdkEventKey* event, gpointer data)
{ {
ComboCell *cell = data; ComboCell* cell = data;
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
switch (event->keyval) switch (event->keyval)
{ {
@ -213,30 +215,31 @@ key_press_item_cb (GncItemList *item_list, GdkEventKey *event, gpointer data)
break; break;
default: default:
gtk_widget_event (GTK_WIDGET(box->sheet), gtk_widget_event (GTK_WIDGET (box->sheet),
(GdkEvent *) event); (GdkEvent*) event);
break; break;
} }
} }
static void static void
combo_disconnect_signals (ComboCell *cell) combo_disconnect_signals (ComboCell* cell)
{ {
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
if (!box->signals_connected) if (!box->signals_connected)
return; return;
g_signal_handlers_disconnect_matched (G_OBJECT (box->item_list), G_SIGNAL_MATCH_DATA, g_signal_handlers_disconnect_matched (G_OBJECT (box->item_list),
G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, cell); 0, 0, NULL, NULL, cell);
box->signals_connected = FALSE; box->signals_connected = FALSE;
} }
static void static void
combo_connect_signals (ComboCell *cell) combo_connect_signals (ComboCell* cell)
{ {
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
if (box->signals_connected) if (box->signals_connected)
return; return;
@ -257,40 +260,42 @@ combo_connect_signals (ComboCell *cell)
} }
static void static void
block_list_signals (ComboCell *cell) block_list_signals (ComboCell* cell)
{ {
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
if (!box->signals_connected) if (!box->signals_connected)
return; return;
g_signal_handlers_block_matched (G_OBJECT (box->item_list), G_SIGNAL_MATCH_DATA, g_signal_handlers_block_matched (G_OBJECT (box->item_list),
G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, cell); 0, 0, NULL, NULL, cell);
} }
static void static void
unblock_list_signals (ComboCell *cell) unblock_list_signals (ComboCell* cell)
{ {
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
if (!box->signals_connected) if (!box->signals_connected)
return; return;
g_signal_handlers_unblock_matched (G_OBJECT (box->item_list), G_SIGNAL_MATCH_DATA, g_signal_handlers_unblock_matched (G_OBJECT (box->item_list),
G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, cell); 0, 0, NULL, NULL, cell);
} }
static void static void
gnc_combo_cell_gui_destroy (BasicCell *bcell) gnc_combo_cell_gui_destroy (BasicCell* bcell)
{ {
PopBox *box = bcell->gui_private; PopBox* box = bcell->gui_private;
ComboCell *cell = (ComboCell *) bcell; ComboCell* cell = (ComboCell*) bcell;
if (cell->cell.gui_realize == NULL) if (cell->cell.gui_realize == NULL)
{ {
if (box != NULL && box->item_list != NULL) if (box != NULL && box->item_list != NULL)
{ {
combo_disconnect_signals(cell); combo_disconnect_signals (cell);
g_object_unref (box->item_list); g_object_unref (box->item_list);
box->item_list = NULL; box->item_list = NULL;
} }
@ -305,16 +310,16 @@ gnc_combo_cell_gui_destroy (BasicCell *bcell)
} }
static void static void
gnc_combo_cell_destroy (BasicCell *bcell) gnc_combo_cell_destroy (BasicCell* bcell)
{ {
ComboCell *cell = (ComboCell *) bcell; ComboCell* cell = (ComboCell*) bcell;
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
gnc_combo_cell_gui_destroy (&(cell->cell)); gnc_combo_cell_gui_destroy (& (cell->cell));
if (box != NULL) if (box != NULL)
{ {
GList *node; GList* node;
/* Don't destroy the qf if its not ours to destroy */ /* Don't destroy the qf if its not ours to destroy */
if (FALSE == box->use_quickfill_cache) if (FALSE == box->use_quickfill_cache)
@ -341,9 +346,9 @@ gnc_combo_cell_destroy (BasicCell *bcell)
} }
void void
gnc_combo_cell_set_sort_enabled (ComboCell *cell, gboolean enabled) gnc_combo_cell_set_sort_enabled (ComboCell* cell, gboolean enabled)
{ {
PopBox *box; PopBox* box;
if (cell == NULL) if (cell == NULL)
return; return;
@ -353,14 +358,14 @@ gnc_combo_cell_set_sort_enabled (ComboCell *cell, gboolean enabled)
return; return;
block_list_signals (cell); block_list_signals (cell);
gnc_item_list_set_sort_enabled(box->item_list, enabled); gnc_item_list_set_sort_enabled (box->item_list, enabled);
unblock_list_signals (cell); unblock_list_signals (cell);
} }
void void
gnc_combo_cell_clear_menu (ComboCell * cell) gnc_combo_cell_clear_menu (ComboCell* cell)
{ {
PopBox *box; PopBox* box;
if (cell == NULL) if (cell == NULL)
return; return;
@ -373,7 +378,7 @@ gnc_combo_cell_clear_menu (ComboCell * cell)
if (FALSE == box->use_quickfill_cache) if (FALSE == box->use_quickfill_cache)
{ {
gnc_quickfill_destroy (box->qf); gnc_quickfill_destroy (box->qf);
box->qf = gnc_quickfill_new (); box->qf = gnc_quickfill_new();
} }
if (box->item_list != NULL) if (box->item_list != NULL)
@ -389,9 +394,9 @@ gnc_combo_cell_clear_menu (ComboCell * cell)
} }
void void
gnc_combo_cell_use_quickfill_cache (ComboCell * cell, QuickFill *shared_qf) gnc_combo_cell_use_quickfill_cache (ComboCell* cell, QuickFill* shared_qf)
{ {
PopBox *box; PopBox* box;
if (cell == NULL) return; if (cell == NULL) return;
@ -407,17 +412,19 @@ gnc_combo_cell_use_quickfill_cache (ComboCell * cell, QuickFill *shared_qf)
} }
void void
gnc_combo_cell_use_list_store_cache (ComboCell * cell, gpointer data) gnc_combo_cell_use_list_store_cache (ComboCell* cell, gpointer data,
gpointer data_full)
{ {
if (cell == NULL) return; if (cell == NULL) return;
cell->shared_store = data; cell->shared_store = data;
cell->shared_store_full = data_full;
} }
void void
gnc_combo_cell_add_menu_item (ComboCell *cell, const char * menustr) gnc_combo_cell_add_menu_item (ComboCell* cell, const char* menustr)
{ {
PopBox *box; PopBox* box;
if (cell == NULL) if (cell == NULL)
return; return;
@ -432,7 +439,7 @@ gnc_combo_cell_add_menu_item (ComboCell *cell, const char * menustr)
gnc_item_list_append (box->item_list, menustr); gnc_item_list_append (box->item_list, menustr);
if (cell->cell.value && if (cell->cell.value &&
(strcmp (menustr, cell->cell.value) == 0)) (strcmp (menustr, cell->cell.value) == 0))
gnc_item_list_select (box->item_list, menustr); gnc_item_list_select (box->item_list, menustr);
unblock_list_signals (cell); unblock_list_signals (cell);
@ -441,8 +448,8 @@ gnc_combo_cell_add_menu_item (ComboCell *cell, const char * menustr)
{ {
GtkTreeIter iter; GtkTreeIter iter;
gtk_list_store_append(box->tmp_store, &iter); gtk_list_store_append (box->tmp_store, &iter);
gtk_list_store_set(box->tmp_store, &iter, 0, menustr, -1); gtk_list_store_set (box->tmp_store, &iter, 0, menustr, -1);
} }
/* If we're going to be using a pre-fab quickfill, /* If we're going to be using a pre-fab quickfill,
@ -454,10 +461,10 @@ gnc_combo_cell_add_menu_item (ComboCell *cell, const char * menustr)
} }
void void
gnc_combo_cell_add_account_menu_item (ComboCell *cell, char * menustr) gnc_combo_cell_add_account_menu_item (ComboCell* cell, char* menustr)
{ {
PopBox *box; PopBox* box;
gchar *menu_copy, *value_copy; gchar* menu_copy, *value_copy;
if (cell == NULL) if (cell == NULL)
return; return;
@ -473,16 +480,16 @@ gnc_combo_cell_add_account_menu_item (ComboCell *cell, char * menustr)
gnc_item_list_append (box->item_list, menustr); gnc_item_list_append (box->item_list, menustr);
if (cell->cell.value) if (cell->cell.value)
{ {
menu_copy = g_strdelimit(g_strdup(menustr), "-:/\\.", ' '); menu_copy = g_strdelimit (g_strdup (menustr), "-:/\\.", ' ');
value_copy = value_copy =
g_strdelimit(g_strdup(cell->cell.value), "-:/\\.", ' '); g_strdelimit (g_strdup (cell->cell.value), "-:/\\.", ' ');
if (strcmp (menu_copy, value_copy) == 0) if (strcmp (menu_copy, value_copy) == 0)
{ {
gnc_combo_cell_set_value (cell, menustr); gnc_combo_cell_set_value (cell, menustr);
gnc_item_list_select (box->item_list, menustr); gnc_item_list_select (box->item_list, menustr);
} }
g_free(value_copy); g_free (value_copy);
g_free(menu_copy); g_free (menu_copy);
} }
unblock_list_signals (cell); unblock_list_signals (cell);
} }
@ -496,28 +503,88 @@ gnc_combo_cell_add_account_menu_item (ComboCell *cell, char * menustr)
} }
void void
gnc_combo_cell_set_value (ComboCell *cell, const char *str) gnc_combo_cell_set_value (ComboCell* cell, const char* str)
{ {
gnc_basic_cell_set_value (&cell->cell, str); gnc_basic_cell_set_value (&cell->cell, str);
} }
static void /* This function looks through full_store for a partial match with newval and returns the first
gnc_combo_cell_modify_verify (BasicCell *_cell, match (which must be subsequently freed). It fills out box->item_list with found matches */
const char *change, static gchar*
int change_len, gnc_combo_cell_type_ahead_search (const gchar* newval,
const char *newval, GtkListStore* full_store, PopBox* box)
int newval_len,
int *cursor_position,
int *start_selection,
int *end_selection)
{ {
ComboCell *cell = (ComboCell *) _cell; GtkTreeIter iter;
PopBox *box = cell->cell.gui_private; gboolean valid;
const char *match_str; int num_found = 0;
QuickFill *match; gchar* first_found = NULL;
gboolean pop_list; gchar* match_str = NULL;
GError* gerror = NULL;
GMatchInfo* match_info = NULL;
GRegex* regex = NULL;
gchar* rep_str = NULL;
gchar* newval_rep = NULL;
GRegex* regex0 = g_regex_new (gnc_get_account_separator_string(), 0, 0,
&gerror);
// Replace ":" in newval with ".*:.*" so we can use regexp to match.
newval_rep = g_strconcat (".*", gnc_get_account_separator_string(), ".*",
NULL);
rep_str = g_regex_replace (regex0, newval, -1, 0, newval_rep, 0, &gerror);
// Then compile the regular expression based on rep_str.
regex = g_regex_new (rep_str, G_REGEX_CASELESS, 0, &gerror);
valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (full_store), &iter);
// Clear result list.
gnc_item_list_clear (box->item_list);
while (valid)
{
static const gint MAX_NUM_MATCHES = 30;
gchar* str_data = NULL;
gchar* normalized_str_data = NULL;
gtk_tree_model_get (GTK_TREE_MODEL (full_store), &iter, 0, &str_data, -1);
normalized_str_data = g_utf8_normalize (str_data, -1, G_NORMALIZE_ALL);
if (g_regex_match (regex, normalized_str_data, 0, NULL))
{
if (!num_found) first_found = g_strdup (str_data);
++num_found;
/* The pop box can be very slow to display if it has too many items and it's not very useful
to have many. So limit that to a reasonable number. */
if (num_found < MAX_NUM_MATCHES)
gnc_item_list_append (box->item_list, str_data);
}
g_free (str_data);
g_free (normalized_str_data);
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (full_store), &iter);
}
if (num_found)
match_str = first_found;
g_regex_unref (regex);
g_regex_unref (regex0);
g_free (rep_str);
g_free (newval_rep);
return match_str;
}
static void
gnc_combo_cell_modify_verify (BasicCell* _cell,
const char* change,
int change_len,
const char* newval,
int newval_len,
int* cursor_position,
int* start_selection,
int* end_selection)
{
ComboCell* cell = (ComboCell*) _cell;
PopBox* box = cell->cell.gui_private;
gchar* match_str = NULL;
glong newval_chars; glong newval_chars;
glong change_chars; glong change_chars;
GtkListStore* full_store;
const gchar* box_str = NULL;
QuickFill* match = NULL;
newval_chars = g_utf8_strlen (newval, newval_len); newval_chars = g_utf8_strlen (newval, newval_len);
change_chars = g_utf8_strlen (change, change_len); change_chars = g_utf8_strlen (change, change_len);
@ -525,53 +592,51 @@ gnc_combo_cell_modify_verify (BasicCell *_cell,
if (box->in_list_select) if (box->in_list_select)
{ {
gnc_basic_cell_set_value_internal (_cell, newval); gnc_basic_cell_set_value_internal (_cell, newval);
*cursor_position = -1; *cursor_position = -1;
*start_selection = 0; *start_selection = 0;
*end_selection = -1; *end_selection = -1;
return;
}
/* If deleting, just accept */
if (change == NULL)
{
gnc_basic_cell_set_value_internal (_cell, newval);
return;
}
/* If we are inserting in the middle, just accept */
if (*cursor_position < _cell->value_chars)
{
gnc_basic_cell_set_value_internal (_cell, newval);
return; return;
} }
// Try the start-of-name match using the quickfill
match = gnc_quickfill_get_string_match (box->qf, newval); match = gnc_quickfill_get_string_match (box->qf, newval);
match_str = g_strdup (gnc_quickfill_string (match));
match_str = gnc_quickfill_string (match); if (match_str != NULL)
if ((match == NULL) || (match_str == NULL))
{ {
gnc_basic_cell_set_value_internal (_cell, newval); // We have a match, but if we were deleting or inserting in the middle, just accept.
if (change == NULL || *cursor_position < _cell->value_chars)
{
gnc_basic_cell_set_value_internal (_cell, newval);
return;
}
*start_selection = newval_chars;
*end_selection = -1;
*cursor_position += change_chars;
box_str = match_str;
}
else
{
// No start-of-name match, try type-ahead search, we match any substring of the account name.
full_store = cell->shared_store_full;
match_str = gnc_combo_cell_type_ahead_search (newval, full_store, box);
*start_selection = newval_chars;
*end_selection = -1;
*cursor_position = newval_chars;
// Do not change the string in the type-in box.
box_str = newval;
}
if (match_str == NULL)
{
// No match. Remove any selection in popup, don't change the type-in box
gnc_basic_cell_set_value_internal (_cell, newval);
block_list_signals (cell); block_list_signals (cell);
gnc_item_list_select (box->item_list, NULL); gnc_item_list_select (box->item_list, NULL);
unblock_list_signals (cell); unblock_list_signals (cell);
return; return;
} }
*start_selection = newval_chars; if (!box->list_popped && auto_pop_combos)
*end_selection = -1;
*cursor_position += change_chars;
if (!box->list_popped)
pop_list = auto_pop_combos;
else
pop_list = FALSE;
if (pop_list)
{ {
gnc_item_edit_show_popup (box->item_edit); gnc_item_edit_show_popup (box->item_edit);
box->list_popped = TRUE; box->list_popped = TRUE;
@ -581,24 +646,25 @@ gnc_combo_cell_modify_verify (BasicCell *_cell,
gnc_item_list_select (box->item_list, match_str); gnc_item_list_select (box->item_list, match_str);
unblock_list_signals (cell); unblock_list_signals (cell);
gnc_basic_cell_set_value_internal (_cell, match_str); gnc_basic_cell_set_value_internal (_cell, box_str);
g_free (match_str);
} }
static gboolean static gboolean
gnc_combo_cell_direct_update (BasicCell *bcell, gnc_combo_cell_direct_update (BasicCell* bcell,
int *cursor_position, int* cursor_position,
int *start_selection, int* start_selection,
int *end_selection, int* end_selection,
void *gui_data) void* gui_data)
{ {
ComboCell *cell = (ComboCell *) bcell; ComboCell* cell = (ComboCell*) bcell;
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
GdkEventKey *event = gui_data; GdkEventKey* event = gui_data;
gboolean keep_on_going = FALSE; gboolean keep_on_going = FALSE;
gboolean extra_colon; gboolean extra_colon;
gunichar unicode_value; gunichar unicode_value;
QuickFill *match; QuickFill* match;
const char *match_str; const char* match_str;
int prefix_len; int prefix_len;
int find_pos; int find_pos;
int new_pos; int new_pos;
@ -606,11 +672,11 @@ gnc_combo_cell_direct_update (BasicCell *bcell,
if (event->type != GDK_KEY_PRESS) if (event->type != GDK_KEY_PRESS)
return FALSE; return FALSE;
unicode_value = gdk_keyval_to_unicode(event->keyval); unicode_value = gdk_keyval_to_unicode (event->keyval);
switch (event->keyval) switch (event->keyval)
{ {
case GDK_KEY_slash: case GDK_KEY_slash:
if (!(event->state & GDK_MOD1_MASK)) if (! (event->state & GDK_MOD1_MASK))
{ {
if (unicode_value == box->complete_char) if (unicode_value == box->complete_char)
break; break;
@ -618,11 +684,11 @@ gnc_combo_cell_direct_update (BasicCell *bcell,
return FALSE; return FALSE;
} }
keep_on_going = TRUE; keep_on_going = TRUE;
/* fall through */ /* fall through */
case GDK_KEY_Tab: case GDK_KEY_Tab:
case GDK_KEY_ISO_Left_Tab: case GDK_KEY_ISO_Left_Tab:
if (!(event->state & GDK_CONTROL_MASK) && if (! (event->state & GDK_CONTROL_MASK) &&
!keep_on_going) !keep_on_going)
return FALSE; return FALSE;
match = gnc_quickfill_get_string_len_match match = gnc_quickfill_get_string_len_match
@ -638,9 +704,9 @@ gnc_combo_cell_direct_update (BasicCell *bcell,
match_str = gnc_quickfill_string (match); match_str = gnc_quickfill_string (match);
if ((match_str != NULL) && if ((match_str != NULL) &&
(strncmp (match_str, bcell->value, (strncmp (match_str, bcell->value,
strlen (bcell->value)) == 0) && strlen (bcell->value)) == 0) &&
(strcmp (match_str, bcell->value) != 0)) (strcmp (match_str, bcell->value) != 0))
{ {
gnc_basic_cell_set_value_internal (bcell, gnc_basic_cell_set_value_internal (bcell,
match_str); match_str);
@ -668,20 +734,20 @@ gnc_combo_cell_direct_update (BasicCell *bcell,
return FALSE; return FALSE;
if ((*cursor_position < bcell->value_chars) && if ((*cursor_position < bcell->value_chars) &&
((*end_selection < bcell->value_chars) || ((*end_selection < bcell->value_chars) ||
(*cursor_position < *start_selection))) (*cursor_position < *start_selection)))
return FALSE; return FALSE;
if ((*cursor_position == bcell->value_chars) && if ((*cursor_position == bcell->value_chars) &&
(*start_selection != *end_selection) && (*start_selection != *end_selection) &&
(*end_selection < bcell->value_chars)) (*end_selection < bcell->value_chars))
return FALSE; return FALSE;
find_pos = -1; find_pos = -1;
if (*start_selection < bcell->value_chars) if (*start_selection < bcell->value_chars)
{ {
int i = *start_selection; int i = *start_selection;
const char *c; const char* c;
gunichar uc; gunichar uc;
c = g_utf8_offset_to_pointer (bcell->value, i); c = g_utf8_offset_to_pointer (bcell->value, i);
@ -710,7 +776,7 @@ gnc_combo_cell_direct_update (BasicCell *bcell,
} }
match = gnc_quickfill_get_string_len_match (box->qf, match = gnc_quickfill_get_string_len_match (box->qf,
bcell->value, new_pos); bcell->value, new_pos);
if (match == NULL) if (match == NULL)
return FALSE; return FALSE;
@ -727,8 +793,8 @@ gnc_combo_cell_direct_update (BasicCell *bcell,
match_str = gnc_quickfill_string (match); match_str = gnc_quickfill_string (match);
if ((match_str != NULL) && if ((match_str != NULL) &&
(strncmp (match_str, bcell->value, strlen (bcell->value)) == 0) && (strncmp (match_str, bcell->value, strlen (bcell->value)) == 0) &&
(strcmp (match_str, bcell->value) != 0)) (strcmp (match_str, bcell->value) != 0))
{ {
gnc_basic_cell_set_value_internal (bcell, match_str); gnc_basic_cell_set_value_internal (bcell, match_str);
@ -745,12 +811,12 @@ gnc_combo_cell_direct_update (BasicCell *bcell,
} }
static void static void
gnc_combo_cell_gui_realize (BasicCell *bcell, gpointer data) gnc_combo_cell_gui_realize (BasicCell* bcell, gpointer data)
{ {
GnucashSheet *sheet = data; GnucashSheet* sheet = data;
GncItemEdit *item_edit = gnucash_sheet_get_item_edit (sheet); GncItemEdit* item_edit = gnucash_sheet_get_item_edit (sheet);
ComboCell *cell = (ComboCell *) bcell; ComboCell* cell = (ComboCell*) bcell;
PopBox *box = cell->cell.gui_private; PopBox* box = cell->cell.gui_private;
/* initialize gui-specific, private data */ /* initialize gui-specific, private data */
box->sheet = sheet; box->sheet = sheet;
@ -759,8 +825,8 @@ gnc_combo_cell_gui_realize (BasicCell *bcell, gpointer data)
box->item_list = GNC_ITEM_LIST (gnc_item_list_new (cell->shared_store)); box->item_list = GNC_ITEM_LIST (gnc_item_list_new (cell->shared_store));
else else
box->item_list = GNC_ITEM_LIST (gnc_item_list_new (box->tmp_store)); box->item_list = GNC_ITEM_LIST (gnc_item_list_new (box->tmp_store));
gtk_widget_show_all (GTK_WIDGET(box->item_list)); gtk_widget_show_all (GTK_WIDGET (box->item_list));
g_object_ref_sink(box->item_list); g_object_ref_sink (box->item_list);
/* to mark cell as realized, remove the realize method */ /* to mark cell as realized, remove the realize method */
cell->cell.gui_realize = NULL; cell->cell.gui_realize = NULL;
@ -773,11 +839,11 @@ gnc_combo_cell_gui_realize (BasicCell *bcell, gpointer data)
} }
static void static void
gnc_combo_cell_gui_move (BasicCell *bcell) gnc_combo_cell_gui_move (BasicCell* bcell)
{ {
PopBox *box = bcell->gui_private; PopBox* box = bcell->gui_private;
combo_disconnect_signals ((ComboCell *) bcell); combo_disconnect_signals ((ComboCell*) bcell);
gnc_item_edit_set_popup (box->item_edit, NULL, NULL, gnc_item_edit_set_popup (box->item_edit, NULL, NULL,
NULL, NULL, NULL, NULL, NULL); NULL, NULL, NULL, NULL, NULL);
@ -786,24 +852,24 @@ gnc_combo_cell_gui_move (BasicCell *bcell)
} }
static int static int
popup_get_height (G_GNUC_UNUSED GtkWidget *widget, popup_get_height (G_GNUC_UNUSED GtkWidget* widget,
int space_available, int space_available,
int row_height, int row_height,
gpointer user_data) gpointer user_data)
{ {
PopBox *box = user_data; PopBox* box = user_data;
int count, pad = 4; int count, pad = 4;
count = gnc_item_list_num_entries(box->item_list); count = gnc_item_list_num_entries (box->item_list);
return MIN(space_available, (count * (row_height + pad)) + pad); return MIN (space_available, (count * (row_height + pad)) + pad);
} }
static int static int
popup_autosize (GtkWidget *widget, popup_autosize (GtkWidget* widget,
int max_width, int max_width,
gpointer user_data) gpointer user_data)
{ {
PopBox *box = user_data; PopBox* box = user_data;
if (!box || !box->autosize) if (!box || !box->autosize)
return max_width; return max_width;
@ -812,14 +878,14 @@ popup_autosize (GtkWidget *widget,
} }
static void static void
popup_set_focus (GtkWidget *widget, popup_set_focus (GtkWidget* widget,
G_GNUC_UNUSED gpointer user_data) G_GNUC_UNUSED gpointer user_data)
{ {
gtk_widget_grab_focus (GTK_WIDGET (GNC_ITEM_LIST (widget)->tree_view)); gtk_widget_grab_focus (GTK_WIDGET (GNC_ITEM_LIST (widget)->tree_view));
} }
static void static void
popup_post_show (GtkWidget *widget, popup_post_show (GtkWidget* widget,
G_GNUC_UNUSED gpointer user_data) G_GNUC_UNUSED gpointer user_data)
{ {
gnc_item_list_autosize (GNC_ITEM_LIST (widget)); gnc_item_list_autosize (GNC_ITEM_LIST (widget));
@ -827,23 +893,24 @@ popup_post_show (GtkWidget *widget,
} }
static int static int
popup_get_width (GtkWidget *widget, popup_get_width (GtkWidget* widget,
G_GNUC_UNUSED gpointer user_data) G_GNUC_UNUSED gpointer user_data)
{ {
GtkAllocation alloc; GtkAllocation alloc;
gtk_widget_get_allocation (GTK_WIDGET (GNC_ITEM_LIST (widget)->tree_view), &alloc); gtk_widget_get_allocation (GTK_WIDGET (GNC_ITEM_LIST (widget)->tree_view),
&alloc);
return alloc.width; return alloc.width;
} }
static gboolean static gboolean
gnc_combo_cell_enter (BasicCell *bcell, gnc_combo_cell_enter (BasicCell* bcell,
int *cursor_position, int* cursor_position,
int *start_selection, int* start_selection,
int *end_selection) int* end_selection)
{ {
ComboCell *cell = (ComboCell *) bcell; ComboCell* cell = (ComboCell*) bcell;
PopBox *box = bcell->gui_private; PopBox* box = bcell->gui_private;
GList *find = NULL; GList* find = NULL;
if (bcell->value) if (bcell->value)
find = g_list_find_custom (box->ignore_strings, find = g_list_find_custom (box->ignore_strings,
@ -853,7 +920,7 @@ gnc_combo_cell_enter (BasicCell *bcell,
return FALSE; return FALSE;
gnc_item_edit_set_popup (box->item_edit, gnc_item_edit_set_popup (box->item_edit,
GTK_WIDGET(box->item_list), GTK_WIDGET (box->item_list),
popup_get_height, popup_autosize, popup_get_height, popup_autosize,
popup_set_focus, popup_post_show, popup_set_focus, popup_post_show,
popup_get_width, box); popup_get_width, box);
@ -872,11 +939,11 @@ gnc_combo_cell_enter (BasicCell *bcell,
} }
static void static void
gnc_combo_cell_leave (BasicCell *bcell) gnc_combo_cell_leave (BasicCell* bcell)
{ {
PopBox *box = bcell->gui_private; PopBox* box = bcell->gui_private;
combo_disconnect_signals ((ComboCell *) bcell); combo_disconnect_signals ((ComboCell*) bcell);
gnc_item_edit_set_popup (box->item_edit, NULL, NULL, gnc_item_edit_set_popup (box->item_edit, NULL, NULL,
NULL, NULL, NULL, NULL, NULL); NULL, NULL, NULL, NULL, NULL);
@ -900,9 +967,9 @@ gnc_combo_cell_leave (BasicCell *bcell)
} }
void void
gnc_combo_cell_set_strict (ComboCell *cell, gboolean strict) gnc_combo_cell_set_strict (ComboCell* cell, gboolean strict)
{ {
PopBox *box; PopBox* box;
if (cell == NULL) if (cell == NULL)
return; return;
@ -913,9 +980,9 @@ gnc_combo_cell_set_strict (ComboCell *cell, gboolean strict)
} }
void void
gnc_combo_cell_set_complete_char (ComboCell *cell, gunichar complete_char) gnc_combo_cell_set_complete_char (ComboCell* cell, gunichar complete_char)
{ {
PopBox *box; PopBox* box;
if (cell == NULL) if (cell == NULL)
return; return;
@ -926,10 +993,10 @@ gnc_combo_cell_set_complete_char (ComboCell *cell, gunichar complete_char)
} }
void void
gnc_combo_cell_add_ignore_string (ComboCell *cell, gnc_combo_cell_add_ignore_string (ComboCell* cell,
const char *ignore_string) const char* ignore_string)
{ {
PopBox *box; PopBox* box;
if (cell == NULL) if (cell == NULL)
return; return;
@ -944,9 +1011,9 @@ gnc_combo_cell_add_ignore_string (ComboCell *cell,
} }
void void
gnc_combo_cell_set_autosize (ComboCell *cell, gboolean autosize) gnc_combo_cell_set_autosize (ComboCell* cell, gboolean autosize)
{ {
PopBox *box; PopBox* box;
if (!cell) if (!cell)
return; return;

234
gnucash/register/register-gnome/gnucash-item-list.c
View File

@ -45,31 +45,32 @@ enum
LAST_SIGNAL LAST_SIGNAL
}; };
static GtkEventBoxClass *gnc_item_list_parent_class; static GtkEventBoxClass* gnc_item_list_parent_class;
static guint gnc_item_list_signals[LAST_SIGNAL]; static guint gnc_item_list_signals[LAST_SIGNAL];
gboolean _gnc_item_find_selection(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data); gboolean _gnc_item_find_selection (GtkTreeModel* model, GtkTreePath* path,
GtkTreeIter* iter, gpointer data);
gint gint
gnc_item_list_num_entries (GncItemList *item_list) gnc_item_list_num_entries (GncItemList* item_list)
{ {
GtkTreeModel *model; GtkTreeModel* model;
g_return_val_if_fail(item_list != NULL, 0); g_return_val_if_fail (item_list != NULL, 0);
g_return_val_if_fail(IS_GNC_ITEM_LIST(item_list), 0); g_return_val_if_fail (IS_GNC_ITEM_LIST (item_list), 0);
model = GTK_TREE_MODEL(item_list->list_store); model = GTK_TREE_MODEL (item_list->list_store);
return gtk_tree_model_iter_n_children(model, NULL); return gtk_tree_model_iter_n_children (model, NULL);
} }
void void
gnc_item_list_clear (GncItemList *item_list) gnc_item_list_clear (GncItemList* item_list)
{ {
GtkTreeSelection* selection; GtkTreeSelection* selection;
g_return_if_fail(IS_GNC_ITEM_LIST(item_list)); g_return_if_fail (IS_GNC_ITEM_LIST (item_list));
g_return_if_fail(item_list->list_store != NULL); g_return_if_fail (item_list->list_store != NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (item_list->tree_view)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (item_list->tree_view));
@ -82,21 +83,20 @@ gnc_item_list_clear (GncItemList *item_list)
void void
gnc_item_list_append (GncItemList *item_list, const char *string) gnc_item_list_append (GncItemList* item_list, const char* string)
{ {
GtkTreeIter iter; GtkTreeIter iter;
g_return_if_fail(IS_GNC_ITEM_LIST(item_list)); g_return_if_fail (IS_GNC_ITEM_LIST (item_list));
g_return_if_fail(item_list->list_store != NULL); g_return_if_fail (item_list->list_store != NULL);
g_return_if_fail(string != NULL); g_return_if_fail (string != NULL);
gtk_list_store_append (item_list->list_store, &iter); gtk_list_store_append (item_list->list_store, &iter);
gtk_list_store_set (item_list->list_store, &iter, 0, string, -1); gtk_list_store_set (item_list->list_store, &iter, 0, string, -1);
} }
void void
gnc_item_list_set_sort_enabled(GncItemList *item_list, gboolean enabled) gnc_item_list_set_sort_enabled (GncItemList* item_list, gboolean enabled)
{ {
if (enabled) if (enabled)
{ {
@ -117,99 +117,101 @@ gnc_item_list_set_sort_enabled(GncItemList *item_list, gboolean enabled)
typedef struct _findSelectionData typedef struct _findSelectionData
{ {
GncItemList *item_list; GncItemList* item_list;
const char *string_to_find; const char* string_to_find;
GtkTreePath *found_path; GtkTreePath* found_path;
} FindSelectionData; } FindSelectionData;
gboolean gboolean
_gnc_item_find_selection(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data) _gnc_item_find_selection (GtkTreeModel* model, GtkTreePath* path,
GtkTreeIter* iter, gpointer data)
{ {
FindSelectionData *to_find = (FindSelectionData*)data; FindSelectionData* to_find = (FindSelectionData*)data;
gchar *iterStr; gchar* iterStr;
gboolean found; gboolean found;
gtk_tree_model_get(model, iter, 0, &iterStr, -1); gtk_tree_model_get (model, iter, 0, &iterStr, -1);
found = g_strcmp0(to_find->string_to_find, iterStr) == 0; found = g_strcmp0 (to_find->string_to_find, iterStr) == 0;
g_free(iterStr); g_free (iterStr);
if (found) if (found)
{ {
to_find->found_path = gtk_tree_path_copy(path); to_find->found_path = gtk_tree_path_copy (path);
return TRUE; return TRUE;
} }
return FALSE; return FALSE;
} }
gboolean gboolean
gnc_item_in_list (GncItemList *item_list, const char *string) gnc_item_in_list (GncItemList* item_list, const char* string)
{ {
FindSelectionData *to_find_data; FindSelectionData* to_find_data;
gboolean result; gboolean result;
g_return_val_if_fail(item_list != NULL, FALSE); g_return_val_if_fail (item_list != NULL, FALSE);
g_return_val_if_fail(IS_GNC_ITEM_LIST(item_list), FALSE); g_return_val_if_fail (IS_GNC_ITEM_LIST (item_list), FALSE);
to_find_data = (FindSelectionData*)g_new0(FindSelectionData, 1); to_find_data = (FindSelectionData*)g_new0 (FindSelectionData, 1);
to_find_data->item_list = item_list; to_find_data->item_list = item_list;
to_find_data->string_to_find = string; to_find_data->string_to_find = string;
gtk_tree_model_foreach(GTK_TREE_MODEL(item_list->list_store), gtk_tree_model_foreach (GTK_TREE_MODEL (item_list->list_store),
_gnc_item_find_selection, _gnc_item_find_selection,
to_find_data); to_find_data);
result = (to_find_data->found_path != NULL); result = (to_find_data->found_path != NULL);
g_free(to_find_data); g_free (to_find_data);
return result; return result;
} }
void void
gnc_item_list_select (GncItemList *item_list, const char *string) gnc_item_list_select (GncItemList* item_list, const char* string)
{ {
GtkTreeSelection *tree_sel = NULL; GtkTreeSelection* tree_sel = NULL;
FindSelectionData *to_find_data; FindSelectionData* to_find_data;
g_return_if_fail(item_list != NULL); g_return_if_fail (item_list != NULL);
g_return_if_fail(IS_GNC_ITEM_LIST(item_list)); g_return_if_fail (IS_GNC_ITEM_LIST (item_list));
tree_sel = gtk_tree_view_get_selection(item_list->tree_view); tree_sel = gtk_tree_view_get_selection (item_list->tree_view);
if (string == NULL) if (string == NULL)
{ {
gtk_tree_selection_unselect_all(tree_sel); gtk_tree_selection_unselect_all (tree_sel);
return; return;
} }
to_find_data = (FindSelectionData*)g_new0(FindSelectionData, 1); to_find_data = (FindSelectionData*)g_new0 (FindSelectionData, 1);
to_find_data->item_list = item_list; to_find_data->item_list = item_list;
to_find_data->string_to_find = string; to_find_data->string_to_find = string;
gtk_tree_model_foreach(GTK_TREE_MODEL(item_list->list_store), gtk_tree_model_foreach (GTK_TREE_MODEL (item_list->list_store),
_gnc_item_find_selection, _gnc_item_find_selection,
to_find_data); to_find_data);
if (to_find_data->found_path != NULL) if (to_find_data->found_path != NULL)
{ {
gtk_tree_view_set_cursor(item_list->tree_view, to_find_data->found_path, NULL, FALSE); gtk_tree_view_set_cursor (item_list->tree_view, to_find_data->found_path, NULL,
gtk_tree_path_free(to_find_data->found_path); FALSE);
gtk_tree_path_free (to_find_data->found_path);
gnc_item_list_show_selected(item_list); gnc_item_list_show_selected (item_list);
} }
g_free(to_find_data); g_free (to_find_data);
} }
void void
gnc_item_list_show_selected (GncItemList *item_list) gnc_item_list_show_selected (GncItemList* item_list)
{ {
GtkTreeSelection *selection; GtkTreeSelection* selection;
GtkTreeIter iter; GtkTreeIter iter;
GtkTreePath *path; GtkTreePath* path;
GtkTreeModel *model; GtkTreeModel* model;
g_return_if_fail(item_list != NULL); g_return_if_fail (item_list != NULL);
g_return_if_fail(IS_GNC_ITEM_LIST(item_list)); g_return_if_fail (IS_GNC_ITEM_LIST (item_list));
selection = gtk_tree_view_get_selection (item_list->tree_view); selection = gtk_tree_view_get_selection (item_list->tree_view);
@ -223,17 +225,17 @@ gnc_item_list_show_selected (GncItemList *item_list)
} }
int int
gnc_item_list_autosize (GncItemList *item_list) gnc_item_list_autosize (GncItemList* item_list)
{ {
g_return_val_if_fail(item_list != NULL, 0); g_return_val_if_fail (item_list != NULL, 0);
g_return_val_if_fail(IS_GNC_ITEM_LIST(item_list), 0); g_return_val_if_fail (IS_GNC_ITEM_LIST (item_list), 0);
return 100; return 100;
} }
static void static void
gnc_item_list_init (GncItemList *item_list) gnc_item_list_init (GncItemList* item_list)
{ {
item_list->tree_view = NULL; item_list->tree_view = NULL;
item_list->list_store = NULL; item_list->list_store = NULL;
@ -241,17 +243,17 @@ gnc_item_list_init (GncItemList *item_list)
static gboolean static gboolean
gnc_item_list_button_event(GtkWidget *widget, GdkEventButton *event, gnc_item_list_button_event (GtkWidget* widget, GdkEventButton* event,
gpointer data) gpointer data)
{ {
GncItemList *item_list; GncItemList* item_list;
GtkTreeIter iter; GtkTreeIter iter;
GtkTreePath *path; GtkTreePath* path;
GtkTreeModel *model; GtkTreeModel* model;
gchar *string; gchar* string;
gboolean success; gboolean success;
g_return_val_if_fail(IS_GNC_ITEM_LIST (data), FALSE); g_return_val_if_fail (IS_GNC_ITEM_LIST (data), FALSE);
item_list = GNC_ITEM_LIST (data); item_list = GNC_ITEM_LIST (data);
@ -285,7 +287,7 @@ gnc_item_list_button_event(GtkWidget *widget, GdkEventButton *event,
gnc_item_list_signals[ACTIVATE_ITEM], gnc_item_list_signals[ACTIVATE_ITEM],
0, 0,
string); string);
g_free(string); g_free (string);
return TRUE; return TRUE;
default: default:
return FALSE; return FALSE;
@ -295,13 +297,13 @@ gnc_item_list_button_event(GtkWidget *widget, GdkEventButton *event,
} }
static gboolean static gboolean
gnc_item_list_key_event (GtkWidget *widget, GdkEventKey *event, gpointer data) gnc_item_list_key_event (GtkWidget* widget, GdkEventKey* event, gpointer data)
{ {
GncItemList *item_list = GNC_ITEM_LIST (data); GncItemList* item_list = GNC_ITEM_LIST (data);
GtkTreeSelection *selection = NULL; GtkTreeSelection* selection = NULL;
GtkTreeIter iter; GtkTreeIter iter;
GtkTreeModel *model; GtkTreeModel* model;
gchar *string; gchar* string;
gboolean retval; gboolean retval;
switch (event->keyval) switch (event->keyval)
@ -317,7 +319,9 @@ gnc_item_list_key_event (GtkWidget *widget, GdkEventKey *event, gpointer data)
gnc_item_list_signals[ACTIVATE_ITEM], gnc_item_list_signals[ACTIVATE_ITEM],
0, 0,
string); string);
g_free(string); g_signal_emit (G_OBJECT (item_list), gnc_item_list_signals[CHANGE_ITEM], 0,
string);
g_free (string);
return TRUE; return TRUE;
case GDK_KEY_Page_Up: case GDK_KEY_Page_Up:
@ -331,16 +335,17 @@ gnc_item_list_key_event (GtkWidget *widget, GdkEventKey *event, gpointer data)
/* These go to the sheet */ /* These go to the sheet */
g_signal_stop_emission_by_name (G_OBJECT (widget), "key_press_event"); g_signal_stop_emission_by_name (G_OBJECT (widget), "key_press_event");
g_signal_emit_by_name (G_OBJECT (item_list), "key_press_event", event, &retval); g_signal_emit_by_name (G_OBJECT (item_list), "key_press_event", event,
&retval);
return retval; return retval;
} }
static void static void
gnc_item_list_class_init (GncItemListClass *item_list_class) gnc_item_list_class_init (GncItemListClass* item_list_class)
{ {
GObjectClass *object_class = G_OBJECT_CLASS (item_list_class); GObjectClass* object_class = G_OBJECT_CLASS (item_list_class);
gnc_item_list_parent_class = g_type_class_peek_parent (item_list_class); gnc_item_list_parent_class = g_type_class_peek_parent (item_list_class);
@ -349,7 +354,7 @@ gnc_item_list_class_init (GncItemListClass *item_list_class)
g_signal_new ("select_item", g_signal_new ("select_item",
G_OBJECT_CLASS_TYPE (object_class), G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST, G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GncItemListClass, select_item), G_STRUCT_OFFSET (GncItemListClass, select_item),
NULL, NULL, NULL, NULL,
g_cclosure_marshal_VOID__POINTER, g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_NONE, 1,
@ -359,7 +364,7 @@ gnc_item_list_class_init (GncItemListClass *item_list_class)
g_signal_new ("change_item", g_signal_new ("change_item",
G_OBJECT_CLASS_TYPE (object_class), G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST, G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GncItemListClass, change_item), G_STRUCT_OFFSET (GncItemListClass, change_item),
NULL, NULL, NULL, NULL,
g_cclosure_marshal_VOID__POINTER, g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_NONE, 1,
@ -369,7 +374,7 @@ gnc_item_list_class_init (GncItemListClass *item_list_class)
g_signal_new ("activate_item", g_signal_new ("activate_item",
G_OBJECT_CLASS_TYPE (object_class), G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_LAST, G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GncItemListClass, activate_item), G_STRUCT_OFFSET (GncItemListClass, activate_item),
NULL, NULL, NULL, NULL,
g_cclosure_marshal_VOID__POINTER, g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1, G_TYPE_NONE, 1,
@ -390,13 +395,13 @@ gnc_item_list_get_type (void)
{ {
static const GTypeInfo gnc_item_list_info = static const GTypeInfo gnc_item_list_info =
{ {
sizeof(GncItemListClass), sizeof (GncItemListClass),
NULL, NULL,
NULL, NULL,
(GClassInitFunc) gnc_item_list_class_init, (GClassInitFunc) gnc_item_list_class_init,
NULL, NULL,
NULL, NULL,
sizeof(GncItemList), sizeof (GncItemList),
0, 0,
(GInstanceInitFunc) gnc_item_list_init (GInstanceInitFunc) gnc_item_list_init
}; };
@ -411,40 +416,41 @@ gnc_item_list_get_type (void)
static void static void
tree_view_selection_changed (GtkTreeSelection *selection, tree_view_selection_changed (GtkTreeSelection* selection,
gpointer data) gpointer data)
{ {
GncItemList *item_list = GNC_ITEM_LIST (data); GncItemList* item_list = GNC_ITEM_LIST (data);
GtkTreeModel *model; GtkTreeModel* model;
GtkTreeIter iter; GtkTreeIter iter;
char *string; char* string;
g_return_if_fail(data); g_return_if_fail (data);
g_return_if_fail(selection); g_return_if_fail (selection);
if (!gtk_tree_selection_get_selected (selection, &model, &iter)) if (!gtk_tree_selection_get_selected (selection, &model, &iter))
return; return;
gtk_tree_model_get (model, &iter, 0, &string, -1); gtk_tree_model_get (model, &iter, 0, &string, -1);
g_signal_emit (G_OBJECT (item_list), gnc_item_list_signals[CHANGE_ITEM], 0, string); g_signal_emit (G_OBJECT (item_list), gnc_item_list_signals[CHANGE_ITEM], 0,
string);
g_free (string); g_free (string);
} }
GtkWidget * GtkWidget*
gnc_item_list_new(GtkListStore *list_store) gnc_item_list_new (GtkListStore* list_store)
{ {
GtkWidget *tree_view; GtkWidget* tree_view;
GtkWidget *scrollwin; GtkWidget* scrollwin;
GtkCellRenderer *renderer; GtkCellRenderer* renderer;
GtkTreeViewColumn *column; GtkTreeViewColumn* column;
GncItemList *item_list = GncItemList* item_list =
GNC_ITEM_LIST(g_object_new (GNC_TYPE_ITEM_LIST, GNC_ITEM_LIST (g_object_new (GNC_TYPE_ITEM_LIST,
NULL)); NULL));
scrollwin = gnc_scrolled_window_new (); scrollwin = gnc_scrolled_window_new();
gtk_container_add (GTK_CONTAINER (item_list), scrollwin); gtk_container_add (GTK_CONTAINER (item_list), scrollwin);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin), gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollwin),
@ -454,21 +460,22 @@ gnc_item_list_new(GtkListStore *list_store)
if (NULL == list_store) if (NULL == list_store)
list_store = gtk_list_store_new (1, G_TYPE_STRING); list_store = gtk_list_store_new (1, G_TYPE_STRING);
else else
g_object_ref(list_store); g_object_ref (list_store);
tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store)); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
g_object_unref(list_store); g_object_unref (list_store);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)), gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (
tree_view)),
GTK_SELECTION_BROWSE); GTK_SELECTION_BROWSE);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list_store), gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store),
0, GTK_SORT_ASCENDING); 0, GTK_SORT_ASCENDING);
renderer = gtk_cell_renderer_text_new (); renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes (_("List"), column = gtk_tree_view_column_new_with_attributes (_ ("List"),
renderer, renderer,
"text", 0, "text", 0,
NULL); NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
gtk_container_add (GTK_CONTAINER (scrollwin), tree_view); gtk_container_add (GTK_CONTAINER (scrollwin), tree_view);
@ -476,16 +483,17 @@ gnc_item_list_new(GtkListStore *list_store)
item_list->tree_view = GTK_TREE_VIEW (tree_view); item_list->tree_view = GTK_TREE_VIEW (tree_view);
item_list->list_store = list_store; item_list->list_store = list_store;
g_signal_connect (G_OBJECT(tree_view), "button_press_event", g_signal_connect (G_OBJECT (tree_view), "button_press_event",
G_CALLBACK (gnc_item_list_button_event), item_list); G_CALLBACK (gnc_item_list_button_event), item_list);
g_signal_connect (G_OBJECT (tree_view), "key_press_event", g_signal_connect (G_OBJECT (tree_view), "key_press_event",
G_CALLBACK (gnc_item_list_key_event), item_list); G_CALLBACK (gnc_item_list_key_event), item_list);
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view))), "changed", g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (
tree_view))), "changed",
G_CALLBACK (tree_view_selection_changed), item_list); G_CALLBACK (tree_view_selection_changed), item_list);
return GTK_WIDGET(item_list); return GTK_WIDGET (item_list);
} }