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

1115 lines
29 KiB
C++
Executable File
Raw Blame History

// cg0500.cpp - Tabella causali
#include <applicat.h>
#include <msksheet.h>
#include <relapp.h>
#include <tabutil.h>
#include <config.h>
#include <utility.h>
#include <clifo.h>
#include <pconti.h>
#include <causali.h>
#include <rcausali.h>
#include "cglib.h"
#include "cg0501.h"
#include "cg0500.h"
////////////////////////////////////////////////////////////////////////////
// Funzioni legate ai parametri ditta
////////////////////////////////////////////////////////////////////////////
HIDDEN bool salda_conto()
{
static bool _saldaconto = 2;
if (_saldaconto == 2)
{
TConfig conf(CONFIG_DITTA);
_saldaconto = conf.get_bool("GesSal");
}
return _saldaconto;
}
HIDDEN bool gestione_valuta()
{
static bool _gest_val = 2;
if (_gest_val == 2)
{
TConfig conf(CONFIG_DITTA);
_gest_val = conf.get_bool("GesVal");
}
return _gest_val;
}
HIDDEN int anno_iva()
{
static int _anno_iva = 0;
if (_anno_iva == 0)
{
TConfig conf(CONFIG_DITTA);
_anno_iva = (int)conf.get_long("AnLiIv", "cg");
if (_anno_iva < 1900)
{
_anno_iva = TDate(TODAY).year();
error_box("Anno liquidazione IVA non specificato: assumo %d", _anno_iva);
}
}
return _anno_iva;
}
////////////////////////////////////////////////////////////////////////////
// Le righe di causale:
// Righe_rcaus e' un array di Riga_rcaus
// Riga_rcaus e' una token_string corrispondente ad una riga dello spreadsheet
////////////////////////////////////////////////////////////////////////////
class Riga_rcaus : public TToken_string
{
public:
const TString& operator = (const TString& s)
{return TToken_string::operator=(s);}
Riga_rcaus (TConto& tc, // il conto
const char *df="", // descrizione fissa
char tipocf=' ', // tipo C/F
char sezione=' ', // dare/avere
const char * des="", // descrizione del conto
const char * desagg="", // codice descr. aggiuntiva
bool rigaiva=' ', // se e' una riga iva
const char * codiva=""); // codice iva
};
Riga_rcaus::Riga_rcaus (TConto& tc,const char * df, char tipocf, char sez,
const char * des, const char * desagg,
bool rigaiva, const char * codiva)
: TToken_string(80)
{
add(df);
// add(tc.tipo());
add(tipocf);
if (tc.ok())
{
add((long)tc.gruppo());
add((long)tc.conto());
add((long)tc.sottoconto());
}
else
{
add("");
add("");
add("");
}
add(sez);
add(des);
add(desagg);
add((char)rigaiva);
add(codiva);
}
class TRighe_rcaus : public TArray
{
public:
void set_descr (int numrig=-1, const char * descr="", char tipocf=' ');
void add_riga(int numrig, const char * dfi, char tipocf,
char sezione, const char * des, const char * desagg,
bool rigaiva, const char * codiva, TConto& tc );
void carica_descr_0 ();
void carica_descr_1 ();
void carica_descr_2 ();
void carica_descr_tpr1 ();
void carica_descr_tpr2 ();
TRighe_rcaus() : TArray(20) {}
};
void TRighe_rcaus::add_riga(int i, const char * dfi, char tipocf,
char sez, const char * des, const char * desagg, bool rigaiva,
const char * codiva, TConto& tc)
{
Riga_rcaus *r = (Riga_rcaus*)objptr(i);
// TString df(20), d(50), da(4), civa(3);
int g=0,c=0;
long s=0L;
// char sz=' ', cf=' ';
// bool riva;
if (r == NULL)
{
r = new Riga_rcaus (tc,dfi,tipocf,sez,des,desagg,rigaiva,codiva);
add(r,i); // ???
}
// else
// {
// if (tc.ok())
// {
g = tc.gruppo();
c = tc.conto();
s = tc.sottoconto();
// }
(*r)="";
r->add(dfi);
r->add(tipocf);
r->add((long)g);
r->add((long)c);
r->add((long)s);
r->add(sez);
r->add(des);
r->add(desagg);
r->add(rigaiva ? "X" : "");
r->add(codiva);
// }
}
void TRighe_rcaus::set_descr(int i, const char * dfi, char tipocf)
{
Riga_rcaus *r = (Riga_rcaus*)objptr(i);
TConto tc;
if (r == NULL)
{
r = new Riga_rcaus (tc,dfi,tipocf);
add(r,i);
}
r->add(dfi, 0);
r->add(tipocf, 1);
}
bool filtra_reg(const TRelation * r);
class CG0500_application : public TRelation_application
{
int _filtro; // tipo di filtro su tab. reg.
// 1 vendite senza corrisp
// 2 vendite con corrisp
// 3 acquisti
friend bool filtra_reg(const TRelation * r);
// static bool conto_hndl (TMask_field& f, KEY k);
static bool sottoconto_hndl (TMask_field& f, KEY k);
static bool tipocf_hndl (TMask_field& f, KEY k);
// static bool m770_hndl (TMask_field& f, KEY k);
static bool cod_reg_hndl (TMask_field& f, KEY k);
static bool tipodoc_hndl (TMask_field& f, KEY k);
static bool tipomov_hndl (TMask_field& f, KEY k);
// static bool codcausim_hndl (TMask_field& f, KEY k);
static bool leggi_riga (int r, KEY k);
TRelation * _rel;
TMask * _msk;
int _mode; // Modo maschera corrente
int _items;
TRighe_rcaus _righe_rcaus;
TBit_array _righe_gia_presenti;
void togli_dal_file(const TString&);
void compila_righe_rcaus (const TString&, int, int, int);
void read_rcaus(TMask&);
bool carica_descr(TMask&);
bool fill_sheet(TMask&);
static bool has_iva (const char * tpc);
bool is_clifo(const char * tpc);
protected:
virtual bool user_create();
virtual bool user_destroy();
virtual TRelation* get_relation() const { return _rel; }
virtual TMask* get_mask(int mode);
virtual bool changing_mask(int mode) {return FALSE; }
virtual bool remove();
void init_mask(TMask&);
virtual void init_query_mode(TMask&);
virtual void init_insert_mode(TMask&);
virtual void init_modify_mode(TMask&);
virtual int rewrite(const TMask& m);
virtual int write(const TMask& m);
virtual int read(TMask& m);
// int cancella(long items);
public:
int _riga;
TMask * main_mask() { return _msk; }
CG0500_application() {}
};
HIDDEN CG0500_application * app() { return (CG0500_application*) MainApp(); }
// Per sapere su che riga sono dello spreadsheet. v. set_notify piu' sotto
bool CG0500_application::leggi_riga(int r, KEY k)
{
if (k == K_SPACE)
app()->_riga = r;
return TRUE;
}
bool filtra_reg(const TRelation * r)
{
const TString codtab(r->lfile()->get("CODTAB"));
int tiporeg = r->lfile()->get_int("I0");
bool corrisp = r->lfile()->get_bool("B0");
const int anno = atoi(codtab.left(4));
switch (app()->_filtro)
{
case 1:
if (anno == anno_iva() && tiporeg == 1 && !corrisp)
return TRUE;
break;
case 2:
if (anno == anno_iva() && tiporeg == 1 && corrisp)
return TRUE;
break;
case 3:
if (anno == anno_iva() && tiporeg == 2)
return TRUE;
break;
case 4: // tiporeg 1 senza corrisp OPPURE 2 (NC ST ND AF)
if (anno == anno_iva())
if ( (tiporeg == 1 && !corrisp) || tiporeg == 2 )
return TRUE;
break;
default:
return FALSE;
}
return FALSE;
}
TMask* CG0500_application::get_mask(int mode)
{
return _msk;
}
bool CG0500_application::has_iva (const char * tpconto)
{
TFixed_string tpc(tpconto);
// Lascio abilitato codiva e rigaiva solo per i conti senza descr.fissa
if (tpc.trim().empty())
return TRUE;
else
return FALSE;
}
bool CG0500_application::is_clifo (const char * tpconto)
{
TFixed_string tpc(tpconto);
if ( (tpc == "C Clienti/Fornitori") || (tpc == "C Clienti") ||
(tpc == "C Fornitori") )
return TRUE;
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
// Handler
////////////////////////////////////////////////////////////////////////////
bool CG0500_application::cod_reg_hndl (TMask_field& f, KEY k)
{
if (k == K_TAB && f.focusdirty())
app()->fill_sheet(f.mask());
// controllo di consistenza tra codice (tipo) registro e tipo documento
if (k == K_ENTER && f.dirty())
{
bool ok = TRUE;
const TString16 tpd = f.mask().get(F_TIPO_DOC);
const int tipo = f.mask().get_int(F_TIPO_REG);
const bool corrisp = f.mask().get_bool(F_CORRISP);
// con tipo=1 e corrisp=""
if (tpd == "FV" || tpd == "FS" || tpd == "FS")
{
if (tipo != 1 || corrisp) ok = FALSE;
} else
// con tipo=1 e corrisp="X"
if (tpd == "CN" || tpd == "RN" || tpd == "CR" ||
tpd == "SC" || tpd == "RF" || tpd == "SN")
{
if (tipo != 1 || !corrisp) ok = FALSE;
} else
// Possono essere 1 o 2
if (tpd == "NC" || tpd == "ST" || tpd == "ND" ||
tpd == "AF")
{
if (tipo != 1 && tipo != 2) ok = FALSE;
} else
// con tipo=2
if (tpd == "FA" || tpd == "BD")
{
if (tipo != 2) ok = FALSE;
}
if (!ok)
return f.warning_box("Il registro (tipo %d) non e' compatibile con il tipo di documento (%s)",
tipo, (const char*)tpd);
}
return TRUE;
}
/* ???
bool CG0500_application::m770_hndl (TMask_field& f, KEY k)
{
if (k == K_TAB && f.focusdirty())
app()->fill_sheet(f.mask());
return TRUE;
}
*/
/*******************
15/07/94 se compilo conto o sottoconto metto REQUIRED in DARE/AVERE
21/07/94 Metto REQUIRED fisso nel .uml perche' g-c-s ci saranno sempre
bool CG0500_application::conto_hndl (TMask_field& f, KEY k)
{
if (f.to_check(k))
{
const TString val(f.get());
TEdit_field& sezione = (TEdit_field&)f.mask().field(106);
if (val.not_empty())
sezione.check_type(CHECK_REQUIRED);
else
sezione.check_type(CHECK_NONE);
}
return TRUE;
}
*******************/
// Handler del campo sottoconto C/F (205) della maschera di edit dello sheet
// controlla se il tipocf del g-c-s corrisponde al tipo inserito
// (nel campo 102)
bool CG0500_application::sottoconto_hndl (TMask_field& f, KEY k)
{
if (k == K_TAB)
{
const int tpr = app()->main_mask()->get_int(F_TIPO_REG);
// se sono sulla prima riga e acquisti o vendite
if (app()->_riga == 0 && (tpr == 1 || tpr == 2) )
{
int g = f.mask().get_int(103);
int c = f.mask().get_int(104);
if (g != 0 || c != 0)
{
f.mask().disable(103);
f.mask().disable(104);
}
else
{
f.mask().enable(103);
f.mask().enable(104);
}
}
/*
int g = f.mask().get_int(103);
int c = f.mask().get_int(104);
long s = f.mask().get_long(105);
TString tipocf = f.mask().get(102);
TConto tc(g,c,s);
if (tipocf != tc.tipo())
return f.warning_box("Il tipo C/F non corrisponde a quello del conto");
*/
}
return TRUE;
}
// Handler del campo tipocf ? della maschera di edit dello sheet
// 106 e' la sezione dare o avere
// 105 e' il sottoconto
// 205 e' il sottoconto in caso di C/F
bool CG0500_application::tipocf_hndl (TMask_field& f, KEY k)
{
// TFixed_string tpc(f.mask().get(101));
if (k == K_SPACE)
{
const int tpr = app()->main_mask()->get_int(F_TIPO_REG);
// 109 e 110 sono rigaiva e codiva
if (tpr == 1 || tpr == 2)
{
f.mask().enable(109); f.mask().enable(110);
}
else
{
f.mask().disable(109); f.mask().disable(110);
}
// se sono sulla prima riga e acquisti o vendite
// servira' a qualcosa ? boh ?
if (app()->_riga == 0)
{
if (tpr == 1) // VENDITE => C
{
f.mask().hide(105);
f.mask().hide(305);
f.mask().show(205);
return TRUE;
}
else
if (tpr == 2) // ACQUISTI => F
{
f.mask().hide(105);
f.mask().hide(205);
f.mask().show(305);
return TRUE;
}
}
/*** Questo lo ri-faccio fare nel .uml
const TString cf(f.get());
if (cf == "C")
{
f.mask().hide(105);
f.mask().hide(305);
f.mask().show(205);
}
else
if (cf == "F")
{
f.mask().hide(105);
f.mask().hide(205);
f.mask().show(305);
}
else // TIPOCF VUOTO
{
f.mask().hide(205);
f.mask().hide(305);
f.mask().show(105);
return TRUE;
}
*********************/
}
return TRUE;
}
bool CG0500_application::tipodoc_hndl (TMask_field& f, KEY k)
{
if (k == K_TAB && f.focusdirty())
{
const TString16 val(f.get());
const int tpm = f.mask().get_int(F_TIPO_MOV);
TEdit_field& field_reg = (TEdit_field&)f.mask().field(F_COD_REG);
if (val.not_empty())
{
f.mask().hide(F_OP_FINE_ANNO);
f.mask().enable(F_COD_REG);
field_reg.check_type(CHECK_REQUIRED);
// Cambio il filtro sui registri
// con tipo=1 e corrisp=""
if (val == "FV" || val == "FF" || val == "FS")
{
app()->_filtro = 1;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
// TString filt(format("CODTAB[1,4]=%s && I0=1 && B0=\"\"",
// (const char *)an_iva));
// field_reg.browse()->cursor()->filter(filt);
}
// con tipo=1 e corrisp="X"
if (val == "CN" || val == "RN" || val == "CR" ||
val == "SC" || val == "RF" || val == "SN")
{
app()->_filtro = 2;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
// Possono essere 1 o 2
if (val == "NC" || val == "ST" || val == "ND" ||
val == "AF")
{
app()->_filtro = 4;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
// con tipo=2
if (val == "FA" || val == "BD")
{
app()->_filtro = 3;
field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
}
f.mask().hide(F_TIPO_MOV_2);
f.mask().show(F_TIPO_MOV_1);
f.mask().show(F_AUTO_FAT);
f.mask().show(F_OP_INTRACOM);
f.mask().show(F_ALLEGAT);
f.mask().show(F_FAT_RITARDO);
f.mask().show(F_COD_CAUS_IM);
f.mask().show(F_MOV_VALU);
f.mask().show(F_MOV_SEZ);
f.mask().show(F_M_770);
f.mask().show(F_OP_FINE_ANNO);
}
else // tipodoc vuoto
{
// Devo poter rivedere tutti i registri se ho cancellato il campo TIPODOC
field_reg.check_type(CHECK_NORMAL);
if ( !salda_conto() || tpm == 0 )
f.mask().show(F_OP_FINE_ANNO);
else
f.mask().hide(F_OP_FINE_ANNO);
f.mask().set(F_COD_REG,"");
f.mask().disable(F_COD_REG);
f.mask().hide(F_TIPO_MOV_1);
f.mask().show(F_TIPO_MOV_2);
f.mask().hide(F_AUTO_FAT);
f.mask().hide(F_OP_INTRACOM);
f.mask().hide(F_ALLEGAT);
f.mask().hide(F_FAT_RITARDO);
f.mask().hide(F_COD_CAUS_IM);
f.mask().hide(F_MOV_VALU);
f.mask().hide(F_MOV_SEZ);
if (tpm > 0) // tipomov != nessuno
{
f.mask().hide(F_M_770);
f.mask().hide(F_OP_FINE_ANNO);
}
else
{
f.mask().show(F_M_770);
f.mask().show(F_OP_FINE_ANNO);
}
}
app()->fill_sheet(f.mask());
}
return TRUE;
}
bool CG0500_application::tipomov_hndl (TMask_field& f, KEY k)
{
if (f.to_check(k))
{
const int tpm = atoi(f.get());
if (tpm > 0)
{
if ( (tpm == 3) || (tpm == 5) || (tpm == 6) )
f.mask().enable(F_MOV_SEZ);
else
f.mask().disable(F_MOV_SEZ);
}
if (k == K_TAB)
app()->fill_sheet(f.mask());
}
return TRUE;
}
/* ??? CLEAR da maschera
bool CG0500_application::codcausim_hndl (TMask_field& f, KEY k)
{
if (f.to_check(k))
{
const int m770 = f.mask().get_int(F_M_770);
if (m770 > 0)
return f.error_box ("Il codice causale per l'incasso immediato puo' essere indicato solo se non c'e' il collegamento Mod.770");
}
return TRUE;
}
*/
////////////////////////////////////////////////////////////////////////////
//
////////////////////////////////////////////////////////////////////////////
// Registro vendite prima riga tipocf = "C" le altre fisso a BLANK
void TRighe_rcaus::carica_descr_tpr1()
{
int i=0;
TConto tc();
set_descr(i++, "C Clienti", 'C');
set_descr(i++, "C Di ricavo", ' ');
set_descr(i++, "C Iva vendite", ' ');
set_descr(i++, "C Iva non detraibile", ' ');
set_descr(i++, "C Imp. esenti", ' ');
set_descr(i++, "C Imp. non imponibili", ' ');
set_descr(i++, "C Imp. non soggetti", ' ');
set_descr(i++, "C Ritenute fiscali", ' ');
set_descr(i++, "C Ritenute soc.", ' ');
carica_descr_0();
}
// Registro ACQUISTI prima riga tipocf = "F" le altre fisso a BLANK
void TRighe_rcaus::carica_descr_tpr2()
{
int i=0;
set_descr( i++, "C Fornitori", 'F');
set_descr(i++, "C Di costo", ' ');
set_descr(i++, "C Iva acquisti", ' ');
set_descr(i++, "C Iva non detraibile", ' ');
set_descr(i++, "C Imp. esenti", ' ');
set_descr(i++, "C Imp. non imponibili", ' ');
set_descr(i++, "C Imp. non soggetti", ' ');
set_descr(i++, "C Ritenute fiscali", ' ');
set_descr(i++, "C Ritenute soc.", ' ');
carica_descr_0();
}
void TRighe_rcaus::carica_descr_2()
{
int i=0;
set_descr (i++, "Costo");
set_descr (i++, "Cassa/banca");
set_descr (i++, "Erario");
carica_descr_0();
}
void TRighe_rcaus::carica_descr_0()
{
for (int i = items(); i < 20; i++)
set_descr(i);
}
void TRighe_rcaus::carica_descr_1()
{
int i=0;
set_descr ( i++, "C Clienti/Fornitori");
set_descr ( i++, "C Cassa o banca");
set_descr ( i++, "C Tratta");
set_descr ( i++, "C Ricevuta bancaria");
set_descr ( i++, "C Cessione");
set_descr ( i++, "C Paghero'");
set_descr ( i++, "C Lettera di credito");
set_descr ( i++, "C Abb. pass/sc.");
set_descr ( i++, "C Abb. att/sc.");
set_descr ( i++, "C Spese e rimborsi");
set_descr ( i++, "C Ritenute fiscali");
if (gestione_valuta())
set_descr (i++, "C Differenza cambio");
carica_descr_0();
}
void CG0500_application::compila_righe_rcaus (const TString& tpd, int tpm, int tpr, int m770)
{
if (tpd.empty())
{
if ( tpm == 3 || tpm == 5 || tpm == 6 )
_righe_rcaus.carica_descr_1();
else
{
if ( !salda_conto() || tpm == 0 )
if (m770 == 6)
{
_righe_rcaus.carica_descr_2();
return;
}
_righe_rcaus.carica_descr_0();
}
}
else
{
if (tpr == 1)
_righe_rcaus.carica_descr_tpr1();
else
if (tpr == 2)
_righe_rcaus.carica_descr_tpr2();
_righe_rcaus.carica_descr_0();
}
}
void CG0500_application::read_rcaus(TMask& m)
{
int numrig, g, c;
long s;
TString d(50), da(3), civa(3);
char sz, cf;
bool riva;
TLocalisamfile * rcaus = _rel->lfile(LF_RCAUSALI);
_rel->update(); // chiamo position_rels()
_righe_gia_presenti.reset();
_righe_rcaus.destroy();
bool ok = _rel->is_first_match(LF_RCAUSALI);
while (ok)
{
numrig = rcaus->get_int(RCA_NRIGA);
CHECK(numrig > 0, "Causale con numero riga nullo");
g = rcaus->get_int(RCA_GRUPPO);
c = rcaus->get_int(RCA_CONTO);
s = rcaus->get_long(RCA_SOTTOCONTO);
sz = rcaus->get(RCA_SEZIONE)[0];
d = rcaus->get(RCA_DESC);
da = rcaus->get(RCA_CODDESC);
cf = rcaus->get(RCA_TIPOCF)[0];
riva = rcaus->get_bool(RCA_RIGAIVA);
civa = rcaus->get(RCA_CODIVA);
TConto tc(g,c,s,cf);
_righe_rcaus.add_riga(numrig-1, "", cf, sz, d, da, riva, civa, tc);
// g.right_just(3); c.right_just(3); s.right_just(6);
// _righe_rcaus.add_riga(numrig-1,"",g,c,s,sz,d,da,tc,riva,civa);
_righe_gia_presenti.set(numrig);
ok = _rel->next_match(LF_RCAUSALI);
}
}
bool CG0500_application::carica_descr(TMask& m)
{
TLocalisamfile& caus = *_rel->lfile();
TString tpd(caus.get("TIPODOC"));
int tpm = caus.get_int("TIPOMOV");
int m770 = caus.get_int("M770");
TString16 chiave; chiave << anno_iva() << caus.get("REG");
TTable reg("REG");
reg.put("CODTAB", chiave);
reg.read();
int tpr = reg.get_int("I0");
TSheet_field& cs = (TSheet_field&)m.field(F_SHEET_GCS);
compila_righe_rcaus(tpd,tpm,tpr,m770);
_items = _righe_rcaus.items();
cs.reset();
for (int i = 0; i < _items; i++)
{
TToken_string &riga = cs.row(i);
Riga_rcaus* r = (Riga_rcaus*)_righe_rcaus.objptr(i);
if (r != NULL) riga = *r;
else riga.cut(0);
}
cs.force_update();
return TRUE;
}
bool CG0500_application::fill_sheet(TMask& m)
{
TString tpd(m.get(F_TIPO_DOC));
int tpm = m.get_int(F_TIPO_MOV);
int tpr = m.get_int(F_TIPO_REG);
int m770 = m.get_int(F_M_770);
TSheet_field& cs = (TSheet_field&)m.field(F_SHEET_GCS);
int i;
/***************
int items=cs.items();
for (i = 0; i < items; i++)
{
TToken_string &riga = cs.row(i);
(Riga_rcaus&)_righe_rcaus[i] = riga;
}
********************/
compila_righe_rcaus(tpd,tpm,tpr,m770);
_items = _righe_rcaus.items();
cs.reset();
for (i = 0; i < _items; i++)
{
TToken_string &riga = cs.row(i);
Riga_rcaus* r = (Riga_rcaus*)_righe_rcaus.objptr(i);
if (r != NULL) riga = *r;
else riga.cut(0);
}
cs.force_update();
return TRUE;
}
void CG0500_application::togli_dal_file(const TString& cau)
{
long i;
TLocalisamfile *rcaus = _rel->lfile(LF_RCAUSALI);
long last = _righe_gia_presenti.last_one();
long start = _righe_gia_presenti.first_one();
for (i=start; i<=last; i++)
{
if (_righe_gia_presenti[i])
{
rcaus->zero();
rcaus->put(RCA_CODCAUS,cau);
rcaus->put(RCA_NRIGA, i);
rcaus->remove();
}
}
}
int CG0500_application::rewrite(const TMask& m)
{
const int tpm = m.get_int(F_TIPO_MOV);
const TString16 cau(m.get(F_COD_CAUS));
TString80 desc;
TString16 coddesc;
TLocalisamfile *rcaus = _rel->lfile(LF_RCAUSALI);
TLocalisamfile *caus = _rel->lfile(LF_CAUSALI);
m.autosave(_rel);
caus->put(CAU_TIPOMOV, tpm);
TSheet_field& cs = (TSheet_field&)m.field(F_SHEET_GCS);
// _items = _righe_rcaus.items();
_items = cs.items();
for (int i = 0; i < _items; i++)
{
TToken_string &riga = cs.row(i);
desc = riga.get(0);
const char tipo_cf = riga.get()[0];
const int g = riga.get_int();
const int c = riga.get_int();
long s = riga.get_long();
char sezione = riga.get()[0];
desc = riga.get();
coddesc = riga.get();
// NB spostato TIPOCF da terzultimo a secondo
if (g > 0 || c > 0 || s > 0L)
{
rcaus->zero();
rcaus->put (RCA_CODCAUS, (const char *)cau);
rcaus->put (RCA_NRIGA, i+1); // Numerare da uno!
// rcaus->put (RCA_NRIGA , i);
rcaus->put (RCA_GRUPPO , g);
rcaus->put (RCA_CONTO , c);
rcaus->put (RCA_SOTTOCONTO, s);
rcaus->put (RCA_SEZIONE, sezione);
rcaus->put (RCA_DESC , (const char *)desc);
rcaus->put (RCA_CODDESC, (const char *)coddesc);
rcaus->put (RCA_TIPOCF, tipo_cf);
if (_righe_gia_presenti[i+1])
{
rcaus->rewrite();
_righe_gia_presenti.reset(i+1);
}
else
rcaus->write();
}
}
togli_dal_file(cau);
// cs.reset();
// cs.force_update();
return _rel->rewrite();
}
int CG0500_application::write(const TMask& m)
{
const TString tpm(m.get(F_TIPO_MOV));
const TString cau(m.get(F_COD_CAUS));
TString desc_conto(30);
TString desc(50);
TString coddesc(3);
char tipo_cf;
TLocalisamfile *rcaus = _rel->lfile(LF_RCAUSALI);
TLocalisamfile *caus = _rel->lfile(LF_CAUSALI);
m.autosave(_rel);
caus->put(CAU_TIPOMOV, (const char*)tpm);
TSheet_field& cs = (TSheet_field&)m.field(F_SHEET_GCS);
// _items = _righe_rcaus.items();
_items = cs.items();
// NB spostato TIPOCF da terzultimo a secondo
for (int i = 0; i < _items; i++)
{
TToken_string &riga = cs.row(i);
desc_conto = riga.get(0);
tipo_cf = riga.get()[0];
const int g = riga.get_int();
const int c = riga.get_int();
long s = riga.get_long();
char sezione = riga.get()[0];
desc = riga.get();
coddesc = riga.get();
// NB spostato TIPOCF da terzultimo a secondo
if (g > 0 || c > 0 || s > 0L)
{
rcaus->zero();
rcaus->put (RCA_CODCAUS, (const char *)cau);
rcaus->put (RCA_NRIGA , i+1);
// rcaus->put (RCA_NRIGA , i);
rcaus->put (RCA_TIPOCF, tipo_cf);
rcaus->put (RCA_GRUPPO , g);
rcaus->put (RCA_CONTO , c);
rcaus->put (RCA_SOTTOCONTO, s);
rcaus->put (RCA_SEZIONE, sezione);
rcaus->put (RCA_DESC , (const char *)desc);
rcaus->put (RCA_CODDESC, (const char *)coddesc);
rcaus->write();
}
}
return _rel->write();
}
/*
int CG0500_application::cancella(long items)
{
TLocalisamfile * rcaus = _rel->lfile(LF_RCAUSALI);
const TString codcaus = _rel->lfile()->get(RCA_CODCAUS);
for (int i = 1; i <= items; i++)
{
rcaus->zero();
rcaus->put(RCA_CODCAUS, codcaus);
rcaus->put(RCA_NRIGA, i);
if (rcaus->read(_isequal, _lock) == NOERR)
rcaus->remove();
}
return rcaus->status();
}
*/
bool CG0500_application::remove()
{
const bool ok = TRelation_application::remove();
if (ok)
{
const TString cod(_rel->lfile()->get(RCA_CODCAUS));
TLocalisamfile& rcaus = *_rel->lfile(LF_RCAUSALI);
rcaus.zero();
rcaus.put(RCA_CODCAUS, cod);
int e = rcaus.read(_isgteq);
while (e == NOERR && rcaus.get(RCA_CODCAUS) == cod)
{
rcaus.remove();
e = rcaus.next();
}
}
return ok;
}
void CG0500_application::init_query_mode(TMask& m)
{
_righe_rcaus.destroy();
init_mask(m);
}
void CG0500_application::init_insert_mode(TMask& m)
{
init_mask(m);
}
void CG0500_application::init_modify_mode(TMask& m)
{
init_mask(m);
}
void CG0500_application::init_mask(TMask& m)
{
const TString tpd(m.get(F_TIPO_DOC));
const TString tpm(m.get(F_TIPO_MOV));
const TString codreg(m.get(F_COD_REG));
TSheet_field& cs = (TSheet_field&)m.field(F_SHEET_GCS);
// cs.reset();
// cs.force_update();
// F_TIPO_MOV e', nella maschera, un campo nascosto.
// Sono visibili nella maschera F_TIPO_MOV_1 oppure F_TIPO_MOV2,
// a seconda che F_TIPO_DOC sia compilato oppure no.
// All'inizio viene fatto l'output del campo TIPOMOV del file nel campo
// nascosto F_TIPO_MOV.
// Qui il contenuto di F_TIPO_MOV viene mandato a F_TIPO_MOV_1
// oppure F_TIPO_MOV_2.
if (tpd.empty())
m.set(F_TIPO_MOV_2, tpm);
else
m.set(F_TIPO_MOV_1, tpm);
// 27/06/94 Setto il campo nascosto F_ANNOES all'anno di liq. Iva
// preso dai par.ditta
const int anno = anno_iva();
m.set(F_ANNOES, anno);
// Setto il tipo reg e il flag corrisp nei campi nascosti della maschera
// perche non mi fa l'output su di essi quando carica i dati dal file
/*
TRegistro reg(codreg, anno);
const int tipo = reg.tipo();
m.set(F_TIPO_REG, tipo);
m.set(F_CORRISP, reg.corrisp());
*/
}
int CG0500_application::read(TMask& m)
{
m.autoload(_rel);
read_rcaus(m);
carica_descr(m);
return NOERR;
}
bool CG0500_application::user_create()
{
_rel = new TRelation (LF_CAUSALI);
_rel->add(LF_RCAUSALI, "CODCAUS=CODCAUS");
_msk = new TMask("cg0500a");
if (!salda_conto())
{
_msk->hide (F_MOV_SEZ);
_msk->hide (F_TIPO_MOV);
}
else
_msk->hide (F_COD_CAUS_IM);
if (!gestione_valuta()) _msk->hide (F_MOV_VALU);
_msk->set_handler(F_TIPO_DOC, tipodoc_hndl);
_msk->set_handler(F_TIPO_MOV_1, tipomov_hndl);
_msk->set_handler(F_TIPO_MOV_2, tipomov_hndl);
_msk->set_handler(F_COD_REG, cod_reg_hndl);
// _msk->set_handler(F_COD_CAUS_IM, codcausim_hndl);
// _msk->set_handler(F_M_770, m770_hndl);
//
// Handler del campo GRUPPO della maschera di edit dello sheet.
// Uso per abilitare il campo C/F per alcuni tipi di conti.
//
TSheet_field& cs = (TSheet_field&)_msk->field(F_SHEET_GCS);
cs.sheet_mask().set_handler(102, tipocf_hndl); // 102 e' il TIPOCF
// cs.sheet_mask().set_handler(104, conto_hndl); // ..conto se non vuoti
// mettono required dare/avere
cs.sheet_mask().set_handler(105, sottoconto_hndl); // 205 e' il sottoc. C/F
cs.sheet_mask().set_handler(205, sottoconto_hndl); // 205 e' il sottoc. C/F
cs.sheet_mask().set_handler(305, sottoconto_hndl); // 205 e' il sottoc. C/F
cs.set_notify(leggi_riga);
return TRUE;
}
bool CG0500_application::user_destroy()
{
delete _msk;
delete _rel;
return TRUE;
}
int cg0500(int argc, char* argv[])
{
CG0500_application a;
a.run(argc, argv, "Tabella causali");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink