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

36
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);
VirtualLocation new_virt_loc;
CursorClass cursor_class;
CellType cell_type;
const char *cell_name;
Transaction *trans;
gnc_numeric amount;
BasicCell *cell;
@ -558,7 +558,7 @@ gnc_split_register_auto_completion (SplitRegister *reg,
return FALSE;
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)
{
@ -576,7 +576,7 @@ gnc_split_register_auto_completion (SplitRegister *reg,
return FALSE;
/* and leaving the description cell */
if (cell_type != DESC_CELL)
if (!gnc_cell_name_equal (cell_name, DESC_CELL))
return FALSE;
/* 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 */
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))
*p_new_virt_loc = new_virt_loc;
}
@ -702,7 +702,7 @@ gnc_split_register_auto_completion (SplitRegister *reg,
return FALSE;
/* and leaving the memo cell */
if (cell_type != MEMO_CELL)
if (!gnc_cell_name_equal (cell_name, MEMO_CELL))
return FALSE;
/* 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 */
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))
*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 */
do
{
CellType cell_type;
const char *cell_name;
ComboCell *cell;
Account *account;
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 ||
cell_type == MXFRM_CELL))
if (!gnc_cell_name_equal (cell_name, XFRM_CELL) &&
!gnc_cell_name_equal (cell_name, MXFRM_CELL))
break;
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,
XFRM_CELL, FALSE))
cell = (ComboCell *) gnc_table_layout_get_cell (reg->table->layout,
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))
cell = (ComboCell *) gnc_table_layout_get_cell (reg->table->layout,
MXFRM_CELL);
break;
default:
break;
}
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;
const guint32 black = 0x000000;
const guint32 red = 0xff0000;
const char * cell_name;
gboolean is_current;
gnc_numeric shares;
CellType cell_type;
Split *split;
if (!use_red_for_negative)
@ -383,12 +383,12 @@ gnc_split_register_get_shares_fg_color (VirtualLocation virt_loc,
if (!split)
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,
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));
else if (is_current)
shares = gnc_price_cell_get_value
@ -410,8 +410,8 @@ gnc_split_register_get_balance_fg_color (VirtualLocation virt_loc,
SplitRegister *reg = user_data;
const guint32 black = 0x000000;
const guint32 red = 0xff0000;
const char * cell_name;
gnc_numeric balance;
CellType cell_type;
Split *split;
if (!use_red_for_negative)
@ -421,9 +421,9 @@ gnc_split_register_get_balance_fg_color (VirtualLocation virt_loc,
if (!split)
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);
else
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))
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)
balance = get_trans_total_balance (reg, xaccSplitGetParent (split));
@ -887,24 +888,26 @@ gnc_split_register_get_tdebcred_entry (VirtualLocation virt_loc,
gpointer user_data)
{
SplitRegister *reg = user_data;
const char * cell_name;
gnc_numeric total;
int cell_type;
Split *split;
split = sr_get_split (reg, virt_loc.vcell_loc);
if (!split)
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));
if (gnc_numeric_zero_p (total))
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;
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;
total = gnc_numeric_abs (total);
@ -922,7 +925,8 @@ gnc_split_register_get_debcred_entry (VirtualLocation virt_loc,
gboolean is_debit;
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);
@ -1173,7 +1177,7 @@ gnc_template_register_get_debcred_entry (VirtualLocation virt_loc,
if (kvpf)
{
gnc_numeric amount;
int cell_type;
const char * cell_name;
char *str;
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))
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 "";
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 "";
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);
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);

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

@ -480,7 +480,7 @@ xaccSRGetSplitAmountVirtLoc (SplitRegister *reg, Split *split,
{
VirtualLocation v_loc;
CursorClass cursor_class;
CellType cell_type;
const char *cell_name;
gnc_numeric value;
if (!xaccSRGetSplitVirtLoc (reg, split, &v_loc.vcell_loc))
@ -494,13 +494,13 @@ xaccSRGetSplitAmountVirtLoc (SplitRegister *reg, Split *split,
{
case CURSOR_CLASS_SPLIT:
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;
default:
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))
return FALSE;
@ -1520,14 +1520,14 @@ xaccSRSaveRegEntry (SplitRegister *reg, gboolean do_commit)
}
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;
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;
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 (),
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>
*/
#include "config.h"
#include <stdlib.h>
#include <string.h>
@ -43,6 +45,13 @@
/* This static indicates the debugging module that this .o belongs to. */
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 *
gnc_basic_cell_new (void)
{
@ -70,7 +79,8 @@ BasicCellHelpValue(BasicCell *cell)
static void
gnc_basic_cell_clear (BasicCell *cell)
{
cell->cell_type = -1;
g_free (cell->cell_name);
cell->cell_name = NULL;
cell->changed = FALSE;
cell->conditionally_changed = FALSE;
@ -138,10 +148,23 @@ gnc_basic_cell_destroy (BasicCell *cell)
}
void
gnc_basic_cell_set_name (BasicCell *cell, int cell_type)
gnc_basic_cell_set_name (BasicCell *cell, const char *name)
{
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

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

@ -191,7 +191,7 @@ typedef enum
struct _BasicCell
{
int cell_type;
char * cell_name;
char * value; /* current value */
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);
void gnc_basic_cell_init (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,
const char *sample_text);

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

@ -70,7 +70,7 @@ xaccInitSplitRegister (SplitRegister *reg,
static void
gnc_register_add_cell (SplitRegister *sr,
CellType cell_type,
const char *cell_name,
const char *cell_type_name,
const char *sample_text,
CellAlignment alignment,
@ -84,7 +84,7 @@ gnc_register_add_cell (SplitRegister *sr,
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_alignment (cell, alignment);
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);
}
/* ============================================== */
/* configAction strings into the action cell */
/* hack alert -- this stuff really, really should be in a config file ... */
static void
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
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;
cell = gnc_cellblock_get_cell (from, row, col);
if (!cell || cell->cell_type < 0)
if (!cell || !cell->cell_name)
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
configLayout (SplitRegister *reg)
{
@ -265,19 +234,22 @@ configLayout (SplitRegister *reg)
curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_LEDGER);
set_cell (reg, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, MXFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4);
if ( reg->template ) {
set_cell( reg, curs, FDEBT_CELL, 0, 5);
set_cell( reg, curs, FCRED_CELL, 0, 6);
} else {
set_cell (reg, curs, DEBT_CELL, 0, 5);
set_cell (reg, curs, CRED_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, MXFRM_CELL, 0, 3);
gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
if (reg->template)
{
gnc_table_layout_set_cell (reg->table->layout, curs, FDEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, FCRED_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 = gnc_table_layout_get_cursor (reg->table->layout,
@ -285,18 +257,18 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, ACTN_CELL, 1, 1);
set_cell (reg, curs, NOTES_CELL, 1, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 1, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_JOURNAL);
set_cell (reg, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, TDEBT_CELL, 0, 5);
set_cell (reg, curs, TCRED_CELL, 0, 6);
set_cell (reg, curs, TBALN_CELL, 0, 7);
gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, TDEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, TCRED_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, TBALN_CELL, 0, 7);
curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -304,21 +276,24 @@ configLayout (SplitRegister *reg)
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,
CURSOR_SPLIT);
set_cell (reg, curs, ACTN_CELL, 0, 1);
set_cell (reg, curs, MEMO_CELL, 0, 2);
set_cell (reg, curs, XFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4);
if ( reg->template ) {
set_cell( reg, curs, FDEBT_CELL, 0, 5);
set_cell( reg, curs, FCRED_CELL, 0, 6);
} else {
set_cell (reg, curs, DEBT_CELL, 0, 5);
set_cell (reg, curs, CRED_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, MEMO_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, XFRM_CELL, 0, 3);
gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
if (reg->template)
{
gnc_table_layout_set_cell (reg->table->layout, curs, FDEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, FCRED_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;
@ -332,17 +307,20 @@ configLayout (SplitRegister *reg)
curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_LEDGER);
set_cell (reg, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, MXFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4);
if ( reg->template ) {
set_cell (reg, curs, FDEBT_CELL, 0, 5);
set_cell (reg, curs, FCRED_CELL, 0, 6);
} else {
set_cell (reg, curs, DEBT_CELL, 0, 5);
set_cell (reg, curs, CRED_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, MXFRM_CELL, 0, 3);
gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
if (reg->template)
{
gnc_table_layout_set_cell (reg->table->layout, curs, FDEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, FCRED_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;
@ -351,17 +329,17 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, ACTN_CELL, 1, 1);
set_cell (reg, curs, NOTES_CELL, 1, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 1, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_JOURNAL);
set_cell (reg, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, TDEBT_CELL, 0, 5);
set_cell (reg, curs, TCRED_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, TDEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, TCRED_CELL, 0, 6);
curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -369,21 +347,24 @@ configLayout (SplitRegister *reg)
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,
CURSOR_SPLIT);
set_cell (reg, curs, ACTN_CELL, 0, 1);
set_cell (reg, curs, MEMO_CELL, 0, 2);
set_cell (reg, curs, XFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4);
if ( reg->template ) {
set_cell (reg, curs, FDEBT_CELL, 0, 5);
set_cell (reg, curs, FCRED_CELL, 0, 6);
} else {
set_cell (reg, curs, DEBT_CELL, 0, 5);
set_cell (reg, curs, CRED_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, MEMO_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, XFRM_CELL, 0, 3);
gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
if (reg->template)
{
gnc_table_layout_set_cell (reg->table->layout, curs, FDEBT_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, FCRED_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;
@ -396,16 +377,16 @@ configLayout (SplitRegister *reg)
curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_LEDGER);
set_cell (reg, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, MXFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4);
set_cell (reg, curs, SHRS_CELL, 0, 5);
set_cell (reg, curs, PRIC_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 7);
set_cell (reg, curs, CRED_CELL, 0, 8);
set_cell (reg, curs, BALN_CELL, 0, 9);
gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, MXFRM_CELL, 0, 3);
gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
gnc_table_layout_set_cell (reg->table->layout, curs, SHRS_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, PRIC_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 7);
gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 8);
gnc_table_layout_set_cell (reg->table->layout, curs, BALN_CELL, 0, 9);
curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -413,19 +394,19 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, ACTN_CELL, 1, 1);
set_cell (reg, curs, NOTES_CELL, 1, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 1, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_JOURNAL);
set_cell (reg, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, TSHRS_CELL, 0, 5);
set_cell (reg, curs, TDEBT_CELL, 0, 7);
set_cell (reg, curs, TCRED_CELL, 0, 8);
set_cell (reg, curs, TBALN_CELL, 0, 9);
gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, TSHRS_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, TDEBT_CELL, 0, 7);
gnc_table_layout_set_cell (reg->table->layout, curs, TCRED_CELL, 0, 8);
gnc_table_layout_set_cell (reg->table->layout, curs, TBALN_CELL, 0, 9);
curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -433,19 +414,19 @@ configLayout (SplitRegister *reg)
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,
CURSOR_SPLIT);
set_cell (reg, curs, ACTN_CELL, 0, 1);
set_cell (reg, curs, MEMO_CELL, 0, 2);
set_cell (reg, curs, XFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4);
set_cell (reg, curs, SHRS_CELL, 0, 5);
set_cell (reg, curs, PRIC_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 7);
set_cell (reg, curs, CRED_CELL, 0, 8);
gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, MEMO_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, XFRM_CELL, 0, 3);
gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
gnc_table_layout_set_cell (reg->table->layout, curs, SHRS_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, PRIC_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 7);
gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 8);
break;
}
@ -456,15 +437,15 @@ configLayout (SplitRegister *reg)
curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_LEDGER);
set_cell (reg, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, MXFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4);
set_cell (reg, curs, SHRS_CELL, 0, 5);
set_cell (reg, curs, PRIC_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 7);
set_cell (reg, curs, CRED_CELL, 0, 8);
gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, MXFRM_CELL, 0, 3);
gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
gnc_table_layout_set_cell (reg->table->layout, curs, SHRS_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, PRIC_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 7);
gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 8);
curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -472,18 +453,18 @@ configLayout (SplitRegister *reg)
copy_cursor_row (reg, curs, curs_last, 0);
set_cell (reg, curs, ACTN_CELL, 1, 1);
set_cell (reg, curs, NOTES_CELL, 1, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 1, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, NOTES_CELL, 1, 2);
curs = gnc_table_layout_get_cursor (reg->table->layout,
CURSOR_SINGLE_JOURNAL);
set_cell (reg, curs, DATE_CELL, 0, 0);
set_cell (reg, curs, NUM_CELL, 0, 1);
set_cell (reg, curs, DESC_CELL, 0, 2);
set_cell (reg, curs, TSHRS_CELL, 0, 5);
set_cell (reg, curs, TDEBT_CELL, 0, 7);
set_cell (reg, curs, TCRED_CELL, 0, 8);
gnc_table_layout_set_cell (reg->table->layout, curs, DATE_CELL, 0, 0);
gnc_table_layout_set_cell (reg->table->layout, curs, NUM_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, DESC_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, TSHRS_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, TDEBT_CELL, 0, 7);
gnc_table_layout_set_cell (reg->table->layout, curs, TCRED_CELL, 0, 8);
curs_last = curs;
curs = gnc_table_layout_get_cursor (reg->table->layout,
@ -491,22 +472,23 @@ configLayout (SplitRegister *reg)
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,
CURSOR_SPLIT);
set_cell (reg, curs, ACTN_CELL, 0, 1);
set_cell (reg, curs, MEMO_CELL, 0, 2);
set_cell (reg, curs, XFRM_CELL, 0, 3);
set_cell (reg, curs, RECN_CELL, 0, 4);
set_cell (reg, curs, SHRS_CELL, 0, 5);
set_cell (reg, curs, PRIC_CELL, 0, 6);
set_cell (reg, curs, DEBT_CELL, 0, 7);
set_cell (reg, curs, CRED_CELL, 0, 8);
gnc_table_layout_set_cell (reg->table->layout, curs, ACTN_CELL, 0, 1);
gnc_table_layout_set_cell (reg->table->layout, curs, MEMO_CELL, 0, 2);
gnc_table_layout_set_cell (reg->table->layout, curs, XFRM_CELL, 0, 3);
gnc_table_layout_set_cell (reg->table->layout, curs, RECN_CELL, 0, 4);
gnc_table_layout_set_cell (reg->table->layout, curs, SHRS_CELL, 0, 5);
gnc_table_layout_set_cell (reg->table->layout, curs, PRIC_CELL, 0, 6);
gnc_table_layout_set_cell (reg->table->layout, curs, DEBT_CELL, 0, 7);
gnc_table_layout_set_cell (reg->table->layout, curs, CRED_CELL, 0, 8);
break;
}
/* --------------------------------------------------------- */
default:
PERR ("unknown register type %d \n", reg->type);
@ -514,8 +496,6 @@ configLayout (SplitRegister *reg)
}
}
/* ============================================== */
SplitRegister *
gnc_register_new (SplitRegisterType type,
SplitRegisterStyle style,
@ -546,8 +526,6 @@ gnc_register_new (SplitRegisterType type,
return reg;
}
/* ============================================== */
static void
mallocCursors (SplitRegister *reg)
{
@ -595,6 +573,8 @@ mallocCursors (SplitRegister *reg)
cursor = gnc_cellblock_new (1, num_cols, CURSOR_SINGLE_LEDGER);
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);
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);
}
/* ============================================== */
static void
xaccInitSplitRegister (SplitRegister *reg,
SplitRegisterType type,
@ -945,8 +923,6 @@ xaccInitSplitRegister (SplitRegister *reg,
}
}
/* ============================================== */
void
xaccConfigSplitRegister (SplitRegister *reg,
SplitRegisterType newtype,
@ -966,8 +942,6 @@ xaccConfigSplitRegister (SplitRegister *reg,
gnc_table_realize_gui (reg->table);
}
/* ============================================== */
void
xaccDestroySplitRegister (SplitRegister *reg)
{
@ -997,8 +971,6 @@ xaccDestroySplitRegister (SplitRegister *reg)
g_free (reg);
}
/* ============================================== */
static CursorClass
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);
}
/* ============================================== */
CursorClass
xaccSplitRegisterGetCurrentCursorClass (SplitRegister *reg)
{
@ -1025,8 +995,6 @@ xaccSplitRegisterGetCurrentCursorClass (SplitRegister *reg)
return sr_cellblock_cursor_class (reg, table->current_cursor);
}
/* ============================================== */
CursorClass
xaccSplitRegisterGetCursorClass (SplitRegister *reg,
VirtualCellLocation vcell_loc)
@ -1048,8 +1016,6 @@ xaccSplitRegisterGetCursorClass (SplitRegister *reg,
return sr_cellblock_cursor_class (reg, vcell->cellblock);
}
/* ============================================== */
CursorClass
xaccCursorNameToClass (const char *cursor_name)
{
@ -1067,56 +1033,3 @@ xaccCursorNameToClass (const char *cursor_name)
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
*/
#ifndef XACC_SPLITREG_H
#define XACC_SPLITREG_H
#ifndef SPLITREG_H
#define SPLITREG_H
#include "Account.h" /* FIXME No Engine headers!!! */
@ -73,33 +73,29 @@ typedef enum
NUM_REGISTER_TYPES
} SplitRegisterType;
/* These values are used to identify the cells in the register. */
/* Keep these in sync with the cell_names array in splitreg.c. */
typedef enum
{
NO_CELL = -1,
DATE_CELL = 0,
NUM_CELL,
DESC_CELL,
RECN_CELL,
BALN_CELL,
ACTN_CELL,
XFRM_CELL,
MEMO_CELL,
CRED_CELL,
DEBT_CELL,
PRIC_CELL,
SHRS_CELL,
MXFRM_CELL, /* MXFRM is the "mirrored" transfer-from account */
TCRED_CELL, /* T* cells are transaction summary cells */
TDEBT_CELL,
TSHRS_CELL,
TBALN_CELL,
NOTES_CELL,
FCRED_CELL, // formula credit, used by the template ledger
FDEBT_CELL, // formula debit, used by the template ledger
CELL_TYPE_COUNT,
} CellType;
/* Cell Names */
#define DATE_CELL "date"
#define NUM_CELL "num"
#define DESC_CELL "description"
#define RECN_CELL "reconcile"
#define BALN_CELL "balance"
#define ACTN_CELL "action"
#define XFRM_CELL "account"
#define MEMO_CELL "memo"
#define DEBT_CELL "debit"
#define CRED_CELL "credit"
#define PRIC_CELL "price"
#define SHRS_CELL "shares"
#define MXFRM_CELL "transfer"
/* T* cells are transaction summary cells */
#define TDEBT_CELL "trans-debit"
#define TCRED_CELL "trans-credit"
#define TSHRS_CELL "trans-shares"
#define TBALN_CELL "trans-balance"
#define NOTES_CELL "notes"
#define FDEBT_CELL "debit formula"
#define FCRED_CELL "credit-formula"
/*
* enumerated display styles
@ -199,10 +195,4 @@ CursorClass xaccSplitRegisterGetCursorClass (SplitRegister *reg,
CursorClass xaccCursorNameToClass (const char *cursor_name);
const char * xaccSplitRegisterGetCellTypeName (CellType type);
CellType xaccSplitRegisterGetCellTypeFromName (const char *name);
#endif /* XACC_SPLITREG_H */
/* ============ END OF FILE ===================== */
#endif

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);
}
int
gnc_table_get_current_cell_type (Table *table)
const char *
gnc_table_get_current_cell_name (Table *table)
{
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
gnc_table_get_current_cell_location (Table *table,
int cell_type,
const char *cell_name,
VirtualLocation *virt_loc)
{
if (table == NULL)
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,
virt_loc);
}
@ -229,12 +229,12 @@ gnc_table_get_entry_internal (Table *table, VirtualLocation virt_loc,
gboolean *conditionally_changed)
{
TableGetEntryHandler entry_handler;
const char *cell_name;
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 "";
entry = entry_handler (virt_loc, FALSE,
@ -254,7 +254,7 @@ gnc_table_get_entry (Table *table, VirtualLocation virt_loc)
BasicCell *cell;
cell = gnc_table_get_cell (table, virt_loc);
if (!cell || cell->cell_type < 0)
if (!cell || !cell->cell_name)
return "";
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,
cell->cell_type);
cell->cell_name);
if (!entry_handler) return "";
entry = entry_handler (virt_loc, TRUE, NULL,
@ -284,15 +284,15 @@ CellIOFlags
gnc_table_get_io_flags (Table *table, VirtualLocation virt_loc)
{
TableGetCellIOFlagsHandler io_flags_handler;
int cell_type;
const char *cell_name;
if (!table || !table->model)
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,
cell_type);
cell_name);
if (!io_flags_handler)
return XACC_CELL_ALLOW_NONE;
@ -303,15 +303,15 @@ const char *
gnc_table_get_label (Table *table, VirtualLocation virt_loc)
{
TableGetLabelHandler label_handler;
const char *cell_name;
const char *label;
int cell_type;
if (!table || !table->model)
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)
return "";
@ -326,15 +326,15 @@ guint32
gnc_table_get_fg_color (Table *table, VirtualLocation virt_loc)
{
TableGetFGColorHandler fg_color_handler;
int cell_type;
const char *cell_name;
if (!table || !table->model)
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,
cell_type);
cell_name);
if (!fg_color_handler)
return 0x0;
@ -346,7 +346,7 @@ gnc_table_get_bg_color (Table *table, VirtualLocation virt_loc,
gboolean *hatching)
{
TableGetBGColorHandler bg_color_handler;
int cell_type;
const char *cell_name;
if (hatching)
*hatching = FALSE;
@ -354,10 +354,10 @@ gnc_table_get_bg_color (Table *table, VirtualLocation virt_loc,
if (!table || !table->model)
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,
cell_type);
cell_name);
if (!bg_color_handler)
return 0x0;
@ -370,15 +370,15 @@ gnc_table_get_borders (Table *table, VirtualLocation virt_loc,
PhysicalCellBorders *borders)
{
TableGetCellBorderHandler cell_border_handler;
int cell_type;
const char *cell_name;
if (!table || !table->model)
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_type);
cell_name);
if (!cell_border_handler)
return;
@ -444,21 +444,21 @@ gnc_table_get_cell (Table *table, VirtualLocation virt_loc)
virt_loc.phys_col_offset);
}
int
gnc_table_get_cell_type (Table *table, VirtualLocation virt_loc)
const char *
gnc_table_get_cell_name (Table *table, VirtualLocation virt_loc)
{
BasicCell *cell;
cell = gnc_table_get_cell (table, virt_loc);
if (cell == NULL)
return -1;
return NULL;
return cell->cell_type;
return cell->cell_name;
}
gboolean
gnc_table_get_cell_location (Table *table,
int cell_type,
const char *cell_name,
VirtualCellLocation vcell_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++)
{
BasicCell *cell;
int ctype;
cell = gnc_cellblock_get_cell (cellblock, cell_row, cell_col);
if (!cell)
return FALSE;
ctype = cell->cell_type;
if (ctype == cell_type)
if (gnc_basic_cell_has_name (cell, cell_name))
{
if (virt_loc != NULL)
{
@ -1082,15 +1079,15 @@ gboolean
gnc_table_confirm_change (Table *table, VirtualLocation virt_loc)
{
TableConfirmHandler confirm_handler;
int cell_type;
const char *cell_name;
if (!table || !table->model)
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,
cell_type);
cell_name);
if (!confirm_handler)
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,
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,
int cell_type,
const char *cell_name,
VirtualLocation *virt_loc);
@ -203,11 +203,11 @@ char * gnc_table_get_help (Table *table);
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);
gboolean gnc_table_get_cell_location (Table *table,
int cell_type,
const char * cell_name,
VirtualCellLocation vcell_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 *cursors; /* The cursors in the table */
CellBlock *primary_cursor;
};
typedef struct _CellBuffer CellBuffer;
struct _CellBuffer
{
int cell_type;
char * cell_name;
char * value;
guint32 changed;
guint32 conditionally_changed;
@ -105,7 +107,7 @@ gnc_table_layout_add_cell (TableLayout *layout,
{
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)
return;
@ -122,7 +124,7 @@ gnc_table_layout_add_cell (TableLayout *layout,
}
BasicCell *
gnc_table_layout_get_cell (TableLayout *layout, int cell_type)
gnc_table_layout_get_cell (TableLayout *layout, const char *cell_name)
{
GList *node;
@ -132,7 +134,7 @@ gnc_table_layout_get_cell (TableLayout *layout, int cell_type)
{
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;
}
@ -140,13 +142,13 @@ gnc_table_layout_get_cell (TableLayout *layout, int cell_type)
}
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;
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;
return gnc_basic_cell_get_value (cell);
@ -154,14 +156,14 @@ gnc_table_layout_get_cell_value (TableLayout *layout, int cell_type)
gboolean
gnc_table_layout_get_cell_changed (TableLayout *layout,
int cell_type,
const char *cell_name,
gboolean include_conditional)
{
BasicCell *cell;
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 (!include_conditional)
@ -236,6 +238,50 @@ gnc_table_layout_get_cursors (TableLayout *layout)
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 *
gnc_cursor_buffer_new (void)
{
@ -252,6 +298,9 @@ destroy_cell_buffer (CellBuffer *cb)
if (cb == NULL)
return;
g_free (cb->cell_name);
cb->cell_name = NULL;
g_free (cb->value);
cb->value = NULL;
@ -296,6 +345,7 @@ save_cell (BasicCell *bcell)
cb = g_new0 (CellBuffer, 1);
cb->cell_name = g_strdup (bcell->cell_name);
cb->value = g_strdup (bcell->value);
cb->changed = bcell->changed;
cb->conditionally_changed = bcell->conditionally_changed;
@ -325,7 +375,6 @@ gnc_table_layout_save_cursor (TableLayout *layout,
continue;
cb = save_cell (list_cell);
cb->cell_type = list_cell->cell_type;
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;
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);
}

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);
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,
int cell_type);
const char *cell_name);
gboolean gnc_table_layout_get_cell_changed (TableLayout *layout,
int cell_type,
const char *cell_name,
gboolean include_conditional);
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);
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);
void gnc_cursor_buffer_destroy (CursorBuffer *buffer);

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

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

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

@ -78,7 +78,7 @@ gnucash_cursor_get_pixel_coords (GnucashCursor *cursor,
BasicCell *cell;
cell = gnc_cellblock_get_cell (vcell->cellblock, 0, col);
if (cell && cell->cell_type >= 0)
if (cell && cell->cell_name)
break;
}
@ -95,7 +95,7 @@ gnucash_cursor_get_pixel_coords (GnucashCursor *cursor,
BasicCell *cell;
cell = gnc_cellblock_get_cell (vcell->cellblock, 0, col);
if (cell && cell->cell_type >= 0)
if (cell && cell->cell_name)
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;
cell = gnc_cellblock_get_cell (cb, i, j);
if (!cell || cell->cell_type < 0)
if (!cell || !cell->cell_name)
{
xpaint += w;
continue;

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

@ -859,8 +859,78 @@ gnucash_style_set_register_hint_font_name (const char *name)
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
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;
CellBlock *header;
@ -887,18 +957,18 @@ gnucash_sheet_get_header_widths (GnucashSheet *sheet, int *header_widths)
continue;
cell = gnc_cellblock_get_cell (header, row, col);
if (!cell)
if (!cell || !cell->cell_name)
continue;
if (cell->cell_type < 0)
continue;
header_widths[cell->cell_type] = cd->pixel_width;
gnc_header_widths_set_width (widths,
cell->cell_name,
cd->pixel_width);
}
}
void
gnucash_sheet_set_header_widths (GnucashSheet *sheet, int *header_widths)
gnucash_sheet_set_header_widths (GnucashSheet *sheet,
GNCHeaderWidths widths)
{
SheetBlockStyle *style;
CellBlock *header;
@ -923,16 +993,11 @@ gnucash_sheet_set_header_widths (GnucashSheet *sheet, int *header_widths)
row, col);
cell = gnc_cellblock_get_cell (header, row, col);
if (!cell)
if (!cell || !cell->cell_name)
continue;
if (cell->cell_type < 0)
continue;
if (header_widths[cell->cell_type] < 0)
continue;
cd->pixel_width = header_widths[cell->cell_type];
cd->pixel_width = gnc_header_widths_get_width
(widths, cell->cell_name);
}
}

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,
PhysicalCellBorders *borders);
void gnucash_sheet_get_header_widths (GnucashSheet *sheet, int *header_widths);
void gnucash_sheet_set_header_widths (GnucashSheet *sheet, int *header_widths);
typedef GHashTable *GNCHeaderWidths;
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_hint_font;
#endif

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

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