IntenseFinance/gnucash
3
0
Fork 0
mirror of https://github.com/Gnucash/gnucash.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

Change integer cell types to string cell names.

Browse Source 
git-svn-id: svn+ssh://svn.gnucash.org/repo/gnucash/trunk@5270 57a11ea4-9604-0410-9ed3-97b8803252fd
This commit is contained in:
Dave Peticolas 2001-09-03 11:06:29 +00:00
parent 32c67f6d85
commit 907b7fc5d7
19 changed files with 565 additions and 487 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/register/ledger-core/split-register-control.c
View File

@ -542,7 +542,7 @@ gnc_split_register_auto_completion (SplitRegister *reg,
Transaction *blank_trans = xaccSplitGetParent (blank_split); Transaction *blank_trans = xaccSplitGetParent (blank_split);
VirtualLocation new_virt_loc; VirtualLocation new_virt_loc;
CursorClass cursor_class; CursorClass cursor_class;
CellType cell_type; const char *cell_name;
Transaction *trans; Transaction *trans;
gnc_numeric amount; gnc_numeric amount;
BasicCell *cell; BasicCell *cell;
@ -552,13 +552,13 @@ gnc_split_register_auto_completion (SplitRegister *reg,
if (dir != GNC_TABLE_TRAVERSE_RIGHT) if (dir != GNC_TABLE_TRAVERSE_RIGHT)
return FALSE; return FALSE;
split = xaccSRGetCurrentSplit(reg); split = xaccSRGetCurrentSplit (reg);
trans = xaccSRGetCurrentTrans(reg); trans = xaccSRGetCurrentTrans (reg);
if (trans == NULL) if (trans == NULL)
return FALSE; return FALSE;
cursor_class = xaccSplitRegisterGetCurrentCursorClass (reg); cursor_class = xaccSplitRegisterGetCurrentCursorClass (reg);
cell_type = gnc_table_get_current_cell_type (reg->table); cell_name = gnc_table_get_current_cell_name (reg->table);
switch (cursor_class) switch (cursor_class)
{ {
@ -576,7 +576,7 @@ gnc_split_register_auto_completion (SplitRegister *reg,
return FALSE; return FALSE;
/* and leaving the description cell */ /* and leaving the description cell */
if (cell_type != DESC_CELL) if (!gnc_cell_name_equal (cell_name, DESC_CELL))
return FALSE; return FALSE;
/* nothing but the date, num, and description should be changed */ /* nothing but the date, num, and description should be changed */
@ -681,9 +681,9 @@ gnc_split_register_auto_completion (SplitRegister *reg,
/* now move to the non-empty amount column */ /* now move to the non-empty amount column */
amount = xaccSplitGetAmount (blank_split); amount = xaccSplitGetAmount (blank_split);
cell_type = (gnc_numeric_negative_p (amount)) ? CRED_CELL : DEBT_CELL; cell_name = (gnc_numeric_negative_p (amount)) ? CRED_CELL : DEBT_CELL;
if (gnc_table_get_current_cell_location (reg->table, cell_type, if (gnc_table_get_current_cell_location (reg->table, cell_name,
&new_virt_loc)) &new_virt_loc))
*p_new_virt_loc = new_virt_loc; *p_new_virt_loc = new_virt_loc;
} }
@ -702,7 +702,7 @@ gnc_split_register_auto_completion (SplitRegister *reg,
return FALSE; return FALSE;
/* and leaving the memo cell */ /* and leaving the memo cell */
if (cell_type != MEMO_CELL) if (!gnc_cell_name_equal (cell_name, MEMO_CELL))
return FALSE; return FALSE;
/* nothing but the action, memo, and amounts should be changed */ /* nothing but the action, memo, and amounts should be changed */
@ -797,9 +797,9 @@ gnc_split_register_auto_completion (SplitRegister *reg,
/* now move to the non-empty amount column */ /* now move to the non-empty amount column */
amount = xaccSplitGetAmount (auto_split); amount = xaccSplitGetAmount (auto_split);
cell_type = (gnc_numeric_negative_p (amount)) ? CRED_CELL : DEBT_CELL; cell_name = (gnc_numeric_negative_p (amount)) ? CRED_CELL : DEBT_CELL;
if (gnc_table_get_current_cell_location (reg->table, cell_type, if (gnc_table_get_current_cell_location (reg->table, cell_name,
&new_virt_loc)) &new_virt_loc))
*p_new_virt_loc = new_virt_loc; *p_new_virt_loc = new_virt_loc;
} }
@ -860,37 +860,33 @@ gnc_split_register_traverse (VirtualLocation *p_new_virt_loc,
/* See if we are leaving an account field */ /* See if we are leaving an account field */
do do
{ {
CellType cell_type; const char *cell_name;
ComboCell *cell; ComboCell *cell;
Account *account; Account *account;
char *name; char *name;
cell_type = gnc_table_get_current_cell_type (reg->table); cell_name = gnc_table_get_current_cell_name (reg->table);
if (!(cell_type == XFRM_CELL || if (!gnc_cell_name_equal (cell_name, XFRM_CELL) &&
cell_type == MXFRM_CELL)) !gnc_cell_name_equal (cell_name, MXFRM_CELL))
break; break;
cell = NULL; cell = NULL;
switch (cell_type) if (gnc_cell_name_equal (cell_name, XFRM_CELL))
{ {
case XFRM_CELL: if (gnc_table_layout_get_cell_changed (reg->table->layout,
if (gnc_table_layout_get_cell_changed (reg->table->layout, XFRM_CELL, FALSE))
XFRM_CELL, FALSE)) cell = (ComboCell *) gnc_table_layout_get_cell (reg->table->layout,
cell = (ComboCell *) gnc_table_layout_get_cell (reg->table->layout, XFRM_CELL);
XFRM_CELL); }
break;
case MXFRM_CELL: if (gnc_cell_name_equal (cell_name, MXFRM_CELL))
if (gnc_table_layout_get_cell_changed (reg->table->layout, {
MXFRM_CELL, FALSE)) if (gnc_table_layout_get_cell_changed (reg->table->layout,
cell = (ComboCell *) gnc_table_layout_get_cell (reg->table->layout, MXFRM_CELL, FALSE))
MXFRM_CELL); cell = (ComboCell *) gnc_table_layout_get_cell (reg->table->layout,
break; MXFRM_CELL);
default:
break;
} }
if (!cell) if (!cell)

38
src/register/ledger-core/split-register-model.c
View File

@ -371,9 +371,9 @@ gnc_split_register_get_shares_fg_color (VirtualLocation virt_loc,
SplitRegister *reg = user_data; SplitRegister *reg = user_data;
const guint32 black = 0x000000; const guint32 black = 0x000000;
const guint32 red = 0xff0000; const guint32 red = 0xff0000;
const char * cell_name;
gboolean is_current; gboolean is_current;
gnc_numeric shares; gnc_numeric shares;
CellType cell_type;
Split *split; Split *split;
if (!use_red_for_negative) if (!use_red_for_negative)
@ -383,12 +383,12 @@ gnc_split_register_get_shares_fg_color (VirtualLocation virt_loc,
if (!split) if (!split)
return black; return black;
cell_type = gnc_table_get_cell_type (reg->table, virt_loc); cell_name = gnc_table_get_cell_name (reg->table, virt_loc);
is_current = virt_cell_loc_equal (reg->table->current_cursor_loc.vcell_loc, is_current = virt_cell_loc_equal (reg->table->current_cursor_loc.vcell_loc,
virt_loc.vcell_loc); virt_loc.vcell_loc);
if (cell_type == TSHRS_CELL) if (gnc_cell_name_equal (cell_name, TSHRS_CELL))
shares = get_trans_total_amount (reg, xaccSplitGetParent (split)); shares = get_trans_total_amount (reg, xaccSplitGetParent (split));
else if (is_current) else if (is_current)
shares = gnc_price_cell_get_value shares = gnc_price_cell_get_value
@ -410,8 +410,8 @@ gnc_split_register_get_balance_fg_color (VirtualLocation virt_loc,
SplitRegister *reg = user_data; SplitRegister *reg = user_data;
const guint32 black = 0x000000; const guint32 black = 0x000000;
const guint32 red = 0xff0000; const guint32 red = 0xff0000;
const char * cell_name;
gnc_numeric balance; gnc_numeric balance;
CellType cell_type;
Split *split; Split *split;
if (!use_red_for_negative) if (!use_red_for_negative)
@ -421,9 +421,9 @@ gnc_split_register_get_balance_fg_color (VirtualLocation virt_loc,
if (!split) if (!split)
return black; return black;
cell_type = gnc_table_get_cell_type (reg->table, virt_loc); cell_name = gnc_table_get_cell_name (reg->table, virt_loc);
if (cell_type == BALN_CELL) if (gnc_cell_name_equal (cell_name, BALN_CELL))
balance = xaccSplitGetBalance (split); balance = xaccSplitGetBalance (split);
else else
balance = get_trans_total_balance (reg, xaccSplitGetParent (split)); balance = get_trans_total_balance (reg, xaccSplitGetParent (split));
@ -737,7 +737,8 @@ gnc_split_register_get_balance_entry (VirtualLocation virt_loc,
if (split == xaccSplitLookup (&info->blank_split_guid)) if (split == xaccSplitLookup (&info->blank_split_guid))
return NULL; return NULL;
is_trans = gnc_table_get_cell_type (reg->table, virt_loc) == TBALN_CELL; is_trans = gnc_cell_name_equal
(gnc_table_get_cell_name (reg->table, virt_loc), TBALN_CELL);
if (is_trans) if (is_trans)
balance = get_trans_total_balance (reg, xaccSplitGetParent (split)); balance = get_trans_total_balance (reg, xaccSplitGetParent (split));
@ -887,24 +888,26 @@ gnc_split_register_get_tdebcred_entry (VirtualLocation virt_loc,
gpointer user_data) gpointer user_data)
{ {
SplitRegister *reg = user_data; SplitRegister *reg = user_data;
const char * cell_name;
gnc_numeric total; gnc_numeric total;
int cell_type;
Split *split; Split *split;
split = sr_get_split (reg, virt_loc.vcell_loc); split = sr_get_split (reg, virt_loc.vcell_loc);
if (!split) if (!split)
return NULL; return NULL;
cell_type = gnc_table_get_cell_type (reg->table, virt_loc); cell_name = gnc_table_get_cell_name (reg->table, virt_loc);
total = get_trans_total_amount (reg, xaccSplitGetParent (split)); total = get_trans_total_amount (reg, xaccSplitGetParent (split));
if (gnc_numeric_zero_p (total)) if (gnc_numeric_zero_p (total))
return NULL; return NULL;
if (gnc_numeric_negative_p (total) && (cell_type == TDEBT_CELL)) if (gnc_numeric_negative_p (total) &&
gnc_cell_name_equal (cell_name, TDEBT_CELL))
return NULL; return NULL;
if (gnc_numeric_positive_p (total) && (cell_type == TCRED_CELL)) if (gnc_numeric_positive_p (total) &&
gnc_cell_name_equal (cell_name, TCRED_CELL))
return NULL; return NULL;
total = gnc_numeric_abs (total); total = gnc_numeric_abs (total);
@ -922,7 +925,8 @@ gnc_split_register_get_debcred_entry (VirtualLocation virt_loc,
gboolean is_debit; gboolean is_debit;
Split *split; Split *split;
is_debit = gnc_table_get_cell_type (reg->table, virt_loc) == DEBT_CELL; is_debit = gnc_cell_name_equal
(gnc_table_get_cell_name (reg->table, virt_loc), DEBT_CELL);
split = sr_get_split (reg, virt_loc.vcell_loc); split = sr_get_split (reg, virt_loc.vcell_loc);
@ -1173,7 +1177,7 @@ gnc_template_register_get_debcred_entry (VirtualLocation virt_loc,
if (kvpf) if (kvpf)
{ {
gnc_numeric amount; gnc_numeric amount;
int cell_type; const char * cell_name;
char *str; char *str;
str = kvp_value_get_string (kvp_frame_get_slot (kvpf, str = kvp_value_get_string (kvp_frame_get_slot (kvpf,
@ -1184,12 +1188,14 @@ gnc_template_register_get_debcred_entry (VirtualLocation virt_loc,
if (gnc_numeric_zero_p (amount)) if (gnc_numeric_zero_p (amount))
return ""; return "";
cell_type = gnc_table_get_cell_type (reg->table, virt_loc); cell_name = gnc_table_get_cell_name (reg->table, virt_loc);
if (gnc_numeric_negative_p (amount) && (cell_type == DEBT_CELL)) if (gnc_numeric_negative_p (amount) &&
gnc_cell_name_equal (cell_name, DEBT_CELL))
return ""; return "";
if (gnc_numeric_positive_p (amount) && (cell_type == CRED_CELL)) if (gnc_numeric_positive_p (amount) &&
gnc_cell_name_equal (cell_name, CRED_CELL))
return ""; return "";
amount = gnc_numeric_abs (amount); amount = gnc_numeric_abs (amount);

3
src/register/ledger-core/split-register-p.h
View File

@ -137,7 +137,8 @@ CellBlock * sr_get_active_cursor (SplitRegister *reg);
void sr_set_last_num (SplitRegister *reg, const char *num); void sr_set_last_num (SplitRegister *reg, const char *num);
Account * gnc_split_register_get_account (SplitRegister *reg, int cell_type); Account * gnc_split_register_get_account (SplitRegister *reg,
const char *cell_name);
gboolean gnc_split_register_recn_cell_confirm (char old_flag, gpointer data); gboolean gnc_split_register_recn_cell_confirm (char old_flag, gpointer data);

12
src/register/ledger-core/split-register.c
View File

@ -480,7 +480,7 @@ xaccSRGetSplitAmountVirtLoc (SplitRegister *reg, Split *split,
{ {
VirtualLocation v_loc; VirtualLocation v_loc;
CursorClass cursor_class; CursorClass cursor_class;
CellType cell_type; const char *cell_name;
gnc_numeric value; gnc_numeric value;
if (!xaccSRGetSplitVirtLoc (reg, split, &v_loc.vcell_loc)) if (!xaccSRGetSplitVirtLoc (reg, split, &v_loc.vcell_loc))
@ -494,13 +494,13 @@ xaccSRGetSplitAmountVirtLoc (SplitRegister *reg, Split *split,
{ {
case CURSOR_CLASS_SPLIT: case CURSOR_CLASS_SPLIT:
case CURSOR_CLASS_TRANS: case CURSOR_CLASS_TRANS:
cell_type = (gnc_numeric_negative_p (value)) ? CRED_CELL : DEBT_CELL; cell_name = (gnc_numeric_negative_p (value)) ? CRED_CELL : DEBT_CELL;
break; break;
default: default:
return FALSE; return FALSE;
} }
if (!gnc_table_get_cell_location (reg->table, cell_type, if (!gnc_table_get_cell_location (reg->table, cell_name,
v_loc.vcell_loc, &v_loc)) v_loc.vcell_loc, &v_loc))
return FALSE; return FALSE;
@ -1520,14 +1520,14 @@ xaccSRSaveRegEntry (SplitRegister *reg, gboolean do_commit)
} }
Account * Account *
gnc_split_register_get_account (SplitRegister *reg, int cell_type) gnc_split_register_get_account (SplitRegister *reg, const char * cell_name)
{ {
const char *name; const char *name;
if (!gnc_table_layout_get_cell_changed (reg->table->layout, cell_type, TRUE)) if (!gnc_table_layout_get_cell_changed (reg->table->layout, cell_name, TRUE))
return NULL; return NULL;
name = gnc_table_layout_get_cell_value (reg->table->layout, cell_type); name = gnc_table_layout_get_cell_value (reg->table->layout, cell_name);
return xaccGetAccountFromFullName (gncGetCurrentGroup (), return xaccGetAccountFromFullName (gncGetCurrentGroup (),
name, gnc_get_account_separator ()); name, gnc_get_account_separator ());

29
src/register/register-core/basiccell.c
View File

@ -33,6 +33,8 @@
* Copyright (c) 2000 Dave Peticolas <dave@krondo.com> * Copyright (c) 2000 Dave Peticolas <dave@krondo.com>
*/ */
#include "config.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -43,6 +45,13 @@
/* This static indicates the debugging module that this .o belongs to. */ /* This static indicates the debugging module that this .o belongs to. */
static short module = MOD_REGISTER; static short module = MOD_REGISTER;
gboolean
gnc_cell_name_equal (const char * cell_name_1,
const char * cell_name_2)
{
return (safe_strcmp (cell_name_1, cell_name_2) == 0);
}
BasicCell * BasicCell *
gnc_basic_cell_new (void) gnc_basic_cell_new (void)
{ {
@ -70,7 +79,8 @@ BasicCellHelpValue(BasicCell *cell)
static void static void
gnc_basic_cell_clear (BasicCell *cell) gnc_basic_cell_clear (BasicCell *cell)
{ {
cell->cell_type = -1; g_free (cell->cell_name);
cell->cell_name = NULL;
cell->changed = FALSE; cell->changed = FALSE;
cell->conditionally_changed = FALSE; cell->conditionally_changed = FALSE;
@ -138,10 +148,23 @@ gnc_basic_cell_destroy (BasicCell *cell)
} }
void void
gnc_basic_cell_set_name (BasicCell *cell, int cell_type) gnc_basic_cell_set_name (BasicCell *cell, const char *name)
{ {
if (!cell) return; if (!cell) return;
cell->cell_type = cell_type; if (cell->cell_name == name) return;
g_free (cell->cell_name);
cell->cell_name = g_strdup (name);
}
gboolean
gnc_basic_cell_has_name (BasicCell *cell, const char *name)
{
if (!cell) return FALSE;
if (!name) return FALSE;
if (!cell->cell_name) return FALSE;
return (strcmp (name, cell->cell_name) == 0);
} }
void void

8
src/register/register-core/basiccell.h
View File

@ -191,7 +191,7 @@ typedef enum
struct _BasicCell struct _BasicCell
{ {
int cell_type; char * cell_name;
char * value; /* current value */ char * value; /* current value */
char * blank_help; /* help when value is blank */ char * blank_help; /* help when value is blank */
@ -232,11 +232,15 @@ struct _BasicCell
}; };
gboolean gnc_cell_name_equal (const char * cell_name_1,
const char * cell_name_2);
BasicCell * gnc_basic_cell_new (void); BasicCell * gnc_basic_cell_new (void);
void gnc_basic_cell_init (BasicCell *bcell); void gnc_basic_cell_init (BasicCell *bcell);
void gnc_basic_cell_destroy (BasicCell *bcell); void gnc_basic_cell_destroy (BasicCell *bcell);
void gnc_basic_cell_set_name (BasicCell *cell, int cell_type); void gnc_basic_cell_set_name (BasicCell *cell, const char *name);
gboolean gnc_basic_cell_has_name (BasicCell *cell, const char *name);
void gnc_basic_cell_set_sample_text (BasicCell *cell, void gnc_basic_cell_set_sample_text (BasicCell *cell,
const char *sample_text); const char *sample_text);

355
src/register/register-core/splitreg.c
View File

@ -70,7 +70,7 @@ xaccInitSplitRegister (SplitRegister *reg,
static void static void
gnc_register_add_cell (SplitRegister *sr, gnc_register_add_cell (SplitRegister *sr,
CellType cell_type, const char *cell_name,
const char *cell_type_name, const char *cell_type_name,
const char *sample_text, const char *sample_text,
CellAlignment alignment, CellAlignment alignment,
@ -84,7 +84,7 @@ gnc_register_add_cell (SplitRegister *sr,
cell = gnc_register_make_cell (cell_type_name); cell = gnc_register_make_cell (cell_type_name);
gnc_basic_cell_set_name (cell, cell_type); gnc_basic_cell_set_name (cell, cell_name);
gnc_basic_cell_set_sample_text (cell, sample_text); gnc_basic_cell_set_sample_text (cell, sample_text);
gnc_basic_cell_set_alignment (cell, alignment); gnc_basic_cell_set_alignment (cell, alignment);
gnc_basic_cell_set_expandable (cell, expandable); gnc_basic_cell_set_expandable (cell, expandable);
@ -93,10 +93,8 @@ gnc_register_add_cell (SplitRegister *sr,
gnc_table_layout_add_cell (sr->table->layout, cell); gnc_table_layout_add_cell (sr->table->layout, cell);
} }
/* ============================================== */
/* configAction strings into the action cell */ /* configAction strings into the action cell */
/* hack alert -- this stuff really, really should be in a config file ... */ /* hack alert -- this stuff really, really should be in a config file ... */
static void static void
configAction (SplitRegister *reg) configAction (SplitRegister *reg)
{ {
@ -198,34 +196,6 @@ configAction (SplitRegister *reg)
} }
} }
/* ============================================== */
static void
set_cell (SplitRegister *reg, CellBlock *cursor,
CellType cell_type, short row, short col)
{
CellBlock *header;
CellBlock *cursor_sl;
BasicCell *cell;
header = gnc_table_layout_get_cursor (reg->table->layout, CURSOR_HEADER);
cursor->start_col = MIN (cursor->start_col, col);
cursor->stop_col = MAX (cursor->stop_col, col);
header->start_col = MIN (header->start_col, col);
header->stop_col = MAX (header->stop_col, col);
cell = gnc_table_layout_get_cell (reg->table->layout, cell_type);
gnc_cellblock_set_cell (cursor, row, col, cell);
cursor_sl = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_LEDGER);
if (cursor == cursor_sl)
gnc_cellblock_set_cell (header, row, col, cell);
}
static void static void
copy_cursor_row (SplitRegister *reg, CellBlock *to, CellBlock *from, int row) copy_cursor_row (SplitRegister *reg, CellBlock *to, CellBlock *from, int row)
{ {
@ -236,15 +206,14 @@ copy_cursor_row (SplitRegister *reg, CellBlock *to, CellBlock *from, int row)
BasicCell *cell; BasicCell *cell;
cell = gnc_cellblock_get_cell (from, row, col); cell = gnc_cellblock_get_cell (from, row, col);
if (!cell || cell->cell_type < 0) if (!cell || !cell->cell_name)
continue; continue;
set_cell (reg, to, cell->cell_type, row, col); gnc_table_layout_set_cell (reg->table->layout, to,
cell->cell_name, row, col);
} }
} }
/* ============================================== */
static void static void
configLayout (SplitRegister *reg) configLayout (SplitRegister *reg)
{ {
@ -265,19 +234,22 @@ configLayout (SplitRegister *reg)
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_LEDGER); CURSOR_SINGLE_LEDGER);
set_cell (reg, curs, DATE_CELL, 0, 0); gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, MXFRM_CELL, 0, 3); gnc_table_layout_set_cell (reg->table->layout, curs, MXFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4); gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
if ( reg->template ) { if (reg->template)
set_cell( reg, curs, FDEBT_CELL, 0, 5); {
set_cell( reg, curs, FCRED_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, FDEBT_CELL, 0, 5);
} else { gnc_table_layout_set_cell (reg->table->layout, curs, FCRED_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 5);
set_cell (reg, curs, CRED_CELL, 0, 6);
} }
set_cell (reg, curs, BALN_CELL, 0, 7); else
{
gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 6);
}
gnc_table_layout_set_cell (reg->table->layout, curs, BALN_CELL, 0, 7);
curs_last = curs; curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -285,18 +257,18 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0); copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, ACTN_CELL, 1, 1); gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 1, 1);
set_cell (reg, curs, NOTES_CELL, 1, 2); gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_JOURNAL); CURSOR_SINGLE_JOURNAL);
set_cell (reg, curs, DATE_CELL, 0, 0); gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, TDEBT_CELL, 0, 5); gnc_table_layout_set_cell (reg->table->layout, curs, TDEBT_CELL, 0, 5);
set_cell (reg, curs, TCRED_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, TCRED_CELL, 0, 6);
set_cell (reg, curs, TBALN_CELL, 0, 7); gnc_table_layout_set_cell (reg->table->layout, curs, TBALN_CELL, 0, 7);
curs_last = curs; curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -304,21 +276,24 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0); copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, NOTES_CELL, 1, 2); gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SPLIT); CURSOR_SPLIT);
set_cell (reg, curs, ACTN_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 0, 1);
set_cell (reg, curs, MEMO_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, MEMO_CELL, 0, 2);
set_cell (reg, curs, XFRM_CELL, 0, 3); gnc_table_layout_set_cell (reg->table->layout, curs, XFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4); gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
if ( reg->template ) { if (reg->template)
set_cell( reg, curs, FDEBT_CELL, 0, 5); {
set_cell( reg, curs, FCRED_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, FDEBT_CELL, 0, 5);
} else { gnc_table_layout_set_cell (reg->table->layout, curs, FCRED_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 5); }
set_cell (reg, curs, CRED_CELL, 0, 6); else
{
gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 6);
} }
break; break;
@ -332,17 +307,20 @@ configLayout (SplitRegister *reg)
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_LEDGER); CURSOR_SINGLE_LEDGER);
set_cell (reg, curs, DATE_CELL, 0, 0); gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, MXFRM_CELL, 0, 3); gnc_table_layout_set_cell (reg->table->layout, curs, MXFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4); gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
if ( reg->template ) { if (reg->template)
set_cell (reg, curs, FDEBT_CELL, 0, 5); {
set_cell (reg, curs, FCRED_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, FDEBT_CELL, 0, 5);
} else { gnc_table_layout_set_cell (reg->table->layout, curs, FCRED_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 5); }
set_cell (reg, curs, CRED_CELL, 0, 6); else
{
gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 6);
} }
curs_last = curs; curs_last = curs;
@ -351,17 +329,17 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0); copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, ACTN_CELL, 1, 1); gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 1, 1);
set_cell (reg, curs, NOTES_CELL, 1, 2); gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_JOURNAL); CURSOR_SINGLE_JOURNAL);
set_cell (reg, curs, DATE_CELL, 0, 0); gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, TDEBT_CELL, 0, 5); gnc_table_layout_set_cell (reg->table->layout, curs, TDEBT_CELL, 0, 5);
set_cell (reg, curs, TCRED_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, TCRED_CELL, 0, 6);
curs_last = curs; curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -369,21 +347,24 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0); copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, NOTES_CELL, 1, 2); gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SPLIT); CURSOR_SPLIT);
set_cell (reg, curs, ACTN_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 0, 1);
set_cell (reg, curs, MEMO_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, MEMO_CELL, 0, 2);
set_cell (reg, curs, XFRM_CELL, 0, 3); gnc_table_layout_set_cell (reg->table->layout, curs, XFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4); gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
if ( reg->template ) { if (reg->template)
set_cell (reg, curs, FDEBT_CELL, 0, 5); {
set_cell (reg, curs, FCRED_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, FDEBT_CELL, 0, 5);
} else { gnc_table_layout_set_cell (reg->table->layout, curs, FCRED_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 5); }
set_cell (reg, curs, CRED_CELL, 0, 6); else
{
gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 6);
} }
break; break;
@ -396,16 +377,16 @@ configLayout (SplitRegister *reg)
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_LEDGER); CURSOR_SINGLE_LEDGER);
set_cell (reg, curs, DATE_CELL, 0, 0); gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, MXFRM_CELL, 0, 3); gnc_table_layout_set_cell (reg->table->layout, curs, MXFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4); gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
set_cell (reg, curs, SHRS_CELL, 0, 5); gnc_table_layout_set_cell (reg->table->layout, curs, SHRS_CELL, 0, 5);
set_cell (reg, curs, PRIC_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, PRIC_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 7); gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 7);
set_cell (reg, curs, CRED_CELL, 0, 8); gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 8);
set_cell (reg, curs, BALN_CELL, 0, 9); gnc_table_layout_set_cell (reg->table->layout, curs, BALN_CELL, 0, 9);
curs_last = curs; curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -413,19 +394,19 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0); copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, ACTN_CELL, 1, 1); gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 1, 1);
set_cell (reg, curs, NOTES_CELL, 1, 2); gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_JOURNAL); CURSOR_SINGLE_JOURNAL);
set_cell (reg, curs, DATE_CELL, 0, 0); gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, TSHRS_CELL, 0, 5); gnc_table_layout_set_cell (reg->table->layout, curs, TSHRS_CELL, 0, 5);
set_cell (reg, curs, TDEBT_CELL, 0, 7); gnc_table_layout_set_cell (reg->table->layout, curs, TDEBT_CELL, 0, 7);
set_cell (reg, curs, TCRED_CELL, 0, 8); gnc_table_layout_set_cell (reg->table->layout, curs, TCRED_CELL, 0, 8);
set_cell (reg, curs, TBALN_CELL, 0, 9); gnc_table_layout_set_cell (reg->table->layout, curs, TBALN_CELL, 0, 9);
curs_last = curs; curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -433,19 +414,19 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0); copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, NOTES_CELL, 1, 2); gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SPLIT); CURSOR_SPLIT);
set_cell (reg, curs, ACTN_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 0, 1);
set_cell (reg, curs, MEMO_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, MEMO_CELL, 0, 2);
set_cell (reg, curs, XFRM_CELL, 0, 3); gnc_table_layout_set_cell (reg->table->layout, curs, XFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4); gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
set_cell (reg, curs, SHRS_CELL, 0, 5); gnc_table_layout_set_cell (reg->table->layout, curs, SHRS_CELL, 0, 5);
set_cell (reg, curs, PRIC_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, PRIC_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 7); gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 7);
set_cell (reg, curs, CRED_CELL, 0, 8); gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 8);
break; break;
} }
@ -456,15 +437,15 @@ configLayout (SplitRegister *reg)
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_LEDGER); CURSOR_SINGLE_LEDGER);
set_cell (reg, curs, DATE_CELL, 0, 0); gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, MXFRM_CELL, 0, 3); gnc_table_layout_set_cell (reg->table->layout, curs, MXFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4); gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
set_cell (reg, curs, SHRS_CELL, 0, 5); gnc_table_layout_set_cell (reg->table->layout, curs, SHRS_CELL, 0, 5);
set_cell (reg, curs, PRIC_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, PRIC_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 7); gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 7);
set_cell (reg, curs, CRED_CELL, 0, 8); gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 8);
curs_last = curs; curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -472,18 +453,18 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0); copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, ACTN_CELL, 1, 1); gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 1, 1);
set_cell (reg, curs, NOTES_CELL, 1, 2); gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_JOURNAL); CURSOR_SINGLE_JOURNAL);
set_cell (reg, curs, DATE_CELL, 0, 0); gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, TSHRS_CELL, 0, 5); gnc_table_layout_set_cell (reg->table->layout, curs, TSHRS_CELL, 0, 5);
set_cell (reg, curs, TDEBT_CELL, 0, 7); gnc_table_layout_set_cell (reg->table->layout, curs, TDEBT_CELL, 0, 7);
set_cell (reg, curs, TCRED_CELL, 0, 8); gnc_table_layout_set_cell (reg->table->layout, curs, TCRED_CELL, 0, 8);
curs_last = curs; curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -491,22 +472,23 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0); copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, NOTES_CELL, 1, 2); gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout, curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SPLIT); CURSOR_SPLIT);
set_cell (reg, curs, ACTN_CELL, 0, 1); gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 0, 1);
set_cell (reg, curs, MEMO_CELL, 0, 2); gnc_table_layout_set_cell (reg->table->layout, curs, MEMO_CELL, 0, 2);
set_cell (reg, curs, XFRM_CELL, 0, 3); gnc_table_layout_set_cell (reg->table->layout, curs, XFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4); gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
set_cell (reg, curs, SHRS_CELL, 0, 5); gnc_table_layout_set_cell (reg->table->layout, curs, SHRS_CELL, 0, 5);
set_cell (reg, curs, PRIC_CELL, 0, 6); gnc_table_layout_set_cell (reg->table->layout, curs, PRIC_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 7); gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 7);
set_cell (reg, curs, CRED_CELL, 0, 8); gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 8);
break; break;
} }
/* --------------------------------------------------------- */ /* --------------------------------------------------------- */
default: default:
PERR ("unknown register type %d \n", reg->type); PERR ("unknown register type %d \n", reg->type);
@ -514,8 +496,6 @@ configLayout (SplitRegister *reg)
} }
} }
/* ============================================== */
SplitRegister * SplitRegister *
gnc_register_new (SplitRegisterType type, gnc_register_new (SplitRegisterType type,
SplitRegisterStyle style, SplitRegisterStyle style,
@ -546,8 +526,6 @@ gnc_register_new (SplitRegisterType type,
return reg; return reg;
} }
/* ============================================== */
static void static void
mallocCursors (SplitRegister *reg) mallocCursors (SplitRegister *reg)
{ {
@ -595,6 +573,8 @@ mallocCursors (SplitRegister *reg)
cursor = gnc_cellblock_new (1, num_cols, CURSOR_SINGLE_LEDGER); cursor = gnc_cellblock_new (1, num_cols, CURSOR_SINGLE_LEDGER);
gnc_table_layout_add_cursor (reg->table->layout, cursor); gnc_table_layout_add_cursor (reg->table->layout, cursor);
gnc_table_layout_set_primary_cursor (reg->table->layout, cursor);
cursor = gnc_cellblock_new (2, num_cols, CURSOR_DOUBLE_LEDGER); cursor = gnc_cellblock_new (2, num_cols, CURSOR_DOUBLE_LEDGER);
gnc_table_layout_add_cursor (reg->table->layout, cursor); gnc_table_layout_add_cursor (reg->table->layout, cursor);
@ -609,8 +589,6 @@ mallocCursors (SplitRegister *reg)
gnc_table_layout_add_cursor (reg->table->layout, cursor); gnc_table_layout_add_cursor (reg->table->layout, cursor);
} }
/* ============================================== */
static void static void
xaccInitSplitRegister (SplitRegister *reg, xaccInitSplitRegister (SplitRegister *reg,
SplitRegisterType type, SplitRegisterType type,
@ -945,8 +923,6 @@ xaccInitSplitRegister (SplitRegister *reg,
} }
} }
/* ============================================== */
void void
xaccConfigSplitRegister (SplitRegister *reg, xaccConfigSplitRegister (SplitRegister *reg,
SplitRegisterType newtype, SplitRegisterType newtype,
@ -966,8 +942,6 @@ xaccConfigSplitRegister (SplitRegister *reg,
gnc_table_realize_gui (reg->table); gnc_table_realize_gui (reg->table);
} }
/* ============================================== */
void void
xaccDestroySplitRegister (SplitRegister *reg) xaccDestroySplitRegister (SplitRegister *reg)
{ {
@ -997,8 +971,6 @@ xaccDestroySplitRegister (SplitRegister *reg)
g_free (reg); g_free (reg);
} }
/* ============================================== */
static CursorClass static CursorClass
sr_cellblock_cursor_class (SplitRegister *reg, CellBlock *cursor) sr_cellblock_cursor_class (SplitRegister *reg, CellBlock *cursor)
{ {
@ -1008,8 +980,6 @@ sr_cellblock_cursor_class (SplitRegister *reg, CellBlock *cursor)
return xaccCursorNameToClass (cursor->cursor_name); return xaccCursorNameToClass (cursor->cursor_name);
} }
/* ============================================== */
CursorClass CursorClass
xaccSplitRegisterGetCurrentCursorClass (SplitRegister *reg) xaccSplitRegisterGetCurrentCursorClass (SplitRegister *reg)
{ {
@ -1025,8 +995,6 @@ xaccSplitRegisterGetCurrentCursorClass (SplitRegister *reg)
return sr_cellblock_cursor_class (reg, table->current_cursor); return sr_cellblock_cursor_class (reg, table->current_cursor);
} }
/* ============================================== */
CursorClass CursorClass
xaccSplitRegisterGetCursorClass (SplitRegister *reg, xaccSplitRegisterGetCursorClass (SplitRegister *reg,
VirtualCellLocation vcell_loc) VirtualCellLocation vcell_loc)
@ -1048,8 +1016,6 @@ xaccSplitRegisterGetCursorClass (SplitRegister *reg,
return sr_cellblock_cursor_class (reg, vcell->cellblock); return sr_cellblock_cursor_class (reg, vcell->cellblock);
} }
/* ============================================== */
CursorClass CursorClass
xaccCursorNameToClass (const char *cursor_name) xaccCursorNameToClass (const char *cursor_name)
{ {
@ -1067,56 +1033,3 @@ xaccCursorNameToClass (const char *cursor_name)
return CURSOR_CLASS_NONE; return CURSOR_CLASS_NONE;
} }
/* keep in sync with CellType enum */
static const char *cell_names[] =
{
"date",
"num",
"description",
"reconcile",
"balance",
"action",
"account",
"memo",
"credit",
"debit",
"price",
"shares",
"transfer",
"trans-credit",
"trans-debit",
"trans-shares",
"trans-balance",
"notes",
"credit formula",
"debit formula",
};
const char *
xaccSplitRegisterGetCellTypeName (CellType type)
{
if (type < 0)
return NULL;
if (type >= CELL_TYPE_COUNT)
return NULL;
return cell_names[type];
}
CellType
xaccSplitRegisterGetCellTypeFromName (const char *name)
{
CellType type;
if (name == NULL)
return NO_CELL;
for (type = 0; type < CELL_TYPE_COUNT; type++)
if (safe_strcmp (name, cell_names[type]) == 0)
return type;
return NO_CELL;
}
/* ============ END OF FILE ===================== */

62
src/register/register-core/splitreg.h
View File

@ -41,8 +41,8 @@
* Copyright (c) 1998, 1999, 2000 Linas Vepstas * Copyright (c) 1998, 1999, 2000 Linas Vepstas
*/ */
#ifndef XACC_SPLITREG_H #ifndef SPLITREG_H
#define XACC_SPLITREG_H #define SPLITREG_H
#include "Account.h" /* FIXME No Engine headers!!! */ #include "Account.h" /* FIXME No Engine headers!!! */
@ -73,33 +73,29 @@ typedef enum
NUM_REGISTER_TYPES NUM_REGISTER_TYPES
} SplitRegisterType; } SplitRegisterType;
/* These values are used to identify the cells in the register. */ /* Cell Names */
/* Keep these in sync with the cell_names array in splitreg.c. */ #define DATE_CELL "date"
typedef enum #define NUM_CELL "num"
{ #define DESC_CELL "description"
NO_CELL = -1, #define RECN_CELL "reconcile"
DATE_CELL = 0, #define BALN_CELL "balance"
NUM_CELL, #define ACTN_CELL "action"
DESC_CELL, #define XFRM_CELL "account"
RECN_CELL, #define MEMO_CELL "memo"
BALN_CELL, #define DEBT_CELL "debit"
ACTN_CELL, #define CRED_CELL "credit"
XFRM_CELL, #define PRIC_CELL "price"
MEMO_CELL, #define SHRS_CELL "shares"
CRED_CELL, #define MXFRM_CELL "transfer"
DEBT_CELL,
PRIC_CELL, /* T* cells are transaction summary cells */
SHRS_CELL, #define TDEBT_CELL "trans-debit"
MXFRM_CELL, /* MXFRM is the "mirrored" transfer-from account */ #define TCRED_CELL "trans-credit"
TCRED_CELL, /* T* cells are transaction summary cells */ #define TSHRS_CELL "trans-shares"
TDEBT_CELL, #define TBALN_CELL "trans-balance"
TSHRS_CELL, #define NOTES_CELL "notes"
TBALN_CELL, #define FDEBT_CELL "debit formula"
NOTES_CELL, #define FCRED_CELL "credit-formula"
FCRED_CELL, // formula credit, used by the template ledger
FDEBT_CELL, // formula debit, used by the template ledger
CELL_TYPE_COUNT,
} CellType;
/* /*
* enumerated display styles * enumerated display styles
@ -199,10 +195,4 @@ CursorClass xaccSplitRegisterGetCursorClass (SplitRegister *reg,
CursorClass xaccCursorNameToClass (const char *cursor_name); CursorClass xaccCursorNameToClass (const char *cursor_name);
const char * xaccSplitRegisterGetCellTypeName (CellType type); #endif
CellType xaccSplitRegisterGetCellTypeFromName (const char *name);
#endif /* XACC_SPLITREG_H */
/* ============ END OF FILE ===================== */

73
src/register/register-core/table-allgui.c
View File

@ -164,24 +164,24 @@ gnc_table_restore_current_cursor (Table *table,
table->current_cursor, buffer); table->current_cursor, buffer);
} }
int const char *
gnc_table_get_current_cell_type (Table *table) gnc_table_get_current_cell_name (Table *table)
{ {
if (table == NULL) if (table == NULL)
return -1; return NULL;
return gnc_table_get_cell_type (table, table->current_cursor_loc); return gnc_table_get_cell_name (table, table->current_cursor_loc);
} }
gboolean gboolean
gnc_table_get_current_cell_location (Table *table, gnc_table_get_current_cell_location (Table *table,
int cell_type, const char *cell_name,
VirtualLocation *virt_loc) VirtualLocation *virt_loc)
{ {
if (table == NULL) if (table == NULL)
return FALSE; return FALSE;
return gnc_table_get_cell_location (table, cell_type, return gnc_table_get_cell_location (table, cell_name,
table->current_cursor_loc.vcell_loc, table->current_cursor_loc.vcell_loc,
virt_loc); virt_loc);
} }
@ -229,12 +229,12 @@ gnc_table_get_entry_internal (Table *table, VirtualLocation virt_loc,
gboolean *conditionally_changed) gboolean *conditionally_changed)
{ {
TableGetEntryHandler entry_handler; TableGetEntryHandler entry_handler;
const char *cell_name;
const char *entry; const char *entry;
int cell_type;
cell_type = gnc_table_get_cell_type (table, virt_loc); cell_name = gnc_table_get_cell_name (table, virt_loc);
entry_handler = gnc_table_model_get_entry_handler (table->model, cell_type); entry_handler = gnc_table_model_get_entry_handler (table->model, cell_name);
if (!entry_handler) return ""; if (!entry_handler) return "";
entry = entry_handler (virt_loc, FALSE, entry = entry_handler (virt_loc, FALSE,
@ -254,7 +254,7 @@ gnc_table_get_entry (Table *table, VirtualLocation virt_loc)
BasicCell *cell; BasicCell *cell;
cell = gnc_table_get_cell (table, virt_loc); cell = gnc_table_get_cell (table, virt_loc);
if (!cell || cell->cell_type < 0) if (!cell || !cell->cell_name)
return ""; return "";
if (virt_cell_loc_equal (table->current_cursor_loc.vcell_loc, if (virt_cell_loc_equal (table->current_cursor_loc.vcell_loc,
@ -269,7 +269,7 @@ gnc_table_get_entry (Table *table, VirtualLocation virt_loc)
} }
entry_handler = gnc_table_model_get_entry_handler (table->model, entry_handler = gnc_table_model_get_entry_handler (table->model,
cell->cell_type); cell->cell_name);
if (!entry_handler) return ""; if (!entry_handler) return "";
entry = entry_handler (virt_loc, TRUE, NULL, entry = entry_handler (virt_loc, TRUE, NULL,
@ -284,15 +284,15 @@ CellIOFlags
gnc_table_get_io_flags (Table *table, VirtualLocation virt_loc) gnc_table_get_io_flags (Table *table, VirtualLocation virt_loc)
{ {
TableGetCellIOFlagsHandler io_flags_handler; TableGetCellIOFlagsHandler io_flags_handler;
int cell_type; const char *cell_name;
if (!table || !table->model) if (!table || !table->model)
return XACC_CELL_ALLOW_NONE; return XACC_CELL_ALLOW_NONE;
cell_type = gnc_table_get_cell_type (table, virt_loc); cell_name = gnc_table_get_cell_name (table, virt_loc);
io_flags_handler = gnc_table_model_get_io_flags_handler (table->model, io_flags_handler = gnc_table_model_get_io_flags_handler (table->model,
cell_type); cell_name);
if (!io_flags_handler) if (!io_flags_handler)
return XACC_CELL_ALLOW_NONE; return XACC_CELL_ALLOW_NONE;
@ -303,15 +303,15 @@ const char *
gnc_table_get_label (Table *table, VirtualLocation virt_loc) gnc_table_get_label (Table *table, VirtualLocation virt_loc)
{ {
TableGetLabelHandler label_handler; TableGetLabelHandler label_handler;
const char *cell_name;
const char *label; const char *label;
int cell_type;
if (!table || !table->model) if (!table || !table->model)
return ""; return "";
cell_type = gnc_table_get_cell_type (table, virt_loc); cell_name = gnc_table_get_cell_name (table, virt_loc);
label_handler = gnc_table_model_get_label_handler (table->model, cell_type); label_handler = gnc_table_model_get_label_handler (table->model, cell_name);
if (!label_handler) if (!label_handler)
return ""; return "";
@ -326,15 +326,15 @@ guint32
gnc_table_get_fg_color (Table *table, VirtualLocation virt_loc) gnc_table_get_fg_color (Table *table, VirtualLocation virt_loc)
{ {
TableGetFGColorHandler fg_color_handler; TableGetFGColorHandler fg_color_handler;
int cell_type; const char *cell_name;
if (!table || !table->model) if (!table || !table->model)
return 0x0; /* black */ return 0x0; /* black */
cell_type = gnc_table_get_cell_type (table, virt_loc); cell_name = gnc_table_get_cell_name (table, virt_loc);
fg_color_handler = gnc_table_model_get_fg_color_handler (table->model, fg_color_handler = gnc_table_model_get_fg_color_handler (table->model,
cell_type); cell_name);
if (!fg_color_handler) if (!fg_color_handler)
return 0x0; return 0x0;
@ -346,7 +346,7 @@ gnc_table_get_bg_color (Table *table, VirtualLocation virt_loc,
gboolean *hatching) gboolean *hatching)
{ {
TableGetBGColorHandler bg_color_handler; TableGetBGColorHandler bg_color_handler;
int cell_type; const char *cell_name;
if (hatching) if (hatching)
*hatching = FALSE; *hatching = FALSE;
@ -354,10 +354,10 @@ gnc_table_get_bg_color (Table *table, VirtualLocation virt_loc,
if (!table || !table->model) if (!table || !table->model)
return 0xffffff; /* white */ return 0xffffff; /* white */
cell_type = gnc_table_get_cell_type (table, virt_loc); cell_name = gnc_table_get_cell_name (table, virt_loc);
bg_color_handler = gnc_table_model_get_bg_color_handler (table->model, bg_color_handler = gnc_table_model_get_bg_color_handler (table->model,
cell_type); cell_name);
if (!bg_color_handler) if (!bg_color_handler)
return 0x0; return 0x0;
@ -370,15 +370,15 @@ gnc_table_get_borders (Table *table, VirtualLocation virt_loc,
PhysicalCellBorders *borders) PhysicalCellBorders *borders)
{ {
TableGetCellBorderHandler cell_border_handler; TableGetCellBorderHandler cell_border_handler;
int cell_type; const char *cell_name;
if (!table || !table->model) if (!table || !table->model)
return; return;
cell_type = gnc_table_get_cell_type (table, virt_loc); cell_name = gnc_table_get_cell_name (table, virt_loc);
cell_border_handler = gnc_table_model_get_cell_border_handler (table->model, cell_border_handler = gnc_table_model_get_cell_border_handler (table->model,
cell_type); cell_name);
if (!cell_border_handler) if (!cell_border_handler)
return; return;
@ -444,21 +444,21 @@ gnc_table_get_cell (Table *table, VirtualLocation virt_loc)
virt_loc.phys_col_offset); virt_loc.phys_col_offset);
} }
int const char *
gnc_table_get_cell_type (Table *table, VirtualLocation virt_loc) gnc_table_get_cell_name (Table *table, VirtualLocation virt_loc)
{ {
BasicCell *cell; BasicCell *cell;
cell = gnc_table_get_cell (table, virt_loc); cell = gnc_table_get_cell (table, virt_loc);
if (cell == NULL) if (cell == NULL)
return -1; return NULL;
return cell->cell_type; return cell->cell_name;
} }
gboolean gboolean
gnc_table_get_cell_location (Table *table, gnc_table_get_cell_location (Table *table,
int cell_type, const char *cell_name,
VirtualCellLocation vcell_loc, VirtualCellLocation vcell_loc,
VirtualLocation *virt_loc) VirtualLocation *virt_loc)
{ {
@ -479,15 +479,12 @@ gnc_table_get_cell_location (Table *table,
for (cell_col = 0; cell_col < cellblock->num_cols; cell_col++) for (cell_col = 0; cell_col < cellblock->num_cols; cell_col++)
{ {
BasicCell *cell; BasicCell *cell;
int ctype;
cell = gnc_cellblock_get_cell (cellblock, cell_row, cell_col); cell = gnc_cellblock_get_cell (cellblock, cell_row, cell_col);
if (!cell) if (!cell)
return FALSE; return FALSE;
ctype = cell->cell_type; if (gnc_basic_cell_has_name (cell, cell_name))
if (ctype == cell_type)
{ {
if (virt_loc != NULL) if (virt_loc != NULL)
{ {
@ -1082,15 +1079,15 @@ gboolean
gnc_table_confirm_change (Table *table, VirtualLocation virt_loc) gnc_table_confirm_change (Table *table, VirtualLocation virt_loc)
{ {
TableConfirmHandler confirm_handler; TableConfirmHandler confirm_handler;
int cell_type; const char *cell_name;
if (!table || !table->model) if (!table || !table->model)
return TRUE; return TRUE;
cell_type = gnc_table_get_cell_type (table, virt_loc); cell_name = gnc_table_get_cell_name (table, virt_loc);
confirm_handler = gnc_table_model_get_confirm_handler (table->model, confirm_handler = gnc_table_model_get_confirm_handler (table->model,
cell_type); cell_name);
if (!confirm_handler) if (!confirm_handler)
return TRUE; return TRUE;

8
src/register/register-core/table-allgui.h
View File

@ -159,10 +159,10 @@ void gnc_table_save_current_cursor (Table *table, CursorBuffer *buffer);
void gnc_table_restore_current_cursor (Table *table, void gnc_table_restore_current_cursor (Table *table,
CursorBuffer *buffer); CursorBuffer *buffer);
int gnc_table_get_current_cell_type (Table *table); const char * gnc_table_get_current_cell_name (Table *table);
gboolean gnc_table_get_current_cell_location (Table *table, gboolean gnc_table_get_current_cell_location (Table *table,
int cell_type, const char *cell_name,
VirtualLocation *virt_loc); VirtualLocation *virt_loc);
@ -203,11 +203,11 @@ char * gnc_table_get_help (Table *table);
BasicCell * gnc_table_get_cell (Table *table, VirtualLocation virt_loc); BasicCell * gnc_table_get_cell (Table *table, VirtualLocation virt_loc);
int gnc_table_get_cell_type (Table *table, const char * gnc_table_get_cell_name (Table *table,
VirtualLocation virt_loc); VirtualLocation virt_loc);
gboolean gnc_table_get_cell_location (Table *table, gboolean gnc_table_get_cell_location (Table *table,
int cell_type, const char * cell_name,
VirtualCellLocation vcell_loc, VirtualCellLocation vcell_loc,
VirtualLocation *virt_loc); VirtualLocation *virt_loc);

69
src/register/register-core/table-layout.c
View File

@ -36,12 +36,14 @@ struct table_layout_struct
{ {
GList *cells; /* The cells in the table */ GList *cells; /* The cells in the table */
GList *cursors; /* The cursors in the table */ GList *cursors; /* The cursors in the table */
CellBlock *primary_cursor;
}; };
typedef struct _CellBuffer CellBuffer; typedef struct _CellBuffer CellBuffer;
struct _CellBuffer struct _CellBuffer
{ {
int cell_type; char * cell_name;
char * value; char * value;
guint32 changed; guint32 changed;
guint32 conditionally_changed; guint32 conditionally_changed;
@ -105,7 +107,7 @@ gnc_table_layout_add_cell (TableLayout *layout,
{ {
BasicCell *list_cell = node->data; BasicCell *list_cell = node->data;
if (list_cell->cell_type == cell->cell_type) if (gnc_basic_cell_has_name (list_cell, cell->cell_name))
{ {
if (list_cell == cell) if (list_cell == cell)
return; return;
@ -122,7 +124,7 @@ gnc_table_layout_add_cell (TableLayout *layout,
} }
BasicCell * BasicCell *
gnc_table_layout_get_cell (TableLayout *layout, int cell_type) gnc_table_layout_get_cell (TableLayout *layout, const char *cell_name)
{ {
GList *node; GList *node;
@ -132,7 +134,7 @@ gnc_table_layout_get_cell (TableLayout *layout, int cell_type)
{ {
BasicCell *list_cell = node->data; BasicCell *list_cell = node->data;
if (list_cell->cell_type == cell_type) if (gnc_basic_cell_has_name (list_cell, cell_name))
return list_cell; return list_cell;
} }
@ -140,13 +142,13 @@ gnc_table_layout_get_cell (TableLayout *layout, int cell_type)
} }
const char * const char *
gnc_table_layout_get_cell_value (TableLayout *layout, int cell_type) gnc_table_layout_get_cell_value (TableLayout *layout, const char * cell_name)
{ {
BasicCell *cell; BasicCell *cell;
g_return_val_if_fail (layout != NULL, NULL); g_return_val_if_fail (layout != NULL, NULL);
cell = gnc_table_layout_get_cell (layout, cell_type); cell = gnc_table_layout_get_cell (layout, cell_name);
if (!cell) return NULL; if (!cell) return NULL;
return gnc_basic_cell_get_value (cell); return gnc_basic_cell_get_value (cell);
@ -154,14 +156,14 @@ gnc_table_layout_get_cell_value (TableLayout *layout, int cell_type)
gboolean gboolean
gnc_table_layout_get_cell_changed (TableLayout *layout, gnc_table_layout_get_cell_changed (TableLayout *layout,
int cell_type, const char *cell_name,
gboolean include_conditional) gboolean include_conditional)
{ {
BasicCell *cell; BasicCell *cell;
g_return_val_if_fail (layout != NULL, FALSE); g_return_val_if_fail (layout != NULL, FALSE);
cell = gnc_table_layout_get_cell (layout, cell_type); cell = gnc_table_layout_get_cell (layout, cell_name);
if (!cell) return FALSE; if (!cell) return FALSE;
if (!include_conditional) if (!include_conditional)
@ -236,6 +238,50 @@ gnc_table_layout_get_cursors (TableLayout *layout)
return layout->cursors; return layout->cursors;
} }
void
gnc_table_layout_set_primary_cursor (TableLayout *layout,
CellBlock *cursor)
{
g_return_if_fail (layout != NULL);
layout->primary_cursor = cursor;
}
void
gnc_table_layout_set_cell (TableLayout *layout,
CellBlock *cursor,
const char *cell_name,
int row, int col)
{
CellBlock *header;
BasicCell *cell;
g_return_if_fail (layout != NULL);
g_return_if_fail (layout->primary_cursor != NULL);
g_return_if_fail (cursor != NULL);
g_return_if_fail (cell_name != NULL);
g_return_if_fail (row >= 0);
g_return_if_fail (col >= 0);
g_return_if_fail (row < cursor->num_rows);
g_return_if_fail (col < cursor->num_cols);
header = gnc_table_layout_get_cursor (layout, CURSOR_HEADER);
cell = gnc_table_layout_get_cell (layout, cell_name);
g_return_if_fail (header != NULL);
g_return_if_fail (cell != NULL);
cursor->start_col = MIN (cursor->start_col, col);
cursor->stop_col = MAX (cursor->stop_col, col);
header->start_col = MIN (header->start_col, col);
header->stop_col = MAX (header->stop_col, col);
gnc_cellblock_set_cell (cursor, row, col, cell);
if (cursor == layout->primary_cursor)
gnc_cellblock_set_cell (header, row, col, cell);
}
CursorBuffer * CursorBuffer *
gnc_cursor_buffer_new (void) gnc_cursor_buffer_new (void)
{ {
@ -252,6 +298,9 @@ destroy_cell_buffer (CellBuffer *cb)
if (cb == NULL) if (cb == NULL)
return; return;
g_free (cb->cell_name);
cb->cell_name = NULL;
g_free (cb->value); g_free (cb->value);
cb->value = NULL; cb->value = NULL;
@ -296,6 +345,7 @@ save_cell (BasicCell *bcell)
cb = g_new0 (CellBuffer, 1); cb = g_new0 (CellBuffer, 1);
cb->cell_name = g_strdup (bcell->cell_name);
cb->value = g_strdup (bcell->value); cb->value = g_strdup (bcell->value);
cb->changed = bcell->changed; cb->changed = bcell->changed;
cb->conditionally_changed = bcell->conditionally_changed; cb->conditionally_changed = bcell->conditionally_changed;
@ -325,7 +375,6 @@ gnc_table_layout_save_cursor (TableLayout *layout,
continue; continue;
cb = save_cell (list_cell); cb = save_cell (list_cell);
cb->cell_type = list_cell->cell_type;
buffer->cell_buffers = g_list_prepend (buffer->cell_buffers, cb); buffer->cell_buffers = g_list_prepend (buffer->cell_buffers, cb);
} }
@ -377,7 +426,7 @@ gnc_table_layout_restore_cursor (TableLayout *layout,
CellBuffer *cb = node->data; CellBuffer *cb = node->data;
BasicCell *cell; BasicCell *cell;
cell = gnc_table_layout_get_cell (layout, cb->cell_type); cell = gnc_table_layout_get_cell (layout, cb->cell_name);
restore_cell (cell, cb, cursor); restore_cell (cell, cb, cursor);
} }

15
src/register/register-core/table-layout.h
View File

@ -44,11 +44,12 @@ void gnc_table_layout_destroy (TableLayout *layout);
void gnc_table_layout_add_cell (TableLayout *layout, BasicCell *cell); void gnc_table_layout_add_cell (TableLayout *layout, BasicCell *cell);
BasicCell * gnc_table_layout_get_cell (TableLayout *layout, int cell_type); BasicCell * gnc_table_layout_get_cell (TableLayout *layout,
const char *cell_name);
const char * gnc_table_layout_get_cell_value (TableLayout *layout, const char * gnc_table_layout_get_cell_value (TableLayout *layout,
int cell_type); const char *cell_name);
gboolean gnc_table_layout_get_cell_changed (TableLayout *layout, gboolean gnc_table_layout_get_cell_changed (TableLayout *layout,
int cell_type, const char *cell_name,
gboolean include_conditional); gboolean include_conditional);
GList * gnc_table_layout_get_cells (TableLayout *layout); GList * gnc_table_layout_get_cells (TableLayout *layout);
@ -61,6 +62,14 @@ CellBlock * gnc_table_layout_get_cursor (TableLayout *layout,
GList * gnc_table_layout_get_cursors (TableLayout *layout); GList * gnc_table_layout_get_cursors (TableLayout *layout);
void gnc_table_layout_set_primary_cursor (TableLayout *layout,
CellBlock *cursor);
void gnc_table_layout_set_cell (TableLayout *layout,
CellBlock *cursor,
const char *cell_name,
int row, int col);
CursorBuffer * gnc_cursor_buffer_new (void); CursorBuffer * gnc_cursor_buffer_new (void);
void gnc_cursor_buffer_destroy (CursorBuffer *buffer); void gnc_cursor_buffer_destroy (CursorBuffer *buffer);

110
src/register/register-core/table-model.c
View File

@ -29,11 +29,11 @@
#include "table-model.h" #include "table-model.h"
#define DEFAULT_HANDLER (-1) #define DEFAULT_HANDLER ""
typedef struct typedef struct
{ {
int cell_type; char *cell_name;
gpointer handler; gpointer handler;
} HandlerNode; } HandlerNode;
@ -41,7 +41,7 @@ typedef struct
static GHashTable * static GHashTable *
gnc_table_model_handler_hash_new (void) gnc_table_model_handler_hash_new (void)
{ {
return g_hash_table_new (g_int_hash, g_int_equal); return g_hash_table_new (g_str_hash, g_str_equal);
} }
static void static void
@ -49,6 +49,9 @@ hash_destroy_helper (gpointer key, gpointer value, gpointer user_data)
{ {
HandlerNode *node = value; HandlerNode *node = value;
g_free (node->cell_name);
node->cell_name = NULL;
g_free (node); g_free (node);
} }
@ -62,50 +65,57 @@ gnc_table_model_handler_hash_destroy (GHashTable *hash)
} }
static void static void
gnc_table_model_handler_hash_remove (GHashTable *hash, int cell_type) gnc_table_model_handler_hash_remove (GHashTable *hash, const char *cell_name)
{ {
HandlerNode *node; HandlerNode *node;
if (!hash) return; if (!hash) return;
node = g_hash_table_lookup (hash, &cell_type); node = g_hash_table_lookup (hash, cell_name);
if (!node) return; if (!node) return;
g_free (node->cell_name);
node->cell_name = NULL;
g_free (node); g_free (node);
} }
static void static void
gnc_table_model_handler_hash_insert (GHashTable *hash, int cell_type, gnc_table_model_handler_hash_insert (GHashTable *hash,
const char *cell_name,
gpointer handler) gpointer handler)
{ {
HandlerNode *node; HandlerNode *node;
g_return_if_fail (hash != NULL); g_return_if_fail (hash != NULL);
g_return_if_fail ((cell_type >= 0) || (cell_type == DEFAULT_HANDLER)); g_return_if_fail (cell_name != NULL);
gnc_table_model_handler_hash_remove (hash, cell_type); gnc_table_model_handler_hash_remove (hash, cell_name);
if (!handler) return; if (!handler) return;
node = g_new0 (HandlerNode, 1); node = g_new0 (HandlerNode, 1);
node->cell_type = cell_type; node->cell_name = g_strdup (cell_name);
node->handler = handler; node->handler = handler;
g_hash_table_insert (hash, &node->cell_type, node); g_hash_table_insert (hash, node->cell_name, node);
} }
static gpointer static gpointer
gnc_table_model_handler_hash_lookup (GHashTable *hash, int cell_type) gnc_table_model_handler_hash_lookup (GHashTable *hash, const char *cell_name)
{ {
HandlerNode *node; HandlerNode *node;
if (!hash) return NULL; if (!hash) return NULL;
node = g_hash_table_lookup (hash, &cell_type); if (cell_name)
if (node) return node->handler; {
node = g_hash_table_lookup (hash, cell_name);
if (node) return node->handler;
}
cell_type = DEFAULT_HANDLER; cell_name = DEFAULT_HANDLER;
node = g_hash_table_lookup (hash, &cell_type); node = g_hash_table_lookup (hash, cell_name);
if (node) return node->handler; if (node) return node->handler;
return NULL; return NULL;
@ -163,13 +173,13 @@ gnc_table_model_destroy (TableModel *model)
void void
gnc_table_model_set_entry_handler (TableModel *model, gnc_table_model_set_entry_handler (TableModel *model,
TableGetEntryHandler entry_handler, TableGetEntryHandler entry_handler,
int cell_type) const char * cell_name)
{ {
g_return_if_fail (model != NULL); g_return_if_fail (model != NULL);
g_return_if_fail (cell_type >= 0); g_return_if_fail (cell_name != NULL);
gnc_table_model_handler_hash_insert (model->entry_handlers, gnc_table_model_handler_hash_insert (model->entry_handlers,
cell_type, cell_name,
entry_handler); entry_handler);
} }
@ -185,24 +195,24 @@ gnc_table_model_set_default_entry_handler
} }
TableGetEntryHandler TableGetEntryHandler
gnc_table_model_get_entry_handler (TableModel *model, int cell_type) gnc_table_model_get_entry_handler (TableModel *model, const char * cell_name)
{ {
g_return_val_if_fail (model != NULL, NULL); g_return_val_if_fail (model != NULL, NULL);
return gnc_table_model_handler_hash_lookup (model->entry_handlers, return gnc_table_model_handler_hash_lookup (model->entry_handlers,
cell_type); cell_name);
} }
void void
gnc_table_model_set_label_handler (TableModel *model, gnc_table_model_set_label_handler (TableModel *model,
TableGetLabelHandler label_handler, TableGetLabelHandler label_handler,
int cell_type) const char * cell_name)
{ {
g_return_if_fail (model != NULL); g_return_if_fail (model != NULL);
g_return_if_fail (cell_type >= 0); g_return_if_fail (cell_name != NULL);
gnc_table_model_handler_hash_insert (model->label_handlers, gnc_table_model_handler_hash_insert (model->label_handlers,
cell_type, cell_name,
label_handler); label_handler);
} }
@ -218,25 +228,25 @@ gnc_table_model_set_default_label_handler
} }
TableGetLabelHandler TableGetLabelHandler
gnc_table_model_get_label_handler (TableModel *model, int cell_type) gnc_table_model_get_label_handler (TableModel *model, const char * cell_name)
{ {
g_return_val_if_fail (model != NULL, NULL); g_return_val_if_fail (model != NULL, NULL);
return gnc_table_model_handler_hash_lookup (model->label_handlers, return gnc_table_model_handler_hash_lookup (model->label_handlers,
cell_type); cell_name);
} }
void void
gnc_table_model_set_io_flags_handler gnc_table_model_set_io_flags_handler
(TableModel *model, (TableModel *model,
TableGetCellIOFlagsHandler io_flags_handler, TableGetCellIOFlagsHandler io_flags_handler,
int cell_type) const char * cell_name)
{ {
g_return_if_fail (model != NULL); g_return_if_fail (model != NULL);
g_return_if_fail (cell_type >= 0); g_return_if_fail (cell_name != NULL);
gnc_table_model_handler_hash_insert (model->io_flags_handlers, gnc_table_model_handler_hash_insert (model->io_flags_handlers,
cell_type, cell_name,
io_flags_handler); io_flags_handler);
} }
@ -254,25 +264,25 @@ gnc_table_model_set_default_io_flags_handler
TableGetCellIOFlagsHandler TableGetCellIOFlagsHandler
gnc_table_model_get_io_flags_handler (TableModel *model, gnc_table_model_get_io_flags_handler (TableModel *model,
int cell_type) const char * cell_name)
{ {
g_return_val_if_fail (model != NULL, NULL); g_return_val_if_fail (model != NULL, NULL);
return gnc_table_model_handler_hash_lookup (model->io_flags_handlers, return gnc_table_model_handler_hash_lookup (model->io_flags_handlers,
cell_type); cell_name);
} }
void void
gnc_table_model_set_fg_color_handler gnc_table_model_set_fg_color_handler
(TableModel *model, (TableModel *model,
TableGetFGColorHandler fg_color_handler, TableGetFGColorHandler fg_color_handler,
int cell_type) const char * cell_name)
{ {
g_return_if_fail (model != NULL); g_return_if_fail (model != NULL);
g_return_if_fail (cell_type >= 0); g_return_if_fail (cell_name != NULL);
gnc_table_model_handler_hash_insert (model->fg_color_handlers, gnc_table_model_handler_hash_insert (model->fg_color_handlers,
cell_type, cell_name,
fg_color_handler); fg_color_handler);
} }
@ -290,25 +300,25 @@ gnc_table_model_set_default_fg_color_handler
TableGetFGColorHandler TableGetFGColorHandler
gnc_table_model_get_fg_color_handler (TableModel *model, gnc_table_model_get_fg_color_handler (TableModel *model,
int cell_type) const char * cell_name)
{ {
g_return_val_if_fail (model != NULL, NULL); g_return_val_if_fail (model != NULL, NULL);
return gnc_table_model_handler_hash_lookup (model->fg_color_handlers, return gnc_table_model_handler_hash_lookup (model->fg_color_handlers,
cell_type); cell_name);
} }
void void
gnc_table_model_set_bg_color_handler gnc_table_model_set_bg_color_handler
(TableModel *model, (TableModel *model,
TableGetBGColorHandler bg_color_handler, TableGetBGColorHandler bg_color_handler,
int cell_type) const char * cell_name)
{ {
g_return_if_fail (model != NULL); g_return_if_fail (model != NULL);
g_return_if_fail (cell_type >= 0); g_return_if_fail (cell_name != NULL);
gnc_table_model_handler_hash_insert (model->bg_color_handlers, gnc_table_model_handler_hash_insert (model->bg_color_handlers,
cell_type, cell_name,
bg_color_handler); bg_color_handler);
} }
@ -326,25 +336,25 @@ gnc_table_model_set_default_bg_color_handler
TableGetBGColorHandler TableGetBGColorHandler
gnc_table_model_get_bg_color_handler (TableModel *model, gnc_table_model_get_bg_color_handler (TableModel *model,
int cell_type) const char * cell_name)
{ {
g_return_val_if_fail (model != NULL, NULL); g_return_val_if_fail (model != NULL, NULL);
return gnc_table_model_handler_hash_lookup (model->bg_color_handlers, return gnc_table_model_handler_hash_lookup (model->bg_color_handlers,
cell_type); cell_name);
} }
void void
gnc_table_model_set_cell_border_handler gnc_table_model_set_cell_border_handler
(TableModel *model, (TableModel *model,
TableGetCellBorderHandler cell_border_handler, TableGetCellBorderHandler cell_border_handler,
int cell_type) const char * cell_name)
{ {
g_return_if_fail (model != NULL); g_return_if_fail (model != NULL);
g_return_if_fail (cell_type >= 0); g_return_if_fail (cell_name != NULL);
gnc_table_model_handler_hash_insert (model->cell_border_handlers, gnc_table_model_handler_hash_insert (model->cell_border_handlers,
cell_type, cell_name,
cell_border_handler); cell_border_handler);
} }
@ -362,25 +372,25 @@ gnc_table_model_set_default_cell_border_handler
TableGetCellBorderHandler TableGetCellBorderHandler
gnc_table_model_get_cell_border_handler (TableModel *model, gnc_table_model_get_cell_border_handler (TableModel *model,
int cell_type) const char * cell_name)
{ {
g_return_val_if_fail (model != NULL, NULL); g_return_val_if_fail (model != NULL, NULL);
return gnc_table_model_handler_hash_lookup (model->cell_border_handlers, return gnc_table_model_handler_hash_lookup (model->cell_border_handlers,
cell_type); cell_name);
} }
void void
gnc_table_model_set_confirm_handler gnc_table_model_set_confirm_handler
(TableModel *model, (TableModel *model,
TableConfirmHandler confirm_handler, TableConfirmHandler confirm_handler,
int cell_type) const char * cell_name)
{ {
g_return_if_fail (model != NULL); g_return_if_fail (model != NULL);
g_return_if_fail (cell_type >= 0); g_return_if_fail (cell_name != NULL);
gnc_table_model_handler_hash_insert (model->confirm_handlers, gnc_table_model_handler_hash_insert (model->confirm_handlers,
cell_type, cell_name,
confirm_handler); confirm_handler);
} }
@ -398,10 +408,10 @@ gnc_table_model_set_default_confirm_handler
TableConfirmHandler TableConfirmHandler
gnc_table_model_get_confirm_handler (TableModel *model, gnc_table_model_get_confirm_handler (TableModel *model,
int cell_type) const char * cell_name)
{ {
g_return_val_if_fail (model != NULL, NULL); g_return_val_if_fail (model != NULL, NULL);
return gnc_table_model_handler_hash_lookup (model->confirm_handlers, return gnc_table_model_handler_hash_lookup (model->confirm_handlers,
cell_type); cell_name);
} }

28
src/register/register-core/table-model.h
View File

@ -118,78 +118,78 @@ void gnc_table_model_destroy (TableModel *model);
void gnc_table_model_set_entry_handler void gnc_table_model_set_entry_handler
(TableModel *model, (TableModel *model,
TableGetEntryHandler entry_handler, TableGetEntryHandler entry_handler,
int cell_type); const char * cell_name);
void gnc_table_model_set_default_entry_handler void gnc_table_model_set_default_entry_handler
(TableModel *model, (TableModel *model,
TableGetEntryHandler entry_handler); TableGetEntryHandler entry_handler);
TableGetEntryHandler gnc_table_model_get_entry_handler TableGetEntryHandler gnc_table_model_get_entry_handler
(TableModel *model, (TableModel *model,
int cell_type); const char * cell_name);
void gnc_table_model_set_label_handler void gnc_table_model_set_label_handler
(TableModel *model, (TableModel *model,
TableGetLabelHandler label_handler, TableGetLabelHandler label_handler,
int cell_type); const char * cell_name);
void gnc_table_model_set_default_label_handler void gnc_table_model_set_default_label_handler
(TableModel *model, (TableModel *model,
TableGetLabelHandler label_handler); TableGetLabelHandler label_handler);
TableGetLabelHandler gnc_table_model_get_label_handler TableGetLabelHandler gnc_table_model_get_label_handler
(TableModel *model, (TableModel *model,
int cell_type); const char * cell_name);
void gnc_table_model_set_io_flags_handler void gnc_table_model_set_io_flags_handler
(TableModel *model, (TableModel *model,
TableGetCellIOFlagsHandler io_flags_handler, TableGetCellIOFlagsHandler io_flags_handler,
int cell_type); const char * cell_name);
void gnc_table_model_set_default_io_flags_handler void gnc_table_model_set_default_io_flags_handler
(TableModel *model, (TableModel *model,
TableGetCellIOFlagsHandler io_flags_handler); TableGetCellIOFlagsHandler io_flags_handler);
TableGetCellIOFlagsHandler gnc_table_model_get_io_flags_handler TableGetCellIOFlagsHandler gnc_table_model_get_io_flags_handler
(TableModel *model, (TableModel *model,
int cell_type); const char * cell_name);
void gnc_table_model_set_fg_color_handler void gnc_table_model_set_fg_color_handler
(TableModel *model, (TableModel *model,
TableGetFGColorHandler io_flags_handler, TableGetFGColorHandler io_flags_handler,
int cell_type); const char * cell_name);
void gnc_table_model_set_default_fg_color_handler void gnc_table_model_set_default_fg_color_handler
(TableModel *model, (TableModel *model,
TableGetFGColorHandler io_flags_handler); TableGetFGColorHandler io_flags_handler);
TableGetFGColorHandler gnc_table_model_get_fg_color_handler TableGetFGColorHandler gnc_table_model_get_fg_color_handler
(TableModel *model, (TableModel *model,
int cell_type); const char * cell_name);
void gnc_table_model_set_bg_color_handler void gnc_table_model_set_bg_color_handler
(TableModel *model, (TableModel *model,
TableGetBGColorHandler io_flags_handler, TableGetBGColorHandler io_flags_handler,
int cell_type); const char * cell_name);
void gnc_table_model_set_default_bg_color_handler void gnc_table_model_set_default_bg_color_handler
(TableModel *model, (TableModel *model,
TableGetBGColorHandler io_flags_handler); TableGetBGColorHandler io_flags_handler);
TableGetBGColorHandler gnc_table_model_get_bg_color_handler TableGetBGColorHandler gnc_table_model_get_bg_color_handler
(TableModel *model, (TableModel *model,
int cell_type); const char * cell_name);
void gnc_table_model_set_cell_border_handler void gnc_table_model_set_cell_border_handler
(TableModel *model, (TableModel *model,
TableGetCellBorderHandler io_flags_handler, TableGetCellBorderHandler io_flags_handler,
int cell_type); const char * cell_name);
void gnc_table_model_set_default_cell_border_handler void gnc_table_model_set_default_cell_border_handler
(TableModel *model, (TableModel *model,
TableGetCellBorderHandler io_flags_handler); TableGetCellBorderHandler io_flags_handler);
TableGetCellBorderHandler gnc_table_model_get_cell_border_handler TableGetCellBorderHandler gnc_table_model_get_cell_border_handler
(TableModel *model, (TableModel *model,
int cell_type); const char * cell_name);
void gnc_table_model_set_confirm_handler void gnc_table_model_set_confirm_handler
(TableModel *model, (TableModel *model,
TableConfirmHandler io_flags_handler, TableConfirmHandler io_flags_handler,
int cell_type); const char * cell_name);
void gnc_table_model_set_default_confirm_handler void gnc_table_model_set_default_confirm_handler
(TableModel *model, (TableModel *model,
TableConfirmHandler io_flags_handler); TableConfirmHandler io_flags_handler);
TableConfirmHandler gnc_table_model_get_confirm_handler TableConfirmHandler gnc_table_model_get_confirm_handler
(TableModel *model, (TableModel *model,
int cell_type); const char * cell_name);
#endif #endif

4
src/register/register-gnome/gnucash-cursor.c
View File

@ -78,7 +78,7 @@ gnucash_cursor_get_pixel_coords (GnucashCursor *cursor,
BasicCell *cell; BasicCell *cell;
cell = gnc_cellblock_get_cell (vcell->cellblock, 0, col); cell = gnc_cellblock_get_cell (vcell->cellblock, 0, col);
if (cell && cell->cell_type >= 0) if (cell && cell->cell_name)
break; break;
} }
@ -95,7 +95,7 @@ gnucash_cursor_get_pixel_coords (GnucashCursor *cursor,
BasicCell *cell; BasicCell *cell;
cell = gnc_cellblock_get_cell (vcell->cellblock, 0, col); cell = gnc_cellblock_get_cell (vcell->cellblock, 0, col);
if (cell && cell->cell_type >= 0) if (cell && cell->cell_name)
break; break;
} }

2
src/register/register-gnome/gnucash-header.c
View File

@ -145,7 +145,7 @@ gnucash_header_draw (GnomeCanvasItem *item, GdkDrawable *drawable,
w = cd->pixel_width; w = cd->pixel_width;
cell = gnc_cellblock_get_cell (cb, i, j); cell = gnc_cellblock_get_cell (cb, i, j);
if (!cell || cell->cell_type < 0) if (!cell || !cell->cell_name)
{ {
xpaint += w; xpaint += w;
continue; continue;

111
src/register/register-gnome/gnucash-style.c
View File

@ -859,21 +859,91 @@ gnucash_style_set_register_hint_font_name (const char *name)
gdk_font_ref (gnucash_register_hint_font); gdk_font_ref (gnucash_register_hint_font);
} }
typedef struct
{
char *cell_name;
int width;
} WidthNode;
GNCHeaderWidths
gnc_header_widths_new (void)
{
return g_hash_table_new (g_str_hash, g_str_equal);
}
static void
header_width_destroy_helper (gpointer key, gpointer value, gpointer user_data)
{
WidthNode *wn = value;
g_free (wn->cell_name);
wn->cell_name = NULL;
g_free (wn);
}
void void
gnucash_sheet_get_header_widths (GnucashSheet *sheet, int *header_widths) gnc_header_widths_destroy (GNCHeaderWidths widths)
{
if (!widths) return;
g_hash_table_foreach (widths, header_width_destroy_helper, NULL);
g_hash_table_destroy (widths);
}
void
gnc_header_widths_set_width (GNCHeaderWidths widths,
const char *cell_name,
int width)
{
WidthNode *wn;
g_return_if_fail (widths != NULL);
g_return_if_fail (cell_name != NULL);
wn = g_hash_table_lookup (widths, cell_name);
if (!wn)
{
wn = g_new0 (WidthNode, 1);
wn->cell_name = g_strdup (cell_name);
g_hash_table_insert (widths, wn->cell_name, wn);
}
wn->width = width;
}
int
gnc_header_widths_get_width (GNCHeaderWidths widths,
const char *cell_name)
{
WidthNode *wn;
g_return_val_if_fail (widths != NULL, 0);
wn = g_hash_table_lookup (widths, cell_name);
if (!wn)
return 0;
return wn->width;
}
void
gnucash_sheet_get_header_widths (GnucashSheet *sheet,
GNCHeaderWidths widths)
{ {
SheetBlockStyle *style; SheetBlockStyle *style;
CellBlock *header; CellBlock *header;
int row, col; int row, col;
g_return_if_fail(sheet != NULL); g_return_if_fail (sheet != NULL);
g_return_if_fail(GNUCASH_IS_SHEET(sheet)); g_return_if_fail (GNUCASH_IS_SHEET(sheet));
style = gnucash_sheet_get_style_from_cursor (sheet, CURSOR_HEADER); style = gnucash_sheet_get_style_from_cursor (sheet, CURSOR_HEADER);
g_return_if_fail(style != NULL); g_return_if_fail (style != NULL);
header = style->cursor; header = style->cursor;
g_return_if_fail(header != NULL); g_return_if_fail (header != NULL);
for (row = 0; row < style->nrows; row++) for (row = 0; row < style->nrows; row++)
for (col = 0; col < style->ncols; col++) for (col = 0; col < style->ncols; col++)
@ -887,31 +957,31 @@ gnucash_sheet_get_header_widths (GnucashSheet *sheet, int *header_widths)
continue; continue;
cell = gnc_cellblock_get_cell (header, row, col); cell = gnc_cellblock_get_cell (header, row, col);
if (!cell) if (!cell || !cell->cell_name)
continue; continue;
if (cell->cell_type < 0) gnc_header_widths_set_width (widths,
continue; cell->cell_name,
cd->pixel_width);
header_widths[cell->cell_type] = cd->pixel_width;
} }
} }
void void
gnucash_sheet_set_header_widths (GnucashSheet *sheet, int *header_widths) gnucash_sheet_set_header_widths (GnucashSheet *sheet,
GNCHeaderWidths widths)
{ {
SheetBlockStyle *style; SheetBlockStyle *style;
CellBlock *header; CellBlock *header;
int row, col; int row, col;
g_return_if_fail(sheet != NULL); g_return_if_fail (sheet != NULL);
g_return_if_fail(GNUCASH_IS_SHEET(sheet)); g_return_if_fail (GNUCASH_IS_SHEET(sheet));
style = gnucash_sheet_get_style_from_cursor (sheet, CURSOR_HEADER); style = gnucash_sheet_get_style_from_cursor (sheet, CURSOR_HEADER);
g_return_if_fail(style != NULL); g_return_if_fail (style != NULL);
header = style->cursor; header = style->cursor;
g_return_if_fail(header != NULL); g_return_if_fail (header != NULL);
for (row = 0; row < style->nrows; row++) for (row = 0; row < style->nrows; row++)
for (col = 0; col < style->ncols; col++) for (col = 0; col < style->ncols; col++)
@ -923,16 +993,11 @@ gnucash_sheet_set_header_widths (GnucashSheet *sheet, int *header_widths)
row, col); row, col);
cell = gnc_cellblock_get_cell (header, row, col); cell = gnc_cellblock_get_cell (header, row, col);
if (!cell) if (!cell || !cell->cell_name)
continue; continue;
if (cell->cell_type < 0) cd->pixel_width = gnc_header_widths_get_width
continue; (widths, cell->cell_name);
if (header_widths[cell->cell_type] < 0)
continue;
cd->pixel_width = header_widths[cell->cell_type];
} }
} }

17
src/register/register-gnome/gnucash-style.h
View File

@ -119,14 +119,25 @@ void gnucash_style_config_register_borders (gboolean use_vertical_lines,
void gnucash_sheet_get_borders (GnucashSheet *sheet, VirtualLocation virt_loc, void gnucash_sheet_get_borders (GnucashSheet *sheet, VirtualLocation virt_loc,
PhysicalCellBorders *borders); PhysicalCellBorders *borders);
void gnucash_sheet_get_header_widths (GnucashSheet *sheet, int *header_widths); typedef GHashTable *GNCHeaderWidths;
void gnucash_sheet_set_header_widths (GnucashSheet *sheet, int *header_widths);
GNCHeaderWidths gnc_header_widths_new (void);
void gnc_header_widths_destroy (GNCHeaderWidths widths);
void gnc_header_widths_set_width (GNCHeaderWidths widths,
const char *cell_name,
int width);
int gnc_header_widths_get_width (GNCHeaderWidths widths,
const char *cell_name);
void gnucash_sheet_get_header_widths (GnucashSheet *sheet,
GNCHeaderWidths widths);
void gnucash_sheet_set_header_widths (GnucashSheet *sheet,
GNCHeaderWidths widths);
extern GdkFont *gnucash_register_font; extern GdkFont *gnucash_register_font;
extern GdkFont *gnucash_register_hint_font; extern GdkFont *gnucash_register_hint_font;
#endif #endif

52
src/register/register-gnome/table-gnome.c
View File

@ -56,9 +56,8 @@ void
gnc_table_save_state (Table *table) gnc_table_save_state (Table *table)
{ {
GnucashSheet *sheet; GnucashSheet *sheet;
int header_widths[CELL_TYPE_COUNT]; GNCHeaderWidths widths;
SCM alist; SCM alist;
int i;
if (!table) if (!table)
return; return;
@ -68,34 +67,41 @@ gnc_table_save_state (Table *table)
sheet = GNUCASH_SHEET (table->ui_data); sheet = GNUCASH_SHEET (table->ui_data);
for (i = 0; i < CELL_TYPE_COUNT; i++) widths = gnc_header_widths_new ();
header_widths[i] = -1;
if (!GTK_OBJECT_DESTROYED(GTK_OBJECT(sheet))) if (!GTK_OBJECT_DESTROYED(GTK_OBJECT(sheet)))
gnucash_sheet_get_header_widths (sheet, header_widths); gnucash_sheet_get_header_widths (sheet, widths);
alist = SCM_EOL; alist = SCM_EOL;
if (gnc_lookup_boolean_option("General", "Save Window Geometry", TRUE)) if (gnc_lookup_boolean_option("General", "Save Window Geometry", TRUE))
for (i = 0; i < CELL_TYPE_COUNT; i++) {
GList *node = gnc_table_layout_get_cells (table->layout);
for (; node; node = node->next)
{ {
const char *name; BasicCell *cell = node->data;
int width;
SCM assoc; SCM assoc;
if (header_widths[i] <= 0) width = gnc_header_widths_get_width (widths,
cell->cell_name);
if (width <= 0)
continue; continue;
if (i == DESC_CELL) if (gnc_basic_cell_has_name (cell, DESC_CELL))
continue; continue;
name = xaccSplitRegisterGetCellTypeName (i); assoc = gh_cons (gh_str02scm(cell->cell_name),
assoc = gh_cons (gh_str02scm(name), gh_int2scm(width));
gh_int2scm(header_widths[i]));
alist = gh_cons (assoc, alist); alist = gh_cons (assoc, alist);
} }
}
if (!gh_null_p (alist)) if (!gh_null_p (alist))
gnc_set_option ("__gui", "reg_column_widths", alist); gnc_set_option ("__gui", "reg_column_widths", alist);
gnc_header_widths_destroy (widths);
} }
static void static void
@ -135,12 +141,11 @@ table_destroy_cb (Table *table)
void void
gnc_table_init_gui (gncUIWidget widget, void *data) gnc_table_init_gui (gncUIWidget widget, void *data)
{ {
int header_widths[CELL_TYPE_COUNT]; GNCHeaderWidths widths;
GnucashSheet *sheet; GnucashSheet *sheet;
GnucashRegister *greg; GnucashRegister *greg;
Table *table; Table *table;
SCM alist; SCM alist;
int i;
g_return_if_fail (widget != NULL); g_return_if_fail (widget != NULL);
g_return_if_fail (GNUCASH_IS_REGISTER (widget)); g_return_if_fail (GNUCASH_IS_REGISTER (widget));
@ -158,8 +163,7 @@ gnc_table_init_gui (gncUIWidget widget, void *data)
/* config the cell-block styles */ /* config the cell-block styles */
for (i = 0; i < CELL_TYPE_COUNT; i++) widths = gnc_header_widths_new ();
header_widths[i] = -1;
if (gnc_lookup_boolean_option("General", "Save Window Geometry", TRUE)) if (gnc_lookup_boolean_option("General", "Save Window Geometry", TRUE))
alist = gnc_lookup_option ("__gui", "reg_column_widths", alist = gnc_lookup_option ("__gui", "reg_column_widths",
@ -170,32 +174,32 @@ gnc_table_init_gui (gncUIWidget widget, void *data)
while (gh_list_p (alist) && !gh_null_p (alist)) while (gh_list_p (alist) && !gh_null_p (alist))
{ {
char *name; char *name;
CellType ctype;
SCM assoc; SCM assoc;
assoc = gh_car (alist); assoc = gh_car (alist);
alist = gh_cdr (alist); alist = gh_cdr (alist);
name = gh_scm2newstr(gh_car (assoc), NULL); name = gh_scm2newstr(gh_car (assoc), NULL);
ctype = xaccSplitRegisterGetCellTypeFromName (name); if (!name)
if (name)
free(name);
if (ctype == NO_CELL)
continue; continue;
header_widths[ctype] = gh_scm2int(gh_cdr (assoc)); gnc_header_widths_set_width (widths, name,
gh_scm2int(gh_cdr (assoc)));
free (name);
} }
gnucash_sheet_create_styles (sheet); gnucash_sheet_create_styles (sheet);
gnucash_sheet_set_header_widths (sheet, header_widths); gnucash_sheet_set_header_widths (sheet, widths);
gnucash_sheet_compile_styles (sheet); gnucash_sheet_compile_styles (sheet);
gnucash_sheet_table_load (sheet, TRUE); gnucash_sheet_table_load (sheet, TRUE);
gnucash_sheet_cursor_set_from_table (sheet, TRUE); gnucash_sheet_cursor_set_from_table (sheet, TRUE);
gnucash_sheet_redraw_all (sheet); gnucash_sheet_redraw_all (sheet);
gnc_header_widths_destroy (widths);
} }
void void