root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/include/msksheet.cpp
guy 55a36762ef archives.cpp Tolto include windows.h 
checks.cpp      Tolto include windows.h
colors.cpp      Tolto include windows.h
controls.cpp    Aggiunto cambiamento del font runtime dei TText_control
execp.cpp       Tolto include windows.h
form.cpp        Tolto include windows.h
mask.cpp        Corretta formattazione di due righe
maskfld.cpp     Aggiunto messaggio CHECK
msksheet.cpp    Tolto include windows.h
relapp.cpp      Tolto include windows.h
strings.pp      Corretto CHECK della TFixed_string::format()
viswin.cpp      Tolto include windows.h
window.cpp      Tolto include windows.h
xvtility.cpp    Corretto calcolo altezza righe delle maschere


git-svn-id: svn://10.65.10.50/trunk@4085 c028cbd2-c16b-5b4b-a496-9718f37d4682
1997-01-17 11:07:43 +00:00

2563 lines
70 KiB
C++
Executable File
Raw Blame History

#define XI_INTERNAL
#include <xi.h>
extern "C"
{
#include <xiutils.h>
}
#include <colors.h>
#include <config.h>
#include <controls.h>
#include <msksheet.h>
#include <urldefid.h>
///////////////////////////////////////////////////////////
// TSpreadsheet
///////////////////////////////////////////////////////////
// @doc INTERNAL
// @class TSpreadsheet | Classe per la creazione di uno spreadsheet all'interno
// di una maschera
//
// @base public | TWindow
class TSpreadsheet : public TControl
{
// @author:(INTERNAL) Guido
// @cfriend TSheet_field
friend class TSheet_field;
// @access:(INTERNAL) Private Member
// @cmember:(INTERNAL) Array di TToken_strings contenenti le righe
TString_array _str;
// @cmember:(INTERNAL) Array delle colonne disattivate (solo visualizzazione)
TBit_array _column_disabled;
struct TRow_property : public TObject
{
TBit_array _disabled;
COLOR _back, _fore;
TRow_property();
virtual ~TRow_property() { }
};
// @cmember:(INTERNAL) Array delle proprieta' delle righe
TArray _property;
// @cmember:(INTERNAL) Maschera in cui e' contenuto lo spreadsheet
TMask _mask;
// @cmember:(INTERNAL) Numero di colonne presenti nello spreadsheet
int _columns;
// @cmember:(INTERNAL) Indica se e' attivo lo spreadsheet
bool _active;
// @cmember:(INTERNAL) Funzione per la gestione di una riga dello sheet (vedi <t SPREADSHEET_NOTIFY>)
SPREADSHEET_NOTIFY _notify;
// @cmember:(INTERNAL) Campo corrente che si sta editando
TOperable_field* _edit_field;
// @cmember:(INTERNAL) Coordinata della riga della cella corrente
int _cur_row;
// @cmember:(INTERNAL) Numero del record sul file al quale fa riferimento la cella corrente
int _cur_rec;
// @cmember:(INTERNAL) Coordinata della colonna della cella corrente
int _cur_col;
// @cmember:(INTERNAL) Indica se la riga corrente e' stata modificata
bool _row_dirty;
// @cmember:(INTERNAL) Indica se la cella corrente e' stata modificata
bool _cell_dirty;
// @cmember:(INTERNAL) Permette di gestire i check OFF_ROW e OFF_CELL
bool _check_enabled;
// @cmember:(INTERNAL) Numero della riga che necessita aggiornamento (vengono aggiornate
// nella <mf TSpreadsheet::on_idle>)
int _needs_update;
// @cmember:(INTERNAL) Numero della riga a cui saltare appena possibile
int _selection_posted;
// @cmember:(INTERNAL) Dimensioni delle colonne
int _default_width[32]; // 32 = MAX_COLS
// @cmember:(INTERNAL) Bisogna salvare l'ordien delle colonne
bool _save_columns_order;
// @cmember:(INTERNAL) Inizializza lo spreadsheet
void init();
// @cmember:(INTERNAL) Funzione che intercetta gli eventi dello spreadsheet
friend void XVT_CALLCONV1 xiev_handler(XI_OBJ *itf, XI_EVENT *xiev);
// @access Protected Member
protected:
//@cmember Gestisce gli eventi delle celle (chiamata dal <mf TSpreadsheet::xiev_handler>)
virtual bool event_handler(XI_OBJ* itf, XI_EVENT* xiev);
//@cmember Copia una cella nel corrispondente campo della maschera e ne ritorna il contenuto
const char* copy_cell2field(XI_OBJ* cell = NULL);
//@cmember Gestisce l'uscita delle celle (chiamata dal <mf TSpreadsheet::list_handler>)
bool off_cell_handler(XI_OBJ* cell = NULL);
// @cmember Ritorna il campo della maschera corrispondente alla cella dello
// spreadsheet indicata da <p pos>
TOperable_field* col2field(int pos) const;
// @cmember Controlla se esiste il campo della maschera corrispondente alla cella dello
// spreadsheet indicata da <p pos>
TOperable_field* test_field(int pos) const;
// @cmember Ritorna il campo della maschera corrispondente alla cella dello
// spreadsheet indicata da <p cell> (chiama <mf TMask::col2field>)
TOperable_field* cell2field(const XI_OBJ* cell) const;
// @cmember Ritorna la posizione della colonna con identificatore <p cid>
int cid2col(short cid) const;
// @cmember Ritorna la colonna logica con identificatore <p cid>
int cid2index(short cid) const;
// @cmember Ritorna la colonna corrispondente al campo <p f> della maschera
int field2col(const TOperable_field* f) const;
// @cmember Aggiorna il record sullo spreadsheet
void update_rec(int rec);
TOperable_field* field(short id) const;
// @cmember Converte il numero del record nel corrispondente numero della riga
int rec2row(int rec);
// @cmember Converte il numero della riga nel corrispondente
// numero del record
int row2rec(int& row);
// @cmember Setta la posizione (riga e colonna) del focus sullo spreadsheet.
// Ritorna il numero del record corrente
int set_pos(int row, int col)
{ _cur_col = col; _cur_row = row; return _cur_rec = row2rec(_cur_row); }
// @cmember Chiama la funzione specificata con la <mf TSpreadsheet::set_notify>
bool notify(int row, KEY k);
// @cmember Chiama la funzione specificata con la <mf TSpreadsheet::set_notify>
// ogni volta che c'e' una modifica nello spreadsheet
void notify_change();
// @cmember Permette di fare tutti gli aggiornamenti necessari (indicati in
// <p _needs_update>)
void on_idle();
// @cmember Cerca la colonna col
XI_OBJ* find_column(int col) const;
// @cmember Cerca le proprieta' della riga r e volendo le crea pure
TRow_property* get_property(int r, bool create = FALSE);
TSheet_field& owner() const { return (TSheet_field&)*_fld; }
// @access Public Member
public:
// @cmember Modifica a video la riga
void update(int row);
// @cmember Ritorna la disabilitazione della colonna <p col>
bool column_disabled(int col) const { return _column_disabled[col]; }
// @cmember Ritorna l' abilitazione della colonna <p col>
bool column_enabled(int col) const { return !column_disabled(col); }
// @cmember Ritorna il contenuto della riga <p n>-esima
TToken_string& row(int n)
{ return _str.row(n); }
// @cmember Aggiunge una riga allo spreadsheet passata come puntatore
// (vedi <mf TArray::add>)
int add(const TToken_string& s)
{ return _str.add(s); }
// @cmember Aggiunge una riga allo spreadsheet (vedi <mf TArray::add>)
int add(TToken_string* s)
{ return _str.add(s); }
// @cmember Inserisce un record in una posizione stabilita
int insert(int rec);
// @cmember Inserisce un record (da prgramma) in una posizione stabilita
int _insert(int rec, bool update_sheet = TRUE);
// @cmember Elimina il record <p rec>
bool destroy(int rec = -1, bool update_sheet = TRUE);
// @cmember Ritorna l'array di tutte le stringhe delle righe
TString_array& rows_array()
{ return _str; }
// @cmember Trova una colonna abilitata a partire da colonna
int find_enabled_column(int rec, int colonna, int direction) const;
// @cmember Trova un record abilitato a partire da rec
int find_enabled_record(int rec, int direction) const;
// @cmember Permette di mettere il focus su una cella
void set_focus_cell(int riga, int colonna);
// @cmember Abilita/disabilita tutto lo spreadsheet (vedi <mf TMask::activate>)
void activate(bool on);
// @cmember Permette di abilitare/disabilitare una colonna
void enable_column(int col, bool on = TRUE);
// @cmember Permette di eliminare una colonna dallo spreadsheet
void delete_column(const int col) const;
// @cmember Sposta la colonna dalla posizione <p fromindex> alla posizione
// <p toindex>
void move_column(const int fromindex, const int toindex) const;
// @cmember Permette di invertire la posizione di due colonne
void swap_columns(const int fromid, const int toid) const;
// @cmember Permette di invertire la posizione di due righe
void swap_rows(const int fromindex, const int toindex);
// @cmember Salva la disposizione delle colonne
void save_columns_order() const;
// @cmember Salva la disposizione delle colonne
void load_columns_order();
// @cmember Setta la disposizione delle colonne
void set_columns_order(TToken_string* order);
// @cmember Setta la larghezza della colonna
void set_column_width(const int col, const int width) const;
// @cmember Setta il titolo della colonna
void set_column_header(const int col, const TString& header) const;
// @cmember Setta l'allineamento di una colonna
void set_column_justify(int col, bool right);
// @cmember Permette di abilitare/disabilitare una singola cella
void enable_cell(int row, int column, bool on = TRUE);
// @cmember Controlla se una cella e' disabilitata
bool cell_disabled(int row, int column) const;
// @cmember Setta i colori di una riga
void set_back_and_fore_color(COLOR back, COLOR fore, int row);
// @cmember Legge i colori di una riga
void get_back_and_fore_color(COLOR& back, COLOR& fore, int row);
// @cmember Ritorna la maschera che appartiene allo spreadsheet
TMask& sheet_mask() const;
// @cmember Ritorna la maschera cui appartiene lo spreadsheet
TMask& mask() const;
// @cmember Ricopia i campi della maschera nel record <p n>-esimo ed
// aggiorna il display
void mask2str(int n);
// @cmember Ricopia i campi del record <p n>-esimo nella maschera ed
// aggiorna il display
void str2mask(int n);
// @cmember Apre la maschera della riga <p n>-esima editando la riga
KEY edit(int n);
// @cmember Ritorna il numero di righe dello sheet
int items() const
{ return _str.items(); }
// @cmember Ritorna il record corrente
int selected() const
{ return _cur_rec; }
// @cmember Seleziona una riga dandogli il focus
void select(int r, bool scrollto);
// @cmember Ritorna il numero di colonne presenti nello spreadsheet
int columns() const
{ return _columns; }
// @cmember Seleziona una riga appena possibile
void post_select(int r);
// @cmember Controlla se e' stato modificato una cella dello spreadsheet
bool dirty() const
{ return owner().dirty(); }
// @cmember Permette di indicare se e' stata modificata una cella dello spreadsheet
void set_dirty(bool spork = TRUE)
{ owner().set_dirty(spork); }
// @cmember Ritorna il valore della variabile active
bool active() const
{ return _active; }
// @cmember Ritorna se e' possibile lasciare il focus dallo spreadsheet (TRUE se e' possibile)
bool test_focus_change();
// @cmember Setta il membro <p _notify> al valore <p n>
void set_notify(SPREADSHEET_NOTIFY n)
{ _notify = n; }
// @cmember Costruttore
TSpreadsheet(WINDOW parent, short dlg, short x, short y, short dx, short dy, const char* maskname, int maskno, const char* head, TSheet_field* owner);
// @cmember Distruttore
virtual ~TSpreadsheet();
};
TSpreadsheet::TRow_property::TRow_property()
: _back(NORMAL_BACK_COLOR), _fore(NORMAL_COLOR)
{
}
// @doc INTERNAL
// @mfunc Costruttore
TSpreadsheet::TSpreadsheet(
WINDOW parent, // @parm Finestra alla quale appartiene lo spreadsheet
short dlg, // @parm Identificatore del campo
short x, // @parm Coordinata x (in caratteri) nel quale posizionare lo spreadsheet
short y, // @parm Coordinata y (in caratteri) nel quale posizionare lo spreadsheet
short dx, // @parm Larghezza (in caratteri) dello spreasheet
short dy, // @parm Lunghezza (in caratteri) dello spreasheet
const char* maskname, // @parm Nome del file della maschera
int maskno, // @parm Numero identificativo della maschera nel file
const char* head, // @parm Titolo delle colonne
TSheet_field* o) // @parm Indica il campo della maschera che contiene lo spreadsheet
:
_mask(maskname, maskno), _notify(NULL),
_cur_row(0), _cur_col(1), _cur_rec(0), _edit_field(NULL), _active(TRUE),
_row_dirty(FALSE), _cell_dirty(FALSE), _check_enabled(TRUE),
_needs_update(-1), _selection_posted(-1), _save_columns_order(FALSE)
{
const int NUMBER_WIDTH = 3;
const int MAX_COL = 32;
int m_width[MAX_COL], v_width[MAX_COL];
int fixed_columns = 1; // Number of fixed columns
TControl::_fld = o;
sheet_mask().set_sheet(o);
// Calcolo larghezza massima tabella
TToken_string header(head);
TToken_string new_header(256);
int i = 0, tot_width = NUMBER_WIDTH+1;
int f_width = tot_width<<1; // Stima larghezza colonne fisse
int max_width = f_width; // Stima larghezza della colonna piu' grande
for (const char* h = header.get(); h; h = header.get(), i++)
{
CHECKD(i < MAX_COL, "Tu meni calumns in scit: ", i);
const int cid = FIRST_FIELD+i; // Column & Field ID
const TOperable_field & f = (TOperable_field &) _mask.field(cid); // Field on mask
TString testa(h);
const int at = testa.find('@');
const int m = f.size(); // Memory width
int v = m; // Video width
if (at >= 0)
{
const TString& wi = testa.mid(at+1);
v = atoi(wi);
if (wi.find('F') >= 0)
{
fixed_columns++;
f_width += v+1;
}
testa.cut(at);
v = max(at, v+(f.has_query_button() ? 1 : 0));
}
else
{
v = max(testa.len(), m+(f.has_query_button() ? 1 : 0));
}
if (v > 69)
v = 69;
m_width[i] = m+1; // m = number of allowed chars
v_width[i] = v+1; // v = width of column
if (v >= max_width) max_width = v+1;
tot_width += v_width[i];
new_header.add(testa);
}
_columns = i;
RCT rct; coord2rct(parent, x, y, dx, dy, rct);
rct.right -= 2*XI_FU_MULTIPLE; // toglie scroll-bar
// Controlla se ci sono troppe colonne fisse
if ((f_width+max_width)*XI_FU_MULTIPLE > rct.right)
fixed_columns = 1;
XI_OBJ* itf = get_interface(parent);
XI_OBJ_DEF* listdef = xi_add_list_def(NULL, dlg,
rct.top, rct.left, rct.bottom-rct.top,
XI_ATR_ENABLED | XI_ATR_VISIBLE,
NORMAL_COLOR, NORMAL_BACK_COLOR, // normal
NORMAL_COLOR, DISABLED_BACK_COLOR, // disabled
FOCUS_COLOR, // active
0);
CHECK(listdef, "Can't create spreadsheet definition");
listdef->app_data = (long)this;
XI_LIST_DEF* l = listdef->v.list;
l->width = rct.right - rct.left;
l->min_heading_height = xi_button_calc_height_font_id(xvt_default_font());
l->sizable_columns = TRUE;
l->movable_columns = TRUE;
l->scroll_bar = TRUE;
l->scroll_bar_button = TRUE;
l->fixed_columns = fixed_columns;
l->active_back_color = FOCUS_BACK_COLOR;
l->white_space_color = MASK_DARK_COLOR;
l->rule_color = MASK_DARK_COLOR;
// Definizione della prima colonna (numero di riga)
word attr = XI_ATR_RJUST;
if (sheet_mask().id2pos(FIRST_FIELD -1) != -1)
attr |= XI_ATR_SELECTABLE;
XI_OBJ_DEF* coldef = xi_add_column_def(listdef, 0, attr, 0,
NUMBER_WIDTH * XI_FU_MULTIPLE, NUMBER_WIDTH+1,
attr & XI_ATR_SELECTABLE ? "X" : "");
coldef->app_data = (long)this;
coldef->v.column->heading_platform = TRUE;
coldef->v.column->column_platform = TRUE;
if (attr & XI_ATR_SELECTABLE)
{
coldef->v.column->icon_rid = ICO_SEARCH;
coldef->v.column->icon_x = 2;
if (listdef->v.list->min_heading_height < 20)
listdef->v.list->min_heading_height = 20;
}
else
coldef->v.column->center_heading = TRUE;
for (h = new_header.get(0), i = 0; h; h = new_header.get(), i++)
{
const TString testo(h);
const int cid = FIRST_FIELD+i; // Column & Field ID
const TOperable_field & f = (const TOperable_field &)_mask.field(cid); // Field on mask
const int acqua = f.class_id();
long flags = XI_ATR_EDITMENU | XI_ATR_AUTOSCROLL | XI_ATR_FOCUSBORDER;
if (AUTOSELECT)
flags |= XI_ATR_AUTOSELECT;
switch (acqua)
{
case CLASS_EDIT_FIELD:
if (f.right_justified())
flags |= XI_ATR_RJUST;
break;
case CLASS_REAL_FIELD:
flags |= XI_ATR_RJUST;
break;
default:
break;
}
if (f.active()) flags |= XI_ATR_ENABLED;
else _column_disabled.set(i);
coldef = xi_add_column_def(listdef, cid, flags, cid,
v_width[i] * XI_FU_MULTIPLE, m_width[i],
(char*)(const char*)testo);
coldef->app_data = (long)this;
coldef->v.column->heading_platform = TRUE;
coldef->v.column->center_heading = TRUE;
}
// Create the whole thing!
_obj = xi_create(itf, listdef);
xi_dequeue(); // Flush events in XOL
xi_tree_free(listdef); // Free definitions
CHECKD(_obj, "Can't create spreadsheet ", owner().dlg());
update_tab_cid();
int num;
XI_OBJ** column = xi_get_member_list(_obj, &num);
for (i = 0; i < num; i++)
{
RCT rct; xi_get_rect(column[i], &rct);
_default_width[i] = rct.right - rct.left;
}
}
TSpreadsheet::~TSpreadsheet()
{
}
TMask& TSpreadsheet::sheet_mask() const
{
return ((TSpreadsheet*)this)->_mask;
}
// Converts a row number in the correspondig record number
int TSpreadsheet::row2rec(int& row)
{
int rows;
const long* handle = xi_get_list_info(_obj, &rows);
if (row < 0)
row = 0;
else
{
if (row >= rows)
row = rows-1;
}
const int r = (int)handle[row];
CHECKD(r >= 0 && r < items(), "Sheet line out of range: ", row);
return r;
}
// Converts a row number in the correspondig record number
int TSpreadsheet::rec2row(int record)
{
int rows;
const long* rec = xi_get_list_info(_obj, &rows);
int r = int(record - rec[0]);
if (r < 0 || r >= rows)
r = -1;
return r;
}
// Retrieves the corresponding field of the mask from a spredsheet cell
TOperable_field* TSpreadsheet::test_field(int pos) const
{
int num;
XI_OBJ** column = xi_get_member_list(_obj, &num);
CHECKD(pos >= 0 && pos < num, "Bad column number", pos);
TOperable_field* good = NULL;
for (short id = column[pos]->cid; ; id += 100)
{
TOperable_field* f = field(id);
if (f == NULL) break; // Search failed
good = f; // We've found a field with the proper ID ...
if (f->active()) break; // ... and it's active: end of search
}
return good;
}
// Retrieves the corresponding field of the mask from a spredsheet cell
TOperable_field* TSpreadsheet::col2field(int pos) const
{
TOperable_field* good = test_field(pos);
CHECKD(good, "Can't find field corresponding to column ", pos);
return good;
}
// Retrieves the corresponding field of the mask from a spredsheet cell
TOperable_field* TSpreadsheet::cell2field(const XI_OBJ* cell) const
{
XI_OBJ cella;
if (cell == NULL)
{
XI_MAKE_CELL(&cella, _obj, _cur_row, _cur_col);
cell = &cella;
}
return col2field(cell->v.cell.column);
}
int TSpreadsheet::cid2col(short cid) const
{
CHECKD(cid >= FIRST_FIELD, "Bad column id ", cid);
int num;
XI_OBJ** column = xi_get_member_list(_obj, &num);
for (int c = num-1; c > 0; c--)
{
if (column[c]->cid == cid)
return c;
}
return 0;
}
int TSpreadsheet::cid2index(short cid) const
{
CHECKD(cid >= FIRST_FIELD, "Bad column id ", cid);
return (cid % 100) - 1;
}
int TSpreadsheet::field2col(const TOperable_field* f) const
{
const short cid = FIRST_FIELD + cid2index(f->dlg());
return cid2col(cid);
}
void TSpreadsheet::update_rec(int rec)
{
const int riga = rec2row(rec);
if (riga >= 0)
{
const bool has_focus = rec == selected() && mask().focus_field().dlg() == owner().dlg();
// if (has_focus) xi_set_focus(get_interface());
XI_OBJ row;
XI_MAKE_ROW(&row, _obj, riga);
xi_cell_request(&row); // Update internal values
if (has_focus)
{
str2mask(_cur_rec);
set_focus_cell(riga, _cur_col);
}
}
if (_needs_update == rec)
_needs_update = -1;
}
// Cerca una colonna abilitata a partire da colonna
// La prima cella utilizzabile ha indice 1
// rec e' un numero di record assoluto
// colonna e' un numero di colonna a video: puo' succedere che la 3 corrisponda al campo 107
int TSpreadsheet::find_enabled_column(int rec, int colonna, int direction) const
{
CHECKD(direction == +1 || direction == -1, "Bad column search direction", direction);
int num;
XI_OBJ** column = xi_get_member_list(_obj, &num);
if (colonna <= 0 || colonna >= num)
colonna = 1;
int c = colonna;
do
{
const short n = column[c]->cid - FIRST_FIELD;
if (!cell_disabled(rec, n))
return c;
c += direction;
if (c >= num)
c = 1;
else
if (c <= 0)
c = num-1;
}
while (c != colonna);
return 0;
}
int TSpreadsheet::find_enabled_record(int rec, int direction) const
{
for (int r = rec+direction; r >= 0 && r < items(); r += direction)
{
if (find_enabled_column(r, 1, +1) > 0)
return r;
}
return -1;
}
// riga (da 0), colonna (0 = numero, 1 = prima cella, ...)
void TSpreadsheet::set_focus_cell(int riga, int colonna)
{
// xi_set_focus(get_interface());
const int rec = row2rec(riga);
colonna = find_enabled_column(rec, colonna, +1);
if (colonna > 0)
{
WINDOW win = xvt_scr_get_focus_vobj(); // Puo' essere NULL per cui poi non funziona ...
WINDOW par = parent(); // ... la xi_set_focus(&cell)
if (win != par)
{
xvt_scr_set_focus_vobj(par);
xvt_vobj_raise(par);
}
XI_OBJ cell;
XI_MAKE_CELL(&cell, _obj, riga, colonna);
xi_set_focus(&cell);
if (rec != _cur_rec)
{
_cur_rec = rec;
_cur_row = riga;
/* Guy! str2mask(_cur_rec); */
_row_dirty = FALSE;
}
_edit_field = col2field(_cur_col = colonna); // qui
}
}
// @doc INTERNAL
// @mfunc Inserisce un record in una posizione stabilita
//
// @rdesc Ritorna la posizione nella quale e' stato inserito il record. Se non riesce ad inserirlo
// ritorna -1.
int TSpreadsheet::insert(
int rec) // @parm Numero del record da inserire nello spreadsheet
// @comm Non e' possibile inserire un nuovo record nel caso nello spreadsheet vi siano
// almeno 999 righe oppure se lo spreadsheet non e' attivo.
{
static bool ininsert = FALSE;
if (ininsert || items() >= 999)
return -1;
if (rec < 0 && items() > 0 && !owner().append() )
{
XI_OBJ* itf = get_interface();
XI_OBJ* focus = xi_get_focus(itf);
if (focus && focus->type == XIT_CELL)
rec = _cur_rec + 1;
else
rec = 0;
}
ininsert = TRUE;
int r = rec < 0 ? items() : rec;
const bool ok = notify(r, K_INS);
if (ok)
{
r = _str.insert(new TToken_string(80), rec);
_property.insert(NULL, r);
// Notifica che l'inserimento h terminato
notify(r, K_CTRL + K_INS);
owner().post_insert(r);
xi_insert_row(_obj, INT_MAX);
xi_cell_request(_obj);
}
else
r = -1;
ininsert = FALSE;
return r;
}
// @doc INTERNAL
// @mfunc Inserisce un record (da programma) in una posizione stabilita
//
// @rdesc Ritorna la posizione nella quale e' stato inserito il record. Se non riesce ad inserirlo
// ritorna -1.
int TSpreadsheet::_insert(
int rec, // @parm Numero del record da inserire nello spreadsheet
bool update_sheet) // @parm Aggiornamento visuale dell sheet
// @comm Non e' possibile inserire un nuovo record nel caso nello spreadsheet vi siano
// almeno 999 righe oppure se lo spreadsheet non e' attivo.
{
if (items() >= 999)
return -1;
int r = _str.insert(new TToken_string(80), rec);
_property.insert(NULL, r);
owner().post_insert(r);
xi_insert_row(_obj, INT_MAX);
if (update_sheet)
xi_cell_request(_obj);
return r;
}
// @doc INTERNAL
// @mfunc Elimina una riga
//
// @rdesc Ritorna il risultato dell'operazione:
//
// @flag TRUE | Se la riga esisteve e quindi e' stata eliminata
// @flag FALSE | Se la riga non esisteve
bool TSpreadsheet::destroy(
int rec, // @parm Numero della riga da eliminare
bool update_sheet) // @parm Aggiornamento visuale dell sheet
// @comm Se il parametro <p rec> assume valore -1 vengono eliminate tutte le righe presenti
// nello spreadsheet
{
static bool indestroy = FALSE;
if ( indestroy )
return FALSE;
indestroy = TRUE;
bool ok = TRUE;
if (rec < 0)
{
_str.destroy();
_property.destroy();
set_dirty(_row_dirty = FALSE);
}
else
{
_property.destroy(rec, TRUE); // Destroy line info
ok = _str.destroy(rec, TRUE); // Destroy line
}
if (ok && mask().is_running() && update_sheet)
update(-1);
indestroy = FALSE;
return ok;
}
// @doc INTERNAL
// @mfunc Modifica a video la riga
void TSpreadsheet::update(
int rec) // @parm Numero della riga da modificare
// @comm Se il valore di <p row> e' minore di 0 viene aggiornato l'intero spreadsheet
{
if (rec < 0)
{
int num = 0;
const long* handle = xi_get_list_info(_obj, &num);
int first = 0, last = 0;
bool scroll = items() == 0; // || !owner().mask().is_running();
if (!scroll)
{
xi_get_visible_rows(_obj, &first, &last);
scroll = items() <= handle[first];
}
if (scroll)
xi_scroll(_obj, XI_SCROLL_FIRST);
else
{
const long as = AUTOSELECT ? XI_ATR_AUTOSELECT : 0;
xi_scroll_rec(_obj, handle[first], NORMAL_COLOR, XI_ATR_ENABLED | as, 0);
}
_needs_update = -1; // Clear pending row update
}
else
update_rec(rec);
}
void TSpreadsheet::notify_change()
{
if (!_row_dirty)
{
str2mask(_cur_rec);
_edit_field = cell2field(NULL); // Ricalcola correttamente il campo corrente
notify(_cur_rec, K_SPACE);
_row_dirty = _cell_dirty = TRUE;
set_dirty();
}
}
const char* TSpreadsheet::copy_cell2field(XI_OBJ* cell)
{
const char* txt;
if (cell == NULL)
{
XI_OBJ cella;
XI_MAKE_CELL(&cella, _obj, _cur_row, _cur_col);
txt = xi_get_text(&cella, NULL, -1);
}
else
txt = xi_get_text(cell, NULL, -1);
if (_edit_field->is_editable())
{
if (_edit_field->class_id() == CLASS_ZOOM_FIELD)
_edit_field->set(row(_cur_row).get(_cur_col - 1));
const char* val = _edit_field->is_kind_of(CLASS_LIST_FIELD) ? txt :
(const char*)((TEditable_field*)_edit_field)->win2raw(txt);
_edit_field->set(val);
_edit_field->set_dirty(); // Get it dirty!
}
return _edit_field->get();
}
bool TSpreadsheet::off_cell_handler(XI_OBJ *cell)
{
bool ok = TRUE;
if (_edit_field != NULL)
{
const char* nuo = copy_cell2field(cell);
if (_edit_field->on_key(_edit_field->is_edit() ? K_TAB : K_SPACE) == FALSE) // Test it
ok = *nuo == '\0'; // Se e' vuoto lascia stare
else
_cell_dirty = FALSE;
if (_row_dirty)
mask2str(_cur_rec); // Update sheet row
}
return ok;
}
bool TSpreadsheet::test_focus_change()
{
bool ok = xi_move_focus(get_interface()) ? TRUE : FALSE;
return ok;
}
// Certified 75%
bool TSpreadsheet::event_handler(XI_OBJ* itf, XI_EVENT *xiev)
{
static KEY _lastab = K_TAB;
static char tmp[16];
BOOLEAN& refused = xiev->refused;
switch (xiev->type)
{
case XIE_GET_FIRST:
if (items() > 0L)
{
long n = items() * (long)xiev->v.rec_request.percent / 100L;
if (n < 0L) n = 0L;
xiev->v.rec_request.data_rec = n;
}
else
refused = TRUE;
break;
case XIE_GET_LAST:
xiev->v.rec_request.data_rec = items()-1;
break;
case XIE_GET_PREV:
case XIE_GET_NEXT:
{
const long n = xiev->v.rec_request.spec_rec + (xiev->type == XIE_GET_NEXT ? +1 : -1) ;
if (n < 0 || n >= items())
refused = TRUE;
else
xiev->v.rec_request.data_rec = n;
}
break;
case XIE_CELL_REQUEST:
{
const int rec = (int)xiev->v.cell_request.rec;
const int maxlen = xiev->v.cell_request.len;
const char* src = NULL;
int nm;
XI_OBJ** obj = xi_get_member_list(xiev->v.cell_request.list, &nm);
const int num = xiev->v.cell_request.col_nbr;
const int cid = obj[num]->cid;
if (cid >= FIRST_FIELD)
{
if (rec < items())
{
const int col = cid - FIRST_FIELD;
const int curr = _cur_rec;
_cur_rec = rec;
const TOperable_field* f = field(cid);
_cur_rec = curr;
if (f)
{
const TEditable_field* e = (const TEditable_field*)f;
src = row(rec).get(col); // Set value for cell
if (src && *src)
{
if (e->is_kind_of(CLASS_LIST_FIELD))
/* src = src */; // Leave code as is
else
src = e->raw2win(src); // Get formatted string
}
if (cell_disabled(rec, col))
{
xiev->v.cell_request.back_color = DISABLED_BACK_COLOR;
xiev->v.cell_request.attrib &= ~XI_ATR_ENABLED;
}
else
{
get_back_and_fore_color(xiev->v.cell_request.back_color,
xiev->v.cell_request.color, rec);
}
if (e->has_query_button())
{
xiev->v.cell_request.button = TRUE;
xiev->v.cell_request.button_on_focus = TRUE;
}
}
else
xiev->v.cell_request.back_color = DISABLED_BACK_COLOR;
}
}
else
{
sprintf(tmp, "%d", rec+1);
src = tmp;
}
char* dst = xiev->v.cell_request.s;
if (src && *src)
{
strncpy(dst, src, maxlen);
dst[maxlen-1] = '\0';
}
else
*dst = '\0';
}
break;
case XIE_CHG_CELL:
if (_edit_field && !_cell_dirty)
{
notify_change();
_cell_dirty = TRUE;
_edit_field->set_dirty();
}
break;
case XIE_BUTTON:
if (_check_enabled)
{
on_idle(); // Termina tutti gli eventuali update in corso
if (xiev->v.xi_obj->type == XIT_CELL)
{
XI_CELL_DATA& cell = xiev->v.xi_obj->v.cell;
int num;
XI_OBJ** column = xi_get_member_list(_obj, &num);
CHECK(cell.column < num, "Bad column");
int rec = cell.row;
rec = row2rec(rec);
const int col = column[cell.column]->cid - FIRST_FIELD;
if (!cell_disabled(rec, col))
{
if (xi_move_focus(xiev->v.xi_obj))
dispatch_e_char(parent(), K_F9);
}
}
else
if (xiev->v.xi_obj->type == XIT_LIST)
{
owner().mask().notify_focus_field(owner().dlg());
insert(-1);
}
}
break;
case XIE_SELECT:
if (xiev->v.xi_obj->type == XIT_ROW)
{
_check_enabled = FALSE;
if (_cell_dirty)
off_cell_handler();
const int oldrec = _cur_rec;
set_pos(xiev->v.select.xi_obj->v.row, 1);
if (oldrec != _cur_rec)
{
_row_dirty = FALSE;
on_idle(); // Forces update delayed by str2mask
}
const int button_pos = sheet_mask().id2pos(FIRST_FIELD-1);
if (button_pos >= 0)
{
TMask & sm = owner().sheet_mask();
TMask_field& button = sm.fld(button_pos);
if (button.active())
{
str2mask(_cur_rec);
button.on_hit();
if (sm.dirty())
{
notify_change();
mask2str(_cur_rec);
}
}
}
_check_enabled = TRUE;
owner().highlight();
}
refused = TRUE;
break;
case XIE_DBL_CELL:
{
_check_enabled = FALSE;
const int oldrec = _cur_rec;
if ( xiev->v.xi_obj != NULL )
set_pos(xiev->v.xi_obj->v.cell.row, xiev->v.xi_obj->v.cell.column);
if (oldrec != _cur_rec || !_row_dirty)
{
_row_dirty = FALSE;
notify_change();
_cell_dirty = FALSE;
}
const KEY k = edit(_cur_rec);
if (k == K_ENTER)
_row_dirty = TRUE;
else
if (k == K_DEL)
{
_row_dirty = _cell_dirty = FALSE;
if (_cur_rec >= items())
{
_row_dirty = _cell_dirty = FALSE;
_cur_rec = items()-1;
_cur_row = 0; _cur_col = 1;
}
if (_cur_rec >= 0 && _cur_rec < items())
set_focus_cell(_cur_row, _cur_col);
}
_check_enabled = TRUE;
}
break;
case XIE_ON_LIST:
owner().mask().notify_focus_field(owner().dlg());
break;
case XIE_OFF_LIST:
on_idle();
break;
case XIE_ON_ROW:
if (_check_enabled)
{
const int row = xiev->v.xi_obj->v.row; // Riga in cui si sta entrando
int rows; // Numero totale di righe attive
const long* handle = xi_get_list_info(_obj, &rows);
// Calcola il numero del record corrispondente alla riga
const bool exist = row >= 0 && row < rows;
int next_rec = exist ? (int)handle[row] : items()-1;
// Se la riga non esiste o non ha nessuna cella valida abilitata ...
// ... cerca la prossima riga valida e rifiuta l'ingresso in questa
if (!exist || find_enabled_column(next_rec, 1, +1) <= 0)
{
next_rec = find_enabled_record(next_rec, next_rec >= _cur_rec ? +1 : -1);
post_select(next_rec);
refused = TRUE;
break;
}
// Setta _cur_rec in base a alla riga e cella correnti
set_pos(xiev->v.xi_obj->v.row, _cur_col);
if (_cur_rec < items() && notify(_cur_rec, K_TAB))
{
/* Guy! str2mask(_cur_rec); */
_row_dirty = FALSE;
}
else
{
_cur_row = _cur_rec = 0;
refused = TRUE;
}
}
break;
case XIE_OFF_ROW:
if (_check_enabled)
{
_check_enabled = FALSE; // Avoid recursion!
if (_row_dirty && active())
{
bool ok = owner().sheet_mask().check_fields();
if (ok)
{
mask2str(_cur_rec); // Update sheet with mask contents
ok = notify(_cur_rec, K_ENTER); // Notify edit
_row_dirty = FALSE; // Avoid double notifications!
}
if (ok)
{
xvt_statbar_refresh();
}
else
{
refused = TRUE;
}
}
if (!refused) // Notifica l'abbandono della riga
refused = !notify(_cur_rec, K_CTRL+K_TAB);
_check_enabled = TRUE;
}
break;
case XIE_ON_CELL:
if (_check_enabled)
{
const int physical_column = xiev->v.xi_obj->v.cell.column;
TOperable_field* f = test_field(physical_column);
bool disabled = TRUE;
if (f)
{
const int logical_column = (f->dlg()-FIRST_FIELD) % 100;
disabled = cell_disabled(_cur_rec, logical_column); // If the cell is disabled ...
}
if (disabled)
{
const int dir = _lastab == K_TAB ? +1 : -1;
const int nex = find_enabled_column(_cur_rec, physical_column, dir);
if (nex > 0) // If at least one enabled cell exists
set_focus_cell(_cur_row, nex);
else
refused = TRUE;
}
else
{
_edit_field = f;
_cur_col = physical_column;
_edit_field->set_focusdirty(_cell_dirty = FALSE);
// Azzera il flag di update_pending
EVENT e; e.type = E_UPDATE;
xi_eh(_obj->itf->v.itf->xvt_win, &e);
}
}
break;
case XIE_OFF_CELL:
if (_edit_field && _check_enabled && _cell_dirty)
{
_check_enabled = FALSE;
XI_OBJ* cell = xiev->v.xi_obj;
refused = !off_cell_handler(cell);
_check_enabled = TRUE;
}
break;
case XIE_COL_MOVE:
if (xiev->v.column.in_fixed ||
xiev->v.column.col_nbr < xi_get_fixed_columns(xiev->v.column.list))
refused = TRUE;
else
_save_columns_order = TRUE;
break;
case XIE_COL_SIZE:
_save_columns_order = TRUE;
break;
case XIE_GET_PERCENT:
{
const long rec = xiev->v.get_percent.record;
long n = items(); if (n <= 0) n = 1;
xiev->v.get_percent.percent = int(rec * 100L / n);
}
break;
case XIE_CLEANUP:
break;
case XIE_CHAR_CELL:
if (_edit_field)
{
const KEY k = xiev_to_key(xiev);
switch(k)
{
case K_F8:
case K_F9:
if (_edit_field != NULL)
{
notify_change();
copy_cell2field();
}
case K_F2:
case K_F11:
if (_check_enabled && active())
{
_check_enabled = FALSE; // Disable checks
notify_change();
bool ok = TRUE;
if (k == K_F9 && _edit_field->is_kind_of(CLASS_LIST_FIELD)) // list
{
XI_OBJ cell; XI_MAKE_CELL(&cell, _obj, _cur_row, _cur_col);
// droppa giu'
TList_field& lst = (TList_field&)(*_edit_field);
TDropDownList ddl(&cell, lst.get_codes(), lst.get_values());
ddl.open();
while (ddl.is_open())
do_events();
// sdroppa su
copy_cell2field();
}
else // edit_field
{
// Notifica il corretto campo col focus sulla maschera
sheet_mask().notify_focus_field(_edit_field->dlg());
ok = _edit_field->on_key(k);
if (!ok && k == K_F9) // Ricerca non completata?
{
_edit_field = &owner().sheet_mask().focus_field();
const int col = field2col(_edit_field);
if (col != _cur_col) // Ricerca alternativa
{
_cur_col = col;
dispatch_e_char(parent(), K_F9);
}
}
}
if (ok)
{
mask2str(_cur_rec);
on_idle(); // Update immediately!
}
else
set_focus_cell(_cur_row, _cur_col);
_check_enabled = TRUE; // Re-enable checks
}
break;
case K_CTRL + '-':
{
if (owner().mask().id2pos(DLG_DELREC) && notify(_cur_rec, K_DEL))
{
int rec = _cur_rec;
_row_dirty = FALSE;
destroy(rec);
if (rec < items())
str2mask(rec);
notify(rec, K_CTRL+K_DEL); // Notifica l'avvenuta cancellazione
if (rec >= items())
rec = items() - 1;
if (rec >= 0)
select(rec, FALSE);
}
refused = TRUE;
}
break;
case K_CTRL + '+':
owner().mask().notify_focus_field(owner().dlg());
insert(-1);
refused = TRUE;
break;
case K_CTRL + 'A':
{
_check_enabled = FALSE;
if (_cell_dirty)
off_cell_handler();
const KEY k = edit(_cur_rec);
if (k == K_ENTER)
_row_dirty = TRUE;
else
if (k == K_DEL)
{
_row_dirty = _cell_dirty = FALSE;
if (_cur_rec >= items())
{
_row_dirty = _cell_dirty = FALSE;
_cur_rec = items()-1;
_cur_row = 0; _cur_col = 1;
}
if (_cur_rec >= 0 && _cur_rec < items())
set_focus_cell(_cur_row, _cur_col);
}
_check_enabled = TRUE;
refused = TRUE;
}
break;
case K_CTRL + 'B':
{
_check_enabled = FALSE;
if (_cell_dirty)
off_cell_handler();
const int button_pos = sheet_mask().id2pos(FIRST_FIELD-1);
if (button_pos >= 0)
{
TMask & sm = owner().sheet_mask();
TMask_field& button = sm.fld(button_pos);
if (button.active())
{
str2mask(_cur_rec);
button.on_hit();
if (sm.dirty())
{
notify_change();
mask2str(_cur_rec);
}
}
}
_check_enabled = TRUE;
owner().highlight();
refused = TRUE;
}
break;
case K_CTRL+K_PREV:
xi_scroll(_obj, XI_SCROLL_PGUP);
break;
case K_CTRL+K_NEXT:
xi_scroll(_obj, XI_SCROLL_PGDOWN);
break;
case K_CTRL+K_HOME:
xi_scroll(_obj, XI_SCROLL_FIRST);
break;
case K_CTRL+K_END:
xi_scroll(_obj, XI_SCROLL_LAST);
break;
default:
if (k > K_CTRL)
{
refused = TRUE;
} else
if (is_edit_key(k) && !_edit_field->on_key(k))
{
refused = TRUE;
beep();
} else
if (_edit_field->is_kind_of(CLASS_LIST_FIELD))
{
notify_change(); // Aggiorna valore corrente listbox
TList_field& lst = ((TList_field&)*_edit_field);
bool changed = FALSE;
switch (k)
{
case K_RIGHT:
changed = lst.select_next();
break;
case K_LEFT:
changed = lst.select_prev();
break;
default:
if (k >= ' ' && k <= 'z')
changed = lst.select_by_initial(k);
break;
}
if (changed)
{
XI_OBJ cell; XI_MAKE_CELL(&cell, _obj, _cur_row, _cur_col);
xi_set_text(&cell, (char*)(const char*)lst.get());
_cell_dirty = TRUE;
}
refused = TRUE;
}
break;
}
}
break;
case XIE_XVT_EVENT:
if (xiev->v.xvte.type == E_CHAR)
{
const KEY k = e_char_to_key(&xiev->v.xvte);
switch (k)
{
case K_ROWEDIT:
xiev->type = XIE_DBL_CELL;
xiev->v.xi_obj = NULL;
event_handler(itf, xiev);
break;
case K_TAB:
case K_BTAB:
_lastab = k;
break;
case K_UP:
case K_DOWN:
_lastab = (_cur_col == 2) ? K_BTAB : K_TAB;
break;
case K_ENTER:
case K_SHIFT+K_ENTER:
{
const int next_rec = find_enabled_record(_cur_rec, k == K_ENTER ? +1 : -1);
if (next_rec >= 0)
{
dispatch_e_char(parent(), k == K_ENTER ? K_DOWN : K_UP);
}
else
{
// if (xi_move_focus(get_interface())) // Test di uscita dalla cella corrente
// {
// xi_set_focus(_obj); // Riporta il focus sullo sheet
dispatch_e_char(parent(), k == K_ENTER ? K_F3 : K_F4);
// }
refused = TRUE;
}
}
break;
case K_ESC:
if (xi_move_focus(get_interface()))
{
owner().mask().on_key(k);
refused = TRUE;
}
break;
case K_CTRL + 'A':
case K_CTRL + 'B':
case K_CTRL + '-':
case K_CTRL + '+':
case K_CTRL+K_PREV:
case K_CTRL+K_NEXT:
case K_CTRL+K_HOME:
case K_CTRL+K_END:
break;
default:
if (k > K_CTRL)
{
if (xi_move_focus(get_interface()))
owner().mask().on_key(k);
refused = TRUE;
}
break;
}
}
break;
default:
break;
}
return !refused;
}
void TSpreadsheet::activate(bool on)
{
_active = on;
const dword old = xi_get_attrib(_obj);
dword att = on ? (old & ~XI_ATR_NAVIGATE) : (old | XI_ATR_NAVIGATE);
if (old != att)
{
int num;
XI_OBJ** columns = xi_get_member_list(_obj, &num);
xi_move_focus(get_interface()); // Set focus to interface
if (on)
att |= XI_ATR_TABWRAP;
else
att &= ~XI_ATR_TABWRAP;
xi_set_attrib(_obj, att);
for (int col = 1; col < num; col++)
{
XI_OBJ* column = columns[col];
att = xi_get_attrib(column);
if (on)
{
att &= ~XI_ATR_READONLY;
if (AUTOSELECT)
att |= XI_ATR_AUTOSELECT;
}
else
{
att |= XI_ATR_READONLY;
att &= ~XI_ATR_AUTOSELECT;
}
xi_set_attrib(column, att); // Set new attributes
}
}
}
void TSpreadsheet::select(int rec, bool scrollto)
{
if (!scrollto)
{
int rows;
const long* handle = xi_get_list_info(_obj, &rows);
int first = 0, last = 0;
xi_get_visible_rows(_obj, &first, &last);
scrollto = rec < handle[first] || rec > handle[last];
}
if (scrollto)
{
const long as = AUTOSELECT ? XI_ATR_AUTOSELECT : 0;
xi_scroll_rec(_obj, rec, NORMAL_COLOR, XI_ATR_ENABLED | as, 0);
}
const int row = rec2row(rec);
const bool has_focus = mask().focus_field().dlg() == owner().dlg();
if (has_focus)
{
_cur_rec = -1;
set_focus_cell(row, 1);
}
else
{
_edit_field = col2field(_cur_col = 1);
_cur_rec = rec;
_cur_row = row;
str2mask(_cur_rec);
_row_dirty = FALSE;
}
notify(rec, K_TAB);
}
void TSpreadsheet::post_select(int rec)
{
_selection_posted = rec;
}
void TSpreadsheet::on_idle()
{
if (_needs_update >= 0)
{
if (_needs_update < items())
update_rec(_needs_update);
_needs_update = -1;
}
if (_selection_posted >= 0)
{
const int next_row = _selection_posted;
_selection_posted = -1;
if (next_row < items())
select(next_row, FALSE);
}
}
// @doc INTERNAL
// @mfunc Cerca la colonna col
XI_OBJ* TSpreadsheet::find_column(
int col) const // @parm Indice o identificatore colonna
{
CHECKD(col >= 0, "Bad column ", col);
if (col < FIRST_FIELD) // Se e' un indice trasformalo in identificatore
col += FIRST_FIELD;
else
if (col >= FIRST_FIELD+100) // Riportalo nel range 101 - 199
col = FIRST_FIELD + cid2index(col);
int num;
XI_OBJ** columns = xi_get_member_list(_obj, &num);
for (int c = num-1; c >= 0; c--)
{
if (columns[c]->cid == col)
break;
}
return c >= 0 ? columns[c] : NULL;
}
TMask& TSpreadsheet::mask() const
{
TMask* m = (TMask*)xvt_vobj_get_data(parent());
return *m;
}
// Ritorna il campo con l'identificatore dato della maschera dello sheet
TOperable_field* TSpreadsheet::field(short id) const
{
const TMask & sm = owner().sheet_mask();
const int pos = sm.id2pos(id);
return pos < 0 ? NULL : (TOperable_field*)&sm.fld(pos);
}
// Ricopia i campi della maschera nel record dato ed aggiorna il display
void TSpreadsheet::mask2str(int rec)
{
TToken_string& r = row(rec);
owner().mask2row(rec, r);
if (_needs_update != rec)
{
if (_needs_update >= 0)
update_rec(_needs_update); // Double update!
_needs_update = rec;
}
}
// Certified 50%
// @doc INTERNAL
// @mfunc Permette di abilitare/disabilitare una singola cella
void TSpreadsheet::enable_cell(
int row, // @parm Riga della cella da abilitare/disabilitare
int column, // @parm Colonna della cella da abilitare/disabilitare
bool on) // @parm Indica l'operazione da effettuare sulla cella:
//
// @flag TRUE | La cella viene abilitata (default)
// @flag FALSE| La cella viene disabilitata
{
if (column >= FIRST_FIELD)
column = cid2index(column);
TRow_property* prop = get_property(row);
if (prop == NULL)
{
if (on) return; // Don't waste time and memory
prop = get_property(row, TRUE);
}
TBit_array& ba = prop->_disabled;
if (column >= 0)
{
ba.set(column, !on);
}
else
{
if (on)
ba.reset();
else
{
ba.set(_columns); // Force right array size
ba.set(); // Set all bits
}
}
}
void TSpreadsheet::set_back_and_fore_color(COLOR back, COLOR fore, int row)
{
TRow_property* prop = get_property(row, TRUE);
if (back != COLOR_INVALID)
prop->_back = back;
if (fore != COLOR_INVALID)
prop->_fore = fore;
}
void TSpreadsheet::get_back_and_fore_color(COLOR& back, COLOR& fore, int row)
{
TRow_property* prop = get_property(row, FALSE);
if (prop)
{
if (prop->_back != NORMAL_BACK_COLOR)
back = prop->_back;
if (prop->_fore != NORMAL_COLOR)
fore = prop->_fore;
}
/*
else
{
back = NORMAL_BACK_COLOR;
fore = NORMAL_COLOR;
}
*/
}
// @doc INTERNAL
// @mfunc Permette di abilitare/disabiltare una colonna
void TSpreadsheet::enable_column(
int col, // @parm Numero della colonna da abilitare/disabilitare
bool on) // @parm Indica l'operazione da effettuare sulla colonna:
//
// @flag TRUE | Abilita la colonna (default)
// @flag FALSE| Disabilita la colonna
{
if (col >= FIRST_FIELD)
col = cid2index(col);
const bool change = _column_disabled[col] == on;
_column_disabled.set(col, !on);
if (change)
{
XI_OBJ* column = find_column(col);
if (column)
{
dword attr = xi_get_attrib(column);
if (on) attr |= XI_ATR_ENABLED;
else attr &= ~XI_ATR_ENABLED;
xi_set_attrib(column, attr); // Set new attributes
}
}
}
void TSpreadsheet::delete_column( const int col ) const
{
XI_OBJ* column = find_column(col);
if (column)
xi_delete(column);
}
void TSpreadsheet::move_column( const int fromindex, const int toindex) const
{
int num;
XI_OBJ** columns = xi_get_member_list(_obj, &num);
CHECKD(fromindex+1 < num, "Can't move column ", fromindex);
XI_OBJ* column = columns[fromindex+1];
xi_move_column( column, toindex );
}
void TSpreadsheet::swap_columns(const int fromid, const int toid) const
{
int num;
XI_OBJ** columns = xi_get_member_list(_obj, &num);
XI_OBJ* from_column = XI_NULL_OBJ;
XI_OBJ* to_column = XI_NULL_OBJ;
int from_pos = 0;
int to_pos = 0;
for (int c = num-1; c > 0; c--)
{
XI_OBJ* column = columns[c];
if (column->cid == fromid)
{
from_column = column;
from_pos = c;
}
if (column->cid == toid)
{
to_column = column;
to_pos = c;
};
}
CHECKD(from_pos, "Can't swap column ", fromid);
CHECKD(to_pos, "Can't swap column ", toid);
xi_move_column(from_column, to_pos);
xi_move_column(to_column, from_pos);
}
void TSpreadsheet::swap_rows( const int fromindex, const int toindex)
{
_str.swap(fromindex, toindex);
_property.swap(fromindex, toindex);
}
void TSpreadsheet::set_column_width(const int col, const int width) const
{
XI_OBJ* column = find_column(col);
if (column)
xi_set_column_width(column, width); // Force redraw
}
void TSpreadsheet::set_column_header(const int col, const TString& header) const
{
XI_OBJ* column = find_column(col);
if (column)
{
xi_set_text(column, (char *)(const char *)header );
RCT r; xi_get_rect(column, &r);
xi_set_column_width(column, (r.right-r.left+1) / CHARX); // Force redraw
}
}
void TSpreadsheet::set_column_justify(int col, bool right)
{
XI_OBJ* column = find_column(col);
if (column)
{
dword attr = xi_get_attrib(column);
if (right)
attr |= XI_ATR_RJUST;
else
attr &= ~XI_ATR_RJUST;
xi_set_attrib(column, attr); // Set new attribute
update(-1);
}
}
TSpreadsheet::TRow_property* TSpreadsheet::get_property(int row, bool create)
{
TRow_property* p = (TRow_property*)_property.objptr(row);
if (p == NULL && create)
{
p = new TRow_property;
_property.add(p, row);
}
return p;
}
// Costruisce l'identificatore del paragrafo contenente la disposizione
// delle colonne del campo f
HIDDEN TFilename& field2parag(const TMask_field& f, TFilename& name)
{
const TMask& m = f.mask();
name = m.source_file();
name.ext(""); // Nome della maschera senza estensione
if (m.number() > 0) // Aggiunge l'eventuale numero di sotto-maschera
name << '(' << m.number() << ')';
return name;
}
void TSpreadsheet::save_columns_order() const
{
if (_save_columns_order)
{
TFilename parag; field2parag(owner(), parag);
TConfig config(CONFIG_USER, parag); // Apre il file di configurazione
if (_save_columns_order == TRUE) // Se vale 3 devo solo resettare
{
int num;
XI_OBJ** column = xi_get_member_list(_obj, &num);
TToken_string order(127); // Nuovo ordine delle colonne
for (int i = 0; i < num; i++) // Scorre le colonne
{
order.add(column[i]->cid);
RCT rct; xi_get_rect(column[i], &rct);
order << ',' << rct.right - rct.left;
}
config.set("Browse", order, NULL, TRUE, owner().dlg());
}
else
config.remove("Browse", owner().dlg());
}
}
void TSpreadsheet::load_columns_order()
{
TFilename parag; field2parag(owner(), parag);
TConfig config(CONFIG_USER, parag);
const int index = owner().dlg();
TToken_string order = config.get("Browse", NULL, index);
if (order.empty_items())
config.remove("Browse", index);
else
set_columns_order(&order);
}
void TSpreadsheet::set_columns_order(TToken_string* order)
{
XI_OBJ* itf = get_interface();
XI_OBJ* focus = xi_get_focus(itf);
xi_set_focus(itf);
int num_cols;
XI_OBJ** column = xi_get_member_list(_obj, &num_cols);
// Costante da sottrarre nella xi_column_set_pixel_width altrimenti la somma due volte!
const int offset = 2 * (int)xi_get_pref(XI_PREF_COLUMN_OFFSET);
const int fixed = xi_get_fixed_columns(_obj);
if (fixed > 1)
xi_set_fixed_columns(_obj, 1);
if (order == NULL)
{
for (int index = 0; index < num_cols; index++)
{
const short cid = index ? FIRST_FIELD + index - 1 : 0;
XI_OBJ* col = find_column(cid);
if (col)
{
if (index >= fixed)
xi_move_column(col, index);
RCT rct; xi_get_rect(col, &rct);
if (_default_width[index] != rct.right - rct.left)
xi_column_set_pixel_width(col, _default_width[index]-offset);
}
}
_save_columns_order = 0x3;
}
else
{
TToken_string col(8, ',');
int pos = 0;
for (col = order->get(0); !col.blank(); col = order->get(), pos++)
{
const int cid = col.get_int(0);
const int width = col.get_int();
XI_OBJ* column = find_column(cid);
if (column) // Controlla che esista ancora
{
if (pos >= fixed && pos < num_cols)
xi_move_column(column, pos); // Sposta la colonna
if (width > XI_FU_MULTIPLE) // Se ha una larghezza valida
xi_column_set_pixel_width(column, width - offset);
}
}
_save_columns_order = FALSE;
}
if (fixed > 1)
xi_set_fixed_columns(_obj, fixed);
if (focus)
xi_set_focus(focus);
}
// Certified 99%
// @doc INTERNAL
// @mfunc Controlla se una cella o un'intera riga e' disabilitata
//
// @rdesc Se column e' minore di zero si considera l'intera riga
// @rdesc Ritorna lo stato della cella indicata:
//
// @flag TRUE | Se la cella e' disabilitata
// @flag FALSE| Se la cella e' abilitata
bool TSpreadsheet::cell_disabled(int row, int column) const
{
const TRow_property* prop = ((TSpreadsheet*)this)->get_property(row);
bool d;
if (column < 0)
d = (prop == NULL) ? FALSE : (prop->_disabled.ones() >= columns()-1);
else
{
d = _column_disabled[column]; // Controlla la colonna
if (d == FALSE && prop != NULL) // Se la colonna e' disabilitata e' inutile proseguire
d = prop->_disabled[column]; // Controlla la cella
}
return d;
}
// Certified 75%
void TSpreadsheet::str2mask(int riga)
{
if (riga == items())
{
const int curr = _cur_rec;
_cur_rec = riga;
owner().sheet_mask().reset();
_cur_rec = curr;
mask2str(riga);
return;
}
TToken_string& r = row(riga);
owner().row2mask(riga, r);
}
// Certified 100%
bool TSpreadsheet::notify(int rec, KEY k)
{
const bool ok = _notify ? _notify(owner(), rec, k) : TRUE;
if (k == K_ENTER)
set_dirty(ok ? TRUE : 3);
return ok;
}
// Certified 99%
KEY TSpreadsheet::edit(int n)
{
str2mask(n);
KEY k = owner().run_editmask(n);
if (active())
{
if (k == K_ENTER)
{
mask2str(n);
}
else
{
if (k == K_DEL)
{
const bool ok = notify(n, K_DEL); // Notifica intenzione di cancellare
if (ok)
{
destroy(n);
if (n < items())
str2mask(n);
notify(n, K_CTRL+K_DEL); // Notifica l'avvenuta cancellazione
}
}
else
if (k == K_ESC)
{
str2mask(n); // Ripristina valori precedenti
}
}
}
return k;
}
///////////////////////////////////////////////////////////
// TSheet_field
///////////////////////////////////////////////////////////
// Certified 100%
TSheet_field::TSheet_field(TMask* m)
: TOperable_field(m), _append(TRUE)
{
}
// Certified 100%
word TSheet_field::class_id() const
{
return CLASS_SHEET_FIELD;
}
bool TSheet_field::is_kind_of(word cid) const
{ return cid == CLASS_SHEET_FIELD || TOperable_field::is_kind_of(cid); }
// Certified 100%
TSheet_field::~TSheet_field()
{
}
// Certified 100%
void TSheet_field::reset()
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
if (s->items())
s->select(0, FALSE);
s->destroy();
s->sheet_mask().reset();
set_dirty(); // Reset any error (dirty = 3)
set_dirty(mask().is_running()); // Set dirty state based on mask status
force_update();
}
// Certified 100%
void TSheet_field::destroy(int r, bool update_sheet)
{
((TSpreadsheet*)_ctl)->destroy(r, update_sheet);
}
// Certified 100%
int TSheet_field::insert(int r, bool update_sheet)
{
return ((TSpreadsheet*)_ctl)->_insert(r, update_sheet);
}
void TSheet_field::parse_head(TScanner& scanner)
{
_ctl_data._width = scanner.integer();
_ctl_data._height = scanner.integer();
if (_ctl_data._height == 0)
_ctl_data._height = -1;
}
// Certified 100%
bool TSheet_field::parse_item(TScanner& scanner)
{
if (scanner.key() == "IT")
{
_ctl_data._park.add(scanner.string());
return TRUE;
}
return TMask_field::parse_item(scanner);
}
// Certified 100%
void TSheet_field::create(WINDOW parent)
{
const TMask& m = mask();
const TString head(_ctl_data._park);
_ctl = new TSpreadsheet(parent, dlg(), _ctl_data._x, _ctl_data._y, _ctl_data._width, _ctl_data._height,
m.source_file(), m.sheets(), head, this);
_ctl->show(shown());
if (!_flags.enable_default)
{
_flags.enabled = TRUE; // Lo sheet e' sempre operabile anche se non editabile
disable();
}
const TMask & s = sheet_mask();
for (short id = FIRST_FIELD; ; id++)
if (s.id2pos(id) < 0) break;
_last_column_id = id - 1;
((TSpreadsheet*)_ctl)->load_columns_order();
}
// Certified 100%
TString_array& TSheet_field::rows_array() const
{
return ((TSpreadsheet*)_ctl)->rows_array();
}
// Certified 100%
// Ritorna l'indice della prima riga vuota dello sheet
int TSheet_field::first_empty() const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
const int max = (int)s->items();
for (int n = 0; n < max; n++)
if (s->row(n).empty_items())
break;
return n;
}
// @doc EXTERNAL
// @mfunc Ritorna nuova riga dello spreadshhet
//
// @rdesc Ritorna la stringa letta
TToken_string& TSheet_field::row(
int n) // @parm Numero della riga da leggere/creare
// @comm Se il parametro <p n> e maggiore del numero massimo di righe presenti
// o minore di 0 viene aggiunta una riga vuota in fondo allo spreadsheet
// (viene chiamata la <mf TSpreadsheet::add>)
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
const int max = (int)s->items();
if (n < 0 || n >= max)
{
if (n < 0) n = first_empty();
if (n >= max)
n = (int)s->add(new TToken_string(80));
}
return s->row(n);
}
// @doc EXTERNAL
// @mfunc Forza l'aggiornamento dei dati della riga sullo schermo
void TSheet_field::force_update(
int r) // @parm Numero della riga da aggiornare
// @comm Se il parametro <p r> assume valore -1 vengono aggiornate tutte le righe presenti
// nello spreadsheet
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->update(r);
}
int TSheet_field::items() const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
return (int)s->items();
}
int TSheet_field::selected() const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
return s != NULL ?(int)s->selected() : -1;
}
void TSheet_field::set_notify(SPREADSHEET_NOTIFY n)
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->set_notify(n);
}
// Certified 50%
void TSheet_field::highlight() const
{
// TEditable_field::highlight();
TSpreadsheet* s = (TSpreadsheet*)_ctl;
if (s->_check_enabled)
{
int rows; xi_get_list_info(s->_obj, &rows);
if (rows > 0)
{
if (s->notify(s->_cur_rec, K_TAB))
{
s->set_focus_cell(s->_cur_row, s->_cur_col);
s->str2mask(selected());
}
}
}
}
void TSheet_field::enable(bool on)
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->activate(on);
}
bool TSheet_field::enabled() const
{
// return items() > 0;
return TMask_field::enabled();
}
int TSheet_field::cid2index(short cid) const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
return s->cid2index(cid);
}
void TSheet_field::enable_column(int column, bool on)
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->enable_column(column, on);
}
void TSheet_field::enable_cell(int row, int column, bool on)
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->enable_cell(row, column, on);
}
bool TSheet_field::column_enabled(int column) const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
return s->column_enabled(column);
}
bool TSheet_field::column_disabled(int column) const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
return s->column_disabled(column);
}
bool TSheet_field::cell_disabled(int row, int column) const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
return s->cell_disabled(row, column);
}
// Matteo
void TSheet_field::delete_column( const int col ) const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->delete_column( col );
}
void TSheet_field::move_column( const int fromindex, const int toindex ) const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->move_column(fromindex, toindex);
}
void TSheet_field::swap_columns(const int fromid, const int toid) const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->swap_columns(fromid, toid);
}
void TSheet_field::swap_rows( const int fromindex, const int toindex)
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->swap_rows(fromindex, toindex);
}
void TSheet_field::set_column_width( const int col, const int width ) const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->set_column_width(col, width);
}
void TSheet_field::set_column_header( const int col, const TString& header ) const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->set_column_header(col, header);
}
void TSheet_field::set_column_justify(int col, bool right)
{
if (col < FIRST_FIELD)
col += FIRST_FIELD;
sheet_mask().field(col).set_justify(right);
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->set_column_justify(col, right);
}
TMask& TSheet_field::sheet_mask() const
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
return s->sheet_mask();
}
bool TSheet_field::on_hit()
{
if (!mask().is_running()) // Inizializzazione maschera
{
force_update();
if (items() > 0)
{
mask().notify_focus_field(dlg()); // Fa' credere alla maschera che ha il focus ...
select(0); // ... cosi' la set_focus_cell funziona bene
}
set_dirty(FALSE);
}
return TRUE;
}
void TSheet_field::select(int r, bool scrollto)
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
s->select(r, scrollto);
}
bool TSheet_field::on_key(KEY k)
{
if (k == K_TAB && items() > 0)
{
if (focusdirty())
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
if (!s->test_focus_change())
return FALSE;
}
}
if (k == K_ROWEDIT && items() > 0)
{
select(items()-1);
XI_EVENT xie;
xie.type = XIE_DBL_CELL;
xie.v.xi_obj = NULL;
_ctl->event_handler(NULL, &xie);
return TRUE;
}
return TOperable_field::on_key(k);
}
void TSheet_field::on_idle()
{
((TSpreadsheet*)_ctl)->on_idle();
}
void TSheet_field::exchange(bool show_value, const real& nuo)
{
TMask& m = sheet_mask();
const real& vec = mask().exchange();
if (vec != nuo)
{
TBit_array valuta(32);
int i = 0;
for (int f = FIRST_FIELD; ;f++, i++)
{
const int pos = m.id2pos(f);
if (pos < 0) break;
if (m.fld(pos).class_id() == CLASS_REAL_FIELD)
{
if (m.fld(pos).exchangeable())
valuta.set(i);
}
}
for (int riga = 0; riga < items(); riga++)
{
TToken_string& r = row(riga);
for (const char* s = r.get(i = 0); s; s = r.get(++i))
if (*s > ' ' && valuta[i])
{
real v(s);
v *= nuo;
v /= vec;
v.round();
r.add(v.string(), i);
}
}
}
m.set_exchange(show_value, nuo);
if (mask().is_running())
force_update();
}
// Ricopia i campi della maschera nel record dato
void TSheet_field::mask2row(int n, TToken_string & rec)
{
const TMask& m = sheet_mask();
rec.cut(0);
const TSpreadsheet& s = (const TSpreadsheet&)*_ctl;
for (short id = FIRST_FIELD; id <= _last_column_id ; id++)
{
int pos = m.id2pos(id);
const int firstpos = pos;
if (pos >= 0)
{
for(int dlg = id; pos >= 0; pos = m.id2pos(dlg += 100))
{
const TMask_field& f = m.fld(pos);
if (f.shown() || f.ghost())
{
rec.add(f.get());
if (active() && s.active())
{
const int col = cid2index(id);
if (!s.column_disabled(col))
{
const bool on = f.enabled();
enable_cell(n, col, on);
}
}
break;
}
}
#ifdef DBG
if (pos < 0 && s.cid2col(id) > 0)
yesnofatal_box("Mask2row: Non e' visibile il campo %d", id);
#endif
}
if (pos < 0)
rec.add(firstpos >= 0 ? m.fld(firstpos).get() : " ");
}
}
// Ricopia i campi del record dato nella maschera
void TSheet_field::row2mask(int n, TToken_string & r)
{
TString val(80);
TMask& m = sheet_mask();
const int campi = m.fields();
const TSpreadsheet& s = (const TSpreadsheet&)*_ctl;
int i; // Conatatore di tutti i cicli successivi
for (short id = FIRST_FIELD; id <= _last_column_id; id++)
{
const int index = cid2index(id);
val = r.get(index);
int dlg = id;
for(int pos = m.id2pos(dlg); pos >= 0; pos = m.id2pos(dlg += 100))
{
TMask_field& f = m.fld(pos);
f.set(val);
const bool on = s.active() && !cell_disabled(n, index);
if (f.enabled() != on)
f.enable(on);
}
}
for (i = 0; i < campi; i++)
{
TMask_field& f = m.fld(i);
const short id = f.dlg();
if (id >= FIRST_FIELD &&
!f.is_kind_of(CLASS_BUTTON_FIELD) &&
(f.active() || f.ghost()))
{
if (f.has_check())
f.check(STARTING_CHECK);
f.set_dirty(FALSE);
f.on_hit();
}
}
for (i = 0; i < campi; i++)
{
TMask_field& f = m.fld(i);
if (f.dirty() == TRUE)
f.set_dirty(FALSE);
}
val.format("Riga %d", n+1);
m.set_caption(val);
}
void TSheet_field::set_back_and_fore_color(COLOR back, COLOR fore, int row)
{
TSpreadsheet& s = (TSpreadsheet&)*_ctl;
s.set_back_and_fore_color(back, fore, row);
}
void TSheet_field::reset_columns_order()
{
TSpreadsheet& s = (TSpreadsheet&)*_ctl;
s.set_columns_order(NULL);
}
void TSheet_field::save_columns_order()
{
const TSpreadsheet& s = (const TSpreadsheet&)*_ctl;
s.save_columns_order();
}
void TSheet_field::check_row(int n)
{
TSpreadsheet* s = (TSpreadsheet*)_ctl;
const int current = s->_cur_rec;
s->_cur_rec = n;
TMask& m = sheet_mask();
CHECK(!m.is_running(), "Can't use check_row while sheet mask is running");
TToken_string & r = row(n);
const int max = m.fields();
TMaskmode mask_mode = (TMaskmode) m.mode();
m.set_mode(MODE_INS);
for (int i = max - 1; i >= 0; i--)
{
TMask_field & f = m.fld(i);
if (f.has_check())
f.set_dirty();
}
row2mask(n, r);
mask2row(n, r);
m.set_mode(mask_mode);
s->_cur_rec = current;
}
Reference in New Issue View Git Blame Copy Permalink