split-register.c

/********************************************************************\
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
\********************************************************************/
/*
 * split-register.c
 * author Copyright (c) 1998-2000 Linas Vepstas <linas@linas.org>
 * author Copyright (c) 2000-2001 Dave Peticolas <dave@krondo.com>
 * author Copyright (c) 2017 Aaron Laws
 */
#include <config.h>

#include <glib.h>
#include <glib/gi18n.h>

#include "combocell.h"
#include "datecell.h"
#include "dialog-utils.h"
#include "gnc-component-manager.h"
#include "split-register-p.h"
#include "gnc-date.h"
#include "gnc-ledger-display.h"
#include "gnc-prefs.h"
#include "gnc-ui.h"
#include "gnc-warnings.h"
#include "split-register-copy-ops.h"
#include "numcell.h"
#include "pricecell.h"
#include "quickfillcell.h"
#include "recncell.h"
#include "split-register.h"
#include "split-register-control.h"
#include "split-register-layout.h"
#include "split-register-model.h"
#include "split-register-model-save.h"
#include "table-allgui.h"
#include "dialog-account.h"
#include "dialog-dup-trans.h"
#include "engine-helpers.h"
#include "qofbookslots.h"


/* This static indicates the debugging module that this .o belongs to. */
static QofLogModule log_module = GNC_MOD_LEDGER;

/* The copied split or transaction, if any */
typedef struct
{
    GType ftype;
    union
    {
        FloatingSplit *fs;
        FloatingTxn *ft;
    };
} ft_fs_store;

static ft_fs_store copied_item = { 0, { NULL } };
static CursorClass copied_class = CURSOR_CLASS_NONE;
static GncGUID copied_leader_guid;

static gboolean gnc_split_register_save_to_copy_buffer (SplitRegister *reg,
                                                        FloatingTxn *ft,
                                                        FloatingSplit *fs,
                                                        gboolean use_cut_semantics);
static gboolean gnc_split_register_auto_calc (SplitRegister *reg,
                                              Split *split);


static void
gnc_copy_split_onto_split (Split* from, Split* to, gboolean use_cut_semantics)
{
    FloatingSplit *fs;

    if ((from == NULL) || (to == NULL))
        return;

    fs = gnc_split_to_float_split (from);
    if (!fs)
        return;

    gnc_float_split_to_split (fs, to);
    gnc_float_split_free (fs);
}

void
gnc_copy_trans_onto_trans (Transaction* from, Transaction* to,
                           gboolean use_cut_semantics,
                           gboolean do_commit)
{
    FloatingTxn *ft;

    if ((from == NULL) || (to == NULL))
        return;

    ft = gnc_txn_to_float_txn (from, use_cut_semantics);
    if (!ft)
        return;

    gnc_float_txn_to_txn (ft, to, do_commit);
    gnc_float_txn_free (ft);
}

static int
gnc_split_get_value_denom (Split* split)
{
    gnc_commodity* currency;
    int denom;

    currency = xaccTransGetCurrency (xaccSplitGetParent (split));
    denom = gnc_commodity_get_fraction (currency);
    if (denom == 0)
    {
        gnc_commodity* commodity = gnc_default_currency ();
        denom = gnc_commodity_get_fraction (commodity);
        if (denom == 0)
            denom = 100;
    }

    return denom;
}

static int
gnc_split_get_amount_denom (Split* split)
{
    int denom;

    denom = xaccAccountGetCommoditySCU (xaccSplitGetAccount (split));
    if (denom == 0)
    {
        gnc_commodity* commodity = gnc_default_currency ();
        denom = gnc_commodity_get_fraction (commodity);
        if (denom == 0)
            denom = 100;
    }

    return denom;
}

/* returns TRUE if begin_edit was aborted */
gboolean
gnc_split_register_begin_edit_or_warn (SRInfo* info, Transaction* trans)
{
    ENTER ("info=%p, trans=%p", info, trans);

    if (!xaccTransIsOpen (trans))
    {
        xaccTransBeginEdit (trans);
        /* This is now the pending transaction */
        info->pending_trans_guid = *xaccTransGetGUID (trans);
        LEAVE ("opened and marked pending");
        return FALSE;
    }
    else
    {
        Split*       blank_split = xaccSplitLookup (&info->blank_split_guid,
                                                    gnc_get_current_book ());
        Transaction* blank_trans = xaccSplitGetParent (blank_split);

        if (trans == blank_trans)
        {
            /* This is a brand-new transaction. It is already
             * open, so just mark it as pending. */
            info->pending_trans_guid = *xaccTransGetGUID (trans);
            LEAVE ("already open, now pending.");
            return FALSE;
        }
        else
        {
            GtkWindow* parent = NULL;
            if (info->get_parent)
                parent = GTK_WINDOW (info->get_parent (info->user_data));
            gnc_error_dialog (parent, "%s",
                              _ ("This transaction is already being edited in another register. Please finish editing it there first."));
            LEAVE ("already editing");
            return TRUE;
        }
    }
    LEAVE (" ");
    return FALSE;  /* to satisfy static code analysis */
}

void
gnc_split_register_expand_current_trans (SplitRegister* reg, gboolean expand)
{
    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);
}

gboolean
gnc_split_register_current_trans_expanded (SplitRegister* reg)
{
    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;
}

Transaction*
gnc_split_register_get_current_trans (SplitRegister* reg)
{
    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);
}

Split*
gnc_split_register_get_current_split (SplitRegister* reg)
{
    if (reg == NULL)
        return NULL;

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

Split*
gnc_split_register_get_blank_split (SplitRegister* reg)
{
    SRInfo* info = gnc_split_register_get_info (reg);

    if (!reg) return NULL;

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

gboolean
gnc_split_register_get_split_virt_loc (SplitRegister* reg, Split* split,
                                       VirtualCellLocation* vcell_loc)
{
    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;
}

gboolean
gnc_split_register_get_split_amount_virt_loc (SplitRegister* reg, Split* split,
                                              VirtualLocation* virt_loc)
{
    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;
}

Split*
gnc_split_register_duplicate_current (SplitRegister* reg)
{
    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;
}

static void
gnc_split_register_copy_current_internal (SplitRegister* reg,
                                          gboolean use_cut_semantics)
{
    SRInfo* info = gnc_split_register_get_info (reg);
    CursorClass cursor_class;
    Transaction* trans;
    Split* blank_split;
    gboolean changed;
    Split *split;
    FloatingSplit *new_fs = NULL;
    FloatingTxn *new_ft = NULL;

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

    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)
    {
        LEAVE ("no trans");
        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 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;
    }

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

    /* See if we were asked to copy an unchanged blank split. Don't. */
    if (!changed && ((split == NULL) || (split == blank_split)))
    {
        /* We're either on an unedited, brand-new split or an unedited, brand-new
         * transaction (the transaction anchored by the blank split.) */
        /* FIXME: This doesn't work exactly right. When entering a new transaction,
         *        you can edit the description, move to a split row, then move
         *        back to the description, then ask for a copy, and this code will
         *        be reached. It forgets that you changed the row the first time
         *        you were there.  -Charles */
        LEAVE ("nothing to copy/cut");
        return;
    }

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

    if (cursor_class == CURSOR_CLASS_SPLIT)
    {
        /* We are on a split in an expanded transaction. Just copy the split. */
        new_fs = gnc_split_to_float_split (split);

        if (new_fs)
        {
            if (changed)
                gnc_split_register_save_to_copy_buffer (reg, NULL, new_fs,
                                                        use_cut_semantics);

            copied_leader_guid = *guid_null ();
        }
    }
    else
    {
        /* We are on a transaction row. Copy the whole transaction. */
        new_ft = gnc_txn_to_float_txn (trans, use_cut_semantics);

        if (new_ft)
        {
            if (changed)
            {
                int split_index;
                FloatingSplit *fs;

                split_index = xaccTransGetSplitIndex (trans, split);
                if (split_index >= 0)
                    fs = gnc_float_txn_get_float_split (new_ft, split_index);
                else
                    fs = NULL;

                gnc_split_register_save_to_copy_buffer (reg, new_ft, fs,
                                                        use_cut_semantics);
            }

            copied_leader_guid = info->default_account;
        }
    }

    if (!new_fs && !new_ft)
    {
        g_warning ("BUG DETECTED: copy failed");
        LEAVE ("copy failed");
        return;
    }

    /* unprotect the old object, if any */
    if (copied_item.ftype == GNC_TYPE_SPLIT)
        gnc_float_split_free (copied_item.fs);
    if (copied_item.ftype == GNC_TYPE_TRANSACTION)
        gnc_float_txn_free (copied_item.ft);
    copied_item.ftype = 0;

    if (new_fs)
    {
        copied_item.fs = new_fs;
        copied_item.ftype = GNC_TYPE_SPLIT;
    }
    else if (new_ft)
    {
        copied_item.ft = new_ft;
        copied_item.ftype = GNC_TYPE_TRANSACTION;
    }

    copied_class = cursor_class;
    LEAVE ("%s %s", use_cut_semantics ? "cut" : "copied",
           cursor_class == CURSOR_CLASS_SPLIT ? "split" : "transaction");
}

void
gnc_split_register_copy_current (SplitRegister* reg)
{
    gnc_split_register_copy_current_internal (reg, FALSE);
}

void
gnc_split_register_cut_current (SplitRegister* reg)
{
    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);
}

void
gnc_split_register_paste_current (SplitRegister* reg)
{
    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;
        const GncGUID *new_guid;
        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 (" ");
}

gboolean
gnc_split_register_is_blank_split (SplitRegister* reg, Split* split)
{
    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;
}

void
gnc_split_register_change_blank_split_ref (SplitRegister* reg, Split* split)
{
    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);
}

void
gnc_split_register_delete_current_split (SplitRegister* reg)
{
    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);
}

void
gnc_split_register_delete_current_trans (SplitRegister* reg)
{
    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 (" ");
}

void
gnc_split_register_void_current_trans (SplitRegister* reg, const char* reason)
{
    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 ();
}

void
gnc_split_register_unvoid_current_trans (SplitRegister* reg)
{
    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 ();
}

void
gnc_split_register_empty_current_trans_except_split (SplitRegister* reg,
                                                     Split* split)
{
    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);
}

void
gnc_split_register_empty_current_trans (SplitRegister* reg)
{
    Split* split;

    /* get the current split based on cursor position */
    split = gnc_split_register_get_current_split (reg);
    gnc_split_register_empty_current_trans_except_split (reg, split);
}

void
gnc_split_register_cancel_cursor_split_changes (SplitRegister* reg)
{
    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);
}

void
gnc_split_register_cancel_cursor_trans_changes (SplitRegister* reg)
{
    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);
}

void
gnc_split_register_redraw (SplitRegister* reg)
{
    gnc_ledger_display_refresh_by_split_register (reg);
}

/* Copy from the register object to scheme. This needs to be
 * in sync with gnc_split_register_save and xaccSRSaveChangedCells. */
static gboolean
gnc_split_register_save_to_copy_buffer (SplitRegister *reg,
                                        FloatingTxn *ft, FloatingSplit *fs,
                                        gboolean use_cut_semantics)
{
    FloatingSplit *other_fs = NULL;
    Transaction *trans;

    /* 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))
        return FALSE;

    /* get the handle to the current split and transaction */
    trans = gnc_split_register_get_current_trans (reg);
    if (trans == NULL)
        return FALSE;

    /* copy the contents from the cursor to the split */
    if (gnc_table_layout_get_cell_changed (reg->table->layout, DATE_CELL, TRUE))
    {
        BasicCell* cell;
        time64 time;
        cell = gnc_table_layout_get_cell (reg->table->layout, DATE_CELL);
        gnc_date_cell_get_date ((DateCell*) cell, &time, TRUE);
        xaccTransSetDatePostedSecsNormalized (trans, time);
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, NUM_CELL, TRUE))
    {
        const char* value;

        value = gnc_table_layout_get_cell_value (reg->table->layout, NUM_CELL);
        if (reg->use_tran_num_for_num_field)
            xaccTransSetNum (trans, value);
        /* else this contains the same as ACTN_CELL which is already handled below *
         * and the TNUM_CELL contains transaction number which is handled in next  *
         * if statement. */
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, TNUM_CELL, TRUE))
    {
        const char* value;

        value = gnc_table_layout_get_cell_value (reg->table->layout, TNUM_CELL);
        if (!reg->use_tran_num_for_num_field)
            xaccTransSetNum (trans, value);
        /* else this cell is not used */
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, DESC_CELL, TRUE))
    {
        const char* value;

        value = gnc_table_layout_get_cell_value (reg->table->layout, DESC_CELL);
        xaccTransSetDescription (trans, value);
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, NOTES_CELL, TRUE))
    {
        const char* value;

        value = gnc_table_layout_get_cell_value (reg->table->layout, NOTES_CELL);
        xaccTransSetNotes (trans, value);
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, RECN_CELL, TRUE))
    {
        BasicCell* cell;
        char flag;

        cell = gnc_table_layout_get_cell (reg->table->layout, RECN_CELL);
        flag = gnc_recn_cell_get_flag ((RecnCell*) cell);

        gnc_float_split_set_reconcile_state (fs, flag);
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, ACTN_CELL, TRUE))
    {
        const char* value;

        value = gnc_table_layout_get_cell_value (reg->table->layout, ACTN_CELL);
        gnc_float_split_set_action (fs, value);
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, MEMO_CELL, TRUE))
    {
        const char* value;

        value = gnc_table_layout_get_cell_value (reg->table->layout, MEMO_CELL);
        gnc_float_split_set_memo (fs, value);
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, XFRM_CELL, TRUE))
    {
        Account* new_account;

        new_account = gnc_split_register_get_account (reg, XFRM_CELL);

        if (new_account != NULL)
            gnc_float_split_set_account (fs, new_account);
    }

    if (reg->style == REG_STYLE_LEDGER)
        other_fs = gnc_float_txn_get_other_float_split (ft, fs);

    if (gnc_table_layout_get_cell_changed (reg->table->layout, MXFRM_CELL, TRUE))
    {
        other_fs = gnc_float_txn_get_other_float_split (ft, fs);

        if (!other_fs)
        {
            if (g_list_length (ft->m_splits) == 1)
            {
                Split* temp_split;

                temp_split = xaccMallocSplit (gnc_get_current_book ());
                other_fs = gnc_split_to_float_split (temp_split);
                xaccSplitDestroy (temp_split);

                gnc_float_txn_append_float_split (ft, other_fs);
            }
        }

        if (other_fs)
        {
            Account* new_account;

            new_account = gnc_split_register_get_account (reg, MXFRM_CELL);

            if (new_account != NULL)
                gnc_float_split_set_account (other_fs, new_account);
        }
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout,
                                           DEBT_CELL, TRUE) ||
        gnc_table_layout_get_cell_changed (reg->table->layout,
                                           CRED_CELL, TRUE))
    {
        BasicCell* cell;
        gnc_numeric new_value;
        gnc_numeric credit;
        gnc_numeric debit;

        cell = gnc_table_layout_get_cell (reg->table->layout, CRED_CELL);
        credit = gnc_price_cell_get_value ((PriceCell*) cell);

        cell = gnc_table_layout_get_cell (reg->table->layout, DEBT_CELL);
        debit = gnc_price_cell_get_value ((PriceCell*) cell);

        new_value = gnc_numeric_sub_fixed (debit, credit);

        gnc_float_split_set_value (fs, new_value);
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, PRIC_CELL, TRUE))
    {
        /* do nothing for now */
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout, SHRS_CELL, TRUE))
    {
        BasicCell* cell;
        gnc_numeric shares;

        cell = gnc_table_layout_get_cell (reg->table->layout, SHRS_CELL);

        shares = gnc_price_cell_get_value ((PriceCell*) cell);

        gnc_float_split_set_amount (fs, shares);
    }

    if (gnc_table_layout_get_cell_changed (reg->table->layout,
                                           DEBT_CELL, TRUE) ||
        gnc_table_layout_get_cell_changed (reg->table->layout,
                                           CRED_CELL, TRUE) ||
        gnc_table_layout_get_cell_changed (reg->table->layout,
                                           PRIC_CELL, TRUE) ||
        gnc_table_layout_get_cell_changed (reg->table->layout,
                                           SHRS_CELL, TRUE))
    {
        if (other_fs)
        {
            gnc_numeric num;

            num = gnc_float_split_get_amount (fs);
            gnc_float_split_set_amount (other_fs, gnc_numeric_neg (num));

            num = gnc_float_split_get_value (fs);
            gnc_float_split_set_value (other_fs, gnc_numeric_neg (num));
        }
    }

    return TRUE;
}
static void
unreconcile_splits (SplitRegister* reg)
{
    if (reg->unrecn_splits == NULL)
        return; //Nothing to do.
    PINFO ("Unreconcile %d splits of reconciled transaction",
           g_list_length (reg->unrecn_splits));

    for (GList* node = reg->unrecn_splits; node; node = node->next)
    {
        Split* split = node->data;
        Transaction* txn = xaccSplitGetParent (split);
        if (!xaccTransIsOpen (txn))
            PWARN ("Unreconcile of split failed because its parent transaction wasn't open for editing");
        else if (xaccSplitGetReconcile (split) == YREC)
            xaccSplitSetReconcile (split, NREC);
    }
    g_list_free (reg->unrecn_splits);
    reg->unrecn_splits = NULL;
}

gboolean
gnc_split_register_save (SplitRegister* reg, gboolean do_commit)
{
    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;
}


Account*
gnc_split_register_get_account_by_name (SplitRegister* reg, BasicCell* bcell,
                                        const char* name)
{
    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;
    static gboolean creating_account = FALSE;
    GtkWindow* parent = GTK_WINDOW (gnc_split_register_get_parent (reg));

    if (!name || (strlen (name) == 0))
        return 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 gnc_ui_new_accounts_from_name_window is used, there is a call to
     * refresh which subsequently calls this function again, that's the
     * reason for static creating_account. */

    if (!account && !creating_account)
    {
        /* Ask if they want to create a new one. */
        if (!gnc_verify_dialog (parent, TRUE, missing, name))
            return NULL;
        creating_account = TRUE;
        /* User said yes, they want to create a new account. */
        account = gnc_ui_new_accounts_from_name_window (parent, name);
        creating_account = FALSE;
        if (!account)
            return NULL;
    }

    if (!creating_account)
    {
        /* Now have the account. */
        account_name = gnc_get_account_name_for_split_register (account,
                                                                reg->show_leaf_accounts);
        if (g_strcmp0 (account_name, gnc_basic_cell_get_value (bcell)))
        {
            /* The name has changed. Update the cell. */
            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 (account && xaccAccountGetPlaceholder (account))
        {
            gchar* fullname = gnc_account_get_full_name (account);
            gnc_error_dialog (GTK_WINDOW (gnc_split_register_get_parent (reg)),
                              placeholder, fullname);
            g_free (fullname);
            return NULL;
        }
    }

    /* Be seeing you. */
    return account;
}

Account*
gnc_split_register_get_account (SplitRegister* reg, const char* cell_name)
{
    BasicCell* cell;
    const char* name;

    if (!gnc_table_layout_get_cell_changed (reg->table->layout, cell_name, TRUE))
        return NULL;

    cell = gnc_table_layout_get_cell (reg->table->layout, cell_name);
    if (!cell)
        return NULL;
    name = gnc_basic_cell_get_value (cell);
    return gnc_split_register_get_account_by_name (reg, cell, name);
}

static gnc_numeric
calculate_value (SplitRegister* reg)
{
    gnc_numeric credit;
    gnc_numeric debit;

    PriceCell* cell = (PriceCell*)gnc_table_layout_get_cell (reg->table->layout,
                                                             CRED_CELL);
    credit = gnc_price_cell_get_value (cell);

    cell = (PriceCell*)gnc_table_layout_get_cell (reg->table->layout,
                                                  DEBT_CELL);
    debit = gnc_price_cell_get_value (cell);

    return gnc_numeric_sub_fixed (debit, credit);
}


static int
recalc_message_box (SplitRegister* reg, gboolean shares_changed,
                    gboolean price_changed, gboolean value_changed)
{
    int choice;
    int default_value;
    GList* node;
    GList* radio_list = NULL;
    const char* title = _ ("Recalculate Transaction");
    const char* message = _ ("The values entered for this transaction "
                             "are inconsistent. Which value would you "
                             "like to have recalculated?");

    if (shares_changed)
        radio_list = g_list_append (radio_list, g_strdup_printf ("%s (%s)",
                                                                 _ ("_Shares"),
                                                                 _ ("Changed")));
    else
        radio_list = g_list_append (radio_list, g_strdup (_ ("_Shares")));

    if (price_changed)
        radio_list = g_list_append (radio_list, g_strdup_printf ("%s (%s)",
                                                                 _ ("_Price"),
                                                                 _ ("Changed")));
    else
        radio_list = g_list_append (radio_list, g_strdup (_ ("_Price")));

    if (value_changed)
        radio_list = g_list_append (radio_list, g_strdup_printf ("%s (%s)",
                                                                 _ ("_Value"),
                                                                 _ ("Changed")));
    else
        radio_list = g_list_append (radio_list, g_strdup (_ ("_Value")));

    if (price_changed) default_value = 2;  /* change the value */
    else  default_value = 1;  /* change the value */

    choice = gnc_choose_radio_option_dialog
        (gnc_split_register_get_parent (reg),
         title,
         message,
         _ ("_Recalculate"),
         default_value,
         radio_list);

    for (node = radio_list; node; node = node->next)
        g_free (node->data);

    g_list_free (radio_list);

    return choice;
}

static void
recalculate_shares (Split* split, SplitRegister* reg,
                    gnc_numeric value, gnc_numeric price, gboolean value_changed)
{
    gint64 denom = gnc_split_get_amount_denom (split);
    gnc_numeric amount = gnc_numeric_div (value, price, denom,
                                          GNC_HOW_RND_ROUND_HALF_UP);

    BasicCell* cell = gnc_table_layout_get_cell (reg->table->layout, SHRS_CELL);
    gnc_price_cell_set_value ((PriceCell*) cell, amount);
    gnc_basic_cell_set_changed (cell, TRUE);

    if (value_changed)
    {
        cell = gnc_table_layout_get_cell (reg->table->layout, PRIC_CELL);
        gnc_basic_cell_set_changed (cell, FALSE);
    }
}

static void
recalculate_price (Split* split, SplitRegister* reg,
                   gnc_numeric value, gnc_numeric amount)
{
    BasicCell* price_cell;
    gnc_numeric price = gnc_numeric_div (value, amount,
                                         GNC_DENOM_AUTO,
                                         GNC_HOW_DENOM_EXACT);

    if (gnc_numeric_negative_p (price))
    {
        BasicCell* debit_cell;
        BasicCell* credit_cell;

        debit_cell = gnc_table_layout_get_cell (reg->table->layout,
                                                DEBT_CELL);

        credit_cell = gnc_table_layout_get_cell (reg->table->layout,
                                                 CRED_CELL);

        price = gnc_numeric_neg (price);

        gnc_price_cell_set_debt_credit_value ((PriceCell*) debit_cell,
                                              (PriceCell*) credit_cell,
                                              gnc_numeric_neg (value));

        gnc_basic_cell_set_changed (debit_cell, TRUE);
        gnc_basic_cell_set_changed (credit_cell, TRUE);
    }

    price_cell = gnc_table_layout_get_cell (reg->table->layout, PRIC_CELL);
    gnc_price_cell_set_value ((PriceCell*) price_cell, price);
    gnc_basic_cell_set_changed (price_cell, TRUE);
}

static void
recalculate_value (Split* split, SplitRegister* reg,
                   gnc_numeric price, gnc_numeric amount, gboolean shares_changed)
{
    BasicCell* debit_cell = gnc_table_layout_get_cell (reg->table->layout,
                                                       DEBT_CELL);
    BasicCell* credit_cell = gnc_table_layout_get_cell (reg->table->layout,
                                                        CRED_CELL);
    gint64 denom = gnc_split_get_value_denom (split);
    gnc_numeric value = gnc_numeric_mul (price, amount, denom,
                                         GNC_HOW_RND_ROUND_HALF_UP);

    gnc_price_cell_set_debt_credit_value ((PriceCell*) debit_cell,
                                          (PriceCell*) credit_cell, value);

    gnc_basic_cell_set_changed (debit_cell, TRUE);
    gnc_basic_cell_set_changed (credit_cell, TRUE);

    if (shares_changed)
    {
        BasicCell* cell = gnc_table_layout_get_cell (reg->table->layout,
                                                     PRIC_CELL);
        gnc_basic_cell_set_changed (cell, FALSE);
    }
}

static gboolean
gnc_split_register_auto_calc (SplitRegister* reg, Split* split)
{
    PriceCell* cell = NULL;
    gboolean recalc_shares = FALSE;
    gboolean recalc_price = FALSE;
    gboolean recalc_value = FALSE;
    gboolean price_changed;
    gboolean value_changed;
    gboolean shares_changed;
    gnc_numeric calc_value;
    gnc_numeric value;
    gnc_numeric price;
    gnc_numeric amount;
    Account* account;
    int denom;
    int choice;

    if (STOCK_REGISTER    != reg->type &&
        CURRENCY_REGISTER != reg->type &&
        PORTFOLIO_LEDGER  != reg->type)
        return TRUE;

    account = gnc_split_register_get_account (reg, XFRM_CELL);

    if (!account)
        account = xaccSplitGetAccount (split);

    if (!account)
        account = gnc_split_register_get_default_account (reg);

    if (!xaccAccountIsPriced (account))
        return TRUE;

    price_changed = gnc_table_layout_get_cell_changed (reg->table->layout,
                                                       PRIC_CELL, TRUE);
    value_changed = (gnc_table_layout_get_cell_changed (reg->table->layout,
                                                        DEBT_CELL, TRUE) ||
                     gnc_table_layout_get_cell_changed (reg->table->layout,
                                                        CRED_CELL, TRUE));
    shares_changed = gnc_table_layout_get_cell_changed (reg->table->layout,
                                                        SHRS_CELL, TRUE);

    if (!price_changed && !value_changed && !shares_changed)
        return TRUE;

    /* If we are using commodity trading accounts then the value may
       not really be the value.  Punt if so. */
    if (xaccTransUseTradingAccounts (xaccSplitGetParent (split)))
    {
        gnc_commodity* acc_commodity;
        acc_commodity = xaccAccountGetCommodity (account);
        if (! (xaccAccountIsPriced (account) ||
               !gnc_commodity_is_iso (acc_commodity)))
            return TRUE;
    }

    if (shares_changed)
    {
        cell = (PriceCell*) gnc_table_layout_get_cell (reg->table->layout,
                                                       SHRS_CELL);
        amount = gnc_price_cell_get_value (cell);
    }
    else
        amount = xaccSplitGetAmount (split);

    if (price_changed)
    {
        cell = (PriceCell*) gnc_table_layout_get_cell (reg->table->layout,
                                                       PRIC_CELL);
        price = gnc_price_cell_get_value (cell);
    }
    else
        price = xaccSplitGetSharePrice (split);

    if (value_changed)
        value = calculate_value (reg);
    else
        value = xaccSplitGetValue (split);


    /* Check if shares and price are BOTH zero (and value is non-zero).
     * If so, we can assume that this is an income-correcting split
     */
    if (gnc_numeric_zero_p (amount) && gnc_numeric_zero_p (price) &&
        !gnc_numeric_zero_p (value))
    {
        return TRUE;
    }

    /* Check if precisely one value is zero. If so, we can assume that the
     * zero value needs to be recalculated.   */

    if (!gnc_numeric_zero_p (amount))
    {
        if (gnc_numeric_zero_p (price))
        {
            if (!gnc_numeric_zero_p (value))
                recalc_price = TRUE;
        }
        else if (gnc_numeric_zero_p (value))
            recalc_value = TRUE;
    }
    else if (!gnc_numeric_zero_p (price))
        if (!gnc_numeric_zero_p (value))
            recalc_shares = TRUE;

    /* If we have not already flagged a recalc, check if this is a split
     * which has 2 of the 3 values changed. */

    if ((!recalc_shares) &&
        (!recalc_price)  &&
        (!recalc_value))
    {
        if (price_changed && value_changed)
        {
            if (!shares_changed)
                recalc_shares = TRUE;
        }
        else if (value_changed && shares_changed)
            recalc_price = TRUE;
        else if (price_changed && shares_changed)
            recalc_value = TRUE;
    }

    calc_value = gnc_numeric_mul (price, amount,
                                  GNC_DENOM_AUTO, GNC_HOW_DENOM_LCD);

    denom = gnc_split_get_value_denom (split);

    /*  Now, if we have not flagged one of the recalcs, and value and
     *  calc_value are not the same number, then we need to ask for
     *  help from the user. */

    if (!recalc_shares &&
        !recalc_price &&
        !recalc_value &&
        !gnc_numeric_same (value, calc_value, denom, GNC_HOW_RND_ROUND_HALF_UP))
    {
        choice = recalc_message_box (reg, shares_changed,
                                     price_changed,
                                     value_changed);
        switch (choice)
        {
            case 0: /* Modify number of shares */
                recalc_shares = TRUE;
                break;
            case 1: /* Modify the share price */
                recalc_price = TRUE;
                break;
            case 2: /* Modify total value */
                recalc_value = TRUE;
                break;
            default: /* Cancel */
                return FALSE;
        }
    }

    if (recalc_shares && !gnc_numeric_zero_p (price))
        recalculate_shares (split, reg, value, price, value_changed);

    if (recalc_price && !gnc_numeric_zero_p (amount))
    {
        recalculate_price (split, reg, value, amount);
        price_changed = TRUE;
    }
    if (recalc_value)
        recalculate_value (split, reg, price, amount, shares_changed);

    return TRUE;
}

static GNCAccountType
gnc_split_register_type_to_account_type (SplitRegisterType sr_type)
{
    switch (sr_type)
    {
        case BANK_REGISTER:
            return ACCT_TYPE_BANK;
        case CASH_REGISTER:
            return ACCT_TYPE_CASH;
        case ASSET_REGISTER:
            return ACCT_TYPE_ASSET;
        case CREDIT_REGISTER:
            return ACCT_TYPE_CREDIT;
        case LIABILITY_REGISTER:
            return ACCT_TYPE_LIABILITY;
        case PAYABLE_REGISTER:
            return ACCT_TYPE_PAYABLE;
        case RECEIVABLE_REGISTER:
            return ACCT_TYPE_RECEIVABLE;
        case INCOME_LEDGER:
        case INCOME_REGISTER:
            return ACCT_TYPE_INCOME;
        case EXPENSE_REGISTER:
            return ACCT_TYPE_EXPENSE;
        case STOCK_REGISTER:
        case PORTFOLIO_LEDGER:
            return ACCT_TYPE_STOCK;
        case CURRENCY_REGISTER:
            return ACCT_TYPE_CURRENCY;
        case TRADING_REGISTER:
            return ACCT_TYPE_TRADING;
        case GENERAL_JOURNAL:
            return ACCT_TYPE_NONE;
        case EQUITY_REGISTER:
            return ACCT_TYPE_EQUITY;
        case SEARCH_LEDGER:
            return ACCT_TYPE_NONE;
        default:
            return ACCT_TYPE_NONE;
    }
}

const char*
gnc_split_register_get_debit_string (SplitRegister* reg)
{
    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;
}

const char*
gnc_split_register_get_credit_string (SplitRegister* reg)
{
    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;
}

gboolean
gnc_split_register_changed (SplitRegister* reg)
{
    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;
}

void
gnc_split_register_show_present_divider (SplitRegister* reg,
                                         gboolean show_present)
{
    SRInfo* info = gnc_split_register_get_info (reg);

    if (reg == NULL)
        return;

    info->show_present_divider = show_present;
}

gboolean
gnc_split_register_full_refresh_ok (SplitRegister* reg)
{
    SRInfo* info = gnc_split_register_get_info (reg);

    if (!info)
        return FALSE;

    return info->full_refresh;
}

/* configAction strings into the action cell */
/* hack alert -- this stuff really, really should be in a config file ... */
static void
gnc_split_register_config_action (SplitRegister* reg)
{
    ComboCell* cell;

    cell = (ComboCell*) gnc_table_layout_get_cell (reg->table->layout,
                                                   ACTN_CELL);

    /* setup strings in the action pull-down */
    switch (reg->type)
    {
        case BANK_REGISTER:
            /* broken ! FIXME bg */
        case SEARCH_LEDGER:
            gnc_combo_cell_add_menu_item (cell, C_ ("Action Column", "Deposit"));
            gnc_combo_cell_add_menu_item (cell, _ ("Withdraw"));
            gnc_combo_cell_add_menu_item (cell, _ ("Check"));
            gnc_combo_cell_add_menu_item (cell, _ ("Interest"));
            gnc_combo_cell_add_menu_item (cell, _ ("ATM Deposit"));
            gnc_combo_cell_add_menu_item (cell, _ ("ATM Draw"));
            gnc_combo_cell_add_menu_item (cell, _ ("Teller"));
            gnc_combo_cell_add_menu_item (cell, _ ("Charge"));
            gnc_combo_cell_add_menu_item (cell, _ ("Payment"));
            gnc_combo_cell_add_menu_item (cell, _ ("Receipt"));
            gnc_combo_cell_add_menu_item (cell, _ ("Increase"));
            gnc_combo_cell_add_menu_item (cell, _ ("Decrease"));
            /* Action: Point Of Sale */
            gnc_combo_cell_add_menu_item (cell, _ ("POS"));
            gnc_combo_cell_add_menu_item (cell, _ ("Phone"));
            gnc_combo_cell_add_menu_item (cell, _ ("Online"));
            /* Action: Automatic Deposit ?!? */
            gnc_combo_cell_add_menu_item (cell, _ ("AutoDep"));
            gnc_combo_cell_add_menu_item (cell, _ ("Wire"));
            gnc_combo_cell_add_menu_item (cell, _ ("Credit"));
            gnc_combo_cell_add_menu_item (cell, _ ("Direct Debit"));
            gnc_combo_cell_add_menu_item (cell, _ ("Transfer"));
            break;
        case CASH_REGISTER:
            gnc_combo_cell_add_menu_item (cell, _ ("Increase"));
            gnc_combo_cell_add_menu_item (cell, _ ("Decrease"));
            gnc_combo_cell_add_menu_item (cell, _ ("Buy"));
            gnc_combo_cell_add_menu_item (cell, _ ("Sell"));
            break;
        case ASSET_REGISTER:
            gnc_combo_cell_add_menu_item (cell, _ ("Buy"));
            gnc_combo_cell_add_menu_item (cell, _ ("Sell"));
            gnc_combo_cell_add_menu_item (cell, _ ("Fee"));
            break;
        case CREDIT_REGISTER:
            gnc_combo_cell_add_menu_item (cell, _ ("ATM Deposit"));
            gnc_combo_cell_add_menu_item (cell, _ ("ATM Draw"));
            gnc_combo_cell_add_menu_item (cell, _ ("Buy"));
            gnc_combo_cell_add_menu_item (cell, _ ("Credit"));
            gnc_combo_cell_add_menu_item (cell, _ ("Fee"));
            gnc_combo_cell_add_menu_item (cell, _ ("Interest"));
            gnc_combo_cell_add_menu_item (cell, _ ("Online"));
            gnc_combo_cell_add_menu_item (cell, _ ("Sell"));
            break;
        case LIABILITY_REGISTER:
            gnc_combo_cell_add_menu_item (cell, _ ("Buy"));
            gnc_combo_cell_add_menu_item (cell, _ ("Sell"));
            gnc_combo_cell_add_menu_item (cell, _ ("Loan"));
            gnc_combo_cell_add_menu_item (cell, _ ("Interest"));
            gnc_combo_cell_add_menu_item (cell, _ ("Payment"));
            break;
        case RECEIVABLE_REGISTER:
        case PAYABLE_REGISTER:
            gnc_combo_cell_add_menu_item (cell, _ ("Invoice"));
            gnc_combo_cell_add_menu_item (cell, _ ("Payment"));
            gnc_combo_cell_add_menu_item (cell, _ ("Interest"));
            gnc_combo_cell_add_menu_item (cell, _ ("Credit"));
            break;
        case INCOME_LEDGER:
        case INCOME_REGISTER:
            gnc_combo_cell_add_menu_item (cell, _ ("Increase"));
            gnc_combo_cell_add_menu_item (cell, _ ("Decrease"));
            gnc_combo_cell_add_menu_item (cell, _ ("Buy"));
            gnc_combo_cell_add_menu_item (cell, _ ("Sell"));
            gnc_combo_cell_add_menu_item (cell, _ ("Interest"));
            gnc_combo_cell_add_menu_item (cell, _ ("Payment"));
            gnc_combo_cell_add_menu_item (cell, _ ("Rebate"));
            gnc_combo_cell_add_menu_item (cell, _ ("Paycheck"));
            break;
        case EXPENSE_REGISTER:
        case TRADING_REGISTER:
            gnc_combo_cell_add_menu_item (cell, _ ("Increase"));
            gnc_combo_cell_add_menu_item (cell, _ ("Decrease"));
            gnc_combo_cell_add_menu_item (cell, _ ("Buy"));
            gnc_combo_cell_add_menu_item (cell, _ ("Sell"));
            break;
        case GENERAL_JOURNAL:
        case EQUITY_REGISTER:
            gnc_combo_cell_add_menu_item (cell, _ ("Buy"));
            gnc_combo_cell_add_menu_item (cell, _ ("Sell"));
            gnc_combo_cell_add_menu_item (cell, _ ("Equity"));
            break;
        case STOCK_REGISTER:
        case PORTFOLIO_LEDGER:
        case CURRENCY_REGISTER:
            gnc_combo_cell_add_menu_item (cell, ACTION_BUY_STR);
            gnc_combo_cell_add_menu_item (cell, ACTION_SELL_STR);
            gnc_combo_cell_add_menu_item (cell, _ ("Price"));
            gnc_combo_cell_add_menu_item (cell, _ ("Fee"));
            /* Action: Dividend */
            gnc_combo_cell_add_menu_item (cell, _ ("Dividend"));
            gnc_combo_cell_add_menu_item (cell, _ ("Interest"));
            /* Action: Long Term Capital Gains */
            gnc_combo_cell_add_menu_item (cell, _ ("LTCG"));
            /* Action: Short Term Capital Gains */
            gnc_combo_cell_add_menu_item (cell, _ ("STCG"));
            gnc_combo_cell_add_menu_item (cell, _ ("Income"));
            /* Action: Distribution */
            gnc_combo_cell_add_menu_item (cell, _ ("Dist"));
            gnc_combo_cell_add_menu_item (cell, C_ ("Action Column", "Split"));
            break;

        default:
            gnc_combo_cell_add_menu_item (cell, _ ("Increase"));
            gnc_combo_cell_add_menu_item (cell, _ ("Decrease"));
            gnc_combo_cell_add_menu_item (cell, _ ("Buy"));
            gnc_combo_cell_add_menu_item (cell, _ ("Sell"));
            break;
    }
}

static void
gnc_split_register_config_cells (SplitRegister* reg)
{
    gnc_combo_cell_add_ignore_string
        ((ComboCell*)
         gnc_table_layout_get_cell (reg->table->layout, MXFRM_CELL),
         SPLIT_TRANS_STR);

    gnc_combo_cell_add_ignore_string
        ((ComboCell*)
         gnc_table_layout_get_cell (reg->table->layout, MXFRM_CELL),
         STOCK_SPLIT_STR);

    /* the action cell */
    gnc_combo_cell_set_autosize
        ((ComboCell*)
         gnc_table_layout_get_cell (reg->table->layout, ACTN_CELL), TRUE);

    /* Use GNC_COMMODITY_MAX_FRACTION for prices and "exchange rates"  */
    gnc_price_cell_set_fraction
        ((PriceCell*)
         gnc_table_layout_get_cell (reg->table->layout, PRIC_CELL),
         GNC_COMMODITY_MAX_FRACTION);

    /* Initialize shares and share balance cells */
    gnc_price_cell_set_print_info
        ((PriceCell*) gnc_table_layout_get_cell (reg->table->layout, SHRS_CELL),
         gnc_default_share_print_info ());

    gnc_price_cell_set_print_info
        ((PriceCell*) gnc_table_layout_get_cell (reg->table->layout, TSHRS_CELL),
         gnc_default_share_print_info ());

    /* Initialize the rate cell
     * use a share_print_info to make sure we don't have rounding errors
     */
    gnc_price_cell_set_print_info
        ((PriceCell*) gnc_table_layout_get_cell (reg->table->layout, RATE_CELL),
         gnc_default_share_print_info ());

    /* The action cell should accept strings not in the list */
    gnc_combo_cell_set_strict
        ((ComboCell*)
         gnc_table_layout_get_cell (reg->table->layout, ACTN_CELL), FALSE);

    /* number format for share quantities in stock ledgers */
    switch (reg->type)
    {
        case CURRENCY_REGISTER:
        case STOCK_REGISTER:
        case PORTFOLIO_LEDGER:
            gnc_price_cell_set_print_info
                ((PriceCell*)
                 gnc_table_layout_get_cell (reg->table->layout, PRIC_CELL),
                 gnc_default_price_print_info (gnc_default_currency ()));
            break;

        default:
            break;
    }

    /* add menu items for the action cell */
    gnc_split_register_config_action (reg);
}

static void
split_register_pref_changed (gpointer prefs, gchar* pref, gpointer user_data)
{
    SplitRegister* reg = user_data;
    SRInfo* info;

    g_return_if_fail (pref);
    if (reg == NULL)
        return;

    info = reg->sr_info;
    if (!info)
        return;

    if (g_str_has_suffix (pref, GNC_PREF_ACCOUNTING_LABELS))
    {
        /* Release current strings. Will be reloaded at next reference. */
        g_free (info->tdebit_str);
        g_free (info->tcredit_str);

        info->debit_str = NULL;
        info->tdebit_str = NULL;
        info->credit_str = NULL;
        info->tcredit_str = NULL;

    }
    else if (g_str_has_suffix (pref, GNC_PREF_ACCOUNT_SEPARATOR))
    {
        info->separator_changed = TRUE;
    }
    else if (g_str_has_suffix (pref, GNC_PREF_SHOW_LEAF_ACCT_NAMES))
    {
        reg->show_leaf_accounts = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL_REGISTER,
                                                      GNC_PREF_SHOW_LEAF_ACCT_NAMES);
    }
    else if (g_str_has_suffix (pref, GNC_PREF_ALT_COLOR_BY_TRANS))
    {
        reg->double_alt_color = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL_REGISTER,
                                                    GNC_PREF_ALT_COLOR_BY_TRANS);
    }
    else
    {
        g_warning ("split_register_pref_changed: Unknown preference %s", pref);
    }
}

static void
split_register_book_option_changed (gpointer new_val, gpointer user_data)
{
    SplitRegister* reg = user_data;
    gboolean* new_data = (gboolean*)new_val;

    if (reg == NULL)
        return;

    reg->use_tran_num_for_num_field = (*new_data ? FALSE : TRUE);
}

static void
gnc_split_register_init (SplitRegister* reg,
                         SplitRegisterType type,
                         SplitRegisterStyle style,
                         gboolean use_double_line,
                         gboolean do_auto_complete,
                         gboolean is_template,
                         gboolean mismatched_commodities)
{
    TableLayout* layout;
    TableModel* model;
    TableControl* control;

    /* Register 'destroy' callback */
    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
                           GNC_PREF_ACCOUNTING_LABELS,
                           split_register_pref_changed,
                           reg);
    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL,
                           GNC_PREF_ACCOUNT_SEPARATOR,
                           split_register_pref_changed,
                           reg);
    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL_REGISTER,
                           GNC_PREF_SHOW_LEAF_ACCT_NAMES,
                           split_register_pref_changed,
                           reg);
    gnc_prefs_register_cb (GNC_PREFS_GROUP_GENERAL_REGISTER,
                           GNC_PREF_ALT_COLOR_BY_TRANS,
                           split_register_pref_changed,
                           reg);
    gnc_book_option_register_cb (OPTION_NAME_NUM_FIELD_SOURCE,
                                 split_register_book_option_changed,
                                 reg);

    reg->sr_info = NULL;

    reg->unrecn_splits = NULL;

    reg->show_leaf_accounts = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL_REGISTER,
                                                  GNC_PREF_SHOW_LEAF_ACCT_NAMES);
    reg->double_alt_color = gnc_prefs_get_bool (GNC_PREFS_GROUP_GENERAL_REGISTER,
                                                GNC_PREF_ALT_COLOR_BY_TRANS);

    reg->type = type;
    reg->style = style;
    reg->use_double_line = use_double_line;
    reg->do_auto_complete = do_auto_complete;
    reg->is_template = is_template;
    reg->mismatched_commodities = mismatched_commodities;
    reg->use_tran_num_for_num_field =
        (qof_book_use_split_action_for_num_field (gnc_get_current_book ())
         ? FALSE : TRUE);

    layout = gnc_split_register_layout_new (reg);

    if (is_template)
        model = gnc_template_register_model_new ();
    else
        model = gnc_split_register_model_new ();
    model->handler_user_data = reg;

    control = gnc_split_register_control_new ();
    control->user_data = reg;

    reg->table = gnc_table_new (layout, model, control);

    gnc_split_register_config_cells (reg);

    /* Set up header */
    {
        VirtualCellLocation vcell_loc = { 0, 0 };
        CellBlock* header;

        header = gnc_table_layout_get_cursor (reg->table->layout, CURSOR_HEADER);

        gnc_table_set_vcell (reg->table, header, NULL, TRUE, TRUE, vcell_loc);
    }

    /* Set up first and only 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 (reg->table->layout,
                                              CURSOR_SINGLE_LEDGER);

        gnc_table_set_vcell (reg->table, cursor, NULL, TRUE, TRUE, vloc.vcell_loc);

        if (gnc_table_find_close_valid_cell (reg->table, &vloc, FALSE))
            gnc_table_move_cursor (reg->table, vloc);
        else
        {
            PERR ("Can't find valid initial location");
        }
    }
}

SplitRegister*
gnc_split_register_new (SplitRegisterType type,
                        SplitRegisterStyle style,
                        gboolean use_double_line,
                        gboolean is_template,
                        gboolean mismatched_commodities)
{
    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;
}

void
gnc_split_register_config (SplitRegister* reg,
                           SplitRegisterType newtype,
                           SplitRegisterStyle newstyle,
                           gboolean use_double_line)
{
    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);
}

void
gnc_split_register_set_reverse_sort (SplitRegister* reg, gboolean reverse_sort)
{
    g_return_if_fail (reg);
    gnc_table_model_set_reverse_sort (reg->table->model, reverse_sort);
}

void
gnc_split_register_set_auto_complete (SplitRegister* reg,
                                      gboolean do_auto_complete)
{
    g_return_if_fail (reg);
    reg->do_auto_complete = do_auto_complete;
}

static void
gnc_split_register_destroy_info (SplitRegister* reg)
{
    SRInfo* info;

    if (reg == NULL)
        return;

    if (reg->unrecn_splits != NULL)
    {
        g_list_free (reg->unrecn_splits);
        reg->unrecn_splits =  NULL;
    }

    info = reg->sr_info;
    if (!info)
        return;

    g_free (info->tdebit_str);
    g_free (info->tcredit_str);

    info->debit_str = NULL;
    info->tdebit_str = NULL;
    info->credit_str = NULL;
    info->tcredit_str = NULL;

    g_free (reg->sr_info);

    reg->sr_info = NULL;
}

void
gnc_split_register_set_data (SplitRegister* reg, void* user_data,
                             SRGetParentCallback get_parent)
{
    SRInfo* info = gnc_split_register_get_info (reg);

    g_return_if_fail (reg != NULL);

    info->user_data = user_data;
    info->get_parent = get_parent;
}

static void
gnc_split_register_cleanup (SplitRegister* reg)
{
    SRInfo* info = gnc_split_register_get_info (reg);
    Transaction* pending_trans;
    Transaction* blank_trans = NULL;
    Split* blank_split;

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

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

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

    gnc_suspend_gui_refresh ();

    /* Destroy the transaction containing the "blank split", which was only
     * created to support the area for entering a new transaction. Since the
     * register is closing, this transaction is no longer needed. */
    if (blank_split != NULL)
    {
        gboolean was_open;

        blank_trans = xaccSplitGetParent (blank_split);

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

        /* Destroying the transaction will automatically remove its splits. */
        was_open = xaccTransIsOpen (blank_trans);
        xaccTransDestroy (blank_trans);
        if (was_open)
            xaccTransCommitEdit (blank_trans);

        /* Update the register info. */
        if (blank_trans == pending_trans)
        {
            info->pending_trans_guid = *guid_null ();
            pending_trans = NULL;
        }
        info->blank_split_guid = *guid_null ();
        info->auto_complete = FALSE;
        blank_split = NULL;
    }

    /* be sure to take care of any open transactions */
    if (pending_trans != NULL)
    {
        g_critical ("BUG DETECTED: pending_trans=%p, blank_split=%p, blank_trans=%p",
                    pending_trans, blank_split, blank_trans);
        g_assert_not_reached ();
        info->pending_trans_guid = *guid_null ();
        /* CAS: It's not clear to me that we'd really want to commit
           here, rather than rollback. But, maybe this is just dead
           code. */
        if (xaccTransIsOpen (pending_trans))
            xaccTransCommitEdit (pending_trans);
        else g_assert_not_reached ();

        pending_trans = NULL;
    }

    gnc_split_register_destroy_info (reg);

    gnc_resume_gui_refresh ();

    LEAVE (" ");
}

void
gnc_split_register_destroy (SplitRegister* reg)
{
    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 (" ");
}

void
gnc_split_register_set_read_only (SplitRegister* reg, gboolean read_only)
{
    gnc_table_model_set_read_only (reg->table->model, read_only);
}

SplitRegisterTypeGroup
gnc_split_register_get_register_group (SplitRegister *reg)
{
    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;
    }
}