Cell

A "Cell" is an active object which is designed to read a specific kind of user input. More...

Files
file	basiccell.h
file	cell-factory.h
file	checkboxcell.h
file	combocell.h
file	datecell.h
file	doclinkcell.h
file	formulacell.h
file	numcell.h
file	pricecell.h
file	quickfillcell.h
file	recncell.h

Data Structures
struct	BasicCell
	The BasicCell class provides an abstract base class defining the handling of the editing of a cell of a table. More...
struct	CheckboxCell
	The CheckboxCell object implements a cell handler that will toggle between yes and no values when clicked upon by the mouse. More...
struct	ComboCell
	The ComboCell object implements a cell handler with a "combination-box" pull-down menu in it. More...
struct	CompletionCell
	The CompletionCell object implements a cell handler with a "combination-box" pull-down menu in it. More...
struct	DateCell
	The DateCell object implements a date handling cell. More...
struct	Doclinkcell
	The Doclinkcell object implements a cell handler that will cycle through a series of single-character values when clicked upon by the mouse and will return a glyph if font can show it. More...
struct	FormulaCell
	The FormulaCell is a register-table cell which can contain a formula involving numbers, formula markup and strings denoting either functions or variables. More...
struct	NumCell
	The NumCell object implements a number handling cell. More...
struct	PriceCell
	The PriceCell object implements a cell handler that stores a single double-precision value, and has the smarts to display it as a price/amount as well as accepting monetary or general numeric input. More...
struct	QuickFillCell
	The QuickFillCell implements a text cell with quick-fill capabilities. More...
struct	RecnCell
	The RecnCell object implements a cell handler that will cycle through a series of single-character values when clicked upon by the mouse. More...

Macros
#define	GLYPH_PAPERCLIP   "\360\237\223\216"
#define	GLYPH_LINK   "\360\237\224\227"

Typedefs
typedef BasicCell *(*	CellCreateFunc) (void)
typedef void(*	CellSetValueFunc) (BasicCell *cell, const char *new_value)
typedef gboolean(*	CellEnterFunc) (BasicCell *cell, int *cursor_position, int *start_selection, int *end_selection)
typedef void(*	CellModifyVerifyFunc) (BasicCell *cell, const char *add_str, int add_str_len, const char *new_value, int new_value_len, int *cursor_position, int *start_selection, int *end_selection)
typedef gboolean(*	CellDirectUpdateFunc) (BasicCell *cell, int *cursor_position, int *start_selection, int *end_selection, gpointer gui_data)
typedef void(*	CellLeaveFunc) (BasicCell *cell)
typedef void(*	CellRealizeFunc) (BasicCell *cell, gpointer gui_handle)
typedef void(*	CellMoveFunc) (BasicCell *cell)
typedef void(*	CellDestroyFunc) (BasicCell *cell)
typedef const char *(*	DoclinkcellStringGetter) (char flag)
typedef gboolean(*	DoclinkcellConfirm) (char old_flag, gpointer data)
typedef const char *(*	RecnCellStringGetter) (char flag)
typedef gboolean(*	RecnCellConfirm) (char old_flag, gpointer data)

Enumerations
enum	CellAlignment { CELL_ALIGN_RIGHT , CELL_ALIGN_CENTER , CELL_ALIGN_LEFT }

Functions
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, const char *name)
gboolean	gnc_basic_cell_has_name (BasicCell *cell, const char *name)
void	gnc_basic_cell_set_type_name (BasicCell *cell, const gchar *type_name)
gboolean	gnc_basic_cell_has_type_name (BasicCell *cell, const gchar *type_name)
void	gnc_basic_cell_set_sample_text (BasicCell *cell, const char *sample_text)
void	gnc_basic_cell_set_alignment (BasicCell *cell, CellAlignment alignment)
void	gnc_basic_cell_set_expandable (BasicCell *cell, gboolean expandable)
void	gnc_basic_cell_set_span (BasicCell *cell, gboolean span)
const char *	gnc_basic_cell_get_value (BasicCell *cell)
void	gnc_basic_cell_set_value (BasicCell *bcell, const char *value)
gboolean	gnc_basic_cell_get_changed (BasicCell *cell)
gboolean	gnc_basic_cell_get_conditionally_changed (BasicCell *cell)
void	gnc_basic_cell_set_changed (BasicCell *cell, gboolean changed)
void	gnc_basic_cell_set_conditionally_changed (BasicCell *cell, gboolean changed)
void	gnc_basic_cell_set_value_internal (BasicCell *bcell, const char *value)
char *	gnc_basic_cell_validate (BasicCell *bcell, GNCPrintAmountInfo print_info, const char *change, const char *newval, const char *toks, gint *cursor_position)
CellFactory *	gnc_cell_factory_new (void)
void	gnc_cell_factory_destroy (CellFactory *cf)
void	gnc_cell_factory_add_cell_type (CellFactory *cf, const char *cell_type_name, CellCreateFunc cell_creator)
BasicCell *	gnc_cell_factory_make_cell (CellFactory *cf, const char *cell_type_name)
BasicCell *	gnc_checkbox_cell_new (void)
void	gnc_checkbox_cell_set_flag (CheckboxCell *cell, gboolean flag)
gboolean	gnc_checkbox_cell_get_flag (CheckboxCell *cell)
const char *	gnc_checkbox_cell_get_string (gboolean flag)
BasicCell *	gnc_combo_cell_new (void)
void	gnc_combo_cell_init (ComboCell *cell)
void	gnc_combo_cell_set_value (ComboCell *cell, const char *value)
void	gnc_combo_cell_clear_menu (ComboCell *cell)
void	gnc_combo_cell_add_menu_item (ComboCell *cell, const char *menustr)
	Add a menu item to the list.
void	gnc_combo_cell_add_account_menu_item (ComboCell *cell, char *menustr)
	Add a 'account name' menu item to the list.
void	gnc_combo_cell_set_sort_enabled (ComboCell *cell, gboolean enabled)
	Enable sorting of the menu item's contents.
void	gnc_combo_cell_set_strict (ComboCell *cell, gboolean strict)
	Determines whether the cell will accept strings not in the menu.
void	gnc_combo_cell_set_complete_char (ComboCell *cell, gunichar complete_char)
	Sets a character used for special completion processing.
void	gnc_combo_cell_add_ignore_string (ComboCell *cell, const char *ignore_string)
	Add a string to a list of strings which, if the cell has that value, will cause the cell to be uneditable on 'enter'.
void	gnc_combo_cell_set_autosize (ComboCell *cell, gboolean autosize)
	Determines whether the popup list autosizes itself or uses all available space.
void	gnc_combo_cell_use_quickfill_cache (ComboCell *cell, QuickFill *shared_qf)
	Tell the combocell to use a shared QuickFill object.
void	gnc_combo_cell_use_list_store_cache (ComboCell *cell, gpointer data)
BasicCell *	gnc_completion_cell_new (void)
void	gnc_completion_cell_init (CompletionCell *cell)
void	gnc_completion_cell_set_value (CompletionCell *cell, const char *value)
void	gnc_completion_cell_clear_menu (CompletionCell *cell)
void	gnc_completion_cell_add_menu_item (CompletionCell *cell, const char *menustr)
	Add a menu item to the hash table list.
void	gnc_completion_cell_set_sort_enabled (CompletionCell *cell, gboolean enabled)
	Enable sorting of the menu item's contents.
void	gnc_completion_cell_set_strict (CompletionCell *cell, gboolean strict)
	Determines whether the cell will accept strings not in the menu.
void	gnc_completion_cell_set_autosize (CompletionCell *cell, gboolean autosize)
	Determines whether the popup list autosizes itself or uses all available space.
void	gnc_completion_cell_reverse_sort (CompletionCell *cell, gboolean is_reversed)
	Register the sort direction.
BasicCell *	gnc_date_cell_new (void)
	installs a callback to handle date recording
void	gnc_date_cell_set_value (DateCell *cell, int day, int mon, int year)
	Accepts a numeric date and sets the contents of the date cell to that value.
void	gnc_date_cell_set_value_secs (DateCell *cell, time64 secs)
	Sets the contents of the cell with seconds before or since the Unix epoch.
void	gnc_date_cell_commit (DateCell *cell)
	Commits any pending changes to the value of the cell.
void	gnc_date_cell_get_date (DateCell *cell, time64 *time, gboolean warn)
	Set a time64 to the value in the DateCell.
BasicCell *	gnc_doclink_cell_new (void)
void	gnc_doclink_cell_set_flag (Doclinkcell *cell, char flag)
char	gnc_doclink_cell_get_flag (Doclinkcell *cell)
void	gnc_doclink_cell_set_confirm_cb (Doclinkcell *cell, DoclinkcellConfirm confirm_cb, gpointer data)
void	gnc_doclink_cell_set_string_getter (Doclinkcell *cell, DoclinkcellStringGetter getter)
void	gnc_doclink_cell_set_valid_flags (Doclinkcell *cell, const char *flags, char default_flag)
	note that
void	gnc_doclink_cell_set_flag_order (Doclinkcell *cell, const char *flags)
void	gnc_doclink_cell_set_read_only (Doclinkcell *cell, gboolean read_only)
void	gnc_doclink_cell_set_use_glyphs (Doclinkcell *cell)
gboolean	gnc_doclink_get_use_glyphs (Doclinkcell *cell)
const char *	gnc_doclink_get_glyph_from_flag (char link_flag)
BasicCell *	gnc_formula_cell_new (void)
void	gnc_formula_cell_set_value (FormulaCell *fc, const char *newVal)
BasicCell *	gnc_num_cell_new (void)
void	gnc_num_cell_set_value (NumCell *cell, const char *str)
gboolean	gnc_num_cell_set_last_num (NumCell *cell, const char *str)
BasicCell *	gnc_price_cell_new (void)
	installs a callback to handle price recording
gnc_numeric	gnc_price_cell_get_value (PriceCell *cell)
	return the value of a price cell
gboolean	gnc_price_cell_set_value (PriceCell *cell, gnc_numeric amount)
	updates amount, returns TRUE if string representation actually changed
void	gnc_price_cell_set_fraction (PriceCell *cell, int fraction)
	Sets the fraction used for rounding.
void	gnc_price_cell_blank (PriceCell *cell)
	Sets the cell as blank, regardless of the blank_zero value.
void	gnc_price_cell_set_blank_zero (PriceCell *cell, gboolean blank_zero)
	determines whether 0 values are left blank or printed.
void	gnc_price_cell_set_print_info (PriceCell *cell, GNCPrintAmountInfo print_info)
	set the printing context of the price cell
void	gnc_price_cell_set_debt_credit_value (PriceCell *debit, PriceCell *credit, gnc_numeric amount)
	updates two cells; the deb cell if amt is negative, the credit cell if amount is positive, and makes the other cell blank.
BasicCell *	gnc_quickfill_cell_new (void)
void	gnc_quickfill_cell_set_value (QuickFillCell *cell, const char *value)
	sets the current cell value to the indicated string, simultaneously adding the string to the quick-fill tree.
void	gnc_quickfill_cell_set_sort (QuickFillCell *cell, QuickFillSort sort)
void	gnc_quickfill_cell_add_completion (QuickFillCell *cell, const char *completion)
void	gnc_quickfill_cell_use_quickfill_cache (QuickFillCell *cell, QuickFill *shared_qf)
	Lets the cell use the given shared quickfill object instead of the one it owns internally.
BasicCell *	gnc_recn_cell_new (void)
void	gnc_recn_cell_set_flag (RecnCell *cell, char flag)
char	gnc_recn_cell_get_flag (RecnCell *cell)
void	gnc_recn_cell_set_confirm_cb (RecnCell *cell, RecnCellConfirm confirm_cb, gpointer data)
void	gnc_recn_cell_set_string_getter (RecnCell *cell, RecnCellStringGetter getter)
void	gnc_recn_cell_set_valid_flags (RecnCell *cell, const char *flags, char default_flag)
	note that chars is copied into the RecnCell directly, but remains the "property" of the caller.
void	gnc_recn_cell_set_flag_order (RecnCell *cell, const char *flags)
void	gnc_recn_cell_set_read_only (RecnCell *cell, gboolean read_only)

Detailed Description

A "Cell" is an active object which is designed to read a specific kind of user input.

A Cell object has callbacks that are called when the user enters the cell (e.g. by mouse-clicking on a cell in a table, or tabbing into it), when the user attempts to modify text in the cell (e.g. by typing in it), and when the user leaves the cell (e.g. by mouse-clicking elsewhere, or tabbing away).

Special-purpose cells can be created by "inheriting" from the basic cell object. Thus, there are special-purpose cells for handling dates, pull-down menus, text fields with auto-completion from a list of alternatives, monetary amounts, etc.

Cells implementations may or may not contain GUI code. Cells which require only that text be displayed are completely "GUI-independent", that is, they depend on the underlying table to display the text. Cells which require additional GUI elements (such as pull-down menus) must implement the proper GUI handling on their own (using, e.g., GTK).

Macro Definition Documentation

GLYPH_LINK

#define GLYPH_LINK   "\360\237\224\227"

Definition at line 47 of file doclinkcell.h.

GLYPH_PAPERCLIP

#define GLYPH_PAPERCLIP   "\360\237\223\216"

Definition at line 46 of file doclinkcell.h.

Typedef Documentation

CellCreateFunc

typedef BasicCell *(* CellCreateFunc) (void)

Definition at line 172 of file basiccell.h.

CellDestroyFunc

typedef void(* CellDestroyFunc) (BasicCell *cell)

Definition at line 203 of file basiccell.h.

CellDirectUpdateFunc

typedef gboolean(* CellDirectUpdateFunc) (BasicCell *cell, int *cursor_position, int *start_selection, int *end_selection, gpointer gui_data)

Definition at line 191 of file basiccell.h.

CellEnterFunc

typedef gboolean(* CellEnterFunc) (BasicCell *cell, int *cursor_position, int *start_selection, int *end_selection)

Definition at line 177 of file basiccell.h.

CellLeaveFunc

typedef void(* CellLeaveFunc) (BasicCell *cell)

Definition at line 197 of file basiccell.h.

CellModifyVerifyFunc

typedef void(* CellModifyVerifyFunc) (BasicCell *cell, const char *add_str, int add_str_len, const char *new_value, int new_value_len, int *cursor_position, int *start_selection, int *end_selection)

Definition at line 182 of file basiccell.h.

CellMoveFunc

typedef void(* CellMoveFunc) (BasicCell *cell)

Definition at line 201 of file basiccell.h.

CellRealizeFunc

typedef void(* CellRealizeFunc) (BasicCell *cell, gpointer gui_handle)

Definition at line 199 of file basiccell.h.

CellSetValueFunc

typedef void(* CellSetValueFunc) (BasicCell *cell, const char *new_value)

Definition at line 174 of file basiccell.h.

DoclinkcellConfirm

typedef gboolean(* DoclinkcellConfirm) (char old_flag, gpointer data)

Definition at line 50 of file doclinkcell.h.

DoclinkcellStringGetter

typedef const char *(* DoclinkcellStringGetter) (char flag)

Definition at line 49 of file doclinkcell.h.

RecnCellConfirm

typedef gboolean(* RecnCellConfirm) (char old_flag, gpointer data)

Definition at line 45 of file recncell.h.

RecnCellStringGetter

typedef const char *(* RecnCellStringGetter) (char flag)

Definition at line 44 of file recncell.h.

Enumeration Type Documentation

CellAlignment

enum CellAlignment

Definition at line 205 of file basiccell.h.

{
    CELL_ALIGN_RIGHT,
    CELL_ALIGN_CENTER,
    CELL_ALIGN_LEFT
} CellAlignment;

Function Documentation

gnc_basic_cell_destroy()

void gnc_basic_cell_destroy

(

BasicCell *

bcell

)

Definition at line 127 of file basiccell.c.

{
    ENTER(" ");
    if (cell->destroy)
        cell->destroy (cell);
 
    /* give any gui elements a chance to clean up */
    if (cell->gui_destroy)
        (*(cell->gui_destroy)) (cell);
 
    /* free up data strings */
    g_free (cell->value);
    cell->value = NULL;
 
    /* help prevent access to freed memory */
    gnc_basic_cell_clear (cell);
 
    /* free the object itself */
    g_free (cell);
    LEAVE(" ");
}

gnc_basic_cell_get_changed()

gboolean gnc_basic_cell_get_changed

(

BasicCell *

cell

)

Definition at line 250 of file basiccell.c.

{
    if (!cell) return FALSE;
 
    return cell->changed;
}

gnc_basic_cell_get_conditionally_changed()

gboolean gnc_basic_cell_get_conditionally_changed

(

BasicCell *

cell

)

Definition at line 258 of file basiccell.c.

{
    if (!cell) return FALSE;
 
    return cell->conditionally_changed;
}

gnc_basic_cell_get_value()

const char * gnc_basic_cell_get_value

(

BasicCell *

cell

)

Definition at line 224 of file basiccell.c.

{
    g_return_val_if_fail (cell != NULL, NULL);
 
    return cell->value;
}

gnc_basic_cell_has_name()

gboolean gnc_basic_cell_has_name	(	BasicCell *	cell,
		const char *	name
	)

Definition at line 160 of file basiccell.c.

{
    if (!cell) return FALSE;
    if (!name) return FALSE;
    if (!cell->cell_name) return FALSE;
 
    return (strcmp (name, cell->cell_name) == 0);
}

gnc_basic_cell_has_type_name()

gboolean gnc_basic_cell_has_type_name	(	BasicCell *	cell,
		const gchar *	type_name
	)

Definition at line 181 of file basiccell.c.

{
    if (!cell) return FALSE;
    if (!type_name) return FALSE;
    if (!cell->cell_type_name) return FALSE;
 
    return (g_strcmp0 (type_name, cell->cell_type_name));
}

gnc_basic_cell_init()

void gnc_basic_cell_init

(

BasicCell *

bcell

)

Definition at line 116 of file basiccell.c.

{
    gnc_basic_cell_clear (cell);
 
    cell->gui_realize = gnc_basic_cell_gui_realize;
    cell->gui_destroy = gnc_basic_cell_gui_destroy;
 
    cell->value = g_strdup ("");
}

gnc_basic_cell_new()

BasicCell * gnc_basic_cell_new

(

void

)

Definition at line 74 of file basiccell.c.

{
    BasicCell * cell;
 
    cell = g_new0 (BasicCell, 1);
 
    gnc_basic_cell_init (cell);
 
    return cell;
}

gnc_basic_cell_set_alignment()

void gnc_basic_cell_set_alignment	(	BasicCell *	cell,
		CellAlignment	alignment
	)

Definition at line 202 of file basiccell.c.

{
    if (!cell) return;
    cell->alignment = alignment;
}

gnc_basic_cell_set_changed()

void gnc_basic_cell_set_changed	(	BasicCell *	cell,
		gboolean	changed
	)

Definition at line 266 of file basiccell.c.

{
    if (!cell) return;
 
    cell->changed = changed;
}

gnc_basic_cell_set_conditionally_changed()

void gnc_basic_cell_set_conditionally_changed	(	BasicCell *	cell,
		gboolean	changed
	)

Definition at line 274 of file basiccell.c.

{
    if (!cell) return;
 
    cell->conditionally_changed = changed;
}

gnc_basic_cell_set_expandable()

void gnc_basic_cell_set_expandable	(	BasicCell *	cell,
		gboolean	expandable
	)

Definition at line 210 of file basiccell.c.

{
    if (!cell) return;
    cell->expandable = expandable;
}

gnc_basic_cell_set_name()

void gnc_basic_cell_set_name	(	BasicCell *	cell,
		const char *	name
	)

Definition at line 150 of file basiccell.c.

{
    if (!cell) return;
    if (cell->cell_name == name) return;
 
    g_free (cell->cell_name);
    cell->cell_name = g_strdup (name);
}

gnc_basic_cell_set_sample_text()

void gnc_basic_cell_set_sample_text	(	BasicCell *	cell,
		const char *	sample_text
	)

Definition at line 191 of file basiccell.c.

{
    if (!cell) return;
    if (cell->sample_text == sample_text) return;
 
    g_free (cell->sample_text);
    cell->sample_text = g_strdup (sample_text);
}

gnc_basic_cell_set_span()

void gnc_basic_cell_set_span	(	BasicCell *	cell,
		gboolean	span
	)

Definition at line 217 of file basiccell.c.

{
    if (!cell) return;
    cell->span = span;
}

gnc_basic_cell_set_type_name()

void gnc_basic_cell_set_type_name	(	BasicCell *	cell,
		const gchar *	type_name
	)

Definition at line 171 of file basiccell.c.

{
    if (!cell) return;
    if (cell->cell_type_name == type_name) return;
 
    g_free (cell->cell_type_name);
    cell->cell_type_name = g_strdup(type_name);
}

gnc_basic_cell_set_value()

void gnc_basic_cell_set_value	(	BasicCell *	bcell,
		const char *	value
	)

Definition at line 232 of file basiccell.c.

{
    CellSetValueFunc cb;
 
    cb = cell->set_value;
    if (cb)
    {
        /* avoid recursion by disabling the
         * callback while it's being called. */
        cell->set_value = NULL;
        cb (cell, val);
        cell->set_value = cb;
    }
    else
        gnc_basic_cell_set_value_internal (cell, val);
}

gnc_basic_cell_set_value_internal()

void gnc_basic_cell_set_value_internal	(	BasicCell *	bcell,
		const char *	value
	)

Definition at line 282 of file basiccell.c.

{
    if (value == NULL)
        value = "";
 
    /* If the caller tries to set the value with our own value then do
     * nothing because we have no work to do (or, at least, all the work
     * will result in the status-quo, so why do anything?)  See bug
     * #103174 and the description in the changelog on 2003-09-04.
     */
    if (cell->value == value)
        return;
 
    g_free (cell->value);
    cell->value = g_strdup (value);
    cell->value_chars = g_utf8_strlen(value, -1);
}

gnc_basic_cell_validate()

char * gnc_basic_cell_validate	(	BasicCell *	bcell,
		GNCPrintAmountInfo	print_info,
		const char *	change,
		const char *	newval,
		const char *	toks,
		gint *	cursor_position
	)

Definition at line 301 of file basiccell.c.

{
    struct lconv *lc = gnc_localeconv ();
    gunichar decimal_point;
    gunichar thousands_sep;
    const char *symbol = NULL;
    char *tokens;
 
    if (print_info.monetary)
    {
        const gnc_commodity *comm = print_info.commodity;
 
        decimal_point = g_utf8_get_char (lc->mon_decimal_point);
        thousands_sep = g_utf8_get_char (lc->mon_thousands_sep);
 
        if (comm)
            symbol = gnc_commodity_get_nice_symbol (comm);
        else
            symbol = gnc_commodity_get_nice_symbol (gnc_default_currency ());
 
        tokens = g_strconcat (toks, symbol, NULL);
    }
    else
    {
        decimal_point = g_utf8_get_char (lc->decimal_point);
        thousands_sep = g_utf8_get_char (lc->thousands_sep);
 
        tokens = g_strdup (toks);
    }
 
    for (const char *c = change; c && *c; c = g_utf8_next_char (c))
    {
        gunichar uc = g_utf8_get_char (c);
        if (!g_unichar_isdigit (uc) &&
            !g_unichar_isspace (uc) &&
            !g_unichar_isalpha (uc) &&
            (decimal_point != uc) &&
            (thousands_sep != uc) &&
            (g_utf8_strchr (tokens, -1, uc) == NULL))
        {
            g_free (tokens);
            return NULL;
        }
    }
    g_free (tokens);
 
    gnc_filter_text_set_cursor_position (newval, symbol, cursor_position);
 
    return gnc_filter_text_for_currency_symbol (newval, symbol);
}

gnc_cell_factory_add_cell_type()

void gnc_cell_factory_add_cell_type	(	CellFactory *	cf,
		const char *	cell_type_name,
		CellCreateFunc	cell_creator
	)

Definition at line 77 of file cell-factory.c.

{
    CellRecord *cr;
 
    g_return_if_fail (cell_type_name != NULL);
    g_return_if_fail (cell_creator != NULL);
 
    cr = g_hash_table_lookup (cf->cell_table, cell_type_name);
 
    if (cr)
    {
        g_hash_table_remove (cf->cell_table, cell_type_name);
        g_free (cr->cell_type_name);
    }
    else
        cr = g_new0 (CellRecord, 1);
 
    cr->cell_type_name = g_strdup (cell_type_name);
    cr->creator = cell_creator;
 
    g_hash_table_insert (cf->cell_table, cr->cell_type_name, cr);
}

gnc_cell_factory_destroy()

void gnc_cell_factory_destroy

(

CellFactory *

cf

)

Definition at line 67 of file cell-factory.c.

{
    if (!cf) return;
 
    g_hash_table_foreach (cf->cell_table, cell_table_destroy_helper, NULL);
 
    g_free (cf);
}

gnc_cell_factory_make_cell()

BasicCell * gnc_cell_factory_make_cell	(	CellFactory *	cf,
		const char *	cell_type_name
	)

Definition at line 103 of file cell-factory.c.

{
    CellRecord *cr;
 
    g_return_val_if_fail (cf != NULL, NULL);
    g_return_val_if_fail (cell_type_name != NULL, NULL);
 
    cr = g_hash_table_lookup (cf->cell_table, cell_type_name);
    g_return_val_if_fail (cr != NULL, NULL);
 
    return cr->creator ();
}

gnc_cell_factory_new()

CellFactory * gnc_cell_factory_new

(

void

)

Definition at line 46 of file cell-factory.c.

{
    CellFactory *cf;
 
    cf = g_new0 (CellFactory, 1);
 
    cf->cell_table = g_hash_table_new (g_str_hash, g_str_equal);
 
    return cf;
}

gnc_cell_name_equal()

gboolean gnc_cell_name_equal	(	const char *	cell_name_1,
		const char *	cell_name_2
	)

Definition at line 51 of file basiccell.c.

{
    return (g_strcmp0 (cell_name_1, cell_name_2) == 0);
}

gnc_checkbox_cell_get_flag()

gboolean gnc_checkbox_cell_get_flag

(

CheckboxCell *

cell

)

Definition at line 107 of file checkboxcell.c.

{
    g_return_val_if_fail (cell != NULL, '\0');
 
    return cell->flag;
}

gnc_checkbox_cell_get_string()

const char * gnc_checkbox_cell_get_string

(

gboolean

flag

)

Definition at line 116 of file checkboxcell.c.

{
#ifndef MAC_INTEGRATION
    const char* checked = UNICODE_CHECKMARK;
#else
    const char* checked = "X";
#endif
    return (flag ? checked : " ");
}

gnc_checkbox_cell_new()

BasicCell * gnc_checkbox_cell_new

(

void

)

Definition at line 82 of file checkboxcell.c.

{
    CheckboxCell * cell;
 
    cell = g_new0 (CheckboxCell, 1);
 
    gnc_checkbox_cell_init (cell);
 
    return &cell->cell;
}

gnc_checkbox_cell_set_flag()

void gnc_checkbox_cell_set_flag	(	CheckboxCell *	cell,
		gboolean	flag
	)

Definition at line 94 of file checkboxcell.c.

{
    const char *string;
 
    g_return_if_fail (cell != NULL);
 
    cell->flag = flag;
    string = gnc_checkbox_cell_get_string (flag);
 
    gnc_basic_cell_set_value_internal (&cell->cell, string);
}

gnc_combo_cell_add_account_menu_item()

void gnc_combo_cell_add_account_menu_item	(	ComboCell *	cell,
		char *	menustr
	)

Add a 'account name' menu item to the list.

When testing for equality with the currently selected item, this function will ignore the characters normally used to separate account names.

Definition at line 463 of file combocell-gnome.c.

{
    PopBox* box;
 
    if (cell == NULL)
        return;
    if (menustr == NULL)
        return;
 
    box = cell->cell.gui_private;
 
    if (box->item_list != NULL)
    {
        block_list_signals (cell);
 
        gnc_item_list_append (box->item_list, menustr);
        if (cell->cell.value)
        {
            gchar* menu_copy = g_strdup (menustr);
            gchar* value_copy = g_strdup (cell->cell.value);
            g_strdelimit (menu_copy, "-:/\\.", ' ');
            g_strdelimit (value_copy, "-:/\\.", ' ');
            if (strcmp (menu_copy, value_copy) == 0)
            {
                gnc_combo_cell_set_value (cell, menustr);
                gnc_item_list_select (box->item_list, menustr);
            }
            g_free (value_copy);
            g_free (menu_copy);
        }
        unblock_list_signals (cell);
    }
 
    /* If we're going to be using a pre-fab quickfill,
     * then don't fill it in here */
    if (FALSE == box->use_quickfill_cache)
    {
        gnc_quickfill_insert (box->qf, menustr, QUICKFILL_ALPHA);
    }
}

gnc_combo_cell_add_ignore_string()

void gnc_combo_cell_add_ignore_string	(	ComboCell *	cell,
		const char *	ignore_string
	)

Add a string to a list of strings which, if the cell has that value, will cause the cell to be uneditable on 'enter'.

Definition at line 1131 of file combocell-gnome.c.

{
    PopBox* box;
 
    if (cell == NULL)
        return;
 
    if (!ignore_string)
        return;
 
    box = cell->cell.gui_private;
 
    box->ignore_strings = g_list_prepend (box->ignore_strings,
                                          g_strdup (ignore_string));
}

gnc_combo_cell_add_menu_item()

void gnc_combo_cell_add_menu_item	(	ComboCell *	cell,
		const char *	menustr
	)

Add a menu item to the list.

Definition at line 424 of file combocell-gnome.c.

{
    PopBox* box;
 
    if (cell == NULL)
        return;
    if (menustr == NULL)
        return;
 
    box = cell->cell.gui_private;
 
    if (box->item_list != NULL)
    {
        block_list_signals (cell);
 
        gnc_item_list_append (box->item_list, menustr);
        if (cell->cell.value &&
            (strcmp (menustr, cell->cell.value) == 0))
            gnc_item_list_select (box->item_list, menustr);
 
        unblock_list_signals (cell);
    }
    else
    {
        GtkTreeIter iter;
 
        gtk_list_store_append (box->tmp_store, &iter);
        gtk_list_store_set (box->tmp_store, &iter, 0, menustr, -1);
    }
 
    /* If we're going to be using a pre-fab quickfill,
     * then don't fill it in here */
    if (FALSE == box->use_quickfill_cache)
    {
        gnc_quickfill_insert (box->qf, menustr, QUICKFILL_ALPHA);
    }
}

gnc_combo_cell_clear_menu()

void gnc_combo_cell_clear_menu

(

ComboCell *

cell

)

Definition at line 366 of file combocell-gnome.c.

{
    PopBox* box;
 
    if (cell == NULL)
        return;
 
    box = cell->cell.gui_private;
    if (box == NULL)
        return;
 
    /* Don't destroy the qf if its not ours to destroy */
    if (FALSE == box->use_quickfill_cache)
    {
        gnc_quickfill_destroy (box->qf);
        box->qf = gnc_quickfill_new();
    }
 
    if (box->item_list != NULL)
    {
        block_list_signals (cell);
 
        gnc_item_list_clear (box->item_list);
        gnc_item_edit_hide_popup (box->item_edit);
        box->list_popped = FALSE;
        unblock_list_signals (cell);
    }
    else
        gtk_list_store_clear (box->tmp_store);
}

gnc_combo_cell_init()

void gnc_combo_cell_init

(

ComboCell *

cell

)

Definition at line 133 of file combocell-gnome.c.

{
    PopBox* box;
 
    gnc_basic_cell_init (& (cell->cell));
 
    cell->cell.is_popup = TRUE;
 
    cell->cell.destroy = gnc_combo_cell_destroy;
 
    cell->cell.gui_realize = gnc_combo_cell_gui_realize;
    cell->cell.gui_destroy = gnc_combo_cell_gui_destroy;
 
    box = g_new0 (PopBox, 1);
 
    box->sheet = NULL;
    box->item_edit = NULL;
    box->item_list = NULL;
    box->tmp_store = gtk_list_store_new (1, G_TYPE_STRING);
    box->signals_connected = FALSE;
    box->list_popped = FALSE;
    box->autosize = FALSE;
 
    cell->cell.gui_private = box;
 
    box->qf = gnc_quickfill_new();
    box->use_quickfill_cache = FALSE;
 
    box->in_list_select = FALSE;
 
    box->strict = TRUE;
 
    box->complete_char = '\0';
 
    box->ignore_strings = NULL;
}

gnc_combo_cell_new()

BasicCell * gnc_combo_cell_new

(

void

)

Definition at line 119 of file combocell-gnome.c.

{
    ComboCell* cell;
 
    g_once (&auto_pop_init_once, gnc_combo_cell_autopop_init, NULL);
 
    cell = g_new0 (ComboCell, 1);
 
    gnc_combo_cell_init (cell);
 
    return &cell->cell;
}

gnc_combo_cell_set_autosize()

void gnc_combo_cell_set_autosize	(	ComboCell *	cell,
		gboolean	autosize
	)

Determines whether the popup list autosizes itself or uses all available space.

FALSE by default.

Definition at line 1149 of file combocell-gnome.c.

{
    PopBox* box;
 
    if (!cell)
        return;
 
    box = cell->cell.gui_private;
    if (!box)
        return;
 
    box->autosize = autosize;
}

gnc_combo_cell_set_complete_char()

void gnc_combo_cell_set_complete_char	(	ComboCell *	cell,
		gunichar	complete_char
	)

Sets a character used for special completion processing.

Definition at line 1118 of file combocell-gnome.c.

{
    PopBox* box;
 
    if (cell == NULL)
        return;
 
    box = cell->cell.gui_private;
 
    box->complete_char = complete_char;
}

gnc_combo_cell_set_sort_enabled()

void gnc_combo_cell_set_sort_enabled	(	ComboCell *	cell,
		gboolean	enabled
	)

Enable sorting of the menu item's contents.

Loading the item is much faster with sorting disabled.

Definition at line 349 of file combocell-gnome.c.

{
    PopBox* box;
 
    if (cell == NULL)
        return;
 
    box = cell->cell.gui_private;
    if (box->item_list == NULL)
        return;
 
    block_list_signals (cell);
    gnc_item_list_set_sort_column (box->item_list, 0);
    unblock_list_signals (cell);
}

gnc_combo_cell_set_strict()

void gnc_combo_cell_set_strict	(	ComboCell *	cell,
		gboolean	strict
	)

Determines whether the cell will accept strings not in the menu.

Defaults to strict, i.e., only menu items are accepted.

Definition at line 1105 of file combocell-gnome.c.

{
    PopBox* box;
 
    if (cell == NULL)
        return;
 
    box = cell->cell.gui_private;
 
    box->strict = strict;
}

gnc_combo_cell_set_value()

void gnc_combo_cell_set_value	(	ComboCell *	cell,
		const char *	value
	)

Definition at line 505 of file combocell-gnome.c.

{
    gnc_basic_cell_set_value (&cell->cell, str);
}

gnc_combo_cell_use_list_store_cache()

void gnc_combo_cell_use_list_store_cache	(	ComboCell *	cell,
		gpointer	data
	)

Definition at line 416 of file combocell-gnome.c.

{
    if (cell == NULL) return;
 
    cell->shared_store = data;
}

gnc_combo_cell_use_quickfill_cache()

void gnc_combo_cell_use_quickfill_cache	(	ComboCell *	cell,
		QuickFill *	shared_qf
	)

Tell the combocell to use a shared QuickFill object.

Using this routine can dramatically improve performance when creating combocells with a large number of entries. For example, users with thousands of accounts are complaining about 10-second register startup times, of which 98% of the cpu is spent building the multi-thousand entry quickfill. When a shared quickfill is specified, the combo-cell will not add to nor delete the quickfill; it is the users resonsibility to manage the quickfill object. The combocell will not make a copy of the quickfill.

Definition at line 398 of file combocell-gnome.c.

{
    PopBox* box;
 
    if (cell == NULL) return;
 
    box = cell->cell.gui_private;
    if (NULL == box) return;
 
    if (FALSE == box->use_quickfill_cache)
    {
        box->use_quickfill_cache = TRUE;
        gnc_quickfill_destroy (box->qf);
    }
    box->qf = shared_qf;
}

gnc_completion_cell_add_menu_item()

void gnc_completion_cell_add_menu_item	(	CompletionCell *	cell,
		const char *	menustr
	)

Add a menu item to the hash table list.

Definition at line 466 of file completioncell-gnome.c.

{
    if (!cell || !menustr)
        return;
 
    PopBox* box = cell->cell.gui_private;
 
    if (box->item_hash)
    {
        gpointer value = g_hash_table_lookup (box->item_hash, menustr);
        gboolean update = FALSE;
        if (value)
        {
            if (!box->register_is_reversed)
                update = TRUE;
        }
        else
            update = TRUE;
 
        if (update)
        {
            g_hash_table_insert (box->item_hash, g_strdup (menustr),
                                 GINT_TO_POINTER(box->occurrence));
        }
        box->occurrence++;
    }
}

gnc_completion_cell_clear_menu()

void gnc_completion_cell_clear_menu

(

CompletionCell *

cell

)

Definition at line 448 of file completioncell-gnome.c.

{
    if (!cell)
        return;
 
    PopBox* box = cell->cell.gui_private;
    if (!box)
        return;
 
    if (box->item_list)
    {
        g_hash_table_remove_all (box->item_hash);
        item_store_clear (cell);
        box->occurrence = 0;
    }
}

gnc_completion_cell_init()

void gnc_completion_cell_init

(

CompletionCell *

cell

)

Definition at line 106 of file completioncell-gnome.c.

{
    gnc_basic_cell_init (& (cell->cell));
 
    cell->cell.is_popup = TRUE;
 
    cell->cell.destroy = gnc_completion_cell_destroy;
 
    cell->cell.gui_realize = gnc_completion_cell_gui_realize;
    cell->cell.gui_destroy = gnc_completion_cell_gui_destroy;
 
    PopBox* box = g_new0 (PopBox, 1);
 
    box->sheet = NULL;
    box->item_edit = NULL;
    box->item_list = NULL;
    box->item_store = NULL;
 
    box->signals_connected = FALSE;
    box->list_popped = FALSE;
    box->autosize = FALSE;
    box->register_is_reversed = FALSE;
 
    box->sort_enabled = FALSE;
 
    cell->cell.gui_private = box;
 
    box->strict = FALSE;
    box->in_list_select = FALSE;
    box->occurrence = 0;
 
    box->item_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
}

gnc_completion_cell_new()

BasicCell * gnc_completion_cell_new

(

void

)

Definition at line 98 of file completioncell-gnome.c.

{
    CompletionCell* cell = g_new0 (CompletionCell, 1);
    gnc_completion_cell_init (cell);
    return &cell->cell;
}

gnc_completion_cell_reverse_sort()

void gnc_completion_cell_reverse_sort	(	CompletionCell *	cell,
		gboolean	is_reversed
	)

Register the sort direction.

Used to determine in what order the completion should present the list. FALSE by default

Definition at line 820 of file completioncell-gnome.c.

{
    if (!cell)
        return;
 
    PopBox* box = cell->cell.gui_private;
 
    if (is_reversed != box->register_is_reversed)
    {
        gnc_completion_cell_clear_menu (cell);
        box->register_is_reversed = is_reversed;
        box->occurrence = 0;
    }
}

gnc_completion_cell_set_autosize()

void gnc_completion_cell_set_autosize	(	CompletionCell *	cell,
		gboolean	autosize
	)

Determines whether the popup list autosizes itself or uses all available space.

FALSE by default.

Definition at line 1065 of file completioncell-gnome.c.

{
    if (!cell)
        return;
 
    PopBox* box = cell->cell.gui_private;
    if (!box)
        return;
 
    box->autosize = autosize;
}

gnc_completion_cell_set_sort_enabled()

void gnc_completion_cell_set_sort_enabled	(	CompletionCell *	cell,
		gboolean	enabled
	)

Enable sorting of the menu item's contents.

Definition at line 394 of file completioncell-gnome.c.

{
    if (!cell)
        return;
 
    PopBox* box = cell->cell.gui_private;
    box->sort_enabled = enabled;
}

gnc_completion_cell_set_strict()

void gnc_completion_cell_set_strict	(	CompletionCell *	cell,
		gboolean	strict
	)

Determines whether the cell will accept strings not in the menu.

Defaults to strict, i.e., only menu items are accepted.

Definition at line 1052 of file completioncell-gnome.c.

{
    if (!cell)
        return;
 
    PopBox* box = cell->cell.gui_private;
    if (!box)
        return;
 
    box->strict = strict;
}

gnc_completion_cell_set_value()

void gnc_completion_cell_set_value	(	CompletionCell *	cell,
		const char *	value
	)

Definition at line 496 of file completioncell-gnome.c.

{
    if (!cell || !str)
        return;
 
    gnc_basic_cell_set_value (&cell->cell, str);
}

gnc_date_cell_commit()

void gnc_date_cell_commit

(

DateCell *

cell

)

Commits any pending changes to the value of the cell.

That is, it will take the cells current string value, and parse it into a month-day-year value.

Why is this needed? Basically, while the user is typing into the cell, we do not even try to parse the date, lest we confuse things royally. Normally, when the user leaves this cell, and moves to another, we parse the date and print it nicely and cleanly into the cell. But it can happen that we want to get the accurate contents of the date cell before we've left it, e.g. if the user has clicked on the "commit" button. This is the routine to call for that.

Definition at line 462 of file datecell-gnome.c.

{
    PopBox *box = cell->cell.gui_private;
    char buff[DATE_BUF];
 
    if (!cell)
        return;
 
    gnc_parse_date (&(box->date), cell->cell.value, FALSE);
 
    qof_print_date_dmy_buff (buff, MAX_DATE_LENGTH,
                             box->date.tm_mday,
                             box->date.tm_mon + 1,
                             box->date.tm_year + 1900);
 
    gnc_basic_cell_set_value_internal (&cell->cell, buff);
 
    if (!box->date_picker)
        return;
 
    block_picker_signals (cell);
    gnc_date_picker_set_date (box->date_picker,
                              box->date.tm_mday,
                              box->date.tm_mon,
                              box->date.tm_year + 1900);
    unblock_picker_signals (cell);
}

gnc_date_cell_get_date()

void gnc_date_cell_get_date	(	DateCell *	cell,
		time64 *	time,
		gboolean	warn
	)

Set a time64 to the value in the DateCell.

Parameters

cell	The DateCell
time	A time64* to which the function will write the time.
warn	Whether to warn of parse errors or silently change to a valid one.

Definition at line 737 of file datecell-gnome.c.

{
    PopBox *box = cell->cell.gui_private;
    if (!cell || !time)
        return;
 
    gnc_parse_date (&(box->date), cell->cell.value, warn);
    *time = gnc_mktime (&box->date);
}

gnc_date_cell_new()

BasicCell * gnc_date_cell_new

(

void

)

installs a callback to handle date recording

Definition at line 241 of file datecell-gnome.c.

{
    DateCell *cell;
 
    cell = g_new0 (DateCell, 1);
 
    gnc_date_cell_init (cell);
 
    return &cell->cell;
}

gnc_date_cell_set_value()

void gnc_date_cell_set_value	(	DateCell *	cell,
		int	day,
		int	mon,
		int	year
	)

Accepts a numeric date and sets the contents of the date cell to that value.

The value day, month, year should follow the regular written conventions.

Parameters

cell	The DateCell to set
day	The day of the month, 1..31
month	The month of the year, 1..12
year	The year, 4 digits, common era

Definition at line 406 of file datecell-gnome.c.

{
    PopBox *box = cell->cell.gui_private;
    struct tm dada;
    char buff[DATE_BUF];
 
    dada.tm_mday = day;
    dada.tm_mon  = mon - 1;
    dada.tm_year = year - 1900;
 
    gnc_tm_set_day_start(&dada);
    gnc_mktime (&dada);
 
    box->date.tm_mday = dada.tm_mday;
    box->date.tm_mon  = dada.tm_mon;
    box->date.tm_year = dada.tm_year;
 
    qof_print_date_dmy_buff (buff, MAX_DATE_LENGTH, dada.tm_mday, dada.tm_mon + 1, dada.tm_year + 1900);
 
    gnc_basic_cell_set_value_internal (&cell->cell, buff);
 
    if (!box->date_picker)
        return;
 
    block_picker_signals (cell);
    gnc_date_picker_set_date (box->date_picker, day, mon - 1, year);
    unblock_picker_signals (cell);
}

gnc_date_cell_set_value_secs()

void gnc_date_cell_set_value_secs	(	DateCell *	cell,
		time64	secs
	)

Sets the contents of the cell with seconds before or since the Unix epoch.

Parameters

cell	The DateCell to set
secs	Seconds before or since the Unix epoch, 1 January 1970 CE.

Definition at line 436 of file datecell-gnome.c.

{
    PopBox *box = cell->cell.gui_private;
    char buff[DATE_BUF];
 
    gnc_localtime_r (&secs, &(box->date));
 
    qof_print_date_dmy_buff (buff, MAX_DATE_LENGTH,
                             box->date.tm_mday,
                             box->date.tm_mon + 1,
                             box->date.tm_year + 1900);
 
    gnc_basic_cell_set_value_internal (&cell->cell, buff);
 
    if (!box->date_picker)
        return;
 
    block_picker_signals (cell);
    gnc_date_picker_set_date (box->date_picker,
                              box->date.tm_mday,
                              box->date.tm_mon,
                              box->date.tm_year + 1900);
    unblock_picker_signals (cell);
}

gnc_doclink_cell_get_flag()

char gnc_doclink_cell_get_flag

(

Doclinkcell *

cell

)

Definition at line 209 of file doclinkcell.c.

{
    g_return_val_if_fail (cell != NULL, '\0');
 
    return cell->flag;
}

gnc_doclink_cell_new()

BasicCell * gnc_doclink_cell_new

(

void

)

Definition at line 159 of file doclinkcell.c.

{
    Doclinkcell * cell;
 
    cell = g_new0 (Doclinkcell, 1);
 
    gnc_doclink_cell_init (cell);
 
    return &cell->cell;
}

gnc_doclink_cell_set_confirm_cb()

void gnc_doclink_cell_set_confirm_cb	(	Doclinkcell *	cell,
		DoclinkcellConfirm	confirm_cb,
		gpointer	data
	)

Definition at line 226 of file doclinkcell.c.

{
    g_return_if_fail (cell != NULL);
 
    cell->confirm_cb = confirm_cb;
    cell->confirm_data = data;
}

gnc_doclink_cell_set_flag()

void gnc_doclink_cell_set_flag	(	Doclinkcell *	cell,
		char	flag
	)

Definition at line 196 of file doclinkcell.c.

{
    const char *string;
 
    g_return_if_fail (cell != NULL);
 
    cell->flag = flag;
    string = gnc_doclink_cell_get_string (cell, flag);
 
    gnc_basic_cell_set_value_internal (&cell->cell, string);
}

gnc_doclink_cell_set_flag_order()

void gnc_doclink_cell_set_flag_order	(	Doclinkcell *	cell,
		const char *	flags
	)

Definition at line 247 of file doclinkcell.c.

{
    g_return_if_fail (cell != NULL);
    g_return_if_fail (flags != NULL);
 
    cell->flag_order = (char *)flags;
}

gnc_doclink_cell_set_read_only()

void gnc_doclink_cell_set_read_only	(	Doclinkcell *	cell,
		gboolean	read_only
	)

Definition at line 256 of file doclinkcell.c.

{
    g_return_if_fail (cell != NULL);
 
    cell->read_only = read_only;
}

gnc_doclink_cell_set_string_getter()

void gnc_doclink_cell_set_string_getter	(	Doclinkcell *	cell,
		DoclinkcellStringGetter	getter
	)

Definition at line 217 of file doclinkcell.c.

{
    g_return_if_fail (cell != NULL);
 
    cell->get_string = get_string;
}

gnc_doclink_cell_set_use_glyphs()

void gnc_doclink_cell_set_use_glyphs

(

Doclinkcell *

cell

)

Definition at line 264 of file doclinkcell.c.

{
#ifdef MAC_INTEGRATION
    cell->use_glyphs = FALSE;
#else 
    gboolean use_glyphs = TRUE;
    gchar *test_text;
    GtkWidget *label;
    PangoLayout *test_layout;
    gint count;
 
    g_return_if_fail (cell != NULL);
 
    label = gtk_label_new (NULL);
    test_text = g_strconcat (GLYPH_LINK, ",", GLYPH_PAPERCLIP, NULL);
    test_layout = gtk_widget_create_pango_layout (GTK_WIDGET (label), test_text);
 
    pango_layout_set_text (test_layout, test_text, strlen (test_text));
 
    count = pango_layout_get_unknown_glyphs_count (test_layout);
 
    if (count != 0)
        use_glyphs = FALSE;
 
    g_object_unref (test_layout);
    g_free (test_text);
 
    cell->use_glyphs = use_glyphs;
#endif
}

gnc_doclink_cell_set_valid_flags()

void gnc_doclink_cell_set_valid_flags	(	Doclinkcell *	cell,
		const char *	flags,
		char	default_flag
	)

note that

Parameters

flags

is copied into the RecnCell directly, but remains the "property" of the caller. The caller must maintain the chars pointer, and the caller must setup a mechanism to 'free' the chars pointer. The rationale is that you may have many Doclinkcell objects that use the same set of flags.

Definition at line 236 of file doclinkcell.c.

{
    g_return_if_fail (cell != NULL);
    g_return_if_fail (flags != NULL);
 
    cell->valid_flags = (char *)flags;
    cell->default_flag = default_flag;
}

gnc_doclink_get_glyph_from_flag()

const char * gnc_doclink_get_glyph_from_flag

(

char

link_flag

)

Definition at line 53 of file doclinkcell.c.

{
    switch (link_flag)
    {
    case WLINK:
        return GLYPH_LINK;
    case FLINK:
        return GLYPH_PAPERCLIP;
    default:
        return " ";
    }
}

gnc_doclink_get_use_glyphs()

gboolean gnc_doclink_get_use_glyphs

(

Doclinkcell *

cell

)

Definition at line 78 of file doclinkcell.c.

{
    return cell->use_glyphs;
}

gnc_formula_cell_new()

BasicCell * gnc_formula_cell_new

(

void

)

Definition at line 63 of file formulacell.c.

{
    FormulaCell *fc = g_new0( FormulaCell, 1 );
    gnc_formula_cell_init( fc );
    return &fc->cell;
}

gnc_formula_cell_set_value()

void gnc_formula_cell_set_value	(	FormulaCell *	fc,
		const char *	newVal
	)

Definition at line 85 of file formulacell.c.

{
    DEBUG("got value [%s]", newVal);
    gnc_formula_cell_set_value_internal( &fc->cell, newVal );
}

gnc_num_cell_new()

BasicCell * gnc_num_cell_new

(

void

)

Definition at line 178 of file numcell.c.

{
    NumCell *cell;
 
    cell = g_new0 (NumCell, 1);
 
    gnc_num_cell_init (cell);
 
    return &cell->cell;
}

gnc_num_cell_set_last_num()

gboolean gnc_num_cell_set_last_num	(	NumCell *	cell,
		const char *	str
	)

Definition at line 215 of file numcell.c.

{
    long int number;
 
    if (!cell)
        return FALSE;
 
    if (gnc_parse_num (str, &number))
    {
        cell->next_num = number + 1;
        cell->next_num_set = TRUE;
        return TRUE;
    }
 
    return FALSE;
}

gnc_num_cell_set_value()

void gnc_num_cell_set_value	(	NumCell *	cell,
		const char *	str
	)

Definition at line 206 of file numcell.c.

{
    if (!cell)
        return;
 
    gnc_num_cell_set_value_internal (&cell->cell, str);
}

gnc_price_cell_blank()

void gnc_price_cell_blank

(

PriceCell *

cell

)

Sets the cell as blank, regardless of the blank_zero value.

Definition at line 251 of file pricecell.c.

{
    if (cell == NULL)
        return;
 
    cell->amount = gnc_numeric_zero ();
    cell->need_to_parse = FALSE;
 
    gnc_basic_cell_set_value_internal (&cell->cell, "");
}

gnc_price_cell_get_value()

gnc_numeric gnc_price_cell_get_value

(

PriceCell *

cell

)

return the value of a price cell

Definition at line 208 of file pricecell.c.

{
    if (cell == NULL)
        return gnc_numeric_zero ();
 
    gnc_price_cell_parse (cell, FALSE);
 
    return cell->amount;
}

gnc_price_cell_new()

BasicCell * gnc_price_cell_new

(

void

)

installs a callback to handle price recording

Definition at line 168 of file pricecell.c.

{
    PriceCell *cell;
 
    cell = g_new0 (PriceCell, 1);
 
    gnc_price_cell_init (cell);
 
    return &cell->cell;
}

gnc_price_cell_set_blank_zero()

void gnc_price_cell_set_blank_zero	(	PriceCell *	cell,
		gboolean	blank_zero
	)

determines whether 0 values are left blank or printed.

defaults to true.

Definition at line 263 of file pricecell.c.

{
    if (cell == NULL)
        return;
 
    cell->blank_zero = blank_zero;
}

gnc_price_cell_set_debt_credit_value()

void gnc_price_cell_set_debt_credit_value	(	PriceCell *	debit,
		PriceCell *	credit,
		gnc_numeric	amount
	)

updates two cells; the deb cell if amt is negative, the credit cell if amount is positive, and makes the other cell blank.

Definition at line 281 of file pricecell.c.

{
    /* debits are positive, credits are negative */
    if (gnc_numeric_positive_p (amount))
    {
        gnc_price_cell_set_value (debit, amount);
        gnc_price_cell_set_value (credit, gnc_numeric_zero ());
    }
    else
    {
        gnc_price_cell_set_value (debit, gnc_numeric_zero ());
        gnc_price_cell_set_value (credit, gnc_numeric_neg (amount));
    }
}

gnc_price_cell_set_fraction()

void gnc_price_cell_set_fraction	(	PriceCell *	cell,
		int	fraction
	)

Sets the fraction used for rounding.

If 0, no rounding is performed.

Definition at line 242 of file pricecell.c.

{
    if (cell == NULL)
        return;
 
    cell->fraction = ABS (fraction);
}

gnc_price_cell_set_print_info()

void gnc_price_cell_set_print_info	(	PriceCell *	cell,
		GNCPrintAmountInfo	print_info
	)

set the printing context of the price cell

Definition at line 272 of file pricecell.c.

{
    if (cell == NULL)
        return;
 
    cell->print_info = print_info;
}

gnc_price_cell_set_value()

gboolean gnc_price_cell_set_value	(	PriceCell *	cell,
		gnc_numeric	amount
	)

updates amount, returns TRUE if string representation actually changed

Definition at line 219 of file pricecell.c.

{
    const char *buff;
 
    if (cell == NULL)
        return FALSE;
 
    if (cell->fraction > 0)
        amount = gnc_numeric_convert (amount, cell->fraction, GNC_HOW_RND_ROUND_HALF_UP);
 
    cell->amount = amount;
    buff = gnc_price_cell_print_value (cell);
    cell->need_to_parse = FALSE;
 
    if (g_strcmp0 (buff, cell->cell.value) == 0)
        return FALSE;
 
    gnc_basic_cell_set_value_internal (&cell->cell, buff);
 
    return TRUE;
}

gnc_quickfill_cell_add_completion()

void gnc_quickfill_cell_add_completion	(	QuickFillCell *	cell,
		const char *	completion
	)

Definition at line 337 of file quickfillcell.c.

{
    if (cell == NULL)
        return;
 
    gnc_quickfill_insert (cell->qf, completion, cell->sort);
}

gnc_quickfill_cell_new()

BasicCell * gnc_quickfill_cell_new

(

void

)

Definition at line 292 of file quickfillcell.c.

{
    QuickFillCell *cell;
 
    cell = g_new0 (QuickFillCell, 1);
 
    gnc_quickfill_cell_init (cell);
 
    return &cell->cell;
}

gnc_quickfill_cell_set_sort()

void gnc_quickfill_cell_set_sort	(	QuickFillCell *	cell,
		QuickFillSort	sort
	)

Definition at line 314 of file quickfillcell.c.

{
    if (cell == NULL)
        return;
 
    cell->sort = sort;
}

gnc_quickfill_cell_set_value()

void gnc_quickfill_cell_set_value	(	QuickFillCell *	cell,
		const char *	value
	)

sets the current cell value to the indicated string, simultaneously adding the string to the quick-fill tree.

Definition at line 304 of file quickfillcell.c.

{
    if (cell == NULL)
        return;
 
    gnc_basic_cell_set_value_internal (&cell->cell, value);
    gnc_quickfill_insert (cell->qf, value, cell->sort);
}

gnc_quickfill_cell_use_quickfill_cache()

void gnc_quickfill_cell_use_quickfill_cache	(	QuickFillCell *	cell,
		QuickFill *	shared_qf
	)

Lets the cell use the given shared quickfill object instead of the one it owns internally.

The cell will not delete the shared quickfill upon destruction.

Definition at line 346 of file quickfillcell.c.

{
    g_assert(cell);
    g_assert(shared_qf);
 
    if (!cell->use_quickfill_cache)
    {
        cell->use_quickfill_cache = TRUE;
        gnc_quickfill_destroy (cell->qf);
    }
    cell->qf = shared_qf;
}

gnc_recn_cell_get_flag()

char gnc_recn_cell_get_flag

(

RecnCell *

cell

)

Definition at line 170 of file recncell.c.

{
    g_return_val_if_fail (cell != NULL, '\0');
 
    return cell->flag;
}

gnc_recn_cell_new()

BasicCell * gnc_recn_cell_new

(

void

)

Definition at line 124 of file recncell.c.

{
    RecnCell * cell;
 
    cell = g_new0 (RecnCell, 1);
 
    gnc_recn_cell_init (cell);
 
    return &cell->cell;
}

gnc_recn_cell_set_confirm_cb()

void gnc_recn_cell_set_confirm_cb	(	RecnCell *	cell,
		RecnCellConfirm	confirm_cb,
		gpointer	data
	)

Definition at line 186 of file recncell.c.

{
    g_return_if_fail (cell != NULL);
 
    cell->confirm_cb = confirm_cb;
    cell->confirm_data = data;
}

gnc_recn_cell_set_flag()

void gnc_recn_cell_set_flag	(	RecnCell *	cell,
		char	flag
	)

Definition at line 157 of file recncell.c.

{
    const char *string;
 
    g_return_if_fail (cell != NULL);
 
    cell->flag = flag;
    string = gnc_recn_cell_get_string (cell, flag);
 
    gnc_basic_cell_set_value_internal (&cell->cell, string);
}

gnc_recn_cell_set_flag_order()

void gnc_recn_cell_set_flag_order	(	RecnCell *	cell,
		const char *	flags
	)

Definition at line 207 of file recncell.c.

{
    g_return_if_fail (cell != NULL);
    g_return_if_fail (flags != NULL);
 
    cell->flag_order = (char *)flags;
}

gnc_recn_cell_set_read_only()

void gnc_recn_cell_set_read_only	(	RecnCell *	cell,
		gboolean	read_only
	)

Definition at line 216 of file recncell.c.

{
    g_return_if_fail (cell != NULL);
    cell->read_only = read_only;
}

gnc_recn_cell_set_string_getter()

void gnc_recn_cell_set_string_getter	(	RecnCell *	cell,
		RecnCellStringGetter	getter
	)

Definition at line 178 of file recncell.c.

{
    g_return_if_fail (cell != NULL);
    cell->get_string = get_string;
}

gnc_recn_cell_set_valid_flags()

void gnc_recn_cell_set_valid_flags	(	RecnCell *	cell,
		const char *	flags,
		char	default_flag
	)

note that chars is copied into the RecnCell directly, but remains the "property" of the caller.

The caller must maintain the chars pointer, and the caller must setup a mechanism to 'free' the chars pointer. The rationale is that you may have many RecnCell objects that use the same set of flags – this saves you an alloc/free for each cell. - warlord 2001-11-28

Definition at line 196 of file recncell.c.

{
    g_return_if_fail (cell != NULL);
    g_return_if_fail (flags != NULL);
 
    cell->valid_flags = (char *)flags;
    cell->default_flag = default_flag;
}