campo-sirio/cg/cg0500.cpp

// 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"

#define SS_TIPOCF 102           
#define SS_GRUPPO 103
#define SS_CONTO  104

////////////////////////////////////////////////////////////////////////////
// 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, char tipocf,
                char  sezione, const char * des, const char * desagg,
                bool rigaiva, const char * codiva, TConto& tc );
  void clear(int riga); // pulisce una riga in seguito ad Azzera
  void ClearDescr();    // cancella solo le descrizioni fisse
  void CaricaRigheLibere();
  void CausaleIncassoPagamento();
  void CausaleRitenutaOccas ();
  void CausaleVendite ();
  void CausaleAcquisti();
  TRighe_rcaus() : TArray(20) {}
};

void TRighe_rcaus::ClearDescr() 
{                             
  for (int i=0; i < items(); i++)
  {
    Riga_rcaus *r = (Riga_rcaus*)objptr(i);
    
    if (r) r->add("", 0);
  }
}

void TRighe_rcaus::clear(int row) 
{
  Riga_rcaus *r = (Riga_rcaus*)objptr(row);
  
  if (r)
  {
    r->add("", 1);
    r->add(0, 2); 
    r->add(0, 3);
    r->add(0L, 4);
    r->add("", 5);
    r->add("", 6);
    r->add("", 7);
    r->add("", 8);
    r->add("", 9);  
  }
}

void TRighe_rcaus::add_riga(int i, char tipocf, 
                            char sez, const char * des, const char * desagg, bool rigaiva,
                            const char * codiva, TConto& tc)
{
  Riga_rcaus *r = (Riga_rcaus*)objptr(i);
  int g=0,c=0;
  long s=0L;

  if (r == NULL)
  {
    r = new Riga_rcaus (tc,"",tipocf,sez,des,desagg,rigaiva,codiva);
    add(r,i);             // ???
  } 

  g = tc.gruppo();
  c = tc.conto();
  s = tc.sottoconto();
  r->add(tipocf, 1);
  r->add((long)g, 2);
  r->add((long)c, 3);
  r->add((long)s, 4);
  r->add(sez, 5);
  r->add(des, 6);
  r->add(desagg, 7);
  r->add(rigaiva ? "X" : "", 8);
  r->add(codiva, 9);
}

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);

typedef enum { acquisto, vendita, incasso_pagamento, 
               ritenuta_occas, incasso_pagamento_gesval } tipo_descr;

               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 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 conto_hndl (TMask_field& f, KEY k);
  static bool sottoconto_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;

  TBit_array                            _righe_gia_presenti;
  
  void togli_dal_file(const TString&);

  void   read_rcaus(TMask&);
  bool   descr2array(TMask&);
  bool   descr2array2(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)   { return _msk; }
  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);
  int re_write (const TMask& m, bool rewrite=FALSE);
  virtual int read(TMask& m);
  //  int cancella(long items);

public:
  TRighe_rcaus  _righe_rcaus; // Array delle descrizioni delle righe
  tipo_descr    _tipo_des;        // Il tipo di causale corrente
  int _riga;                  // Riga corrente dello sheet (set_notify)

  void compilaarray (const TString&, int, int, int);
  void array2sheet();         // Copia le descrizioni dall'array allo sheet

  TMask * main_mask() const { return _msk; }
  TMask & ss_mask() const  { return ss().sheet_mask(); }
  TSheet_field& ss() const { return (TSheet_field&)_msk->field(F_SHEET_GCS);}

  CG0500_application() {}
};

HIDDEN CG0500_application * app() { return (CG0500_application*) MainApp(); }

// Per sapere su che riga sono dello spreadsheet. v. set_notify piu' sotto
// e per pulire la sezione Dare/avere in caso di riga azzerata
bool CG0500_application::leggi_riga(int r, KEY k)
{
  if (k == K_SPACE) app()->_riga = r;

  if (k == K_ENTER)
  {
    TToken_string &riga = app()->ss().row(r);
    int g  = riga.get_int(3); 
    int c  = riga.get_int(4); 
    long s = riga.get_long(5); 
    if (g == 0 && c == 0 && s == 0L)  // riga azzerata  
    {
      riga.add("", 1);  // pulisco tipo C/F
      riga.add("", 5);  // pulisco Dare/Avere
      app()->_righe_rcaus.clear(r);  // pulisco la riga anche nell'array
      app()->ss().force_update(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)
      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;
}


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 della maschera principale
////////////////////////////////////////////////////////////////////////////
bool CG0500_application::tipodoc_hndl (TMask_field& f, KEY k)
{
  //  if (k == K_TAB)
  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() && val != "IN" && val != "PG" && val != "AN")
    {
      f.mask().show(F_OP_FINE_ANNO);
      f.mask().show(F_M_770);   
      f.mask().hide(F_TIPO_MOV_2);      
      f.mask().show(F_TIPO_MOV_1);
      f.mask().enable(F_COD_REG);
      field_reg.check_type(CHECK_REQUIRED);

      // Cambio il filtro sui registri 
      // con tipo=1  
      if (val == "FV" || val == "FF" || val == "FS")
      {
        app()->_filtro = 1;
        field_reg.browse()->cursor()->set_filterfunction(filtra_reg);
      }

      // 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);
      }

    }
    else         // TIPODOC vuoto || IN || PG || AN
    {
      // Devo poter rivedere tutti i registri se ho cancellato il campo TIPODOC
      field_reg.check_type(CHECK_NORMAL);

      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);      
      
      if ( !salda_conto() || tpm == 0 )
      {
        f.mask().show(F_OP_FINE_ANNO);
        f.mask().show(F_M_770);
      } 
      else
      {
        f.mask().hide(F_OP_FINE_ANNO);
        f.mask().hide(F_M_770);
      } 
    }
    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;
}

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);
    const TString16 codreg = f.mask().get(F_COD_REG);
    
    if (tpd.not_empty() && tpd != "AN" && tpd != "PG" && tpd != "IN")
    {
      if (codreg.empty()) ok = FALSE;
    }
    else
    {
      // con tipo=1
      if (tpd == "FV" || tpd == "FS" || tpd == "FS")
      {
        if (tipo != 1) 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; 
   } 
   */

////////////////////////////////////////////////////////////////////////////
// Handler della maschera dello spreadsheet
////////////////////////////////////////////////////////////////////////////
// Se specifico il conto deve essere non vuoto il gruppo
bool CG0500_application::conto_hndl (TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    int io = f.dlg();
    int c = f.mask().get_int(io);
    int g = f.mask().get_int(io - 1); 

    if (c > 0)
      if (g == 0)
        return f.warning_box("Non accetto un conto senza gruppo");
  }
  // Controllo: << solo la riga 1 o 7 possono essere C/F >>
  if (k == K_ENTER)
  {
    char scarta    = '\0';
    int ultima     = 8;
    char cf        = f.mask().get(SS_TIPOCF)[0];
    TMask_field& cfld = f.mask().field(SS_TIPOCF);
    const int tpr  = app()->main_mask()->get_int(F_TIPO_REG);  

    switch (tpr)
    {
    case 1:
      scarta = 'F';
      break;
    case 2: 
      scarta = 'C';
      break;
    case 0:
      scarta = 'Z';    // Accetto tutto
      switch (app()->_tipo_des)
      {
      case incasso_pagamento:
        ultima = 11;
        break;
      case incasso_pagamento_gesval:
        ultima = 12;
        break;
      default:
        break;
      } 
    }
    if (app()->_riga > ultima)     // se sono nelle righe libere accetto tutto
      return TRUE;                           
    else
      if (app()->_riga == 0 || app()->_riga == 6)
      {
        if (cf == scarta)
          return cfld.warning_box(
            "Impossibile inserire un %s con registro di tipo %s nella riga %d", 
            cf == 'C' ? "cliente" : "fornitore", 
            tpr == 1 ? "vendite" : "acquisti", app()->_riga+1);
      }
      else
        if (cf != '\0')
          return cfld.warning_box(
            "Impossibile inserire un %s con registro di tipo %s nella riga %d", 
            cf == 'C' ? "cliente" : "fornitore",
            tpr == 1 ? "vendite" : "acquisti", app()->_riga+1);                 
  }
  return TRUE;
}

// Se specifico il sottoconto devono essere non vuoti gruppo e conto
bool CG0500_application::sottoconto_hndl (TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    int io = f.dlg();
    int s = f.mask().get_int(io);
    int g = f.mask().get_int(SS_GRUPPO); 
    int c = f.mask().get_int(SS_CONTO); 

    if (s > 0)
      if (g == 0 || c == 0)
        return f.warning_box("Non accetto un sottoconto con gruppo o conto vuoti");
  }
  return TRUE;
}

// Handler del campo tipocf ? della maschera di edit dello sheet
// Abilita 109 e 110 (rigaiva e codiva) SOLO SE registro 1 o 2
// Controlla all'uscita che il tipo C/F vada bene per la riga corrente
// in questo modo:
// se tpr==1 NON accetta nelle righe 1 o 7 il tipo F
// se tpr==2 NON accetta nelle righe 1 o 7 il tipo C
// nelle righe sopra la 10 sono libero
//
bool CG0500_application::tipocf_hndl (TMask_field& f, KEY k)
{
  if (k == K_SPACE)
  {
    TString16 cf(f.get());
    const int tpr = app()->main_mask()->get_int(F_TIPO_REG);  
    if (tpr == 1 || tpr == 2)
    {
      f.mask().enable(109); f.mask().enable(110);         
    }
    else 
    {
      f.mask().disable(109); f.mask().disable(110);
    }
  }
  return TRUE;  
}

////////////////////////////////////////////////////////////////////////////
// Funzioni che caricano le varie descrizioni fisse
////////////////////////////////////////////////////////////////////////////
void TRighe_rcaus::CausaleVendite()
{
  int i=0;
  TConto tc();
  app()->_tipo_des = vendita;
  //  set_descr(i++, "C Clienti", 'C');
  set_descr(i++, "C Clienti");   // Lascio scelta libera
  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.");
  CaricaRigheLibere();
}


void TRighe_rcaus::CausaleAcquisti()
{
  int i=0;
  app()->_tipo_des = acquisto;
  //  set_descr( i++, "C Fornitori", 'F');
  set_descr( i++, "C Fornitori", ' ');
  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.", ' ');
  CaricaRigheLibere();
}

void TRighe_rcaus::CausaleRitenutaOccas()
{
  int i=0;
  app()->_tipo_des = ritenuta_occas;
  set_descr (i++, "Costo");
  set_descr (i++, "Cassa/banca");
  set_descr (i++, "Erario");
  CaricaRigheLibere();
}

void TRighe_rcaus::CaricaRigheLibere()
{
  for (int i = items(); i < 20; i++)
    set_descr(i);
}

void TRighe_rcaus::CausaleIncassoPagamento()
{
  int i=0;
  app()->_tipo_des = incasso_pagamento;
  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");
    app()->_tipo_des = incasso_pagamento_gesval;
  }
  CaricaRigheLibere();
}

void CG0500_application::compilaarray(const TString& tpd, int tpm, int tpr, int m770)
{
  if (tpd.empty() || tpd == "IN" || tpd == "AN" || tpd == "PG")
  {
    if ( tpm == 3 || tpm == 5 || tpm == 6 )
      _righe_rcaus.CausaleIncassoPagamento();  
    else
    {
      if ( !salda_conto() || tpm == 0 )
        if (m770 == 6) 
        {
          _righe_rcaus.CausaleRitenutaOccas();  
          return;
        }
      _righe_rcaus.ClearDescr();
      _righe_rcaus.CaricaRigheLibere();  
    }
  }
  else
  {
    if (tpr == 1)
      _righe_rcaus.CausaleVendite();  
    else
      if (tpr == 2)
        _righe_rcaus.CausaleAcquisti();  
      else
      {
        _righe_rcaus.ClearDescr();
        _righe_rcaus.CaricaRigheLibere();  
      }
  }
}

bool CG0500_application::fill_sheet(TMask& m)
{
  descr2array2(m);
  array2sheet();
  return TRUE;
}

int CG0500_application::read(TMask& m)
{
  m.autoload(_rel);
  descr2array(m);
  array2sheet();
  read_rcaus(m);
  return NOERR;
}

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);
  TSheet_field& cs = ss();

  _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);
    TToken_string & riga = cs.row(numrig-1);
    riga.add(cf, 1); riga.add(g, 2); riga.add(c, 3); riga.add(s,4);
    riga.add(sz, 5); riga.add(d, 6); riga.add(da,7);
    riga.add(riva ? "X" : "", 8);
    riga.add(civa, 9);

    //    _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);
  }
}

// ricopio l'array Righe_rcaus nello sheet
void CG0500_application::array2sheet()
{
  char _dfi [30];
  TFixed_string dfi(_dfi,30);
  _items = _righe_rcaus.items();
  //  ss().reset();
  for (int i = 0; i < _items; i++)
  {
    TToken_string & riga = ss().row(i);
    //    Riga_rcaus    * r    = (Riga_rcaus*)_righe_rcaus.objptr(i);
    TToken_string   * r    = (TToken_string*)_righe_rcaus.objptr(i);    
    if (r != NULL) 
    {
      dfi = r->get(0);
      riga.add(dfi,0);
    }
    else 
      riga.cut(0);
  }
  ss().force_update();
}

bool CG0500_application::descr2array2(TMask& m)
{              
  TLocalisamfile& caus = *_rel->lfile();
  TString16 tpd, codreg;
  int       tpm, m770, tpr;
  
  codreg = m.field(F_COD_REG).get();
  tpd    = m.field(F_TIPO_DOC).get();
  tpm    = m.get_int(F_TIPO_MOV);
  m770   = m.get_int(F_M_770);    
  /*      
     TString16 chiave; chiave << anno_iva() << codreg;      
     TTable reg("REG");
     reg.put("CODTAB", chiave);
     reg.read();
     tpr = reg.get_int("I0");
     */
  tpr    = m.get_int(F_TIPO_REG);  
  // carico le descrizioni fisse nell'array Righe_rcaus  
  compilaarray(tpd,tpm,tpr,m770);

  return TRUE;
}

bool CG0500_application::descr2array(TMask& m)
{              
  TLocalisamfile& caus = *_rel->lfile();
  TString16 tpd, codreg;
  int       tpm, m770;
  
  if (m.mode() == MODE_MOD)
  {
    codreg = caus.get("REG");
    tpd    = caus.get("TIPODOC");
    tpm    = caus.get_int("TIPOMOV");
    m770   = caus.get_int("M770");
  }
  else 
  {
    codreg = m.field(F_COD_REG).get();
    tpd    = m.field(F_TIPO_DOC).get();
    tpm    = m.get_int(F_TIPO_MOV);
    m770   = m.get_int(F_M_770);    
  }
  
  TString16 chiave; chiave << anno_iva() << codreg;      
  TTable reg("REG");
  reg.put("CODTAB", chiave);
  reg.read();
  int tpr = reg.get_int("I0");

  // carico le descrizioni fisse nell'array Righe_rcaus  
  compilaarray(tpd,tpm,tpr,m770);

  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::write(const TMask& m)
{
  return re_write(m, FALSE);
}

int CG0500_application::rewrite(const TMask& m)
{
  return re_write(m, TRUE);
}

int CG0500_application::re_write(const TMask& m,bool rewrite)
{
  const TString16 cau(m.get(F_COD_CAUS));
  TString80 desc;
  TString16 coddesc;
  TLocalisamfile *rcaus = _rel->lfile(LF_RCAUSALI);

  m.autosave(_rel);

  TSheet_field& cs = ss();
  //  _items = _righe_rcaus.items();
  _items = cs.items();

  for (int i = 0; i < _items; i++)
  {
    TToken_string &riga = cs.row(i);
    if (riga.empty_items()) 
      continue;
    
    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_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 (rewrite)
      {
        if (_righe_gia_presenti[i+1]) // bitarray delle righe lette da file all'inizio
        {
          rcaus->rewrite();
          _righe_gia_presenti.reset(i+1);
        }
else
  rcaus->write();
      }
else
  rcaus->write();
    }
  } 
  
  if (rewrite)
  {
    togli_dal_file(cau);  // Elimina dal file le righe rimaste nel bitarray
    return _rel->rewrite();
  }
  else
    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();
  ss().reset();
  init_mask(m);
}

void CG0500_application::init_insert_mode(TMask& m)
{
  ss().reset();
  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));
  
  // 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() || tpd == "IN" || tpd == "AN" || tpd == "PG")
  {
    m.hide(F_TIPO_MOV_1);
    m.set(F_TIPO_MOV_2, tpm);
    m.show(F_TIPO_MOV_2);    
  }
  else
  {
    m.hide(F_TIPO_MOV_2);  
    m.set(F_TIPO_MOV_1, tpm);
    m.show(F_TIPO_MOV_1);        
  }
  // 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()); 
     */
}


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_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 = ss();
  cs.set_notify(leggi_riga);
  
  cs.sheet_mask().set_handler(102, tipocf_hndl);  // 102 e' il TIPOCF
  cs.sheet_mask().set_handler(105, sottoconto_hndl);  
  cs.sheet_mask().set_handler(205, sottoconto_hndl); 
  cs.sheet_mask().set_handler(305, sottoconto_hndl);
  cs.sheet_mask().set_handler(104, conto_hndl);
  
  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;
}