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. More...
void	gnc_entry_ledger_load (GncEntryLedger *ledger, GList *entry_list)
	Copy GncEntry information from the list to the rows of the Ledger. More...
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. More...
GncEntry *	gnc_entry_ledger_get_blank_entry (GncEntryLedger *ledger)
	Returns the GncEntry that represents the blank new line at the bottom of the ledger. More...
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). More...
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. More...
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.

Function Documentation

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_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 788 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_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_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 978 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 ();
}