root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Aggiunta documentazione in linea

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@2546 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
andrea 1996-01-31 17:19:02 +00:00
parent a17eaa542a
commit 41a0596be2
23 changed files with 1771 additions and 669 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
include/applicat.cpp
View File

@ -26,6 +26,7 @@
#define BITTEST(w,p) (((w) & (0x0001 << (p))) != 0)
// @doc EXTERNAL
///////////////////////////////////////////////////////////
// Metodi di accesso globali all'applicazione corrente
@ -33,13 +34,23 @@
HIDDEN TApplication* _application = NULL;
// @func Ritorna l'applicazione in corso
//
// @rdesc Ritorna il reference all'applicazione in corso
TApplication& main_app()
{
CHECK(_application, "NULL application!");
return *_application;
}
bool xvt_running() { return _application != NULL; }
// @func Controlla se si sta eseguendo xvt
//
// @rdesc Ritorna i seguenti valori:
//
// @flag TRUE | Se se e' stata definita una <c TApplication>
// @flag FALSE | Se se non e' stata definita una <c TApplication>
bool xvt_running()
{ return _application != NULL; }
///////////////////////////////////////////////////////////
// Gestione dello sfondo della finestra principale
@ -379,7 +390,14 @@ void TApplication::set_perms()
}
void TApplication::check_parameters(int & argc, char* argv[])
// @mfunc Legge il parametro /uUTENTE e lo toglie dalla lista
void TApplication::check_parameters(
int & argc, // @parm Numero del parametro da controllare
char* argv[]) // @parm Array di paramentri da passare all'applicazione
// @comm Nel caso si identifichi che il paramentro <p argc> sia il nome dell'utente
// si setta la variabile col nome dell'utente, altrimenti l'utente diventa PRASSI,
// e si diminuisce di uno il numero di argomenti da passare.
{
if (argc > 1)
{
@ -401,7 +419,13 @@ void TApplication::check_parameters(int & argc, char* argv[])
}
void TApplication::run(int argc, char* argv[], const char* title)
// @mfunc Fa partire l'applicazione
void TApplication::run(
int argc, // @parm Numero deglia argomenti da passara all'applicazione
char* argv[], // @parm Argomenti da passare all'applicazione
const char* title) // @parm Titolo dell'applicazione
// @comm E' in questa fase che si controlla se esiste la chiave e' attaccata
{
TFilename base(argv[0]);
base.ext(""); base.lower();
@ -489,7 +513,14 @@ void TApplication::uncheck_menu_item(MENU_TAG item)
}
void TApplication::enable_menu_item(MENU_TAG item, bool on)
// @mfunc Permette di abilitare/disabilitare una voce di menu'
void TApplication::enable_menu_item(
MENU_TAG item, // @parm Voce del menu' da abilitare/disabilitare
bool on) // @parm Operazione da svolgere sulla voce del menu':
//
// @flag TRUE | Viene abilitata la voce del menu'
// @flag FALSE | Viene disabilitata la voce del menu'
{
xvt_menu_set_item_enabled(TASK_WIN, item, on);
xvt_menu_update(TASK_WIN);
@ -585,13 +616,16 @@ bool TApplication::set_firm(long newfirm)
return TRUE;
}
// @mfunc Gestisce le voci di configurazione
//
// @rdesc Ritorna TRUE se sono state cambiate delle voci
bool TApplication::config()
// gestisce le voci di configurazione
// le si passa il file in cui cercare il proprio
// paragrafo (comunque relativo alla ditta)
// se non c'e', viene creato copiando il default
// la variabile EdMask di quel paragrafo specifica
// la maschera da usare
// @comm Le si passa il file in cui cercare il proprio paragrafo (comunque relativo
// alla ditta) se non c'e', viene creato copiando il default la variabile EdMask
// di quel paragrafo specifica la maschera da usare.
{
TConfig cnf(CONFIG_DITTA);
bool ok = FALSE;
@ -642,7 +676,12 @@ bool TApplication::config()
return ok;
}
void TApplication::set_cursor(bool w)
// @mfunc Cambia il cursore del mouse
void TApplication::set_cursor(
bool w) // @parm Indica il tipo di cursore da utilizzare:
//
// @flag TRUE | Cursore a clessidra per le wait
// @flag FALSE | Cursore a frecca normale
{
static int _count = 0;
@ -661,9 +700,15 @@ void TApplication::set_cursor(bool w)
}
}
// Ritorna TRUE se al programma corrente e' concesso cambiare ditta da menu.
// Praticamente controlla se e' stato lanciato da ba0 o dal program manager
// @mfunc Controlla se al programma corrente e' concesso cambiare ditta da menu.
//
// @rdesc Ritoran i seguenti valori:
//
// @flag TRUE | Se e' abilitata la voce di menu' per il cambio della ditta
// @flag FALSE | Se non e' possibile cambiare ditta da menu'
bool TApplication::firm_change_enabled() const
// @comm Praticamente controlla se e' stato lanciato da ba0 o dal program manager
{
#if XVT_OS == XVT_OS_WIN
static bool can = 2;

180
include/applicat.h
View File

@ -9,9 +9,7 @@
#include <strings.h>
#endif
// @C
// Classe TApplication
// @END
// @doc EXTERNAL
#define MSG_AI "AI" // message auto_insert (relapp)
#define MSG_FS "FS" // message filtered start (relapp)
@ -20,97 +18,181 @@
#define CHK_DONGLE 0 // dongle authorization checks
#define CHK_USER 1 // user authorization checks
// @class TApplication | Classe per la gestione di tutte le applicazioni PRASSI
class TApplication
// @author:(INTERNAL) Guido
// @access Private Member
{
// @DPRIV
// @cmember Identificatore del menu' legato all'applicazione
int _bar;
// @cmember Numero di argomenti passati all'applicazione
int __argc;
// @cmember Array di argomenti passati all'applicazione
const char** __argv;
// @cmember Array di autorizzazione concessa della chiavi
TBit_array _dongle_aut;
// @cmember Array di autorizzazione concessa all'utente
TBit_array _user_aut;
TString80 _name, _title;
long _savefirm;
bool _create_ok; // Succesfully created
word _waiting;
void terminate(); // End of application
void set_cursor(bool w); // Change mouse cursor
bool config(); // Change parameters
void about() const; // About box
// @cmember Nome dell'applicazione
TString80 _name;
// @cmember Titolo della finestra
TString80 _title;
// @cmember Codice della ditta
long _savefirm;
// @cmember Indica se e' stata creata con successo
bool _create_ok;
// @cmember Handle del modulo del programma di cui si sta attendendo la fine
word _waiting;
// @cmember Termine dell'applicazione
void terminate();
// @cmember Cambia il cursore del mouse
void set_cursor(bool w);
// @cmember Gestisce le voci di configurazione
bool config();
// @cmember About box: risposta alla opzione Informazioni del menu File
void about() const;
// @access Protected Member
protected:
// @cmember Ritorna il nome del modulo dell'applicazione
const char* get_module_name() const;
// @cmember Event handler della finestra principale del programma
static long XVT_CALLCONV1 task_eh(WINDOW win, EVENT* ep);
// @cmember Handler degli eventi della finestra principale, chiamato da <mf TApplication::task_eh>
virtual long handler(WINDOW win, EVENT* ep);
virtual bool extended_firm() const { return FALSE; } // Extended set_firm dialog box
virtual bool use_files() const { return TRUE; }
virtual bool create(); // Crea la finestra principale
virtual bool menu(MENU_TAG) { return TRUE; } // Controlla il menu
virtual bool build_firm_data(long cod, bool flagcom = FALSE) { return TRUE;}
virtual bool destroy(); // Rimuove l'applicazione
// @cmember Estende il dialog box della set_firm
virtual bool extended_firm() const
{ return FALSE; }
// @cmember Indica se si intendono usare i files DBF
virtual bool use_files() const
{ return TRUE; }
// @cmember Crea la finestra principale
virtual bool create();
// @cmember Controlla il menu
virtual bool menu(MENU_TAG)
{ return TRUE; }
// @cmember Chiamata ogni volta che viene cambiata una ditta
virtual bool build_firm_data(long cod, bool flagcom = FALSE)
{ return TRUE;}
// @cmember Rimuove l'applicazione
virtual bool destroy();
// @cmember Chiamata ogni volta che l'utente usa il menu Cambia Parametri
virtual void on_config_change();
// @cmember Chiamata ogni volta che l'utente cambia ditta
virtual void on_firm_change();
// @cmember Setta i permessi di utilizzo dei moduli
void set_perms();
// @access Public Member
public:
// @FPUB
void setbar(int menubar) { _bar = menubar;} // Modifica la menu-bar
// @cmember Modifca la barra dei menu' inserendo la <p menubar>
void setbar(int menubar)
{ _bar = menubar;}
// @cmember Fa partire l'applicazione
void run(int argc, char* argv[], const char* name);
// @DES Queste funzioni possono essere ridefinite da ogni applicazione
// @FPUB
virtual word class_id() const { return CLASS_APPLICATION; }
virtual bool ok() const { return _create_ok; }
// @comm Queste funzioni possono essere ridefinite da ogni applicazione
//
// @cmember Ritorna l'identificatore della classe
virtual word class_id() const
{ return CLASS_APPLICATION; }
// @cmember Controlla se si tratta di una applicazione valida
virtual bool ok() const
{ return _create_ok; }
// @cmember Risposta alla selezione Stampa del menu File
virtual void print();
// @cmember Controlla se al programma corrente e' concesso cambiare ditta da menu.
virtual bool firm_change_enabled() const;
virtual const char * extra_modules() const {return "";}
void stop_run(); // Forza chiusura applicazione
// @cmember Ritorna la <c TToken_string> con la lista dei moduli cui appartiene il programma
virtual const char * extra_modules() const
{return "";}
void check_menu_item(MENU_TAG item); // Check menu
void uncheck_menu_item(MENU_TAG item); // Uncheck
// @cmember Forza la chiusura dell'applicazione
void stop_run();
// @cmember Mette il segno Check a fianco di una voce di menu
void check_menu_item(MENU_TAG item);
// @cmember Toglie il segno Check a fianco di una voce di menu
void uncheck_menu_item(MENU_TAG item);
// @cmember Permette di abilitare/disabilitare una voce di menu'
void enable_menu_item(MENU_TAG item, bool on = TRUE);
void disable_menu_item(MENU_TAG item) { enable_menu_item(item, FALSE); }
// @cmember Permette di disabilitare una voce di menu' (chiama <mf TApplication::enable_menu_item>)
void disable_menu_item(MENU_TAG item)
{ enable_menu_item(item, FALSE); }
// @cmember Simula la selezione di una voce di menu
void dispatch_e_menu(MENU_TAG item);
const TString& name() const { return _name; }
const char** argv() const { return __argv; }
// @cmember Ritorna il nome dell'applicazione
const TString& name() const
{ return _name; }
// @cmember Ritorna l'array di paramentri da passara all'applicazione
const char** argv() const
{ return __argv; }
// @cmember Ritroan il paramentro <p i>-esimo da passare all'applicazione
const char* argv(int i) const { return __argv[i]; }
int argc() const { return __argc; }
// @cmember Ritorna il numero di paramentri da passare all'applicazione
int argc() const
{ return __argc; }
void set_title(const char* t) { _title = t; }
const TString& title() const { return _title; }
// @cmember Setta il titolo da assegnare all'applicazione
void set_title(const char* t)
{ _title = t; }
// @cmember Ritorna il titolo da assegnare all'applicazione
const TString& title() const
{ return _title; }
static void check_parameters(int & argc, char *argv[]);
// @cmember static void | check_parameters | int & argc, char *argv[] |
// Legge il parametro /uUTENTE e lo toglie dalla lista
static void check_parameters(int& argc, char *argv[]);
// @cmember Controlla se il modulo <p module> ha l'autorizzazione all'esecuzione
bool has_module(int module, int checktype = CHK_ALL) const;
// @cmember Setta la ditta corrente (Ritorna se ce l'ha fatta)
bool set_firm(long cod = -1);
// @cmember Ritorna la ditta corrente
long get_firm() const;
// @cmember Ritorna la directory in cui si trovano i dati della ditta corrente
const char* get_firm_dir() const;
void wait_for(word taskid) { _waiting = taskid; }
void wake_up() { _waiting = 0xFFFF; }
word waiting() const { return _waiting; }
void begin_wait() { set_cursor(TRUE); } // Set CURSOR_WAIT
void end_wait() { set_cursor(FALSE); } // Set CURSOR_ARROW
// Main window menu runtime interface
// @cmember Attende la fine del modulo con handle <p taskid>
void wait_for(word taskid)
{ _waiting = taskid; }
// @cmember Interrompe lo stato di attesa
void wake_up()
{ _waiting = 0xFFFF; }
// @cmember Ritorna l'handle del task di cui l'applicazione e' in attesa
word waiting() const
{ return _waiting; }
// @cmember Setta il cursore a clessidra
void begin_wait()
{ set_cursor(TRUE); }
// @cmember Setta il cursore standard
void end_wait()
{ set_cursor(FALSE); }
// @cmember Interfaccia runtime del menu' della finestra principale???
bool add_menu(TString_array& menu, MENU_TAG id = 0);
// @cmember Elimina il menu' <p id> (Ritorna se ce l'ha fatta???)
bool remove_menu(MENU_TAG id);
// @cmember Costruttore
TApplication();
// @cmember Distruttore
virtual ~TApplication();
};
bool xvt_running(); // xvt is running?
bool xvt_running();
TApplication& main_app();
#endif /* __APPLICATION_H */

2
include/array.h
View File

@ -12,7 +12,7 @@
// @doc EXTERNAL
//
// @type COMPARE_FUNCTION | Prototipo funzione di confronto tra elementi della
// clsse <c TObject> da passare al metodo sort dei <c TArray>
// classe <c TObject> da passare al metodo sort dei <c TArray>
typedef (*COMPARE_FUNCTION)(const TObject**, const TObject**);
// @doc EXTERNAL

357
include/controls.cpp
View File

@ -17,9 +17,11 @@ extern "C"
#define STRICT
#include <windows.h>
///////////////////////////////////////////////////////////
// @doc INTERNAL
///////////////////////////////////////////////////////////
// TPicture_array
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
class TPicture_array : public TArray
{
@ -28,14 +30,14 @@ public:
//TImage& image(short id) { return (TImage&)operator[](id); }
const TImage& image(short id) const { return (const TImage&)operator[](id); }
bool exist(short id) const { return objptr(id) != NULL; }
bool exist(short id) const { return objptr(id) != NULL; }
TPicture_array() : TArray(128) {}
~TPicture_array() {}
};
TImage& TPicture_array::add(short id, bool convert)
{
{
TImage* i = (TImage*)objptr(id);
if (i == NULL)
@ -43,10 +45,10 @@ TImage& TPicture_array::add(short id, bool convert)
i = new TImage(id);
TArray::add(i, id);
if (convert)
i->convert_to_default_colors();
}
return *i;
i->convert_to_default_colors();
}
return *i;
}
///////////////////////////////////////////////////////////
@ -56,7 +58,7 @@ TImage& TPicture_array::add(short id, bool convert)
HIDDEN TControl* creating = NULL;
HIDDEN long ctl_flags;
HIDDEN WINDOW _hdc;
HIDDEN RCT _client;
HIDDEN RCT _client;
HIDDEN TPicture_array cpb;
HIDDEN void get_geometry(WINDOW win)
@ -114,13 +116,13 @@ void xvt_draw_rect(WINDOW win, const RCT& rect, COLOR lt, COLOR rb, short depth)
{
if (pen.color != rb)
{
pen.color = rb;
xvt_dwin_set_cpen(win, &pen);
pen.color = rb;
xvt_dwin_set_cpen(win, &pen);
}
if (!drawed)
{
p.h = r.right; p.v = r.top;
xvt_dwin_draw_set_pos(win, p);
p.h = r.right; p.v = r.top;
xvt_dwin_draw_set_pos(win, p);
}
p.v = r.bottom;
xvt_dwin_draw_line(win, p);
@ -136,17 +138,24 @@ void xvt_draw_rect(WINDOW win, const RCT& rect, COLOR lt, COLOR rb, short depth)
}
}
// @mfunc Crea il controllo
void TControl::create(
short left, short top, short right, short bottom, const char* title,
WINDOW parent, long flags, long app_data, short id)
short left, // @parm Coordinata X di posizionamento (in pixel)
short top, // @parm Coordinata Y di posizionamento (in pixel)
short right, // @parm Larghezza (in pixel)
short bottom, // @parm Altezza (in pixel)
const char* title, // @parm Prompt
WINDOW parent, // @parm Handle della finestra a cui apprtiene il controllo
long flags, // @parm Flags di configurazione
long app_data, // @parm Puntatore all'oggetto <c TControl>
short id) // @parm Identificatore assegnato
{
bool bold = FALSE;
_color = NORMAL_COLOR;
_backcolor = MASK_BACK_COLOR;
while (*title == '@' || *title == '$')
{
{
switch (*title++)
{
case '@':
@ -155,24 +164,24 @@ void TControl::create(
case '$':
title++; // Skip [
if (isalpha(*title))
_color = trans_color(*title);
_color = trans_color(*title);
else
{
int r = 0, g = 0, b = 0;
sscanf(title, "%d,%d,%d", &r, &g, &b);
_color = MAKE_COLOR(r, g, b);
{
int r = 0, g = 0, b = 0;
sscanf(title, "%d,%d,%d", &r, &g, &b);
_color = MAKE_COLOR(r, g, b);
}
while (*title != ']') // Find ]
{
CHECK(*title, "Bad prompt color format");
title++;
}
CHECK(*title, "Bad prompt color format");
title++;
}
break;
default:
break;
}
break;
}
title++;
}
}
const int prop_count = 1;
const char* prop_list[prop_count+1] = { title, NULL };
@ -187,8 +196,8 @@ void TControl::create(
creating = this;
ctl_flags = flags;
_win = xvtcm_create(id, left, top, right, bottom,
prop_count, (char**)prop_list, parent,
0, 0, NULL, handler, set_creation_args);
prop_count, (char**)prop_list, parent,
0, 0, NULL, handler, set_creation_args);
CHECKD(_win, "Can't create control ", id);
creating = NULL;
@ -254,19 +263,19 @@ long XVT_CALLCONV1 TControl::handler(WINDOW win, EVENT* ep)
xvt_vobj_get_client_rect(win, &r);
if (xvt_rect_has_point(&r, ep->v.mouse.where))
{
if (!pressed)
{
cc->mouse_down(ep->v.mouse.where);
pressed = TRUE;
}
if (!pressed)
{
cc->mouse_down(ep->v.mouse.where);
pressed = TRUE;
}
}
else
{
if (pressed)
{
cc->update();
pressed = FALSE;
}
if (pressed)
{
cc->update();
pressed = FALSE;
}
}
}
break;
@ -277,8 +286,8 @@ long XVT_CALLCONV1 TControl::handler(WINDOW win, EVENT* ep)
tracking = FALSE;
if (pressed)
{
cc->mouse_up();
pressed = FALSE;
cc->mouse_up();
pressed = FALSE;
}
}
break;
@ -294,7 +303,11 @@ long XVT_CALLCONV1 TControl::handler(WINDOW win, EVENT* ep)
return 0L;
}
void TControl::enable(bool on)
// @mfunc Abilita/disabilita il controllo
void TControl::enable(
bool on) // @parm Operazione da svolgere sul controllo:
// @flag TRUE | Il controllo viene abilitato
// @flag FALSE | Il controllo viene disabilitato
{
if (on == disabled())
{
@ -304,7 +317,11 @@ void TControl::enable(bool on)
}
}
void TControl::check(bool on)
// @mfunc Setta se il controllo debba avere un check
void TControl::check(
bool on) // @parm Puo' assumere i seguenti valori:
// @flag TRUE | Se il controllo deve avere un check
// @flag FALSE | Se il controllo non deve avere un check
{
_checked = on;
}
@ -318,7 +335,7 @@ void TControl::update() const
}
void TControl::set_caption(const char* t)
{
{
_caption = t;
update();
}
@ -335,13 +352,13 @@ protected:
public:
TText(short left, short top, short right, short bottom,
const char* caption, WINDOW parent,
long flags, long app_data, short id);
const char* caption, WINDOW parent,
long flags, long app_data, short id);
};
TText::TText(short left, short top, short right, short bottom,
const char* caption, WINDOW parent,
long flags, long app_data, short id)
const char* caption, WINDOW parent,
long flags, long app_data, short id)
{
create(left, top+1, right, bottom-1, caption, parent, flags, app_data, id);
}
@ -366,15 +383,15 @@ protected:
public:
TGroup(short left, short top, short right, short bottom,
const char* caption, WINDOW parent,
long flags, long app_data, short id);
const char* caption, WINDOW parent,
long flags, long app_data, short id);
};
TGroup::TGroup(short left, short top, short right, short bottom,
const char* caption, WINDOW parent,
long flags, long app_data, short id)
const char* caption, WINDOW parent,
long flags, long app_data, short id)
: TText(left, top, right, bottom, caption, parent, flags | CTL_FLAG_DISABLED, app_data,
(id < 0) ? -2 : id)
(id < 0) ? -2 : id)
{}
void TGroup::draw_round_rect(const RCT& r, COLOR c) const
@ -427,14 +444,14 @@ protected:
public:
TButton(short left, short top, short right, short bottom,
const char* caption,WINDOW parent,
long flags, long app_data, short id);
const char* caption,WINDOW parent,
long flags, long app_data, short id);
};
TButton::TButton(short left, short top, short right, short bottom,
const char* caption, WINDOW parent,
long flags, long app_data, short id)
const char* caption, WINDOW parent,
long flags, long app_data, short id)
{
create(left, top, right, bottom, caption, parent, flags, app_data, id);
}
@ -504,21 +521,21 @@ protected:
public:
TPush_button(short left, short top, short right, short bottom,
const char* caption, WINDOW parent,
long flags, long app_data, short id);
const char* caption, WINDOW parent,
long flags, long app_data, short id);
virtual ~TPush_button();
};
TPush_button::TPush_button(short left, short top, short right, short bottom,
const char* capt, WINDOW parent,
long flags, long app_data, short id)
const char* capt, WINDOW parent,
long flags, long app_data, short id)
: TButton(left-(id == DLG_F9), top, right, bottom,
capt, parent, flags, app_data, id),
_picup(0), _picdn(0)
capt, parent, flags, app_data, id),
_picup(0), _picdn(0)
{
switch(id)
{
case DLG_OK:
if (strcmp("Conferma", caption()) == 0)
capt = format("#%d", BMP_OK);
@ -543,7 +560,7 @@ TPush_button::TPush_button(short left, short top, short right, short bottom,
case DLG_STOPREC:
capt = format("#%d", BMP_STOPREC);
break;
/*
/*
case DLG_FIRSTREC:
capt = format("#%d", BMP_FIRSTREC);
break;
@ -556,7 +573,7 @@ TPush_button::TPush_button(short left, short top, short right, short bottom,
case DLG_LASTREC:
capt = format("#%d", BMP_LASTREC);
break;
*/
*/
case DLG_SAVEREC:
capt = format("#%d#%d", BMP_SAVEREC, BMP_SAVERECDN);
break;
@ -593,8 +610,8 @@ TPush_button::TPush_button(short left, short top, short right, short bottom,
const int height = bottom-top;
const int width = right-left;
const char* diesis = strchr(capt, '#');
const char* diesis = strchr(capt, '#');
if (diesis != NULL)
{
_picup = atoi(++diesis);
@ -604,8 +621,8 @@ TPush_button::TPush_button(short left, short top, short right, short bottom,
{
_picdn = atoi(++diesis);
cpb.add(_picdn);
}
}
_dx = (width - pic.width()) >> 1;
_dy = (height - pic.height()) >> 1;
@ -615,9 +632,9 @@ TPush_button::TPush_button(short left, short top, short right, short bottom,
{
TFixed_string c(capt);
_accel = c.find('~');
if (_accel > 0)
if (_accel > 0)
_accel = xvt_dwin_get_text_width(win(), (char*)capt, _accel);
_dx = (width - xvt_dwin_get_text_width(win(), (char*)caption(), -1)) >> 1;
_dy = (height- CHARY)/2 + BASEY - DEPTH;
}
@ -632,23 +649,23 @@ void TPush_button::draw_pressed(bool pressed) const
TButton::draw_pressed(pressed);
if (_picup)
{
{
const short pic = (pressed && _picdn) ? _picdn : _picup;
if (cpb.exist(pic))
{
const TImage& i = cpb.image(pic);
RCT dst = i.rect();
RCT dst = i.rect();
if (pressed)
xvt_rect_offset(&dst, _dx+DEPTH, _dy+DEPTH);
xvt_rect_offset(&dst, _dx+DEPTH, _dy+DEPTH);
else
xvt_rect_offset(&dst, _dx, _dy);
xvt_rect_offset(&dst, _dx, _dy);
i.draw(_hdc, dst);
}
}
else
{
const char* t = caption();
const short x = _dx + DEPTH*pressed;
const short y = _dy + DEPTH*pressed;
@ -656,7 +673,7 @@ void TPush_button::draw_pressed(bool pressed) const
xvt_dwin_draw_text(_hdc, x+1, y+1, (char*)t, -1);
if (_accel >= 0)
xvt_dwin_draw_text(_hdc, x+_accel+1, y+1, "_", 1);
const COLOR c = disabled() ? DISABLED_COLOR : color();
xvt_dwin_set_fore_color(_hdc, c);
xvt_dwin_draw_text(_hdc, x, y, (char*)t, -1);
@ -696,17 +713,17 @@ void TPush_button::update() const
for (int i = sx; i < ex; i += 2)
{
PNT p = { sy, i };
xvt_dwin_draw_set_pos(_hdc, p);
p.v = ey;
xvt_dwin_draw_line(_hdc, p);
PNT p = { sy, i };
xvt_dwin_draw_set_pos(_hdc, p);
p.v = ey;
xvt_dwin_draw_line(_hdc, p);
}
for (i = sy; i < ey; i += 2)
{
PNT p = { i, sx };
xvt_dwin_draw_set_pos(_hdc, p);
p.h = ex;
xvt_dwin_draw_line(_hdc, p);
PNT p = { i, sx };
xvt_dwin_draw_set_pos(_hdc, p);
p.h = ex;
xvt_dwin_draw_line(_hdc, p);
}
}
}
@ -736,25 +753,25 @@ TPage_button::TPage_button(WINDOW parent, byte flag) : _flag(flag)
RCT r; xvt_vobj_get_client_rect(parent, &r);
const int w = (flag == 3) ? width : width2;
if (flag == 2) r.right -= w;
create(r.right-w, r.bottom-height, r.right, r.bottom,
"", parent, 0L, 0L, DLG_PAGE);
"", parent, 0L, 0L, DLG_PAGE);
cpb.add(BMP_BOOK1 + flag -1, flag == 3);
}
void TPage_button::mouse_down(PNT where)
{
bool p;
{
bool p;
switch (_flag)
{
case 1:
p = FALSE; break;
case 2:
p = TRUE;
p = TRUE;
default:
p = where.h < (width2); break;
}
check(p);
check(p);
}
void TPage_button::mouse_up()
@ -764,13 +781,13 @@ void TPage_button::mouse_up()
void TPage_button::update() const
{
TControl::update();
TControl::update();
if (_flag)
cpb.image(BMP_BOOK1 + _flag -1).draw(_hdc);
}
void TPage_button::set_flag(byte f)
{
{
_flag = f;
update();
}
@ -878,8 +895,8 @@ protected:
public:
TCheckbox(short left, short top, short right, short bottom,
const char* caption, WINDOW parent,
long flags, long app_data, short id);
const char* caption, WINDOW parent,
long flags, long app_data, short id);
virtual ~TCheckbox();
};
@ -888,20 +905,20 @@ TCheckbox::TCheckbox(
const char* caption, WINDOW parent,
long flags, long app_data, short id)
: TButton(left, top, right, bottom,
caption, parent, flags, app_data, id)
caption, parent, flags, app_data, id)
{
if (!cpb.exist(BMP_CHECK_ON))
{
TImage& i = cpb.add(BMP_CHECK_ON, TRUE);
{
TImage& i = cpb.add(BMP_CHECK_ON, TRUE);
const short dx = 0;
const short dy = BASEY - i.height() + 2;
i.set_pos(dx, dy);
cpb.add(BMP_CHECK_OFF, TRUE).set_pos(dx, dy);
cpb.add(BMP_RADIO_ON, TRUE).set_pos(dx, dy);
cpb.add(BMP_RADIO_OFF, TRUE).set_pos(dx, dy);
}
}
}
@ -922,9 +939,9 @@ void TCheckbox::draw_pressed(bool pressed) const
short pic;
if (radio())
pic = pressed ? BMP_RADIO_ON : BMP_RADIO_OFF;
else
else
pic = pressed ? BMP_CHECK_ON : BMP_CHECK_OFF;
if (cpb.exist(pic))
cpb.image(pic).draw(_hdc);
}
@ -958,48 +975,72 @@ void TCheckbox::update() const
// User functions
///////////////////////////////////////////////////////////
// @func Permette di creare un Checkbox
//
// @rdesc Ritorna l'handle del controllo creato
WINDOW xvt_create_checkbox(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id)
short left, // @parm Coordinata X di posizionamento (in pixel)
short top, // @parm Coordinata Y di posizionamento (in pixel)
short right, // @parm Larghezza (in pixel)
short bottom, // @parm Altezza (in pixel)
const char* caption, // @parm Prompt
WINDOW parent, // @parm Handle della finestra a cui apprtiene il controllo
long flags, // @parm Flags di configurazione
long app_data, // @parm Puntatore all'oggetto <c TControl>
int id) // @parm Identificatore assegnato
// @comm Il controllo si ditruggera' automagicamente alla fine della sua vita.
{
TCheckbox* cb = new TCheckbox(left, top, right, bottom,
caption, parent,
flags, app_data, id);
caption, parent,
flags, app_data, id);
// It'll destroy itself automagically :-)
return cb->win();
}
// @func Permette di creare un Radiobutton
//
// @rdesc Ritorna l'handle del controllo creato
WINDOW xvt_create_radiobutton(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id)
short left, // @parm Coordinata X di posizionamento (in pixel)
short top, // @parm Coordinata Y di posizionamento (in pixel)
short right, // @parm Larghezza (in pixel)
short bottom, // @parm Altezza (in pixel)
const char* caption, // @parm Prompt
WINDOW parent, // @parm Handle della finestra a cui apprtiene il controllo
long flags, // @parm Flags di configurazione
long app_data, // @parm Puntatore all'oggetto <c TControl>
int id) // @parm Identificatore assegnato
// @comm Il controllo si ditruggera' automagicamente alla fine della sua vita.
{
flags |= CTL_FLAG_MULTIPLE;
TCheckbox* cb = new TCheckbox(left, top, right, bottom,
caption, parent,
flags, app_data, id);
caption, parent,
flags, app_data, id);
// It'll destroy itself automagically :-)
return cb->win();
}
// @func Permette di creare un qualsiasi Bottone premibile
//
// @rdesc Ritorna l'handle del controllo creato
WINDOW xvt_create_pushbutton(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id)
short left, // @parm Coordinata X di posizionamento (in pixel)
short top, // @parm Coordinata Y di posizionamento (in pixel)
short right, // @parm Larghezza (in pixel)
short bottom, // @parm Altezza (in pixel)
const char* caption, // @parm Prompt
WINDOW parent, // @parm Handle della finestra a cui apprtiene il controllo
long flags, // @parm Flags di configurazione
long app_data, // @parm Puntatore all'oggetto <c TControl>
int id) // @parm Identificatore assegnato
// @comm Il controllo si ditruggera' automagicamente alla fine della sua vita.
{
TControl* pb;
@ -1018,8 +1059,8 @@ WINDOW xvt_create_pushbutton(
bottom -= BASEY>>1;
}
pb = new TPush_button(left, top, right, bottom,
caption, parent,
flags, app_data, id);
caption, parent,
flags, app_data, id);
}
// It'll destroy itself automagically :-)
@ -1027,38 +1068,54 @@ WINDOW xvt_create_pushbutton(
}
// @func Permette di creare un campo di solo Testo
//
// @rdesc Ritorna l'handle del controllo creato
WINDOW xvt_create_text(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id)
short left, // @parm Coordinata X di posizionamento (in pixel)
short top, // @parm Coordinata Y di posizionamento (in pixel)
short right, // @parm Larghezza (in pixel)
short bottom, // @parm Altezza (in pixel)
const char* caption, // @parm Prompt
WINDOW parent, // @parm Handle della finestra a cui apprtiene il controllo
long flags, // @parm Flags di configurazione
long app_data, // @parm Puntatore all'oggetto <c TControl>
int id) // @parm Identificatore assegnato
// @comm Il controllo si ditruggera' automagicamente alla fine della sua vita.
{
TText* cb = new TText(left, top, right, bottom,
caption, parent,
flags, app_data, id);
caption, parent,
flags, app_data, id);
// It'll destroy itself automagically :-)
return cb->win();
}
// @func Permette di creare un Groupbox
//
// @rdesc Ritorna l'handle del controllo creato
WINDOW xvt_create_groupbox(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id)
short left, // @parm Coordinata X di posizionamento (in pixel)
short top, // @parm Coordinata Y di posizionamento (in pixel)
short right, // @parm Larghezza (in pixel)
short bottom, // @parm Altezza (in pixel)
const char* caption, // @parm Prompt
WINDOW parent, // @parm Handle della finestra a cui apprtiene il controllo
long flags, // @parm Flags di configurazione
long app_data, // @parm Puntatore all'oggetto <c TControl>
int id) // @parm Identificatore assegnato
// @comm Il controllo si ditruggera' automagicamente alla fine della sua vita.
{
TGroup* cb = new TGroup(left, top, right, bottom,
caption, parent,
flags, app_data, id);
caption, parent,
flags, app_data, id);
// It'll destroy itself automagically :-)
return cb->win();
}
// @func Dealloca le bitmab utilizzate per i controlli
void free_controls_bmp()
{
cpb.destroy();
@ -1082,13 +1139,13 @@ void xvt_change_page_tags(WINDOW pag, bool on, WINDOW tag, byte p)
if (on) f |= 0x1;
else f &= 0x2;
pb->set_flag(f);
}
}
if (tag != NULL_WIN)
{
TTag_button* pt = (TTag_button*)TControl::WINDOW2TControl(tag);
pt->set_pages(p);
}
}
}

183
include/controls.h
View File

@ -6,105 +6,154 @@
#endif
WINDOW xvt_create_checkbox(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id
);
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id);
WINDOW xvt_create_radiobutton(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id
);
WINDOW xvt_create_radiobutton(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id);
WINDOW xvt_create_pushbutton(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id
);
WINDOW xvt_create_pushbutton(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id);
WINDOW xvt_create_text(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id
);
WINDOW xvt_create_text(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id);
WINDOW xvt_create_groupbox(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id
);
WINDOW xvt_create_groupbox(
short left, short top, short right, short bottom,
const char* caption,
WINDOW parent,
long flags,
long app_data,
int id);
void free_controls_bmp();
void free_controls_bmp();
///////////////////////////////////////////////////////////
// Custom control
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
// Custom control
///////////////////////////////////////////////////////////
class TControl
// @doc INTERNAL
// @class TControl | Classe per la creazione di controlli personalizzati
class TControl
// @author:(INTERNAL) Guido
// @access Private Member
{
// @cmember Handle del controllo creato
WINDOW _win;
// @cmember Iedntificatore assegnato al cotrollo
short _id;
// @cmember Prompt del controllo
TString _caption;
COLOR _color, _backcolor;
// @cmember Colore di foreground del controllo
COLOR _color;
// @cmember Colore di background del controllo
COLOR _backcolor;
// @cmember Indica se il controllo e' disabilitato
bool _disabled : 1;
bool _checked : 1;
bool _focused : 1;
// @cmember Indica se il controllo ha un check
bool _checked : 1;
// @cmember Indica se il controllo ha il focus
bool _focused : 1;
// @cmember Indica varie cose a seconda del tipo di controllo she si sta utilizzando
bool _multiple : 1;
// @access Protected Member
protected:
// @cmember E' l'handler del controllo
static long XVT_CALLCONV1 handler(WINDOW win, EVENT* ep);
void create(short left, short top, short right, short bottom,
const char* caption,
WINDOW parent, long flags, long app_data, short id);
// @cmember Crea il controllo
void create(short left, short top, short right, short bottom, const char* caption, WINDOW parent, long flags, long app_data, short id);
// @cmember Ridisegna il controllo a video
virtual void update() const pure;
virtual void mouse_down(PNT) {};
virtual void mouse_up() {};
virtual WIN_TYPE type() const { return W_NO_BORDER; }
// @cmember Chiamate ogni volta che viene premuto il mouse sul controllo
virtual void mouse_down(PNT)
{};
// @cmember Chiamate ogni volta che viene rialsciato il mouse sul controllo
virtual void mouse_up()
{};
// @cmember Ritorna il tipo di finestra su cui si trova il controllo
virtual WIN_TYPE type() const
{ return W_NO_BORDER; }
// @access Public Member
public:
// @cmember Ritorna il TControl dalla finestra del controllo
static TControl* WINDOW2TControl(WINDOW win);
// @cmember Distruttore. Necessariamente virtuale per derivare altri distruttori
virtual ~TControl();
WINDOW win() const { return _win; }
short id() const { return _id; }
const char* caption() const { return _caption; }
// @cmember Ritorna l'handle del controllo
WINDOW win() const
{ return _win; }
// @cmember Ritorna l'identificatore assegnato al controllo
short id() const
{ return _id; }
// @cmember Ritorna il prompt del controllo
const char* caption() const
{ return _caption; }
// @cmember Setta il prompt del controllo
void set_caption(const char* c);
COLOR color() const { return _color; }
void set_color(COLOR c) { _color = c; }
COLOR back_color() const { return _backcolor; }
void set_back_color(COLOR c) { _backcolor = c; }
bool checked() const { return _checked; }
// @cmember Ritorna il colore di forground del controllo
COLOR color() const
{ return _color; }
// @cmember Setta il colore di forground del controllo
void set_color(COLOR c)
{ _color = c; }
// @cmember Ritorna il colore di background del controllo
COLOR back_color() const
{ return _backcolor; }
// @cmember Setta il colore di background del controllo
void set_back_color(COLOR c)
{ _backcolor = c; }
// @cmember Ritorna se il controllo possiede un check
bool checked() const
{ return _checked; }
// @cmember Setta se il controllo debba avere un check
virtual void check(bool on);
bool disabled() const { return _disabled; }
// @cmember Ritorna se il controllo e' disabilitato
bool disabled() const
{ return _disabled; }
// @cmember Abilita/disabilita il controllo
void enable(bool on);
bool focused() const { return _focused; }
void focus(bool on) { _focused = on; }
// @cmember Ritorna se il controllo ha il focus
bool focused() const
{ return _focused; }
// @cmember Setta il focus sul cursore (stessa sintassi di <mf TCursor::enable>)
void focus(bool on)
{ _focused = on; }
bool multiple() const { return _multiple; }
// @cmember Ritorna il contenuto della variabile <md TControl::_multiple>
bool multiple() const
{ return _multiple; }
};
#endif

285
include/form.cpp
View File

@ -39,6 +39,8 @@ HIDDEN const int frm_id = 113;
// Utility functions
///////////////////////////////////////////////////////////
// @doc EXTERNAL
// Current form (edit, print)
HIDDEN TForm* _cur_form = NULL;
HIDDEN TPrint_section* _cur_sect = NULL;
@ -62,8 +64,12 @@ HIDDEN TMask& special_mask()
return *_special_mask;
}
// Translate char to pagetype (visible outside here, no more HIDDEN)
pagetype char2page(char c)
// @func Funzione che converte dalla notazione carattere al corrispondente
// enum <t pagetype>
//
// @rdesc Ritorna il <t pagetype> corrispondente
pagetype char2page(
char c) // @parm Notazione carattere del tipo di pagina
{
pagetype pt;
switch(c)
@ -577,7 +583,13 @@ void TForm_item::print_on(TRectype& prof)
}
}
void TForm_item::enable(bool on)
// @mfunc Abilita/Disabilita il campo
void TForm_item::enable(
bool on) // @parm Operazione da svolgere sul campo:
// @flag TRUE | Il campo viene abiliato
// @flag FALSE | Il campo viene disabiliato
// @comm Viene automaticamente setta se il campo diventi visibile o nascosto (chaiam <mf TForm_item::show>)
{
_flag.enabled = on;
show(on);
@ -612,8 +624,10 @@ TToken_string& TForm_item::message(int m)
return *t;
}
void TForm_item::send_message(const TString& cmd, TForm_item& des) const
// @mfunc Manda il messaggio al campo <p dest>
void TForm_item::send_message(
const TString& cmd, // @parm Messaggio di comando
TForm_item& des) const // @parm Campo a cui destinare il messaggio
{
if (cmd == "ADD" || cmd == "INC")
{
@ -2171,7 +2185,13 @@ bool TPrint_section::update()
return ok;
}
bool TPrint_section::read_from(const TRectype& prof)
// @mfunc Legge dal record <p rec> altezza e offset prima colonna della sezione
//
// @rdesc Ritorna se i valori letti hanno modificato quelli attuali
bool TPrint_section::read_from(
const TRectype& prof) // @parm Record dal quela leggere i valori
// @comm Nel caso il record non sia LF_RFORM viene dato un messaggio di <f CHECK>.
{
CHECK(prof.num() == LF_RFORM, "Il record deve essere del file LF_RFORM");
@ -2516,8 +2536,12 @@ bool TPrint_section::detail_field_notify (TSheet_field& s, int r, KEY k)
}
return TRUE;
}
bool TPrint_section::edit(const char* title)
// @mfunc Esegue l'edit della sezione di stampa
//
// @rdesc Ritorna TRUE se e' stata modificata effettivamente
bool TPrint_section::edit(
const char* title) // @parm Titolo della maschera di edit
{
const bool is_ba_editor = TString(_form->section_mask()).left(2) == "ba";
bool nstd_dirty = FALSE;
@ -2972,7 +2996,18 @@ void TForm::print_general(ostream& out) const
out << "END\n" << endl;
}
TPrint_section* TForm::exist(char s, pagetype t, bool create)
// @mfunc Controlla se esiste una sezione di stampa
//
// @rdesc Ritorna la <c TPrint_section> trovata o creata
TPrint_section* TForm::exist(
char s, // @parm Indica in quale parte deve cercare:
//
// @flag F | Tra i footers
// @flag G | Tra gli sfondi
// @flag H | Tra gli headers
// @flag B | Tra i bodies (default)
pagetype t, // @parm Tipo di pagina (vedi <t pagetype>)
bool create) // @parm Indica se creare la sezione nel caso non esista
{
TArray* a;
switch (toupper(s))
@ -3023,7 +3058,13 @@ TPrint_section& TForm::section(char s, word pagenum)
return section(s, pt);
}
bool TForm::reread(char sec, pagetype p, bool force)
// @mfunc Rilegge la sezione specificata
//
// @rdesc Ritorna se ce l'ha fatta
bool TForm::reread(
char sec, // @parm Sezione da rileggere
pagetype p, // @parm Posizione della pagina
bool force) // @parm Forza rilettura anche se nessun campo e' cambiato
{
TPrint_section* s = exist(sec,p);
bool ok = force;
@ -3087,7 +3128,16 @@ bool TForm::reread(char sec, pagetype p, bool force)
// TForm
///////////////////////////////////////////////////////////
bool TForm::ps_change_date_format(TPrint_section& s, const char* f)
// @mfunc Cambia il formato di tutte le date nel form
//
// @rdesc Ritorna sempre TRUE
bool TForm::ps_change_date_format(
TPrint_section& s, // @parm Sezione nella quale modificare le date
const char* f) // @parm Nuovo formato delle date
// @comm Ha le stesse funzioni di <mf TForm::change_date_format>, ma per <c TPrint_section>,
// all'uopo di chiamarla con ricorsiva insistenza
{
for (word i = 0; i < s.fields(); i++)
{
@ -3106,8 +3156,18 @@ bool TForm::ps_change_date_format(TPrint_section& s, const char* f)
}
return TRUE;
}
bool TForm::ps_change_number_format(TPrint_section& s, int w, int dec, const char* p)
// @mfunc Cambia il formato di tutti i numeri nel form
//
// @rdesc Ritorna sempre TRUE
bool TForm::ps_change_number_format(
TPrint_section& s, // @parm Sezione nella quale modificare i numeri
int w, // @parm Dimensione massima del fomato numerico
int dec, // @parm Numero di decimali
const char* p) // @parm Picture del nuovo formato
// @comm Ha le stesse funzioni di <mf TForm::change_number_format>, ma per <c TPrint_section>,
// all'uopo di chiamarla con ricorsiva insistenza
{
for (word i = 0; i < s.fields(); i++)
{
@ -3154,8 +3214,15 @@ void TForm::change_number_format(int w, int dec, const char* p)
if ((ps = exist(secs[sc], char2page(ptyp[pt]), FALSE)) != NULL)
ps_change_number_format(*ps, w, dec, p);
}
word TForm::set_background(word p, bool u)
// @mfunc Effettua l'update della sezione grafica background
//
// @rdesc Ritorna la lunghezza della pagina da stampare
word TForm::set_background(
word p, // @parm Numero pagina
bool u) // @parm Indica se aggiornare lo sfondo nella stampante corrente
// @xref <mf TForm::set_header> <mf TForm::set_body> <mf TForm::set_footer>
{
word len = 0;
@ -3169,7 +3236,14 @@ word TForm::set_background(word p, bool u)
return len;
}
word TForm::set_header(word p, bool u)
// @mfunc Effettua l'update della sezione header
//
// @rdesc Ritorna l'altezza dell'header settato
word TForm::set_header(
word p, // @parm !!!
bool u) // @parm Indica se cambiare l'eventuale header corrente!!!
// @xref <mf TForm::set_background> <mf TForm::set_body> <mf TForm::set_footer>
{
TPrinter& pr = printer();
pr.resetheader();
@ -3189,7 +3263,15 @@ word TForm::set_header(word p, bool u)
return head.height();
}
word TForm::set_body(word p, bool u)
// @mfunc Effettua l'update della sezione body
//
// @rdesc Ritorna l'altezza del body settato
word TForm::set_body(
word p, // @parm !!!
bool u) // @parm Indica se cambiare l'eventuale body corrente!!!
// @xref <mf TForm::set_background> <mf TForm::set_header> <mf TForm::set_footer>
{
TPrint_section& body = section('B', p);
@ -3206,7 +3288,15 @@ word TForm::set_body(word p, bool u)
return body.height();
}
word TForm::set_footer(word p, bool u)
// @mfunc Effettua l'update della sezione footer
//
// @rdesc Ritorna l'altezza del footer settato
word TForm::set_footer(
word p, // @parm !!!
bool u) // @parm Indica se cambiare l'eventuale footer corrente!!!
// @xref <mf TForm::set_background> <mf TForm::set_header> <mf TForm::set_body>
{
TPrinter& pr = printer();
pr.resetfooter();
@ -3243,12 +3333,35 @@ void TForm::footer_handler(TPrinter& p)
}
word TForm::page(const TPrinter& p) const
// @mfunc Ritorna il numero di pagina correntemente in stampa
//
// @rdesc Se <md _TForm::lastpage> e' TRUE (sta stampando l'ultima pagina)
// ritorna 0, altrimenti ritorna il numero della pagian corrente da stampare
// (chiam <mf TPrinter::getcurrentepage>).
word TForm::page(
const TPrinter& p) const // @parm Operazione corrente di stampa
{
return _lastpage ? 0 : p.getcurrentpage();
}
// @mfunc Effettua il posizionamento manuale del modulo
void TForm::arrange_form()
// @comm Nota: siccome si scrive direttamente sulla porta, sarebbe necessario
// mandare una stringa di reset alla stampante, o per lo meno far si' che
// ogni volta che si fa il posizionamento il font col quale scrive sia sempre
// lo stesso. Tutto cio' non e' possibile con la generica solo testo, o meglio
// ad ogni stampa col posizionamento e' necessario che la stampante sia resettata.
// <nl>Riassumendo, come regola generale, i posizionamenti devono essere fatti con il
// font di default della stampante (tipicamente 10 cpi). Accade pero' (con la generica
// solo testo) che rimanga settato l'ultimo font, di conseguenza quando si effettua una
// seconda stampa con posizionamento, stampera' tali caratteri in 17"! Per questo
// motivo e' necessario settare a 17 cpi, almeno la prima volta, la stampante!.
// <nl>Quindi, per ovviare a tutto cio, visto che <mf TForm::arange_form> ha senso solo su
// stampanti ad aghi, che le stampanti ad aghi possono andare in emulazione EPSON o IBM,
// che il codice per settare il font draft 17cpi e' lo stesso sia per EPSON che IBM
// CHR(15), allora prima del posizionamento scrivo il chr(15) sulla stampante!
{
TString device;
#if XVT_OS == XVT_OS_WIN
@ -3264,20 +3377,7 @@ void TForm::arrange_form()
device = device.left(4); //Legge solo LPTx...
#endif
FILE* lpt = fopen(device,"w");
// Nota: siccome si scrive direttamente sulla porta, sarebbe necessario
// mandare una stringa di reset alla stampante, o per lo meno far si' che
// ogni volta che si fa il posizionamento il font col quale scrive sia sempre
// lo stesso. Tutto cio' non e' possibile con la generica solo testo, o meglio
// ad ogni stampa col posizionamento e' necessario che la stampante sia resettata.
// Riassumendo, come regola generale, i posizionamenti devono essere fatti con il
// font di default della stampante (tipicamente 10 cpi). Accade pero' (con la generica
// solo testo) che rimanga settato l'ultimo font, di conseguenza quando si effettua una
// seconda stampa con posizionamento, stampera' tali caratteri in 17"!!!! Per questo
// motivo e' necessario settare a 17 cpi, almeno la prima volta, la stampante!.
// Quindi, per ovviare a tutto cio, visto che TForm::arange_form() ha senso solo su
// stampanti ad aghi, che le stampanti ad aghi possono andare in emulazione EPSON o IBM,
// che il codice per settare il font draft 17cpi e' lo stesso sia per EPSON che IBM
// CHR(15), allora prima del posizionamento scrivo il chr(15) sulla stampante!
int i, x;
TString str_pos;
if (lpt == NULL) fatal_box("Non rieso ad aprire il device %s.",device);
@ -3325,7 +3425,16 @@ long TForm::records() const
return r;
}
bool TForm::genera_fincatura(pagetype p, int y1, int y2, const int* rows)
// @mfunc Genera automaticamente la sezione grafica con colonne fincate
//
// @rdesc Ritorna FALSE se non c'e' il body per quella pagina
bool TForm::genera_fincatura(
pagetype p, // @parm Posizione della pagina (vedi <t pagetype>)
int y1, // @parm Prima y per le righe verticali
int y2, // @parm Ultima y per le righe verticali
const int* rows) // @parm Array di posizioni riga con 0 per finire
{
TPrint_section* body = exist('B', p);
if (body == NULL) return FALSE;
@ -3405,7 +3514,15 @@ bool TForm::genera_fincatura(pagetype p, int y1, int y2, const int* rows)
return TRUE;
}
bool TForm::genera_intestazioni(pagetype p, short y)
// @mfunc Genera le righe di intestazione colonna alla riga indicata, vale per COLUMNWISE
//
// @rdesc Ritorna FALSE se non esiste body (o non e' COLUMNWISE) o se non esiste l'header
bool TForm::genera_intestazioni(
pagetype p, // @parm Posizione della pgaina (vedi <t pagetype>)
short y) // @parm Riga dell'header in cui vanno inserite
// @comm I form_items di intestazione vengono aggiunti alla sezione header di tipo <p p> con ID -1
{
TPrint_section* body = exist('B', p);
if (body == NULL || !body->columnwise()) return FALSE;
@ -3430,10 +3547,87 @@ bool TForm::genera_intestazioni(pagetype p, short y)
return TRUE;
}
// Stampa gli items dal from a to
// se to < 0 stampa fino alla fine del file
/*
void TForm::remove_temp_items(char sec, pagetype p)
{
TPrint_section* s = exist(sec,p);
if (s!=NULL)
{
const word items = s->fields();
for (word j=0;j<items; j++)
{
if (s->field(j).temp())
s->destroy_field(j,FALSE);
}
s->field_array().pack();
}
}
bool TForm::print(long from, long to)
void TForm::put_examples(char sez, pagetype p)
{
TPrint_section* s = exist(sez,p);
if (s!=NULL)
{
const word items = s->fields();
for (word i=0;i<items;i++)
{
TForm_item& fi = s->field(i);
if (fi.fields()!=0) continue;
if (fi.memo())
fi.set(fi.memo_info());
else
if (fi.prompt().empty())
{
if (fi.class_name() == "DATA")
{
const TDate d(TODAY);
fi.set(d);
}
else
if (fi.class_name() == "NUMERO")
{
fi.set_prompt(fi.example());
fi.temp() = TRUE;
}
else
fi.set(fi.key());
}
}
}
}
void TForm::remove_examples(char sez, pagetype p)
{
TPrint_section* s = exist(sez,p);
if (s!=NULL)
{
const word items = s->fields();
for (word i=0;i<items;i++)
{
TForm_item& fi = s->field(i);
if (fi.fields()!=0) continue;
if (fi.memo())
fi.set("");
else
if (fi.class_name() == "NUMERO" && fi.temp())
{
fi.set_prompt("");
fi.temp() = FALSE;
}
}
}
}
*/
// @mfunc Stampa gli items da <p form> a <p to>
//
// @rdesc Ritorna se ha effettuato correttamente la stampa
bool TForm::print(
long from, // @parm Primo item da stampare (default 0l)
long to) // @parm Ultimo da stampare (se <lt>0 stampa fino alla fine del file, default -1l)
// @comm Se i parametri di posizionamento sono settati e cosi' pure gli offset genera un <f error_box>.
{
_cur_form = this;
@ -3607,8 +3801,14 @@ word TForm::height(word page)
return h;
}
// @mfunc Legge un profilo
//
// @rdesc Ritorna se e' riuscito nell'operazione:
// @flag TRUE | E' riuscito a leggere il prfilo
// @flag FALSE | Non ha letto il profilo
bool TForm::read_profile()
// @comm Per la lettura del profilo procede leggendo prima la definizione del
// profilo base e successivamente le modifiche relative.
{
TLocalisamfile prof(LF_FORM);
TLocalisamfile rprof(LF_RFORM);
@ -3759,7 +3959,12 @@ void TForm::init()
_background_mode = printer().isgraphics() ? graphics : testo;
}
void TForm::read(const char* name, const char* code, int lev, const char* desc)
// @mfunc Carica il form dal file specificato
void TForm::read(
const char* name, // @parm Nome del profilo di stampa da leggere
const char* code, // @parm Codice del profilo di stampa da leggere
int lev, // @parm Permessi di stampa
const char* desc) // @parm Descrizione del formato da leggere
{
_name= name;
_code= code;

845
include/form.h
View File

File diff suppressed because it is too large Load Diff

2
include/isam.h
View File

@ -126,7 +126,7 @@ class TRectype : public TSortable
friend class TBaseisamfile;
// @cfriend TLocalisamfile
friend class TLocalisamfile;
// @cfriend TIsamtemp file
// @cfriend TIsamtempfile
friend class TIsamtempfile;
// @access Private Member

4
include/mailbox.h
View File

@ -10,8 +10,8 @@
// @doc EXTERNAL
// @class TMessagge | Classe per il passaggio dei messeggi base tra applicazioni
// e linea di comando
// @class TMessage | Classe per il passaggio dei messeggi base tra applicazioni
// e linea di comando
//
// @base public | TObject
class TMessage : public TObject

4
include/mask.cpp
View File

@ -1592,7 +1592,9 @@ WINDOW TMask::add_list (
return f->win();
}
// @cmember Aggiunge runtime un campo boolean alla maschera
// @mfunc Aggiunge runtime un campo boolean alla maschera
//
// @rdesc Ritorna il descrittore del campo aggiunto
WINDOW TMask::add_boolean (
short id, // @parm Numero identificatore del campo da aggiungere
int page, // @parm Pagina nel quale aggiungere il campo

2
include/msksheet.cpp
View File

@ -1306,7 +1306,7 @@ void TSpreadsheet::on_idle()
// @mfunc Cerca la colonna col
XI_OBJ* TSpreadsheet::find_column(
int col) const // @param Indice o identificatore colonna
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

79
include/relapp.cpp
View File

@ -1,4 +1,3 @@
// $Id: relapp.cpp,v 1.70 1995-11-07 11:38:23 villa Exp $
#include <mailbox.h>
#include <sheet.h>
#include <urldefid.h>
@ -14,18 +13,38 @@
// Array delle chiavi della maschera di ricerca
///////////////////////////////////////////////////////////
// @doc INTERNAL
// @class TChiave | Array delle chiavi della maschera di ricerca
// @base public | TObject
class TChiave : public TObject
// @author:(INTERNAL) Guido
// @access Private Member
{
// @ccost MAX | 16 | Numero massimo di chiavi della maschera di ricerca
enum { MAX = 16 };
// @cmember Posizione delle chiavi nella msachera di ricerca
int _pos[MAX];
// @cmember Numero di chiavi presenti nella maschera di ricerca
byte _num;
// @access Public Member
public:
// @cmember Aggiunge una nuova chiave alla posizione <p p>
void add(int p);
int pos(byte n) const { return (n >= _num) ? -1 : _pos[n]; }
byte items() const { return _num; }
TChiave() : _num(0) {}
virtual ~TChiave() {}
// @cmember Ritorna la posizione della chiave <p n>-esima (-1 se non esiste)
int pos(byte n) const
{ return (n >= _num) ? -1 : _pos[n]; }
// @cmember Ritorna il numero di chiavi attualmente presente nella maschera
byte items() const
{ return _num; }
// @cmember Costruttore
TChiave() : _num(0)
{}
// @cmember Distruttore
virtual ~TChiave()
{}
};
void TChiave::add(int p)
@ -70,6 +89,8 @@ TKey_array::TKey_array(const TMask* m) : _mask(m)
}
}
// @doc EXTERNAL
///////////////////////////////////////////////////////////
// TRelation_application
///////////////////////////////////////////////////////////
@ -96,12 +117,15 @@ void TRelation_application::setkey()
}
// what - meaning
// 0 - nop
// 1 - first
// 2 - last
// 3 - both
void TRelation_application::set_limits(byte what)
// @mfunc Setta i limiti
void TRelation_application::set_limits(
byte what) // @parm tipo di limite da assegnare al record
// @comm I limiti possibili sono:
// @flag 0 | Nessuna operazione
// @flag 1 | Primo record
// @flag 2 | Ultimo record
// @flag 3 | Entrambi
{
if (has_filtered_cursor())
{
@ -298,8 +322,15 @@ int TRelation_application::set_mode(int mode)
return _mode;
}
bool TRelation_application::autonum(TMask* m, bool rec)
// @mfunc Permette di autonumerare un record
//
// @rdesc Ritorna se e' riuscito a creare una nuova autonumerazione:
//
// @flag TRUE | Il campo chiave non e' vuoto
// @flag FALSE | Non e' riuscii ad autonumerare il campo chiave
bool TRelation_application::autonum(
TMask* m, // @parm Maschera a cui applicare l'autonumerazione
bool rec) // @parm Indica se registrare il record corrente
{
TToken_string k(get_next_key());
@ -321,8 +352,12 @@ bool TRelation_application::autonum(TMask* m, bool rec)
return k.not_empty();
}
void TRelation_application::query_mode(bool pre_ins)
// @mfunc Entra in modo di ricerca
void TRelation_application::query_mode(
bool pre_ins) // @parm Indica in quale modo andare:
//
// @flag TRUE | Entra in modo MODE_QUERY_INSERT
// @flag FALSE | Entra in modo MODE_QUERY (default)
{
TMask* old = _mask;
const bool was_open = old != NULL && old->is_open();
@ -479,8 +514,12 @@ bool TRelation_application::search_mode()
return FALSE;
}
bool TRelation_application::test_key(byte k, bool err)
// @mfunc Controlla se una chiave e' completa ed esiste su file
//
// @rdesc Ritorna se la chave esiste sul file
bool TRelation_application::test_key(
byte k, // @parm Chiave da ricercare
bool err) // @parm Indica se visualizzare eventuali errori occorsi
{
const TChiave& chiave = _maskeys->key(k);
bool onereq = FALSE, onefill = FALSE;
@ -712,8 +751,12 @@ int TRelation_application::rewrite(const TMask& m)
return r->status();
}
// @mfunc Cancella il record corrente
// @rdesc Ritorna se il record e' stato eliminato
bool TRelation_application::relation_remove()
// @comm Se la maschera e' in MODE_MOD non e' possibile cancellare il record e viene
// emesso un <f CHECK> di errore.
{
CHECK(_mask->mode() == MODE_MOD, "You can call remove in MODE_MOD only");
TRelation *r = get_relation();

209
include/relapp.h
View File

@ -13,108 +13,205 @@
#include <mask.h>
#endif
// @doc EXTERNAL
class TKey_array;
// @class TRelation_application | Classe per la gestione di una apllicazione di manutenzione di uno
// o piu' archivi utilizzando una relazione
//
// @base public | TApplication
class TRelation_application : public TApplication
// @author:(INTERNAL) Guido
// @access Private Member
{
TMask * _mask;
// @cmember Maschera corrente dell'applicazione
TMask* _mask;
// @cmember Array di chiavi della maschera
TKey_array* _maskeys;
TRecnotype _first, _last;
int _search_id;
// @cmember Primo record
TRecnotype _first;
// @cmember Ultimo record
TRecnotype _last;
// @cmember Campo da utilizzare col bottone Ricerca
int _search_id;
// @cmember Nome del programma chiamante
TString16 _autoins_caller;
// @cmember Numero del record nuovo/editato
long _recins;
// @cmember Indica se e' stato chiamato col messaggio di link
bool _lnflag;
// @cmember Contiene il codice del campo e il valore fisso
TToken_string _fixed;
// @cmember Messaggio da passare all'utente per inidicare che e' stata fatta la rinumerazione
TString _renum_message;
// @cmember Setta i campi fissati da <md TRelation_application::_fixed>
bool filter();
// @cmember Controlla se una chiave e' completa ed esiste su file
bool test_key(byte k, bool err);
// @cmember Salva i contenuti della maschera su file
bool save(bool check_dirty);
// @cmember Abilita la ricerca sulla maschera
void enable_query();
// @cmember UNUSED
void set_toolbar(bool all);
int set_mode(int mode); // Seleziona il nuovo modo e ritorna il vecchio
// @cmember Seleziona il nuovo modo e ritorna il vecchio
int set_mode(int mode);
// @cmember Setta i limiti
void set_limits(byte what = 0x3);
void query_insert_mode() { query_mode(TRUE); }
void insert_mode(); // Entra in modo inserimento
bool relation_remove(); // Cancella il record corrente
TMask_field* get_search_field() const;
// @cmember Posiziona l'applicazione in modo richiesta/inserimento (chaima <mf TRelation_application::query_mode>)
void query_insert_mode()
{ query_mode(TRUE); }
// @cmember Entra in modo inserimento
void insert_mode();
// @cmember Cancella il record corrente
bool relation_remove();
// @cmember Ritorna il campo di ricerca della maschera
TMask_field* get_search_field() const;
// @cmember Permette di autonumerare un record
bool autonum(TMask* m, bool rec);
bool has_filtered_cursor() const { return filtered() || force_cursor_usage();}
// @cmember Controlla se il <c TCursor> ha un filtro
bool has_filtered_cursor() const
{ return filtered() || force_cursor_usage();}
// @access Protected Member
protected:
// @cmember Effettua i controlli all'inizio dell'applicazione
virtual bool create();
// @cmember Effettua i controlli alla fine dell'applicazione
virtual bool destroy();
// @cmember Controlla se e' possibile modificare la ditta corrente durante l'esecuzione dell'applicazione
virtual bool firm_change_enabled() const;
protected:
TLocalisamfile& file() const { return get_relation()->lfile(); } // File principale della relazione
TRecnotype first() const { return _first;}
TRecnotype last() const { return _first;}
const TString& autoins_caller() const { return _autoins_caller;}
// @cmember Ritorna il descrittore del file principale della relazione
TLocalisamfile& file() const
{ return get_relation()->lfile(); }
// @cmember Ritorna il primo record!!!
TRecnotype first() const
{ return _first;}
// @cmember Ritorna l'ultimo record!!!
TRecnotype last() const
{ return _first;}
// @cmember !!!
const TString& autoins_caller() const
{ return _autoins_caller;}
// @cmember Gestisce la barra dei menu' (chiama <mf TRelation_application::main_loop>)
virtual bool menu(MENU_TAG m);
virtual bool main_loop(); // Ciclo principale
// @cmember Ciclo principale
virtual bool main_loop();
virtual bool user_create() pure; // Inizializzazione dati utente
virtual bool user_destroy() pure; // Distruzione dati utente
// @cmember Inizializzazione dei dati dell'utente
virtual bool user_create() pure;
// @cmember Distruzione dei dati dell'utente
virtual bool user_destroy() pure;
void set_fixed(); // Fissa i campi non modificabili
bool search_mode(); // Attiva la maschera di ricerca
void query_mode(bool pre_ins = FALSE); // Entra in modo ricerca
bool modify_mode(); // Entra in modo modifica
void setkey();
bool lnflag() const { return _lnflag;}
// La richiesta della maschera da utilizzare per ogni fase di lavoro (ricerca, inserimento,
// modifica avviene sempre in due tempi: changing_mask e get_mask. Cio' serve per gestire
// Correttamente le applicazioni con mashere multiple. La prima funzione serve a sapere se
// la futura get_mask ritornera' una maschera diversa dalla corrente.
virtual bool changing_mask(int mode) pure;
virtual TMask* get_mask(int mode) pure; // Richiede la maschera da usare
// @cmember Fissa i campi non modificabili
void set_fixed();
// @cmember Attiva la maschera di ricerca
bool search_mode();
// @cmember Entra in modo di ricerca
void query_mode(bool pre_ins = FALSE);
// @cmember Entra in modo modifica
bool modify_mode();
// @cmember Legge i campi chiave della maschera e setta il cursore relativo
void setkey();
// @cmember !!!
bool lnflag() const
{ return _lnflag;}
// @cmember Indica se la futura <mf TRelation_application::get_mask> ritornera' una maschera diversa
// dalla corrente.
// <nl>La richiesta della maschera da utilizzare per ogni fase di lavoro
// (ricerca, inserimento, modifica) avviene sempre in due tempi: <mf TRelation_application::changing_mask> e
// <mf TRelation_application::get_mask>. Cio' serve per gestire correttamente le applicazioni
// con mashere multiple.
virtual bool changing_mask(int mode) pure;
// @cmember Richiede la maschera da usare
virtual TMask* get_mask(int mode) pure;
// metodo per far forzare la rigenerazione della lista interna di chiavi ad ogni find()
virtual bool changing_keys() const { return FALSE; }
// @cmember Forza la rigenerazione della lista interna di chiavi ad ogni <mf TRealtion_application::find>
virtual bool changing_keys() const
{ return FALSE; }
virtual TRelation* get_relation() const pure; // Relazione da modificare
virtual int read(TMask& m); // Legge dalla relazione i valori nella maschera
virtual int write(const TMask& m); // Scrive sulla relazione i valori dalla maschera
virtual int rewrite(const TMask& m); // Riscrive sulla relazione i valori dalla maschera
virtual bool remove(); // Cancella il record corrente
// @cmember Ritorna la relazione da modificare
virtual TRelation* get_relation() const pure;
// @cmember Legge dalla relazione i valori nella maschera <p m>
virtual int read(TMask& m);
// @cmember Scrive sulla relazione i valori dalla maschera <p m>
virtual int write(const TMask& m);
// @cmember Riscrive sulla relazione i valori dalla maschera <p m>
virtual int rewrite(const TMask& m);
// @cmember Cancella il record corrente
virtual bool remove();
// Richiede una stringa nella forma CAMPO1|VALORE1|CAMPO2|VALORE2|...|CAMPOn|VALOREn
// contenente le coppie NUMERO_CAMPO_MASCHERA - VALORE_DA_ASSEGNARE che descrivono il
// prossimo codice libero da utilizzare per la autonumerazione.
// Nel caso di banale numerazione progressiva potrebbe essere implementata come
// return format("%d|%s", F_NUM, get_relation()->items());
virtual const char* get_next_key() { return ""; }
// @cmember Richiede una stringa nella forma CAMPO1<pipe>VALORE1<pipe>CAMPO2<pipe>VALORE2<pipe>...
// <pipe>CAMPOn<pipe>VALOREn contenente le coppie NUMERO_CAMPO_MASCHERA - VALORE_DA_ASSEGNARE
// che descrivono il prossimo codice libero da utilizzare per la autonumerazione.
// <nl>Nel caso di banale numerazione progressiva potrebbe essere implementata come
// return format("%d<pipe>%s", F_NUM, get_relation()-<gt>items());
virtual const char* get_next_key()
{ return ""; }
// Richiede se il record corrente e' protetto (non cancellabile)
virtual bool protected_record(TRectype&) { return FALSE; }
// @cmember Richiede se il record corrente e' protetto (non cancellabile)
virtual bool protected_record(TRectype&)
{ return FALSE; }
virtual void init_query_mode(TMask&) { } // Inizializza la maschera per il modo ricerca
virtual void init_query_insert_mode(TMask& m) { init_query_mode(m); }
virtual void init_insert_mode(TMask&) { } // Inizializza la maschera per il modo inserimento
virtual void init_modify_mode(TMask&) { } // Inizializza la maschera per il modo modifica
virtual bool force_cursor_usage() const { return FALSE;}
virtual void write_enable(bool on = TRUE) { get_relation()->write_enable(0, on); }
void write_disable() { write_enable(FALSE); }
// @cmember Inizializza la maschera per il modo ricerca
virtual void init_query_mode(TMask&)
{ }
// @cmember Inizializza la maschera per il modo ricerca ed inserimento (chiama <mf TRelation_application::init_query_mode>)
virtual void init_query_insert_mode(TMask& m)
{ init_query_mode(m); }
// @cmember Inizializza la maschera per il modo inserimento
virtual void init_insert_mode(TMask&)
{ }
// @cmember Inizializza la maschera per il modo modifica
virtual void init_modify_mode(TMask&)
{ }
// @cmember Simula l'utilizzo di un filtro da un'altra applicazione
virtual bool force_cursor_usage() const
{ return FALSE;}
// @cmember Indica se abilitare/disabilitare la scrittura sul file
// principale (vedi <mf TRealtion::write_enable>)
virtual void write_enable(bool on = TRUE)
{ get_relation()->write_enable(0, on); }
// @cmember Indica se disabilitare la scrittura sul file principale (vedi <mf TRealtion::write_enable>)
void write_disable()
{ write_enable(FALSE); }
// @cmember Salva il record corrente e si predispone per un nuovo inserimento
virtual bool save_and_new() const;
void set_search_field(short id) { _search_id = id;} // Impone il campo da utilizzare col bottone Ricerca
public:
TMask& curr_mask() const { return *_mask; }
// @cmember Impone il campo da utilizzare col bottone Ricerca
void set_search_field(short id)
{ _search_id = id;}
bool filtered() const { return _fixed.not_empty(); }
// @access Public Member
public:
// @cmember Ritorna la maschera corrente
TMask& curr_mask() const
{ return *_mask; }
// @cmember Ritorna se sono stati posti dei filtri sul file corrente
bool filtered() const
{ return _fixed.not_empty(); }
// @cmember Cerca un record corrispondete alla chiava <p key> (0 prima chiave completa!!!)
bool find(byte key = 0);
// @cmember Costruisce il membro <md TRelation_application::_fixed>
void set_link(TMask & m, const char * keyexpr);
// @cmember Costruttore
TRelation_application();
// @cmember Distruttore
virtual ~TRelation_application();
};

8
include/relation.h
View File

@ -1,4 +1,4 @@
/* $Id: relation.h,v 1.32 1995-12-29 12:09:12 andrea Exp $ */
/* $Id: relation.h,v 1.33 1996-01-31 17:18:43 andrea Exp $ */
// join.h
// fv 12/8/93
// join class for isam files
@ -20,7 +20,7 @@ class TSort;
//
// @base public | TObject
class TRelation : public TObject
// @author(:INTERNAL) Sandro
// @author:(INTERNAL) Sandro
{
// @cfriend TRelationdef
friend class TRelationdef;
@ -29,7 +29,7 @@ class TRelation : public TObject
// @cfriend TCursor
friend class TCursor;
// @access Provate Member
// @access Private Member
// @cmember Stato della relazione
TToken_string _status;
@ -220,7 +220,7 @@ public:
// @base public | TArray
class TRecord_array : private TArray
// @author(:ITERNAL) Guido
// @author:(INTERNAL) Guido
// @access Private Member
{

9
include/sheet.cpp
View File

@ -283,8 +283,13 @@ void TSheet::handler(WINDOW win, EVENT* ep)
}
// @func ???!!!???
PNT TSheet::log2dev(long x, long y) const
// @mfunc Converte le coordinate da logiche (caratteri) in coordinate fisiche (pixel)
// (vedi <mf TWindow::log2dev>)
//
// @rdesc Ritorna le coordinate fisiche cercate
PNT TSheet::log2dev(
long x, // @parm Coordinata X da convertire
long y) const // @parm Coordinata Y da convertire
{
if (autoscrolling()) x -= origin().x;
return TWindow::log2dev(x, y);

30
include/stack.h
View File

@ -5,22 +5,32 @@
#include <array.h>
#endif
// @C
// Classe TStack : private TArray
// @END
// @doc EXTERNAL
// @class TStack | Classe per la gestione dello stack a basso livello
//
// @base public | TArray
class TStack : private TArray
// @author:(INTERNAL) ???
// @access Private Member
{
// @DPRIV
int _sp; // Puntatore alla cima dello stack
// @cmember Puntatore alla cima dello stack
int _sp;
// @access Public Member
public:
// @FPUB
TStack(int size); // Chiama il costruttore di TArray(size)
// @cmember Costruttore. Chaima il costruttore di <c TArray>
TStack(int size);
int count() const { return _sp; } // Ritorna il puntatore allo stack
void push(const TObject&); // Aggiunge un oggetto sullo stack
TObject& pop(); // Ritorna il primo oggetto sulla cima dello stack
// @cmember Ritorna il puntatore allo stack
int count() const
{ return _sp; }
// @cmember Aggiunge un oggetto sullo stack
void push(const TObject&);
// @cmember Ritorna il primo oggetto sulla cima dello stack
TObject& pop();
};
#endif

26
include/stdtypes.cpp
View File

@ -23,9 +23,15 @@
extern isfdptr *openf;
HIDDEN long _stdlevel = 0;
// @doc EXTERNAL
// @func Ritorna il livello degli archivi
long get_std_level()
{ return _stdlevel; }
// @func Ritorna il numero di serie della chiave
//
// @rdesc Numero di serie della chiave
int get_serial_number()
{
#if XVT_OS != XVT_OS_SCOUNIX
@ -36,6 +42,7 @@ int get_serial_number()
return getser();
}
// @func Inizilizza le variabili globali
void init_global_vars()
{
TPrefix& pref = prefix_init();
@ -70,6 +77,7 @@ void init_global_vars()
DB_init();
}
// @func Dealloca le variabili globali
void free_global_vars()
{
#if XVT_OS != XVT_OS_SCOUNIX
@ -91,7 +99,15 @@ void free_global_vars()
unsigned long _alloc_count = 0;
#endif
// @func Operatore per la creazione di un oggetto (sostituisce operatore C++)
//
// @rdesc Ritorna il puntatore all'oggetto creato
void* operator new(size_t size)
// @comm Per maggiori informazioni fare riferimento all'omonimo comando sull'help
// in linea del C++.
// <nl>Questa funzione viene implementata se non si opera in ambiante FoxPro.
{
void* mem = (void*)malloc(size);
if (mem == NULL)
@ -104,7 +120,15 @@ void* operator new(size_t size)
return mem;
}
void operator delete(void* ptr)
// @func Operatore per la distruzione di un oggetto (sostituisce operatore C++)
void operator delete(
void* ptr) // @parm Puntatore all'oggetto da distruggere
// @comm Per maggiori informazioni fare riferimento all'omonimo comando sull'help
// in linea del C++.
// <nl>Nel caso venga passato un puntatore NULL viene emesso un <f CKECK>.
// <nl>Questa funzione viene implementata se non si opera in ambiante FoxPro.
{
CHECK(ptr, "Can't delete a NULL pointer");
free(ptr);

29
include/stdtypes.h
View File

@ -7,7 +7,8 @@
#endif
#endif
/* @M */
// @doc EXTERNAL
#define pure =0
#define FALSE 0
@ -17,40 +18,49 @@
#define EOL -1
#define NOERR 0
/* @END */
/* @T */
// @type UINT8 | Altro nome di assegnazione per gli unsigned char
typedef unsigned char UINT8;
#ifdef M_I386
// @type UINT16 | Altro nome di assegnazione per gli unsigned short (se compilato a 32bit)
// oppure unsigned int (se non definito M_I386)
typedef unsigned short UINT16;
#else
typedef unsigned int UINT16;
#endif
// @type UINT32 | Altro nome di assegnazione per gli unsigned long
typedef unsigned long UINT32;
// @type INT8 | Altro nome di assegnazione per i char
typedef char INT8;
#ifdef M_I386
// @type INT16 | Altro nome di assegnazione per gli short (se compilato a 32bit)
// oppure int (se non definito M_I386)
typedef short INT16;
#else
typedef int INT16;
#endif
// @type INT32 | Altro nome di assegnazione per i long
typedef long INT32;
// @type bool | Tipo booleano che puo' assumere i valori TRUE (definito come 1)
// e FALSE (definito come 0).
typedef UINT8 bool;
// @type word | Tipo per la definizione di tipi di lunghezza pari a due byte
typedef UINT16 word;
// @type dword | Tipo per la definizione di tipi di lunghezza pari a quattro byte
typedef UINT32 dword;
// @type byte | Tipo per la definizione di tipi di lunghezza pari ad un byte
typedef UINT8 byte;
// @type KEY | Tipo per la definizione di variabili destinati a contenere i caratteri
// immessi da tastiera
typedef UINT16 KEY;
#define UNDEFINED -32767
#undef _SVID
/* @END */
/* @FPUB */
int get_serial_number();
long get_std_level();
void init_global_vars();
@ -61,9 +71,6 @@ extern void* operator new(unsigned);
extern void operator delete(void*);
#endif
/* @END */
#endif /* __STDTYPES_H */
#endif // __STDTYPES_H

59
include/tabapp.h
View File

@ -11,27 +11,60 @@
#define FPC "FPC"
class Tab_application : public TRelation_application
{
TMask* _msk;
TRelation* _rel;
TString16 _tabname;
// @doc EXTERNAL
// @class Tab_application | Classe per la definizione della <c TRelation_application> per le tabelle
//
// @base public | TRelation_application
class Tab_application : public TRelation_application
// @author:(INTERNAL) Nicola
// @access Private Member
{
// @cmember Maschera corrente dell'applicazione
TMask* _msk;
// @cmember Relazione corrente dell'applicazione
TRelation* _rel;
// @cmember Nome della tabella da utilizzare
TString16 _tabname;
// @access Protected Member
protected:
// @cmember Richiede se il record corrente e' protetto (non cancellabile)
virtual bool protected_record(TRectype& rec);
virtual TMask* get_mask(int mode = NO_MODE) { return _msk;}
virtual bool changing_mask(int mode) { return FALSE;}
virtual TRelation* get_relation() const { return _rel;}
// @cmember Richiede la maschera da usare
virtual TMask* get_mask(int mode = NO_MODE)
{ return _msk;}
// @cmember Indica se la futura <mf Tab_application::get_mask> ritornera' una maschera diversa
// dalla corrente.
virtual bool changing_mask(int mode)
{ return FALSE;}
// @cmember Ritorna la relazione da modificare
virtual TRelation* get_relation() const
{ return _rel;}
// @cmember Inizializza la maschera per il modo ricerca
virtual void init_query_mode(TMask& m);
// @cmember Inizializza la maschera per il modo modifica
virtual void init_modify_mode(TMask& m);
virtual bool user_create() ;
virtual bool user_destroy() ;
// @cmember Inizializzazione dei dati dell'utente
virtual bool user_create() ;
// @cmember Distruzione dei dati dell'utente
virtual bool user_destroy() ;
// @cmember Chiama il programma di stampa
virtual void print();
// @access Public Member
public:
Tab_application() : _msk(NULL), _rel(NULL) {}
virtual ~Tab_application() {}
const TString& get_tabname() const { return _tabname; }
// @cmember Costruttore
Tab_application() : _msk(NULL), _rel(NULL)
{}
// @cmember Distruttore
virtual ~Tab_application()
{}
// @cmember Ritorna il nome della tabella
const TString& get_tabname() const
{ return _tabname; }
};
#endif

8
include/utility.cpp
View File

@ -120,8 +120,8 @@ bool make_dir(
#ifndef FOXPRO
// @func Setta la token string modificando la lista dei file formata con caratteri jolly
// in lista con caratteri estesi
// @func Ritorna la lista dei file il cui nome corrisponde alla stringa (con caratteri
// jolly) passata.
//
// @rdesc Ritorna il numero di file che soddisfano la condizione passata (numero di elementi
// della token string)
@ -171,7 +171,7 @@ int list_files(
#endif
// Certified 99%
// @func Permette di ritornare una stringa formata da parametri
// @func Permette di ritornare una stringa formattata
//
// @rdesc Ritorna la stringa desiderata
char* format(
@ -179,7 +179,7 @@ char* format(
...) // @parmvar Uno o piu' parametri corrispondenti ai codici in <p fmt>
// @comm Il funzionamento e' come la <f sprintf> del C, solo che non e' necessario passare la
// stringa di destinazione alla funzione
// stringa di destinazione alla funzione.
{
va_list pars;

4
include/utility.h
View File

@ -22,8 +22,8 @@ const char * decode(const char* data);
//
// @rdesc Ritorna i seguneti valori:
//
// @flag TRUE | Se il carattere <p s> e' uno slash
// @flag FALSE | Se il carattere <p s> non e' uno slash
// @flag TRUE | Se il carattere <p s> non e' uno slash
// @flag FALSE | Se il carattere <p s> e' uno slash
inline bool is_not_slash(
char s) // @parm Carattere da confrontare
{ return s != '\\' && s != '/'; }

37
include/validate.cpp
View File

@ -12,6 +12,8 @@
#include <nditte.h>
// @doc EXTERNAL
typedef bool (*VAL_FUNC)(TMask_field&, KEY k);
HIDDEN const TArray* _parms;
@ -65,8 +67,15 @@ HIDDEN bool _emptycopy_val(TMask_field& f, KEY)
return TRUE;
}
bool pi_check(const char * st, const char * paiva)
// @func Controlla se la Partita IVA assume un valore valido
//
// @rdesc Ritorna i seguenti valori:
//
// @flag TRUE | Se il valore della Partita IVA assume un valore corretto
// @flag FALSE | Se il valore della Partita IVA non puo' essere valido
bool pi_check(
const char* st, // @parm Stato di assegnazione della Partita IVA
const char* paiva) // @parm Codice della Partita IVA da controllare
{
int tot = 0, y;
TString16 stato (st);
@ -187,7 +196,16 @@ HIDDEN bool __cf_check (const char * codcf)
}
bool cf_check (const char * stato, const char * codcf)
// @func Controlla se il Codice Fiscale assume un valore valido
//
// @rdesc Ritorna i seguenti valori:
//
// @flag TRUE | Se il valore del Codice Fiscale assume un valore corretto
// @flag FALSE | Se il valore del Codice Fiscale non puo' essere valido
bool cf_check (
const char* stato, // @parm Stato di assegnazione del Codice Fiscale
const char* codcf) // @parm Codice Fiscale da controllare
{
TString16 cf (codcf);
if (cf.empty())
@ -807,7 +825,18 @@ HIDDEN VAL_FUNC _global_val_func[MAX_FUNC] =
};
bool validate(int fn, TMask_field& f, KEY k, const TArray& parms)
// @func Effettua i controlli sui campi di una maschera
//
// @rdesc Ritorna se il controllo ha avuto successo:
//
// @flag TRUE | Il campo e' positivo al controllo
// @flag FALSE | Il campo non ha i requisiti necessari per passare il controllo
bool validate(
int fn, // @parm Numero della funzione da effettuare
TMask_field& f, // @parm Identificatore del campo da controllare
KEY k, // @parm Codice del tasto premuto sul campo
const TArray& parms) // @parm Array di paramtri per effettuare il controllo
{
_parms = &parms;
return (fn >= 0 && fn < MAX_FUNC) ? _global_val_func[fn](f, k) : TRUE;

7
include/window.cpp
View File

@ -12,7 +12,6 @@
#include <windows.h>
#endif
// @doc EXTERNAL
HIDDEN MENU_ITEM* find_menu_item(MENU_ITEM* menu, MENU_TAG id, bool ismbar)
{
@ -265,12 +264,12 @@ void close_all_dialogs()
WinManager.destroy();
}
// @func Indica se possono essere chiuse le finestre aperte
// @func Indica se l'applicazione puo' essere terminata
//
// @rdesc Ritorna il risultato della ricerca:
//
// @flag TRUE | Se le finestre aperte possono essere chiuse
// @flag FALSE | Se le finestre aperte non possono essere chiuse
// @flag TRUE | Se l'aplicazione puo' essere chiusa
// @flag FALSE | Se l'applicazione non puo' essere chiusa
bool can_close()
{
return WinManager.can_close();