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) #define BITTEST(w,p) (((w) & (0x0001 << (p))) != 0)
// @doc EXTERNAL
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// Metodi di accesso globali all'applicazione corrente // Metodi di accesso globali all'applicazione corrente
@ -33,13 +34,23 @@
HIDDEN TApplication* _application = NULL; HIDDEN TApplication* _application = NULL;
// @func Ritorna l'applicazione in corso
//
// @rdesc Ritorna il reference all'applicazione in corso
TApplication& main_app() TApplication& main_app()
{ {
CHECK(_application, "NULL application!"); CHECK(_application, "NULL application!");
return *_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 // 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) 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]); TFilename base(argv[0]);
base.ext(""); base.lower(); 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_set_item_enabled(TASK_WIN, item, on);
xvt_menu_update(TASK_WIN); xvt_menu_update(TASK_WIN);
@ -585,13 +616,16 @@ bool TApplication::set_firm(long newfirm)
return TRUE; return TRUE;
} }
// @mfunc Gestisce le voci di configurazione
//
// @rdesc Ritorna TRUE se sono state cambiate delle voci
bool TApplication::config() bool TApplication::config()
// gestisce le voci di configurazione
// le si passa il file in cui cercare il proprio // @comm Le si passa il file in cui cercare il proprio paragrafo (comunque relativo
// paragrafo (comunque relativo alla ditta) // alla ditta) se non c'e', viene creato copiando il default la variabile EdMask
// se non c'e', viene creato copiando il default // di quel paragrafo specifica la maschera da usare.
// la variabile EdMask di quel paragrafo specifica
// la maschera da usare
{ {
TConfig cnf(CONFIG_DITTA); TConfig cnf(CONFIG_DITTA);
bool ok = FALSE; bool ok = FALSE;
@ -642,7 +676,12 @@ bool TApplication::config()
return ok; 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; 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. // @mfunc Controlla se al programma corrente e' concesso cambiare ditta da menu.
// Praticamente controlla se e' stato lanciato da ba0 o dal program manager //
// @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 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 #if XVT_OS == XVT_OS_WIN
static bool can = 2; static bool can = 2;

164
include/applicat.h
View File

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

2
include/array.h
View File

@ -12,7 +12,7 @@
// @doc EXTERNAL // @doc EXTERNAL
// //
// @type COMPARE_FUNCTION | Prototipo funzione di confronto tra elementi della // @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**); typedef (*COMPARE_FUNCTION)(const TObject**, const TObject**);
// @doc EXTERNAL // @doc EXTERNAL

263
include/controls.cpp
View File

@ -17,6 +17,8 @@ extern "C"
#define STRICT #define STRICT
#include <windows.h> #include <windows.h>
// @doc INTERNAL
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// TPicture_array // TPicture_array
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
@ -114,13 +116,13 @@ void xvt_draw_rect(WINDOW win, const RCT& rect, COLOR lt, COLOR rb, short depth)
{ {
if (pen.color != rb) if (pen.color != rb)
{ {
pen.color = rb; pen.color = rb;
xvt_dwin_set_cpen(win, &pen); xvt_dwin_set_cpen(win, &pen);
} }
if (!drawed) if (!drawed)
{ {
p.h = r.right; p.v = r.top; p.h = r.right; p.v = r.top;
xvt_dwin_draw_set_pos(win, p); xvt_dwin_draw_set_pos(win, p);
} }
p.v = r.bottom; p.v = r.bottom;
xvt_dwin_draw_line(win, p); xvt_dwin_draw_line(win, p);
@ -136,10 +138,17 @@ void xvt_draw_rect(WINDOW win, const RCT& rect, COLOR lt, COLOR rb, short depth)
} }
} }
// @mfunc Crea il controllo
void TControl::create( void TControl::create(
short left, short top, short right, short bottom, const char* title, short left, // @parm Coordinata X di posizionamento (in pixel)
WINDOW parent, long flags, long app_data, short id) 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; bool bold = FALSE;
_color = NORMAL_COLOR; _color = NORMAL_COLOR;
@ -155,17 +164,17 @@ void TControl::create(
case '$': case '$':
title++; // Skip [ title++; // Skip [
if (isalpha(*title)) if (isalpha(*title))
_color = trans_color(*title); _color = trans_color(*title);
else else
{ {
int r = 0, g = 0, b = 0; int r = 0, g = 0, b = 0;
sscanf(title, "%d,%d,%d", &r, &g, &b); sscanf(title, "%d,%d,%d", &r, &g, &b);
_color = MAKE_COLOR(r, g, b); _color = MAKE_COLOR(r, g, b);
} }
while (*title != ']') // Find ] while (*title != ']') // Find ]
{ {
CHECK(*title, "Bad prompt color format"); CHECK(*title, "Bad prompt color format");
title++; title++;
} }
break; break;
default: default:
@ -187,8 +196,8 @@ void TControl::create(
creating = this; creating = this;
ctl_flags = flags; ctl_flags = flags;
_win = xvtcm_create(id, left, top, right, bottom, _win = xvtcm_create(id, left, top, right, bottom,
prop_count, (char**)prop_list, parent, prop_count, (char**)prop_list, parent,
0, 0, NULL, handler, set_creation_args); 0, 0, NULL, handler, set_creation_args);
CHECKD(_win, "Can't create control ", id); CHECKD(_win, "Can't create control ", id);
creating = NULL; creating = NULL;
@ -254,19 +263,19 @@ long XVT_CALLCONV1 TControl::handler(WINDOW win, EVENT* ep)
xvt_vobj_get_client_rect(win, &r); xvt_vobj_get_client_rect(win, &r);
if (xvt_rect_has_point(&r, ep->v.mouse.where)) if (xvt_rect_has_point(&r, ep->v.mouse.where))
{ {
if (!pressed) if (!pressed)
{ {
cc->mouse_down(ep->v.mouse.where); cc->mouse_down(ep->v.mouse.where);
pressed = TRUE; pressed = TRUE;
} }
} }
else else
{ {
if (pressed) if (pressed)
{ {
cc->update(); cc->update();
pressed = FALSE; pressed = FALSE;
} }
} }
} }
break; break;
@ -277,8 +286,8 @@ long XVT_CALLCONV1 TControl::handler(WINDOW win, EVENT* ep)
tracking = FALSE; tracking = FALSE;
if (pressed) if (pressed)
{ {
cc->mouse_up(); cc->mouse_up();
pressed = FALSE; pressed = FALSE;
} }
} }
break; break;
@ -294,7 +303,11 @@ long XVT_CALLCONV1 TControl::handler(WINDOW win, EVENT* ep)
return 0L; 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()) 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; _checked = on;
} }
@ -335,13 +352,13 @@ protected:
public: public:
TText(short left, short top, short right, short bottom, TText(short left, short top, short right, short bottom,
const char* caption, WINDOW parent, const char* caption, WINDOW parent,
long flags, long app_data, short id); long flags, long app_data, short id);
}; };
TText::TText(short left, short top, short right, short bottom, TText::TText(short left, short top, short right, short bottom,
const char* caption, WINDOW parent, const char* caption, WINDOW parent,
long flags, long app_data, short id) long flags, long app_data, short id)
{ {
create(left, top+1, right, bottom-1, caption, parent, flags, app_data, id); create(left, top+1, right, bottom-1, caption, parent, flags, app_data, id);
} }
@ -366,15 +383,15 @@ protected:
public: public:
TGroup(short left, short top, short right, short bottom, TGroup(short left, short top, short right, short bottom,
const char* caption, WINDOW parent, const char* caption, WINDOW parent,
long flags, long app_data, short id); long flags, long app_data, short id);
}; };
TGroup::TGroup(short left, short top, short right, short bottom, TGroup::TGroup(short left, short top, short right, short bottom,
const char* caption, WINDOW parent, const char* caption, WINDOW parent,
long flags, long app_data, short id) long flags, long app_data, short id)
: TText(left, top, right, bottom, caption, parent, flags | CTL_FLAG_DISABLED, app_data, : 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 void TGroup::draw_round_rect(const RCT& r, COLOR c) const
@ -427,14 +444,14 @@ protected:
public: public:
TButton(short left, short top, short right, short bottom, TButton(short left, short top, short right, short bottom,
const char* caption,WINDOW parent, const char* caption,WINDOW parent,
long flags, long app_data, short id); long flags, long app_data, short id);
}; };
TButton::TButton(short left, short top, short right, short bottom, TButton::TButton(short left, short top, short right, short bottom,
const char* caption, WINDOW parent, const char* caption, WINDOW parent,
long flags, long app_data, short id) long flags, long app_data, short id)
{ {
create(left, top, right, bottom, caption, parent, flags, app_data, id); create(left, top, right, bottom, caption, parent, flags, app_data, id);
} }
@ -504,17 +521,17 @@ protected:
public: public:
TPush_button(short left, short top, short right, short bottom, TPush_button(short left, short top, short right, short bottom,
const char* caption, WINDOW parent, const char* caption, WINDOW parent,
long flags, long app_data, short id); long flags, long app_data, short id);
virtual ~TPush_button(); virtual ~TPush_button();
}; };
TPush_button::TPush_button(short left, short top, short right, short bottom, TPush_button::TPush_button(short left, short top, short right, short bottom,
const char* capt, WINDOW parent, const char* capt, WINDOW parent,
long flags, long app_data, short id) long flags, long app_data, short id)
: TButton(left-(id == DLG_F9), top, right, bottom, : TButton(left-(id == DLG_F9), top, right, bottom,
capt, parent, flags, app_data, id), capt, parent, flags, app_data, id),
_picup(0), _picdn(0) _picup(0), _picdn(0)
{ {
switch(id) switch(id)
{ {
@ -639,9 +656,9 @@ void TPush_button::draw_pressed(bool pressed) const
const TImage& i = cpb.image(pic); const TImage& i = cpb.image(pic);
RCT dst = i.rect(); RCT dst = i.rect();
if (pressed) if (pressed)
xvt_rect_offset(&dst, _dx+DEPTH, _dy+DEPTH); xvt_rect_offset(&dst, _dx+DEPTH, _dy+DEPTH);
else else
xvt_rect_offset(&dst, _dx, _dy); xvt_rect_offset(&dst, _dx, _dy);
i.draw(_hdc, dst); i.draw(_hdc, dst);
} }
} }
@ -696,17 +713,17 @@ void TPush_button::update() const
for (int i = sx; i < ex; i += 2) for (int i = sx; i < ex; i += 2)
{ {
PNT p = { sy, i }; PNT p = { sy, i };
xvt_dwin_draw_set_pos(_hdc, p); xvt_dwin_draw_set_pos(_hdc, p);
p.v = ey; p.v = ey;
xvt_dwin_draw_line(_hdc, p); xvt_dwin_draw_line(_hdc, p);
} }
for (i = sy; i < ey; i += 2) for (i = sy; i < ey; i += 2)
{ {
PNT p = { i, sx }; PNT p = { i, sx };
xvt_dwin_draw_set_pos(_hdc, p); xvt_dwin_draw_set_pos(_hdc, p);
p.h = ex; p.h = ex;
xvt_dwin_draw_line(_hdc, p); xvt_dwin_draw_line(_hdc, p);
} }
} }
} }
@ -738,7 +755,7 @@ TPage_button::TPage_button(WINDOW parent, byte flag) : _flag(flag)
if (flag == 2) r.right -= w; if (flag == 2) r.right -= w;
create(r.right-w, r.bottom-height, r.right, r.bottom, 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); cpb.add(BMP_BOOK1 + flag -1, flag == 3);
} }
@ -878,8 +895,8 @@ protected:
public: public:
TCheckbox(short left, short top, short right, short bottom, TCheckbox(short left, short top, short right, short bottom,
const char* caption, WINDOW parent, const char* caption, WINDOW parent,
long flags, long app_data, short id); long flags, long app_data, short id);
virtual ~TCheckbox(); virtual ~TCheckbox();
}; };
@ -888,7 +905,7 @@ TCheckbox::TCheckbox(
const char* caption, WINDOW parent, const char* caption, WINDOW parent,
long flags, long app_data, short id) long flags, long app_data, short id)
: TButton(left, top, right, bottom, : TButton(left, top, right, bottom,
caption, parent, flags, app_data, id) caption, parent, flags, app_data, id)
{ {
if (!cpb.exist(BMP_CHECK_ON)) if (!cpb.exist(BMP_CHECK_ON))
{ {
@ -958,48 +975,72 @@ void TCheckbox::update() const
// User functions // User functions
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @func Permette di creare un Checkbox
//
// @rdesc Ritorna l'handle del controllo creato
WINDOW xvt_create_checkbox( WINDOW xvt_create_checkbox(
short left, short top, short right, short bottom, short left, // @parm Coordinata X di posizionamento (in pixel)
const char* caption, short top, // @parm Coordinata Y di posizionamento (in pixel)
WINDOW parent, short right, // @parm Larghezza (in pixel)
long flags, short bottom, // @parm Altezza (in pixel)
long app_data, const char* caption, // @parm Prompt
int id) 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, TCheckbox* cb = new TCheckbox(left, top, right, bottom,
caption, parent, caption, parent,
flags, app_data, id); flags, app_data, id);
// It'll destroy itself automagically :-) // It'll destroy itself automagically :-)
return cb->win(); return cb->win();
} }
// @func Permette di creare un Radiobutton
//
// @rdesc Ritorna l'handle del controllo creato
WINDOW xvt_create_radiobutton( WINDOW xvt_create_radiobutton(
short left, short top, short right, short bottom, short left, // @parm Coordinata X di posizionamento (in pixel)
const char* caption, short top, // @parm Coordinata Y di posizionamento (in pixel)
WINDOW parent, short right, // @parm Larghezza (in pixel)
long flags, short bottom, // @parm Altezza (in pixel)
long app_data, const char* caption, // @parm Prompt
int id) 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; flags |= CTL_FLAG_MULTIPLE;
TCheckbox* cb = new TCheckbox(left, top, right, bottom, TCheckbox* cb = new TCheckbox(left, top, right, bottom,
caption, parent, caption, parent,
flags, app_data, id); flags, app_data, id);
// It'll destroy itself automagically :-) // It'll destroy itself automagically :-)
return cb->win(); return cb->win();
} }
// @func Permette di creare un qualsiasi Bottone premibile
//
// @rdesc Ritorna l'handle del controllo creato
WINDOW xvt_create_pushbutton( WINDOW xvt_create_pushbutton(
short left, short top, short right, short bottom, short left, // @parm Coordinata X di posizionamento (in pixel)
const char* caption, short top, // @parm Coordinata Y di posizionamento (in pixel)
WINDOW parent, short right, // @parm Larghezza (in pixel)
long flags, short bottom, // @parm Altezza (in pixel)
long app_data, const char* caption, // @parm Prompt
int id) 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; TControl* pb;
@ -1018,8 +1059,8 @@ WINDOW xvt_create_pushbutton(
bottom -= BASEY>>1; bottom -= BASEY>>1;
} }
pb = new TPush_button(left, top, right, bottom, pb = new TPush_button(left, top, right, bottom,
caption, parent, caption, parent,
flags, app_data, id); flags, app_data, id);
} }
// It'll destroy itself automagically :-) // 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( WINDOW xvt_create_text(
short left, short top, short right, short bottom, short left, // @parm Coordinata X di posizionamento (in pixel)
const char* caption, short top, // @parm Coordinata Y di posizionamento (in pixel)
WINDOW parent, short right, // @parm Larghezza (in pixel)
long flags, short bottom, // @parm Altezza (in pixel)
long app_data, const char* caption, // @parm Prompt
int id) 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, TText* cb = new TText(left, top, right, bottom,
caption, parent, caption, parent,
flags, app_data, id); flags, app_data, id);
// It'll destroy itself automagically :-) // It'll destroy itself automagically :-)
return cb->win(); return cb->win();
} }
// @func Permette di creare un Groupbox
//
// @rdesc Ritorna l'handle del controllo creato
WINDOW xvt_create_groupbox( WINDOW xvt_create_groupbox(
short left, short top, short right, short bottom, short left, // @parm Coordinata X di posizionamento (in pixel)
const char* caption, short top, // @parm Coordinata Y di posizionamento (in pixel)
WINDOW parent, short right, // @parm Larghezza (in pixel)
long flags, short bottom, // @parm Altezza (in pixel)
long app_data, const char* caption, // @parm Prompt
int id) 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, TGroup* cb = new TGroup(left, top, right, bottom,
caption, parent, caption, parent,
flags, app_data, id); flags, app_data, id);
// It'll destroy itself automagically :-) // It'll destroy itself automagically :-)
return cb->win(); return cb->win();
} }
// @func Dealloca le bitmab utilizzate per i controlli
void free_controls_bmp() void free_controls_bmp()
{ {
cpb.destroy(); cpb.destroy();

179
include/controls.h
View File

@ -6,105 +6,154 @@
#endif #endif
WINDOW xvt_create_checkbox( WINDOW xvt_create_checkbox(
short left, short top, short right, short bottom, short left, short top, short right, short bottom,
const char* caption, const char* caption,
WINDOW parent, WINDOW parent,
long flags, long flags,
long app_data, long app_data,
int id int id);
);
WINDOW xvt_create_radiobutton( WINDOW xvt_create_radiobutton(
short left, short top, short right, short bottom, short left, short top, short right, short bottom,
const char* caption, const char* caption,
WINDOW parent, WINDOW parent,
long flags, long flags,
long app_data, long app_data,
int id int id);
);
WINDOW xvt_create_pushbutton( WINDOW xvt_create_pushbutton(
short left, short top, short right, short bottom, short left, short top, short right, short bottom,
const char* caption, const char* caption,
WINDOW parent, WINDOW parent,
long flags, long flags,
long app_data, long app_data,
int id int id);
);
WINDOW xvt_create_text( WINDOW xvt_create_text(
short left, short top, short right, short bottom, short left, short top, short right, short bottom,
const char* caption, const char* caption,
WINDOW parent, WINDOW parent,
long flags, long flags,
long app_data, long app_data,
int id int id);
);
WINDOW xvt_create_groupbox( WINDOW xvt_create_groupbox(
short left, short top, short right, short bottom, short left, short top, short right, short bottom,
const char* caption, const char* caption,
WINDOW parent, WINDOW parent,
long flags, long flags,
long app_data, long app_data,
int id 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; WINDOW _win;
// @cmember Iedntificatore assegnato al cotrollo
short _id; short _id;
// @cmember Prompt del controllo
TString _caption; 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 _disabled : 1;
bool _checked : 1; // @cmember Indica se il controllo ha un check
bool _focused : 1; 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; bool _multiple : 1;
// @access Protected Member
protected: protected:
// @cmember E' l'handler del controllo
static long XVT_CALLCONV1 handler(WINDOW win, EVENT* ep); static long XVT_CALLCONV1 handler(WINDOW win, EVENT* ep);
void create(short left, short top, short right, short bottom, // @cmember Crea il controllo
const char* caption, void create(short left, short top, short right, short bottom, const char* caption, WINDOW parent, long flags, long app_data, short id);
WINDOW parent, long flags, long app_data, short id);
// @cmember Ridisegna il controllo a video
virtual void update() const pure; virtual void update() const pure;
virtual void mouse_down(PNT) {}; // @cmember Chiamate ogni volta che viene premuto il mouse sul controllo
virtual void mouse_up() {}; virtual void mouse_down(PNT)
virtual WIN_TYPE type() const { return W_NO_BORDER; } {};
// @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: public:
// @cmember Ritorna il TControl dalla finestra del controllo
static TControl* WINDOW2TControl(WINDOW win); static TControl* WINDOW2TControl(WINDOW win);
// @cmember Distruttore. Necessariamente virtuale per derivare altri distruttori
virtual ~TControl(); virtual ~TControl();
WINDOW win() const { return _win; } // @cmember Ritorna l'handle del controllo
short id() const { return _id; } WINDOW win() const
const char* caption() const { return _caption; } { 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); void set_caption(const char* c);
COLOR color() const { return _color; } // @cmember Ritorna il colore di forground del controllo
void set_color(COLOR c) { _color = c; } COLOR color() const
{ return _color; }
// @cmember Setta il colore di forground del controllo
void set_color(COLOR c)
{ _color = c; }
COLOR back_color() const { return _backcolor; } // @cmember Ritorna il colore di background del controllo
void set_back_color(COLOR c) { _backcolor = c; } COLOR back_color() const
{ return _backcolor; }
// @cmember Setta il colore di background del controllo
void set_back_color(COLOR c)
{ _backcolor = c; }
bool checked() const { return _checked; } // @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); 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); void enable(bool on);
bool focused() const { return _focused; } // @cmember Ritorna se il controllo ha il focus
void focus(bool on) { _focused = on; } 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 #endif

279
include/form.cpp
View File

@ -39,6 +39,8 @@ HIDDEN const int frm_id = 113;
// Utility functions // Utility functions
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// @doc EXTERNAL
// Current form (edit, print) // Current form (edit, print)
HIDDEN TForm* _cur_form = NULL; HIDDEN TForm* _cur_form = NULL;
HIDDEN TPrint_section* _cur_sect = NULL; HIDDEN TPrint_section* _cur_sect = NULL;
@ -62,8 +64,12 @@ HIDDEN TMask& special_mask()
return *_special_mask; return *_special_mask;
} }
// Translate char to pagetype (visible outside here, no more HIDDEN) // @func Funzione che converte dalla notazione carattere al corrispondente
pagetype char2page(char c) // enum <t pagetype>
//
// @rdesc Ritorna il <t pagetype> corrispondente
pagetype char2page(
char c) // @parm Notazione carattere del tipo di pagina
{ {
pagetype pt; pagetype pt;
switch(c) 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; _flag.enabled = on;
show(on); show(on);
@ -612,8 +624,10 @@ TToken_string& TForm_item::message(int m)
return *t; return *t;
} }
// @mfunc Manda il messaggio al campo <p dest>
void TForm_item::send_message(const TString& cmd, TForm_item& des) const 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") if (cmd == "ADD" || cmd == "INC")
{ {
@ -2171,7 +2185,13 @@ bool TPrint_section::update()
return ok; 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"); CHECK(prof.num() == LF_RFORM, "Il record deve essere del file LF_RFORM");
@ -2517,7 +2537,11 @@ bool TPrint_section::detail_field_notify (TSheet_field& s, int r, KEY k)
return TRUE; 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"; const bool is_ba_editor = TString(_form->section_mask()).left(2) == "ba";
bool nstd_dirty = FALSE; bool nstd_dirty = FALSE;
@ -2972,7 +2996,18 @@ void TForm::print_general(ostream& out) const
out << "END\n" << endl; 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; TArray* a;
switch (toupper(s)) switch (toupper(s))
@ -3023,7 +3058,13 @@ TPrint_section& TForm::section(char s, word pagenum)
return section(s, pt); 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); TPrint_section* s = exist(sec,p);
bool ok = force; bool ok = force;
@ -3087,7 +3128,16 @@ bool TForm::reread(char sec, pagetype p, bool force)
// TForm // 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++) for (word i = 0; i < s.fields(); i++)
{ {
@ -3107,7 +3157,17 @@ bool TForm::ps_change_date_format(TPrint_section& s, const char* f)
return TRUE; 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++) for (word i = 0; i < s.fields(); i++)
{ {
@ -3155,7 +3215,14 @@ void TForm::change_number_format(int w, int dec, const char* p)
ps_change_number_format(*ps, w, dec, p); 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; word len = 0;
@ -3169,7 +3236,14 @@ word TForm::set_background(word p, bool u)
return len; 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(); TPrinter& pr = printer();
pr.resetheader(); pr.resetheader();
@ -3189,7 +3263,15 @@ word TForm::set_header(word p, bool u)
return head.height(); 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); TPrint_section& body = section('B', p);
@ -3206,7 +3288,15 @@ word TForm::set_body(word p, bool u)
return body.height(); 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(); TPrinter& pr = printer();
pr.resetfooter(); 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(); return _lastpage ? 0 : p.getcurrentpage();
} }
// @mfunc Effettua il posizionamento manuale del modulo
void TForm::arrange_form() 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; TString device;
#if XVT_OS == XVT_OS_WIN #if XVT_OS == XVT_OS_WIN
@ -3264,20 +3377,7 @@ void TForm::arrange_form()
device = device.left(4); //Legge solo LPTx... device = device.left(4); //Legge solo LPTx...
#endif #endif
FILE* lpt = fopen(device,"w"); 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; int i, x;
TString str_pos; TString str_pos;
if (lpt == NULL) fatal_box("Non rieso ad aprire il device %s.",device); if (lpt == NULL) fatal_box("Non rieso ad aprire il device %s.",device);
@ -3325,7 +3425,16 @@ long TForm::records() const
return r; 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); TPrint_section* body = exist('B', p);
if (body == NULL) return FALSE; if (body == NULL) return FALSE;
@ -3405,7 +3514,15 @@ bool TForm::genera_fincatura(pagetype p, int y1, int y2, const int* rows)
return TRUE; 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); TPrint_section* body = exist('B', p);
if (body == NULL || !body->columnwise()) return FALSE; if (body == NULL || !body->columnwise()) return FALSE;
@ -3430,10 +3547,87 @@ bool TForm::genera_intestazioni(pagetype p, short y)
return TRUE; 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; _cur_form = this;
@ -3607,8 +3801,14 @@ word TForm::height(word page)
return h; 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() 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 prof(LF_FORM);
TLocalisamfile rprof(LF_RFORM); TLocalisamfile rprof(LF_RFORM);
@ -3759,7 +3959,12 @@ void TForm::init()
_background_mode = printer().isgraphics() ? graphics : testo; _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; _name= name;
_code= code; _code= code;

813
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; friend class TBaseisamfile;
// @cfriend TLocalisamfile // @cfriend TLocalisamfile
friend class TLocalisamfile; friend class TLocalisamfile;
// @cfriend TIsamtemp file // @cfriend TIsamtempfile
friend class TIsamtempfile; friend class TIsamtempfile;
// @access Private Member // @access Private Member

4
include/mailbox.h
View File

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

4
include/mask.cpp
View File

@ -1592,7 +1592,9 @@ WINDOW TMask::add_list (
return f->win(); 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 ( WINDOW TMask::add_boolean (
short id, // @parm Numero identificatore del campo da aggiungere short id, // @parm Numero identificatore del campo da aggiungere
int page, // @parm Pagina nel quale aggiungere il campo 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 // @mfunc Cerca la colonna col
XI_OBJ* TSpreadsheet::find_column( 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); CHECKD(col >= 0, "Bad column ", col);
if (col < FIRST_FIELD) // Se e' un indice trasformalo in identificatore 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 <mailbox.h>
#include <sheet.h> #include <sheet.h>
#include <urldefid.h> #include <urldefid.h>
@ -14,18 +13,38 @@
// Array delle chiavi della maschera di ricerca // 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 class TChiave : public TObject
// @author:(INTERNAL) Guido
// @access Private Member
{ {
// @ccost MAX | 16 | Numero massimo di chiavi della maschera di ricerca
enum { MAX = 16 }; enum { MAX = 16 };
// @cmember Posizione delle chiavi nella msachera di ricerca
int _pos[MAX]; int _pos[MAX];
// @cmember Numero di chiavi presenti nella maschera di ricerca
byte _num; byte _num;
// @access Public Member
public: public:
// @cmember Aggiunge una nuova chiave alla posizione <p p>
void add(int p); void add(int p);
int pos(byte n) const { return (n >= _num) ? -1 : _pos[n]; } // @cmember Ritorna la posizione della chiave <p n>-esima (-1 se non esiste)
byte items() const { return _num; } int pos(byte n) const
TChiave() : _num(0) {} { return (n >= _num) ? -1 : _pos[n]; }
virtual ~TChiave() {} // @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) void TChiave::add(int p)
@ -70,6 +89,8 @@ TKey_array::TKey_array(const TMask* m) : _mask(m)
} }
} }
// @doc EXTERNAL
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
// TRelation_application // TRelation_application
/////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////
@ -96,12 +117,15 @@ void TRelation_application::setkey()
} }
// what - meaning // @mfunc Setta i limiti
// 0 - nop void TRelation_application::set_limits(
// 1 - first byte what) // @parm tipo di limite da assegnare al record
// 2 - last
// 3 - both // @comm I limiti possibili sono:
void TRelation_application::set_limits(byte what) // @flag 0 | Nessuna operazione
// @flag 1 | Primo record
// @flag 2 | Ultimo record
// @flag 3 | Entrambi
{ {
if (has_filtered_cursor()) if (has_filtered_cursor())
{ {
@ -298,8 +322,15 @@ int TRelation_application::set_mode(int mode)
return _mode; return _mode;
} }
// @mfunc Permette di autonumerare un record
bool TRelation_application::autonum(TMask* m, bool rec) //
// @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()); TToken_string k(get_next_key());
@ -321,8 +352,12 @@ bool TRelation_application::autonum(TMask* m, bool rec)
return k.not_empty(); return k.not_empty();
} }
// @mfunc Entra in modo di ricerca
void TRelation_application::query_mode(bool pre_ins) 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; TMask* old = _mask;
const bool was_open = old != NULL && old->is_open(); const bool was_open = old != NULL && old->is_open();
@ -479,8 +514,12 @@ bool TRelation_application::search_mode()
return FALSE; return FALSE;
} }
// @mfunc Controlla se una chiave e' completa ed esiste su file
bool TRelation_application::test_key(byte k, bool err) //
// @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); const TChiave& chiave = _maskeys->key(k);
bool onereq = FALSE, onefill = FALSE; bool onereq = FALSE, onefill = FALSE;
@ -712,8 +751,12 @@ int TRelation_application::rewrite(const TMask& m)
return r->status(); return r->status();
} }
// @mfunc Cancella il record corrente
// @rdesc Ritorna se il record e' stato eliminato
bool TRelation_application::relation_remove() 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"); CHECK(_mask->mode() == MODE_MOD, "You can call remove in MODE_MOD only");
TRelation *r = get_relation(); TRelation *r = get_relation();

205
include/relapp.h
View File

@ -13,108 +13,205 @@
#include <mask.h> #include <mask.h>
#endif #endif
// @doc EXTERNAL
class TKey_array; 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 class TRelation_application : public TApplication
{
TMask * _mask;
TKey_array* _maskeys;
TRecnotype _first, _last;
int _search_id;
// @author:(INTERNAL) Guido
// @access Private Member
{
// @cmember Maschera corrente dell'applicazione
TMask* _mask;
// @cmember Array di chiavi della maschera
TKey_array* _maskeys;
// @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; TString16 _autoins_caller;
// @cmember Numero del record nuovo/editato
long _recins; long _recins;
// @cmember Indica se e' stato chiamato col messaggio di link
bool _lnflag; bool _lnflag;
// @cmember Contiene il codice del campo e il valore fisso
TToken_string _fixed; TToken_string _fixed;
// @cmember Messaggio da passare all'utente per inidicare che e' stata fatta la rinumerazione
TString _renum_message; TString _renum_message;
// @cmember Setta i campi fissati da <md TRelation_application::_fixed>
bool filter(); bool filter();
// @cmember Controlla se una chiave e' completa ed esiste su file
bool test_key(byte k, bool err); bool test_key(byte k, bool err);
// @cmember Salva i contenuti della maschera su file
bool save(bool check_dirty); bool save(bool check_dirty);
// @cmember Abilita la ricerca sulla maschera
void enable_query(); void enable_query();
// @cmember UNUSED
void set_toolbar(bool all); 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 set_limits(byte what = 0x3);
void query_insert_mode() { query_mode(TRUE); } // @cmember Posiziona l'applicazione in modo richiesta/inserimento (chaima <mf TRelation_application::query_mode>)
void insert_mode(); // Entra in modo inserimento void query_insert_mode()
bool relation_remove(); // Cancella il record corrente { query_mode(TRUE); }
TMask_field* get_search_field() const; // @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 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: protected:
// @cmember Effettua i controlli all'inizio dell'applicazione
virtual bool create(); virtual bool create();
// @cmember Effettua i controlli alla fine dell'applicazione
virtual bool destroy(); virtual bool destroy();
// @cmember Controlla se e' possibile modificare la ditta corrente durante l'esecuzione dell'applicazione
virtual bool firm_change_enabled() const; virtual bool firm_change_enabled() const;
protected: protected:
TLocalisamfile& file() const { return get_relation()->lfile(); } // File principale della relazione // @cmember Ritorna il descrittore del file principale della relazione
TRecnotype first() const { return _first;} TLocalisamfile& file() const
TRecnotype last() const { return _first;} { return get_relation()->lfile(); }
const TString& autoins_caller() const { return _autoins_caller;} // @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 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 // @cmember Inizializzazione dei dati dell'utente
virtual bool user_destroy() pure; // Distruzione dati 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 // @cmember Fissa i campi non modificabili
bool search_mode(); // Attiva la maschera di ricerca void set_fixed();
void query_mode(bool pre_ins = FALSE); // Entra in modo ricerca // @cmember Attiva la maschera di ricerca
bool modify_mode(); // Entra in modo modifica bool search_mode();
void setkey(); // @cmember Entra in modo di ricerca
bool lnflag() const { return _lnflag;} void query_mode(bool pre_ins = FALSE);
// La richiesta della maschera da utilizzare per ogni fase di lavoro (ricerca, inserimento, // @cmember Entra in modo modifica
// modifica avviene sempre in due tempi: changing_mask e get_mask. Cio' serve per gestire bool modify_mode();
// Correttamente le applicazioni con mashere multiple. La prima funzione serve a sapere se // @cmember Legge i campi chiave della maschera e setta il cursore relativo
// la futura get_mask ritornera' una maschera diversa dalla corrente. 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; virtual bool changing_mask(int mode) pure;
virtual TMask* get_mask(int mode) pure; // Richiede la maschera da usare // @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() // @cmember Forza la rigenerazione della lista interna di chiavi ad ogni <mf TRealtion_application::find>
virtual bool changing_keys() const { return FALSE; } virtual bool changing_keys() const
{ return FALSE; }
virtual TRelation* get_relation() const pure; // Relazione da modificare // @cmember Ritorna la relazione da modificare
virtual int read(TMask& m); // Legge dalla relazione i valori nella maschera virtual TRelation* get_relation() const pure;
virtual int write(const TMask& m); // Scrive sulla relazione i valori dalla maschera // @cmember Legge dalla relazione i valori nella maschera <p m>
virtual int rewrite(const TMask& m); // Riscrive sulla relazione i valori dalla maschera virtual int read(TMask& m);
virtual bool remove(); // Cancella il record corrente // @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 // @cmember Richiede una stringa nella forma CAMPO1<pipe>VALORE1<pipe>CAMPO2<pipe>VALORE2<pipe>...
// contenente le coppie NUMERO_CAMPO_MASCHERA - VALORE_DA_ASSEGNARE che descrivono il // <pipe>CAMPOn<pipe>VALOREn contenente le coppie NUMERO_CAMPO_MASCHERA - VALORE_DA_ASSEGNARE
// prossimo codice libero da utilizzare per la autonumerazione. // che descrivono il prossimo codice libero da utilizzare per la autonumerazione.
// Nel caso di banale numerazione progressiva potrebbe essere implementata come // <nl>Nel caso di banale numerazione progressiva potrebbe essere implementata come
// return format("%d|%s", F_NUM, get_relation()->items()); // return format("%d<pipe>%s", F_NUM, get_relation()-<gt>items());
virtual const char* get_next_key() { return ""; } virtual const char* get_next_key()
{ return ""; }
// Richiede se il record corrente e' protetto (non cancellabile) // @cmember Richiede se il record corrente e' protetto (non cancellabile)
virtual bool protected_record(TRectype&) { return FALSE; } virtual bool protected_record(TRectype&)
{ return FALSE; }
virtual void init_query_mode(TMask&) { } // Inizializza la maschera per il modo ricerca // @cmember Inizializza la maschera per il modo ricerca
virtual void init_query_insert_mode(TMask& m) { init_query_mode(m); } virtual void init_query_mode(TMask&)
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 // @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&)
{ }
virtual bool force_cursor_usage() const { return FALSE;} // @cmember Simula l'utilizzo di un filtro da un'altra applicazione
virtual void write_enable(bool on = TRUE) { get_relation()->write_enable(0, on); } virtual bool force_cursor_usage() const
void write_disable() { write_enable(FALSE); } { 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; virtual bool save_and_new() const;
void set_search_field(short id) { _search_id = id;} // Impone il campo da utilizzare col bottone Ricerca // @cmember Impone il campo da utilizzare col bottone Ricerca
void set_search_field(short id)
{ _search_id = id;}
// @access Public Member
public: public:
TMask& curr_mask() const { return *_mask; } // @cmember Ritorna la maschera corrente
TMask& curr_mask() const
{ return *_mask; }
bool filtered() const { return _fixed.not_empty(); } // @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); bool find(byte key = 0);
// @cmember Costruisce il membro <md TRelation_application::_fixed>
void set_link(TMask & m, const char * keyexpr); void set_link(TMask & m, const char * keyexpr);
// @cmember Costruttore
TRelation_application(); TRelation_application();
// @cmember Distruttore
virtual ~TRelation_application(); 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 // join.h
// fv 12/8/93 // fv 12/8/93
// join class for isam files // join class for isam files
@ -20,7 +20,7 @@ class TSort;
// //
// @base public | TObject // @base public | TObject
class TRelation : public TObject class TRelation : public TObject
// @author(:INTERNAL) Sandro // @author:(INTERNAL) Sandro
{ {
// @cfriend TRelationdef // @cfriend TRelationdef
friend class TRelationdef; friend class TRelationdef;
@ -29,7 +29,7 @@ class TRelation : public TObject
// @cfriend TCursor // @cfriend TCursor
friend class TCursor; friend class TCursor;
// @access Provate Member // @access Private Member
// @cmember Stato della relazione // @cmember Stato della relazione
TToken_string _status; TToken_string _status;
@ -220,7 +220,7 @@ public:
// @base public | TArray // @base public | TArray
class TRecord_array : private TArray class TRecord_array : private TArray
// @author(:ITERNAL) Guido // @author:(INTERNAL) Guido
// @access Private Member // @access Private Member
{ {

9
include/sheet.cpp
View File

@ -283,8 +283,13 @@ void TSheet::handler(WINDOW win, EVENT* ep)
} }
// @func ???!!!??? // @mfunc Converte le coordinate da logiche (caratteri) in coordinate fisiche (pixel)
PNT TSheet::log2dev(long x, long y) const // (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; if (autoscrolling()) x -= origin().x;
return TWindow::log2dev(x, y); return TWindow::log2dev(x, y);

30
include/stack.h
View File

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

26
include/stdtypes.cpp
View File

@ -23,9 +23,15 @@
extern isfdptr *openf; extern isfdptr *openf;
HIDDEN long _stdlevel = 0; HIDDEN long _stdlevel = 0;
// @doc EXTERNAL
// @func Ritorna il livello degli archivi
long get_std_level() long get_std_level()
{ return _stdlevel; } { return _stdlevel; }
// @func Ritorna il numero di serie della chiave
//
// @rdesc Numero di serie della chiave
int get_serial_number() int get_serial_number()
{ {
#if XVT_OS != XVT_OS_SCOUNIX #if XVT_OS != XVT_OS_SCOUNIX
@ -36,6 +42,7 @@ int get_serial_number()
return getser(); return getser();
} }
// @func Inizilizza le variabili globali
void init_global_vars() void init_global_vars()
{ {
TPrefix& pref = prefix_init(); TPrefix& pref = prefix_init();
@ -70,6 +77,7 @@ void init_global_vars()
DB_init(); DB_init();
} }
// @func Dealloca le variabili globali
void free_global_vars() void free_global_vars()
{ {
#if XVT_OS != XVT_OS_SCOUNIX #if XVT_OS != XVT_OS_SCOUNIX
@ -91,7 +99,15 @@ void free_global_vars()
unsigned long _alloc_count = 0; unsigned long _alloc_count = 0;
#endif #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) 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); void* mem = (void*)malloc(size);
if (mem == NULL) if (mem == NULL)
@ -104,7 +120,15 @@ void* operator new(size_t size)
return mem; 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"); CHECK(ptr, "Can't delete a NULL pointer");
free(ptr); free(ptr);

29
include/stdtypes.h
View File

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

55
include/tabapp.h
View File

@ -11,27 +11,60 @@
#define FPC "FPC" #define FPC "FPC"
class Tab_application : public TRelation_application // @doc EXTERNAL
{
TMask* _msk;
TRelation* _rel;
TString16 _tabname;
// @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: protected:
// @cmember Richiede se il record corrente e' protetto (non cancellabile)
virtual bool protected_record(TRectype& rec); virtual bool protected_record(TRectype& rec);
virtual TMask* get_mask(int mode = NO_MODE) { return _msk;} // @cmember Richiede la maschera da usare
virtual bool changing_mask(int mode) { return FALSE;} virtual TMask* get_mask(int mode = NO_MODE)
virtual TRelation* get_relation() const { return _rel;} { 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); virtual void init_query_mode(TMask& m);
// @cmember Inizializza la maschera per il modo modifica
virtual void init_modify_mode(TMask& m); virtual void init_modify_mode(TMask& m);
// @cmember Inizializzazione dei dati dell'utente
virtual bool user_create() ; virtual bool user_create() ;
// @cmember Distruzione dei dati dell'utente
virtual bool user_destroy() ; virtual bool user_destroy() ;
// @cmember Chiama il programma di stampa
virtual void print(); virtual void print();
// @access Public Member
public: public:
Tab_application() : _msk(NULL), _rel(NULL) {} // @cmember Costruttore
virtual ~Tab_application() {} Tab_application() : _msk(NULL), _rel(NULL)
const TString& get_tabname() const { return _tabname; } {}
// @cmember Distruttore
virtual ~Tab_application()
{}
// @cmember Ritorna il nome della tabella
const TString& get_tabname() const
{ return _tabname; }
}; };
#endif #endif

8
include/utility.cpp
View File

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

4
include/utility.h
View File

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

37
include/validate.cpp
View File

@ -12,6 +12,8 @@
#include <nditte.h> #include <nditte.h>
// @doc EXTERNAL
typedef bool (*VAL_FUNC)(TMask_field&, KEY k); typedef bool (*VAL_FUNC)(TMask_field&, KEY k);
HIDDEN const TArray* _parms; HIDDEN const TArray* _parms;
@ -65,8 +67,15 @@ HIDDEN bool _emptycopy_val(TMask_field& f, KEY)
return TRUE; return TRUE;
} }
// @func Controlla se la Partita IVA assume un valore valido
bool pi_check(const char * st, const char * paiva) //
// @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; int tot = 0, y;
TString16 stato (st); 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); TString16 cf (codcf);
if (cf.empty()) 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; _parms = &parms;
return (fn >= 0 && fn < MAX_FUNC) ? _global_val_func[fn](f, k) : TRUE; 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> #include <windows.h>
#endif #endif
// @doc EXTERNAL
HIDDEN MENU_ITEM* find_menu_item(MENU_ITEM* menu, MENU_TAG id, bool ismbar) HIDDEN MENU_ITEM* find_menu_item(MENU_ITEM* menu, MENU_TAG id, bool ismbar)
{ {
@ -265,12 +264,12 @@ void close_all_dialogs()
WinManager.destroy(); 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: // @rdesc Ritorna il risultato della ricerca:
// //
// @flag TRUE | Se le finestre aperte possono essere chiuse // @flag TRUE | Se l'aplicazione puo' essere chiusa
// @flag FALSE | Se le finestre aperte non possono essere chiuse // @flag FALSE | Se l'applicazione non puo' essere chiusa
bool can_close() bool can_close()
{ {
return WinManager.can_close(); return WinManager.can_close();