root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cg/cg1100.cpp
guy d2a3f37668 Patch level : 2.0 230 
Files correlati     : cg0.exe cg1.exe
Ricompilazione Demo : [ ]
Commento            :

EP20027
Amministrazione\Contabilità generale\Scelta contabilità\tabelle ditta\Causali clicco sul bottone ricerca e seleziono la causale A06 Ftt acquisti. Col mouse mi posiziono sul campo"Cod. Registro"ed entro nella tabella registri associata al campo seleziono la riga del registo acquisti e clicco sul bottone collega: ritorno nella maschera delleTabelle causali

EP20028
Amministrazione\Contabilità generale\Scelta contabilità\tabelle ditta\Clienti Fornitori: richiamo un cliente già registrato vado a pagina 3 col mouse mi sposto sul campo CAB entro nella tabella banche associata al campo seleziono una banca presente clicco sul bottone collega: ritorno nella maschera dell'anagrafica clienti fornitori

EP20029
Lavorando col mouse:Entro in Amministrazione\Contabilità generale\Scelta contabilità\tabelle ditta\Clienti Fornitori clicco sul bottone posta si apre la finestra di outlook e la chiudo. Campo si riduce a icona.Ingrandisco la finestra di campo e Clicco sul bottone oggetti esterni, viene visualizzato errore fatale: impossibile leggere il file 'bagn006.msk' clicco su ok e viene visualizzato errore di Microsoft VisulaC++ Run Time Library Runtime Error! ProgramC:\……\cg0.exe abnormal program termination

EP20030
Amministrazione\Contabilità generale\Scelta contabilità\tabelle ditta\Clienti Fornitori: richiamo un cliente già registrato vado a pagina 4 col mouse clicco sul + del box "Periodo di non accettazione effetti" e viene inserita una nuova riga. Mi posiziono sulla riga appena inserita e cerco di eliminarla col comando da tastiera Alt -.Non funziona

EP20035
Amministrazione\Contabilità generale\Scelta contabilità\Stampa tabelle ditta\Piano dei conti: spunto la voce "conti riclassificati per IV direttiva cee"( oppure conti riclassificati per analisi di bilancio oppure conti non collegati per analisi di bilancio) clicco su conferma errore dell'applicazione cg1.


git-svn-id: svn://10.65.10.50/trunk@10938 c028cbd2-c16b-5b4b-a496-9718f37d4682
2003-03-20 11:48:01 +00:00

1434 lines
38 KiB
C++
Executable File
Raw Blame History

// cg1100.cpp
// Stampa piano dei conti
#include <execp.h>
#include <mailbox.h>
#include <mask.h>
#include <printapp.h>
#include <sort.h>
#include <tabutil.h>
#include <utility.h>
#include <progind.h>
#include <nditte.h>
#include <pconti.h>
#include "cg1.h"
#include "cg1100.h"
const char * TAB_ANABIL = "%IVD";
const char * TAB_IVD = "%IVD";
const int CODTABLEN = 15;
enum stampe {
completa=1,
con_IV_direttiva,
senza_IV_direttiva,
completa_bil,
con_ana_bil,
senza_ana_bil
};
/* modifica inutile per provare cvs remoto */
class CG1100_application : public TPrintapp
{
struct bil_ivd
{
char sez;
char let;
char numr[5];
char num[4];
char gruppo[4];
char conto[4];
char sottoc[8];
char descr[52];
char sez_opp;
char let_opp;
char numr_opp[5];
int num_opp;
};
bil_ivd* _bil;
TTable* _tab; // tabella codici IV direttiva
TIsamtempfile* _tpcon;
TLocalisamfile* _pcon;
TRectype* _rec;
TSort* _sort;
TRelation* _rel, *_relt;
TMask* _msk;
TParagraph_string _d1, _d2; // qui
const char* _buf;
stampe _tipo_stampa;
bool _salto_pag,_resetta_righe_stampa;
int _old_gruppo;
int _pcont_reclen,_i;
int _cur_c1, _cur_c2, _cur_c3;
TString _clivd, _clivdo;
char _sez_da_stamp,_sez_stamp,_let_da_stamp,_let_stamp;
TString _numr_da_stamp,_numr_stamp;
int _gruppo,_conto,_num_da_stamp,_num_stamp,_g_prec,_c_prec;
long _sottoc,_s_prec;
TString _classe_da_stampare,_classe_stampata,_codcbl_da_stamp,_codcbl_stamp;
bool _conto_classificato,_stampa_riga_vuota;
int _sottoc_classificato;
bool _prima_volta, _stampa_g, _stampa_c;
TDate _data_stampa;
TString tmp; // Stringa per porcate galattiche
public:
virtual bool user_destroy() ;
virtual bool user_create() ;
virtual void set_page (int,int);
virtual bool preprocess_print (int,int);
virtual bool preprocess_page (int,int);
virtual print_action postprocess_page (int,int);
virtual void postclose_print ();
virtual bool set_print(int);
void intesta (stampe);
bool elabora_riga(); // decide se fare salto pagina o no
void do_sort();
void set_completa ();
void set_con_IV ();
void set_senza_IV_ana ();
void set_con_ana ();
// void set_senza_ana ();
void prepara_pcon_temp();
void cancella(int,int,long);
void init_sort();
const char* descrizione_numero(char, char, int, int);
const char* descrizione_codcbl(TString&);
// void setta_righe_descr(TParagraph_string*);
int leggo_sottoc(int,int,long);
void riempi_record(char,char,const TString&,int,int,int,long,const TString&,char,char,const TString&,int);
void set_bil_key(bil_ivd* b, char sezione, char lettera,
const char* numero_romano, int numero,
int gruppo = 0, int conto = 0, long sottoconto = 0L);
void set_bil_val(bil_ivd* b, const char* descr,char sez_opp,char let_opp,
const char* numr_opp,int num_opp);
void process_link(int id, const char* txt);
CG1100_application() : _clivd(8), _clivdo(8), _d1("", 30), _d2("", 40) {}
};
void CG1100_application::process_link(int id, const char* txt)
{
TString ss = "1|"; ss << txt;
TMessage fs(cmd2name("cg0","-0"), MSG_LN, ss);
TMailbox m;
m.send(fs);
TExternal_app cg0("cg0 -0");
if (cg0.run()) beep();
}
void CG1100_application::init_sort()
{
switch (_tipo_stampa)
{
case con_IV_direttiva:
_sort->reset(sizeof(bil_ivd));
_sort -> addsortkey ((char*)&(_bil->sez) - (char*)&(_bil->sez),1);
_sort -> addsortkey ((char*)&(_bil->let) - (char*)&(_bil->sez),1);
_sort -> addsortkey ((char*)&(_bil->numr) - (char*)&(_bil->sez),4);
_sort -> addsortkey ((char*)&(_bil->num) - (char*)&(_bil->sez),2);
_sort -> addsortkey ((char*)&(_bil->gruppo) - (char*)&(_bil->sez),3);
_sort -> addsortkey ((char*)&(_bil->conto) - (char*)&(_bil->sez),3);
_sort -> addsortkey ((char*)&(_bil->sottoc) - (char*)&(_bil->sez),6);
break;
case con_ana_bil:
{
TRecfield codcbl (*_rec, PCN_CODCBL);
TRecfield gruppo (*_rec, PCN_GRUPPO);
TRecfield conto (*_rec, PCN_CONTO);
TRecfield sottoc (*_rec, PCN_SOTTOCONTO);
_sort->reset(_rec->len());
_sort->addsortkey (codcbl);
_sort->addsortkey (gruppo);
_sort->addsortkey (conto);
_sort->addsortkey (sottoc);
break;
}
default:
break;
}
}
void CG1100_application::set_bil_key(bil_ivd* b, char sezione, char lettera,
const char* numero_romano, int numero,
int gruppo, int conto,long sottoconto)
{
b->sez = sezione;
b->let = lettera;
strcpy(b->numr, numero_romano);
sprintf(b->num , "%2d", numero);
sprintf(b->gruppo , "%3d", gruppo);
sprintf(b->conto , "%3d", conto);
sprintf(b->sottoc , "%6ld", sottoconto);
}
void CG1100_application::set_bil_val(bil_ivd* b, const char* descr,
char sez_opp,char let_opp,
const char* numr_opp,int num_opp)
{
strcpy(b->descr, descr);
b->sez_opp = sez_opp;
b->let_opp = let_opp;
strcpy(b->numr_opp, numr_opp);
b->num_opp = num_opp;
}
void CG1100_application::riempi_record(char sez,char let,const TString& numr,
int numero,int g,int c,long s,
const TString& descr,char sez_opp,
char let_opp,const TString& numr_opp,
int num_opp)
{
set_bil_key(_bil, sez, let, numr, numero, g, c, s);
set_bil_val(_bil, descr, sez_opp, let_opp, numr_opp, num_opp);
_sort->sort ((const char*) _bil);
}
void CG1100_application::postclose_print()
{
if (_tipo_stampa == senza_ana_bil)
{
delete _relt;
}
}
print_action CG1100_application::postprocess_page(int file,int counter)
{
switch (_tipo_stampa)
{
case completa:
case senza_IV_direttiva:
case completa_bil:
case senza_ana_bil:
break;
case con_IV_direttiva:
{
struct bil_ivd* bil = (struct bil_ivd*) _buf;
_sez_stamp = _sez_da_stamp;
_let_stamp = _let_da_stamp;
_numr_stamp = _numr_da_stamp;
_num_stamp = _num_da_stamp;
_classe_stampata.format("%c%c%s%2d",_sez_stamp,_let_stamp,(const char*)_numr_stamp,_num_stamp);
if ( (_buf = _sort->retrieve()) != NULL)
{
bil = (struct bil_ivd*) _buf;
_sez_da_stamp = bil->sez;
_let_da_stamp = bil->let;
_numr_da_stamp = bil->numr;
_numr_da_stamp.ltrim();
_num_da_stamp = atoi(bil->num);
_gruppo = atoi(bil->gruppo);
_conto = atoi(bil->conto);
_sottoc = atol(bil->sottoc);
_classe_da_stampare.format("%c%c%s%2d",_sez_da_stamp,_let_da_stamp,(const char*)_numr_da_stamp,_num_da_stamp);
//set_auto_ff(FALSE);
return REPEAT_PAGE;
}
}
break;
case con_ana_bil:
{
TRectype rec (LF_PCON);
_codcbl_stamp = _codcbl_da_stamp;
if ( (_buf = _sort->retrieve()) != NULL)
{
rec = _buf;
_codcbl_da_stamp = rec.get(PCN_CODCBL);
_gruppo = rec.get_int(PCN_GRUPPO);
_conto = rec.get_int(PCN_CONTO);
_sottoc = rec.get_long(PCN_SOTTOCONTO);
return REPEAT_PAGE;
}
break;
}
default:
break;
}
return NEXT_PAGE;
}
void CG1100_application::set_page(int file,int counter)
{
//intesta (_tipo_stampa);
switch (_tipo_stampa)
{
case con_IV_direttiva:
{
reset_print();
_i = 1;
if (_sez_da_stamp != _sez_stamp)
set_con_IV ();
else
if (_buf != NULL)
set_con_IV();
}
break;
case con_ana_bil:
{
reset_print();
_i = 1;
if (_codcbl_da_stamp != _codcbl_stamp)
set_con_ana ();
else
if (_buf != NULL)
set_con_ana();
}
break;
case senza_IV_direttiva:
set_senza_IV_ana();
break;
case senza_ana_bil:
set_senza_IV_ana();
break;
default:
break;
}
}
//////////////////////////////////////////////////////////////
// Crea sort se necessario e seleziona il cursore opportuno
//////////////////////////////////////////////////////////////
void CG1100_application::do_sort()
{
if (_tipo_stampa == con_IV_direttiva)
{
char sez_conto,let_conto;
TString numr_conto;
int num_conto;
bool classe_conto = FALSE;
_sort->init();
select_cursor (_cur_c1);
TCursor * cursor = current_cursor();
TRectype & rec = cursor->curr();
long last = cursor->items();
TProgind prg (last, TR("Elaborazione Piano dei Conti... Prego attendere"), FALSE, TRUE, 30);
for ( *cursor = 0; cursor->pos() < last; ++(*cursor) )
{
prg.addstatus(1);
int g = rec.get_int(PCN_GRUPPO);
int c = rec.get_int(PCN_CONTO);
long s = rec.get_int(PCN_SOTTOCONTO);
if (g != 0 && c == 0 && s == 0) continue;
char sez = rec.get_char(PCN_SEZIVD);
char let = rec.get_char(PCN_LETTIVD);
TString numr = rec.get (PCN_NUMRIVD);
int num = rec.get_int (PCN_NUMIVD);
TString descr = rec.get (PCN_DESCR);
char sez_opp = rec.get_char(PCN_SEZIVDOPP);
char let_opp = rec.get_char(PCN_LETTIVDOPP);
TString numr_opp = rec.get (PCN_NUMRIVDOPP);
int num_opp = rec.get_int (PCN_NUMIVDOPP);
if ((g != 0) && (c != 0) && (s == 0))
{
if (sez != '\0' && sez != '0')
{
sez_conto = sez;
if (let != '\0')
let_conto = let;
else
if ((sez == '1')||(sez == '2'))
let_conto = 'Z';
else
let_conto = let;
numr_conto = numr;
num_conto = num;
classe_conto = TRUE;
riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,descr,sez_opp,let_opp,numr_opp,num_opp);
}
else
classe_conto = FALSE;
}
if ((g != 0) && (c != 0) && (s != 0))
{
if (classe_conto)
riempi_record(sez_conto,let_conto,numr_conto,num_conto,g,c,s,descr,sez_opp,let_opp,numr_opp,num_opp);
else
{
if (sez != '\0' && sez != '0')
{
if (let == '\0')
if ((sez == '1')||(sez == '2'))
let = 'Z';
riempi_record(sez,let,numr,num,g,c,s,descr,sez_opp,let_opp,numr_opp,num_opp);
}
}
}
}
_sort->endsort();
select_cursor (_cur_c2);
}
if (_tipo_stampa == con_ana_bil)
{
bool livello_conto = FALSE;
_sort->init();
select_cursor (_cur_c1);
TCursor * cursor = current_cursor();
TRectype & rec = cursor->curr();
long last = cursor->items();
TProgind prg (last, TR("Elaborazione Piano dei Conti... Prego attendere"), FALSE, TRUE, 30);
TString c1(12);
int conto_p = -1;
for ( *cursor = 0; cursor->pos() < last; ++(*cursor) )
{
prg.addstatus(1);
int gruppo = rec.get_int (PCN_GRUPPO);
int conto = rec.get_int (PCN_CONTO);
long sottoc = rec.get_long(PCN_SOTTOCONTO);
if (livello_conto && (conto != conto_p) )
{
c1 = "";
livello_conto = FALSE;
}
conto_p = conto;
if (conto == 0) // Si tratta di un gruppo
c1 = rec.get(PCN_CODCBL);
else
if (sottoc == 0) // Si tratta di un conto
{
if (rec.get(PCN_CODCBL).empty())
rec.put(PCN_CODCBL, c1);
else
{
c1 = rec.get(PCN_CODCBL);
livello_conto = TRUE;
}
}
else // Si tratta di un sottoconto
if (rec.get(PCN_CODCBL).empty())
rec.put(PCN_CODCBL, c1);
if (rec.get(PCN_CODCBL).not_empty() )
_sort->sort (rec.string());
}
_sort->endsort();
select_cursor (_cur_c2);
}
}
void CG1100_application::cancella(int g, int c, long s)
{
_tpcon->setkey(1);
_tpcon->zero();
_tpcon->put(PCN_GRUPPO, g);
_tpcon->put(PCN_CONTO, c);
_tpcon->put(PCN_SOTTOCONTO, s);
if (_tpcon->read() == NOERR)
_tpcon->remove();
}
void CG1100_application::prepara_pcon_temp()
{
TLocalisamfile pcon (LF_PCON);
TRectype rec (LF_PCON);
bool gruppo_riclassificato = FALSE;
bool conto_riclassificato = FALSE;
int g_prec = -1;
int c_prec = -1;
long items = pcon.items();
TProgind prog (items,TR("Elaborazione Piano dei Conti... Prego attendere"), FALSE, TRUE, 30);
for (pcon.first(); !pcon.eof(); pcon.next())
{
prog.addstatus(1);
int g = pcon.get_int (PCN_GRUPPO);
int c = pcon.get_int (PCN_CONTO);
long s = pcon.get_long(PCN_SOTTOCONTO);
if (gruppo_riclassificato && g == g_prec)
continue;
else
gruppo_riclassificato = FALSE;
if (conto_riclassificato && (g == g_prec && c == c_prec) )
continue;
else
conto_riclassificato = FALSE;
TString16 codcbl = pcon.get(PCN_CODCBL);
if (c == 0) // Se si tratta di un gruppo
{
if (codcbl.empty())
{
rec = pcon.curr();
_tpcon->zero();
_tpcon->curr() = rec;
_tpcon->write();
}
else
gruppo_riclassificato = TRUE;
}
else
if (s == 0) // Se si tratta di un conto
{
if (codcbl.empty())
{
rec = pcon.curr();
_tpcon->zero();
_tpcon->curr() = rec;
_tpcon->write();
}
else
{
int gruppo = pcon.get_int(PCN_GRUPPO);
cancella(gruppo,0,0); // Cancella l'eventuale gruppo
conto_riclassificato = TRUE;
}
}
else // Se si tratta di un sottoconto
{
if (codcbl.empty())
{
rec = pcon.curr();
_tpcon->zero();
_tpcon->curr() = rec;
_tpcon->write();
}
else
{
int gruppo = pcon.get_int(PCN_GRUPPO);
int conto = pcon.get_int(PCN_CONTO);
cancella(gruppo,0,0); // Cancella l'eventuale gruppo
cancella(gruppo,conto,0); // Cancella l'eventuale conto
}
}
}
select_cursor(_cur_c3); // Seleziono il cursore definito sul piano dei conti temporaneo
_tpcon->first();
}
bool CG1100_application::preprocess_print (int file,int counter)
{
switch (_tipo_stampa)
{
case completa:
case completa_bil:
case senza_IV_direttiva:
break;
case con_IV_direttiva:
{
struct bil_ivd* bil = (struct bil_ivd*) _buf;
if ((_buf = _sort->retrieve()) != NULL)
{
bil = (struct bil_ivd*) _buf;
_sez_da_stamp = bil->sez;
_let_da_stamp = bil->let;
_numr_da_stamp = bil->numr;
_numr_da_stamp.ltrim();
_num_da_stamp = atoi(bil->num);
_gruppo = atoi(bil->gruppo);
_conto = atoi(bil->conto);
_sottoc = atol(bil->sottoc);
_classe_da_stampare.format("%c%c%s%2d",_sez_da_stamp,_let_da_stamp,(const char*)_numr_da_stamp,_num_da_stamp);
return TRUE;
}
else
return FALSE;
}
break;
case con_ana_bil:
{
TRectype rec (LF_PCON);
if ((_buf = _sort->retrieve()) != NULL)
{
rec = _buf;
_codcbl_da_stamp = rec.get(PCN_CODCBL);
_gruppo = rec.get_int(PCN_GRUPPO);
_conto = rec.get_int(PCN_CONTO);
_sottoc = rec.get_long(PCN_SOTTOCONTO);
return TRUE;
}
else
return FALSE;
}
break;
case senza_ana_bil:
break;
default:
break;
}
return TRUE;
}
void CG1100_application::set_con_IV()
{
struct bil_ivd* bil = (struct bil_ivd*) _buf;
TString descrizione,descr;
char sez_opp,let_opp;
int num_opp,numr_opp;
bool stampa_classe = TRUE;
int numr = atoi(_numr_da_stamp);
TString numrom = itor(numr);
sez_opp = bil->sez_opp;
let_opp = bil->let_opp;
numr_opp = atoi(bil->numr_opp);
TString numrom_opp = itor(numr_opp);
num_opp = bil->num_opp;
descrizione = descrizione_numero(_sez_da_stamp,_let_da_stamp,numr,_num_da_stamp);
descr = bil->descr;
//Se la classe prelevata dal record corrente del sort e' diversa dalla classe
//prelevata dal record precedente, allora stampo la nuova classe con i relativi
//sottoconti. In caso contrario continuo a stampare solo i sottoconti.
if (_classe_da_stampare != _classe_stampata)
{
if (_sez_da_stamp != _sez_stamp)
{
if ((_sez_da_stamp == '1')&&(_let_da_stamp == 'Z'))
{
char app = ' ';
set_row (_i++,"@0g%c", app);
set_row (_i++,FR("@0gCONTI D' ORDINE ATTIVI"));
set_row (_i++,"@0g%c", app);
stampa_classe = FALSE;
}
else
if ((_sez_da_stamp == '1')&&(_let_da_stamp != 'Z'))
{
char app = ' ';
set_row (_i++,"@0g%c", app);
set_row (_i++,FR("@0gATTIVO"));
set_row (_i++,"@0g%c", app);
}
if ((_sez_da_stamp == '2')&&(_let_da_stamp == 'Z'))
{
char app = ' ';
set_row(_i++,"@0g%c", app);
set_row (_i++,FR("@0gCONTI D' ORDINE PASSIVI"));
set_row(_i++,"@0g%c", app);
stampa_classe = FALSE;
}
else
if ((_sez_da_stamp == '2')&&(_let_da_stamp != 'Z'))
{
char app = ' ';
set_row(_i++,"@0g%c", app);
set_row (_i++,FR("@0gPASSIVO"));
set_row(_i++,"@0g%c", app);
}
if (_sez_da_stamp == '5')
{
char app = ' ';
set_row(_i++,"@0g%c", app);
set_row (_i++,FR("@0gCONTI D' ORDINE"));
set_row(_i++,"@0g%c", app);
stampa_classe = FALSE;
}
if (_sez_da_stamp == '9')
{
char app = ' ';
set_row(_i++,"@0g%c", app);
set_row (_i++,FR("@0gCONTO ECONOMICO"));
set_row(_i++,"@0g%c", app);
}
}
else
if ((_let_da_stamp!=_let_stamp)&&(_sez_da_stamp==_sez_stamp))
{
if ((_sez_da_stamp == '1')&&(_let_da_stamp == 'Z'))
{
char app = ' ';
set_row (_i++,"@0g%c", app);
set_row (_i++,FR("@0gCONTI D' ORDINE ATTIVI"));
set_row (_i++,"@0g%c", app);
stampa_classe = FALSE;
}
if ((_sez_da_stamp == '2')&&(_let_da_stamp == 'Z'))
{
char app = ' ';
set_row(_i++,"@0g%c", app);
set_row (_i++,FR("@0gCONTI D' ORDINE PASSIVI"));
set_row(_i++,"@0g%c", app);
stampa_classe = FALSE;
}
}
if (stampa_classe)
{
if ((_sez_da_stamp=='1')||(_sez_da_stamp=='2')||(_sez_da_stamp== '9'))
{
char app = ' ';
set_row (_i++,"@0g%c", app);
if (_let_da_stamp != ' ')
set_row(_i,"@0g%c", _let_da_stamp);
if (_numr_da_stamp != "")
set_row(_i,"@2g%8s", (const char*) numrom);
if (_num_da_stamp != 0)
set_row(_i,"@11g%2d", _num_da_stamp);
_d2 = (const char*) descrizione;
set_row(_i,"@14g#a", &_d2);
// setta_righe_descr(_descr);
}
}
}
set_row (_i,"@58g$[b]%3d$[n]", _gruppo);
set_row (_i,"@62g$[b]%3d$[n]", _conto);
if (_sottoc != 0)
set_row (_i,"@66g$[b]%6ld$[n]", _sottoc);
set_row (_i,"@73g%.40s", (const char*) descr);
if (sez_opp != '0')
{
set_row (_i,"@116g%c", sez_opp);
if (let_opp != '\0')
set_row (_i,"@118g%c", let_opp);
if (numr_opp != 0)
set_row (_i,"@120g%8s", (const char*) numrom_opp);
if (num_opp != 0)
set_row (_i++,"@129g%2d", num_opp);
}
else
_i++;
}
void CG1100_application::set_senza_IV_ana()
{
int i;
TRectype & rec = current_cursor()->curr();
int gruppo = rec.get_int (PCN_GRUPPO);
int conto = rec.get_int (PCN_CONTO);
long sottoc = rec.get_long(PCN_SOTTOCONTO);
reset_print ();
i = 1;
if (_prima_volta)
{
_g_prec = gruppo;
_c_prec = conto;
_prima_volta = FALSE;
}
if (sottoc == 0L) // Se si tratta di un conto
{
if (gruppo != _g_prec)
_stampa_riga_vuota = TRUE;
}
else
{
if (gruppo != _g_prec || conto != _c_prec)
_stampa_riga_vuota = TRUE;
}
if (_stampa_riga_vuota)
{
char app = ' ';
set_row (i++,"@0g%c", app);
_stampa_riga_vuota = FALSE;
}
set_row (i, "$[b]@pn$[n] $[b]@pn$[n] $[b]@pn$[n]",
FLD(LF_PCON, PCN_GRUPPO, "###"), FLD(LF_PCON,PCN_CONTO, "###"),
FLD(LF_PCON, PCN_SOTTOCONTO, "######"));
set_row (i, "@16g@50s", FLD(LF_PCON,PCN_DESCR) );
if (conto != 0 && sottoc == 0l)
{
set_row (i, "@76g@pn", FLD(LF_PCON, PCN_INDBIL, "#") );
set_row (i, "@82g@1s", FLD(LF_PCON, PCN_TMCF) );
set_row (i, "@89g@f", FLD(LF_PCON, PCN_STSOTTBIL) );
set_row (i, "@98g@f", FLD(LF_PCON, PCN_COMPENS) );
set_row (i, "@121g@f", FLD(LF_PCON, PCN_STSOTTAB) );
}
if (sottoc != 0l)
{
char tipospric = rec.get_char(PCN_TIPOSPRIC);
if (tipospric == '\0') tipospric = '0';
set_row (i, "@104g@1n", FLD(LF_PCON, PCN_RICSER) );
set_row (i, "@109g%c", tipospric);
set_row (i, "@115g@1s", FLD(LF_PCON, PCN_SEZSALDI) );
set_row (i, "@129g@f", FLD(LF_PCON, PCN_STSOTTAB) );
}
}
void CG1100_application::set_con_ana()
{
TRectype rec (LF_PCON);
TString16 val;
rec = _buf;
TString descrizione,descr;
bool stampa_codcbl = TRUE;
TString codcbl = rec.get(PCN_CODCBL);
int gruppo = rec.get_int (PCN_GRUPPO);
int conto = rec.get_int (PCN_CONTO);
long sottoc = rec.get_long(PCN_SOTTOCONTO);
bool stsobi = rec.get_bool(PCN_STSOTTAB);
if (stsobi)
val = TR("Si");
else
val = TR("No");
descrizione = descrizione_codcbl(codcbl);
descr = rec.get(PCN_DESCR);
char app = ' ';
set_row (_i++,"@0g%c", app);
if (_codcbl_da_stamp != _codcbl_stamp)
{
set_row (_i,"@0g%10s", (const char*) _codcbl_da_stamp);
set_row (_i,"@11g%s", (const char*) descrizione);
}
set_row (_i,"@62g$[b]%3d$[n]", _gruppo);
if (_conto != 0)
set_row (_i,"@66g$[b]%3d$[n]", _conto);
if (_sottoc != 0)
set_row (_i,"@70g$[b]%6ld$[n]", _sottoc);
if (_gruppo > 99 || _conto > 99)
set_row(_i,"@76g*");
set_row (_i,"@78g%.40s", (const char*) descr);
if (conto != 0 && sottoc == 0l)
set_row (_i, "@121g%s", (const char*) val);
else
if (sottoc != 0l)
set_row (_i, "@129g%s", (const char*) val);
_i++;
}
void CG1100_application::set_completa()
{
TRectype& rec = current_cursor()->curr();
char sezione;
int i;
int gruppo = rec.get_int (PCN_GRUPPO);
int conto = rec.get_int (PCN_CONTO);
long sottoc = rec.get_long(PCN_SOTTOCONTO);
sezione = rec.get_char(PCN_SEZIVD);
TString desc = rec.get(PCN_DESCR);
if (_prima_volta)
{
_s_prec = 0;
_prima_volta = FALSE;
}
if (sottoc != 0l && _s_prec != 0l)
i = 1;
else
{
i = 1;
char app = ' ';
set_row (i++,"@0g%c", app);
}
reset_print ();
set_row (i, "$[b]@pn$[n] $[b]@pn$[n] $[b]@pn$[n]",
FLD(LF_PCON, PCN_GRUPPO, "###"), FLD(LF_PCON,PCN_CONTO, "###"),
FLD(LF_PCON, PCN_SOTTOCONTO, "######"));
set_row (i, "@16g%.40s", (const char*) desc); // ???
if (_tipo_stampa == completa)
{
if (sezione != '0' && sezione != '9')
set_row (i, "@58g@1s", FLD(LF_PCON, PCN_SEZIVD) );
set_row (i, "@60g@1s", FLD(LF_PCON, PCN_LETTIVD) );
set_row (i, "@62g#-8t", &_clivd );
set_row (i, "@71g@pn", FLD(LF_PCON, PCN_NUMIVD, "@@") );
}
else
if (_tipo_stampa == completa_bil)
set_row (i, "@60g@10s", FLD(LF_PCON, PCN_CODCBL) );
if (conto != 0 && sottoc == 0l)
{
set_row (i, "@76g@pn", FLD(LF_PCON, PCN_INDBIL, "#") );
set_row (i, "@82g@1s", FLD(LF_PCON, PCN_TMCF) );
set_row (i, "@89g@f", FLD(LF_PCON, PCN_STSOTTBIL) );
set_row (i, "@98g@f", FLD(LF_PCON, PCN_COMPENS) );
set_row (i, "@121g@f", FLD(LF_PCON, PCN_STSOTTAB) );
}
if (sottoc != 0l)
{
char tipospric = rec.get_char(PCN_TIPOSPRIC);
if (tipospric == '\0') tipospric = '0';
set_row (i, "@104g@1n", FLD(LF_PCON, PCN_RICSER) );
set_row (i, "@109g%c", tipospric);
set_row (i, "@114g@1s", FLD(LF_PCON, PCN_SEZSALDI) );
set_row (i, "@129g@f", FLD(LF_PCON, PCN_STSOTTAB) );
}
_s_prec = sottoc;
}
bool CG1100_application::elabora_riga()
{
TRectype& curr_rec = *_rec;
switch (_tipo_stampa)
{
case completa:
case senza_IV_direttiva:
curr_rec = current_cursor()->curr();
break;
case senza_ana_bil:
{
curr_rec = current_cursor()->curr();
int conto = curr_rec.get_int(PCN_CONTO);
long sottoc = curr_rec.get_long(PCN_SOTTOCONTO);
if (conto != 0)
{
// se e' un sottoconto stampo sotttab in 127
if (sottoc != 0)
{
char tipospric = curr_rec.get_char(PCN_TIPOSPRIC);
if (tipospric == '\0') tipospric = '0';
set_row (1, "@114g%c", tipospric);
set_row (1, "@127g@f", FLD(LF_PCON, PCN_STSOTTAB));
set_row (1, "@117g ");
}
else
// se e' un conto stampo sotttab in 124
{
set_row (1, "@117g@f", FLD(LF_PCON, PCN_STSOTTAB));
set_row (1, "@127g ");
}
}
break;
}
case con_ana_bil:
case con_IV_direttiva:
curr_rec = *_rec;
break;
default:
break;
}
// Gestione salto pagina
if (_tipo_stampa == con_ana_bil) // || _tipo_stampa == con_IV_direttiva)
return FALSE;
int new_gruppo = curr_rec.get_int(PCN_GRUPPO);
if (_salto_pag && new_gruppo != _old_gruppo)
{
const bool salta = _old_gruppo > 0;
_old_gruppo = new_gruppo;
return salta;
}
return FALSE;
}
int CG1100_application::leggo_sottoc(int gruppo,int conto,long sottoc)
{
TLocalisamfile pconti (LF_PCON);
char sez;
int gr,co;
int esito = 0;
bool esiste_conto_classificato = FALSE;
bool esiste_conto_non_classificato = FALSE;
pconti.zero();
pconti.put(PCN_GRUPPO, gruppo);
pconti.put(PCN_CONTO, conto);
pconti.put(PCN_SOTTOCONTO, sottoc);
for (pconti.read(); !pconti.eof() ;pconti.next())
{
gr = pconti.get_int (PCN_GRUPPO);
co = pconti.get_int (PCN_CONTO);
if (gruppo != gr || conto != co) break;
sez = pconti.get_char(PCN_SEZIVD);
if (sez != '0')
esiste_conto_classificato = TRUE;
if (sez == '0')
esiste_conto_non_classificato = TRUE;
}
if (!esiste_conto_classificato && esiste_conto_non_classificato)
esito = 0;
if (esiste_conto_classificato && esiste_conto_non_classificato)
esito = 1;
if (esiste_conto_classificato && !esiste_conto_non_classificato)
esito = 2;
return esito;
}
bool CG1100_application::preprocess_page(int file,int counter)
{
static int c1 = 0;
static TString16 a1;
char sez;
TString16 codcbl;
if (_tipo_stampa == completa || _tipo_stampa == completa_bil)
set_completa();
if (_tipo_stampa == senza_IV_direttiva)
{
if (file == LF_PCON)
{
TRectype& rec = current_cursor()->curr();
int gruppo = rec.get_int (PCN_GRUPPO);
int conto = rec.get_int (PCN_CONTO);
long sottoc = rec.get_long(PCN_SOTTOCONTO);
force_setpage();
if (conto == 0) return FALSE; //Scarto i gruppi
if (sottoc == 0L) // Se si tratta di un conto
{
sez = rec.get_char(PCN_SEZIVD);
if (sez == '0')
{
_sottoc_classificato = byte(leggo_sottoc(gruppo,conto,sottoc));
if (_sottoc_classificato == 0)
_conto_classificato = TRUE;
else
if (_sottoc_classificato == 1)
{
_conto_classificato = FALSE;
return FALSE;
}
else
if (_sottoc_classificato == 2)
{
_conto_classificato = TRUE;
return FALSE;
}
}
else
{
_conto_classificato = TRUE;
return FALSE;
}
}
else // Se si tratta di un sottoconto
{
if (!_conto_classificato)
{
char sezione = rec.get_char(PCN_SEZIVD);
if (sezione != '0')
return FALSE;
}
else
return FALSE;
}
_g_prec = gruppo;
_c_prec = conto;
}
}
if (_tipo_stampa == senza_ana_bil)
{
if (file == LF_PCON)
{
TRectype& rec = current_cursor()->curr();
int gruppo = rec.get_int (PCN_GRUPPO);
int conto = rec.get_int (PCN_CONTO);
long sottoc = rec.get_long(PCN_SOTTOCONTO);
force_setpage();
if (gruppo != _g_prec)
{
_stampa_g = TRUE;
_stampa_c = TRUE;
}
if ( (gruppo != _g_prec || conto != _c_prec) && _stampa_g)
_stampa_c = TRUE;
_g_prec = gruppo;
_c_prec = conto;
if (conto == 0) // Si tratta di un gruppo
{
_stampa_g = FALSE;
_stampa_c = FALSE;
return TRUE;
}
if (sottoc == 0) // Si tratta di un conto
{
if (_stampa_g)
{
_stampa_c = FALSE;
return TRUE;
}
else
return FALSE;
}
if (sottoc != 0) // Si tratta di un sottoconto
{
if (_stampa_c)
return TRUE;
else
return FALSE;
}
}
}
if (elabora_riga())
printer().formfeed();
const int c3 = atoi(_rec->get(PCN_NUMRIVD));
const int o3 = atoi(_rec->get(PCN_NUMRIVDOPP));
_clivd = itor(c3);
_clivdo = itor(o3);
return TRUE;
}
bool CG1100_application::set_print(int)
{
KEY tasto;
_old_gruppo = 0;
tasto = _msk->run();
if (tasto == K_ENTER)
{
_tipo_stampa = (stampe)_msk->get_int(F_SCELTA_STAMPA);
_salto_pag = _msk->get_bool(F_SALTO_PAGINA);
_data_stampa = _msk->get(F_DATA_STAMPA);
// scegli_cur();
enable_link(TR("Collegamento Piano dei conti: "), 'b');
set_multiple_link(TRUE);
_sez_stamp = ' ';
_let_stamp = ' ';
_numr_stamp = "";
_num_stamp = 0;
_classe_stampata = "";
_resetta_righe_stampa = TRUE;
reset_footer();
if (_tipo_stampa == con_ana_bil)
set_footer(2,TR("* Conti collegati ma non trasferibili"));
else
set_footer(2,"");
if (_tipo_stampa == senza_IV_direttiva)
{
_conto_classificato = TRUE;
_sottoc_classificato = 0;
_stampa_riga_vuota = FALSE;
_prima_volta = TRUE;
}
switch (_tipo_stampa)
{
case completa:
case completa_bil:
case senza_IV_direttiva:
select_cursor(_cur_c1);
break;
case senza_ana_bil:
{
_tpcon = new TIsamtempfile (LF_PCON, "ab", TRUE);
_relt = new TRelation (_tpcon);
TCursor *tcursor = new TCursor (_relt);
_cur_c3 = add_cursor (tcursor);
select_cursor(_cur_c1);
prepara_pcon_temp();
break;
}
case con_IV_direttiva:
case con_ana_bil:
init_sort();
do_sort();
select_cursor (_cur_c2); break;
default:
break;
}
//init_sort();
intesta (_tipo_stampa);
printer().footerlen(5);
return TRUE;
}
return FALSE;
}
void CG1100_application::intesta (stampe tipo)
{
int soh = 1; // riga d'inizio dell'intestazione
const long firm = get_firm();
reset_header ();
TLocalisamfile ditte(LF_NDITTE);
ditte.zero();
ditte.put(NDT_CODDITTA, firm);
ditte.read();
if (ditte.bad()) ditte.zero();
TString s(132);
s = ditte.get(NDT_RAGSOC);
TString data = _data_stampa.string();
set_header (soh++, FR("Ditta : %ld %s@105gData %s Pag. @#"), firm, (const char*)s, (const char*)data);
set_header (soh,FR("@0gPIANO DEI CONTI"));
switch (tipo)
{
case completa:
set_header (soh++, FR("@20gStampa completa per IV direttiva"));
s.fill('-');
set_header (soh++, (const char *) s);
set_header (soh++, FR("Conto @59gSez. Classe@75gTipo@86gNo Dettaglio@104gT@107gSpesa@118gDet.alleg.bil."));
set_header (soh++, FR("Sottoconto @16gDescrizione@61gIV dir.@75gConto@81gC/F@86gBilancio@97gComp.@104gA@107gRicavo@114gSez@118gSot.con * Mov."));
break;
case con_IV_direttiva:
set_header (soh++, FR("@20gStampa conti riclassificati per IV direttiva"));
s.fill('-');
set_header (soh++, (const char *) s);
set_header (soh++, FR("@58gCodici Piano@116gSez. e Classe"));
set_header (soh++, FR("Classe@14gDescrizione@58gdei Conti @73gDescrizione@116gdi segno opposto"));
break;
case senza_IV_direttiva:
set_header (soh++, FR("@20gStampa conti non collegati per IV direttiva"));
s.fill('-');
set_header (soh++, (const char *) s);
set_header (soh++, FR("Conto @75gTipo@86gNo Dettaglio@104gT@107gSpesa@118gDet.alleg.bil."));
set_header (soh++, FR("Sottoconto @16gDescrizione@75gConto@81gC/F@86gBilancio@97gComp.@104gA@107gRicavo@114gSez@118gSot.con * Mov."));
break;
case completa_bil:
set_header (soh++, FR("@20gStampa completa per analisi di bilancio"));
s.fill('-');
set_header (soh++, (const char *) s);
set_header (soh++, FR("Conto@60gCod.tabella@75gTipo@86gNo Dettaglio@104gT@107gSpesa@118gDet.alleg.bil."));
set_header (soh++, FR("Sottoconto @16gDescrizione@60gAnalis.bil.@75gConto@81gC/F@86gBilancio@97gComp.@104gA@107gRicavo@114gSez@118gSot.con * Mov."));
break;
case con_ana_bil:
set_header (soh++, FR("@20gStampa conti riclassificati per analisi di bilancio"));
s.fill('-');
set_header (soh++, (const char *) s);
set_header (soh++, FR("Codice @62gCodici Piano@118gDet.alleg.bil."));
set_header (soh++, FR("Tabella@11gDescrizione@62gdei Conti @78gDescrizione@118gSot.con * Mov."));
break;
case senza_ana_bil:
set_header (soh++, FR("@20gStampa conti non collegati per analisi di bilancio"));
s.fill('-');
set_header (soh++, (const char *) s);
set_header (soh++, FR("Conto@74gTipo@86gNo Dettaglio@107gSpesa@114gT@116gDett.alleg.bil."));
set_header (soh++, FR("Sottoconto@16gDescrizione@74gConto@81gC/F@86gBilancio@96gCompensaz.@107gRicavo@114gA@116gSot.con * Movim."));
break;
default:
break;
}
set_header (soh++,(const char*)s);
set_header (soh, "");
}
const char* CG1100_application::descrizione_numero(char sezione, char lettera, int numr, int numero)
{
TTable& tabivd = *_tab;
TString dep,dep2;
tabivd.zero();
if (numr == 0 && numero == 0)
dep = format("%c%c",sezione,lettera);
else
if (numero == 0)
{
if (numr != 0)
dep = format("%1c%1c%04d",sezione, lettera, numr);
else
dep = format("%c%c ",sezione,lettera);
}
else
{
if (numr != 0)
dep = format("%1c%1c%04d%02d",sezione, lettera, numr,numero);
else
dep = format("%c%c %02d",sezione,lettera,numero);
}
tabivd.put("CODTAB", dep);
tabivd.read();
dep2 = tabivd.get("CODTAB");
if (dep == dep2)
tmp = tabivd.get("S0");
else
tmp = "";
return tmp;
}
const char* CG1100_application::descrizione_codcbl(TString& codcbl)
{
TLocalisamfile abpcon (LF_ABPCON);
abpcon.setkey(1);
abpcon.zero();
abpcon.put("CODCBL", codcbl);
if (abpcon.read() == NOERR)
tmp = abpcon.get("DESCRIZ");
else
tmp = "";
return tmp;
}
bool CG1100_application::user_create()
{
_rel = new TRelation (LF_PCON);
_tab = new TTable(TAB_IVD);
_msk = new TMask ("cg1100a") ;
_pcon = new TLocalisamfile (LF_PCON);
TCursor *cursor = new TCursor (_rel);
_cur_c1 = add_cursor (cursor);
_rec = new TRectype (cursor->curr());
_pcont_reclen = _rec->len();
_sort = new TSort(_pcont_reclen);
_cur_c2 = add_cursor (NULL);
add_file(LF_PCON);
_tipo_stampa = completa;
_salto_pag = FALSE;
_bil = new bil_ivd;
_sort = new TSort();
return TRUE;
}
bool CG1100_application::user_destroy()
{
delete _rel;
delete _tab;
delete _pcon;
//delete _tpcon;
delete _msk;
delete _rec;
// delete _descr;
delete _bil;
delete _sort;
return TRUE;
}
int cg1100(int argc, char* argv[])
{
CG1100_application a;
a.run(argc, argv, TR("Stampa Piano dei Conti"));
return 0;
}
Reference in New Issue View Git Blame Copy Permalink