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

Patch level :

Browse Source 
Files correlati     : agalib
Ricompilazione Demo : [ ]
Commento            :
Aggiunto supporto per chiavi software SSA
Aggiunto supporto per ricerche alternative con prefisso %


git-svn-id: svn://10.65.10.50/branches/R_10_00@22582 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
guy 2012-02-22 17:03:39 +00:00
parent 36b5a19596
commit 6ac7b50cda
18 changed files with 2397 additions and 2245 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/about.cpp
View File

@ -317,7 +317,7 @@ TInfo_mask::TInfo_mask() : TProperty_sheet(TR("Informazioni"))
case _dongle_hardlock: prot = "Hardlock"; break;
case _dongle_eutron : prot = "Eutron"; break;
case _dongle_network : prot = dongle().server_name(); break;
case _dongle_aladdin : prot = "Aladdin"; break;
case _dongle_ssa : prot = "SSA"; break;
default : prot = TR("Nessuna"); break;
}

38
include/applicat.cpp
View File

@ -373,37 +373,27 @@ const char* TApplication::get_module_name() const
if (module.empty())
{
const TDongle& d = dongle();
const word aut = d.module_name2code(_name.left(2));
const TString4 modname = _name.left(2);
const word aut = d.module_name2code(modname);
module = d.module_code2desc(aut);
bool ok = module.full();
if (ok && check_autorization())
ok = has_module(aut);
if (ok && check_autorization())
ok = dongle().login(modname);
if (!ok)
{
if (module.empty())
module = "Tools";
module = modname;
TToken_string em(extra_modules());
if (!em.empty_items())
{
if (em != "*")
{
FOR_EACH_TOKEN(em, cod)
{
const word alt = d.module_name2code(cod);
if (has_module(alt))
{
ok = true;
break;
}
}
}
else
ok = true;
ok = em == "*";
FOR_EACH_TOKEN(em, cod) if (!ok)
ok = dongle().login(cod);
}
if (!ok)
{
error_box(TR("Il modulo '%s' non e' autorizzato per l'utente %s"), (const char*)module, ((const char*)user()));
error_box(FR("Il modulo '%s' non e' autorizzato per l'utente %s"), (const char*)module, ((const char*)user()));
module.cut(0);
}
}
@ -522,7 +512,7 @@ void TApplication::run(
const int sn = get_serial_number();
if (sn > 0 && !test_assistance_year())
{
error_box(TR("E' necessario attivare il contratto di assistenza per l'anno in corso"));
error_box(FR("E' necessario attivare il contratto di assistenza per la chiave %d"), sn);
return;
}
@ -607,11 +597,11 @@ void TApplication::uncheck_menu_item(MENU_TAG item)
// @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':
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'
// @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);

3
include/automask.cpp
View File

@ -6,8 +6,7 @@ bool TAutomask::error_box(const char* fmt, ...)
char* msg = message.get_buffer();
va_list argptr;
va_start(argptr, fmt);
int len = vsprintf(msg, fmt, argptr);
CHECKD(len <= message.size(), "Error message too long: ", len);
vsnprintf_s(msg, message.size(), _TRUNCATE, fmt, argptr);
va_end(argptr);
if (is_sheetmask() && !is_running())

1765
include/brwbut.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

406
include/brwbut.h Normal file
View File

@ -0,0 +1,406 @@
#ifndef __BRWBUT_H
#define __BRWBUT_H
///////////////////////////////////////////////////////////
// TBrowse_button
///////////////////////////////////////////////////////////
class TEdit_field;
class TEditable_field;
class TBrowse_button : public TObject
{
TEdit_field* _fld;
protected:
// @cmember Ritorna il primo valore di <p _fld>
TEdit_field& field() const { return *_fld; }
// @cmember Ritorna il campo <p n>-esimo
TEditable_field& field(short id) const;
public:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner) pure;
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner) pure;
virtual KEY run() pure;
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK) pure;
virtual bool is_browse() const { return false; }
virtual bool is_sheet() const { return false; }
virtual bool is_filesel() const { return false; }
virtual bool is_profile() const { return false; }
TBrowse_button(TEdit_field* f);
virtual ~TBrowse_button();
};
///////////////////////////////////////////////////////////
// TBrowse
///////////////////////////////////////////////////////////
// @class TList_sheet | Classe per la gestione dei list sheet
class TList_sheet : public TBrowse_button
// @author:(INTERNAL) Guido
{
// @access:(INTERNAL) Private Memeber
// @cmember:(INTERNAL) Numero di riga corrente dello sheet
int _row;
// @cmember:(INTERNAL) Titolo dello sheet
TString _caption;
// @cmember:(INTERNAL) Testate delle colonne dello sheet
TToken_string _head;
// @cmember:(INTERNAL) Righe dello sheet
TString_array _data;
// @cmember:(INTERNAL) Campi di input sulla maschera
TToken_string _inp_id;
// @cmember:(INTERNAL) Campi di output sulla maschera
TToken_string _out_id;
// @access Protected Member
protected:
// @cmember Ritorna il numero di riga selezionata
int do_input();
// @cmember Scrive l'output della ricerca sulla maschera
void do_output(CheckTime = RUNNING_CHECK);
// @cmember Controlla la sintassi della input del campo e ne setta i membri
void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
void parse_output(TScanner& scanner);
// @access Public Memeber
public:
// @cmember Legge dal file gli item dello sheet
void parse_item(TScanner& scanner);
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
// @cmember Esegue la ricerca. Torna il tasto che ha terminato la ricerca
virtual KEY run();
virtual bool is_sheet() const { return true; }
TString_array& rows_array() { return _data; }
// @cmember Costruttore
TList_sheet(TEdit_field* f, const char* caption, const char* head);
// @cmember Distruttore
virtual ~TList_sheet();
};
// @doc INTERNAL
// @class TBrowse | Classe per la definizione dei campi con ricerca
class TBrowse : public TBrowse_button
// @author:(INTERNAL) Guido
{
// @access:(INTERNAL) Private Member
// @cmember:(INTERNAL) Relazione della ricerca
TRelation* _relation;
// @cmember:(INTERNAL) Cursore sulla relazione
TCursor* _cursor;
// @cmember:(INTERNAL) Comando da eseguire alla pressione del tasto Gestione
TString _insert;
// @cmember:(INTERNAL) Filtro sul cursore
TString _filter;
// @cmember:(INTERNAL) Record selezionato
long _rec;
// @cmember:(INTERNAL) Indica se e' presente un campo secondario nella ricerca
bool _secondary;
// @cmember:(INTERNAL) Indica se sul campo e' gia' stato effettuato il check
bool _checked;
// @cmember:(INTERNAL) Chiave di ricerca alternativa (quando il testo del campo comincia con %)
TBrowse_button* _alt_browse;
// @cmember:(INTERNAL) Testate della maschera di ricerca
TToken_string _head;
// @cmember:(INTERNAL) Campi visualizzati dalla maschera di ricerca
TToken_string _items;
// @cmember:(INTERNAL) Campi di input sulla maschera
TToken_string _inp_id;
// @cmember:(INTERNAL) Campi di input sul file
TToken_string _inp_fn;
// @cmember:(INTERNAL) Campi di output sulla maschera
TToken_string _out_id;
// @cmember:(INTERNAL) Campi di output sul file
TToken_string _out_fn;
// @cmember:(INTERNAL) handler di filtro custom
CONTROL_HANDLER _custom_filter_handler;
// @access Protected Member
protected:
// @cmember Azzera i campi di output sulla maschera
void do_clear(CheckTime t);
// @cmember Chiama la maschera di gestione della ricerca
bool do_link(bool insert);
// @cmember Modifica il cursore
void custom_cursor();
// @cmember Crea lista identificatori di ricerca
TToken_string& create_siblings(TToken_string& siblings) const;
// @access Public Member
public:
// @cmember Modifica il display
void custom_display();
// @cmember Ritorna il numero di inputs senza contare quelli che funzionano
// solo da filtro
int input_fields();
// @cmember Ritorna la lista completa degli identificatori dei campi di input
const char* get_input_fields() const;
// @cmember Ritorna la lista completa dei nomi dei campi di input
const char* get_input_field_names() const;
// @cmember Aggiorna la lista completa degli identificatori dei campi di input
void set_input_fields(const char * inp_id) { _inp_id = inp_id;}
// @cmember Aggiorna la lista completa degli identificatori dei campi di input da un campo
void copy_input(const TBrowse * b);
// @cmember Aggiorna la lista completa dei nomi dei campi di input
void set_input_field_names(const char * inp_names) { _inp_fn = inp_names;}
// @cmember Aggiunge un campo di input alla posizione <pos>
void add_input_field(const char * id, const char * name, const int pos = - 1, bool select = false);
// @cmember Elimina un campo di display alla posizione <pos>
void remove_display_field(const int pos = -1);
// @cmember Aggiorna la lista completa degli identificatori dei campi di output
void set_display_fields(const char * hds, const char * names) { _head = hds; _items = names;}
int get_display_fields(TToken_string& hds, TToken_string& names) const { hds =_head; names = _items; return names.items(); }
// @cmember Aggiorna la display da un campo
void copy_display(const TBrowse * b);
// @cmember Aggiunge un campo di diplay alla posizione <pos>
void add_display_field(const char * hd, const char * name, const int pos = -1);
// @cmember Elimina un campo di input alla posizione <pos>
void remove_input_field(const int pos = -1);
// @cmember Ritorna la lista completa dei campi di output
const char* get_output_fields() const;
// @cmember Ritorna la lista completa dei nomi dei campi di output
const char* get_output_field_names() const;
// @cmember Aggiorna la lista completa degli identificatori dei campi di output
void set_output_fields(const char * out_id) { _out_id = out_id;}
// @cmember Aggiorna la lista completa dei nomi dei campi di input
void set_output_field_names(const char * out_names) { _out_fn = out_names;}
// @cmember Aggiorna la lista completa degli identificatori dei campi di output da un campo
void copy_output(const TBrowse * b);
// @cmember Aggiunge un campo di output alla posizione <pos>
void add_output_field(const char * id, const char * name, const int pos = -1);
// @cmember Elimina un campo di output alla posizione <pos>
void remove_output_field(const int pos = -1);
// @cmember Ritorna il numero di campi non vuoti e non filtrati
int do_input(bool filter = false);
// @cmember Scrive l'output della ricerca sulla maschera
void do_output(CheckTime = RUNNING_CHECK);
// @cmember Costruttore
TBrowse(TEdit_field* f, TRelation* r, int key = 1, const char* filter = "");
// @cmember Costruttore
TBrowse(TEdit_field* f, TCursor* c);
// @cmember Distruttore
~TBrowse();
// @cmember Controlla la sintassi della join del campo e ne setta i membri
void parse_join(TScanner& scanner);
// @cmember Controlla la sintassi della input del campo e ne setta i membri
void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della display del campo e ne setta i membri
void parse_display(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
void parse_output(TScanner& scanner);
// @cmember Controlla la sintassi della insert del campo e ne setta i membri
void parse_insert(TScanner& scanner);
// @cmember Controlla la sintassi della copy del campo e ne setta i membri
bool parse_copy(const TString& what, const TBrowse& b);
// @cmember Permette di settare il comando alla pressione del tasto Gestione
void set_insert(const char* s)
{ _insert = s;}
// @cmember Ritorna il valore di <p _insert>
const TString& get_insert() const
{ return _insert;}
// @cmember Ritorna il valore di <p _filter>
const TString& get_filter() const
{ return _filter;}
// @cmember Cambia il filtro della browse
void set_filter(const char * filter)
{ _filter = filter;}
// @cmember Cambia il cursore della browse
void set_cursor(TCursor * c);
// @cmember Cambia il filtro della browse
void set_custom_filter_handler(CONTROL_HANDLER custom_filter_handler) { _custom_filter_handler = custom_filter_handler;}
// @cmember Controlla la validita' del campo
bool check(CheckTime = RUNNING_CHECK);
// @cmember Controlla se il campo puo' essere vuoto
bool empty_check();
// @cmember Ritorna il valore di <p _head>
const TToken_string& head() const
{ return _head;}
// @cmember Ritorna il valore di <p _items>
const TToken_string& items() const
{ return _items;}
// @cmember Ritorna il valore di <p _cursor>
TCursor* cursor() const
{ return _cursor;}
// @cmember Ritorna il valore di <p _checked>
bool checked() const
{ return _checked;}
// @cmember Ritorna il valore di <p _secondary>
bool secondary() const
{ return _secondary;}
bool set_alt_browse(int altkey);
virtual bool is_browse() const { return true; }
// @cmember Esegue la ricerca. Torna il tasto che ha terminato la ricerca
virtual KEY run();
};
class TAlternative_browse : public TBrowse_button
{
int _altkey;
TString16 _altfld, _outfld;
TCursor* _cursor;
protected:
virtual void parse_input(TScanner& scanner) {}
virtual void parse_output(TScanner& scanner) {}
virtual bool check(CheckTime = RUNNING_CHECK);
public:
TCursor& cursor();
virtual KEY run();
TAlternative_browse(TEdit_field* ef, int altkey);
~TAlternative_browse();
};
class TFile_select : public TBrowse_button
{
TFilename _filter;
public:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner);
virtual KEY run();
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
virtual bool is_filesel() const { return true; }
TFile_select(TEdit_field* ef, const char* filter);
virtual ~TFile_select() { }
};
class TDir_select : public TBrowse_button
{
public:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner);
virtual KEY run();
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
virtual bool is_filesel() const { return TRUE; }
TDir_select(TEdit_field* ef);
virtual ~TDir_select() { }
};
class TReport_select : public TBrowse_button
{
TString _classe;
public:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner);
virtual KEY run();
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
virtual bool is_filesel() const { return true; }
TReport_select(TEdit_field* ef, const char* classe);
virtual ~TReport_select() { }
};
class TProfile_select : public TBrowse_button
{
protected:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner);
public:
virtual KEY run();
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
// @cmember E' un campo profilo
virtual bool is_profile() const { return true; }
// @cmember Estrae dal .ini tutti i profili
int get_descriptions(TString_array& a) const;
TProfile_select(TEdit_field* ef);
virtual ~TProfile_select() { }
};
#endif

229
include/currency.cpp
View File

@ -20,22 +20,20 @@ class TDowJones : public TFile_cache
int _dec_prices; // Decimali per i prezzi unitari
int _dec_change; // Decimali per i cambi
bool _is_euro; // E' l'EURO in persona
exchange_type _et; // Il cambio e' espresso contro EURO
public:
const TExchangeData& operator=(const TExchangeData& d)
{
_chg = d._chg; _dec = d._dec; _dec_prices = d._dec_prices;
_is_euro = d._is_euro; _et = d._et;
_is_euro = d._is_euro;
return d;
}
TExchangeData()
: _chg(UNO), _dec(0), _dec_prices(0), _is_euro(false), _et(_exchange_base) { }
: _chg(UNO), _dec(0), _dec_prices(0), _is_euro(false) { }
};
long _codditta;
TString4 _base_val, _firm_val, _euro_val;
real _euro_chg;
TString4 _firm_val, _euro_val;
protected:
virtual TObject* rec2obj(const TRectype& rec) const;
@ -44,24 +42,21 @@ protected:
const TExchangeData& get(const char* key);
public:
const TString& get_base_val();
const TString& get_firm_val();
const TString& get_euro_val();
void force_firm_val(const char* val);
const char* expand_value(const char* val);
const char* normalize_value(const char* val, const real& chg, exchange_type& et);
const char* normalize_value(const char* val, const real& chg);
real exchange(const real& num,
const char* fromval, const real& fromchg, exchange_type fromeuro,
const char* toval, const real& tochg, exchange_type toeuro,
const char* fromval, const real& fromchg,
const char* toval, const real& tochg,
int price = 0);
real exchange(const real& num, const TExchange& frval, const TExchange& toval, int price = 0);
int get_dec(const char* val, bool prices = FALSE);
const real& get_change(const char* val, exchange_type& contro_euro);
real get_base_change(const char* val);
real get_contro_change(const char* val);
const real& get_change(const char* val);
virtual void flush();
@ -92,7 +87,7 @@ TObject* TDowJones::rec2obj(const TRectype& rec) const
}
}
if (codval.not_empty())
if (codval.full())
{
data->_dec = rec.get_int("I0");
data->_dec_prices = rec.get_int("I1");
@ -100,7 +95,6 @@ TObject* TDowJones::rec2obj(const TRectype& rec) const
data->_dec_prices = data->_dec;
data->_dec_change = rec.get_int("I2");
data->_is_euro = rec.get_bool("B0");
data->_et = rec.get_bool("B1") ? _exchange_contro : _exchange_base;
}
return data;
@ -108,7 +102,6 @@ TObject* TDowJones::rec2obj(const TRectype& rec) const
void TDowJones::flush()
{
_base_val.cut(0);
_firm_val.cut(0);
_euro_val.cut(0);
kill_file();
@ -124,14 +117,12 @@ void TDowJones::test_cache()
_firm_val = prefix().firm().codice_valuta();
}
if (_base_val.empty())
if (_euro_val.empty())
{
fill();
FOR_EACH_ASSOC_OBJECT(_cache, hash, key, obj) if (*key)
{
const TExchangeData& data = *(const TExchangeData*)obj;
if ((_base_val.empty() || strcmp(key, "LIT") == 0) && data._chg == UNO)
_base_val = key;
if (data._is_euro && _euro_val.empty())
_euro_val = key;
}
@ -139,22 +130,13 @@ void TDowJones::test_cache()
if (_euro_val.empty()) // Si son dimenticati dell'EURO?
{
TExchangeData* euro = new TExchangeData;
euro->_chg = 1936.27; euro->_dec = euro->_dec_prices = 2;
euro->_is_euro = TRUE; euro->_et = _exchange_base;
euro->_chg = UNO; euro->_dec = euro->_dec_prices = 2;
euro->_is_euro = true;
_euro_val = "EUR";
_cache.add(_euro_val, euro);
}
if (_base_val.empty()) // Si son dimenticati delle LIRE?
{
TExchangeData* lira = new TExchangeData;
lira->_chg = UNO; lira->_dec = lira->_dec_prices = 0;
lira->_is_euro = FALSE; lira->_et = _exchange_base;
_base_val = "LIT";
_cache.add(_base_val, lira);
}
_firm_val = prefix().firm().codice_valuta();
_euro_chg = get_base_change(_euro_val);
}
}
@ -167,9 +149,7 @@ const char* TDowJones::expand_value(const char* val)
if (xvt_str_compare_ignoring_case(val, "_FIRM") == 0)
val = get_firm_val(); else
if (xvt_str_compare_ignoring_case(val, "_EURO") == 0)
val = get_euro_val(); else
if (xvt_str_compare_ignoring_case(val, "_BASE") == 0)
val = get_base_val();
val = get_euro_val();
}
else
{
@ -188,12 +168,6 @@ const TDowJones::TExchangeData& TDowJones::get(const char* val)
return (const TExchangeData&)query(expand_value(val));
}
const TString& TDowJones::get_base_val()
{
test_cache();
return _base_val;
}
const TString& TDowJones::get_firm_val()
{
test_cache();
@ -215,10 +189,8 @@ void TDowJones::force_firm_val(const char* val)
real TDowJones::exchange(const real& num, // Importo da convertire
const char* frval, // Dalla valuta
const real& frchg, // Dal cambio
exchange_type freur, // Dal cambio in euro
const char* toval, // Alla valuta
const real& tochg, // Al cambio
exchange_type toeur, // Al cambio in euro
int price) // e' un prezzo ?
{
real n = num;
@ -228,27 +200,12 @@ real TDowJones::exchange(const real& num, // Importo da convertire
const TExchangeData& datato = get(toval);
real fr = frchg;
if (fr <= ZERO) { fr = datafr._chg; freur = datafr._et; }
if (fr <= ZERO) fr = datafr._chg;
real to = tochg;
if (to <= ZERO) { to = datato._chg; toeur = datato._et; }
if (to <= ZERO) to = datato._chg;
const int mode = (freur == _exchange_contro ? 1 : 0) + (toeur == _exchange_contro ? 2 : 0);
switch (mode)
{
case 1:
n = (n * _euro_chg) / (fr * to); // Modo misto 1
break;
case 2:
n = n * (fr * to) / _euro_chg; // Modo misto 2
break;
case 3:
n = n * to / fr; // Nuovo modo
break;
default:
n = n * fr / to; // Vecchio modo
break;
}
n = n * to / fr; // Nuovo modo
if (price == 0 || price == 1) // Arrotonda solo in caso normale
n.round(price ? datato._dec_prices : datato._dec);
}
@ -260,10 +217,9 @@ real TDowJones::exchange(const real& num, // Importo da convertire
const TExchange& toval, // Alla valuta
int price) // e' un prezzo ?
{
exchange_type fret, toet;
const real& frch = frval.get_change(fret);
const real& toch = toval.get_change(toet);
return exchange(num, frval.get_value(), frch, fret, toval.get_value(), toch, toet, price);
const real& frch = frval.get_change();
const real& toch = toval.get_change();
return exchange(num, frval.get_value(), frch, toval.get_value(), toch, price);
}
int TDowJones::get_dec(const char* val, bool price)
@ -272,56 +228,15 @@ int TDowJones::get_dec(const char* val, bool price)
return price ? data._dec_prices : data._dec;
}
const real& TDowJones::get_change(const char* val, exchange_type& et)
const real& TDowJones::get_change(const char* val)
{
const TExchangeData& data = get(val);
et = data._et;
return data._chg;
}
real TDowJones::get_base_change(const char* val)
const char* TDowJones::normalize_value(const char* val, const real& /*exch*/)
{
exchange_type et;
real c = get_change(val, et);
if (et == _exchange_contro)
{
c = _euro_chg / c;
c.round(6);
}
return c;
}
real TDowJones::get_contro_change(const char* val)
{
exchange_type et;
real c = get_change(val, et);
if (et == _exchange_base)
{
c = _euro_chg / c;
c.round(6);
}
return c;
}
const char* TDowJones::normalize_value(const char* val, const real& exch, exchange_type& et)
{
val = expand_value(val);
if (et == _exchange_undefined)
{
if (exch > ZERO)
{
real base_diff = get_base_change(val) - exch;
base_diff = abs(base_diff);
real contro_diff = get_contro_change(val) - exch;
contro_diff = abs(contro_diff);
et = base_diff < contro_diff ? _exchange_base : _exchange_contro;
}
else
get_change(val, et);
}
return val;
return expand_value(val);
}
///////////////////////////////////////////////////////////
@ -332,60 +247,23 @@ void TExchange::copy(const TExchange& exc)
{
strcpy(_val, exc._val);
_exchange = exc._exchange;
_et = exc._et;
}
const real& TExchange::get_change(exchange_type& et) const
const real& TExchange::get_change() const
{
if (_exchange.is_zero())
return DowJones.get_change(_val, et);
et = _et;
return DowJones.get_change(_val);
return _exchange;
}
real TExchange::get_base_change() const
{
exchange_type et;
real c = get_change(et);
if (et != _exchange_base)
{
c = DowJones.get_base_change("_EURO") / c;
c.round(6);
}
return c;
}
real TExchange::get_contro_change() const
{
exchange_type et;
real c = get_change(et);
if (et != _exchange_contro)
{
c = DowJones.get_base_change("_EURO") / c;
c.round(6);
}
return c;
}
int TExchange::compare(const TSortable& obj) const
{
const TExchange& exc = (const TExchange&)obj;
int cmp = strcmp(_val, exc._val);
if (cmp == 0)
{
if (_et == exc._et)
{
exchange_type dummy;
const real diff = get_change(dummy) - exc.get_change(dummy);
cmp = diff.sign();
}
else
{
real chg1 = get_contro_change();
real chg2 = exc.get_contro_change();
const real diff = chg1 - chg2;
cmp = diff.sign();
}
const real diff = get_change() - exc.get_change();
cmp = diff.sign();
}
return cmp;
}
@ -410,28 +288,24 @@ int TExchange::decimals(bool price) const
return DowJones.get_dec(_val, price);
}
void TExchange::set(const char* val, const real& chg, exchange_type et)
void TExchange::set(const char* val, const real& chg)
{
val = DowJones.normalize_value(val, chg, et);
val = DowJones.normalize_value(val, chg);
strncpy(_val, val, 4);
_val[3] = '\0';
_exchange = chg;
_et = et;
}
void TExchange::set(const TRectype& rec)
{
const TString4 codval = rec.get("CODVAL");
const real chg = rec.get_real("CAMBIO");
exchange_type et = _exchange_undefined;
if (rec.exist("CONTROEURO"))
et = rec.get_bool("CONTROEURO") ? _exchange_contro : _exchange_base;
set(codval, chg, et);
set(codval, chg);
}
TExchange::TExchange(const char* val, const real& chg, exchange_type et)
TExchange::TExchange(const char* val, const real& chg)
{
set(val, chg, et);
set(val, chg);
}
TExchange::TExchange(const TRectype& rec)
@ -443,11 +317,6 @@ TExchange::TExchange(const TRectype& rec)
// TCurrency
///////////////////////////////////////////////////////////
const TString& TCurrency::get_base_val()
{
return DowJones.get_base_val();
}
const TString& TCurrency::get_firm_val()
{
return DowJones.get_firm_val();
@ -458,11 +327,6 @@ const TString& TCurrency::get_euro_val()
return DowJones.get_euro_val();
}
int TCurrency::get_base_dec(bool price)
{
return DowJones.get_dec(NULL, price);
}
int TCurrency::get_firm_dec(bool price)
{
return DowJones.get_dec(get_firm_val(), price);
@ -473,17 +337,7 @@ int TCurrency::get_euro_dec(bool price)
return DowJones.get_dec(get_euro_val(), price);
}
const real& TCurrency::get_firm_change(exchange_type& ce)
{
return DowJones.get_change("_FIRM", ce);
}
const real& TCurrency::get_euro_change()
{
exchange_type dummy;
return DowJones.get_change("_EURO", dummy);
}
void TCurrency::force_firm_val(const char* val)
{
DowJones.force_firm_val(val);
@ -494,9 +348,9 @@ void TCurrency::force_cache_update()
DowJones.flush();
}
void TCurrency::force_value(const char* newval, const real& newchange, exchange_type newet)
void TCurrency::force_value(const char* newval, const real& newchange)
{
_chg.set(newval, newchange, newet);
_chg.set(newval, newchange);
}
void TCurrency::change_value(const TExchange& exc)
@ -506,9 +360,9 @@ void TCurrency::change_value(const TExchange& exc)
_chg = exc;
}
void TCurrency::change_value(const char* val, const real& newchange, exchange_type to_euro)
void TCurrency::change_value(const char* val, const real& newchange)
{
const TExchange exc(val, newchange, to_euro);
const TExchange exc(val, newchange);
change_value(exc);
}
@ -616,20 +470,15 @@ TCurrency TCurrency::abs() const
return *this;
}
bool TCurrency::is_base_value() const
{
return get_base_val() == get_value();
}
bool TCurrency::is_firm_value() const
{
return _chg.is_firm_value();
}
TCurrency::TCurrency(const real& num, const char* val, const real& exchg, exchange_type et, bool price)
TCurrency::TCurrency(const real& num, const char* val, const real& exchg, bool price)
: _num(num), _price(price)
{
force_value(val, exchg, et);
force_value(val, exchg);
_num.round(decimals());
}
@ -651,9 +500,9 @@ bool same_values(const char * valuea, const char * valueb)
real change_currency(const real& num,
const char* fromval, const real& fromchg, exchange_type fromeuro,
const char* toval, const real& tochg, exchange_type toeuro,
const char* fromval, const real& fromchg,
const char* toval, const real& tochg,
int price)
{
return DowJones.exchange(num, fromval, fromchg, fromeuro, toval, tochg, toeuro, price);
return DowJones.exchange(num, fromval, fromchg, toval, tochg, price);
}

46
include/currency.h
View File

@ -14,13 +14,10 @@
class TRectype;
#endif
enum exchange_type { _exchange_base, _exchange_contro, _exchange_undefined };
class TExchange : public TSortable
{
char _val[4]; // Codice valuta
real _exchange; // Cambio personalizzato
exchange_type _et;// Cambio normale o contro euro
protected:
void copy(const TExchange& exc);
@ -32,20 +29,17 @@ public:
TExchange& operator=(const TExchange& exc) { copy(exc); return *this; }
TExchange& operator=(const TRectype& rec) { set(rec); return *this; }
void set(const char* val = NULL, const real& exc = ZERO, exchange_type et = _exchange_undefined);
void set(const char* val = NULL, const real& exc = ZERO);
void set(const TRectype& rec);
exchange_type get_type() const { return _et; }
bool is_firm_value() const;
bool is_euro_value() const;
const char* get_value() const { return _val; }
const real& get_change(exchange_type& et) const;
real get_base_change() const;
real get_contro_change() const;
const real& get_change() const;
int decimals(bool price = false) const;
TExchange(const char* val = NULL, const real& exc = ZERO, exchange_type et = _exchange_undefined);
TExchange(const char* val = NULL, const real& exc = ZERO);
TExchange(const TExchange& exc) { copy(exc); }
TExchange(const TRectype& rec);
virtual ~TExchange() { }
@ -63,14 +57,14 @@ protected:
TCurrency(bool price) : _price(price) { } // Internal use only
public:
static const TString& get_base_val();
//static const TString& get_base_val();
static const TString& get_firm_val();
static const TString& get_euro_val();
static int get_base_dec(bool price = false);
//static int get_base_dec(bool price = false);
static int get_firm_dec(bool price = false);
static int get_euro_dec(bool price = false);
static const real& get_firm_change(exchange_type& ce);
static const real& get_euro_change();
//static const real& get_firm_change(exchange_type& ce);
//static const real& get_euro_change();
// serve per la personalizzazione cgp4, per stampare il bilancio in euro
static void force_firm_val(const char* val);
@ -79,15 +73,15 @@ public:
void set_price(bool p) { _price = p; }
bool is_price() const { return _price; }
void force_value(const char* newval, const real& newchange = ZERO, exchange_type et = _exchange_undefined);
void force_value(const char* newval, const real& newchange = ZERO);
void change_value(const TExchange& exc);
void change_value(const char* newval, const real& newchange = ZERO, exchange_type et = _exchange_undefined);
void change_to_base_val() { change_value(get_base_val()); }
void change_value(const char* newval, const real& newchange = ZERO);
//void change_to_base_val() { change_value(get_base_val()); }
void change_to_firm_val() { change_value(get_firm_val()); }
void change_to_euro_val() { change_value(get_euro_val()); }
const char* get_value() const { return _chg.get_value(); }
bool is_base_value() const;
//bool is_base_value() const;
bool is_firm_value() const;
bool same_value_as(const TCurrency& cur) const { return _chg.same_value_as(cur._chg); }
@ -97,9 +91,10 @@ public:
void set_exchange(const TExchange& exc) { _chg = exc; }
const TExchange& get_exchange() const { return _chg; }
const real& get_change(exchange_type& et) const { return _chg.get_change(et); }
real get_base_change() const { return _chg.get_base_change(); }
real get_contro_change() const { return _chg.get_contro_change(); }
//const real& get_change(exchange_type& et) const { return _chg.get_change(et); }
//real get_base_change() const { return _chg.get_base_change(); }
//real get_contro_change() const { return _chg.get_contro_change(); }
const real& get_change() const { return _chg.get_change(); }
const TCurrency& operator=(const TCurrency& cur) { copy(cur); return *this; }
@ -123,7 +118,8 @@ public:
TCurrency() : _price(false) {}
TCurrency(const TCurrency& cur) { copy(cur); }
TCurrency(const real& num, const char* val = "", const real& exchg = ZERO, exchange_type et = _exchange_undefined, bool price = false);
//TCurrency(const real& num, const char* val = "", const real& exchg = ZERO, exchange_type et = _exchange_undefined, bool price = false);
TCurrency(const real& num, const char* val = "", const real& exchg = ZERO, bool price = false);
TCurrency(const real& num, const TExchange& chg, bool price = false);
virtual ~TCurrency() { }
};
@ -135,8 +131,8 @@ public:
TPrice() : TCurrency(true) { }
TPrice(const TPrice& price) { copy(price); }
TPrice(const real& num, const char* val = "", const real& exc = ZERO, exchange_type ext = _exchange_undefined)
: TCurrency(num, val, exc, ext, true) { }
TPrice(const real& num, const char* val = "", const real& exc = ZERO)
: TCurrency(num, val, exc) { set_price(true); }
virtual ~TPrice() { }
};
@ -147,8 +143,8 @@ bool same_values(const char * valuea, const char * valueb);
// Funzione di levello super-basso: usate solo se sapete bene cosa state facendo
real change_currency(const real& num,
const char* fromval, const real& fromchg, exchange_type fromeuro,
const char* toval, const real& tochg, exchange_type toeuro = _exchange_undefined,
const char* fromval, const real& fromchg,
const char* toval, const real& tochg,
int price_round = 0);
#endif

96
include/dongle.cpp
View File

@ -124,11 +124,11 @@ void TDongle::garble(word* data) const
case _dongle_eutron:
xvt_dongle_sl_crypt(data);
break;
case _dongle_aladdin:
// xvt_dongle_al_crypt(data);
break;
default:
case _dongle_ssa:
xvt_dongle_sa_crypt(data); // Reversible XOR encryption
break;
default:
break;
}
}
@ -303,9 +303,9 @@ bool TDongle::eutron_login(bool test_all_keys)
{
bool ok = false;
const char* labels[3] = { "AGA.INFORMATICA", "AGA.CAMPO", "25EBAI" };
TDongleType types[3] = { _aga_dongle, _user_dongle, _developer_dongle };
for (int k = test_all_keys ? 0 : 1; k < 3; k++)
const char* labels[2] = { "AGA.CAMPO", "25EBAI" };
TDongleType types[2] = { _user_dongle, _developer_dongle };
for (int k = test_all_keys ? 0 : 1; k < 2; k++)
{
const unsigned char* pwd = (const unsigned char*)::encode(labels[k]);
ok = xvt_dongle_sl_login((const unsigned char*)labels[k], pwd) != 0;
@ -365,13 +365,50 @@ bool TDongle::eutron_login(bool test_all_keys)
_module.set(0, true); // Forza l'attivazione della base
}
else
set_developer_permissions();
set_developer_permissions();
}
return ok;
}
bool TDongle::aladdin_login(bool test_all_dongles)
{ return false; }
bool TDongle::ssa_login(const char* mod)
{
if (mod && *mod)
{
return xvt_dongle_sa_login(mod) == 0;
}
_max_users = 1;
_last_update = TDate(TODAY);
_year_assist = _last_update.year();
_module.reset(); // Disattiva tutti i moduli
_module.set(0L); // Attiva la base
const int err = xvt_dongle_sa_login(NULL);
_serno = (err >= 0) ? err : 0xFFFF;
if (_serno != 0xFFFF)
{
_hardware =_dongle_ssa;
_type = _serno ? _user_dongle : _developer_dongle;
if (_serno)
{
Tdninst dn;
if (dn.find_serno())
_year_assist = dn.assist_year();
else
_year_assist = 2121;
for (word m = BAAUT; m < ENDAUT; m++)
{
const TString& name = module_code2name(m);
if (xvt_dongle_sa_test(name) == 0)
_module.set(m);
}
}
else
set_developer_permissions();
}
return _serno != 0xFFFF;
}
bool TDongle::network_login(bool test_all_keys)
{
@ -446,7 +483,7 @@ bool TDongle::login(bool test_all_keys)
case _dongle_hardlock: ok = hardlock_login(test_all_keys); break;
case _dongle_eutron : ok = eutron_login(test_all_keys); break;
case _dongle_network : ok = network_login(test_all_keys); break;
case _dongle_aladdin : ok = aladdin_login(test_all_keys); break;
case _dongle_ssa : ok = ssa_login(NULL); break;
default : ok = false; break;
}
if (!ok)
@ -459,8 +496,8 @@ bool TDongle::login(bool test_all_keys)
ok = eutron_login(test_all_keys);
if (!ok && hw != _dongle_hardlock)
ok = hardlock_login(test_all_keys);
if (!ok && hw != _dongle_aladdin)
ok = aladdin_login(test_all_keys);
if (!ok && hw != _dongle_ssa)
ok = ssa_login(NULL);
}
if (ok)
@ -469,7 +506,7 @@ bool TDongle::login(bool test_all_keys)
{ // DEMO
_hardware = _dongle_unknown;
_type = _no_dongle;
_serno = 0xFFFF; //numero di serie più alto possibile (65535 in exadecimals: non sarà mai raggiunto da chiavi clienti...magari!)
_serno = 0xFFFF; //numero di serie più alto possibile (65535 in esadecimale: non sarà mai raggiunto da chiavi clienti...magari!)
_max_users = 1;
_last_update = TDate(TODAY);
_year_assist = 3000; // anno di assistenza a 3000 per non avere problemi con le versioni nei vari anni
@ -482,6 +519,15 @@ bool TDongle::login(bool test_all_keys)
return ok;
}
bool TDongle::login(const char* module)
{
const word code = module_name2code(module);
bool ok = active(code);
if (ok && _hardware == _dongle_ssa)
ok = ssa_login(module);
return ok;
}
bool TDongle::logout()
{
switch (_hardware)
@ -495,8 +541,8 @@ bool TDongle::logout()
case _dongle_network:
rpc_UserLogout(main_app().name());
break;
case _dongle_aladdin:
// xvt_dongle_al_logout();
case _dongle_ssa:
xvt_dongle_sa_logout(NULL);
break;
default:
break;
@ -643,12 +689,11 @@ int TDongle::oem() const
if (campo.blank())
campo = "Campo Enterprise";
if (firm.blank())
firm = "AGA informatica s.r.l.";
firm = "Sirio Informatica e Sistemi s.p.a.";
if (breve.blank())
breve = "Campo";
if (oem < 0)
oem = firm.starts_with("AGA ") ? 0 : 1;
if (oem < 0) oem = 1;
}
return _OEM;
}
@ -798,11 +843,6 @@ bool TDongle::burn_eutron()
return ok;
}
bool TDongle::burn_aladdin()
{
return false;
}
bool TDongle::burn()
{
bool ok = local() && _type == _user_dongle;
@ -811,10 +851,9 @@ bool TDongle::burn()
{
switch(_hardware)
{
case _dongle_hardlock: ok = burn_hardlock(); break;
case _dongle_eutron : ok = burn_eutron(); break;
case _dongle_aladdin : ok = burn_aladdin(); break;
default : break;
case _dongle_hardlock: ok = burn_hardlock(); break;
case _dongle_eutron : ok = burn_eutron(); break;
default : ok = false; break;
}
}
@ -1258,7 +1297,6 @@ bool Tdninst::find_serno() const
{
if (em.year_assist() > 2100)
{
TToken_string l(80, '=');
good = em.find_serno(serno);
}
else

9
include/dongle.h
View File

@ -13,7 +13,7 @@
#include <strings.h>
#endif
enum TDongleHardware { _dongle_unknown, _dongle_hardlock, _dongle_eutron, _dongle_network, _dongle_aladdin };
enum TDongleHardware { _dongle_unknown, _dongle_hardlock, _dongle_eutron, _dongle_network, _dongle_ssa };
enum TDongleType { _no_dongle, _user_dongle, _developer_dongle, _aga_dongle };
class TDongle : public TObject
@ -39,11 +39,13 @@ protected:
bool hardlock_login(bool test_all_dongles);
bool eutron_login(bool test_all_dongles);
bool network_login(bool test_all_dongles);
bool aladdin_login(bool test_all_dongles);
bool ssa_login(const char* mod);
bool ssa_test_module(const char* mod);
bool ssa_logout();
bool burn_hardlock();
bool burn_eutron();
bool burn_aladdin();
int can_try_server() const;
const TString_array& info() const; // Array di coppie modulo|descrizione
@ -54,6 +56,7 @@ public: // TObject
public:
bool login(bool test_all_dongles = false);
bool login(const char* module);
bool logout();
word number() const { return _serno; }

8
include/form.cpp
View File

@ -1464,7 +1464,7 @@ TCurrency TForm_currency::get_currency() const
{
const char * codval = _driver ? _driver->get() : (const char *) form().get_curr_codval();
const real n(get());
return TCurrency(n, codval, ZERO, _exchange_undefined, _flag.price != 0);
return TCurrency(n, codval, ZERO, _flag.price != 0);
}
bool TForm_currency::update()
@ -1555,7 +1555,7 @@ bool TForm_currency::update()
int d = 0;
if (_driver)
{
const TCurrency z(ZERO, _driver->get(), ZERO, _exchange_base, _flag.price != 0);
const TCurrency z(ZERO, _driver->get(), ZERO, _flag.price != 0);
d = z.decimals();
}
else
@ -4743,11 +4743,11 @@ int TForm::matches_done(int file)
return 0;
}
void TForm::set_output_exchange(const char* codval, real exchange, exchange_type et)
void TForm::set_output_exchange(const char* codval, real exchange)
{
if (_exchange == NULL)
_exchange = new TExchange;
_exchange->set(codval, exchange, et);
_exchange->set(codval, exchange);
}
TForm::TForm()

2
include/form.h
View File

@ -336,7 +336,7 @@ public:
const bool magic_currency() const
{ return _magic_currency; }
void set_output_exchange(const char* codval, real exchange = ZERO, exchange_type et = _exchange_undefined);
void set_output_exchange(const char* codval, real exchange = ZERO);
const TExchange* output_exchange() const { return _exchange; }
void enable_message_add(bool on) { _msg_add_enabled = on; }

6
include/golem.cpp
View File

@ -972,11 +972,11 @@ bool TMail_message::send(TMAPI_session& lhSession, bool hide_ui)
int i;
for (i = 0; i < items(); i++)
tot += row(i).len();
char * buffer = new char[tot + 1];
char* buffer = new char[tot + 16];
long b = 0;
for (i = 0; i < items(); i++)
{
strcpy(&buffer[b], row(i));
strcpy_s(&buffer[b], tot-b+1, row(i));
b += row(i).len();
}
buffer[b] = '\0';
@ -1065,7 +1065,7 @@ void TMail_message::set_date_time(const char* str)
int anno, mese, giorno;
int ora = 12, minuto = 0, secondo = 0;
const int num = sscanf(str, "%d/%d/%d %d:%d:%d",
const int num = sscanf_s(str, "%d/%d/%d %d:%d:%d",
&anno, &mese, &giorno, &ora, &minuto, &secondo);
if (num >= 3)
{

1584
include/maskfld.cpp
View File

File diff suppressed because it is too large Load Diff

408
include/maskfld.h
View File

@ -11,7 +11,7 @@
#ifndef __SCANNER_H
#include <scanner.h>
#endif
#endif
#ifndef __WINDOW_H
#include <window.h>
@ -36,6 +36,14 @@ class TCurrency; // __CURRENCY_H
// @doc EXTERNAL
// @enum Momento di richiesta del check
enum CheckTime
{
RUNNING_CHECK, // @emem Check chiamato mentra la maschera sta andando
STARTING_CHECK, // @emem Check chiamato al caricamento della maschera
FINAL_CHECK // @emem Check chiamato quando la maschera si sta fermando
};
// @enum Tipo di check da eseguire su un controllo
enum CheckType {
CHECK_NONE, // @emem Nessun controllo
@ -46,11 +54,6 @@ enum CheckType {
// @doc EXTERNAL
// @enum Momento di richiesta del check
enum CheckTime {
RUNNING_CHECK, // @emem Check chiamato mentra la maschera sta andando
STARTING_CHECK, // @emem Check chiamato al caricamento della maschera
FINAL_CHECK }; // @emem Check chiamato quando la maschera si sta fermando
// @type CONTROL_HANDLER | Prototipo funzione per gestire i tasti speciali all'interno di un controllo
typedef bool (*CONTROL_HANDLER)(TMask_field& field, KEY key);
@ -264,21 +267,17 @@ public:
virtual bool has_query_button() const
{ return false;}
// @cmember Ritorna il campo corrispondente su record
virtual const TFieldref* field() const
{ return NULL; }
virtual const TFieldref* field() const { return NULL; }
// @cmember Imposta il tipo di checktype del campo
virtual void check_type(CheckType);
// @cmember Ritorna lo stato di checktype del campo
virtual CheckType check_type() const
{ return CHECK_NONE; }
virtual CheckType check_type() const { return CHECK_NONE; }
// @cmember Ritorna true se il checktype del campo e' <p CHECK_REQUIRED>
bool required() const
{ return check_type() == CHECK_REQUIRED; }
bool required() const { return check_type() == CHECK_REQUIRED; }
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK)
{ return true;}
virtual bool check(CheckTime = RUNNING_CHECK) { return true;}
// @cmember Azzera il contenuto del campo
virtual void reset();
@ -793,386 +792,13 @@ public:
virtual ~TCheckbutton_field() {}
};
///////////////////////////////////////////////////////////
// TBrowse_button
///////////////////////////////////////////////////////////
class TEdit_field;
class TBrowse_button : public TObject
{
TEdit_field* _fld;
protected:
// @cmember Ritorna il primo valore di <p _fld>
TEdit_field& field() const
{ return *_fld; }
// @cmember Ritorna il campo <p n>-esimo
TEditable_field& field(short id) const;
public:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner) pure;
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner) pure;
virtual KEY run() pure;
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK) pure;
virtual bool is_browse() const { return false; }
virtual bool is_sheet() const { return false; }
virtual bool is_filesel() const { return false; }
virtual bool is_profile() const { return false; }
TBrowse_button(TEdit_field* f);
virtual ~TBrowse_button();
};
///////////////////////////////////////////////////////////
// TBrowse
///////////////////////////////////////////////////////////
// @class TList_sheet | Classe per la gestione dei list sheet
class TList_sheet : public TBrowse_button
// @author:(INTERNAL) Guido
{
// @access:(INTERNAL) Private Memeber
// @cmember:(INTERNAL) Numero di riga corrente dello sheet
int _row;
// @cmember:(INTERNAL) Titolo dello sheet
TString _caption;
// @cmember:(INTERNAL) Testate delle colonne dello sheet
TToken_string _head;
// @cmember:(INTERNAL) Righe dello sheet
TString_array _data;
// @cmember:(INTERNAL) Campi di input sulla maschera
TToken_string _inp_id;
// @cmember:(INTERNAL) Campi di output sulla maschera
TToken_string _out_id;
// @access Protected Member
protected:
// @cmember Ritorna il numero di riga selezionata
int do_input();
// @cmember Scrive l'output della ricerca sulla maschera
void do_output(CheckTime = RUNNING_CHECK);
// @cmember Controlla la sintassi della input del campo e ne setta i membri
void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
void parse_output(TScanner& scanner);
// @access Public Memeber
public:
// @cmember Legge dal file gli item dello sheet
void parse_item(TScanner& scanner);
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
// @cmember Esegue la ricerca. Torna il tasto che ha terminato la ricerca
virtual KEY run();
virtual bool is_sheet() const { return true; }
TString_array& rows_array() { return _data; }
// @cmember Costruttore
TList_sheet(TEdit_field* f, const char* caption, const char* head);
// @cmember Distruttore
virtual ~TList_sheet();
};
// @doc INTERNAL
// @class TBrowse | Classe per la definizione dei campi con ricerca
class TBrowse : public TBrowse_button
// @author:(INTERNAL) Guido
{
// @access:(INTERNAL) Private Member
// @cmember:(INTERNAL) Relazione della ricerca
TRelation* _relation;
// @cmember:(INTERNAL) Cursore sulla relazione
TCursor* _cursor;
// @cmember:(INTERNAL) Comando da eseguire alla pressione del tasto Gestione
TString _insert;
// @cmember:(INTERNAL) Filtro sul cursore
TString _filter;
// @cmember:(INTERNAL) Record selezionato
long _rec;
// @cmember:(INTERNAL) Indica se e' presente un campo secondario nella ricerca
bool _secondary;
// @cmember:(INTERNAL) Indica se sul campo e' gia' stato effettuato il check
bool _checked;
// @cmember:(INTERNAL) Testate della maschera di ricerca
TToken_string _head;
// @cmember:(INTERNAL) Campi visualizzati dalla maschera di ricerca
TToken_string _items;
// @cmember:(INTERNAL) Campi di input sulla maschera
TToken_string _inp_id;
// @cmember:(INTERNAL) Campi di input sul file
TToken_string _inp_fn;
// @cmember:(INTERNAL) Campi di output sulla maschera
TToken_string _out_id;
// @cmember:(INTERNAL) Campi di output sul file
TToken_string _out_fn;
// @cmember:(INTERNAL) handler di filtro custom
CONTROL_HANDLER _custom_filter_handler;
// @access Protected Member
protected:
// @cmember Azzera i campi di output sulla maschera
void do_clear(CheckTime t);
// @cmember Chiama la maschera di gestione della ricerca
bool do_link(bool insert);
// @cmember Crea lista identificatori di ricerca
TToken_string& create_siblings(TToken_string& siblings);
// @cmember Modifica il cursore
void custom_cursor();
// @access Public Member
public:
// @cmember Modifica il display
void custom_display();
// @cmember Ritorna il numero di inputs senza contare quelli che funzionano
// solo da filtro
int input_fields();
// @cmember Ritorna la lista completa degli identificatori dei campi di input
const char* get_input_fields() const;
// @cmember Ritorna la lista completa dei nomi dei campi di input
const char* get_input_field_names() const;
// @cmember Aggiorna la lista completa degli identificatori dei campi di input
void set_input_fields(const char * inp_id) { _inp_id = inp_id;}
// @cmember Aggiorna la lista completa degli identificatori dei campi di input da un campo
void copy_input(const TBrowse * b);
// @cmember Aggiorna la lista completa dei nomi dei campi di input
void set_input_field_names(const char * inp_names) { _inp_fn = inp_names;}
// @cmember Aggiunge un campo di input alla posizione <pos>
void add_input_field(const char * id, const char * name, const int pos = - 1, bool select = false);
// @cmember Elimina un campo di display alla posizione <pos>
void remove_display_field(const int pos = -1);
// @cmember Aggiorna la lista completa degli identificatori dei campi di output
void set_display_fields(const char * hds, const char * names) { _head = hds; _items = names;}
// @cmember Aggiorna la il display da un campo
void copy_display(const TBrowse * b);
// @cmember Aggiunge un campo di diplay alla posizione <pos>
void add_display_field(const char * hd, const char * name, const int pos = -1);
// @cmember Elimina un campo di input alla posizione <pos>
void remove_input_field(const int pos = -1);
// @cmember Ritorna la lista completa dei campi di output
const char* get_output_fields() const;
// @cmember Ritorna la lista completa dei nomi dei campi di output
const char* get_output_field_names() const;
// @cmember Aggiorna la lista completa degli identificatori dei campi di output
void set_output_fields(const char * out_id) { _out_id = out_id;}
// @cmember Aggiorna la lista completa dei nomi dei campi di input
void set_output_field_names(const char * out_names) { _out_fn = out_names;}
// @cmember Aggiorna la lista completa degli identificatori dei campi di output da un campo
void copy_output(const TBrowse * b);
// @cmember Aggiunge un campo di output alla posizione <pos>
void add_output_field(const char * id, const char * name, const int pos = -1);
// @cmember Elimina un campo di output alla posizione <pos>
void remove_output_field(const int pos = -1);
// @cmember Ritorna il numero di campi non vuoti e non filtrati
int do_input(bool filter = false);
// @cmember Scrive l'output della ricerca sulla maschera
void do_output(CheckTime = RUNNING_CHECK);
// @cmember Costruttore
TBrowse(TEdit_field* f, TRelation* r, int key = 1, const char* filter = "");
// @cmember Costruttore
TBrowse(TEdit_field* f, TCursor* c);
// @cmember Distruttore
~TBrowse();
// @cmember Controlla la sintassi della join del campo e ne setta i membri
void parse_join(TScanner& scanner);
// @cmember Controlla la sintassi della input del campo e ne setta i membri
void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della display del campo e ne setta i membri
void parse_display(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
void parse_output(TScanner& scanner);
// @cmember Controlla la sintassi della insert del campo e ne setta i membri
void parse_insert(TScanner& scanner);
// @cmember Controlla la sintassi della copy del campo e ne setta i membri
bool parse_copy(const TString& what, const TBrowse& b);
// @cmember Permette di settare il comando alla pressione del tasto Gestione
void set_insert(const char* s)
{ _insert = s;}
// @cmember Ritorna il valore di <p _insert>
const TString& get_insert() const
{ return _insert;}
// @cmember Ritorna il valore di <p _filter>
const TString& get_filter() const
{ return _filter;}
// @cmember Cambia il filtro della browse
void set_filter(const char * filter)
{ _filter = filter;}
// @cmember Cambia il cursore della browse
void set_cursor(TCursor * c);
// @cmember Cambia il filtro della browse
void set_custom_filter_handler(CONTROL_HANDLER custom_filter_handler) { _custom_filter_handler = custom_filter_handler;}
// @cmember Controlla la validita' del campo
bool check(CheckTime = RUNNING_CHECK);
// @cmember Controlla se il campo puo' essere vuoto
bool empty_check();
// @cmember Ritorna il valore di <p _head>
const TToken_string& head() const
{ return _head;}
// @cmember Ritorna il valore di <p _items>
const TToken_string& items() const
{ return _items;}
// @cmember Ritorna il valore di <p _cursor>
TCursor* cursor() const
{ return _cursor;}
// @cmember Ritorna il valore di <p _checked>
bool checked() const
{ return _checked;}
// @cmember Ritorna il valore di <p _secondary>
bool secondary() const
{ return _secondary;}
virtual bool is_browse() const { return true; }
// @cmember Esegue la ricerca. Torna il tasto che ha terminato la ricerca
virtual KEY run();
};
class TFile_select : public TBrowse_button
{
TFilename _filter;
public:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner);
virtual KEY run();
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
virtual bool is_filesel() const { return true; }
TFile_select(TEdit_field* ef, const char* filter);
virtual ~TFile_select() { }
};
class TDir_select : public TBrowse_button
{
public:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner);
virtual KEY run();
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
virtual bool is_filesel() const { return TRUE; }
TDir_select(TEdit_field* ef);
virtual ~TDir_select() { }
};
class TReport_select : public TBrowse_button
{
TString _classe;
public:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner);
virtual KEY run();
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
virtual bool is_filesel() const { return true; }
TReport_select(TEdit_field* ef, const char* classe);
virtual ~TReport_select() { }
};
class TProfile_select : public TBrowse_button
{
protected:
// @cmember Controlla la sintassi della input del campo e ne setta i membri
virtual void parse_input(TScanner& scanner);
// @cmember Controlla la sintassi della output del campo e ne setta i membri
virtual void parse_output(TScanner& scanner);
public:
virtual KEY run();
// @cmember Controlla la validita' del campo
virtual bool check(CheckTime = RUNNING_CHECK);
// @cmember E' un campo profilo
virtual bool is_profile() const { return true; }
// @cmember Estrae dal .ini tutti i profili
int get_descriptions(TString_array& a) const;
TProfile_select(TEdit_field* ef);
virtual ~TProfile_select() { }
};
// @doc EXTERNAL
#ifndef __BRWBUT_H
#include <brwbut.h>
#endif
// @class TEdit_field | Classe per la definizione dei campi editabili
//
// @base public | TEditable_field

2
include/msksheet.cpp
View File

@ -1158,7 +1158,7 @@ bool TSpreadsheet::event_handler(XI_OBJ* itf, XI_EVENT *xiev)
const real r(src); // Memorizzo valore numerico
const int pos = driver->dlg() - FIRST_FIELD;
const TString4 codval = rowrec.get(pos); // Codice valuta
const TCurrency c(r, codval, ZERO, _exchange_undefined, e->uppercase());
const TCurrency c(r, codval, ZERO, e->uppercase());
src = c.string(true);
break;
}

2
include/sheet.cpp
View File

@ -1683,7 +1683,7 @@ bool TBrowse_sheet::browse_field_handler(TMask_field& f, KEY k)
TBrowse* b = e.browse();
if (b != NULL)
{
b->do_input(FALSE);
b->do_input(false);
rec = b->cursor()->read(_isgteq);
}
}

13
include/validate.cpp
View File

@ -1,7 +1,7 @@
#include <diction.h>
#include <expr.h>
#include <isam.h>
#include <mask.h>
#include <recarray.h>
#include <validate.h>
#include <defmask.h>
@ -17,9 +17,7 @@ HIDDEN int get_val_param_count()
HIDDEN const TString& get_val_param(int i)
{
const TString* str = (const TString*)_parms->objptr(i);
if (str && *str)
return *str;
return EMPTY_STRING;
return str ? *str : EMPTY_STRING;
}
HIDDEN int get_int_val_param(int i)
@ -524,7 +522,7 @@ HIDDEN bool _mtcheck_val(TMask_field& f, KEY)
const int month = atoi(f.get());
if (month < 1 || month > 13)
return false;
/*
TLocalisamfile d(LF_NDITTE);
d.put(NDT_CODDITTA, prefix().get_codditta());
if (d.read() != NOERR)
@ -532,6 +530,11 @@ HIDDEN bool _mtcheck_val(TMask_field& f, KEY)
if (d.get_char(NDT_FREQVIVA) == 'M')
return true;
return month == 13 || (month % 3) == 0;
*/
if (month == 13 || (month % 3) == 0)
return true;
const TRectype& ndt = cache().get(LF_NDITTE, prefix().get_codditta());
return ndt.get_char(NDT_FREQVIVA) == 'M';
}

23
include/viswin.cpp
View File

@ -547,7 +547,9 @@ void TViswin::shift_screen(scroll dir)
case down:
xvt_rect_set(&r, 0, taby(Y_OFFSET)/*+1*/,
tabx(int(_textcolumns) + X_OFFSET), taby(int(_textrows) + Y_OFFSET));
xvt_dwin_scroll_rect (win(), &r, 0, dir == down ? taby(1) : -taby(1));
paint_row (dir == up ? origin ().y + _textrows - 1 : origin ().y);
break;
case left:
@ -1554,18 +1556,6 @@ long TViswin::handler (WINDOW win, EVENT * ep)
break;
case E_MOUSE_MOVE:
{
/*
if (!_selecting && !_iscross) // no buttons pressed
{
p = ep->v.mouse.where;
if (in_text (p))
{
p.x += (origin ().x - 6);
p.y += (origin ().y - 1);
check_link (&p);
}
}
*/
if (_selecting || _iscross)
{
autoscroll(FALSE);
@ -1722,7 +1712,9 @@ long TViswin::handler (WINDOW win, EVENT * ep)
erase_selection ();
check_link ();
update_thumb (origin().x, origin().y - 1l);
_need_scroll = down;
//_need_scroll = down;
update (); // AAAARGH!
check_link (&_point);
}
else scroll_error(-1, 0);
}
@ -1785,7 +1777,10 @@ long TViswin::handler (WINDOW win, EVENT * ep)
check_link ();
update_thumb (origin ().x, origin ().y + 1l);
_point.y++;
_need_scroll = up;
// _need_scroll = up;
update (); // AAAARGH!
check_link (&_point);
}
else scroll_error(-1, _txt.lines()-_textrows/*-1*/);
}