This is gnucash-design.info, produced by makeinfo version 4.1 from
gnucash-design.texinfo.


INFO-DIR-SECTION Programming

START-INFO-DIR-ENTRY
* gnucash: (gnucash-design).       Design of the GnuCash program
END-INFO-DIR-ENTRY


   This file documents the design of the GnuCash program.

   Copyright 2000 Gnumatic Incorporated

   This is Edition 1.8.11, last updated 13 August 2001, of the `GnuCash
Design Document', version 1.8.11.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or
any later version published by the Free Software Foundation; with the
Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts
being LIST, and with the Back-Cover Texts being LIST.  A copy of the
license is included in the section entitled "GNU Free Documentation
License".


File: gnucash-design.info,  Node: Iterating over Components,  Prev: Finding Components,  Up: Component Manager

Iterating over Components
=========================

   The Component Manager API provides a function for iterating over all
components in a class as well as all registered components regardless
of class.

   In either case, a generic component handler is invoked for each
component. The handler has the following signature:

 - Data type: GNCComponentHandler void (*) (const char * CLASS, gint
          COMPONENT_ID, gpointer ITER_DATA)
     The component handler is invoked with the CLASS, COMPONENT_ID of a
     particular component, as well as the ITER_DATA supplied in the
     iteration API call.

 - Function: void gnc_forall_gui_components (const char *
          COMPONENT_CLASS, GNCComponentHandler HANDLER, gpointer
          ITER_DATA)
     Apply HANDLER to every component in COMPONENT_CLASS. If
     COMPONENT_CLASS is `NULL', then iteration is performed over every
     registered component. ITER_DATA is supplied to HANDLER as the
     third argument.


File: gnucash-design.info,  Node: Register,  Next: Reports,  Prev: Component Manager,  Up: Top

Register
********

   The register is an infrastructure for building a modular matrix of
cells in which each cell may be specialized to perform a particular
function, e.g., to read dates, numerical amounts, or text. The register
has been designed to be easy to extend, modular, easy to maintain, and
memory efficient. It is intended to be used for building financial apps
and spread-sheets.

   The register object should not have any 'knowledge' of the accounting
model of GnuCash or of the workings of the main application. The
register should not be specific to a particular GUI (such as Gnome/GTK).
It should be possible to use the register in a stand-alone fashion.

   The register is built from several types of components: Cells,
Cellblocks, Cursors, the Table, and the Split Register.

* Menu:

* Cells::
* Cellblocks::
* Table::
* Split Register::


File: gnucash-design.info,  Node: Cells,  Next: Cellblocks,  Prev: Register,  Up: Register

Cells
=====

   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).

* Menu:

* BasicCell::


File: gnucash-design.info,  Node: BasicCell,  Prev: Cells,  Up: Cells

BasicCell
---------

   The "BasicCell" interface defines the core functionality that all
cells must implement. A BasicCell contains the following data members.

`char *value'
     The 'value' of the cell stored as a character string.

`GdkWChar *w_value'
     The 'value' of the cell stores as a wide character string.

`gint value_len'
     The length of w_value.

`guint32 changed'
     This member is set to have all 1-bits (2^32 - 1) to indicate the
     cell contents have been changed from the register value.

`guint32 conditionally_changed'
     This member is set to have all 1-bits (2^32 - 1) to indicate the
     cell contents have been changed from the register value, but that
     the register should not be considered to be changed unless other
     cells have been changed (not conditionally).

`char * blank_help'
     This member is a text string which may be used by a GUI
     implementation to display an informative help string when the
     value of a cell is empty (perhaps prompting the user to enter a
     particular kind of value).


File: gnucash-design.info,  Node: Cellblocks,  Next: Table,  Prev: Cells,  Up: Register

Cellblocks
==========

   A "Cellblock" is an array of active cells. The cells are laid out in
rows and columns. The cellblock serves as a convenient container for
organizing active cells in an array. Through the mechanism of Cursors
(defined below), it allows a group of cells to be treated as a single
transactional entity. That is, the cursor/cellblock allows all edits to
a groups of cells to be simultaneously committed or rejected by
underlying engines. This makes it appropriate for use as a GUI for
transaction-processing applications with two-phase commit requirements.


File: gnucash-design.info,  Node: Table,  Next: Split Register,  Prev: Cellblocks,  Up: Register

Table
=====

   The "Table" is a displayed matrix. The table is a complex object; it
is _not_ merely a cellblock. The table provides all of the GUI
infrastructure for displaying a row-column matrix of strings.

   The table provides one very important function for minimizing memory
usage for large matrixes - the notion of a "Cursor". The cursor is a
cellblock (an array of active cells) that is moved to the location that
the user is currently editing. The cursor "virtualizes" cell functions;
that is, it makes it seem to the user as if all cells in the table are
active, when in fact the only cell that actually needs to be active is
the one that the user is currently editing.

   The table design allows multiple cursors to be defined. When a user
enters a cell, the appropriate cursor is positioned within the table.
Cursors cannot overlap: any given cell can be mapped to at most one
cursor. Multiple-cursor support allows tables to be designed that have a
non-uniform layout. For example, the multiple-cursor support can be used
to define a tree structure of headings and sub-headings, where the
layout/format of the heading is different from the sub-headings. A
financial example is a table which lists splits underneath their parent
transaction. This is very different from a checkbook register, where all
entries are uniform, and can be handled with a single repeated cursor.

   Users of the table must provide a TableView object which provides an
API the table uses to obtain information about the data it is displaying
such as strings, colors, etc. Thus, the table represents the non-GUI
portion of the View object in the Model-View-Controller paradigm.


File: gnucash-design.info,  Node: Split Register,  Prev: Table,  Up: Register

Split Register
==============

   The split register is a special-purpose object aimed at the display
of financial transactions. It includes cells for the date, prices,
balances, transfer accounts, etc. The register is where the cells,
cursor and table get put together into a unified whole. The register
defines specific, actual layouts and widths of the date, price, etc.
cells in a table. It includes a table header, and defines more than ten
specific layouts: bank, credit-card, stock, general ledger, etc.

   The split register implementation is divided into two components. The
first component (src/register/splitreg.[ch]) defines the basic structure
and implementation of a split register, but does not specifically use or
depend on the other GnuCash modules, including the Engine. Of course,
this implementation was created with the engine financial structures in
mind.

   The second component (src/SplitLedger.[ch]) implements the full
register behavior (the Controller in MVC) and makes full use of the
Engine API. This component is responsible for loading transactions and
splits into the register, modifying transactions and splits according
to user input, and accomplishing tasks such as performing automatic
completion.


File: gnucash-design.info,  Node: Reports,  Next: User Preferences,  Prev: Register,  Up: Top

Reports
*******

   The reporting infrastructure is designed facilitate the creation of
sophisticated reports including tables, graphs, and hyperlinks.  The
infrastructure includes functionality to support the following:

   * Creation of tables, with headings, subheadings, totals, and
     subtotals.

   * Formatting of dates & numbers.

   * Currency conversions.

   * Create of graphs such as pie and bar charts.

   * Creation of hyperlinks to other reports and to other GnuCash
     objects such as registers.


* Menu:

* Creating a Report::


File: gnucash-design.info,  Node: Creating a Report,  Prev: Reports,  Up: Reports

Creating a Report
=================

   To define a report, your report must have

   `(gnc:support <your_report_name>)'

   and should have

   `(gnc:depend "report-utilities.scm")'

   as well as

   `(gnc:depend "report-html.scm")'

   if you wish to use the html generation facilities. You should avoid
creating HTML directly wherever possible.

   To autoload your report, you should add the line `(gnc:depend
<your_report_name>)' to the file `src/scm/report/report-list.scm'.

   `(gnc:depend "date-utilities.scm")'

   has lots of date-manipulation functions you'll almost certainly need.

   To define a report, you call `(gnc:define-report)'. This function
can accept a variable number of arguments, but at the moment four
distinct arguments are recognised, as in the following from the
transaction report:

       (gnc:define-report
        'version 1
        'name (N_ "Transaction Report")
        'options-generator trep-options-generator
        'renderer trep-renderer)

`version'
     This is the version number of the report, which is currently
     ignored.

`name'
     This is the name of the report. It should be marked as
     translatable, but the name should be given in untranslated form,
     hence the use of `(N_ )'.

`options-generator'
     This should be a function that takes no arguments and returns an
     options structure with the options for the report. The options
     interface is currently not fully documented, but should be.

`renderer'
     This is the function which renders the HTML.


File: gnucash-design.info,  Node: User Preferences,  Next: Function Index,  Prev: Reports,  Up: Top

User Preferences
****************

   The options system is used to obtain user preferences, both globally,
and when displaying a report. A wide variety of option types are
supported, so it should be possible to create an option for just about
any property the user might wish to specify.  New option types can be
added if necessary, but as the process requires detailed knowledge of
GnuCash internals and GTK+/GNOME, it is not documented here.

   At present, users are most likely to come across the options system
when designing custom reports, and are consequently mostly going to use
the Scheme interface. There is also a C interface to much of the options
system which is used to access preferences for the UI, but it is not yet
documented.

* Menu:

* Option Databases::
* Option Types::
* Option Creation::
* Option Values::


File: gnucash-design.info,  Node: Option Databases,  Next: Option Types,  Prev: User Preferences,  Up: User Preferences

Option Databases
================

   The options for a particular report are placed in an "options
database".  For doing a report, the option-generator function must
return an options database.  The function

   `(gnc:new-option)'

   returns a new, empty options database that you can then add options
to.

   Options are organised into sections, which are each given a title
string such as "Register" or "International".  The UI displays each
section on a seperate page.  Each section has a number of options.
Each option has a name that uniquely identifies it in that section, and
an alphabetic "sort tag" that determines the relative ordering of the
options for display.


File: gnucash-design.info,  Node: Option Types,  Next: Option Creation,  Prev: Option Databases,  Up: User Preferences

Option Types
============

   Sometimes, GnuCash requires the user to specify true/false
properties.  Others properties most easily specified by selections from
a list, others from a number, others still by selecting dates, or one
or more accounts in the account hierachy, or even colors.  GnuCash
supports all of these and more:

`boolean'
     These are displayed as a checkbox by the UI.  They are used to
     specify yes/no answers.

`string'
     The UI provides a text entry box where arbitrary text may be
     entered.

`font'
     This allows users to select fonts from those available on the
     system.

`currency'
     For specifying a currency such as "USD", "AUD", "UKP" etc.

`date'
     For specifying dates.  Depending on exactly what is required, you
     can choose to let the user specify an "absolute" date, a "relative"
     date such as "one month ago", or "start of the current accounting
     period", or let the user choose how whether to specify the
     required date in relative or absolute terms.

`account-list'
     For selecting a particular account or accounts.  The UI displays a
     tree of the account hierachy.

`multichoice'
     For selecting one of a group of choices.

`list'
     Similar to the multichoice option, but allows the selection of one
     or more items from the group.

`number-range'
     For specifying a numeric quantity.  The programmer can bound the
     range and precision of the quantity.

`pixmap'
     For selecting a pixmap located on the filesystem.

`color'
     For selecting a color value.

`internal'
     An option that isn't specified through an options dialog box.  For
     instance, this is used to store the window dimensions so that they
     are preserved along with other preferences.


File: gnucash-design.info,  Node: Option Creation,  Next: Option Values,  Prev: Option Types,  Up: User Preferences

Option Creation
===============

   To add an option to an options database, you first create that
option, then register it with the database.  For example, to create a
simple checkbox-style boolean option, you would use
`gnc:make-simple-boolean-option' to create the option.  Once created,
you can then register the option.  With `gnc:register-option'.

 - Function: gnc:register-option database option
     Register OPTION in options database DATABASE

   The example below shows how to create an options database, then
register a boolean option with it:

     (define gnc:*hello-world-options* (gnc:new-options))
     (gnc:register-option gnc:*hello-world-options*
          (gnc:make-simple-boolean-option
           "Hello, World!" "Boolean Option"
           "a" "This is a boolean option." #t))

Option Creation Functions
-------------------------

 - Function: gnc:make-simple-boolean-option section name sort-tag
          documentation-string default-value
     Creates a boolean option, with option section SECTION and name
     NAME specified as strings.  Note that the section and name strings
     uniquely specify the option for the option database that they get
     registered to, and are used for looking up the option when the
     value is required.  SORT-TAG is a string tag that specifies the
     relative order when displaying the options.  Options are displayed
     top to bottom in case-sensitive alphabetical order.
     DOCUMENTATION-STRING is a string containing a short string
     describing the purpose of the option, which the UI displays as a
     tooltip.  DEFAULT-VALUE should be a boolean value indicating the
     default value of this option.

     Note that SECTION, NAME, SORT-TAG, and DOCUMENTATION-STRING are
     common to all the following functions.

 - Function: gnc:make-complex-boolean-option section name sort-tag
          documentation-string default-value setter-function-called-cb
          option-widget-changed-cb
     As above, but the function specified in OPTION-WIDGET-CHANGED-CB
     is called when the GUI widget representing the option is changed
     (the user clicks on the toggle button), and
     SETTER-FUNCTION-CALLED-CB is called when the option's setter is
     called (when the user selects "OK" or "Apply").

     One use for having a non-false OPTION-WIDGET-CHANGED-CB is to make
     another option mutable (in concert with `gnc:option-set-sensitive',
     discussed later).

 - Function: gnc:make-string-option section name sort-tag
          documentation-string default-value
     Make an option where the user can specify a string.


 - Function: gnc:make-date-option section name sort-tag
          documentation-string default-getter show-time subtype
          relative-date-list
     Create a date option.  There are three different variations of date
     options, specified by the variable SUBTYPE, which should be one of
     `'relative', `'absolute', or `both'.  `absolute' date options
     allow the selection of a specific day/month/year combination.
     `relative' date options allow the selection from a list of
     different dates specified in relation to the current date, such as
     "today", "start of the current month", or "six months ago".
     Finally `both' allows the user to choose either using absolute or
     relative date options.
   DEFAULT-GETTER should be a "thunk" (Scheme function taking no
arguments) that returns a pair.  The car of the pair should contain
either `'relative' or `'absolute', to indicate whether the default
value is relative or absolute.  If the car is `relative', then the cdr
should be a one of the relative date symbols listed in
RELATIVE-DATE-LIST.  If the car is `absolute', it should be a timepair
containing the default date/time.

   SHOW-TIME is a boolean that indicates whether when selecting an
absolute date, the user can specify a time.  It is ignored if the
SUBTYPE is `relative'.

   RELATIVE-DATE-LIST is a list of symbols that indicate the relative
dates permitted.  The symbols used must have been previously defined as
indicating a particular relative date.  GNC:RELATIVE-DATES contains a
list of symbols that have already been set up for the most common
relative dates.  FIXME: document relative date system.

 - Function: gnc:make-multichoice-option section name sort-tag
          documentation-string default-value value-list
     Create a multichoice option.  VALUE-LIST is a list of vectors of
     length 3, each representing a different choice.  Each vector should
     contain - in the following order:
        * A symbol identifying this choice.

        * A string naming this choice - this string will be the main one
          displayed.

        * A string describing this choice slightly more fully.  This
          string will appear as a tooltip.


 - Function: gnc:make-list-option section name sort-key
          documentation-string default-values value-list
     Like a multichoice option, but users can select one or more values
     from a list.  DEFAULT-VALUES is a list of selected values instead
     of just one.


 - Function: gnc:make-font-option section name sort-tag
          documentation-string default-value
     Allow the user to specify the font.  Font options store font
     descriptions as strings, like the X Logical Font Description.  You
     must provide a default value, as there is unfortunately no easy
     way for the GUI to pick a default value.


 - Function: gnc:make-color-option section name sort-key
          documentation-string default-value
     scale use-alpha?

     Allow the user to select a color.  The default value should be a
     list of length 4 containing the red, green, blue, and alpha
     channel values for the color.  The scale is the maximum value for
     a channel, and the use-alpha? is a boolean that, if false,
     disregards the alpha channel (note: if you don't know what an
     alpha channel is, you don't need it).


 - Function: gnc:make-currency-option section name sort-tag
          documentation-string default-value
     Let the user specify a currency using a currency code.  The GUI
     provides a specialised widget for currency selection.


 - Function: gnc:make-account-list-option section name sort-tag
          documentation-string default-getter value-validator
          multiple-selection

 - Function: gnc:make-internal-option section name sort-key
          documentation-string default-value
     Create an option that isn't controlled through the options GUI.
     This is used mainly by the GUI to store state that should be
     preserved from session to session but isn't really configurable
     from a dialog box, such as the size of the GnuCash main window.

 - Function: gnc:make-number-range-option section name sort-tag
          documentation-string default-value lower-bound upper-bound
          num-decimals step-size
     Create an option for selecting a numerical quantity.  lower-bound
     and upper-bound specify the domain of acceptable figures, and
     num-decimals specifies the range to which the option will be
     displayed (FIXME:and rounded to?).  Step-size specifies the step
     size for the UI's up/down buttons.



File: gnucash-design.info,  Node: Option Values,  Prev: Option Creation,  Up: User Preferences

Option Values
=============

   To get the value of an option, you must first lookup the option in
the options database.

 - Function: gnc:lookup-option options section name
     Looks up the option in section SECTION and name NAME in the
     options database OPTIONS.


   Once you have looked up the option, you can get its value using the
function `gnc:option-value'.

 - Function: gnc:option-value option
     Get the value of an option.  Option values returned are of the same
     type as how the default values are specified (except the date
     option which needs to be fixed).



File: gnucash-design.info,  Node: Function Index,  Next: Data Type Index,  Prev: User Preferences,  Up: Top

Function Index
**************

* Menu:

* double_to_gnc_numeric:                 Numeric Floating Point Conversion.
* gnc:lookup-option:                     Option Values.
* gnc:make-account-list-option:          Option Creation.
* gnc:make-color-option:                 Option Creation.
* gnc:make-complex-boolean-option:       Option Creation.
* gnc:make-currency-option:              Option Creation.
* gnc:make-date-option:                  Option Creation.
* gnc:make-font-option:                  Option Creation.
* gnc:make-internal-option:              Option Creation.
* gnc:make-list-option:                  Option Creation.
* gnc:make-multichoice-option:           Option Creation.
* gnc:make-number-range-option:          Option Creation.
* gnc:make-simple-boolean-option:        Option Creation.
* gnc:make-string-option:                Option Creation.
* gnc:option-value:                      Option Values.
* gnc:register-option:                   Option Creation.
* gnc_book_begin:                        GNCBook API.
* gnc_book_destroy:                      GNCBook API.
* gnc_book_end:                          GNCBook API.
* gnc_book_get_error:                    GNCBook API.
* gnc_book_get_error_message:            GNCBook API.
* gnc_book_get_file_path:                GNCBook API.
* gnc_book_get_group:                    GNCBook API.
* gnc_book_load:                         GNCBook API.
* gnc_book_new:                          GNCBook API.
* gnc_book_pop_error:                    GNCBook API.
* gnc_book_save:                         GNCBook API.
* gnc_book_save_may_clobber_data:        GNCBook API.
* gnc_book_set_group:                    GNCBook API.
* gnc_commodity_destroy:                 General Commodity API.
* gnc_commodity_equiv:                   General Commodity API.
* gnc_commodity_get_exchange_code:       Commodity Getters.
* gnc_commodity_get_fraction:            Commodity Getters.
* gnc_commodity_get_fullname:            Commodity Getters.
* gnc_commodity_get_mnemonic:            Commodity Getters.
* gnc_commodity_get_namespace:           Commodity Getters.
* gnc_commodity_get_printname:           Commodity Getters.
* gnc_commodity_get_unique_name:         Commodity Getters.
* gnc_commodity_new:                     General Commodity API.
* gnc_commodity_set_exchange_code:       Commodity Setters.
* gnc_commodity_set_fraction:            Commodity Setters.
* gnc_commodity_set_fullname:            Commodity Setters.
* gnc_commodity_set_mnemonic:            Commodity Setters.
* gnc_commodity_set_namespace:           Commodity Setters.
* gnc_commodity_table_add_namespace:     Commodity Table Modification API.
* gnc_commodity_table_delete_namespace:  Commodity Table Modification API.
* gnc_commodity_table_destroy:           General Commodity Table API.
* gnc_commodity_table_find_full:         Commodity Table Access API.
* gnc_commodity_table_get_commodities:   Commodity Table Access API.
* gnc_commodity_table_get_namespaces:    Commodity Table Access API.
* gnc_commodity_table_get_number_of_namespaces: Commodity Table Access API.
* gnc_commodity_table_get_size:          Commodity Table Access API.
* gnc_commodity_table_has_namespace:     Commodity Table Access API.
* gnc_commodity_table_insert:            Commodity Table Modification API.
* gnc_commodity_table_lookup:            Commodity Table Access API.
* gnc_commodity_table_new:               General Commodity Table API.
* gnc_commodity_table_remove:            Commodity Table Modification API.
* gnc_commodity_table_remove_non_iso:    Commodity Table Modification API.
* gnc_component_manager_init:            CM Initialization and Shutdown.
* gnc_component_manager_shutdown:        CM Initialization and Shutdown.
* gnc_engine_commodities:                General Commodity Table API.
* gnc_engine_register_event_handler:     Event API.
* gnc_engine_resume_events:              Event API.
* gnc_engine_suspend_events:             Event API.
* gnc_engine_unregister_event_handler:   Event API.
* gnc_find_first_gui_component:          Finding Components.
* gnc_find_gui_components:               Finding Components.
* gnc_forall_gui_components:             Iterating over Components.
* gnc_gui_component_clear_watches:       Watching Engine Objects.
* gnc_gui_component_watch_entity:        Watching Engine Objects.
* gnc_gui_component_watch_entity_type:   Watching Engine Objects.
* gnc_gui_get_entity_events:             Refresh Handlers.
* gnc_gui_refresh_all:                   Controlling Refreshes.
* gnc_gui_refresh_suspended:             Controlling Refreshes.
* gnc_numeric_abs:                       Basic Arithmetic Operations.
* gnc_numeric_add:                       Basic Arithmetic Operations.
* gnc_numeric_add_fixed:                 Basic Arithmetic Operations.
* gnc_numeric_add_with_error:            Basic Arithmetic Operations.
* gnc_numeric_check:                     Numeric Error Handling.
* gnc_numeric_compare:                   Numeric Comparisons and Predicates.
* gnc_numeric_convert:                   Numeric Denominator Conversion.
* gnc_numeric_convert_with_error:        Numeric Denominator Conversion.
* gnc_numeric_create:                    Creating Numeric Objects.
* gnc_numeric_div:                       Basic Arithmetic Operations.
* gnc_numeric_div_with_error:            Basic Arithmetic Operations.
* gnc_numeric_eq:                        Numeric Comparisons and Predicates.
* gnc_numeric_equal:                     Numeric Comparisons and Predicates.
* gnc_numeric_error:                     Numeric Error Handling.
* gnc_numeric_mul:                       Basic Arithmetic Operations.
* gnc_numeric_mul_with_error:            Basic Arithmetic Operations.
* gnc_numeric_neg:                       Basic Arithmetic Operations.
* gnc_numeric_negative_p:                Numeric Comparisons and Predicates.
* gnc_numeric_positive_p:                Numeric Comparisons and Predicates.
* gnc_numeric_reduce:                    Numeric Denominator Conversion.
* gnc_numeric_same:                      Numeric Comparisons and Predicates.
* gnc_numeric_sub:                       Basic Arithmetic Operations.
* gnc_numeric_sub_fixed:                 Basic Arithmetic Operations.
* gnc_numeric_sub_with_error:            Basic Arithmetic Operations.
* gnc_numeric_to_double:                 Numeric Floating Point Conversion.
* gnc_numeric_to_string:                 Numeric String Conversion.
* gnc_numeric_zero:                      Creating Numeric Objects.
* gnc_numeric_zero_p:                    Numeric Comparisons and Predicates.
* gnc_price_begin_edit:                  Price Setters.
* gnc_price_clone:                       General Price API.
* gnc_price_commit_edit:                 Price Setters.
* gnc_price_create:                      General Price API.
* gnc_price_get_commodity:               Price Getters.
* gnc_price_get_currency:                Price Getters.
* gnc_price_get_guid:                    Price Getters.
* gnc_price_get_source:                  Price Getters.
* gnc_price_get_time:                    Price Getters.
* gnc_price_get_type:                    Price Getters.
* gnc_price_get_value:                   Price Getters.
* gnc_price_get_version:                 Price Getters.
* gnc_price_list_destroy:                Price Lists.
* gnc_price_list_insert:                 Price Lists.
* gnc_price_list_remove:                 Price Lists.
* gnc_price_lookup:                      General Price API.
* gnc_price_ref:                         General Price API.
* gnc_price_set_commodity:               Price Setters.
* gnc_price_set_currency:                Price Setters.
* gnc_price_set_source:                  Price Setters.
* gnc_price_set_time:                    Price Setters.
* gnc_price_set_type:                    Price Setters.
* gnc_price_set_value:                   Price Setters.
* gnc_price_set_version:                 Price Setters.
* gnc_price_unref:                       General Price API.
* gnc_pricedb_add_price:                 General Price Database API.
* gnc_pricedb_create:                    General Price Database API.
* gnc_pricedb_destroy:                   General Price Database API.
* gnc_pricedb_remove_price:              General Price Database API.
* gnc_register_gui_component:            Registering and Unregistering Components.
* gnc_resume_gui_refresh:                Controlling Refreshes.
* gnc_suspend_gui_refresh:               Controlling Refreshes.
* gnc_unregister_gui_component:          Registering and Unregistering Components.
* gnc_unregister_gui_component_by_data:  Registering and Unregistering Components.
* guid_compare:                          How to use GUIDs.
* guid_equal:                            How to use GUIDs.
* guid_hash_table_new:                   How to use GUIDs.
* guid_hash_to_guint:                    How to use GUIDs.
* guid_init:                             The GUID Generator.
* guid_init_only_salt:                   The GUID Generator.
* guid_init_with_salt:                   The GUID Generator.
* guid_new:                              The GUID Generator.
* guid_to_string:                        How to use GUIDs.
* guid_to_string_buff:                   How to use GUIDs.
* kvp_frame_copy:                        kvp_frame.
* kvp_frame_delete:                      kvp_frame.
* kvp_frame_get_frame:                   kvp_frame.
* kvp_frame_get_frame_gslist:            kvp_frame.
* kvp_frame_get_frame_slash:             kvp_frame.
* kvp_frame_get_slot:                    kvp_frame.
* kvp_frame_get_slot_path:               kvp_frame.
* kvp_frame_get_slot_path_gslist:        kvp_frame.
* kvp_frame_new:                         kvp_frame.
* kvp_frame_set_slot:                    kvp_frame.
* kvp_frame_set_slot_nc:                 kvp_frame.
* kvp_frame_set_slot_path:               kvp_frame.
* kvp_frame_set_slot_path_gslist:        kvp_frame.
* kvp_list_car:                          kvp_list.
* kvp_list_cdr:                          kvp_list.
* kvp_list_cons:                         kvp_list.
* kvp_list_copy:                         kvp_list.
* kvp_list_delete:                       kvp_list.
* kvp_list_new:                          kvp_list.
* kvp_list_null_p:                       kvp_list.
* kvp_value_copy:                        kvp_value.
* kvp_value_delete:                      kvp_value.
* kvp_value_get_binary:                  kvp_value.
* kvp_value_get_float64:                 kvp_value.
* kvp_value_get_frame:                   kvp_value.
* kvp_value_get_guid:                    kvp_value.
* kvp_value_get_int64:                   kvp_value.
* kvp_value_get_list:                    kvp_value.
* kvp_value_get_string:                  kvp_value.
* kvp_value_get_type:                    kvp_value.
* kvp_value_new_binary:                  kvp_value.
* kvp_value_new_float64:                 kvp_value.
* kvp_value_new_frame:                   kvp_value.
* kvp_value_new_guid:                    kvp_value.
* kvp_value_new_int64:                   kvp_value.
* kvp_value_new_list:                    kvp_value.
* kvp_value_new_string:                  kvp_value.
* string_to_gnc_numeric:                 Numeric String Conversion.
* string_to_guid:                        How to use GUIDs.
* xaccAccountBeginEdit:                  General Account API.
* xaccAccountCommitEdit:                 General Account API.
* xaccAccountDestroy:                    General Account API.
* xaccAccountGetBalance:                 Account Getters.
* xaccAccountGetBalanceAsOfDate:         Account Getters.
* xaccAccountGetChildren:                Account Getters.
* xaccAccountGetClearedBalance:          Account Getters.
* xaccAccountGetCode:                    Account Getters.
* xaccAccountGetCurrency:                Account Getters.
* xaccAccountGetCurrencySCU:             Account Getters.
* xaccAccountGetDescription:             Account Getters.
* xaccAccountGetEffectiveSecurity:       Account Getters.
* xaccAccountGetFullName:                Account Getters.
* xaccAccountGetGUID:                    General Account API.
* xaccAccountGetName:                    Account Getters.
* xaccAccountGetNotes:                   Account Getters.
* xaccAccountGetParent:                  Account Getters.
* xaccAccountGetParentAccount:           Account Getters.
* xaccAccountGetReconciledBalance:       Account Getters.
* xaccAccountGetSecurity:                Account Getters.
* xaccAccountGetSecuritySCU:             Account Getters.
* xaccAccountGetShareBalance:            Account Getters.
* xaccAccountGetShareBalanceAsOfDate:    Account Getters.
* xaccAccountGetShareClearedBalance:     Account Getters.
* xaccAccountGetShareReconciledBalance:  Account Getters.
* xaccAccountGetSlots:                   General Account API.
* xaccAccountGetSplitList:               Account Getters.
* xaccAccountGetTaxRelated:              Account Tax API.
* xaccAccountGetTaxUSCode:               Account Tax API.
* xaccAccountGetTaxUSPayerNameSource:    Account Tax API.
* xaccAccountGetType:                    Account Getters.
* xaccAccountGetTypeStr:                 Account Type API.
* xaccAccountGroupCommitEdit:            General Account Group API.
* xaccAccountInsertSubAccount:           Account Group Account API.
* xaccAccountLookup:                     General Account API.
* xaccAccountRemoveGroup:                Account Group Account API.
* xaccAccountSetSlots_nc:                General Account API.
* xaccAccountSetTaxRelated:              Account Tax API.
* xaccAccountSetTaxUSCode:               Account Tax API.
* xaccAccountSetTaxUSPayerNameSource:    Account Tax API.
* xaccAccountStringToEnum:               Account Type API.
* xaccAccountStringToType:               Account Type API.
* xaccAccountTypeEnumAsString:           Account Type API.
* xaccAccountTypesCompatible:            Account Type API.
* xaccCloneAccountSimple:                General Account API.
* xaccFreeAccountGroup:                  General Account Group API.
* xaccGroupConcatGroup:                  General Account Group API.
* xaccGroupGetAccount:                   Account Group Account API.
* xaccGroupGetAccountList:               Account Group Account API.
* xaccGroupGetDepth:                     Account Group Account API.
* xaccGroupGetNumAccounts:               Account Group Account API.
* xaccGroupGetNumSubAccounts:            Account Group Account API.
* xaccGroupGetSubAccounts:               Account Group Account API.
* xaccGroupInsertAccount:                Account Group Account API.
* xaccGroupMarkDoFree:                   General Account Group API.
* xaccGroupMarkNotSaved:                 General Account Group API.
* xaccGroupMarkSaved:                    General Account Group API.
* xaccGroupMergeAccounts:                General Account Group API.
* xaccGroupNotSaved:                     General Account Group API.
* xaccGroupRemoveAccount:                Account Group Account API.
* xaccGUIDFree:                          How to use GUIDs.
* xaccGUIDMalloc:                        How to use GUIDs.
* xaccGUIDNew:                           GUIDs and GnuCash Entities.
* xaccGUIDNull:                          GUID Types.
* xaccGUIDType:                          GUID Types.
* xaccLookupEntity:                      GUIDs and GnuCash Entities.
* xaccMallocAccount:                     General Account API.
* xaccMallocAccountGroup:                General Account Group API.
* xaccMallocSplit:                       General Split API.
* xaccMallocTransaction:                 General Transaction API.
* xaccRemoveEntity:                      GUIDs and GnuCash Entities.
* xaccSplitDestroy:                      General Split API.
* xaccSplitGetAccount:                   Split Getters.
* xaccSplitGetAction:                    Split Getters.
* xaccSplitGetBalance:                   Split Getters.
* xaccSplitGetBaseValue:                 Split Getters.
* xaccSplitGetClearedBalance:            Split Getters.
* xaccSplitGetDateReconciledTS:          Split Getters.
* xaccSplitGetGUID:                      General Split API.
* xaccSplitGetMemo:                      Split Getters.
* xaccSplitGetParent:                    Split Getters.
* xaccSplitGetReconcile:                 Split Getters.
* xaccSplitGetReconciledBalance:         Split Getters.
* xaccSplitGetShareAmount:               Split Getters.
* xaccSplitGetShareBalance:              Split Getters.
* xaccSplitGetShareClearedBalance:       Split Getters.
* xaccSplitGetSharePrice:                Split Getters.
* xaccSplitGetShareReconciledBalance:    Split Getters.
* xaccSplitGetType:                      Split Getters.
* xaccSplitGetValue:                     Split Getters.
* xaccSplitLookup:                       General Split API.
* xaccSplitMakeStockSplit:               General Split API.
* xaccSplitSetAction:                    Split Setters.
* xaccSplitSetBaseValue:                 Split Setters.
* xaccSplitSetDateReconciledSecs:        Split Setters.
* xaccSplitSetDateReconciledTS:          Split Setters.
* xaccSplitSetMemo:                      Split Setters.
* xaccSplitSetReconcile:                 Split Setters.
* xaccSplitSetShareAmount:               Split Setters.
* xaccSplitSetSharePrice:                Split Setters.
* xaccSplitSetSharePriceAndAmount:       Split Setters.
* xaccSplitSetValue:                     Split Setters.
* xaccStoreEntity:                       GUIDs and GnuCash Entities.
* xaccTransAppendSplit:                  General Transaction API.
* xaccTransBeginEdit:                    General Transaction API.
* xaccTransCommitEdit:                   General Transaction API.
* xaccTransCountSplits:                  Transaction Getters.
* xaccTransDestroy:                      General Transaction API.
* xaccTransGetDate:                      Transaction Getters.
* xaccTransGetDateEnteredTS:             Transaction Getters.
* xaccTransGetDateL:                     Transaction Getters.
* xaccTransGetDateStr:                   Transaction Getters.
* xaccTransGetDateTS:                    Transaction Getters.
* xaccTransGetDescription:               Transaction Getters.
* xaccTransGetGUID:                      General Transaction API.
* xaccTransGetNum:                       Transaction Getters.
* xaccTransGetSlot:                      General Transaction API.
* xaccTransGetSplit:                     Transaction Getters.
* xaccTransGetSplitList:                 Transaction Getters.
* xaccTransIsOpen:                       General Transaction API.
* xaccTransLookup:                       General Transaction API.
* xaccTransRollbackEdit:                 General Transaction API.
* xaccTransSetDate:                      Transaction Setters.
* xaccTransSetDateEnteredSecs:           Transaction Setters.
* xaccTransSetDateEnteredTS:             Transaction Setters.
* xaccTransSetDateSecs:                  Transaction Setters.
* xaccTransSetDateToday:                 Transaction Setters.
* xaccTransSetDateTS:                    Transaction Setters.
* xaccTransSetDescription:               Transaction Setters.
* xaccTransSetNum:                       Transaction Setters.
* xaccTransSetSlot:                      General Transaction API.


File: gnucash-design.info,  Node: Data Type Index,  Next: Concept Index,  Prev: Function Index,  Up: Top

Date Type Index
***************

* Menu:

* Account:                               Accounts.
* AccountGroup:                          Account Groups.
* BasicCell:                             BasicCell.
* EventInfo:                             Refresh Handlers.
* gnc_commodity:                         Commodities.
* gnc_commodity_table:                   Commodity Tables.
* gnc_numeric:                           Numeric Library.
* GNCAccountType:                        Account Types.
* GNCBook:                               GNCBooks.
* GNCComponentCloseHandler:              Close Handlers.
* GNCComponentFindHandler:               Finding Components.
* GNCComponentHandler:                   Iterating over Components.
* GNCComponentRefreshHandler:            Refresh Handlers.
* GNCEngineEventHandler:                 Event API.
* GNCEngineEventType:                    Event API.
* GNCIdType:                             GUID Types.
* GNCPrice:                              Prices.
* GNCPriceDB:                            Price Databases.
* GUID:                                  Globally Unique Identifiers.
* kvp_frame:                             kvp_frame.
* kvp_list:                              kvp_list.
* kvp_value:                             kvp_value.
* kvp_value_t:                           kvp_value.
* Split:                                 Splits.
* Transaction:                           Transactions.


File: gnucash-design.info,  Node: Concept Index,  Prev: Data Type Index,  Up: Top

Concept Index
*************

* Menu:

* Basic Arithmetic Operations:           Basic Arithmetic Operations.
* Component Manager:                     Component Manager.
* Creating Numeric Objects:              Creating Numeric Objects.
* Globally Unique Identifier:            Globally Unique Identifiers.
* Key-Value Pairs:                       Key-Value Pair Frames.
* Key-Value Policy:                      Key-Value Policy.
* Numeric Comparisons and Predicates:    Numeric Comparisons and Predicates.
* Numeric Denominator Conversion:        Numeric Denominator Conversion.
* Numeric Error Handling:                Numeric Error Handling.
* Numeric Example:                       Numeric Example.
* Numeric Floating Point Conversion:     Numeric Floating Point Conversion.
* Numeric Library:                       Numeric Library.
* Numeric String Conversion:             Numeric String Conversion.
* Option Creation:                       Option Creation.
* Option Databases:                      Option Databases.
* Option Values:                         Option Values.
* Refresh Mechanism:                     Refresh Mechanism.
* Register:                              Register.
* Reports:                               Reports.
* Standard Numeric Arguments:            Standard Numeric Arguments.
* The Engine:                            Engine.
* The GUID Generator:                    The GUID Generator.
* User Preferences:                      User Preferences.
* When to use GUIDs:                     When to use GUIDs.


