Split Register

GnuCash-specific ledger and journal displays based on RegisterCore. More...

Files
file	split-register-control.h
	TableControl specialized for the SplitRegister.
file	split-register-layout.h
	Create the actual register visual layout.
file	split-register-model-save.h
	Save handlers for the SplitRegister Model and Template SplitRegister model.
file	split-register-model.h
	TableModels specialized for SplitRegister and template SplitRegister.
file	split-register-p.h
	private declarations for SplitRegister
file	split-register.h
	API for checkbook register display area.

Data Structures
struct	SRInfo
struct	SplitRegister
	The type, style and table for the register. More...

Macros
#define	SPLIT_TRANS_STR   _("-- Split Transaction --")
#define	STOCK_SPLIT_STR   _("-- Stock Split --")
#define	ACTION_BUY_STR   _("Buy")
#define	ACTION_SELL_STR   _("Sell")

Typedefs
typedef GtkWidget *(*	SRGetParentCallback) (gpointer user_data)
	Callback function type.

Enumerations
enum	RateReset_t { RATE_RESET_NOT_REQD = 0, RATE_RESET_REQD = 1, RATE_RESET_DONE = 2 }
enum	SplitRegisterType {   BANK_REGISTER, CASH_REGISTER, ASSET_REGISTER, CREDIT_REGISTER,   LIABILITY_REGISTER, INCOME_REGISTER, EXPENSE_REGISTER, EQUITY_REGISTER,   STOCK_REGISTER, CURRENCY_REGISTER, RECEIVABLE_REGISTER, PAYABLE_REGISTER,   TRADING_REGISTER, NUM_SINGLE_REGISTER_TYPES, GENERAL_JOURNAL = NUM_SINGLE_REGISTER_TYPES, INCOME_LEDGER,   PORTFOLIO_LEDGER, SEARCH_LEDGER, NUM_REGISTER_TYPES }
	Register types. More...
enum	SplitRegisterTypeGroup {   REG_TYPE_GROUP_UNKNOWN, REG_TYPE_GROUP_CURRENCY, REG_TYPE_GROUP_APAR, REG_TYPE_GROUP_STOCK,   REG_TYPE_GROUP_JOURNAL, REG_TYPE_GROUP_PORTFOLIO }
	Register group types. More...
enum	SplitRegisterStyle { REG_STYLE_LEDGER, REG_STYLE_AUTO_LEDGER, REG_STYLE_JOURNAL }
	Register styles.
enum	CursorClass { CURSOR_CLASS_NONE = -1, CURSOR_CLASS_SPLIT, CURSOR_CLASS_TRANS, NUM_CURSOR_CLASSES }
	Types of cursors.

Functions
TableControl *	gnc_split_register_control_new (void)
	Create a new TableControl specialized for the SplitRegister. More...
TableLayout *	gnc_split_register_layout_new (SplitRegister *reg)
	Generate the split register layout. More...
void	gnc_split_register_model_add_save_handlers (TableModel *model)
void	gnc_template_register_model_add_save_handlers (TableModel *model)
SRSaveData *	gnc_split_register_save_data_new (Transaction *trans, Split *split, gboolean expanded)
void	gnc_split_register_save_data_destroy (SRSaveData *sd)
TableModel *	gnc_split_register_model_new (void)
TableModel *	gnc_template_register_model_new (void)
SRInfo *	gnc_split_register_get_info (SplitRegister *reg)
GtkWidget *	gnc_split_register_get_parent (SplitRegister *reg)
Split *	gnc_split_register_get_split (SplitRegister *reg, VirtualCellLocation vcell_loc)
Account *	gnc_split_register_get_default_account (SplitRegister *reg)
Transaction *	gnc_split_register_get_trans (SplitRegister *reg, VirtualCellLocation vcell_loc)
Split *	gnc_split_register_get_trans_split (SplitRegister *reg, VirtualCellLocation vcell_loc, VirtualCellLocation *trans_split_loc)
gboolean	gnc_split_register_find_split (SplitRegister *reg, Transaction *trans, Split *trans_split, Split *split, CursorClass cursor_class, VirtualCellLocation *vcell_loc)
void	gnc_split_register_show_trans (SplitRegister *reg, VirtualCellLocation start_loc)
void	gnc_split_register_set_trans_visible (SplitRegister *reg, VirtualCellLocation vcell_loc, gboolean visible, gboolean only_blank_split)
	Set the visibility of the split rows belonging to a transaction located at vcell_loc. More...
void	gnc_split_register_set_cell_fractions (SplitRegister *reg, Split *split)
CellBlock *	gnc_split_register_get_passive_cursor (SplitRegister *reg)
CellBlock *	gnc_split_register_get_active_cursor (SplitRegister *reg)
void	gnc_split_register_set_last_num (SplitRegister *reg, const char *num)
Account *	gnc_split_register_get_account_by_name (SplitRegister *reg, BasicCell *cell, const char *name)
Account *	gnc_split_register_get_account (SplitRegister *reg, const char *cell_name)
gboolean	gnc_split_register_recn_cell_confirm (char old_flag, gpointer data)
gboolean	gnc_split_register_check_cell (SplitRegister *reg, const char *cell_name)
CursorClass	gnc_split_register_cursor_name_to_class (const char *cursor_name)
gnc_numeric	gnc_split_register_debcred_cell_value (SplitRegister *reg)
gboolean	gnc_split_reg_has_rate_cell (SplitRegisterType type)
	Determine if we need to perform any conversion on the splits in this transaction, and if so, what conversion we need.
gboolean	gnc_split_register_split_needs_amount (SplitRegister *reg, Split *split)
gboolean	gnc_split_register_needs_conv_rate (SplitRegister *reg, Transaction *txn, Account *acc)
SplitRegister *	gnc_split_register_new (SplitRegisterType type, SplitRegisterStyle style, gboolean use_double_line, gboolean is_template, gboolean mismatched_commodities)
	Creates a new split register. More...
void	gnc_split_register_destroy (SplitRegister *reg)
	Destroys a split register. More...
void	gnc_split_register_config (SplitRegister *reg, SplitRegisterType type, SplitRegisterStyle style, gboolean use_double_line)
	Sets a split register's type, style or line use. More...
void	gnc_split_register_set_reverse_sort (SplitRegister *reg, gboolean reverse_sort)
	Sets a split register's reverse sort order based on register. More...
void	gnc_split_register_set_auto_complete (SplitRegister *reg, gboolean do_auto_complete)
	Sets whether a register uses auto-completion. More...
void	gnc_split_register_set_read_only (SplitRegister *reg, gboolean read_only)
	Sets whether a register window is "read only". More...
SplitRegisterTypeGroup	gnc_split_register_get_register_group (SplitRegister *reg)
	Group registers for common layouts. More...
void	gnc_split_register_set_template_account (SplitRegister *reg, Account *template_account)
	Set the template account for use in a template register. More...
void	gnc_split_register_set_data (SplitRegister *reg, gpointer user_data, SRGetParentCallback get_parent)
	Sets the user data and callback hooks for the register. More...
CursorClass	gnc_split_register_get_current_cursor_class (SplitRegister *reg)
	Returns the class of a register's current cursor. More...
CursorClass	gnc_split_register_get_cursor_class (SplitRegister *reg, VirtualCellLocation vcell_loc)
	Returns the class of the cursor at the given virtual cell location. More...
Transaction *	gnc_split_register_get_current_trans (SplitRegister *reg)
	Gets the transaction at the current cursor location, which may be on the transaction itself or on any of its splits. More...
Split *	gnc_split_register_get_current_trans_split (SplitRegister *reg, VirtualCellLocation *vcell_loc)
	Gets the anchoring split of the transaction at the current cursor location, which may be on the transaction itself or on any of its splits. More...
Split *	gnc_split_register_get_current_split (SplitRegister *reg)
	Returns the split at which the cursor is currently located. More...
Split *	gnc_split_register_get_blank_split (SplitRegister *reg)
	Gets the blank split for a register. More...
gboolean	gnc_split_register_get_split_virt_loc (SplitRegister *reg, Split *split, VirtualCellLocation *vcell_loc)
	Searches the split register for a given split. More...
gboolean	gnc_split_register_get_split_amount_virt_loc (SplitRegister *reg, Split *split, VirtualLocation *virt_loc)
	Searches the split register for the given split and determines the location of either its credit (if non-zero) or debit cell. More...
Split *	gnc_split_register_duplicate_current (SplitRegister *reg)
	Duplicates either the current transaction or the current split depending on the register mode and cursor position. More...
void	gnc_split_register_copy_current (SplitRegister *reg)
	Makes a copy of the current entity, either a split or a transaction, so that it can be pasted later. More...
void	gnc_split_register_cut_current (SplitRegister *reg)
	Equivalent to copying the current entity and the deleting it with the appropriate delete method. More...
void	gnc_split_register_paste_current (SplitRegister *reg)
	Pastes a previous copied entity onto the current entity, but only if the copied and current entity have the same type. More...
void	gnc_split_register_delete_current_split (SplitRegister *reg)
	Deletes the split associated with the current cursor, if both are non-NULL. More...
void	gnc_split_register_delete_current_trans (SplitRegister *reg)
	Deletes the transaction associated with the current cursor, if both are non-NULL. More...
void	gnc_split_register_void_current_trans (SplitRegister *reg, const char *reason)
	Voids the transaction associated with the current cursor, if non-NULL. More...
void	gnc_split_register_unvoid_current_trans (SplitRegister *reg)
	Unvoids the transaction associated with the current cursor, if non-NULL. More...
void	gnc_split_register_empty_current_trans_except_split (SplitRegister *reg, Split *split)
	Deletes the non-transaction splits associated with the current cursor, if both are non-NULL. More...
void	gnc_split_register_empty_current_trans (SplitRegister *reg)
void	gnc_split_register_cancel_cursor_split_changes (SplitRegister *reg)
	Cancels any changes made to the current cursor, reloads the cursor from the engine, reloads the table from the cursor, and updates the GUI. More...
void	gnc_split_register_cancel_cursor_trans_changes (SplitRegister *reg)
	Cancels any changes made to the current pending transaction, reloads the table from the engine, and updates the GUI. More...
void	gnc_split_register_load (SplitRegister *reg, GList *slist, Account *default_account)
	Populates the rows of a register. More...
gboolean	gnc_split_register_save (SplitRegister *reg, gboolean do_commit)
	Copy the contents of the current cursor to a split. More...
void	gnc_split_register_redraw (SplitRegister *reg)
	Causes a redraw of the register window associated with reg. More...
gboolean	gnc_split_register_changed (SplitRegister *reg)
	Returns TRUE if the register has changed cells. More...
void	gnc_split_register_show_present_divider (SplitRegister *reg, gboolean show_present)
	If TRUE, visually indicate the demarcation between splits with post dates prior to the present, and after. More...
void	gnc_split_register_expand_current_trans (SplitRegister *reg, gboolean expand)
	Expand the current transaction if it is collapsed. More...
void	gnc_split_register_collapse_current_trans (SplitRegister *reg)
	Mark the current transaction as collapsed, and do callbacks. More...
gboolean	gnc_split_register_current_trans_expanded (SplitRegister *reg)
	Return TRUE if current trans is expanded and style is REG_STYLE_LEDGER. More...
const char *	gnc_split_register_get_debit_string (SplitRegister *reg)
	Return the debit string used in the register. More...
const char *	gnc_split_register_get_credit_string (SplitRegister *reg)
	Return the credit string used in the register. More...
gboolean	gnc_split_register_is_blank_split (SplitRegister *reg, Split *split)
	Return TRUE if split is the blank_split. More...
void	gnc_split_register_change_blank_split_ref (SplitRegister *reg, Split *split)
	Change the blank_split reference from pointing to split to another split of the transaction. More...
gboolean	gnc_split_register_handle_exchange (SplitRegister *reg, gboolean force_dialog)
	Pop up the exchange-rate dialog, maybe, for the current split. More...
gboolean	gnc_split_register_begin_edit_or_warn (SRInfo *info, Transaction *trans)

Cell Names
T* cells are transaction summary cells
#define	ACTN_CELL   "action"
#define	DOCLINK_CELL   "doclink"
#define	BALN_CELL   "balance"
#define	CRED_CELL   "credit"
#define	DATE_CELL   "date"
#define	DDUE_CELL   "date-due"
#define	DEBT_CELL   "debit"
#define	DESC_CELL   "description"
#define	FCRED_CELL   "credit-formula"
#define	FDEBT_CELL   "debit-formula"
#define	MEMO_CELL   "memo"
#define	MXFRM_CELL   "transfer"
#define	NOTES_CELL   "notes"
#define	NUM_CELL   "num"
#define	TNUM_CELL   "trans-num"
#define	PRIC_CELL   "price"
#define	RATE_CELL   "exchrate"
#define	RECN_CELL   "reconcile"
#define	SHRS_CELL   "shares"
#define	TBALN_CELL   "trans-balance"
#define	TCRED_CELL   "trans-credit"
#define	TDEBT_CELL   "trans-debit"
#define	TSHRS_CELL   "trans-shares"
#define	TYPE_CELL   "split-type"
#define	XFRM_CELL   "account"
#define	VNOTES_CELL   "void-notes"
#define	RBALN_CELL   "reg-run-balance"

Cursor Names
Cursors ending in 'NUM_ACTN' use the split action field for the NUM_CELL rather than the transaction number field which is shown in the TNUM_CELL
#define	CURSOR_SINGLE_LEDGER   "cursor-single-ledger"
#define	CURSOR_DOUBLE_LEDGER   "cursor-double-ledger"
#define	CURSOR_DOUBLE_LEDGER_NUM_ACTN   "cursor-double-ledger-num-actn"
#define	CURSOR_SINGLE_JOURNAL   "cursor-single-journal"
#define	CURSOR_DOUBLE_JOURNAL   "cursor-double-journal"
#define	CURSOR_DOUBLE_JOURNAL_NUM_ACTN   "cursor-double-journal-num-actn"
#define	CURSOR_SPLIT   "cursor-split"

Detailed Description

GnuCash-specific ledger and journal displays based on RegisterCore.

The split register is a spreadsheet-like area that looks like a checkbook register. It displays transactions and allows the user to edit them in-place. The register does not contain any of the other window decorations that one might want to have for a free standing window (e.g. menubars, * toolbars, etc.)

The layout of the register is configurable. There's a broad variety of cell types to choose from: date cells that know how to parse dates, price cells that know how to parse prices, etc. These cells can be laid out in any column; even a multi-row layout is supported. The name "split register" is derived from the fact that this register can display multiple rows of transaction splits underneath a transaction title/summary row.

An area for entering new transactions is provided at the bottom of the register.

All user input to the register is handled by the 'cursor', which is mapped onto one of the displayed rows.

Design Notes.

Some notes about the "blank split":
Q: What is the "blank split"?
A: A new, empty split appended to the bottom of the ledger window. The blank split provides an area where the user can type in new split/transaction info. The "blank split" is treated in a special way for a number of reasons:

• it must always appear as the bottom-most split in the Ledger window,
• it must be committed if the user edits it, and a new blank split must be created.
• it must be deleted when the ledger window is closed.

To implement the above, the register "user_data" is used to store an SRInfo structure containing the blank split.

Some notes on Commit/Rollback:

There's an engine component and a gui component to the commit/rollback scheme. On the engine side, one must always call BeginEdit() before starting to edit a transaction. When you think you're done, you can call CommitEdit() to commit the changes, or RollbackEdit() to go back to how things were before you started the edit. Think of it as a one-shot mega-undo for that transaction.

Note that the query engine uses the original values, not the currently edited values, when performing a sort. This allows your to e.g. edit the date without having the transaction hop around in the gui while you do it.

On the gui side, commits are now performed on a per-transaction basis, rather than a per-split (per-journal-entry) basis. This means that if you have a transaction with a lot of splits in it, you can edit them all you want without having to commit one before moving to the next.

Similarly, the "cancel" button will now undo the changes to all of the lines in the transaction display, not just to one line (one split) at a time.

Some notes on Reloads & Redraws:

Reloads and redraws tend to be heavyweight. We try to use change flags as much as possible in this code, but imagine the following scenario:

Create two bank accounts. Transfer money from one to the other. Open two registers, showing each account. Change the amount in one window. Note that the other window also redraws, to show the new correct amount.

Since you changed an amount value, potentially all displayed balances change in both register windows (as well as the ledger balance in the main window). Three or more windows may be involved if you have e.g. windows open for bank, employer, taxes and your entering a paycheck (or correcting a typo in an old paycheck). Changing a date might even cause all entries in all three windows to be re-ordered.

The only thing I can think of is a bit stored with every table entry, stating 'this entry has changed since lst time, redraw it'. But that still doesn't avoid the overhead of reloading the table from the engine.

The Register itself is independent of GnuCash, and is designed so that it can be used with other applications. The Ledger is an adaptation of the Register for use by GnuCash. The Ledger sets up an explicit visual layout, putting certain types of cells in specific locations (e.g. date on left, summary in middle, value at right), and hooks up these cells to the various GnuCash financial objects.

This code is also theoretically independent of the actual GUI toolkit/widget-set (it once worked with both Motif and Gnome). The actual GUI-toolkit specific code is supposed to be in a GUI portability layer. Over the years, some gnome-isms may have snuck in; these should also be cleaned up.

Enumeration Type Documentation

SplitRegisterType

enum SplitRegisterType

Register types.

"registers" are single-account display windows. "ledgers" are multiple-account display windows

Definition at line 145 of file split-register.h.

{
    BANK_REGISTER,
    CASH_REGISTER,
    ASSET_REGISTER,
    CREDIT_REGISTER,
    LIABILITY_REGISTER,
    INCOME_REGISTER,
    EXPENSE_REGISTER,
    EQUITY_REGISTER,
    STOCK_REGISTER,
    CURRENCY_REGISTER,
    RECEIVABLE_REGISTER,
    PAYABLE_REGISTER,
    TRADING_REGISTER,
    NUM_SINGLE_REGISTER_TYPES,

    GENERAL_JOURNAL = NUM_SINGLE_REGISTER_TYPES,
    INCOME_LEDGER,
    PORTFOLIO_LEDGER,
    SEARCH_LEDGER,

    NUM_REGISTER_TYPES
} SplitRegisterType;

SplitRegisterTypeGroup

enum SplitRegisterTypeGroup

Register group types.

used for grouping registers that have the same layout

Definition at line 173 of file split-register.h.

{
    REG_TYPE_GROUP_UNKNOWN,
    REG_TYPE_GROUP_CURRENCY,
    REG_TYPE_GROUP_APAR,
    REG_TYPE_GROUP_STOCK,
    REG_TYPE_GROUP_JOURNAL,
    REG_TYPE_GROUP_PORTFOLIO,
} SplitRegisterTypeGroup;

Function Documentation

gnc_split_register_cancel_cursor_split_changes()

void gnc_split_register_cancel_cursor_split_changes

(

SplitRegister *

reg

)

Cancels any changes made to the current cursor, reloads the cursor from the engine, reloads the table from the cursor, and updates the GUI.

The change flags are cleared.

Definition at line 1423 of file split-register.c.

{
    VirtualLocation virt_loc;

    if (reg == NULL)
        return;

    virt_loc = reg->table->current_cursor_loc;

    if (!gnc_table_current_cursor_changed (reg->table, FALSE))
        return;

    /* We're just cancelling the current split here, not the transaction.
     * When cancelling edits, reload the cursor from the transaction. */
    gnc_table_clear_current_cursor_changes (reg->table);

    if (gnc_table_find_close_valid_cell (reg->table, &virt_loc, FALSE))
        gnc_table_move_cursor_gui (reg->table, virt_loc);

    gnc_table_refresh_gui (reg->table, TRUE);
}

gnc_split_register_cancel_cursor_trans_changes()

void gnc_split_register_cancel_cursor_trans_changes

(

SplitRegister *

reg

)

Cancels any changes made to the current pending transaction, reloads the table from the engine, and updates the GUI.

The change flags are cleared.

Definition at line 1446 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    Transaction* pending_trans, *blank_trans;
    gboolean refresh_all = FALSE;

    pending_trans = xaccTransLookup (&info->pending_trans_guid,
                                     gnc_get_current_book ());

    blank_trans = xaccSplitGetParent (gnc_split_register_get_blank_split (reg));

    if (pending_trans == blank_trans)
        refresh_all = TRUE;

    /* Get the currently open transaction, rollback the edits on it, and
     * then repaint everything. To repaint everything, make a note of
     * all of the accounts that will be affected by this rollback. */
    if (!xaccTransIsOpen (pending_trans))
    {
        gnc_split_register_cancel_cursor_split_changes (reg);
        return;
    }

    if (!pending_trans)
        return;

    gnc_suspend_gui_refresh ();

    xaccTransRollbackEdit (pending_trans);

    info->pending_trans_guid = *guid_null ();

    gnc_resume_gui_refresh ();

    if (refresh_all)
        gnc_gui_refresh_all ();  // force a refresh of all registers
    else
        gnc_split_register_redraw (reg);
}

gnc_split_register_change_blank_split_ref()

void gnc_split_register_change_blank_split_ref	(	SplitRegister *	reg,
		Split *	split
	)

Change the blank_split reference from pointing to split to another split of the transaction.

This is used when deleting a split after an autocomplete as the blank_split reference will be pointing to one of the splits so it does not cancel the whole transaction

Definition at line 1121 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    Split* current_blank_split = xaccSplitLookup (&info->blank_split_guid,
                                                  gnc_get_current_book ());
    Split* pref_split = NULL; // has the same account as incoming split
    Split* other_split = NULL; // other split
    Account* blank_split_account = xaccSplitGetAccount (current_blank_split);
    Transaction* trans = xaccSplitGetParent (split);

    // loop through splitlist looking for splits other than the blank_split
    for (GList *n = xaccTransGetSplitList (trans); n; n = n->next)
    {
        Split *s = n->data;
        if (s != current_blank_split)
        {
            if (blank_split_account == xaccSplitGetAccount (s))
                pref_split = s;  // prefer same account
            else
                other_split = s; // any other split
        }
    }
    // now change the saved blank split reference
    if (pref_split != NULL)
        info->blank_split_guid = *xaccSplitGetGUID (pref_split);
    else if (other_split != NULL)
        info->blank_split_guid = *xaccSplitGetGUID (other_split);
}

gnc_split_register_changed()

gboolean gnc_split_register_changed

(

SplitRegister *

reg

)

Returns TRUE if the register has changed cells.

Definition at line 2481 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    Transaction* pending_trans;

    ENTER ("reg=%p", reg);

    if (reg == NULL)
    {
        LEAVE ("no register");
        return FALSE;
    }

    if (gnc_table_current_cursor_changed (reg->table, FALSE))
    {
        LEAVE ("cursor changed");
        return TRUE;
    }

    pending_trans = xaccTransLookup (&info->pending_trans_guid,
                                     gnc_get_current_book ());
    if (xaccTransIsOpen (pending_trans))
    {
        LEAVE ("open and pending txn");
        return TRUE;
    }

    LEAVE ("register unchanged");
    return FALSE;
}

gnc_split_register_collapse_current_trans()

void gnc_split_register_collapse_current_trans

(

SplitRegister *

reg

)

Mark the current transaction as collapsed, and do callbacks.

gnc_split_register_config()

void gnc_split_register_config	(	SplitRegister *	reg,
		SplitRegisterType	type,
		SplitRegisterStyle	style,
		gboolean	use_double_line
	)

Sets a split register's type, style or line use.

Parameters

reg	a ::SplitRegister
type	a SplitRegisterType to use for the register
style	a SplitRegisterStyle to use for the register
use_double_line	TRUE to show two lines for transactions, FALSE for one

Definition at line 2924 of file split-register.c.

{
    if (!reg) return;

    /* If shrinking the transaction split, put the cursor on the first row of the trans */
    if (reg->use_double_line && !use_double_line)
    {
        VirtualLocation virt_loc = reg->table->current_cursor_loc;
        if (gnc_table_find_close_valid_cell (reg->table, &virt_loc, FALSE))
        {
            if (virt_loc.phys_row_offset)
            {
                gnc_table_move_vertical_position (reg->table, &virt_loc,
                                                  -virt_loc.phys_row_offset);
                gnc_table_move_cursor_gui (reg->table, virt_loc);
            }
        }
        else
        {
            /* WTF?  Go to a known safe location. */
            virt_loc.vcell_loc.virt_row = 1;
            virt_loc.vcell_loc.virt_col = 0;
            virt_loc.phys_row_offset = 0;
            virt_loc.phys_col_offset = 0;
            gnc_table_move_cursor_gui (reg->table, virt_loc);
        }
    }

    reg->type = newtype;

    if (reg->type >= NUM_SINGLE_REGISTER_TYPES)
        newstyle = REG_STYLE_JOURNAL;

    reg->style = newstyle;
    reg->use_double_line = use_double_line;

    gnc_table_realize_gui (reg->table);
}

gnc_split_register_control_new()

TableControl* gnc_split_register_control_new

(

void

)

Create a new TableControl specialized for the SplitRegister.

Definition at line 1815 of file split-register-control.cpp.

{
    TableControl *control = gnc_table_control_new();

    control->move_cursor = gnc_split_register_move_cursor;
    control->traverse = gnc_split_register_traverse;

    return control;
}

gnc_split_register_copy_current()

void gnc_split_register_copy_current

(

SplitRegister *

reg

)

Makes a copy of the current entity, either a split or a transaction, so that it can be pasted later.

Definition at line 858 of file split-register.c.

{
    gnc_split_register_copy_current_internal (reg, FALSE);
}

gnc_split_register_current_trans_expanded()

gboolean gnc_split_register_current_trans_expanded

(

SplitRegister *

reg

)

Return TRUE if current trans is expanded and style is REG_STYLE_LEDGER.

Definition at line 279 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);

    if (!reg)
        return FALSE;

    if (reg->style == REG_STYLE_AUTO_LEDGER ||
        reg->style == REG_STYLE_JOURNAL)
        return TRUE;

    return info->trans_expanded;
}

gnc_split_register_cut_current()

void gnc_split_register_cut_current

(

SplitRegister *

reg

)

Equivalent to copying the current entity and the deleting it with the appropriate delete method.

Definition at line 864 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    CursorClass cursor_class;
    Transaction* trans;
    Split* blank_split;
    gboolean changed;
    Split* split;

    blank_split = xaccSplitLookup (&info->blank_split_guid,
                                   gnc_get_current_book ());
    split = gnc_split_register_get_current_split (reg);
    trans = gnc_split_register_get_current_trans (reg);

    /* This shouldn't happen, but be paranoid. */
    if (trans == NULL)
        return;

    cursor_class = gnc_split_register_get_current_cursor_class (reg);

    /* Can't do anything with this. */
    if (cursor_class == CURSOR_CLASS_NONE)
        return;

    /* This shouldn't happen, but be paranoid. */
    if ((split == NULL) && (cursor_class == CURSOR_CLASS_TRANS))
        return;

    changed = gnc_table_current_cursor_changed (reg->table, FALSE);

    /* See if we were asked to cut an unchanged blank split. Don't. */
    if (!changed && ((split == NULL) || (split == blank_split)))
        return;

    gnc_split_register_copy_current_internal (reg, TRUE);

    if (cursor_class == CURSOR_CLASS_SPLIT)
        gnc_split_register_delete_current_split (reg);
    else
        gnc_split_register_delete_current_trans (reg);
}

gnc_split_register_delete_current_split()

void gnc_split_register_delete_current_split

(

SplitRegister *

reg

)

Deletes the split associated with the current cursor, if both are non-NULL.

Deleting the blank split just clears cursor values.

Definition at line 1151 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    Transaction* pending_trans;
    Transaction* trans;
    Split* blank_split;
    Split* split;

    if (!reg) return;

    blank_split = xaccSplitLookup (&info->blank_split_guid,
                                   gnc_get_current_book ());

    pending_trans = xaccTransLookup (&info->pending_trans_guid,
                                     gnc_get_current_book ());

    /* get the current split based on cursor position */
    split = gnc_split_register_get_current_split (reg);
    if (split == NULL)
        return;

    /* If we are deleting the blank split, just cancel. The user is
     * allowed to delete the blank split as a method for discarding
     * any edits they may have made to it. */
    if (split == blank_split)
    {
        gnc_split_register_cancel_cursor_split_changes (reg);
        return;
    }

    gnc_suspend_gui_refresh ();

    trans = xaccSplitGetParent (split);

    /* Check pending transaction */
    if (trans == pending_trans)
    {
        g_assert (xaccTransIsOpen (trans));
    }
    else
    {
        g_assert (!pending_trans);
        if (gnc_split_register_begin_edit_or_warn (info, trans))
        {
            gnc_resume_gui_refresh ();
            return;
        }
    }
    xaccSplitDestroy (split);

    gnc_resume_gui_refresh ();
    gnc_split_register_redraw (reg);
}

gnc_split_register_delete_current_trans()

void gnc_split_register_delete_current_trans

(

SplitRegister *

reg

)

Deletes the transaction associated with the current cursor, if both are non-NULL.

Definition at line 1206 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    Transaction* pending_trans;
    Transaction* trans;
    Split* blank_split;
    Split* split;
    gboolean was_open;

    ENTER ("reg=%p", reg);
    if (!reg)
    {
        LEAVE ("no register");
        return;
    }

    blank_split = xaccSplitLookup (&info->blank_split_guid,
                                   gnc_get_current_book ());
    pending_trans = xaccTransLookup (&info->pending_trans_guid,
                                     gnc_get_current_book ());

    /* get the current split based on cursor position */
    split = gnc_split_register_get_current_split (reg);
    if (split == NULL)
    {
        LEAVE ("no split");
        return;
    }

    gnc_suspend_gui_refresh ();
    trans = xaccSplitGetParent (split);

    /* If we just deleted the blank split, clean up. The user is
     * allowed to delete the blank split as a method for discarding
     * any edits they may have made to it. */
    if (split == blank_split)
    {
        DEBUG ("deleting blank split");
        info->blank_split_guid = *guid_null ();
        info->auto_complete = FALSE;
    }
    else
    {
        info->trans_expanded = FALSE;
    }

    /* Check pending transaction */
    if (trans == pending_trans)
    {
        DEBUG ("clearing pending trans");
        info->pending_trans_guid = *guid_null ();
        pending_trans = NULL;
    }

    was_open = xaccTransIsOpen (trans);
    xaccTransDestroy (trans);
    if (was_open)
    {
        DEBUG ("committing");
        xaccTransCommitEdit (trans);
    }
    gnc_resume_gui_refresh ();
    gnc_split_register_redraw (reg);
    LEAVE (" ");
}

gnc_split_register_destroy()

void gnc_split_register_destroy

(

SplitRegister *

reg

)

Destroys a split register.

Parameters

reg	a ::SplitRegister

Definition at line 3096 of file split-register.c.

{
    g_return_if_fail (reg);

    ENTER ("reg=%p", reg);

    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
                                 GNC_PREF_ACCOUNTING_LABELS,
                                 split_register_pref_changed,
                                 reg);
    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL,
                                 GNC_PREF_ACCOUNT_SEPARATOR,
                                 split_register_pref_changed,
                                 reg);
    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL_REGISTER,
                                 GNC_PREF_SHOW_LEAF_ACCT_NAMES,
                                 split_register_pref_changed,
                                 reg);
    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL_REGISTER,
                                 GNC_PREF_ALT_COLOR_BY_TRANS,
                                 split_register_pref_changed,
                                 reg);
    gnc_book_option_remove_cb (OPTION_NAME_NUM_FIELD_SOURCE,
                               split_register_book_option_changed,
                               reg);

    gnc_split_register_cleanup (reg);

    gnc_table_destroy (reg->table);
    reg->table = NULL;

    /* free the memory itself */
    g_free (reg);
    LEAVE (" ");
}

gnc_split_register_duplicate_current()

Split* gnc_split_register_duplicate_current

(

SplitRegister *

reg

)

Duplicates either the current transaction or the current split depending on the register mode and cursor position.

Returns the split just created, or the 'main' split of the transaction just created, or NULL if nothing happened.

Definition at line 416 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    CursorClass cursor_class;
    Transaction* trans;
    Split* return_split;
    Split* trans_split;
    Split* blank_split;
    gboolean changed;
    Split* split;

    ENTER ("reg=%p", reg);

    blank_split = xaccSplitLookup (&info->blank_split_guid,
                                   gnc_get_current_book ());
    split = gnc_split_register_get_current_split (reg);
    trans = gnc_split_register_get_current_trans (reg);
    trans_split = gnc_split_register_get_current_trans_split (reg, NULL);

    /* This shouldn't happen, but be paranoid. */
    if (trans == NULL)
    {
        LEAVE ("no transaction");
        return NULL;
    }

    cursor_class = gnc_split_register_get_current_cursor_class (reg);

    /* Can't do anything with this. */
    if (cursor_class == CURSOR_CLASS_NONE)
    {
        LEAVE ("no cursor class");
        return NULL;
    }

    /* This shouldn't happen, but be paranoid. */
    if ((split == NULL) && (cursor_class == CURSOR_CLASS_TRANS))
    {
        LEAVE ("no split with transaction class");
        return NULL;
    }

    changed = gnc_table_current_cursor_changed (reg->table, FALSE);

    /* See if we were asked to duplicate an unchanged blank split.
     * There's no point in doing that! */
    if (!changed && ((split == NULL) || (split == blank_split)))
    {
        LEAVE ("skip unchanged blank split");
        return NULL;
    }

    gnc_suspend_gui_refresh ();

    /* If the cursor has been edited, we are going to have to commit
     * it before we can duplicate. Make sure the user wants to do that. */
    if (changed)
    {
        GtkWidget* dialog, *window;
        gint response;
        const char* title = _ ("Save transaction before duplicating?");
        const char* message =
            _ ("The current transaction has been changed. Would you like to "
               "record the changes before duplicating the transaction, or "
               "cancel the duplication?");

        window = gnc_split_register_get_parent (reg);
        dialog = gtk_message_dialog_new (GTK_WINDOW (window),
                                         GTK_DIALOG_DESTROY_WITH_PARENT,
                                         GTK_MESSAGE_QUESTION,
                                         GTK_BUTTONS_CANCEL,
                                         "%s", title);
        gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
                                                  "%s", message);
        gtk_dialog_add_button (GTK_DIALOG (dialog),
                               _ ("_Record"), GTK_RESPONSE_ACCEPT);
        response = gnc_dialog_run (GTK_DIALOG (dialog), GNC_PREF_WARN_REG_TRANS_DUP);
        gtk_widget_destroy (dialog);

        if (response != GTK_RESPONSE_ACCEPT)
        {
            gnc_resume_gui_refresh ();
            LEAVE ("save cancelled");
            return NULL;
        }

        gnc_split_register_save (reg, TRUE);

        /* If the split is NULL, then we were on a blank split row
         * in an expanded transaction. The new split (created by
         * gnc_split_register_save above) will be the last split in the
         * current transaction, as it was just added. */
        if (split == NULL)
            split = xaccTransGetSplit (trans, xaccTransCountSplits (trans) - 1);
    }

    /* Ok, we are now ready to make the copy. */

    if (cursor_class == CURSOR_CLASS_SPLIT)
    {
        Split* new_split;
        char* out_num;
        gboolean new_act_num = FALSE;

        /* We are on a split in an expanded transaction.
         * Just copy the split and add it to the transaction.
         * However, if the split-action field is being used as the register
         * number, and the action field is a number, request a new value or
         * cancel. Need to get next number and update account last num from
         * split account not register account, which may be the same or not */

        if (!reg->use_tran_num_for_num_field
            && gnc_strisnum (gnc_get_num_action (NULL, split)))
        {
            Account* account = xaccSplitGetAccount (split);
            const char* in_num = NULL;
            const char* title = _ ("New Split Information");
            time64 date = info->last_date_entered;

            if (account)
                in_num = xaccAccountGetLastNum (account);
            else
                in_num = gnc_get_num_action (NULL, split);

            if (!gnc_dup_trans_dialog (gnc_split_register_get_parent (reg),
                                       title, FALSE, &date, in_num, &out_num,
                                       NULL, NULL, NULL, NULL))
            {
                gnc_resume_gui_refresh ();
                LEAVE ("dup cancelled");
                return NULL;
            }
            new_act_num = TRUE;
        }

        new_split = xaccMallocSplit (gnc_get_current_book ());

        xaccTransBeginEdit (trans);
        xaccSplitSetParent (new_split, trans);
        gnc_copy_split_onto_split (split, new_split, FALSE);
        if (new_act_num) /* if new number supplied by user dialog */
            gnc_set_num_action (NULL, new_split, out_num, NULL);

        xaccTransCommitEdit (trans);

        if (new_act_num && gnc_strisnum (out_num))
        {
            Account* account = xaccSplitGetAccount (new_split);

            /* If current register is for account, set last num */
            if (xaccAccountEqual (account,
                                  gnc_split_register_get_default_account (reg),
                                  TRUE))
            {
                NumCell* num_cell;
                num_cell = (NumCell*) gnc_table_layout_get_cell (reg->table->layout,
                                                                 NUM_CELL);
                if (gnc_num_cell_set_last_num (num_cell, out_num))
                    gnc_split_register_set_last_num (reg, out_num);
            }
            else
            {
                xaccAccountSetLastNum (account, out_num);
            }
        }

        return_split = new_split;

        info->cursor_hint_split = new_split;
        info->cursor_hint_cursor_class = CURSOR_CLASS_SPLIT;
        if (new_act_num)
            g_free (out_num);
    }
    else
    {
        Account* account;
        NumCell* num_cell;
        Transaction* new_trans;
        int trans_split_index;
        int split_index;
        const char* in_num = NULL;
        const char* in_tnum = NULL;
        char* out_num = NULL;
        char* out_tnum = NULL;
        char* out_tdoclink = NULL;
        time64 date;
        gboolean use_autoreadonly = qof_book_uses_autoreadonly (
            gnc_get_current_book ());

        /* We are on a transaction row. Copy the whole transaction. */

        date = info->last_date_entered;

        account = gnc_split_register_get_default_account (reg);

        if (account && gnc_strisnum (gnc_get_num_action (trans, trans_split)))
            in_num = xaccAccountGetLastNum (account);
        else
            in_num = gnc_get_num_action (trans, trans_split);

        in_tnum = (reg->use_tran_num_for_num_field
                   ? NULL
                   : gnc_get_num_action (trans, NULL));

        if (!gnc_dup_trans_dialog (gnc_split_register_get_parent (reg), NULL,
                                   TRUE, &date, in_num, &out_num, in_tnum, &out_tnum,
                                   xaccTransGetDocLink (trans), &out_tdoclink))
        {
            gnc_resume_gui_refresh ();
            LEAVE ("dup cancelled");
            return NULL;
        }

        if (use_autoreadonly)
        {
            GDate d;
            GDate* readonly_threshold = qof_book_get_autoreadonly_gdate (
                gnc_get_current_book ());
            gnc_gdate_set_time64 (&d, date);
            if (g_date_compare (&d, readonly_threshold) < 0)
            {
                GtkWidget* dialog = gtk_message_dialog_new (NULL,
                                                            0,
                                                            GTK_MESSAGE_ERROR,
                                                            GTK_BUTTONS_OK,
                                                            "%s", _ ("Cannot store a transaction at this date"));
                gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
                                                          "%s", _ ("The entered date of the duplicated transaction is older than the \"Read-Only Threshold\" set for this book. "
                                                                   "This setting can be changed in File->Properties->Accounts."));
                gtk_dialog_run (GTK_DIALOG (dialog));
                gtk_widget_destroy (dialog);

                g_date_free (readonly_threshold);
                return NULL;
            }
            g_date_free (readonly_threshold);
        }

        split_index = xaccTransGetSplitIndex (trans, split);
        trans_split_index = xaccTransGetSplitIndex (trans, trans_split);

        /* we should *always* find the split, but be paranoid */
        if (split_index < 0)
        {
            gnc_resume_gui_refresh ();
            LEAVE ("no split");
            return NULL;
        }

        new_trans = xaccMallocTransaction (gnc_get_current_book ());

        xaccTransBeginEdit (new_trans);
        gnc_copy_trans_onto_trans (trans, new_trans, FALSE, FALSE);
        xaccTransSetDatePostedSecsNormalized (new_trans, date);
        /* We also must set a new DateEntered on the new entry
         * because otherwise the ordering is not deterministic */
        xaccTransSetDateEnteredSecs (new_trans, gnc_time (NULL));

        /* clear the document link entry if returned value NULL */
        if (out_tdoclink == NULL)
            xaccTransSetDocLink (new_trans, "");
        else
            g_free (out_tdoclink);

        /* set per book option */
        gnc_set_num_action (new_trans, NULL, out_num, out_tnum);
        if (!reg->use_tran_num_for_num_field)
        {
            /* find split in new_trans that equals trans_split and set
             * split_action to out_num */
            gnc_set_num_action (NULL,
                                xaccTransGetSplit (new_trans, trans_split_index),
                                out_num, NULL);
            /* note that if the transaction has multiple splits to the register
             * account, only the anchor split will be set with user input. The
             * user will have to adjust other splits manually. */
        }
        xaccTransCommitEdit (new_trans);

        num_cell = (NumCell*) gnc_table_layout_get_cell (reg->table->layout,
                                                         NUM_CELL);
        if (gnc_num_cell_set_last_num (num_cell, out_num))
            gnc_split_register_set_last_num (reg, out_num);

        g_free (out_num);
        if (!reg->use_tran_num_for_num_field)
            g_free (out_tnum);

        /* This shouldn't happen, but be paranoid. */
        if (split_index >= xaccTransCountSplits (new_trans))
            split_index = 0;

        return_split = xaccTransGetSplit (new_trans, split_index);
        trans_split = xaccTransGetSplit (new_trans, trans_split_index);

        info->cursor_hint_trans = new_trans;
        info->cursor_hint_split = return_split;
        info->cursor_hint_trans_split = trans_split;
        info->cursor_hint_cursor_class = CURSOR_CLASS_TRANS;

        info->trans_expanded = FALSE;
    }

    /* Refresh the GUI. */
    gnc_resume_gui_refresh ();

    LEAVE (" ");
    return return_split;
}

gnc_split_register_empty_current_trans_except_split()

void gnc_split_register_empty_current_trans_except_split	(	SplitRegister *	reg,
		Split *	split
	)

Deletes the non-transaction splits associated with the current cursor, if both are non-NULL.

Definition at line 1370 of file split-register.c.

{
    SRInfo* info;
    Transaction* trans;
    Transaction* pending;
    int i = 0;
    Split* s;

    if ((reg == NULL)  || (split == NULL))
        return;

    gnc_suspend_gui_refresh ();
    info = gnc_split_register_get_info (reg);
    pending = xaccTransLookup (&info->pending_trans_guid, gnc_get_current_book ());

    trans = xaccSplitGetParent (split);
    if (!pending)
    {
        if (gnc_split_register_begin_edit_or_warn (info, trans))
        {
            gnc_resume_gui_refresh ();
            return;
        }
    }
    else if (pending == trans)
    {
        g_assert (xaccTransIsOpen (trans));
    }
    else g_assert_not_reached ();

    while ((s = xaccTransGetSplit (trans, i)) != NULL)
    {
        if (s != split)
            xaccSplitDestroy (s);
        else i++;
    }

    gnc_resume_gui_refresh ();
    gnc_split_register_redraw (reg);
}

gnc_split_register_expand_current_trans()

void gnc_split_register_expand_current_trans	(	SplitRegister *	reg,
		gboolean	expand
	)

Expand the current transaction if it is collapsed.

Definition at line 219 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    VirtualLocation virt_loc;

    if (!reg)
        return;

    if (reg->style == REG_STYLE_AUTO_LEDGER ||
        reg->style == REG_STYLE_JOURNAL)
        return;

    /* ok, so I just wanted an excuse to use exclusive-or */
    if (! (expand ^ info->trans_expanded))
        return;

    if (!expand)
    {
        virt_loc = reg->table->current_cursor_loc;
        gnc_split_register_get_trans_split (reg, virt_loc.vcell_loc,
                                            &virt_loc.vcell_loc);

        if (gnc_table_find_close_valid_cell (reg->table, &virt_loc, FALSE))
            gnc_table_move_cursor_gui (reg->table, virt_loc);
        else
        {
            PERR ("Can't find place to go!");
            return;
        }
    }

    info->trans_expanded = expand;

    gnc_table_set_virt_cell_cursor (reg->table,
                                    reg->table->current_cursor_loc.vcell_loc,
                                    gnc_split_register_get_active_cursor (reg));

    gnc_split_register_set_trans_visible (
        reg, reg->table->current_cursor_loc.vcell_loc, expand, FALSE);

    virt_loc = reg->table->current_cursor_loc;
    if (!expand || !gnc_table_virtual_loc_valid (reg->table, virt_loc, FALSE))
    {
        if (gnc_table_find_close_valid_cell (reg->table, &virt_loc, FALSE))
            gnc_table_move_cursor_gui (reg->table, virt_loc);
        else
        {
            PERR ("Can't find place to go!");
            return;
        }
    }

    gnc_table_refresh_gui (reg->table, TRUE);

    if (expand)
        gnc_split_register_show_trans (reg,
                                       reg->table->current_cursor_loc.vcell_loc);
}

gnc_split_register_get_blank_split()

Split* gnc_split_register_get_blank_split

(

SplitRegister *

reg

)

Gets the blank split for a register.

Parameters

reg	a ::SplitRegister

Returns

the ::Split used as the blank split, or NULL if there currently isn't one

Definition at line 328 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);

    if (!reg) return NULL;

    return xaccSplitLookup (&info->blank_split_guid, gnc_get_current_book ());
}

gnc_split_register_get_credit_string()

const char* gnc_split_register_get_credit_string

(

SplitRegister *

reg

)

Return the credit string used in the register.

Definition at line 2458 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);

    if (!reg)
        return NULL;

    if (info->credit_str)
        return info->credit_str;

    info->credit_str =
        gnc_account_get_credit_string
        (gnc_split_register_type_to_account_type (reg->type));

    if (info->credit_str)
        return info->credit_str;

    info->credit_str = g_strdup (_ ("Credit"));

    return info->credit_str;
}

gnc_split_register_get_current_cursor_class()

CursorClass gnc_split_register_get_current_cursor_class

(

SplitRegister *

reg

)

Returns the class of a register's current cursor.

Parameters

reg	a ::SplitRegister

Returns

the CursorClass of the current cursor

Definition at line 546 of file split-register-util.c.

{
    Table *table;

    if (reg == NULL)
        return CURSOR_CLASS_NONE;

    table = reg->table;
    if (table == NULL)
        return CURSOR_CLASS_NONE;

    return gnc_split_register_cursor_class (reg, table->current_cursor);
}

gnc_split_register_get_current_split()

Split* gnc_split_register_get_current_split

(

SplitRegister *

reg

)

Returns the split at which the cursor is currently located.

Parameters

reg	a ::SplitRegister

Returns

the ::Split at the cursor location, or the anchoring split if the cursor is currently on a transaction

Definition at line 318 of file split-register.c.

{
    if (reg == NULL)
        return NULL;

    return gnc_split_register_get_split (
        reg, reg->table->current_cursor_loc.vcell_loc);
}

gnc_split_register_get_current_trans()

Transaction* gnc_split_register_get_current_trans

(

SplitRegister *

reg

)

Gets the transaction at the current cursor location, which may be on the transaction itself or on any of its splits.

Parameters

reg	a ::SplitRegister

Returns

the ::Transaction at the cursor location, or NULL

Definition at line 294 of file split-register.c.

{
    Split* split;
    VirtualCellLocation vcell_loc;

    if (reg == NULL)
        return NULL;

    split = gnc_split_register_get_current_split (reg);
    if (split != NULL)
        return xaccSplitGetParent (split);

    /* Split is blank. Assume it is the blank split of a multi-line
     * transaction. Go back one row to find a split in the transaction. */
    vcell_loc = reg->table->current_cursor_loc.vcell_loc;

    vcell_loc.virt_row--;

    split = gnc_split_register_get_split (reg, vcell_loc);

    return xaccSplitGetParent (split);
}

gnc_split_register_get_current_trans_split()

Split* gnc_split_register_get_current_trans_split	(	SplitRegister *	reg,
		VirtualCellLocation *	vcell_loc
	)

Gets the anchoring split of the transaction at the current cursor location, which may be on the transaction itself or on any of its splits.

Parameters

reg	a ::SplitRegister
vcell_loc	a pointer to be filled with the location of the transaction's virtual cell

Returns

the anchoring ::Split of the transaction

Definition at line 187 of file split-register-util.c.

{
    VirtualCellLocation vcell_loc;

    if (reg == NULL)
        return NULL;

    vcell_loc = reg->table->current_cursor_loc.vcell_loc;

    return gnc_split_register_get_trans_split (reg, vcell_loc, trans_split_loc);
}

gnc_split_register_get_cursor_class()

CursorClass gnc_split_register_get_cursor_class	(	SplitRegister *	reg,
		VirtualCellLocation	vcell_loc
	)

Returns the class of the cursor at the given virtual cell location.

Parameters

reg	a ::SplitRegister
vcell_loc	the location of a virtual cell

Returns

the CursorClass of the cursor at vcell_loc

Definition at line 525 of file split-register-util.c.

{
    VirtualCell *vcell;
    Table *table;

    if (reg == NULL)
        return CURSOR_CLASS_NONE;

    table = reg->table;
    if (table == NULL)
        return CURSOR_CLASS_NONE;

    vcell = gnc_table_get_virtual_cell (table, vcell_loc);
    if (vcell == NULL)
        return CURSOR_CLASS_NONE;

    return gnc_split_register_cursor_class (reg, vcell->cellblock);
}

gnc_split_register_get_debit_string()

const char* gnc_split_register_get_debit_string

(

SplitRegister *

reg

)

Return the debit string used in the register.

Definition at line 2435 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);

    if (!reg)
        return NULL;

    if (info->debit_str)
        return info->debit_str;

    info->debit_str =
        gnc_account_get_debit_string
        (gnc_split_register_type_to_account_type (reg->type));

    if (info->debit_str)
        return info->debit_str;

    info->debit_str = g_strdup (_ ("Debit"));

    return info->debit_str;
}

gnc_split_register_get_register_group()

SplitRegisterTypeGroup gnc_split_register_get_register_group

(

SplitRegister *

reg

)

Group registers for common layouts.

Parameters

reg	a ::SplitRegister

Returns

the SplitRegisterTypeGroup that groups registers together

Definition at line 3139 of file split-register.c.

{
    switch (reg->type)
    {
        case BANK_REGISTER:
        case CASH_REGISTER:
        case ASSET_REGISTER:
        case CREDIT_REGISTER:
        case LIABILITY_REGISTER:
        case INCOME_REGISTER:
        case EXPENSE_REGISTER:
        case EQUITY_REGISTER:
        case TRADING_REGISTER:
        {
            return REG_TYPE_GROUP_CURRENCY;
            break;
        }
        case PAYABLE_REGISTER:
        case RECEIVABLE_REGISTER:
        {
            return REG_TYPE_GROUP_APAR;
            break;
        }
        case INCOME_LEDGER:
        case GENERAL_JOURNAL:
        case SEARCH_LEDGER:
        {
            return REG_TYPE_GROUP_JOURNAL;
            break;
        }
        case STOCK_REGISTER:
        case CURRENCY_REGISTER:
        {
            return REG_TYPE_GROUP_STOCK;
            break;
        }
        case PORTFOLIO_LEDGER:
        {
            return REG_TYPE_GROUP_PORTFOLIO;
            break;
        }
        default:
            return REG_TYPE_GROUP_UNKNOWN;
            PERR ("unknown register type %d\n", reg->type);
        break;
    }
}

gnc_split_register_get_split_amount_virt_loc()

gboolean gnc_split_register_get_split_amount_virt_loc	(	SplitRegister *	reg,
		Split *	split,
		VirtualLocation *	virt_loc
	)

Searches the split register for the given split and determines the location of either its credit (if non-zero) or debit cell.

Parameters

reg	a ::SplitRegister
split	the ::Split to find
virt_loc	a pointer to be filled with the amount cell's location

Returns

TRUE if the split was found and the location has been stored at virt_loc, FALSE otherwise

Definition at line 378 of file split-register.c.

{
    VirtualLocation v_loc;
    CursorClass cursor_class;
    const char* cell_name;
    gnc_numeric value;

    if (!gnc_split_register_get_split_virt_loc (reg, split, &v_loc.vcell_loc))
        return FALSE;

    cursor_class = gnc_split_register_get_cursor_class (reg, v_loc.vcell_loc);

    value = xaccSplitGetValue (split);

    switch (cursor_class)
    {
        case CURSOR_CLASS_SPLIT:
        case CURSOR_CLASS_TRANS:
            cell_name = (gnc_numeric_negative_p (value)) ? CRED_CELL : DEBT_CELL;
            break;
        default:
            return FALSE;
    }

    if (!gnc_table_get_cell_location (reg->table, cell_name,
                                      v_loc.vcell_loc, &v_loc))
        return FALSE;

    if (virt_loc == NULL)
        return TRUE;

    *virt_loc = v_loc;

    return TRUE;
}

gnc_split_register_get_split_virt_loc()

gboolean gnc_split_register_get_split_virt_loc	(	SplitRegister *	reg,
		Split *	split,
		VirtualCellLocation *	vcell_loc
	)

Searches the split register for a given split.

The search begins from the bottom row and works backwards. The location of the first virtual cell that matches will be returned in vcell_loc.

Parameters

reg	a ::SplitRegister
split	the ::Split to find
vcell_loc	a pointer to be filled with the location of the matching virtual cell

Returns

TRUE if the split was found and the location has been stored at vcell_loc, FALSE otherwise

Definition at line 338 of file split-register.c.

{
    Table* table;
    int v_row;
    int v_col;

    if (!reg || !split) return FALSE;

    table = reg->table;

    /* go backwards because typically you search for splits at the end
     * and because we find split rows before transaction rows. */

    for (v_row = table->num_virt_rows - 1; v_row > 0; v_row--)
        for (v_col = 0; v_col < table->num_virt_cols; v_col++)
        {
            VirtualCellLocation vc_loc = { v_row, v_col };
            VirtualCell* vcell;
            Split* s;

            vcell = gnc_table_get_virtual_cell (table, vc_loc);
            if (!vcell || !vcell->visible)
                continue;

            s = xaccSplitLookup (vcell->vcell_data, gnc_get_current_book ());

            if (s == split)
            {
                if (vcell_loc)
                    *vcell_loc = vc_loc;

                return TRUE;
            }
        }

    return FALSE;
}

gnc_split_register_handle_exchange()

gboolean gnc_split_register_handle_exchange	(	SplitRegister *	reg,
		gboolean	force_dialog
	)

Pop up the exchange-rate dialog, maybe, for the current split.

If force_dialog is TRUE, the forces the dialog to be called. If the dialog does not complete successfully, then return TRUE. Return FALSE in all other cases (meaning "move on")

Pop up the exchange-rate dialog, maybe, for the current split.

If the dialog does not complete successfully, then return TRUE. Return FALSE in all other cases (meaning "move on")

Parameters

reg	the register to operate on
force_dialog	pop a dialog even if we don't think we need it.

Returns

whether more handling is required.

Definition at line 1285 of file split-register-control.cpp.

{
    SRInfo *info;
    Transaction *txn;
    Split *split, *osplit;
    Account *xfer_acc, *reg_acc;
    gnc_commodity *txn_cur, *xfer_com, *reg_com;
    gnc_numeric amount, exch_rate;
    XferDialog *xfer;
    gboolean expanded = FALSE;
    PriceCell *rate_cell;
    const char *message;
    CursorClass cursor_class;

    ENTER("reg=%p, force_dialog=%s", reg, force_dialog ? "TRUE" : "FALSE" );

    /* No point in setting a rate on a template transaction. */
    if (reg->is_template)
    {
        LEAVE("Template transaction, rate makes no sense.");
        return FALSE;
    }

    /* Make sure we NEED this for this type of register */
    if (!gnc_split_reg_has_rate_cell (reg->type))
    {
        if (force_dialog)
        {
            message = _("This register does not support editing exchange rates.");
            gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)), "%s", message);
        }
        LEAVE("no rate cell");
        return FALSE;
    }

    rate_cell = (PriceCell*) gnc_table_layout_get_cell(
                    reg->table->layout, RATE_CELL);
    if (!rate_cell)
    {
        if (force_dialog)
        {
            message = _("This register does not support editing exchange rates.");
            gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)), "%s", message);
        }
        LEAVE("null rate cell");
        return FALSE;
    }

    /* See if we already have an exchange rate... */
    info = gnc_split_register_get_info (reg);
    exch_rate = gnc_price_cell_get_value (rate_cell);
    if (!gnc_numeric_zero_p(exch_rate) && !force_dialog &&
        info->rate_reset != RATE_RESET_REQD)
    {
        LEAVE("rate already non-zero");
        return FALSE;
    }

    /* Are we expanded? */
    expanded = gnc_split_register_current_trans_expanded (reg);
    cursor_class = gnc_split_register_get_current_cursor_class (reg);

    /* If we're expanded AND a transaction cursor, there is nothing to do */
    if (expanded && cursor_class == CURSOR_CLASS_TRANS)
    {
        if (force_dialog)
        {
            message = _("You need to select a split in order to modify its exchange "
                        "rate.");
            gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)), "%s", message);
        }
        LEAVE("expanded with transaction cursor; nothing to do");
        return FALSE;
    }

    /* Grab the xfer account */
    xfer_acc = gnc_split_register_get_account_always(
                   reg, expanded ? XFRM_CELL : MXFRM_CELL);

    /* If this is an un-expanded, multi-split transaction, then warn the user */
    if (force_dialog && !expanded && !xfer_acc)
    {
        message = _("You need to expand the transaction in order to modify its "
                    "exchange rates.");
        gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)), "%s", message);
        LEAVE("%s", message);
        return TRUE;
    }

    /* No account -- don't run the dialog */
    if (!xfer_acc)
    {
        if (force_dialog)
        {
            message = _("The entered account could not be found.");
            gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)), "%s", message);
        }
        LEAVE("no xfer account");
        return FALSE;
    }

    /* Grab the txn currency and xfer commodity */
    txn = gnc_split_register_get_current_trans (reg);
    txn_cur = xaccTransGetCurrency (txn);
    xfer_com = xaccAccountGetCommodity (xfer_acc);

    /* Grab the register account and commodity (may be used later) */
    reg_acc = gnc_split_register_get_default_account (reg);
    reg_com = xaccAccountGetCommodity (reg_acc);

    /* Grab the split and perhaps the "other" split (if it is a two-split txn) */
    split = gnc_split_register_get_current_split (reg);
    osplit = xaccSplitGetOtherSplit (split);

    /* Check if the txn- and xfer- commodities are the same */
    if (gnc_commodity_equal (txn_cur, xfer_com))
    {
        /* If we're not forcing the dialog, then there is no reason to
         * go on.  We're using the correct accounts.
         */
        if (!force_dialog)
        {
            LEAVE("txn and account currencies match, and not forcing");
            return FALSE;
        }

        /* Only proceed with two-split, basic, non-expanded registers */
        if (expanded || osplit == NULL)
        {
            message = _("The two currencies involved equal each other.");
            gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)), "%s", message);
            LEAVE("register is expanded or osplit == NULL; not forcing dialog");
            return FALSE;
        }

        /* If we're forcing, then compare the current account
         * commodity to the transaction currency.
         */
        xfer_acc = reg_acc;
        xfer_com = reg_com;
        if (gnc_commodity_equal (txn_cur, xfer_com))
        {
            message = _("The two currencies involved equal each other.");
            gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)), "%s", message);
            LEAVE("reg commodity == txn commodity; not forcing");
            return FALSE;
        }
    }

    /* If this is a non-expanded, two-split txn where BOTH splits need
     * conversion rates, then require the user to actually expand the
     * transaction in order to edit it.
     */
    if (!expanded && osplit &&
            gnc_split_register_split_needs_amount (reg, split) &&
            gnc_split_register_split_needs_amount (reg, osplit))
    {
        message = _("You need to expand the transaction in order to modify its "
                    "exchange rates.");
        if (force_dialog)
        {
            gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)), "%s", message);
        }
        LEAVE("%s", message);
        return TRUE;
    }

    /* Strangely, if we're in a two-split, non-expanded txn, we need
     * to do something really special with the exchange rate!  In
     * particular, we have to pick it up from the _other_ split --
     * right?
     * XXX: perhaps I should pop up an error here?  Or maybe require the
     * user to go into expanded-mode?
     */
    if (!expanded && osplit && !gnc_commodity_equal(reg_com, txn_cur) &&
            !gnc_commodity_equal(reg_com, xfer_com))
    {
        gnc_numeric amt = xaccSplitGetAmount (osplit);
        gnc_numeric val = xaccSplitGetValue (osplit);
        exch_rate = gnc_numeric_div (amt, val, GNC_DENOM_AUTO, GNC_HOW_DENOM_REDUCE);
    }

    /* Ok, we need to grab the exchange rate */
    amount = gnc_split_register_debcred_cell_value (reg);

    /*
     * If "amount" is zero then we don't need an exchange-rate.. Return
     * FALSE to let the user continue on.
     */
    if (gnc_numeric_zero_p (amount))
    {
        if (force_dialog)
        {
            message = _("The split's amount is zero, so no exchange rate is needed.");
            gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)), "%s", message);
        }
        LEAVE("amount is zero; no exchange rate needed");
        return FALSE;
    }

    /* If the exch_rate is zero, we're not forcing the dialog, and this is
     * _not_ the blank split, then return FALSE -- this is a "special"
     * gain/loss stock transaction.
     */
    if (gnc_numeric_zero_p(exch_rate) && !force_dialog && split &&
            info->rate_reset != RATE_RESET_REQD &&
            split != gnc_split_register_get_blank_split (reg))
    {
        LEAVE("gain/loss split; no exchange rate needed");
        return FALSE;
    }

    /* Show the exchange-rate dialog */
    xfer = gnc_split_register_xfer_dialog(reg, txn, split);
    gnc_xfer_dialog_is_exchange_dialog(xfer, &exch_rate);
    if (gnc_xfer_dialog_run_exchange_dialog(
                xfer, &exch_rate, amount, reg_acc, txn, xfer_com, expanded))
    {
        /* FIXME: How should the dialog be destroyed? */
        LEAVE("leaving rate unchanged");
        return TRUE;
    }
    /* FIXME: How should the dialog be destroyed? */

    /* Set the RATE_CELL on this cursor and mark it changed */
    gnc_price_cell_set_value (rate_cell, exch_rate);
    gnc_basic_cell_set_changed (&rate_cell->cell, TRUE);
    info->rate_account = xfer_acc;
    info->rate_reset = RATE_RESET_DONE;
    LEAVE("set rate=%s", gnc_num_dbg_to_string(exch_rate));
    return FALSE;
}

gnc_split_register_is_blank_split()

gboolean gnc_split_register_is_blank_split	(	SplitRegister *	reg,
		Split *	split
	)

Return TRUE if split is the blank_split.

Definition at line 1108 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    Split* current_blank_split = xaccSplitLookup (&info->blank_split_guid,
                                                  gnc_get_current_book ());

    if (split == current_blank_split)
        return TRUE;

    return FALSE;
}

gnc_split_register_layout_new()

TableLayout* gnc_split_register_layout_new

(

SplitRegister *

reg

)

Generate the split register layout.

Definition at line 867 of file split-register-layout.c.

{
    TableLayout* layout;

    layout = gnc_table_layout_new();

    gnc_split_register_layout_add_cells (reg, layout);
    gnc_split_register_layout_add_cursors (reg, layout);
    gnc_split_register_set_cells (reg, layout);

    return layout;
}

gnc_split_register_load()

void gnc_split_register_load	(	SplitRegister *	reg,
		GList *	slist,
		Account *	default_account
	)

Populates the rows of a register.

The rows are filled, based on the register style, with data associated with the given list of splits slist. In addition, an area for the user to begin entering new transactions is placed at the tail end of the register. This area is anchored by the "blank split".

The account default_account, if provided, is used to determine various default values for the blank split (such as currency, last check number, and transfer account) for the blank split.

Parameters

reg	a ::SplitRegister
slist	a list of splits
default_account	an account to provide defaults for the blank split

Definition at line 369 of file split-register-load.c.

{
    SRInfo* info;
    Transaction* pending_trans;
    CursorBuffer* cursor_buffer;
    GHashTable* trans_table = NULL;
    CellBlock* cursor_header;
    CellBlock* lead_cursor;
    CellBlock* split_cursor;
    Transaction* blank_trans;
    Transaction* find_trans;
    Transaction* trans;
    CursorClass find_class;
    Split* find_trans_split;
    Split* blank_split;
    Split* find_split;
    Split* split;
    Table* table;
    GList* node;
    gnc_commodity *account_comm = NULL;

    gboolean start_primary_color = TRUE;
    gboolean found_pending = FALSE;
    gboolean need_divider_upper = FALSE;
    gboolean found_divider_upper = FALSE;
    gboolean found_divider = FALSE;
    gboolean has_last_num = FALSE;
    gboolean multi_line;
    gboolean dynamic;
    gboolean we_own_slist = FALSE;
    gboolean use_autoreadonly = qof_book_uses_autoreadonly (
                                    gnc_get_current_book());
    gboolean future_after_blank = gnc_prefs_get_bool (
                                      GNC_PREFS_GROUP_GENERAL_REGISTER,
                                      GNC_PREF_FUTURE_AFTER_BLANK);
    gboolean added_blank_trans = FALSE;

    VirtualCellLocation vcell_loc;
    VirtualLocation save_loc;

    int new_trans_split_row = -1;
    int new_trans_row = -1;
    int new_split_row = -1;
    time64 present, autoreadonly_time = 0;

    g_return_if_fail (reg);
    table = reg->table;
    g_return_if_fail (table);
    info = gnc_split_register_get_info (reg);
    g_return_if_fail (info);

    ENTER ("reg=%p, slist=%p, default_account=%p", reg, slist, default_account);

    blank_split = xaccSplitLookup (&info->blank_split_guid,
                                   gnc_get_current_book());

    pending_trans = xaccTransLookup (&info->pending_trans_guid,
                                     gnc_get_current_book());

    if (default_account)
        account_comm = gnc_account_get_currency_or_parent (default_account);

    if (!account_comm)
        account_comm = gnc_default_currency ();

    /* Bug 742089: Set the debit and credit cells' print_info to the account */
    gnc_price_cell_set_print_info
    ((PriceCell*) gnc_table_layout_get_cell (table->layout, DEBT_CELL),
     gnc_commodity_print_info (account_comm, FALSE));

    gnc_price_cell_set_print_info
    ((PriceCell*) gnc_table_layout_get_cell (table->layout, CRED_CELL),
     gnc_commodity_print_info (account_comm, FALSE));

    gnc_price_cell_set_print_info
    ((PriceCell*) gnc_table_layout_get_cell (reg->table->layout, PRIC_CELL),
     gnc_commodity_print_info (account_comm, FALSE));

    /* Only test for linked document glyths once */
    if (info->first_pass)
    {
        gnc_doclink_cell_set_use_glyphs
        ((Doclinkcell *) gnc_table_layout_get_cell (table->layout, DOCLINK_CELL));
    }

    /* make sure we have a blank split */
    if (blank_split == NULL)
    {
        /* Wouldn't it be a bug to open the new transaction if there was
         * already a pending transaction?
        */
        g_assert (pending_trans == NULL);
        blank_split = create_blank_split (default_account, info);
    }
    blank_trans = xaccSplitGetParent (blank_split);

    DEBUG ("blank_split=%p, blank_trans=%p, pending_trans=%p",
           blank_split, blank_trans, pending_trans);

    info->default_account = *xaccAccountGetGUID (default_account);

    // gnc_table_leave_update (table, table->current_cursor_loc);

    multi_line = (reg->style == REG_STYLE_JOURNAL);
    dynamic    = (reg->style == REG_STYLE_AUTO_LEDGER);

    lead_cursor = gnc_split_register_get_passive_cursor (reg);
    split_cursor = gnc_table_layout_get_cursor (table->layout, CURSOR_SPLIT);

    /* figure out where we are going to. */
    if (info->traverse_to_new)
    {
        find_trans = blank_trans;
        find_split = NULL;
        find_trans_split = blank_split;
        find_class = CURSOR_CLASS_SPLIT;
    }
    else
    {
        find_trans = info->cursor_hint_trans;
        find_split = info->cursor_hint_split;
        find_trans_split = info->cursor_hint_trans_split;
        find_class = info->cursor_hint_cursor_class;
    }

    save_loc = table->current_cursor_loc;

    /* If the current cursor has changed we save the values for later
     * possible restoration. */
    if (gnc_table_current_cursor_changed (table, TRUE) &&
        (find_split == gnc_split_register_get_current_split (reg)))
    {
        cursor_buffer = gnc_cursor_buffer_new();
        gnc_table_save_current_cursor (table, cursor_buffer);
    }
    else
        cursor_buffer = NULL;

    /* disable move callback -- we don't want the cascade of
     * callbacks while we are fiddling with loading the register */
    gnc_table_control_allow_move (table->control, FALSE);

    /* invalidate the cursor */
    {
        VirtualLocation virt_loc;

        gnc_virtual_location_init (&virt_loc);
        gnc_table_move_cursor_gui (table, virt_loc);
    }

    /* make sure that the header is loaded */
    vcell_loc.virt_row = 0;
    vcell_loc.virt_col = 0;
    cursor_header = gnc_table_layout_get_cursor (table->layout, CURSOR_HEADER);
    gnc_table_set_vcell (table, cursor_header, NULL, TRUE, TRUE, vcell_loc);
    vcell_loc.virt_row++;

    /* get the current time and reset the dividing row */
    present = gnc_time64_get_today_end();
    if (use_autoreadonly)
    {
        GDate* d = qof_book_get_autoreadonly_gdate (gnc_get_current_book());
        // "d" is NULL if use_autoreadonly is FALSE
        autoreadonly_time = d ? gdate_to_time64 (*d) : 0;
        g_date_free (d);
    }

    if (info->first_pass)
    {
        if (default_account)
        {
            const char* last_num = xaccAccountGetLastNum (default_account);

            if (last_num)
            {
                NumCell* cell;

                cell = (NumCell*) gnc_table_layout_get_cell (table->layout, NUM_CELL);
                gnc_num_cell_set_last_num (cell, last_num);
                has_last_num = TRUE;
            }
        }

        /* load up account names into the transfer combobox menus */
        gnc_split_register_load_xfer_cells (reg, default_account);
        gnc_split_register_load_desc_cells (reg);
        gnc_split_register_load_doclink_cells (reg);
        gnc_split_register_load_recn_cells (reg);
        gnc_split_register_load_type_cells (reg);
    }

    if (info->separator_changed)
        change_account_separator (info, table, reg);

    table->model->dividing_row_upper = -1;
    table->model->dividing_row = -1;
    table->model->dividing_row_lower = -1;

    // Ensure that the transaction and splits being edited are in the split
    // list we're about to load.
    if (pending_trans != NULL)
    {
        for (node = xaccTransGetSplitList (pending_trans); node; node = node->next)
        {
            Split* pending_split = (Split*)node->data;
            if (!xaccTransStillHasSplit (pending_trans, pending_split)) continue;
            if (g_list_find (slist, pending_split) != NULL)
                continue;

            if (g_list_find_custom (slist, pending_trans,
                                    _find_split_with_parent_txn) != NULL)
                continue;

            if (!we_own_slist)
            {
                // lazy-copy
                slist = g_list_copy (slist);
                we_own_slist = TRUE;
            }
            slist = g_list_append (slist, pending_split);
        }
    }

    if (multi_line)
        trans_table = g_hash_table_new (g_direct_hash, g_direct_equal);

    // View reversed add blank transaction at the top
    if (table->model->reverse_sort && !future_after_blank)
    {
        if (blank_trans == find_trans)
            new_trans_row = vcell_loc.virt_row;

        if (blank_split == find_trans_split)
            new_trans_split_row = vcell_loc.virt_row;

        /* go to blank on first pass */
        if (info->first_pass)
        {
            save_loc.vcell_loc = vcell_loc;
            save_loc.phys_row_offset = 0;
            save_loc.phys_col_offset = 0;
        }

        // used in the setting the rows insensitive
        table->model->blank_trans_row = vcell_loc.virt_row;

        gnc_split_register_add_transaction (reg,
                                            blank_trans, blank_split,
                                            lead_cursor, split_cursor,
                                            multi_line, start_primary_color,
                                            info->blank_split_edited,
                                            find_trans, find_split,
                                            find_class, &new_split_row,
                                            &vcell_loc);

        if (!multi_line)
            start_primary_color = !start_primary_color;

        added_blank_trans = TRUE;
    }

    gnc_completion_cell_clear_menu (
        (CompletionCell*) gnc_table_layout_get_cell (reg->table->layout, DESC_CELL));

    gnc_completion_cell_reverse_sort (
        (CompletionCell*) gnc_table_layout_get_cell (reg->table->layout, DESC_CELL),
          table->model->reverse_sort);

    /* populate the table */
    for (node = slist; node; node = node->next)
    {
        split = node->data;
        trans = xaccSplitGetParent (split);

        if (!xaccTransStillHasSplit (trans, split))
            continue;

        if (pending_trans == trans)
            found_pending = TRUE;
        /* If the transaction has only one split, and it's not our
         * pending_trans, then it's another register's blank split and
         * we don't want to see it.
         */
        else if (xaccTransCountSplits (trans) == 1 &&
                 xaccSplitGetAccount (split) == NULL)
            continue;

        /* Do not load splits from the blank transaction. */
        if (trans == blank_trans)
            continue;

        if (multi_line)
        {
            /* Skip this split if its transaction has already been loaded. */
            if (g_hash_table_lookup (trans_table, trans))
                continue;

            g_hash_table_insert (trans_table, trans, trans);
        }

        if (info->show_present_divider &&
            use_autoreadonly &&
            !found_divider_upper)
        {
            if (((table->model->reverse_sort && xaccTransGetDate(trans) < autoreadonly_time) ||
                 (!table->model->reverse_sort && xaccTransGetDate (trans) >= autoreadonly_time)))
            {
                table->model->dividing_row_upper = vcell_loc.virt_row;
                found_divider_upper = TRUE;
            }
            else
            {
                need_divider_upper = TRUE;
            }
        }

        if (info->show_present_divider && !found_divider &&
            ((table->model->reverse_sort && xaccTransGetDate (trans) < present) ||
             (!table->model->reverse_sort && xaccTransGetDate (trans) > present)))
        {
            gint count_blank_splits = 1;
            gint virt_row_offset = 2;
            gboolean show_lower_divider = FALSE;

            if (table->model->reverse_sort)
            {
                count_blank_splits = xaccTransCountSplits (blank_trans);

                if (count_blank_splits > 1)
                   count_blank_splits ++;

                if (table->model->reverse_sort && future_after_blank)
                   virt_row_offset = 0;
            }

            if ((table->model->reverse_sort && vcell_loc.virt_row != count_blank_splits + virt_row_offset) ||
                !table->model->reverse_sort)
            {
                table->model->dividing_row = vcell_loc.virt_row; // blue top
                show_lower_divider = TRUE;
            }

            found_divider = TRUE;

            if (future_after_blank)
            {
                if (blank_trans == find_trans)
                    new_trans_row = vcell_loc.virt_row;

                if (blank_split == find_trans_split)
                    new_trans_split_row = vcell_loc.virt_row;

                /* go to blank on first pass */
                if (info->first_pass)
                {
                    save_loc.vcell_loc = vcell_loc;
                    save_loc.phys_row_offset = 0;
                    save_loc.phys_col_offset = 0;
                }

                // used in the setting the rows insensitive
                table->model->blank_trans_row = vcell_loc.virt_row;

                gnc_split_register_add_transaction (reg,
                                                    blank_trans, blank_split,
                                                    lead_cursor, split_cursor,
                                                    multi_line, start_primary_color,
                                                    info->blank_split_edited,
                                                    find_trans, find_split,
                                                    find_class, &new_split_row,
                                                    &vcell_loc);


                if (show_lower_divider)
                    table->model->dividing_row_lower = vcell_loc.virt_row; // blue bottom

                if (!multi_line)
                    start_primary_color = !start_primary_color;

                added_blank_trans = TRUE;
            }
        }

        /* On first load the split list is empty so fill up the quickfill cells
         * only on the next load. */
        if (!info->first_pass && !info->quickfill_setup)
            add_quickfill_completions (reg->table->layout, trans, split, has_last_num);

        gnc_completion_cell_add_menu_item (
            (CompletionCell*) gnc_table_layout_get_cell (reg->table->layout, DESC_CELL),
             xaccTransGetDescription (trans));

        if (trans == find_trans)
            new_trans_row = vcell_loc.virt_row;

        if (split == find_trans_split)
            new_trans_split_row = vcell_loc.virt_row;

        gnc_split_register_add_transaction (reg, trans, split,
                                            lead_cursor, split_cursor,
                                            multi_line, start_primary_color,
                                            TRUE,
                                            find_trans, find_split, find_class,
                                            &new_split_row, &vcell_loc);

        if (!multi_line)
            start_primary_color = !start_primary_color;
    }

    if (multi_line)
        g_hash_table_destroy (trans_table);

    /* add the blank split at the end. */
    if (pending_trans == blank_trans)
        found_pending = TRUE;

    /* No upper divider yet? Store it now */
    if (info->show_present_divider &&
        use_autoreadonly &&
        !found_divider_upper && need_divider_upper)
    {
        table->model->dividing_row_upper = vcell_loc.virt_row;
    }

    /* If we didn't find the pending transaction, it was removed
     * from the account. */
    if (!found_pending)
    {
        info->pending_trans_guid = *guid_null();
        if (xaccTransIsOpen (pending_trans))
            xaccTransCommitEdit (pending_trans);
        else if (pending_trans)
            g_assert_not_reached();

        pending_trans = NULL;
    }

    if (!added_blank_trans)
    {
        if (blank_trans == find_trans)
            new_trans_row = vcell_loc.virt_row;

        if (blank_split == find_trans_split)
            new_trans_split_row = vcell_loc.virt_row;

        /* go to blank on first pass */
        if (info->first_pass)
        {
            save_loc.vcell_loc = vcell_loc;
            save_loc.phys_row_offset = 0;
            save_loc.phys_col_offset = 0;
        }

        // used in the setting the rows insensitive
        table->model->blank_trans_row = vcell_loc.virt_row;

        gnc_split_register_add_transaction (reg, blank_trans, blank_split,
                                            lead_cursor, split_cursor,
                                            multi_line, start_primary_color,
                                            info->blank_split_edited,
                                            find_trans, find_split,
                                            find_class, &new_split_row,
                                            &vcell_loc);

        if (future_after_blank)
        {
            table->model->dividing_row_lower = vcell_loc.virt_row;
        }
    }

    /* go to blank on first pass */
    if (info->first_pass)
    {
        new_split_row = -1;
        new_trans_split_row = -1;
        new_trans_row = -1;
    }

    /* resize the table to the sizes we just counted above */
    /* num_virt_cols is always one. */
    gnc_table_set_size (table, vcell_loc.virt_row, 1);

    /* restore the cursor to its rightful position */
    {
        VirtualLocation trans_split_loc;

        if (new_split_row > 0)
            save_loc.vcell_loc.virt_row = new_split_row;
        else if (new_trans_split_row > 0)
            save_loc.vcell_loc.virt_row = new_trans_split_row;
        else if (new_trans_row > 0)
            save_loc.vcell_loc.virt_row = new_trans_row;

        trans_split_loc = save_loc;

        gnc_split_register_get_trans_split (reg, save_loc.vcell_loc,
                                            &trans_split_loc.vcell_loc);

        if (dynamic || multi_line || info->trans_expanded)
        {
            gnc_table_set_virt_cell_cursor (
                table, trans_split_loc.vcell_loc,
                gnc_split_register_get_active_cursor (reg));
            gnc_split_register_set_trans_visible (reg, trans_split_loc.vcell_loc,
                                                  TRUE, multi_line);

            info->trans_expanded = (reg->style == REG_STYLE_LEDGER);
        }
        else
        {
            save_loc = trans_split_loc;
            info->trans_expanded = FALSE;
        }

        if (gnc_table_find_close_valid_cell (table, &save_loc, FALSE))
        {
            gnc_table_move_cursor_gui (table, save_loc);
            new_split_row = save_loc.vcell_loc.virt_row;

            if (find_split == gnc_split_register_get_current_split (reg))
                gnc_table_restore_current_cursor (table, cursor_buffer);
        }
    }
    gnc_cursor_buffer_destroy (cursor_buffer);
    cursor_buffer = NULL;

    update_info (info, reg);

    gnc_split_register_set_cell_fractions (
        reg, gnc_split_register_get_current_split (reg));

    gnc_table_refresh_gui (table, TRUE);

    // if in reverse order, always show the first transaction
    if (table->model->reverse_sort)
    {
        VirtualCellLocation vc_loc;
        vc_loc.virt_row = 0;
        vc_loc.virt_col = 0;
        gnc_split_register_show_trans (reg, vc_loc);
    }
    else
        gnc_split_register_show_trans (reg, table->current_cursor_loc.vcell_loc);

    /* enable callback for cursor user-driven moves */
    gnc_table_control_allow_move (table->control, TRUE);

    if (we_own_slist)
        g_list_free (slist);

    LEAVE (" ");
}

gnc_split_register_new()

SplitRegister* gnc_split_register_new	(	SplitRegisterType	type,
		SplitRegisterStyle	style,
		gboolean	use_double_line,
		gboolean	is_template,
		gboolean	mismatched_commodities
	)

Creates a new split register.

Parameters

type	a SplitRegisterType to use for the new register
style	a SplitRegisterStyle to use for the new register
use_double_line	TRUE to show two lines for transactions, FALSE for one
is_template	TRUE for a new template, FALSE otherwise

Returns

a newly created ::SplitRegister

Definition at line 2898 of file split-register.c.

{
    SplitRegister* reg;
    gboolean default_do_auto_complete = TRUE;

    reg = g_new0 (SplitRegister, 1);

    if (type >= NUM_SINGLE_REGISTER_TYPES)
        style = REG_STYLE_JOURNAL;

    gnc_split_register_init (reg,
                             type,
                             style,
                             use_double_line,
                             default_do_auto_complete,
                             is_template,
                             mismatched_commodities);

    return reg;
}

gnc_split_register_paste_current()

void gnc_split_register_paste_current

(

SplitRegister *

reg

)

Pastes a previous copied entity onto the current entity, but only if the copied and current entity have the same type.

Definition at line 907 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    CursorClass cursor_class;
    Transaction* trans;
    Transaction* blank_trans;
    Split* blank_split;
    Split* trans_split;
    Split* split;

    ENTER ("reg=%p", reg);

    if (copied_class == CURSOR_CLASS_NONE)
    {
        LEAVE ("no copied cursor class");
        return;
    }

    blank_split = xaccSplitLookup (&info->blank_split_guid,
                                   gnc_get_current_book ());
    blank_trans = xaccSplitGetParent (blank_split);
    split = gnc_split_register_get_current_split (reg);
    trans = gnc_split_register_get_current_trans (reg);

    trans_split = gnc_split_register_get_current_trans_split (reg, NULL);

    /* This shouldn't happen, but be paranoid. */
    if (trans == NULL)
    {
        LEAVE ("no transaction");
        return;
    }

    cursor_class = gnc_split_register_get_current_cursor_class (reg);

    /* Can't do anything with this. */
    if (cursor_class == CURSOR_CLASS_NONE)
    {
        LEAVE ("no current cursor class");
        return;
    }

    /* This shouldn't happen, but be paranoid. */
    if ((split == NULL) && (cursor_class == CURSOR_CLASS_TRANS))
    {
        g_warning ("BUG DETECTED: transaction cursor with no anchoring split!");
        LEAVE ("transaction cursor with no anchoring split");
        return;
    }

    if (cursor_class == CURSOR_CLASS_SPLIT)
    {
        const char* message = _ ("You are about to overwrite an existing split. "
                                 "Are you sure you want to do that?");
        const char* anchor_message = _ ("This is the split anchoring this transaction "
                                        "to the register. You may not overwrite it from "
                                        "this register window. You may overwrite it if "
                                        "you navigate to a register that shows another "
                                        "side of this same transaction.");

        if (copied_class == CURSOR_CLASS_TRANS)
        {
            /* An entire transaction was copied, but we're just on a split. */
            LEAVE ("can't copy trans to split");
            return;
        }

        if (split != NULL)
        {
            /* the General Journal does not have any anchoring splits */
            if ((reg->type != GENERAL_JOURNAL) &&
                split == gnc_split_register_get_current_trans_split (reg, NULL))
            {
                gnc_warning_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)),
                                    "%s", anchor_message);
                LEAVE ("anchore split");
                return;
            }
            else if (!gnc_verify_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)),
                                         FALSE, "%s", message))
            {
                LEAVE ("user cancelled");
                return;
            }
        }

        /* Open the transaction for editing. */
        if (gnc_split_register_begin_edit_or_warn (info, trans))
        {
            LEAVE ("can't begin editing");
            return;
        }

        gnc_suspend_gui_refresh ();

        if (split == NULL)
        {
            /* We are on a null split in an expanded transaction. */
            split = xaccMallocSplit (gnc_get_current_book ());
            xaccSplitSetParent (split, trans);
        }

        if (copied_item.ftype != GNC_TYPE_SPLIT)
        {
            LEAVE ("copy buffer doesn't represent a split");
            return;
        }

        gnc_float_split_to_split (copied_item.fs, split);
    }
    else
    {
        const char *message = _("You are about to overwrite an existing "
                                "transaction. "
                                "Are you sure you want to do that?");
        Account * copied_leader;
        Account * default_account;
        int trans_split_index;
        int split_index;
        int num_splits;

        if (copied_class == CURSOR_CLASS_SPLIT)
        {
            LEAVE ("can't copy split to transaction");
            return;
        }


        if (copied_item.ftype != GNC_TYPE_TRANSACTION)
        {
            LEAVE ("copy buffer doesn't represent a transaction");
            return;
        }

        /* Ask before overwriting an existing transaction. */
        if (split != blank_split &&
            !gnc_verify_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)),
                                FALSE, "%s", message))
        {
            LEAVE ("user cancelled");
            return;
        }

        /* Open the transaction for editing. */
        if (gnc_split_register_begin_edit_or_warn (info, trans))
        {
            LEAVE ("can't begin editing");
            return;
        }

        gnc_suspend_gui_refresh ();

        DEBUG ("Pasting txn, trans=%p, split=%p, blank_trans=%p, blank_split=%p",
               trans, split, blank_trans, blank_split);

        split_index = xaccTransGetSplitIndex (trans, split);
        trans_split_index = xaccTransGetSplitIndex (trans, trans_split);

        copied_leader = xaccAccountLookup (&copied_leader_guid,
                                           gnc_get_current_book ());
        default_account = gnc_split_register_get_default_account (reg);
        if (copied_leader && default_account)
        {
            gnc_float_txn_to_txn_swap_accounts (copied_item.ft, trans,
                                                copied_leader,
                                                default_account, FALSE);
        }
        else
            gnc_float_txn_to_txn (copied_item.ft, trans, FALSE);

        num_splits = xaccTransCountSplits (trans);
        if (split_index >= num_splits)
            split_index = 0;

        if (trans == blank_trans)
        {
            /* In pasting, the blank split is deleted. Pick a new one. */
            blank_split = xaccTransGetSplit (trans, 0);
            info->blank_split_guid = *xaccSplitGetGUID (blank_split);
            info->blank_split_edited = TRUE;
            info->auto_complete = FALSE;
            DEBUG ("replacement blank_split=%p", blank_split);

            /* NOTE: At this point, the blank transaction virtual cell is still
             *       anchored by the old, deleted blank split. The register will
             *       have to be reloaded (redrawn) to correct this. */
        }

        info->cursor_hint_trans = trans;
        info->cursor_hint_split = xaccTransGetSplit (trans, split_index);
        info->cursor_hint_trans_split = xaccTransGetSplit (trans,
                                                           trans_split_index);
        info->cursor_hint_cursor_class = CURSOR_CLASS_TRANS;
    }

    /* Refresh the GUI. */
    gnc_resume_gui_refresh ();
    LEAVE (" ");
}

gnc_split_register_redraw()

void gnc_split_register_redraw

(

SplitRegister *

reg

)

Causes a redraw of the register window associated with reg.

Definition at line 1487 of file split-register.c.

{
    gnc_ledger_display_refresh_by_split_register (reg);
}

gnc_split_register_save()

gboolean gnc_split_register_save	(	SplitRegister *	reg,
		gboolean	do_commit
	)

Copy the contents of the current cursor to a split.

The split and transaction that are updated are the ones associated with the current cursor (register entry) position. If the do_commit flag is set, the transaction will also be committed. If it is the blank transaction, and the do_commit flag is set, a refresh will result in a new blank transaction. The method returns TRUE if something was changed.

Definition at line 1713 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    Transaction* pending_trans;
    Transaction* blank_trans;
    Transaction* trans;
    Account* account;
    Split* blank_split;
    const char* memo;
    const char* desc;
    Split* split;

    ENTER ("reg=%p, do_commit=%s", reg, do_commit ? "TRUE" : "FALSE");

    if (!reg)
    {
        LEAVE ("no register");
        return FALSE;
    }

    blank_split = xaccSplitLookup (&info->blank_split_guid,
                                   gnc_get_current_book ());

    pending_trans = xaccTransLookup (&info->pending_trans_guid,
                                     gnc_get_current_book ());

    blank_trans = xaccSplitGetParent (blank_split);

    /* get the handle to the current split and transaction */
    split = gnc_split_register_get_current_split (reg);
    trans = gnc_split_register_get_current_trans (reg);
    if (trans == NULL)
    {
        LEAVE ("no transaction");
        return FALSE;
    }

    /* use the changed flag to avoid heavy-weight updates
     * of the split & transaction fields. This will help
     * cut down on unnecessary register redraws. */
    if (!gnc_table_current_cursor_changed (reg->table, FALSE))
    {
        if (!do_commit)
        {
            LEAVE ("commit unnecessary");
            return FALSE;
        }

        if (!xaccTransIsOpen (trans))
        {
            LEAVE ("transaction not open");
            return FALSE;
        }

        if (trans == pending_trans ||
            (trans == blank_trans && info->blank_split_edited))
        {
            /* We are going to commit. */

            gnc_suspend_gui_refresh ();

            if (trans == blank_trans)
            {
                /* We have to clear the blank split before the
                 * refresh or a new one won't be created. */
                info->last_date_entered = xaccTransGetDate (trans);
                info->blank_split_guid = *guid_null ();
                info->blank_split_edited = FALSE;
                info->auto_complete = FALSE;
            }

            /* We have to clear the pending guid *before* committing the
             * trans, because the event handler will find it otherwise. */
            if (trans == pending_trans)
                info->pending_trans_guid = *guid_null ();

            PINFO ("committing trans (%p)", trans);
            unreconcile_splits (reg);
            xaccTransCommitEdit (trans);
            xaccTransRecordPrice (trans, PRICE_SOURCE_SPLIT_REG);

            gnc_resume_gui_refresh ();
        }
        else
            DEBUG ("leaving trans (%p) open", trans);

        LEAVE ("unchanged cursor");
        return TRUE;
    }

    DEBUG ("save split=%p", split);
    DEBUG ("blank_split=%p, blank_trans=%p, pending_trans=%p, trans=%p",
           blank_split, blank_trans, pending_trans, trans);

    /* Act on any changes to the current cell before the save. */
    if (!gnc_split_register_check_cell (reg,
                                        gnc_table_get_current_cell_name (reg->table)))
    {
        LEAVE ("need another go at changing cell");
        return FALSE;
    }

    if (!gnc_split_register_auto_calc (reg, split))
    {
        LEAVE ("auto calc failed");
        return FALSE;
    }

    /* Validate the transfer account names */
    (void)gnc_split_register_get_account (reg, MXFRM_CELL);
    (void)gnc_split_register_get_account (reg, XFRM_CELL);

    /* Maybe deal with exchange-rate transfers */
    if (gnc_split_register_handle_exchange (reg, FALSE))
    {
        LEAVE ("no exchange rate");
        return TRUE;
    }

    gnc_suspend_gui_refresh ();

    /* determine whether we should commit the pending transaction */
    if (pending_trans != trans)
    {
        // FIXME: How could the pending transaction not be open?
        // FIXME: For that matter, how could an open pending
        // transaction ever not be the current trans?
        if (xaccTransIsOpen (pending_trans))
        {
            g_warning ("Impossible? committing pending %p", pending_trans);
            unreconcile_splits (reg);
            xaccTransCommitEdit (pending_trans);
            xaccTransRecordPrice (trans, PRICE_SOURCE_SPLIT_REG);
        }
        else if (pending_trans)
        {
            g_critical ("BUG DETECTED! pending transaction (%p) not open",
                        pending_trans);
            g_assert_not_reached ();
        }

        if (trans == blank_trans)
        {
            /* Don't begin editing the blank trans, because it's
               already open, but mark it pending now. */
            g_assert (xaccTransIsOpen (blank_trans));
            /* This is now the pending transaction */
            info->pending_trans_guid = *xaccTransGetGUID (blank_trans);
        }
        else
        {
            PINFO ("beginning edit of trans %p", trans);
            if (gnc_split_register_begin_edit_or_warn (info, trans))
            {
                gnc_resume_gui_refresh ();
                LEAVE ("transaction opened elsewhere");
                return FALSE;
            }
        }
        pending_trans = trans;
    }
    g_assert (xaccTransIsOpen (trans));

    /* If we are saving a brand new transaction and the blank split hasn't
     * been edited, then we need to give it a default account. */
    /* Q: Why check 'split == blank_split'? Isn't 'trans == blank_trans'
     *    even better? What if there were some way that we could be on
     *    a row other than the transaction row or blank split row, but
     *    the blank split still hasn't been edited? It seems to be assumed
     *    that it isn't possible, but... -Charles, Jan 2009 */
    if (split == blank_split && !info->blank_split_edited)
    {
        /* If we've reached this point, it means that the blank split is
         * anchoring the transaction - see gnc_split_register_add_transaction ()
         * for an explanation - and the transaction has been edited (as evidenced
         * by the earlier check for a changed cursor.) Since the blank split
         * itself has not been edited, we'll have to assign a default account. */
        account = gnc_split_register_get_default_account (reg);
        if (account)
            xaccSplitSetAccount (blank_split, account);
        xaccTransSetDateEnteredSecs (trans, gnc_time (NULL));
    }

    if (split == NULL)
    {
        /* If we were asked to save data for a row for which there is no
         * associated split, then assume that this was an "empty" row - see
         * gnc_split_register_add_transaction () for an explanation. This row
         * is used to add splits to an existing transaction, or to add the
         * 2nd through nth split rows to a brand new transaction.
         * xaccSRGetCurrent will handle this case, too. We will create
         * a new split, copy the row contents to that split, and append
         * the split to the pre-existing transaction. */
        Split* trans_split;

        split = xaccMallocSplit (gnc_get_current_book ());
        xaccTransAppendSplit (trans, split);

        gnc_table_set_virt_cell_data (reg->table,
                                      reg->table->current_cursor_loc.vcell_loc,
                                      xaccSplitGetGUID (split));
        DEBUG ("assigned cell to new split=%p", split);

        trans_split = gnc_split_register_get_current_trans_split (reg, NULL);
        if ((info->cursor_hint_trans == trans) &&
            (info->cursor_hint_trans_split == trans_split) &&
            (info->cursor_hint_split == NULL))
        {
            info->cursor_hint_split = split;
            info->cursor_hint_cursor_class = CURSOR_CLASS_SPLIT;
        }
    }

    DEBUG ("updating trans=%p", trans);

    {
        SRSaveData* sd;

        sd = gnc_split_register_save_data_new (
            trans, split, (info->trans_expanded ||
                           reg->style == REG_STYLE_AUTO_LEDGER ||
                           reg->style == REG_STYLE_JOURNAL));
        gnc_table_save_cells (reg->table, sd);
        gnc_split_register_save_data_destroy (sd);
    }

    memo = xaccSplitGetMemo (split);
    memo = memo ? memo : "(null)";
    desc = xaccTransGetDescription (trans);
    desc = desc ? desc : "(null)";
    PINFO ("finished saving split \"%s\" of trans \"%s\"", memo, desc);

    /* If the modified split is the "blank split", then it is now an
     * official part of the account. Set the blank split to NULL, so we
     * can be sure of getting a new blank split. Also, save the date
     * for the new blank split. */
    if (trans == blank_trans)
    {
        if (do_commit)
        {
            info->blank_split_guid = *guid_null ();
            info->auto_complete = FALSE;
            blank_split = NULL;
            info->last_date_entered = xaccTransGetDate (trans);
        }
        else
            info->blank_split_edited = TRUE;
    }

    /* If requested, commit the current transaction and set the pending
     * transaction to NULL. */
    if (do_commit)
    {
        g_assert (trans == blank_trans || trans == pending_trans);
        if (pending_trans == trans)
        {
            pending_trans = NULL;
            info->pending_trans_guid = *guid_null ();
        }
        unreconcile_splits (reg);
        xaccTransCommitEdit (trans);
        xaccTransRecordPrice (trans, PRICE_SOURCE_SPLIT_REG);
    }

    gnc_table_clear_current_cursor_changes (reg->table);

    gnc_resume_gui_refresh ();

    LEAVE (" ");
    return TRUE;
}

gnc_split_register_set_auto_complete()

void gnc_split_register_set_auto_complete	(	SplitRegister *	reg,
		gboolean	do_auto_complete
	)

Sets whether a register uses auto-completion.

Parameters

reg	a ::SplitRegister
do_auto_complete	TRUE to use auto-completion, FALSE otherwise

Definition at line 2974 of file split-register.c.

{
    g_return_if_fail (reg);
    reg->do_auto_complete = do_auto_complete;
}

gnc_split_register_set_data()

void gnc_split_register_set_data	(	SplitRegister *	reg,
		gpointer	user_data,
		SRGetParentCallback	get_parent
	)

Sets the user data and callback hooks for the register.

gnc_split_register_set_read_only()

void gnc_split_register_set_read_only	(	SplitRegister *	reg,
		gboolean	read_only
	)

Sets whether a register window is "read only".

Parameters

reg	a ::SplitRegister
read_only	TRUE to use "read only" mode, FALSE otherwise

Definition at line 3133 of file split-register.c.

{
    gnc_table_model_set_read_only (reg->table->model, read_only);
}

gnc_split_register_set_reverse_sort()

void gnc_split_register_set_reverse_sort	(	SplitRegister *	reg,
		gboolean	reverse_sort
	)

Sets a split register's reverse sort order based on register.

Parameters

reg	a ::SplitRegister
reverse_sort	TRUE reverse sort order, FALSE default

Definition at line 2967 of file split-register.c.

{
    g_return_if_fail (reg);
    gnc_table_model_set_reverse_sort (reg->table->model, reverse_sort);
}

gnc_split_register_set_template_account()

void gnc_split_register_set_template_account	(	SplitRegister *	reg,
		Account *	template_account
	)

Set the template account for use in a template register.

Parameters

reg	a ::SplitRegister
template_account	the account to use for the template

Definition at line 117 of file split-register-util.c.

{
    SRInfo *info = gnc_split_register_get_info (reg);

    g_return_if_fail (reg != NULL);

    info->template_account = *xaccAccountGetGUID (template_account);
}

gnc_split_register_set_trans_visible()

void gnc_split_register_set_trans_visible	(	SplitRegister *	reg,
		VirtualCellLocation	vcell_loc,
		gboolean	visible,
		gboolean	only_blank_split
	)

Set the visibility of the split rows belonging to a transaction located at vcell_loc.

If only_blank_split is TRUE, only the row used for entering an additional split is affected. Despite the name, this should not be confused with the "blank split" row used for entering the first split of a brand-new transaction. Instead, here it only refers to rows not tied to any split at all, such as those created for entering new splits on old transactions or the 2nd through nth split on brand-new transactions.

Definition at line 317 of file split-register-util.c.

{
    CursorClass cursor_class;

    while (TRUE)
    {
        vcell_loc.virt_row++;

        cursor_class = gnc_split_register_get_cursor_class (reg, vcell_loc);
        if (cursor_class != CURSOR_CLASS_SPLIT)
            return;

        if (only_blank_split && gnc_split_register_get_split (reg, vcell_loc))
            continue;

        gnc_table_set_virt_cell_visible (reg->table, vcell_loc, visible);
    }
}

gnc_split_register_show_present_divider()

void gnc_split_register_show_present_divider	(	SplitRegister *	reg,
		gboolean	show_present
	)

If TRUE, visually indicate the demarcation between splits with post dates prior to the present, and after.

This will only make sense if the splits are ordered primarily by post date.

Definition at line 2513 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);

    if (reg == NULL)
        return;

    info->show_present_divider = show_present;
}

gnc_split_register_unvoid_current_trans()

void gnc_split_register_unvoid_current_trans

(

SplitRegister *

reg

)

Unvoids the transaction associated with the current cursor, if non-NULL.

Definition at line 1323 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    Transaction* pending_trans;
    Transaction* trans;
    Split* blank_split;
    Split* split;

    if (!reg) return;

    blank_split = xaccSplitLookup (&info->blank_split_guid,
                                   gnc_get_current_book ());
    pending_trans = xaccTransLookup (&info->pending_trans_guid,
                                     gnc_get_current_book ());

    /* get the current split based on cursor position */
    split = gnc_split_register_get_current_split (reg);
    if (split == NULL)
        return;

    /* Bail if trying to unvoid the blank split. */
    if (split == blank_split)
        return;

    /* not voided. */
    if (xaccSplitGetReconcile (split) != VREC)
        return;

    info->trans_expanded = FALSE;

    gnc_suspend_gui_refresh ();

    trans = xaccSplitGetParent (split);

    xaccTransUnvoid (trans);

    /* Check pending transaction */
    if (trans == pending_trans)
    {
        info->pending_trans_guid = *guid_null ();
        pending_trans = NULL;
    }

    gnc_resume_gui_refresh ();
}

gnc_split_register_void_current_trans()

void gnc_split_register_void_current_trans	(	SplitRegister *	reg,
		const char *	reason
	)

Voids the transaction associated with the current cursor, if non-NULL.

Definition at line 1273 of file split-register.c.

{
    SRInfo* info = gnc_split_register_get_info (reg);
    Transaction* pending_trans;
    Transaction* trans;
    Split* blank_split;
    Split* split;

    if (!reg) return;

    blank_split = xaccSplitLookup (&info->blank_split_guid,
                                   gnc_get_current_book ());
    pending_trans = xaccTransLookup (&info->pending_trans_guid,
                                     gnc_get_current_book ());

    /* get the current split based on cursor position */
    split = gnc_split_register_get_current_split (reg);
    if (split == NULL)
        return;

    /* Bail if trying to void the blank split. */
    if (split == blank_split)
        return;

    /* already voided. */
    if (xaccSplitGetReconcile (split) == VREC)
        return;

    info->trans_expanded = FALSE;

    gnc_suspend_gui_refresh ();

    trans = xaccSplitGetParent (split);
    xaccTransVoid (trans, reason);

    /* Check pending transaction */
    if (trans == pending_trans)
    {
        info->pending_trans_guid = *guid_null ();
        pending_trans = NULL;
    }
    if (xaccTransIsOpen (trans))
    {
        PERR ("We should not be voiding an open transaction.");
        xaccTransCommitEdit (trans);
    }
    gnc_resume_gui_refresh ();
}