aherman
/
gnucash
mirror of https://github.com/Gnucash/gnucash
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use per-cell save handlers.

Browse Source 
git-svn-id: svn+ssh://svn.gnucash.org/repo/gnucash/trunk@6082 57a11ea4-9604-0410-9ed3-97b8803252fd
zzzoldfeatures/g2-gog-integ
Dave Peticolas 25 years ago
parent 53436822d2
commit 68006009cd
1 changed files with 410 additions and 269 deletions
Show Stats Download Patch File Download Diff File

679
src/register/ledger-core/split-register-model-save.c
Unescape View File

@ -39,6 +39,9 @@ struct sr_save_data
{
Transaction *trans;
Split *split;
gboolean handled_dc; /* We have already handled the debit/credit cells. */
gboolean do_scrub; /* Scrub other split at the end. */
};
/* This static indicates the debugging module that this .o belongs to. */
@ -94,378 +97,431 @@ gnc_split_register_save_due_date_cell (BasicCell * cell,
}
static void
gnc_split_register_save_cells (gpointer save_data,
gpointer user_data)
gnc_split_register_save_num_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
SRInfo *info = gnc_split_register_get_info (reg);
Transaction *trans;
Split *other_split = NULL;
Split *split;
const char *value;
g_return_if_fail (sd != NULL);
g_return_if_fail (gnc_basic_cell_has_name (cell, NUM_CELL));
value = gnc_basic_cell_get_value (cell);
DEBUG ("NUM: %s\n", value ? value : "(null)");
trans = sd->trans;
split = sd->split;
xaccTransSetNum (sd->trans, value);
if (gnc_table_layout_get_cell_changed (reg->table->layout, NUM_CELL, TRUE))
if (gnc_num_cell_set_last_num ((NumCell *) cell, value))
{
BasicCell *cell;
const char *value;
SRInfo *info = gnc_split_register_get_info (reg);
Split *blank_split = xaccSplitLookup (&info->blank_split_guid,
gnc_get_current_book ());
Transaction *blank_trans = xaccSplitGetParent (blank_split);
value = gnc_table_layout_get_cell_value (reg->table->layout, NUM_CELL);
if (sd->trans != blank_trans)
gnc_split_register_set_last_num (reg, gnc_basic_cell_get_value (cell));
}
}
DEBUG ("NUM: %s\n", value ? value : "(null)");
static void
gnc_split_register_save_desc_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
const char *value;
xaccTransSetNum (trans, value);
g_return_if_fail (gnc_basic_cell_has_name (cell, DESC_CELL));
cell = gnc_table_layout_get_cell (reg->table->layout, NUM_CELL);
value = gnc_basic_cell_get_value (cell);
if (gnc_num_cell_set_last_num ((NumCell *) cell, value))
{
SRInfo *info = gnc_split_register_get_info (reg);
Split *blank_split = xaccSplitLookup(&info->blank_split_guid,
gnc_get_current_book ());
Transaction *blank_trans = xaccSplitGetParent (blank_split);
DEBUG ("DESC: %s", value ? value : "(null)");
if (trans != blank_trans)
gnc_split_register_set_last_num (reg, gnc_basic_cell_get_value (cell));
}
}
xaccTransSetDescription (sd->trans, value);
}
if (gnc_table_layout_get_cell_changed (reg->table->layout, DESC_CELL, TRUE))
{
const char *value;
static void
gnc_split_register_save_notes_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
const char *value;
value = gnc_table_layout_get_cell_value (reg->table->layout, DESC_CELL);
g_return_if_fail (gnc_basic_cell_has_name (cell, NOTES_CELL));
DEBUG ("DESC: %s", value ? value : "(null)");
value = gnc_basic_cell_get_value (cell);
xaccTransSetDescription (trans, value);
}
DEBUG ("NOTES: %s", value ? value : "(null)");
if (gnc_table_layout_get_cell_changed (reg->table->layout, NOTES_CELL, TRUE))
{
const char *value;
xaccTransSetNotes (sd->trans, value);
}
value = gnc_table_layout_get_cell_value (reg->table->layout, NOTES_CELL);
static void
gnc_split_register_save_recn_cell (BasicCell * bcell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
RecnCell *cell = (RecnCell *) cell;
DEBUG ("NOTES: %s", value ? value : "(null)");
g_return_if_fail (gnc_basic_cell_has_name (bcell, RECN_CELL));
xaccTransSetNotes (trans, value);
}
DEBUG ("RECN: %c", gnc_recn_cell_get_flag (cell));
if (gnc_table_layout_get_cell_changed (reg->table->layout, RECN_CELL, TRUE))
{
RecnCell *cell;
xaccSplitSetReconcile (sd->split, gnc_recn_cell_get_flag (cell));
}
cell = (RecnCell *) gnc_table_layout_get_cell (reg->table->layout,
RECN_CELL);
static void
gnc_split_register_save_actn_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
const char *value;
DEBUG ("RECN: %c", gnc_recn_cell_get_flag (cell));
g_return_if_fail (gnc_basic_cell_has_name (cell, ACTN_CELL));
xaccSplitSetReconcile (split, gnc_recn_cell_get_flag (cell));
}
value = gnc_basic_cell_get_value (cell);
if (gnc_table_layout_get_cell_changed (reg->table->layout, ACTN_CELL, TRUE))
{
const char *value;
DEBUG ("ACTN: %s", value ? value : "(null)");
value = gnc_table_layout_get_cell_value (reg->table->layout, ACTN_CELL);
xaccSplitSetAction (sd->split, value);
}
DEBUG ("ACTN: %s", value ? value : "(null)");
static void
gnc_split_register_save_memo_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
const char *value;
xaccSplitSetAction (split, value);
}
g_return_if_fail (gnc_basic_cell_has_name (cell, MEMO_CELL));
if (gnc_table_layout_get_cell_changed (reg->table->layout, MEMO_CELL, TRUE))
{
const char *value;
value = gnc_basic_cell_get_value (cell);
value = gnc_table_layout_get_cell_value (reg->table->layout, MEMO_CELL);
DEBUG ("MEMO: %s", value ? value : "(null)");
DEBUG ("MEMO: %s", value ? value : "(null)");
xaccSplitSetMemo (sd->split, value);
}
xaccSplitSetMemo (split, value);
}
/* OK, the handling of transfers gets complicated because it depends
* on what was displayed to the user. For a multi-line display, we
* just reparent the indicated split. For a two-line display, we want
* to reparent the "other" split, but only if there is one. XFRM is
* the straight split, MXFRM is the mirrored split. */
static void
gnc_split_register_save_xfrm_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
Account *old_acc;
Account *new_acc;
/* -------------------------------------------------------------- */
/* OK, the handling of transfers gets complicated because it depends
* on what was displayed to the user. For a multi-line display, we
* just reparent the indicated split, its it, and that's that. For
* a two-line display, we want to reparent the "other" split, but
* only if there is one. XFRM is the straight split, MXFRM is the
* mirrored split. */
g_return_if_fail (gnc_basic_cell_has_name (cell, XFRM_CELL));
if (gnc_table_layout_get_cell_changed (reg->table->layout, XFRM_CELL, TRUE))
{
Account *old_acc;
Account *new_acc;
old_acc = xaccSplitGetAccount (sd->split);
old_acc = xaccSplitGetAccount (split);
new_acc = gnc_split_register_get_account (reg, XFRM_CELL);
new_acc = gnc_split_register_get_account (reg, XFRM_CELL);
if ((new_acc != NULL) && (old_acc != new_acc))
xaccAccountInsertSplit (new_acc, sd->split);
}
if ((new_acc != NULL) && (old_acc != new_acc))
xaccAccountInsertSplit (new_acc, split);
}
static void
gnc_split_register_save_mxfrm_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
Split * other_split;
g_return_if_fail (gnc_basic_cell_has_name (cell, MXFRM_CELL));
other_split = xaccSplitGetOtherSplit (sd->split);
if (reg->style == REG_STYLE_LEDGER && !info->trans_expanded)
other_split = xaccSplitGetOtherSplit (split);
/* other_split may be null for two very different reasons:
* (1) the parent transaction has three or more splits in it,
* and so the "other" split is ambiguous, and thus null.
* (2) the parent transaction has only this one split as a child.
* and "other" is null because there is no other.
*
* In the case (2), we want to create the other split, so that
* the user's request to transfer actually works out. */
if (gnc_table_layout_get_cell_changed (reg->table->layout, MXFRM_CELL, TRUE))
if (!other_split)
{
other_split = xaccSplitGetOtherSplit (split);
/* other_split may be null for two very different reasons:
* (1) the parent transaction has three or more splits in it,
* and so the "other" split is ambiguous, and thus null.
* (2) the parent transaction has only this one split as a child.
* and "other" is null because there is no other.
*
* In the case (2), we want to create the other split, so that
* the user's request to transfer actually works out.
*/
other_split = xaccTransGetSplit (sd->trans, 1);
if (!other_split)
{
other_split = xaccTransGetSplit (trans, 1);
if (!other_split)
{
other_split = xaccMallocSplit (gnc_get_current_book ());
xaccTransAppendSplit (trans, other_split);
}
other_split = xaccMallocSplit (gnc_get_current_book ());
xaccTransAppendSplit (sd->trans, other_split);
}
}
if (other_split)
{
Account *old_acc, *new_acc;
if (other_split)
{
Account *old_acc;
Account *new_acc;
/* do some reparenting. Insertion into new account will automatically
* delete from the old account */
old_acc = xaccSplitGetAccount (other_split);
new_acc = gnc_split_register_get_account (reg, MXFRM_CELL);
/* Do some reparenting. Insertion into new account
* will automatically delete from the old account. */
old_acc = xaccSplitGetAccount (other_split);
new_acc = gnc_split_register_get_account (reg, MXFRM_CELL);
if ((new_acc != NULL) && (old_acc != new_acc))
xaccAccountInsertSplit (new_acc, other_split);
}
if ((new_acc != NULL) && (old_acc != new_acc))
xaccAccountInsertSplit (new_acc, other_split);
}
}
if (gnc_table_layout_get_cell_changed (reg->table->layout, SHRS_CELL, TRUE))
{
PriceCell *cell;
gnc_numeric amount;
static void
gnc_split_register_save_shares_cell (BasicCell * bcell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
PriceCell *cell = (PriceCell *) cell;
gnc_numeric amount;
cell = (PriceCell *) gnc_table_layout_get_cell (reg->table->layout,
SHRS_CELL);
amount = gnc_price_cell_get_value (cell);
g_return_if_fail (gnc_basic_cell_has_name (bcell, SHRS_CELL));
DEBUG ("SHRS");
amount = gnc_price_cell_get_value (cell);
xaccSplitSetAmount (split, amount);
}
DEBUG ("SHRS");
if (gnc_table_layout_get_cell_changed (reg->table->layout, PRIC_CELL, TRUE))
{
PriceCell *cell;
gnc_numeric price;
xaccSplitSetAmount (sd->split, amount);
cell = (PriceCell *) gnc_table_layout_get_cell (reg->table->layout,
PRIC_CELL);
price = gnc_price_cell_get_value (cell);
sd->do_scrub = TRUE;
}
DEBUG ("PRIC");
static void
gnc_split_register_save_price_cell (BasicCell * bcell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
PriceCell *cell = (PriceCell *) cell;
gnc_numeric price;
xaccSplitSetSharePrice (split, price);
}
g_return_if_fail (gnc_basic_cell_has_name (bcell, PRIC_CELL));
if (gnc_table_layout_get_cell_changed (reg->table->layout,
DEBT_CELL, TRUE) ||
gnc_table_layout_get_cell_changed (reg->table->layout,
CRED_CELL, TRUE))
{
PriceCell *cell;
gnc_numeric new_amount;
gnc_numeric credit;
gnc_numeric debit;
price = gnc_price_cell_get_value (cell);
DEBUG ("PRIC");
cell = (PriceCell *) gnc_table_layout_get_cell (reg->table->layout,
CRED_CELL);
credit = gnc_price_cell_get_value (cell);
xaccSplitSetSharePrice (sd->split, price);
cell = (PriceCell *) gnc_table_layout_get_cell (reg->table->layout,
DEBT_CELL);
debit = gnc_price_cell_get_value (cell);
sd->do_scrub = TRUE;
}
new_amount = gnc_numeric_sub_fixed (debit, credit);
static void
gnc_split_register_save_debcred_cell (BasicCell * bcell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
PriceCell *cell;
gnc_numeric new_amount;
gnc_numeric credit;
gnc_numeric debit;
xaccSplitSetValue (split, new_amount);
}
g_return_if_fail (gnc_basic_cell_has_name (bcell, DEBT_CELL) ||
gnc_basic_cell_has_name (bcell, CRED_CELL));
if (gnc_table_layout_get_cell_changed (reg->table->layout,
DEBT_CELL, TRUE) ||
gnc_table_layout_get_cell_changed (reg->table->layout,
CRED_CELL, TRUE) ||
gnc_table_layout_get_cell_changed (reg->table->layout,
PRIC_CELL, TRUE) ||
gnc_table_layout_get_cell_changed (reg->table->layout,
SHRS_CELL, TRUE))
{
xaccSplitScrub (split);
if (sd->handled_dc)
return;
if (other_split)
{
gnc_numeric value = xaccSplitGetValue (split);
cell = (PriceCell *) gnc_table_layout_get_cell (reg->table->layout,
CRED_CELL);
credit = gnc_price_cell_get_value (cell);
value = gnc_numeric_neg (value);
cell = (PriceCell *) gnc_table_layout_get_cell (reg->table->layout,
DEBT_CELL);
debit = gnc_price_cell_get_value (cell);
xaccSplitSetValue (other_split, value);
new_amount = gnc_numeric_sub_fixed (debit, credit);
xaccSplitScrub (other_split);
}
}
xaccSplitSetValue (sd->split, new_amount);
sd->handled_dc = TRUE;
sd->do_scrub = TRUE;
}
static void
gnc_split_register_save_template_cells (gpointer save_data,
gpointer user_data)
gnc_split_register_save_cells (gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
SRInfo *info = gnc_split_register_get_info (reg);
Transaction *trans;
Split *split;
Split *other_split = NULL;
kvp_frame *kvpf;
AccountGroup *template_ag;
Account *template_acc;
kvp_value *tag_val;
BasicCell *cell;
DEBUG (" ");
Split *other_split;
g_return_if_fail (sd != NULL);
trans = sd->trans;
split = sd->split;
if (!sd->do_scrub)
return;
template_acc = xaccAccountLookup (&info->template_account,
gnc_get_current_book ());
other_split = xaccSplitGetOtherSplit (sd->split);
xaccSplitScrub (sd->split);
if (gnc_table_layout_get_cell_changed (reg->table->layout,
DATE_CELL, TRUE) ||
gnc_table_layout_get_cell_changed (reg->table->layout,
DDUE_CELL, TRUE) ||
gnc_table_layout_get_cell_changed (reg->table->layout,
NUM_CELL, TRUE) ||
gnc_table_layout_get_cell_changed (reg->table->layout,
RECN_CELL, TRUE))
if (other_split)
{
PERR( "unexpected changed fields in a template register\n" );
gnc_numeric value = xaccSplitGetValue (sd->split);
value = gnc_numeric_neg (value);
xaccSplitSetValue (other_split, value);
xaccSplitScrub (other_split);
}
}
static void
gnc_template_register_save_unexpected_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
PERR ("unexpected changed fields in a template register");
}
static void
gnc_template_register_save_xfrm_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
SRInfo *info = gnc_split_register_get_info (reg);
Account *template_acc;
const GUID *acctGUID;
kvp_frame *kvpf;
Account *acct;
g_return_if_fail (gnc_basic_cell_has_name (cell, XFRM_CELL));
/* We'll be using the Split's KVP frame a lot */
kvpf = xaccSplitGetSlots (split);
kvpf = xaccSplitGetSlots (sd->split);
if (gnc_table_layout_get_cell_changed (reg->table->layout, XFRM_CELL, TRUE))
/* save the account GUID into the kvp_data. */
acct = gnc_split_register_get_account (reg, XFRM_CELL);
if (!acct)
{
Account *acct;
const GUID *acctGUID;
PERR ("unknown account");
return;
}
/* save the account GUID into the kvp_data. */
acct = gnc_split_register_get_account (reg, XFRM_CELL);
if (!acct)
{
PERR ("unknown account");
return;
}
acctGUID = xaccAccountGetGUID (acct);
acctGUID = xaccAccountGetGUID (acct);
kvp_frame_set_slot_path (kvpf, kvp_value_new_guid(acctGUID),
GNC_SX_ID, GNC_SX_ACCOUNT, NULL);
kvp_frame_set_slot_path (kvpf, kvp_value_new_guid(acctGUID),
GNC_SX_ID, GNC_SX_ACCOUNT, NULL);
kvpf = xaccSplitGetSlots (sd->split);
kvpf = xaccSplitGetSlots (split);
template_acc = xaccAccountLookup (&info->template_account,
gnc_get_current_book ());
cell = gnc_table_layout_get_cell (reg->table->layout, XFRM_CELL);
gnc_basic_cell_set_changed (cell, FALSE);
/* set the actual account to the fake account for these templates */
xaccAccountInsertSplit (template_acc, sd->split);
}
/* set the actual account to the fake account for these templates */
xaccAccountInsertSplit (template_acc, split);
}
static void
gnc_template_register_save_mxfrm_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
}
if ( gnc_table_layout_get_cell_changed (reg->table->layout,
MXFRM_CELL, TRUE) )
{
DEBUG( "Template: Got MXFRM changed\n" );
static void
gnc_template_register_save_debcred_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
kvp_frame *kvpf;
const char *value;
gnc_numeric new_amount;
gnc_numeric credit;
gnc_numeric debit;
cell = gnc_table_layout_get_cell (reg->table->layout, MXFRM_CELL);
gnc_basic_cell_set_changed (cell, FALSE);
}
g_return_if_fail (gnc_basic_cell_has_name (cell, FDEBT_CELL) ||
gnc_basic_cell_has_name (cell, FCRED_CELL));
if (gnc_table_layout_get_cell_changed (reg->table->layout,
FCRED_CELL, TRUE) ||
gnc_table_layout_get_cell_changed (reg->table->layout,
FDEBT_CELL, TRUE))
{
const char *value;
char *amountStr = "x + y/42";
gnc_numeric new_amount;
gnc_numeric credit;
gnc_numeric debit;
if (sd->handled_dc)
return;
DEBUG ("kvp_frame before: %s\n", kvp_frame_to_string (kvpf));
kvpf = xaccSplitGetSlots (sd->split);
/* amountStr = gnc_numeric_to_string( new_amount ); */
DEBUG ("kvp_frame before: %s\n", kvp_frame_to_string (kvpf));
value = gnc_table_layout_get_cell_value (reg->table->layout, FCRED_CELL);
kvp_frame_set_slot_path( kvpf,kvp_value_new_string( value ),
GNC_SX_ID,
GNC_SX_CREDIT_FORMULA,
NULL);
/* amountStr = gnc_numeric_to_string (new_amount); */
value = gnc_table_layout_get_cell_value (reg->table->layout, FDEBT_CELL);
value = gnc_table_layout_get_cell_value (reg->table->layout, FCRED_CELL);
kvp_frame_set_slot_path (kvpf, kvp_value_new_string (value),
GNC_SX_ID,
GNC_SX_CREDIT_FORMULA,
NULL);
kvp_frame_set_slot_path( kvpf,
kvp_value_new_string( value ),
GNC_SX_ID,
GNC_SX_DEBIT_FORMULA,
NULL);
value = gnc_table_layout_get_cell_value (reg->table->layout, FDEBT_CELL);
DEBUG( "kvp_frame after: %s\n", kvp_frame_to_string( kvpf ) );
kvp_frame_set_slot_path (kvpf,
kvp_value_new_string (value),
GNC_SX_ID,
GNC_SX_DEBIT_FORMULA,
NULL);
/* set the amount to an innocuous value */
xaccSplitSetValue (split, gnc_numeric_create(0, 1) );
}
DEBUG ("kvp_frame after: %s\n", kvp_frame_to_string (kvpf));
if (gnc_table_layout_get_cell_changed (reg->table->layout,
SHRS_CELL, TRUE))
{
char *sharesStr = "(x + y)/42";
/* set the amount to an innocuous value */
xaccSplitSetValue (sd->split, gnc_numeric_create (0, 1));
sd->handled_dc = TRUE;
}
static void
gnc_template_register_save_shares_cell (BasicCell * cell,
gpointer save_data,
gpointer user_data)
{
SRSaveData *sd = save_data;
SplitRegister *reg = user_data;
kvp_frame *kvpf;
char *sharesStr = "(x + y)/42";
/* FIXME: shares cells are numeric by definition. */
DEBUG ("kvp_frame before: %s\n", kvp_frame_to_string (kvpf));
g_return_if_fail (gnc_basic_cell_has_name (cell, SHRS_CELL));
/* sharesStr = gnc_numeric_to_string( sharesStr ); */
kvp_frame_set_slot_path( kvpf,
kvp_value_new_string( sharesStr ),
GNC_SX_ID,
GNC_SX_SHARES,
NULL);
kvpf = xaccSplitGetSlots (sd->split);
DEBUG( "kvp_frame after: %s\n", kvp_frame_to_string( kvpf ) );
/* FIXME: shares cells are numeric by definition. */
DEBUG ("kvp_frame before: %s\n", kvp_frame_to_string (kvpf));
/* set the shares to an innocuous value */
xaccSplitSetSharePriceAndAmount (split,
gnc_numeric_create(0, 1),
gnc_numeric_create(0, 1));
/* sharesStr = gnc_numeric_to_string( sharesStr ); */
kvp_frame_set_slot_path (kvpf,
kvp_value_new_string (sharesStr),
GNC_SX_ID,
GNC_SX_SHARES,
NULL);
cell = gnc_table_layout_get_cell (reg->table->layout, SHRS_CELL);
gnc_basic_cell_set_changed (cell, FALSE);
}
DEBUG ("kvp_frame after: %s\n", kvp_frame_to_string (kvpf));
gnc_split_register_save_cells (save_data, user_data);
/* set the shares to an innocuous value */
xaccSplitSetSharePriceAndAmount (sd->split,
gnc_numeric_create (0, 1),
gnc_numeric_create (0, 1));
}
void
@ -481,6 +537,54 @@ gnc_split_register_model_add_save_handlers (TableModel *model)
gnc_split_register_save_due_date_cell,
DDUE_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_num_cell,
NUM_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_desc_cell,
DESC_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_notes_cell,
NOTES_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_recn_cell,
RECN_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_actn_cell,
ACTN_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_memo_cell,
MEMO_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_xfrm_cell,
XFRM_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_mxfrm_cell,
MXFRM_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_shares_cell,
SHRS_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_price_cell,
PRIC_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_debcred_cell,
DEBT_CELL);
gnc_table_model_set_save_handler (model,
gnc_split_register_save_debcred_cell,
CRED_CELL);
gnc_table_model_set_post_save_handler (model, gnc_split_register_save_cells);
}
@ -489,8 +593,43 @@ gnc_template_register_model_add_save_handlers (TableModel *model)
{
g_return_if_fail (model != NULL);
gnc_table_model_set_post_save_handler
(model, gnc_split_register_save_template_cells);
gnc_split_register_model_add_save_handlers (model);
gnc_table_model_set_save_handler (model,
gnc_template_register_save_unexpected_cell,
DATE_CELL);
gnc_table_model_set_save_handler (model,
gnc_template_register_save_unexpected_cell,
DDUE_CELL);
gnc_table_model_set_save_handler (model,
gnc_template_register_save_unexpected_cell,
NUM_CELL);
gnc_table_model_set_save_handler (model,
gnc_template_register_save_unexpected_cell,
DESC_CELL);
gnc_table_model_set_save_handler (model,
gnc_template_register_save_xfrm_cell,
XFRM_CELL);
gnc_table_model_set_save_handler (model,
gnc_template_register_save_mxfrm_cell,
MXFRM_CELL);
gnc_table_model_set_save_handler (model,
gnc_template_register_save_debcred_cell,
FDEBT_CELL);
gnc_table_model_set_save_handler (model,
gnc_template_register_save_debcred_cell,
FCRED_CELL);
gnc_table_model_set_save_handler (model,
gnc_template_register_save_shares_cell,
SHRS_CELL);
}
SRSaveData *
@ -505,6 +644,8 @@ gnc_split_register_save_data_new (Transaction *trans, Split *split)
sd->trans = trans;
sd->split = split;
sd->handled_dc = FALSE;
sd->do_scrub = FALSE;
return sd;
}

Write Preview
Loading…
Cancel
Save