table-allgui.h

Go to the documentation of this file.

/********************************************************************\
 * table-allgui.h -- 2D grid table object, embeds cells for i/o     *
 *                                                                  *
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
\********************************************************************/
#ifndef TABLE_ALLGUI_H
#define TABLE_ALLGUI_H
 
#include <glib.h>
 
#include "basiccell.h"
#include "cellblock.h"
#include "gtable.h"
#include "register-common.h"
#include "table-control.h"
#include "table-layout.h"
#include "table-model.h"
 
typedef struct
{
    CellBlock *cellblock;  
    gpointer   vcell_data; 
    /* flags */
    unsigned int visible : 1;             
    unsigned int start_primary_color : 1; 
} VirtualCell;
 
typedef struct table Table;
 
typedef void (*TableCursorRefreshCB) (Table *table,
                                      VirtualCellLocation vcell_loc,
                                      gboolean do_scroll);
 
typedef void (*TableRedrawHelpCB) (Table *table);
typedef void (*TableDestroyCB) (Table *table);
 
typedef struct
{
    TableCursorRefreshCB cursor_refresh;
 
    TableRedrawHelpCB redraw_help;
    TableDestroyCB destroy;
    
    CellDirectUpdateFunc default_direct_update;
} TableGUIHandlers;
 
struct table
{
    TableLayout  *layout;
    TableModel   *model;
    TableControl *control;
 
    int num_virt_rows;
    int num_virt_cols;
 
    CellBlock *current_cursor;
 
    VirtualLocation current_cursor_loc;
 
    /* private data */
 
    /* The virtual cell table */
    GTable *virt_cells;
 
    TableGUIHandlers gui_handlers;
    gpointer ui_data;
};
 
typedef enum {
    COLOR_UNDEFINED = 0,      // 0
    COLOR_HEADER,             // 1
    COLOR_PRIMARY,            // 2
    COLOR_PRIMARY_ACTIVE,     // 3
    COLOR_SECONDARY,          // 4
    COLOR_SECONDARY_ACTIVE,   // 5
    COLOR_SPLIT,              // 6
    COLOR_SPLIT_ACTIVE,       // 7
    COLOR_NEGATIVE = 16,      // 16
} RegisterColor;
 
 
void gnc_table_set_default_gui_handlers (TableGUIHandlers *gui_handlers);
 
/* Functions to create and destroy Tables.  */
Table *     gnc_table_new (TableLayout *layout,
                           TableModel *model,
                           TableControl *control);
void        gnc_virtual_location_init (VirtualLocation *vloc);
 
void        gnc_table_save_state (Table *table, const gchar *state_section);
void        gnc_table_destroy (Table *table);
 
 
/* Functions to work with current cursor */
int         gnc_table_current_cursor_changed (Table *table,
        gboolean include_conditional);
 
void        gnc_table_clear_current_cursor_changes (Table *table);
 
void        gnc_table_save_current_cursor (Table *table, CursorBuffer *buffer);
void        gnc_table_restore_current_cursor (Table *table,
        CursorBuffer *buffer);
 
const char * gnc_table_get_current_cell_name (Table *table);
 
gboolean    gnc_table_get_current_cell_location (Table *table,
        const char *cell_name,
        VirtualLocation *virt_loc);
 
 
gboolean gnc_table_virtual_cell_out_of_bounds (Table *table,
        VirtualCellLocation vcell_loc);
 
gboolean gnc_table_virtual_location_in_header (Table *table,
        VirtualLocation virt_loc);
 
 
VirtualCell *  gnc_table_get_virtual_cell (Table *table,
        VirtualCellLocation vcell_loc);
 
const char *   gnc_table_get_entry (Table *table, VirtualLocation virt_loc);
 
char *         gnc_table_get_tooltip (Table *table, VirtualLocation virt_loc);
 
const char *   gnc_table_get_label (Table *table, VirtualLocation virt_loc);
 
CellIOFlags    gnc_table_get_io_flags (Table *table, VirtualLocation virt_loc);
 
guint32        gnc_table_get_color (Table *table, VirtualLocation virt_loc,
                                       gboolean *hatching);
 
void           gnc_table_get_borders (Table *table, VirtualLocation virt_loc,
                                      PhysicalCellBorders *borders);
 
CellAlignment  gnc_table_get_align (Table *table, VirtualLocation virt_loc);
 
gboolean       gnc_table_is_popup (Table *table, VirtualLocation virt_loc);
 
char *         gnc_table_get_help (Table *table);
 
BasicCell *    gnc_table_get_cell (Table *table, VirtualLocation virt_loc);
 
const char *   gnc_table_get_cell_name (Table *table,
                                        VirtualLocation virt_loc);
const gchar *  gnc_table_get_cell_type_name (Table *table,
        VirtualLocation virt_loc);
gboolean       gnc_table_get_cell_location (Table *table,
        const char * cell_name,
        VirtualCellLocation vcell_loc,
        VirtualLocation *virt_loc);
 
const char *   gnc_table_get_model_entry (Table *table, const char *cell_name);
 
void           gnc_table_save_cells (Table *table, gpointer save_data);
 
 
VirtualCell *  gnc_table_get_header_cell (Table *table);
 
void        gnc_table_set_size (Table * table, int virt_rows, int virt_cols);
 
void        gnc_table_set_vcell (Table *table, CellBlock *cursor,
                                 gconstpointer vcell_data,
                                 gboolean visible,
                                 gboolean start_primary_color,
                                 VirtualCellLocation vcell_loc);
 
void        gnc_table_set_virt_cell_data (Table *table,
        VirtualCellLocation vcell_loc,
        gconstpointer vcell_data);
 
void        gnc_table_set_virt_cell_visible (Table *table,
        VirtualCellLocation vcell_loc,
        gboolean visible);
 
void        gnc_table_set_virt_cell_cursor (Table *table,
        VirtualCellLocation vcell_loc,
        CellBlock *cursor);
 
void        gnc_table_move_cursor (Table *table, VirtualLocation virt_loc);
 
void        gnc_table_move_cursor_gui (Table *table, VirtualLocation virt_loc);
 
gboolean    gnc_table_verify_cursor_position (Table *table,
        VirtualLocation virt_loc);
 
gpointer    gnc_table_get_vcell_data (Table *table,
                                      VirtualCellLocation vcell_loc);
 
gboolean    gnc_table_find_close_valid_cell (Table *table,
        VirtualLocation *virt_loc,
        gboolean exact_cell);
 
void        gnc_table_init_gui (Table *table);
 
void        gnc_table_realize_gui (Table *table);
 
void        gnc_table_refresh_current_cursor_gui (Table * table,
        gboolean do_scroll);
 
void        gnc_table_refresh_gui (Table *table, gboolean do_scroll);
 
void        gnc_table_show_range (Table *table,
                                  VirtualCellLocation start_loc,
                                  VirtualCellLocation end_loc);
 
void        gnc_table_refresh_cursor_gui (Table * table,
        VirtualCellLocation vcell_loc,
        gboolean do_scroll);
 
/* ==================================================== */
 
void         gnc_table_wrap_verify_cursor_position (Table *table,
        VirtualLocation virt_loc);
 
gboolean     gnc_table_virtual_loc_valid(Table *table,
        VirtualLocation virt_loc,
        gboolean exact_pointer);
 
gboolean     gnc_table_move_tab (Table *table,
                                 VirtualLocation *virt_loc,
                                 gboolean move_right);
 
gboolean     gnc_table_move_vertical_position (Table *table,
        VirtualLocation *virt_loc,
        int phys_row_offset);
 
gboolean     gnc_table_enter_update(Table *table,
                                    VirtualLocation virt_loc,
                                    int *cursor_position,
                                    int *start_selection,
                                    int *end_selection);
 
void         gnc_table_leave_update(Table *table, VirtualLocation virt_loc);
 
gboolean     gnc_table_confirm_change(Table *table, VirtualLocation virt_loc);
 
const char * gnc_table_modify_update(Table *table,
                                     VirtualLocation virt_loc,
                                     const char *change,
                                     int change_len,
                                     const char *newval,
                                     int newval_len,
                                     int *cursor_position,
                                     int *start_selection,
                                     int *end_selection,
                                     gboolean *cancelled);
 
gboolean     gnc_table_direct_update(Table *table,
                                     VirtualLocation virt_loc,
                                     char **newval_ptr,
                                     int *cursor_position,
                                     int *start_selection,
                                     int *end_selection,
                                     gpointer gui_data);
 
gboolean     gnc_table_traverse_update(Table *table,
                                       VirtualLocation virt_loc,
                                       gncTableTraversalDir dir,
                                       VirtualLocation *dest_loc);
 
#endif /* TABLE_ALLGUI_H */