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

Patch level :

Browse Source 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :


git-svn-id: svn://10.65.10.50/trunk@12979 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
brugno 2005-04-21 15:39:13 +00:00
parent 41c198ac1a
commit 074dd2d8ab
3 changed files with 246 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ci/ci0.cpp
View File

@ -10,7 +10,7 @@ int main(int argc, char** argv)
// ci0200(argc,argv); // stampa tabelle // ci0200(argc,argv); // stampa tabelle
break; break;
case 2: case 2:
ci0300(argc,argv); // parametri configurazione Contabilita' Industriale // ci0300(argc,argv); // parametri configurazione Contabilita' Industriale
break; break;
case 3: case 3:
ci0400(argc,argv); // Immssione documenti ci0400(argc,argv); // Immssione documenti

348
ci/ci0400.cpp
View File

@ -1,224 +1,226 @@
#include <applicat.h> #include <applicat.h>
#include <msksheet.h> #include <automask.h>
#include <execp.h>
#include <relation.h> #include <relation.h>
#include <sheet.h> #include <sheet.h>
#include <utility.h> #include <utility.h>
#include "ef0.h" #include <doc.h>
#include "ef0101.h"
#include "ef0400.h"
///////////////////////////////////////////////////////////////////////////// #include "ci0.h"
//Classe per l'eliminazione di effetti di effetti con selezione per gruppi // #include "cilib.h"
///////////////////////////////////////////////////////////////////////////// #include "ci0400.h"
class TEliminazione_effetti: public TSkeleton_application
///////////////////////////////////////////////////////////
// TImmissioneDocumenti_app
///////////////////////////////////////////////////////////
// Overrides
bool TImmissioneDocumenti_app::create()
{ {
TMask *_msk; _mask = new TImmissioneDocumenti_mask();
TRelation *_rel;
TRectype *_from, *_to;
virtual bool create() ;
virtual bool destroy() ;
virtual void main_loop();
protected:
static bool from_numero_handler(TMask_field& f, KEY k);
static bool to_numero_handler(TMask_field& f, KEY k);
static bool from_data_handler(TMask_field& f, KEY k);
static bool to_data_handler(TMask_field& f, KEY k);
static bool conferma_handler(TMask_field& f, KEY k);
static bool annulla_handler(TMask_field& f, KEY k);
static void elimina();
public:
TEliminazione_effetti() {};
virtual ~TEliminazione_effetti() {};
};
// restituisce un riferimento all' applicazione init_tabs();
inline TEliminazione_effetti& app(){return (TEliminazione_effetti&)main_app();} init_flags();
// crea l'applicazione
bool TEliminazione_effetti::create()
{
_msk = new TMask("ef0400a");
_rel = new TRelation(LF_EFFETTI);
_rel->first();
_from = new TRectype(_rel->lfile().curr());
_rel->last();
_to = new TRectype(_rel->lfile().curr());
_msk->set_handler(F_DA_RIBA, from_numero_handler);
_msk->set_handler(F_A_RIBA, to_numero_handler);
_msk->set_handler(F_DA_DATA, from_data_handler);
_msk->set_handler(F_A_DATA, to_data_handler);
_msk->set_handler(DLG_OK, conferma_handler);
_msk->set_handler(DLG_CANCEL, annulla_handler);
return TSkeleton_application::create(); return TSkeleton_application::create();
} }
// distrugge l'applicazione bool TImmissioneDocumenti_app::destroy()
bool TEliminazione_effetti::destroy()
{ {
delete _msk; delete _mask;
delete _rel;
delete _from; return TSkeleton_application::destroy();
delete _to;
return TRUE;
} }
//Carica maschera eliminazione effetti void TImmissioneDocumenti_app::main_loop()
void TEliminazione_effetti::main_loop()
{ {
KEY key = K_ENTER; while (_mask->run() == K_ENTER)
while (key != K_QUIT)//finchè non si chiude la maschera
{ {
_msk->reset(); _mask->open_inner_sheet(_mask->selected_day(),_filters.row(_mask->curr_page()));
key = _msk->run();
} }
} }
//Handler per la gestione della prima chiave (from) del cursore per numero // Chiamate dalla maschera
bool TEliminazione_effetti::from_numero_handler(TMask_field& f, KEY k)
void TImmissioneDocumenti_app::change_year(int newyear)
{ {
TMask &m = f.mask(); _year = newyear;
if (k == K_TAB) _newyearsday.set_year(_year);
{
if (!f.get().empty())// se il campo non è vuoto init_flags();
{
TRectype* from = app()._from;
long num = m.get_long(F_DA_RIBA);
from->put(EFF_NPROGTR, num);
}
}
return TRUE;
} }
//Handler per la gestione della seconda chiave (to) del cursore per numero bool TImmissioneDocumenti_app::has_documents(TDate& day)
bool TEliminazione_effetti::to_numero_handler(TMask_field& f, KEY k)
{ {
TMask &m = f.mask(); return ((_flags)[day-_newyearsday]);
if (k == K_TAB)
{
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* to = app()._to;
long num = m.get_long(F_A_RIBA);
to->put(EFF_NPROGTR, num);
}
}
return TRUE;
} }
//Handler per la gestione della prima chiave (from) del cursore per data // Inizializzazioni
bool TEliminazione_effetti::from_data_handler(TMask_field& f, KEY k)
void TImmissioneDocumenti_app::init_tabs()
{ {
TMask &m = f.mask(); TString almanacname;
if (k == K_TAB) TString pagename;
TString currfilter;
int items;
_tabs.destroy();
_filters.destroy();
TConfig configfile("ci0300.ini");
configfile.list_paragraphs(_tabs);
items = _tabs.items();
for (int i=0;i<items;i++)
{ {
if (!f.get().empty())// se il campo non è vuoto pagename.format("Pagina %2d",i);
{ currfilter = configfile.get("Filtro",_tabs.row(i));
TRectype* from = app()._from; TMask_field* currpage = _mask->find_by_fieldname(pagename);
TDate data = m.get(F_DA_DATA); currpage->set_prompt(_tabs.row(i));
long num = m.get_long(F_DA_RIBA); _filters.add(currfilter);
from->put(EFF_NPROGTR, num); almanacname.format("Almanacco %2d",i);
from->put(EFF_DATASCAD, data); _mask->activate_almanac((TAlmanac_field*)_mask->find_by_fieldname(almanacname), i, TDate(TODAY));
} }
}
return TRUE;
} }
//Handler per la gestione della seconda chiave (to) del cursore per numero void TImmissioneDocumenti_app::init_flags()
bool TEliminazione_effetti::to_data_handler(TMask_field& f, KEY k)
{ {
TMask &m = f.mask(); int items;
if (k == K_TAB) TDate currdate;
{ TDate currstart;
if (!f.get().empty())// se il campo non è vuoto
{
TRectype* to = app()._to;
TDate data = m.get(F_A_DATA);
long num = m.get_long(F_A_RIBA);
to->put(EFF_NPROGTR, num);
to->put(EFF_DATASCAD, data);
}
}
return TRUE;
}
// Si effettua l'istanziazione del cursore e si eliminano gli effetti che vi
// appartengono
void TEliminazione_effetti::elimina()
{
const TRectype *from = app()._from;
const TRectype *to = app()._to;
TMask *m = app()._msk;
TRelation *rel = app()._rel;
TString filter; TString filter;
int key; filter << "ANNO==\"" << _year << "\"";
char op1 = m->get(F_TIPOSEL)[0];
char op2 = m->get(F_TIPODIST)[0]; TRelation relation(LF_DOC);
char op3 = m->get(F_TIPOCANC)[0];
switch (op1) //scelgo la chiave per il cursore TSorted_cursor cursor(&relation, "ANNO", filter);
items =cursor.items();
for (cursor=0;cursor.pos()<items;++cursor)
{ {
case 'N': //selezione effetti per numero currdate = relation.lfile().get_date(DOC_DATADOC);
key = 1; _flags.set(currdate-_newyearsday, 1);
break;
case 'D': //selezione effetti per data
key = 3;
break;
}
//scelgo il filtro per il cursore
filter << "(TIPOCF=\"" << op2 << "\")";
if (op2 == 'C')
filter << "||(TIPOCF=\"\")";
switch (op3)
{
case 'S': //cancello effetti stampati
filter << "&&(EFFSTAMP=\"X\")";
break;
case 'C': //cancello effetti contabilizzati
filter << "&&(EFFCONT=\"X\")";
break;
default : //cancello tutti gli effetti
break;
}
TCursor cur(rel,filter,key,from,to); // istanzio il cursore
TLocalisamfile& delfile = cur.file();// prendo un riferimento al file
long n = cur.items();// prendo il numero di elementi del cursore
cur.freeze();// congelo lo stato del cursore
for (cur=0; cur.pos() < n; ++cur)// scandisco tutti gli elementi del cursore
{
TEffetto eff(delfile.curr());// istanzio un effetto
eff.remove(delfile); // e lo cancello
} }
} }
//Handler per gestire la conferma della cancellazione degli effetti ///////////////////////////////////////////////////////////
bool TEliminazione_effetti::conferma_handler(TMask_field& f, KEY k) // TImmissioneDocumenti_mask
///////////////////////////////////////////////////////////
// Routines Proprietarie
void TImmissioneDocumenti_mask::open_inner_sheet(TDate date, TString doctype)
{ {
TMask &m = f.mask(); int exitval;
if (k == K_SPACE)
TString filter;
filter << "(ANSI(DATADOC)==\"" << date.string(ANSI) << "\")";
filter << "&&";
filter << "(CODNUM==\"" << doctype << "\")";
TRelation relation(LF_DOC);
relation.add(LF_CLIFO, "TIPOCF==TIPOCF|CODCF==CODCF");
TCursor cursor(&relation, filter);
TCursor_sheet sheet(&cursor,
"ANNO|CODNUM|TIPODOC|NUMDOCRIF|STATO|DATADOCRIF|NDOC|20->RAGSOC",
TR("Selezione documenti"),
HR("Anno|Num.|Tipo|Docum.Rif.|Stato|Data@10|Documento|Ragione Sociale@50"),
0x10||0x02||0x04);
exitval = sheet.run();
switch(exitval)
{ {
if (yesno_box(TR("Si desidera veramente eliminare gli effetti selezionati"))) case K_ENTER:
elimina(); case K_DEL:
case K_INS:
call_ve0(exitval, relation, date, doctype);
break;
case K_ESC:
break;
default:
break;
} }
return TRUE;
} }
// Handler per gestire la conferma dell'annullamento dei dati void TImmissioneDocumenti_mask::call_ve0(int exitval, TRelation& relation, TDate& date, TString& doctype)
// inseriti nella maschera
bool TEliminazione_effetti::annulla_handler(TMask_field& f, KEY k)
{ {
TMask &m = f.mask(); TFilename tempfile;
if (k == K_SPACE) tempfile.tempdir();
tempfile.add("cicallsve0.ini");
{ {
if (yesno_box(TR("Si desidera veramente annullare i dati inseriti"))) TConfig configfile(tempfile);
m.reset();
switch(exitval)
{
case K_ENTER:
configfile.set("Action", "Modify", "main");
configfile.set("CODNUM", doctype, "33");
configfile.set("NDOC", relation.lfile().get(DOC_NDOC), "33");
break;
case K_DEL:
configfile.set("Action", "Delete", "main");
configfile.set("CODNUM", doctype, "33");
configfile.set("NDOC", relation.lfile().get(DOC_NDOC), "33");
break;
case K_INS:
configfile.set("Action", "Insert", "main");
configfile.set("NDOC", date.string(), "33");
break;
default:
break;
} }
return TRUE;
configfile.set("PROVV", "D", "33");
configfile.set("ANNO", curr_almanac()->selected_year(), "33");
configfile.set("CODNUM", doctype, "33");
}
TString commandline;
commandline.format("ve0 -0 /i%s",tempfile);
TExternal_app ve(commandline);
ve.run();
remove_file(tempfile);
} }
int ef0400(int argc, char* argv[]) // Richiami all'applicazione
void TImmissioneDocumenti_mask::change_year(int newyear)
{ {
TEliminazione_effetti a ; immissione_documenti_app().change_year(newyear);
a.run(argc, argv, TR("Eliminazione Effetti")); }
bool TImmissioneDocumenti_mask::is_date_void(TDate& cdate)
{
return !(immissione_documenti_app().has_documents(cdate));
}
///////////////////////////////////////////////////////////
// Mains
///////////////////////////////////////////////////////////
int ci0300(int argc, char* argv[])
{
TImmissioneDocumenti_app a ;
a.run(argc, argv, TR("Immissione Documenti"));
return 0;
}
int ci0400(int argc, char* argv[])
{
TImmissioneDocumenti_app a ;
a.run(argc, argv, TR("Immissione Documenti"));
return 0; return 0;
} }

79
ci/ci0400.h
View File

@ -1,15 +1,70 @@
#ifndef __EF0400_H #ifndef __CI0400_H
#define __EF0400_H #define __CI0400_H
// DEFINIZIONE CAMPI MASCHERA PER LA ELIMINAZIONE DEGLI EFFETTI ///////////////////////////////////////////////////////////
// campi maschera ef0400a // TImmissioneDocumenti_mask
///////////////////////////////////////////////////////////
#define F_TIPOSEL 101 class TImmissioneDocumenti_mask : public TAlmanac_mask
#define F_TIPOCANC 102 {
#define F_DA_RIBA 103 protected:
#define F_A_RIBA 104 // ereditato da TMask
#define F_DA_DATA 105 virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly) { return TRUE; }
#define F_A_DATA 106
#define F_TIPODIST 107
#endif// __EF0400_H public:
// ereditato da TAlmanac_mask
virtual bool is_date_void(TDate& cdate);
virtual void change_year(int newyear);
public:
// apertura del foglio interno di gestione dei documenti
void open_inner_sheet(TDate date, TString doctype);
private:
// chiamata del programma ve0
void call_ve0(int exitval, TRelation& relation, TDate& date, TString& doctype);
public:
// Costruttore
TImmissioneDocumenti_mask() : TAlmanac_mask() { }
// Distruttore
~TImmissioneDocumenti_mask() { }
};
///////////////////////////////////////////////////////////
// TImmissioneDocumenti_app
///////////////////////////////////////////////////////////
class TImmissioneDocumenti_app: public TSkeleton_application
{
private:
TImmissioneDocumenti_mask* _mask;
TString_array _tabs; // titoli dei tabs
TString_array _filters; // filtri tipodoc per ogni tab
TBit_array _flags; // flag di presenza dei documenti
TDate _newyearsday; // capodanno dell'anno corrente, per uso interno
int _year; // anno corrente
private:
void init_tabs();
void init_flags();
protected:
virtual bool create(void);
virtual void main_loop();
virtual bool destroy(void) ;
public:
bool has_documents(TDate& day); // passata come funzione alla maschera
void change_year(int newyear); // passata come funzione alla maschera
public:
TImmissioneDocumenti_app() : _flags(366), _year(TDate(TODAY).year()), _newyearsday(1,1,_year) {}
virtual ~TImmissioneDocumenti_app() {}
};
inline TImmissioneDocumenti_app& immissione_documenti_app() { return (TImmissioneDocumenti_app&)main_app(); }
#endif // __CI0400_H