Business Register

A specialized register for Accounts Payable and Accounts Receivable. More...

Files
file	gncEntryLedger.h
file	gncEntryLedgerControl.h
file	gncEntryLedgerLayout.h
file	gncEntryLedgerModel.h
file	gncEntryLedgerP.h

Data Structures
struct	GncEntryLedger

Macros
#define	ENTRY_IACCT_CELL   "inv-account"
#define	ENTRY_BACCT_CELL   "bill-account"
#define	ENTRY_ACTN_CELL   "action"
#define	ENTRY_DATE_CELL   "date"
#define	ENTRY_DESC_CELL   "description"
#define	ENTRY_DISC_CELL   "discount"
#define	ENTRY_DISTYPE_CELL   "discount-type"
#define	ENTRY_DISHOW_CELL   "discount-how"
#define	ENTRY_PRIC_CELL   "price"
#define	ENTRY_QTY_CELL   "quantity"
#define	ENTRY_TAXABLE_CELL   "istaxable"
#define	ENTRY_TAXTABLE_CELL   "taxtable"
#define	ENTRY_TAXINCLUDED_CELL   "taxincluded"
#define	ENTRY_BILLABLE_CELL   "isbillable"
#define	ENTRY_INV_CELL   "isinvoiced"
#define	ENTRY_VALUE_CELL   "line-value"
#define	ENTRY_TAXVAL_CELL   "line-tax-val"
#define	ENTRY_PAYMENT_CELL   "payment"

Enumerations
enum	GncEntryLedgerType {   GNC_ENTRY_ORDER_NONE = -1 , GNCENTRY_ORDER_ENTRY , GNCENTRY_ORDER_VIEWER , GNCENTRY_INVOICE_ENTRY ,   GNCENTRY_INVOICE_VIEWER , GNCENTRY_CUST_CREDIT_NOTE_ENTRY , GNCENTRY_CUST_CREDIT_NOTE_VIEWER , GNCENTRY_BILL_ENTRY ,   GNCENTRY_BILL_VIEWER , GNCENTRY_VEND_CREDIT_NOTE_ENTRY , GNCENTRY_VEND_CREDIT_NOTE_VIEWER , GNCENTRY_EXPVOUCHER_ENTRY ,   GNCENTRY_EXPVOUCHER_VIEWER , GNCENTRY_EMPL_CREDIT_NOTE_ENTRY , GNCENTRY_EMPL_CREDIT_NOTE_VIEWER , GNCENTRY_NUM_REGISTER_TYPES }

Functions
GncEntryLedger *	gnc_entry_ledger_new (QofBook *book, GncEntryLedgerType type)
	Create and return a new GncEntry Ledger.
void	gnc_entry_ledger_set_default_order (GncEntryLedger *ledger, GncOrder *order)
	Set the default order for this ledger.
void	gnc_entry_ledger_set_default_invoice (GncEntryLedger *ledger, GncInvoice *invoice)
	Set the default invoice for this ledger.
void	gnc_entry_ledger_destroy (GncEntryLedger *ledger)
	Destroy the GncEntry Ledger.
GncEntry *	gnc_entry_ledger_get_current_entry (GncEntryLedger *ledger)
	Returns the Entry where the cursor is currently located.
void	gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list)
	Copy GncEntry information from the list to the rows of the Ledger.
void	gnc_entry_ledger_display_refresh (GncEntryLedger *ledger)
Table *	gnc_entry_ledger_get_table (GncEntryLedger *ledger)
	Get the Table.
void	gnc_entry_ledger_set_parent (GncEntryLedger *ledger, GtkWidget *parent)
void	gnc_entry_ledger_set_readonly (GncEntryLedger *ledger, gboolean readonly)
gboolean	gnc_entry_ledger_changed (GncEntryLedger *ledger)
void	gnc_entry_ledger_cancel_cursor_changes (GncEntryLedger *ledger)
gboolean	gnc_entry_ledger_commit_entry (GncEntryLedger *ledger)
	This will act just like hitting 'return' to record an entry.
gboolean	gnc_entry_ledger_check_close (GtkWidget *parent, GncEntryLedger *ledger)
	This will ask the user if they really want to make a change.
void	gnc_entry_ledger_reset_query (GncEntryLedger *ledger)
GncEntry *	gnc_entry_ledger_get_entry (GncEntryLedger *ledger, VirtualCellLocation vcell_loc)
	Returns the GncEntry at the given location, or NULL if the location is not valid.
GncEntry *	gnc_entry_ledger_get_blank_entry (GncEntryLedger *ledger)
	Returns the GncEntry that represents the blank new line at the bottom of the ledger.
gboolean	gnc_entry_ledger_get_entry_virt_loc (GncEntryLedger *ledger, const GncEntry *entry, VirtualCellLocation *vcell_loc)
	Looks up the cell location of the given "entry" and writes the location into the variable pointed to by vcell_loc (which must be non-NULL).
void	gnc_entry_ledger_delete_current_entry (GncEntryLedger *ledger)
void	gnc_entry_ledger_duplicate_current_entry (GncEntryLedger *ledger)
void	gnc_entry_ledger_move_current_entry_updown (GncEntryLedger *ledger, gboolean move_up)
	This implements the command of moving the current entry (where the cursor is currently located) one row upwards or downwards, effectively swapping this row and the other row.
QofQuery *	gnc_entry_ledger_get_query (GncEntryLedger *ledger)
void	gnc_entry_ledger_set_prefs_group (GncEntryLedger *ledger, const gchar *string)
TableControl *	gnc_entry_ledger_control_new (void)
TableLayout *	gnc_entry_ledger_layout_new (GncEntryLedger *ledger)
TableModel *	gnc_entry_ledger_model_new (GncEntryLedgerType type)
	Public Interface.
Account *	gnc_entry_ledger_get_account_by_name (GncEntryLedger *ledger, BasicCell *bcell, const char *name, gboolean *isnew)
Account *	gnc_entry_ledger_get_account (GncEntryLedger *ledger, const char *cell_name)
GncTaxTable *	gnc_entry_ledger_get_taxtable (GncEntryLedger *ledger, const char *cell_name)
gint	gnc_entry_ledger_get_type (GncEntryLedger *ledger, const char *cell_name)
gboolean	gnc_entry_ledger_get_checkmark (GncEntryLedger *ledger, const char *cell_name)
gboolean	gnc_entry_ledger_get_numeric (GncEntryLedger *ledger, const char *cell_name, gnc_numeric *value)
const char *	gnc_entry_ledger_type_string_getter (char flag)
const char *	gnc_entry_ledger_how_string_getter (char flag)
gboolean	gnc_entry_ledger_find_entry (GncEntryLedger *ledger, GncEntry *entry, VirtualCellLocation *vcell_loc)
void	gnc_entry_ledger_load_xfer_cells (GncEntryLedger *ledger)
void	gnc_entry_ledger_display_init (GncEntryLedger *ledger)
void	gnc_entry_ledger_display_fini (GncEntryLedger *ledger)
void	gnc_entry_ledger_compute_value (GncEntryLedger *ledger, gnc_numeric *value, gnc_numeric *tax_value)

Detailed Description

A specialized register for Accounts Payable and Accounts Receivable.

Macro Definition Documentation

ENTRY_ACTN_CELL

#define ENTRY_ACTN_CELL   "action"

Definition at line 60 of file gncEntryLedger.h.

ENTRY_BACCT_CELL

#define ENTRY_BACCT_CELL   "bill-account"

Definition at line 59 of file gncEntryLedger.h.

ENTRY_BILLABLE_CELL

#define ENTRY_BILLABLE_CELL   "isbillable"

Definition at line 71 of file gncEntryLedger.h.

ENTRY_DATE_CELL

#define ENTRY_DATE_CELL   "date"

Definition at line 61 of file gncEntryLedger.h.

ENTRY_DESC_CELL

#define ENTRY_DESC_CELL   "description"

Definition at line 62 of file gncEntryLedger.h.

ENTRY_DISC_CELL

#define ENTRY_DISC_CELL   "discount"

Definition at line 63 of file gncEntryLedger.h.

ENTRY_DISHOW_CELL

#define ENTRY_DISHOW_CELL   "discount-how"

Definition at line 65 of file gncEntryLedger.h.

ENTRY_DISTYPE_CELL

#define ENTRY_DISTYPE_CELL   "discount-type"

Definition at line 64 of file gncEntryLedger.h.

ENTRY_IACCT_CELL

#define ENTRY_IACCT_CELL   "inv-account"

Definition at line 58 of file gncEntryLedger.h.

ENTRY_INV_CELL

#define ENTRY_INV_CELL   "isinvoiced"

Definition at line 73 of file gncEntryLedger.h.

ENTRY_PAYMENT_CELL

#define ENTRY_PAYMENT_CELL   "payment"

Definition at line 77 of file gncEntryLedger.h.

ENTRY_PRIC_CELL

#define ENTRY_PRIC_CELL   "price"

Definition at line 66 of file gncEntryLedger.h.

ENTRY_QTY_CELL

#define ENTRY_QTY_CELL   "quantity"

Definition at line 67 of file gncEntryLedger.h.

ENTRY_TAXABLE_CELL

#define ENTRY_TAXABLE_CELL   "istaxable"

Definition at line 68 of file gncEntryLedger.h.

ENTRY_TAXINCLUDED_CELL

#define ENTRY_TAXINCLUDED_CELL   "taxincluded"

Definition at line 70 of file gncEntryLedger.h.

ENTRY_TAXTABLE_CELL

#define ENTRY_TAXTABLE_CELL   "taxtable"

Definition at line 69 of file gncEntryLedger.h.

ENTRY_TAXVAL_CELL

#define ENTRY_TAXVAL_CELL   "line-tax-val"

Definition at line 75 of file gncEntryLedger.h.

ENTRY_VALUE_CELL

#define ENTRY_VALUE_CELL   "line-value"

Definition at line 74 of file gncEntryLedger.h.

Enumeration Type Documentation

GncEntryLedgerType

enum GncEntryLedgerType

Definition at line 38 of file gncEntryLedger.h.

{
    GNC_ENTRY_ORDER_NONE = -1, //Force clang to use int representation of enum.
    GNCENTRY_ORDER_ENTRY,
    GNCENTRY_ORDER_VIEWER,
    GNCENTRY_INVOICE_ENTRY,
    GNCENTRY_INVOICE_VIEWER,
    GNCENTRY_CUST_CREDIT_NOTE_ENTRY,
    GNCENTRY_CUST_CREDIT_NOTE_VIEWER,
    GNCENTRY_BILL_ENTRY,
    GNCENTRY_BILL_VIEWER,
    GNCENTRY_VEND_CREDIT_NOTE_ENTRY,
    GNCENTRY_VEND_CREDIT_NOTE_VIEWER,
    GNCENTRY_EXPVOUCHER_ENTRY,
    GNCENTRY_EXPVOUCHER_VIEWER,
    GNCENTRY_EMPL_CREDIT_NOTE_ENTRY,
    GNCENTRY_EMPL_CREDIT_NOTE_VIEWER,
    GNCENTRY_NUM_REGISTER_TYPES
} GncEntryLedgerType;

Function Documentation

gnc_entry_ledger_cancel_cursor_changes()

void gnc_entry_ledger_cancel_cursor_changes

(

GncEntryLedger *

ledger

)

Definition at line 956 of file gncEntryLedgerControl.c.

{
    VirtualLocation virt_loc;
 
    if (ledger == NULL)
        return;
 
    virt_loc = ledger->table->current_cursor_loc;
 
    if (!gnc_table_current_cursor_changed (ledger->table, FALSE))
        return;
 
    /* When cancelling edits, reload the cursor from the entry. */
    gnc_table_clear_current_cursor_changes (ledger->table);
 
    if (gnc_table_find_close_valid_cell (ledger->table, &virt_loc, FALSE))
        gnc_table_move_cursor_gui (ledger->table, virt_loc);
 
    gnc_table_refresh_gui (ledger->table, TRUE);
}

gnc_entry_ledger_changed()

gboolean gnc_entry_ledger_changed

(

GncEntryLedger *

ledger

)

Definition at line 694 of file gncEntryLedger.c.

{
    if (!ledger)
        return FALSE;
 
    if (gnc_table_current_cursor_changed (ledger->table, FALSE))
        return TRUE;
 
    return FALSE;
}

gnc_entry_ledger_check_close()

gboolean gnc_entry_ledger_check_close	(	GtkWidget *	parent,
		GncEntryLedger *	ledger
	)

This will ask the user if they really want to make a change.

Definition at line 1012 of file gncEntryLedgerControl.c.

{
    if (!ledger) return TRUE;
 
    if (gnc_entry_ledger_changed (ledger))
    {
        gboolean dontask = FALSE;
 
        if (ledger->type ==  GNCENTRY_INVOICE_ENTRY ||
                ledger->type ==  GNCENTRY_CUST_CREDIT_NOTE_ENTRY)
        {
            gboolean inv_value;
            gboolean only_inv_changed = FALSE;
 
            if (gnc_table_current_cursor_changed (ledger->table, FALSE) == 1 &&
                    gnc_table_layout_get_cell_changed (ledger->table->layout,
                            ENTRY_INV_CELL, TRUE))
                only_inv_changed = TRUE;
 
            inv_value = gnc_entry_ledger_get_checkmark (ledger, ENTRY_INV_CELL);
 
            if (inv_value && only_inv_changed)
            {
                /* If the only change is that the 'inv' entry was clicked
                 * "on", then just accept the change it without question.
                 */
                dontask = TRUE;
            }
        }
 
        return gnc_entry_ledger_check_close_internal (parent, ledger, dontask);
 
    }
    return TRUE;
}

gnc_entry_ledger_commit_entry()

gboolean gnc_entry_ledger_commit_entry

(

GncEntryLedger *

ledger

)

This will act just like hitting 'return' to record an entry.

Definition at line 1004 of file gncEntryLedgerControl.c.

{
    if (!ledger) return TRUE;
 
    return gnc_entry_ledger_check_close_internal (NULL, ledger, TRUE);
}

gnc_entry_ledger_compute_value()

void gnc_entry_ledger_compute_value	(	GncEntryLedger *	ledger,
		gnc_numeric *	value,
		gnc_numeric *	tax_value
	)

Definition at line 706 of file gncEntryLedger.c.

{
    gnc_numeric qty = gnc_numeric_zero(), price = gnc_numeric_zero(), discount = gnc_numeric_zero();
    gint disc_type, disc_how;
    gboolean taxable, taxincluded;
    GncTaxTable *table;
    GList *taxes = NULL;
    int denom = 100;
    gnc_numeric value_unrounded, taxes_unrounded;
    GncEntry *entry;
 
    gnc_entry_ledger_get_numeric (ledger, ENTRY_QTY_CELL, &qty);
    entry = gnc_entry_ledger_get_current_entry (ledger);
    if (ledger->is_cust_doc)
        price = gncEntryGetInvPrice (entry);
    else
        price = gncEntryGetBillPrice (entry);
    gnc_entry_ledger_get_numeric (ledger, ENTRY_DISC_CELL, &discount);
 
    disc_type = gnc_entry_ledger_get_type (ledger, ENTRY_DISTYPE_CELL);
    disc_how = gnc_entry_ledger_get_type (ledger, ENTRY_DISHOW_CELL);
 
    /* Some ledger types (see full list in gnc_entry_ledger_set_cells)
       don't have discounts */
    if (ledger->type == GNCENTRY_BILL_ENTRY ||
        ledger->type == GNCENTRY_BILL_VIEWER ||
        ledger->type == GNCENTRY_VEND_CREDIT_NOTE_ENTRY ||
        ledger->type == GNCENTRY_VEND_CREDIT_NOTE_VIEWER ||
        ledger->type == GNCENTRY_EXPVOUCHER_ENTRY ||
        ledger->type == GNCENTRY_EXPVOUCHER_VIEWER ||
        ledger->type == GNCENTRY_EMPL_CREDIT_NOTE_ENTRY ||
        ledger->type == GNCENTRY_EMPL_CREDIT_NOTE_VIEWER)
    {
        g_assert (gnc_numeric_zero_p (discount));
        disc_type = GNC_AMT_TYPE_VALUE;
        disc_how = GNC_DISC_PRETAX;
    }
 
 
    /* If we're so early in the process that we don't have info, stop now */
    if (disc_type < 0 || disc_how < 0)
    {
        if (value)
            *value = gnc_numeric_zero ();
        if (tax_value)
            *tax_value = gnc_numeric_zero ();
        return;
    }
 
    taxable = gnc_entry_ledger_get_checkmark (ledger, ENTRY_TAXABLE_CELL);
    taxincluded = gnc_entry_ledger_get_checkmark (ledger, ENTRY_TAXINCLUDED_CELL);
    table = gnc_entry_ledger_get_taxtable (ledger, ENTRY_TAXTABLE_CELL);
 
    /* Expense vouchers don't have taxable, taxincluded, or taxtable cells, either */
    if (ledger->type == GNCENTRY_EXPVOUCHER_ENTRY ||
            ledger->type == GNCENTRY_EXPVOUCHER_VIEWER)
    {
        taxable = FALSE;
        taxincluded = FALSE;
        table = NULL;
    }
 
    if (ledger->invoice)
    {
        gnc_commodity *currency = gncInvoiceGetCurrency(ledger->invoice);
        if (currency)
            denom = gnc_commodity_get_fraction(currency);
    }
 
    gncEntryComputeValue (qty, price, (taxable ? table : NULL), taxincluded,
                          discount, disc_type, disc_how, 0,
                          &value_unrounded, NULL, &taxes);
 
    if (value)
        *value = gnc_numeric_convert (value_unrounded, denom,
                                      GNC_HOW_RND_ROUND_HALF_UP);
 
    /* return the tax value */
    taxes_unrounded = gncAccountValueTotal (taxes);
    gncAccountValueDestroy (taxes);
    if (tax_value)
        *tax_value = gnc_numeric_convert (taxes_unrounded, denom,
                                          GNC_HOW_RND_ROUND_HALF_UP);
}

gnc_entry_ledger_control_new()

TableControl * gnc_entry_ledger_control_new

(

void

)

Definition at line 944 of file gncEntryLedgerControl.c.

{
    TableControl * control;
 
    control = gnc_table_control_new ();
    control->move_cursor = gnc_entry_ledger_move_cursor;
    control->traverse = gnc_entry_ledger_traverse;
 
    return control;
}

gnc_entry_ledger_delete_current_entry()

void gnc_entry_ledger_delete_current_entry

(

GncEntryLedger *

ledger

)

Definition at line 837 of file gncEntryLedger.c.

{
    GncEntry *entry;
 
    if (!ledger)
        return;
 
    /* If there is no entry, just return */
    entry = gnc_entry_ledger_get_current_entry (ledger);
    if (!entry)
        return;
 
    /* If this is the blank entry, just cancel the changes */
    if (entry == gnc_entry_ledger_get_blank_entry (ledger))
    {
        gnc_entry_ledger_cancel_cursor_changes (ledger);
        return;
    }
 
    /* Ok, let's delete this entry */
    gnc_suspend_gui_refresh ();
    if (!gncEntryIsOpen (entry))
        gncEntryBeginEdit (entry);
 
    {
        GncOrder *order;
        GncInvoice *invoice;
 
        order = gncEntryGetOrder (entry);
        if (order)
            gncOrderRemoveEntry (order, entry);
 
        invoice = gncEntryGetInvoice (entry);
        if (invoice)
            gncInvoiceRemoveEntry (invoice, entry);
 
        invoice = gncEntryGetBill (entry);
        if (invoice)
            gncBillRemoveEntry (invoice, entry);
 
        gncEntryDestroy (entry);
    }
    gnc_resume_gui_refresh ();
}

gnc_entry_ledger_destroy()

void gnc_entry_ledger_destroy

(

GncEntryLedger *

ledger

)

Destroy the GncEntry Ledger.

Definition at line 387 of file gncEntryLedger.c.

{
    if (!ledger) return;
 
    /* Destroy blank entry, etc. */
    gnc_entry_ledger_clear_blank_entry (ledger);
    gnc_entry_ledger_display_fini (ledger);
    gnc_table_destroy (ledger->table);
    qof_query_destroy (ledger->query);
    g_free (ledger);
}

gnc_entry_ledger_display_fini()

void gnc_entry_ledger_display_fini

(

GncEntryLedger *

ledger

)

Definition at line 192 of file gncEntryLedgerDisplay.c.

{
    if (!ledger) return;
 
    gnc_unregister_gui_component (ledger->component_id);
    gnc_prefs_remove_cb_by_func (GNC_PREFS_GROUP_GENERAL, GNC_PREF_ACCOUNT_SEPARATOR,
                                 gnc_entry_ledger_pref_changed, ledger);
}

gnc_entry_ledger_display_init()

void gnc_entry_ledger_display_init

(

GncEntryLedger *

ledger

)

Definition at line 177 of file gncEntryLedgerDisplay.c.

{
    if (!ledger) return;
 
    ledger->full_refresh = TRUE;
    ledger->component_id = gnc_register_gui_component (ENTRYLEDGER_CLASS,
                           refresh_handler,
                           NULL, ledger);
    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL, GNC_PREF_ACCOUNT_SEPARATOR,
                           gnc_entry_ledger_pref_changed, ledger);
 
    gnc_entry_ledger_display_refresh (ledger);
}

gnc_entry_ledger_display_refresh()

void gnc_entry_ledger_display_refresh

(

GncEntryLedger *

ledger

)

Definition at line 202 of file gncEntryLedgerDisplay.c.

{
    GList *entries;
 
    if (!ledger || ledger->loading) return;
 
    entries = gnc_entry_ledger_get_entries (ledger);
 
    gnc_entry_ledger_set_watches (ledger, entries);
 
    gnc_entry_ledger_refresh_internal (ledger, entries);
}

gnc_entry_ledger_duplicate_current_entry()

void gnc_entry_ledger_duplicate_current_entry

(

GncEntryLedger *

ledger

)

Definition at line 883 of file gncEntryLedger.c.

{
    GncEntry *entry;
    gboolean changed;
 
    if (!ledger)
        return;
 
    /* Be paranoid */
    entry = gnc_entry_ledger_get_current_entry (ledger);
    if (!entry)
        return;
 
    changed = gnc_table_current_cursor_changed (ledger->table, FALSE);
 
    /* See if we're asked to duplicate an unchanged blank entry --
     * there is no point in doing that.
     */
    if (!changed && entry == gnc_entry_ledger_get_blank_entry (ledger))
        return;
 
    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)
    {
        const char *title = _("Save the current entry?");
        const char *message =
            _("The current transaction has been changed. Would you like to "
              "record the changes before duplicating this entry, or "
              "cancel the duplication?");
        GtkWidget *dialog;
        gint response;
 
        dialog = gtk_message_dialog_new(GTK_WINDOW(ledger->parent),
                                        GTK_DIALOG_DESTROY_WITH_PARENT,
                                        GTK_MESSAGE_QUESTION,
                                        GTK_BUTTONS_NONE,
                                        "%s", title);
        gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
                "%s", message);
        gtk_dialog_add_buttons(GTK_DIALOG(dialog),
                               _("_Cancel"), GTK_RESPONSE_CANCEL,
                               _("_Record"), GTK_RESPONSE_ACCEPT,
                               NULL);
        response = gnc_dialog_run(GTK_DIALOG(dialog), GNC_PREF_WARN_INV_ENTRY_DUP);
        gtk_widget_destroy(dialog);
 
        if (response != GTK_RESPONSE_ACCEPT)
        {
            gnc_resume_gui_refresh ();
            return;
        }
 
        if (!gnc_entry_ledger_commit_entry (ledger))
        {
            gnc_resume_gui_refresh ();
            return;
        }
    }
 
    /* Ok, we're ready to make the copy */
    {
        GncEntry * new_entry;
 
        new_entry = gncEntryCreate (ledger->book);
        gncEntryCopy (entry, new_entry, TRUE);
        gncEntrySetDateGDate (new_entry, &ledger->last_date_entered);
 
        /* We also must set a new DateEntered on the new entry
         * because otherwise the ordering is not deterministic */
        gncEntrySetDateEntered (new_entry, gnc_time (NULL));
 
        /* Set the hint for where to display on the refresh */
        ledger->hint_entry = new_entry;
    }
 
    gnc_resume_gui_refresh ();
    return;
}

gnc_entry_ledger_find_entry()

gboolean gnc_entry_ledger_find_entry	(	GncEntryLedger *	ledger,
		GncEntry *	entry,
		VirtualCellLocation *	vcell_loc
	)

Definition at line 582 of file gncEntryLedger.c.

{
    Table *table = ledger->table;
    int v_row;
    GncEntry *e;
 
    for (v_row = 1; v_row < table->num_virt_rows; v_row++)
    {
        VirtualCellLocation vc_loc = { v_row, 0 };
 
        e = gnc_entry_ledger_get_entry (ledger, vc_loc);
 
        if (e == entry)
        {
            if (vcell_loc != NULL)
                *vcell_loc = vc_loc;
            return TRUE;
        }
    }
    return FALSE;
}

gnc_entry_ledger_get_account()

Account * gnc_entry_ledger_get_account	(	GncEntryLedger *	ledger,
		const char *	cell_name
	)

Definition at line 143 of file gncEntryLedger.c.

{
    BasicCell *cell;
    const char * name;
    gboolean dummy;
 
    cell = gnc_table_layout_get_cell (ledger->table->layout, cell_name);
    if (!cell)
        return NULL;
    name = gnc_basic_cell_get_value (cell);
    return gnc_entry_ledger_get_account_by_name (ledger, cell, name, &dummy);
}

gnc_entry_ledger_get_account_by_name()

Account * gnc_entry_ledger_get_account_by_name	(	GncEntryLedger *	ledger,
		BasicCell *	bcell,
		const char *	name,
		gboolean *	isnew
	)

Definition at line 82 of file gncEntryLedger.c.

{
    const char *placeholder = _("The account %s does not allow transactions.");
    const char *missing = _("The account %s does not exist. "
                            "Would you like to create it?");
    char *account_name;
    ComboCell *cell = (ComboCell *) bcell;
    Account *account;
    GList *account_types = NULL;
 
    /* Find the account */
    account = gnc_account_lookup_for_register (gnc_get_current_root_account (), name);
    if (!account)
        account = gnc_account_lookup_by_code (gnc_get_current_root_account(), name);
 
    if (!account)
    {
        /* Ask if they want to create a new one. */
        if (!gnc_verify_dialog (GTK_WINDOW (ledger->parent), TRUE, missing, name))
            return NULL;
 
        /* No changes, as yet. */
        *isnew = FALSE;
 
        /* User said yes, they want to create a new account. */
        account_types = g_list_prepend (account_types, (gpointer)ACCT_TYPE_CREDIT);
        account_types = g_list_prepend (account_types, (gpointer)ACCT_TYPE_ASSET);
        account_types = g_list_prepend (account_types, (gpointer)ACCT_TYPE_LIABILITY);
        if ( ledger->is_cust_doc )
            account_types = g_list_prepend (account_types, (gpointer)ACCT_TYPE_INCOME);
        else
            account_types = g_list_prepend (account_types, (gpointer)ACCT_TYPE_EXPENSE);
 
        account = gnc_ui_new_accounts_from_name_with_defaults (GTK_WINDOW (ledger->parent), name, account_types,
                                                               NULL, NULL);
        g_list_free ( account_types );
        if (!account)
            return NULL;
        *isnew = TRUE;
    }
    
    /* Now have a new account. Update the cell with the name as created. */
    account_name = gnc_get_account_name_for_register (account);
    if (g_strcmp0(account_name, gnc_basic_cell_get_value(bcell)))
    {
        gnc_combo_cell_set_value (cell, account_name);
        gnc_basic_cell_set_changed (&cell->cell, TRUE);
    }
    g_free (account_name);
 
    /* See if the account (either old or new) is a placeholder. */
    if (xaccAccountGetPlaceholder (account))
    {
        gnc_error_dialog (GTK_WINDOW (ledger->parent), placeholder, name);
    }
 
    /* Be seeing you. */
    return account;
}

gnc_entry_ledger_get_blank_entry()

GncEntry * gnc_entry_ledger_get_blank_entry

(

GncEntryLedger *

ledger

)

Returns the GncEntry that represents the blank new line at the bottom of the ledger.

Returns the GncEntry that represents the blank new line at the bottom of the ledger.

Definition at line 75 of file gncEntryLedger.c.

{
    if (!ledger) return NULL;
    return gncEntryLookup (ledger->book, &(ledger->blank_entry_guid));
}

gnc_entry_ledger_get_checkmark()

gboolean gnc_entry_ledger_get_checkmark	(	GncEntryLedger *	ledger,
		const char *	cell_name
	)

Definition at line 179 of file gncEntryLedger.c.

{
    CheckboxCell *cell =
        (CheckboxCell *) gnc_table_layout_get_cell (ledger->table->layout, cell_name);
 
    if (!cell)
        return FALSE;
 
    return cell->flag;
}

gnc_entry_ledger_get_current_entry()

GncEntry * gnc_entry_ledger_get_current_entry

(

GncEntryLedger *

ledger

)

Returns the Entry where the cursor is currently located.

Definition at line 232 of file gncEntryLedger.c.

{
    if (!ledger) return NULL;
 
    return
        gnc_entry_ledger_get_entry (ledger,
                                    ledger->table->current_cursor_loc.vcell_loc);
}

gnc_entry_ledger_get_entry()

GncEntry * gnc_entry_ledger_get_entry	(	GncEntryLedger *	ledger,
		VirtualCellLocation	vcell_loc
	)

Returns the GncEntry at the given location, or NULL if the location is not valid.

Definition at line 218 of file gncEntryLedger.c.

{
    GncGUID *guid;
 
    if (!ledger) return NULL;
 
    guid = gnc_table_get_vcell_data (ledger->table, vcell_loc);
    if (!guid) return NULL;
 
    return gncEntryLookup (ledger->book, guid);
}

gnc_entry_ledger_get_entry_virt_loc()

gboolean gnc_entry_ledger_get_entry_virt_loc	(	GncEntryLedger *	ledger,
		const GncEntry *	entry,
		VirtualCellLocation *	vcell_loc
	)

Looks up the cell location of the given "entry" and writes the location into the variable pointed to by vcell_loc (which must be non-NULL).

Returns TRUE if the entry was found, otherwise FALSE.

Definition at line 793 of file gncEntryLedger.c.

{
    Table *table;
    int v_row;
    int v_col;
 
    if ((ledger == NULL) || (entry == NULL))
        return FALSE;
    g_assert(vcell_loc);
 
    table = ledger->table;
 
    /* go backwards because typically you search for entries at the end */
 
    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;
            GncEntry *e;
 
            vcell = gnc_table_get_virtual_cell (table, vc_loc);
            if (vcell == NULL)
                continue;
 
            if (!vcell->visible)
                continue;
 
            e = gncEntryLookup (ledger->book, vcell->vcell_data);
 
            if (e == entry)
            {
                if (vcell_loc)
                    *vcell_loc = vc_loc;
 
                return TRUE;
            }
        }
 
    return FALSE;
}

gnc_entry_ledger_get_numeric()

gboolean gnc_entry_ledger_get_numeric	(	GncEntryLedger *	ledger,
		const char *	cell_name,
		gnc_numeric *	value
	)

Definition at line 203 of file gncEntryLedger.c.

{
    PriceCell *cell =
        (PriceCell *) gnc_table_layout_get_cell (ledger->table->layout, cell_name);
 
    if (!value || !cell)
        return FALSE;
 
    *value = gnc_price_cell_get_value (cell);
    return TRUE;
}

gnc_entry_ledger_get_query()

QofQuery * gnc_entry_ledger_get_query

(

GncEntryLedger *

ledger

)

Definition at line 966 of file gncEntryLedger.c.

{
    if (!ledger)
        return NULL;
 
    return ledger->query;
}

gnc_entry_ledger_get_table()

Table * gnc_entry_ledger_get_table

(

GncEntryLedger *

ledger

)

Get the Table.

Definition at line 399 of file gncEntryLedger.c.

{
    if (!ledger) return NULL;
    return ledger->table;
}

gnc_entry_ledger_get_taxtable()

GncTaxTable * gnc_entry_ledger_get_taxtable	(	GncEntryLedger *	ledger,
		const char *	cell_name
	)

Definition at line 157 of file gncEntryLedger.c.

{
    GncEntry *entry;
    const char * name;
 
    /* If the cursor has changed, then pull in the current table */
    if (gnc_table_layout_get_cell_changed (ledger->table->layout,
                                           cell_name, TRUE))
    {
        name = gnc_table_layout_get_cell_value (ledger->table->layout, cell_name);
        return gncTaxTableLookupByName (ledger->book, name);
    }
 
    /* If it has not changed, pull in the table from the entry */
    entry = gnc_entry_ledger_get_current_entry (ledger);
    if (ledger->is_cust_doc)
        return gncEntryGetInvTaxTable (entry);
    else
        return gncEntryGetBillTaxTable (entry);
}

gnc_entry_ledger_get_type()

gint gnc_entry_ledger_get_type	(	GncEntryLedger *	ledger,
		const char *	cell_name
	)

Definition at line 191 of file gncEntryLedger.c.

{
    RecnCell *cell =
        (RecnCell *) gnc_table_layout_get_cell (ledger->table->layout, cell_name);
 
    if (!cell)
        return -1;
 
    return (gnc_recn_cell_get_flag (cell) - '0');
}

gnc_entry_ledger_how_string_getter()

const char * gnc_entry_ledger_how_string_getter

(

char

flag

)

Definition at line 62 of file gncEntryLedgerLoad.c.

{
    switch (flag)
    {
    case '1':
        return _ ("<");
    case '2':
        return _ ("=");
    case '3':
        return _ (">");
    default:
        break;
    };
    return "?";
}

gnc_entry_ledger_layout_new()

TableLayout * gnc_entry_ledger_layout_new

(

GncEntryLedger *

ledger

)

Definition at line 290 of file gncEntryLedgerLayout.c.

{
    TableLayout *layout;
 
    layout = gnc_table_layout_new ();
    gnc_entry_ledger_layout_add_cells (ledger, layout);
    gnc_entry_ledger_layout_add_cursors (ledger, layout);
    gnc_entry_ledger_set_cells (ledger, layout);
 
    return layout;
}

gnc_entry_ledger_load()

void gnc_entry_ledger_load	(	GncEntryLedger *	ledger,
		GList *	entry_list
	)

Copy GncEntry information from the list to the rows of the Ledger.

Definition at line 329 of file gncEntryLedgerLoad.c.

{
    GncEntry* blank_entry, *find_entry;
    CursorBuffer* cursor_buffer;
    Table* table;
 
    GList* node;
    CellBlock* cursor_header, *cursor;
    VirtualCellLocation vcell_loc;
    VirtualLocation save_loc;
    gboolean start_primary_color = TRUE;
 
    int new_entry_row = -1;
 
    if (!ledger) return;
 
    /* Load up cells */
    load_discount_type_cells (ledger);
    load_discount_how_cells (ledger);
    gnc_entry_ledger_load_xfer_cells (ledger);
 
    blank_entry = gnc_entry_ledger_get_blank_entry (ledger);
 
    if (blank_entry == NULL && ledger->invoice == NULL && entry_list == NULL)
        return;
 
    if (blank_entry == NULL && ledger->invoice)
    {
        switch (ledger->type)
        {
        case GNCENTRY_ORDER_ENTRY:
        case GNCENTRY_INVOICE_ENTRY:
        case GNCENTRY_BILL_ENTRY:
        case GNCENTRY_EXPVOUCHER_ENTRY:
        case GNCENTRY_CUST_CREDIT_NOTE_ENTRY:
        case GNCENTRY_VEND_CREDIT_NOTE_ENTRY:
        case GNCENTRY_EMPL_CREDIT_NOTE_ENTRY:
 
            gnc_suspend_gui_refresh();
 
            blank_entry = gncEntryCreate (ledger->book);
            gncEntrySetDateGDate (blank_entry, &ledger->last_date_entered);
            ledger->blank_entry_guid = *gncEntryGetGUID (blank_entry);
 
            gnc_resume_gui_refresh();
 
            /* The rest of this does not apply to expense vouchers */
            if (ledger->type != GNCENTRY_EXPVOUCHER_ENTRY)
            {
                const GncOwner* owner = gncOwnerGetEndOwner (gncInvoiceGetOwner (
                                                                 ledger->invoice));
                GncTaxTable* table = NULL;
                GncTaxIncluded taxincluded_p = GNC_TAXINCLUDED_USEGLOBAL;
                gboolean taxincluded = FALSE;
                gnc_numeric discount = gnc_numeric_zero();
                gnc_numeric price = gnc_numeric_zero();
 
                /* Determine the Price from Customer's or Vendor's Job */
                switch (gncOwnerGetType (gncInvoiceGetOwner (ledger->invoice)))
                {
                case GNC_OWNER_JOB:
                    price = gncJobGetRate (gncOwnerGetJob (gncInvoiceGetOwner (ledger->invoice)));
                    break;
                default:
                    break;
                }
 
                /* Determine the TaxIncluded and Discount values */
                switch (gncOwnerGetType (owner))
                {
                case GNC_OWNER_CUSTOMER:
                    taxincluded_p = gncCustomerGetTaxIncluded (owner->owner.customer);
                    discount = gncCustomerGetDiscount (owner->owner.customer);
                    break;
                case GNC_OWNER_VENDOR:
                    taxincluded_p = gncVendorGetTaxIncluded (owner->owner.vendor);
                    break;
                default:
                    break;
                }
 
                /* Compute the default taxincluded */
                switch (taxincluded_p)
                {
                case GNC_TAXINCLUDED_YES:
                    taxincluded = TRUE;
                    break;
                case GNC_TAXINCLUDED_NO:
                    taxincluded = FALSE;
                    break;
                case GNC_TAXINCLUDED_USEGLOBAL:
                    if (ledger->prefs_group)
                    {
                        taxincluded = gnc_prefs_get_bool (ledger->prefs_group, GNC_PREF_TAX_INCL);
                    }
                    else
                    {
                        taxincluded = FALSE;
                    }
                    break;
                }
 
                /* Compute the proper taxtable */
                switch (gncOwnerGetType (owner))
                {
                case GNC_OWNER_CUSTOMER:
                    table = gncTaxTableGetDefault (ledger->book,
                                                   GNC_OWNER_CUSTOMER);
 
                    if (gncCustomerGetTaxTableOverride (owner->owner.customer))
                        table = gncCustomerGetTaxTable (owner->owner.customer);
                    break;
 
                case GNC_OWNER_VENDOR:
                    table = gncTaxTableGetDefault (ledger->book,
                                                   GNC_OWNER_VENDOR);
 
                    if (gncVendorGetTaxTableOverride (owner->owner.vendor))
                        table = gncVendorGetTaxTable (owner->owner.vendor);
                    break;
 
                default:
                    break;
                }
 
                if (ledger->is_cust_doc)
                {
                    gncEntrySetInvTaxable (blank_entry, table != NULL);
                    gncEntrySetInvTaxTable (blank_entry, table);
                    gncEntrySetInvTaxIncluded (blank_entry, taxincluded);
                    gncEntrySetInvDiscount (blank_entry, discount);
                    gncEntrySetInvPrice (blank_entry, price);
                }
                else
                {
                    gncEntrySetBillTaxable (blank_entry, table != NULL);
                    gncEntrySetBillTaxTable (blank_entry, table);
                    gncEntrySetBillTaxIncluded (blank_entry, taxincluded);
                    gncEntrySetBillPrice (blank_entry, price);
                }
            }
 
            break;
        default:
            ledger->blank_entry_guid = *guid_null();
            break;
        }
        ledger->blank_entry_edited = FALSE;
    }
 
    table = ledger->table;
 
    gnc_table_leave_update (table, table->current_cursor_loc);
    save_loc = table->current_cursor_loc;
 
    /* Figure out where we are going to */
    if (ledger->traverse_to_new)
    {
        find_entry = blank_entry;
    }
    else if (ledger->hint_entry)
    {
        find_entry = ledger->hint_entry;
    }
    else
    {
        find_entry = gnc_entry_ledger_get_current_entry (ledger);
        /* XXX: get current entry (cursor_hint_xxx) */
    }
 
    /* If the current cursor has changed we save the values for later
     * possible restoration. */
    if (gnc_table_current_cursor_changed (table, TRUE) &&
        (find_entry == gnc_entry_ledger_get_current_entry (ledger)))
    {
        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;
 
        virt_loc.vcell_loc.virt_row = -1;
        virt_loc.vcell_loc.virt_col = -1;
        virt_loc.phys_row_offset = -1;
        virt_loc.phys_col_offset = -1;
 
        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 */
    table->model->dividing_row_upper = -1;
    table->model->dividing_row = -1;
    table->model->dividing_row_lower = -1;
    cursor = gnc_table_layout_get_cursor (table->layout, "cursor");
 
    /* Populate the table */
    for (node = entry_list; node; node = node->next)
    {
        GncEntry* entry = node->data;
 
        /* Don't load the blank entry */
        if (entry == blank_entry)
            continue;
 
        /* If this is the first load of the ledger, fill the quickfill cells */
        {
            /* XXX */
        }
 
        if (entry == find_entry)
            new_entry_row = vcell_loc.virt_row;
 
        gnc_table_set_vcell (table, cursor, gncEntryGetGUID (entry),
                             TRUE, start_primary_color, vcell_loc);
        vcell_loc.virt_row++;
 
        /* Flip color for the next guy */
        start_primary_color = !start_primary_color;
    }
 
    /* Add the blank entry at the end. */
    if (blank_entry)
    {
        gnc_table_set_vcell (table, cursor, gncEntryGetGUID (blank_entry),
                             TRUE, start_primary_color, vcell_loc);
 
        if (find_entry == blank_entry)
            new_entry_row = vcell_loc.virt_row;
 
        vcell_loc.virt_row++;
    }
 
    /* Resize the table */
    gnc_table_set_size (table, vcell_loc.virt_row, 1);
 
    /* Restore the cursor to its rightful position */
    if (new_entry_row > 0)
        save_loc.vcell_loc.virt_row = new_entry_row;
 
    if (gnc_table_find_close_valid_cell (table, &save_loc, FALSE))
    {
        gnc_table_move_cursor_gui (table, save_loc);
 
        if (find_entry == gnc_entry_ledger_get_current_entry (ledger))
            gnc_table_restore_current_cursor (table, cursor_buffer);
    }
 
    gnc_cursor_buffer_destroy (cursor_buffer);
    cursor_buffer = NULL;
 
    /* Reset the ledger */
    ledger->traverse_to_new = FALSE;
    ledger->hint_entry = NULL;
 
    /* Set the cell fractions */
 
 
    gnc_table_refresh_gui (table, TRUE);
    gnc_entry_ledger_show_entry (ledger, table->current_cursor_loc.vcell_loc);
 
    /* Set completion character */
    gnc_combo_cell_set_complete_char
    ((ComboCell*)
     gnc_table_layout_get_cell (table->layout, ENTRY_IACCT_CELL),
     gnc_get_account_separator());
 
    gnc_combo_cell_set_complete_char
    ((ComboCell*)
     gnc_table_layout_get_cell (table->layout, ENTRY_BACCT_CELL),
     gnc_get_account_separator());
 
    /* enable callback for cursor user-driven moves */
    gnc_table_control_allow_move (table->control, TRUE);
}

gnc_entry_ledger_load_xfer_cells()

void gnc_entry_ledger_load_xfer_cells

(

GncEntryLedger *

ledger

)

Definition at line 315 of file gncEntryLedgerLoad.c.

{
    load_xfer_type_cells (ledger);
    load_taxtable_type_cells (ledger);
    load_payment_type_cells (ledger);
    load_description_cell (ledger);
}

gnc_entry_ledger_model_new()

TableModel * gnc_entry_ledger_model_new

(

GncEntryLedgerType

type

)

Public Interface.

Definition at line 1263 of file gncEntryLedgerModel.c.

{
    TableModel * model;
 
    model = gnc_table_model_new ();
    gnc_entry_ledger_model_new_handlers (model, type);
 
    return model;
}

gnc_entry_ledger_move_current_entry_updown()

void gnc_entry_ledger_move_current_entry_updown	(	GncEntryLedger *	ledger,
		gboolean	move_up
	)

This implements the command of moving the current entry (where the cursor is currently located) one row upwards or downwards, effectively swapping this row and the other row.

If the other row is empty (or it is the blank entry), nothing will happen.

Parameters

move_up

If TRUE, the current entry is moved upwards, otherwise downwards.

Definition at line 983 of file gncEntryLedger.c.

{
    GncEntry *blank, *current, *target;
    VirtualCellLocation vcell_loc;
 
    g_assert(ledger);
 
    blank = gnc_entry_ledger_get_blank_entry(ledger);
    if (!blank)
        return;
 
    /* Ensure we have a valid current GncEntry and it isn't the blank
     * entry */
    current = gnc_entry_ledger_get_current_entry(ledger);
    if (!current || current == blank)
        return;
 
    /* Obtain the GncEntry at the up or down virtual table location */
    vcell_loc = ledger->table->current_cursor_loc.vcell_loc;
    if (move_up)
    {
        if (vcell_loc.virt_row == 0)
            return;
        vcell_loc.virt_row--;
    }
    else
    {
        vcell_loc.virt_row++;
    }
 
    /* Ensure we have a valid other GncEntry and it isn't the blank
     * entry */
    target = gnc_entry_ledger_get_entry(ledger, vcell_loc);
    if (!target || target == blank)
        return;
 
    /* Also, only continue if both have the same date, because the
     * "standard ordering" is tied to the date anyway. Note: This
     * unfortunately prevents the user from changing the ordering if
     * he has chosen a different sort order and the sort key happens
     * to be equal among the two entries. But I don't know how to look
     * up the current sort ordering from here, so I cowardly refuse to
     * tweak the EntryDate in this case. */
    {
        time64 t1, t2;
        GDate d1 = gncEntryGetDateGDate(current),
              d2 = gncEntryGetDateGDate(target);
        if (g_date_compare(&d1, &d2) != 0)
            return;
 
        /* Special treatment if the equality doesn't hold if we access the
        dates as time64. See the comment in gncEntrySetDateGDate() for the
        reason: Some code used the time64 at noon for the EntryDate, other
        code used the time64 at the start of day. */
        t1 = gncEntryGetDate(current);
        t2 = gncEntryGetDate(target);
        if (t1 != t2)
        {
            /* times are not equal, even though the GDates were equal? Then
            we set the GDates again. This will force the times to be equal
            as well. */
            gncEntrySetDateGDate(current, &d1);
            gncEntrySetDateGDate(target, &d2);
        }
    }
 
    /*g_warning("Ok, current desc='%s' target desc='%s'",
              gncEntryGetDescription(current),
              gncEntryGetDescription(target));*/
 
    gnc_suspend_gui_refresh ();
 
    /* Swap the date-entered of both entries. That's already
     * sufficient! */
    {
        time64 time_current = gncEntryGetDateEntered(current);
        time64 time_target = gncEntryGetDateEntered(target);
 
        /* Special treatment for identical times (potentially caused
         * by the "duplicate entry" command) */
        if (time_current == time_target)
        {
            /*g_warning("Surprise - both DateEntered are equal.");*/
            /* We just increment the DateEntered of the previously
             * lower of the two by one second. This might still cause
             * issues if multiple entries had this problem, but
             * whatever. */
            if (move_up)
                ++time_current;
            else
                ++time_target;
        }
 
        /* Write the new DateEntered. */
        gncEntrySetDateEntered(current, time_target);
        gncEntrySetDateEntered(target, time_current);
 
        /* And finally let the GncInvoice sort its entries
         * accordingly, so that the invoice reports will give the same
         * ordering as the register window. */
        gncInvoiceSortEntries(ledger->invoice);
    }
 
    gnc_resume_gui_refresh ();
}

gnc_entry_ledger_new()

GncEntryLedger * gnc_entry_ledger_new	(	QofBook *	book,
		GncEntryLedgerType	type
	)

Create and return a new GncEntry Ledger.

Definition at line 274 of file gncEntryLedger.c.

{
    GncEntryLedger *ledger;
 
    if (!book) return NULL;
    if (type < 0 || type >= GNCENTRY_NUM_REGISTER_TYPES) return NULL;
 
    ledger = g_new0 (GncEntryLedger, 1);
    ledger->type = type;
    ledger->book = book;
    ledger->traverse_to_new = TRUE;
    ledger->prefs_group = NULL;
 
    /* Orders and Invoices are "invoices" for lookups */
    switch (type)
    {
    case GNCENTRY_ORDER_ENTRY:
    case GNCENTRY_ORDER_VIEWER:
    case GNCENTRY_INVOICE_ENTRY:
    case GNCENTRY_INVOICE_VIEWER:
        ledger->is_cust_doc = TRUE;
        ledger->is_credit_note = FALSE;
        break;
    case GNCENTRY_BILL_ENTRY:
    case GNCENTRY_BILL_VIEWER:
    case GNCENTRY_EXPVOUCHER_ENTRY:
    case GNCENTRY_EXPVOUCHER_VIEWER:
    case GNCENTRY_NUM_REGISTER_TYPES:
        ledger->is_cust_doc = FALSE;
        ledger->is_credit_note = FALSE;
        break;
    case GNCENTRY_CUST_CREDIT_NOTE_ENTRY:
    case GNCENTRY_CUST_CREDIT_NOTE_VIEWER:
        ledger->is_cust_doc = TRUE;
        ledger->is_credit_note = TRUE;
        break;
    case GNCENTRY_VEND_CREDIT_NOTE_ENTRY:
    case GNCENTRY_VEND_CREDIT_NOTE_VIEWER:
    case GNCENTRY_EMPL_CREDIT_NOTE_ENTRY:
    case GNCENTRY_EMPL_CREDIT_NOTE_VIEWER:
        ledger->is_cust_doc = FALSE;
        ledger->is_credit_note = TRUE;
        break;
    default:
    PWARN ("Bad GncEntryLedgerType");
    g_free (ledger);
    return NULL;
    break;
    }
 
    ledger->blank_entry_guid = *guid_null();
    ledger->blank_entry_edited = FALSE;
 
    {
        GDate *today = gnc_g_date_new_today();
        ledger->last_date_entered = *today;
        g_date_free(today);
    }
 
    {
        TableLayout *layout = gnc_entry_ledger_layout_new (ledger);
        TableModel *model = gnc_entry_ledger_model_new (type);
        TableControl *control = gnc_entry_ledger_control_new ();
        model->handler_user_data = ledger;
        control->user_data = ledger;
 
        ledger->table = gnc_table_new (layout, model, control);
    }
 
    gnc_entry_ledger_config_cells (ledger);
 
    /* set up header */
    {
        VirtualCellLocation vcell_loc = { 0, 0 };
        CellBlock *header;
 
        header = gnc_table_layout_get_cursor (ledger->table->layout, CURSOR_HEADER);
 
        gnc_table_set_vcell (ledger->table, header, NULL, TRUE, TRUE, vcell_loc);
    }
 
    /* set up first initial row */
    {
        VirtualLocation vloc;
        CellBlock *cursor;
 
        vloc.vcell_loc.virt_row = 1;
        vloc.vcell_loc.virt_col = 0;
        vloc.phys_row_offset = 0;
        vloc.phys_col_offset = 0;
 
        cursor = gnc_table_layout_get_cursor (ledger->table->layout, "cursor");
 
        gnc_table_set_vcell (ledger->table, cursor, NULL, TRUE, TRUE, vloc.vcell_loc);
 
        if (gnc_table_find_close_valid_cell (ledger->table, &vloc, FALSE))
            gnc_table_move_cursor (ledger->table, vloc);
        else
        {
            g_warning ("Can't find valid initial location");
        }
    }
 
    /* Initialize Display */
    gnc_entry_ledger_display_init (ledger);
    if (qof_book_is_readonly(ledger->book))
    {
        gnc_entry_ledger_set_readonly(ledger, TRUE);
    }
    return ledger;
}

gnc_entry_ledger_reset_query()

void gnc_entry_ledger_reset_query

(

GncEntryLedger *

ledger

)

Definition at line 567 of file gncEntryLedger.c.

{
    if (!ledger) return;
    if (!ledger->invoice) return;
 
    create_invoice_query (ledger);
    gnc_entry_ledger_display_refresh (ledger);
}

gnc_entry_ledger_set_default_invoice()

void gnc_entry_ledger_set_default_invoice	(	GncEntryLedger *	ledger,
		GncInvoice *	invoice
	)

Set the default invoice for this ledger.

Definition at line 544 of file gncEntryLedger.c.

{
    if (!ledger) return;
    ledger->invoice = invoice;
 
    /* For bills only, set the default date for new entries
     * to the bill's opened date. This saves a lot of typing when
     * adding bills on a day different from the bill's own date.
     * Note this is for bills only, because for (customer's) invoices
     * it makes more sense to use the current date.
     * Consult https://bugs.gnucash.org/show_bug.cgi?id=646541
     * to understand why.
     */
    if (gncInvoiceGetOwnerType (invoice) == GNC_OWNER_VENDOR)
        ledger->last_date_entered = time64_to_gdate(gncInvoiceGetDateOpened (invoice));
 
    if (!ledger->query && invoice)
        create_invoice_query (ledger);
 
    gnc_entry_ledger_display_refresh (ledger);
}

gnc_entry_ledger_set_default_order()

void gnc_entry_ledger_set_default_order	(	GncEntryLedger *	ledger,
		GncOrder *	order
	)

Set the default order for this ledger.

Definition at line 405 of file gncEntryLedger.c.

{
    if (!ledger) return;
    ledger->order = order;
 
    if (!ledger->query && order)
    {
        ledger->query = qof_query_create_for (GNC_ENTRY_MODULE_NAME);
        qof_query_set_book (ledger->query, gncOrderGetBook (order));
        qof_query_add_guid_match (ledger->query,
                                  g_slist_prepend (g_slist_prepend (NULL,
                                          QOF_PARAM_GUID),
                                          ENTRY_ORDER),
                                  gncOrderGetGUID (order), QOF_QUERY_AND);
    }
    gnc_entry_ledger_display_refresh (ledger);
}

gnc_entry_ledger_set_parent()

void gnc_entry_ledger_set_parent	(	GncEntryLedger *	ledger,
		GtkWidget *	parent
	)

Definition at line 576 of file gncEntryLedger.c.

{
    if (!ledger) return;
    ledger->parent = parent;
}

gnc_entry_ledger_set_prefs_group()

void gnc_entry_ledger_set_prefs_group	(	GncEntryLedger *	ledger,
		const gchar *	string
	)

Definition at line 975 of file gncEntryLedger.c.

{
    if (!ledger)
        return;
 
    ledger->prefs_group = string;
}

gnc_entry_ledger_set_readonly()

void gnc_entry_ledger_set_readonly	(	GncEntryLedger *	ledger,
		gboolean	readonly
	)

Definition at line 605 of file gncEntryLedger.c.

{
    if (!ledger) return;
    if (!readonly && qof_book_is_readonly(ledger->book)) return;
 
    /* reset the ledger type appropriately */
    if (readonly)
    {
        switch (ledger->type)
        {
        case GNCENTRY_ORDER_ENTRY:
            ledger->type = GNCENTRY_ORDER_VIEWER;
            break;
        case GNCENTRY_INVOICE_ENTRY:
            ledger->type = GNCENTRY_INVOICE_VIEWER;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_BILL_ENTRY:
            ledger->type = GNCENTRY_BILL_VIEWER;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_EXPVOUCHER_ENTRY:
            ledger->type = GNCENTRY_EXPVOUCHER_VIEWER;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_CUST_CREDIT_NOTE_ENTRY:
            ledger->type = GNCENTRY_CUST_CREDIT_NOTE_VIEWER;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_VEND_CREDIT_NOTE_ENTRY:
            ledger->type = GNCENTRY_VEND_CREDIT_NOTE_VIEWER;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_EMPL_CREDIT_NOTE_ENTRY:
            ledger->type = GNCENTRY_EMPL_CREDIT_NOTE_VIEWER;
            create_invoice_query (ledger);
            break;
        default:
            return;        /* Nothing to do */
        }
    }
    else
    {
        switch (ledger->type)
        {
        case GNCENTRY_ORDER_VIEWER:
            ledger->type = GNCENTRY_ORDER_ENTRY;
            break;
        case GNCENTRY_INVOICE_VIEWER:
            ledger->type = GNCENTRY_INVOICE_ENTRY;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_BILL_VIEWER:
            ledger->type = GNCENTRY_BILL_ENTRY;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_EXPVOUCHER_VIEWER:
            ledger->type = GNCENTRY_EXPVOUCHER_ENTRY;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_CUST_CREDIT_NOTE_VIEWER:
            ledger->type = GNCENTRY_CUST_CREDIT_NOTE_ENTRY;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_VEND_CREDIT_NOTE_VIEWER:
            ledger->type = GNCENTRY_VEND_CREDIT_NOTE_ENTRY;
            create_invoice_query (ledger);
            break;
        case GNCENTRY_EMPL_CREDIT_NOTE_VIEWER:
            ledger->type = GNCENTRY_EMPL_CREDIT_NOTE_ENTRY;
            create_invoice_query (ledger);
            break;
        default:
            return;        /* Nothing to do */
        }
    }
 
    /* reset the model */
    gnc_table_model_set_read_only (ledger->table->model, readonly);
 
    /* if readonly is TRUE, get rid of the blank entry. */
    if (readonly)
        gnc_entry_ledger_clear_blank_entry (ledger);
 
    /* and refresh the display */
    gnc_entry_ledger_display_refresh (ledger);
}

gnc_entry_ledger_type_string_getter()

const char * gnc_entry_ledger_type_string_getter

(

char

flag

)

Definition at line 48 of file gncEntryLedgerLoad.c.

{
    switch (flag)
    {
    case '1':
        return _ ("$");
    case '2':
        return _ ("%");
    default:
        break;
    };
    return "?";
}