campo-sirio/cg/cg5800.cpp

// Programma per la gestione e la stampa della dichiarazione periodica IVA
#include <applicat.h>
#include <automask.h>
#include <currency.h>
#include <form.h>
#include <prefix.h>
#include <recarray.h>
#include <rePRINT.h>
#include <sheet.h> 
#include <tabutil.h>

#include <nditte.h>

#include "cg5800.h"
#include "cglib03.h"

class TQuadro_VT_selfirm_mask : public TAutomask
{
  TArray_sheet * _ditte;
  TString_array  _nomiditte;
  int            _year;
  
protected:
  bool select_button();
  void build_nomiditte();
  void build_ditte_sheet();

public:
  const int get_year() const { return _year; }
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  TQuadro_VT_selfirm_mask();
  virtual ~TQuadro_VT_selfirm_mask();
};

TQuadro_VT_selfirm_mask::TQuadro_VT_selfirm_mask() : TAutomask("cg5800a")
{
  _ditte  = new TArray_sheet(-1, -1, -4, -4, TR("Selezione Ditte"),
                             HR("Cod.@5|Ragione Sociale@50"));  
  TDate oggi(TODAY);                    
  
  _year = oggi.year();

  build_nomiditte();
  build_ditte_sheet();                             
}

TQuadro_VT_selfirm_mask::~TQuadro_VT_selfirm_mask()
{
  delete _ditte;
}

void TQuadro_VT_selfirm_mask::build_nomiditte()
{                 
  TString cod;
	TRelation relditte(LF_NDITTE);
	TRectype & ditta = relditte.lfile().curr();
	TCursor cur(&relditte);
	const TRecnotype items = cur.items();

	cur.freeze();
  _nomiditte.destroy();
  for (cur = 0L; cur.pos() < items; ++cur)
  {     
		const long codditta = ditta.get_long("CODDITTA");
    bool good = prefix().exist(codditta);

    if (good) 
    {           
      TToken_string* d = new TToken_string(64);
      d->add(codditta);
      d->add(ditta.get("RAGSOC"));
      _nomiditte.add(d);  
    }
  }
}

void TQuadro_VT_selfirm_mask::build_ditte_sheet()
{
  _ditte->destroy();
  long prima = -1;
  
  for (int i = 0; i < _nomiditte.items(); i++)
  {
    TToken_string* d = new TToken_string(_nomiditte.row(i));
    const long pos = _ditte->add(d);     
    const char vers = d->get_char(2);
    const bool selectable = vers != '?';
    _ditte->enable_row(pos, selectable);
    if (selectable && prima < 0)
      _ditte->select(prima = pos);
  }     
}

bool TQuadro_VT_selfirm_mask::select_button()
{     
  if (_ditte->run() == K_ENTER)
  {
    TToken_string& row = _ditte->row(_ditte->selected()); 
    set(F_CODDITTA, row.get(0));
    set(F_RAGSOC, row.get(1));
    return TRUE;        
  }
  return FALSE;
}

bool TQuadro_VT_selfirm_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{                                                  
  switch (o.dlg())
  {
    case F_CODDITTA:
      if (e == fe_button)
        return select_button();
      
      if (e == fe_modify)
      {
        bool found = FALSE;
        TString16 ditta = o.get();
        for (int i = 0; i < _ditte->items(); i++)
        { 
          TToken_string& row = _ditte->row(i);
          if (ditta == row.get(0))
          { 
            if (_ditte->row_enabled(i))
            {
              set(F_CODDITTA, row.get(0));
              set(F_RAGSOC, row.get(1));
              found = TRUE;
            }
            else 
            { 
              warning_box(FR("Non sono definiti i parametri liquidazione per la ditta %ld"),
                          atol(ditta));
              o.reset(); 
            }
            break;
          }
        }
        if (!found)
          o.reset();
        return found;
      }
      break;
    case F_RAGSOC:
      if (e == fe_button)
        return select_button();
      if (e == fe_modify)
      {
        bool found = FALSE;
        TString16 ditta = o.get();
        for (int i = 0; i < _ditte->items(); i++)
        { 
          TToken_string& row = _ditte->row(i);
          TString ts(row.get(1));
          if (ts.find(ditta) != -1)
          { 
            if (_ditte->row_enabled(i))
            {
              set(F_CODDITTA, row.get(0));
              set(F_RAGSOC, row.get(1));
              found = TRUE;
              break;
            }
          }
        }
        if (!found) o.reset(); 
        return found;  
      }
      break;
    case F_YEAR:
      if (e == fe_modify)
      {
        _year = atoi(o.get());
        build_nomiditte();
        build_ditte_sheet();  
        set(F_CODDITTA, "");  
        set(F_RAGSOC, "");  
      }
      break;
     default:
      break;
  }
  
  return TRUE;
} 

class TQuadro_VT_iva_form : public TForm
{
public:
  TQuadro_VT_iva_form() : TForm("cg5800a") {};
  virtual ~TQuadro_VT_iva_form() {};
};
  
class TQuadro_VT_iva_mask : public TAutomask
{
  TQuadro_VT_selfirm_mask * _sf;

protected:
  void read_iva_data();

public:
  void set_prospect();
  void print_prospect();
  virtual bool on_key(KEY k) { return TAutomask::on_key(k);}
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
  TQuadro_VT_iva_mask(TQuadro_VT_selfirm_mask *m) : TAutomask("cg5800b")  {_sf = m;}
  virtual ~TQuadro_VT_iva_mask() {};
};

void TQuadro_VT_iva_mask::read_iva_data()
{
  TTable pem("PEM");
	real tprimp, tpriva, timp, tiva;
  TString16 key;

  key.format("%04d00", _sf->get_year());
	pem.put("CODTAB", key);
	int err = pem.read();
  

	if (err == NOERR)
	{
		set(F_TOTIVIMP, pem.get("R0"));
		set(F_TOTIVIVA, pem.get("R1"));
		timp += pem.get_real("R0");
		tiva += pem.get_real("R1");
	
		for (int codreg = 1;codreg < 23; codreg++)
		{
			key.format("%04d%02d", _sf->get_year(), codreg);
			pem.put("CODTAB", key);
			err = pem.read();

			if (err == NOERR)
			{
				set(F_REGIMP(codreg - 1), pem.get("R0"));
				set(F_REGIVA(codreg - 1), pem.get("R1"));
				tprimp += pem.get_real("R0");
				tpriva += pem.get_real("R1");
				timp += pem.get_real("R0");
				tiva += pem.get_real("R1");
			}
		}
		set(F_TOTIMP, timp);
		set(F_TOTIVA, tiva);
		set(F_TOTPRIMP, tprimp);
		set(F_TOTPRIVA, tpriva);
	}
	else
    error_box("Risultati liquidazione non presenti o da ricalcolare per l'anno %d.", _sf->get_year());

}

void TQuadro_VT_iva_mask::print_prospect()
{
  const int anno = _sf->get_int(F_YEAR);
  TQuadro_VT_iva_form frm;
  
  frm.find_field('B', odd_page, FF_YEAR).set(get(F_YEAR));
	frm.find_field('B', odd_page, FF_TOTIMP).set(get(F_TOTIMP));
	frm.find_field('B', odd_page, FF_TOTIVA).set(get(F_TOTIVA));
	frm.find_field('B', odd_page, FF_TOTPRIMP).set(get(F_TOTPRIMP));
	frm.find_field('B', odd_page, FF_TOTPRIVA).set(get(F_TOTPRIVA));
	frm.find_field('B', odd_page, FF_TOTIVIMP).set(get(F_TOTIVIMP));
	frm.find_field('B', odd_page, FF_TOTIVIVA).set(get(F_TOTIVIVA));

  for (int reg = 0; reg < 22; reg++)
	{
		frm.find_field('B', odd_page, FF_REGIMP(reg)).set(get(F_REGIMP(reg)));
		frm.find_field('B', odd_page, FF_REGIVA(reg)).set(get(F_REGIVA(reg)));
	}
		
	TRectype f(LF_NDITTE);  
  f.put(NDT_CODDITTA, get(F_CODDITTA));
  
  frm.cursor()->setregion(f,f);
  frm.print();
}

bool TQuadro_VT_iva_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{                                                  
  switch (o.dlg())
  {
     case DLG_PRELPR:
      if (e == fe_button)
			{
			  TReport_book book;
		    TReport rep;
				
				if (rep.load("cg5800ra.rep"))
				{
					TRecordset * r = rep.recordset();

					if (r != NULL)
					{
						TVariant var;

						var = get(F_YEAR);
						r->set_var("#ANNO", var);
					}
					book.add(rep);
					if (book.pages() > 0)
						book.print_or_preview();
				}
			}
    default:
      break;
  }
  
  return TRUE;
} 

void TQuadro_VT_iva_mask::set_prospect()
{
  CHECK(_sf, "Invalid mask");
  
  const int anno = _sf->get_year();
  const long ditta = _sf->get_long(F_CODDITTA);
  
  set(F_YEAR, anno);
  set(F_CODDITTA, ditta);
  set(F_RAGSOC, _sf->get(F_RAGSOC));
  
  TFirm frm(ditta);
  
  TIva_round ir;
  ir.set_default_iva_mode(anno, FALSE, ditta);
  
  read_iva_data();
}

class TQuadro_VT_iva_app : public TSkeleton_application
{
protected:
  virtual bool create(); 
  virtual bool destroy(); 
  virtual void main_loop();
public:
  virtual bool firm_change_enabled() const { return FALSE; }
  TQuadro_VT_iva_app  () {};
  virtual ~TQuadro_VT_iva_app  () {};
};

bool TQuadro_VT_iva_app::create()
{ 
  open_files(LF_TAB, LF_TABCOM, LF_NDITTE, 0);
  return TSkeleton_application::create();
}

bool TQuadro_VT_iva_app::destroy()
{
  return TSkeleton_application::destroy();
}

void TQuadro_VT_iva_app::main_loop()
{
  const long ditta = get_firm();
 
  TQuadro_VT_selfirm_mask* m1 = new TQuadro_VT_selfirm_mask();
  while (m1->run() != K_QUIT)
  {
    if (m1->get(F_CODDITTA).empty() || m1->get(F_RAGSOC).empty())  
    { 
      error_box(TR("Selezionare una ditta"));
      continue;
    }
    
    set_firm(m1->get_long(F_CODDITTA));

    TQuadro_VT_iva_mask* m2 = new TQuadro_VT_iva_mask(m1);
    m2->reset();
    m2->enable_default();
    m2->set_prospect();
    if (m2->run() == K_ENTER)
      m2->print_prospect();
    delete m2;  
  }
  delete m1;  

  set_firm(ditta);
}

int cg5800(int argc, char* argv[])
{
  TQuadro_VT_iva_app a;
  a.run(argc, argv, TR("Quadro VT"));
  return 0;
}