#include <defmask.h>

#include "pd6342400a.h"
#include "../ca/calib01.h"
#include "../ca/movana.h"
#include "../ca/rmovana.h"
#include "../ve/velib.h"

static int sort_by_numreg(TSheet_field& sheet, int r1, int r2)
{
  TToken_string& row1 = sheet.row(r1);
  TToken_string& row2 = sheet.row(r2);

  const long numreg1 = row1.get_long(sheet.cid2index(Q_NUMREG));
  const long numreg2 = row2.get_long(sheet.cid2index(Q_NUMREG));

  int dif = numreg1 - numreg2;

  if (dif == 0)
  {
    const int numriga1 = row1.get_int(sheet.cid2index(Q_NUMRIGA));
    const int numriga2 = row2.get_int(sheet.cid2index(Q_NUMRIGA));

    dif = numriga2 - numriga1;
  }
  
  return dif;
}

///////////////////////////////////////////////////////////
// TQuadra_movana_msk
///////////////////////////////////////////////////////////

class TQuadra_movana_msk: public TAutomask
{
  short _scdc_sid,   _scdc_lid;
	short _scms_sid,   _scms_lid;
	short _sfase_sid,  _sfase_lid;
  short _sconto_sid, _sconto_lid;

protected:
  void costruisci_sheet(TSheet_field& s, const short dlg);
	void get_row_anal_fields(TToken_string& row, TString& cdc, TString& cms, TString& fase, TString& codconto, const short sdlg);
	void put_row_anal_fields(TToken_string& row, const TString& cdc, const TString& cms, const TString& fase, const TString& codconto, const short sdlg);
  void get_conto(TString& conto);

  void calcola_totale(TSheet_field& sheet);

  void riempi_sheets();
  
  void crea_riga_quadratura();

  void registra();

  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
public:
	TQuadra_movana_msk();
};

void TQuadra_movana_msk::costruisci_sheet(TSheet_field& s, const short dlg)
{
  const TMultilevel_code_info& fasinfo = ca_multilevel_code_info(LF_FASI);
	TConfig& ini = ca_config();
	TMask& sm = s.sheet_mask();
	int sy = 3;
  short sdlg = dlg;

	_scdc_sid = _scdc_lid =	_scms_sid = _scms_lid =	_sfase_sid = _sfase_lid = _sconto_sid = _sconto_lid = -1;

	for (int i = 0; i < 2; i++)
  {
    const TString& level = ini.get("Level", NULL, i+1);  // Legge il livello 1 o 2

		if (level == "CDC")                                  // Crea centro di costo 
    {
      if (fasinfo.parent() == LF_CDC)
			{
				int h = ca_multilevel_code_info(LF_CDC).levels();
        const int sh = ca_create_fields_compact(sm, 0, LF_FASI, 2, sy, sdlg, sdlg + 50);
				sy += 2;
				_scdc_sid = sdlg;
				_scdc_lid = sdlg + h - 1;
				_sfase_sid = _scdc_lid + 1;
				_sfase_lid = sdlg + sh - 1;
				sdlg += sh;
      }
			else
			{
				const int sh = ca_create_fields_compact(sm, 0, LF_CDC, 2, sy++, sdlg, sdlg + 50);
				_scdc_sid = sdlg;
				_scdc_lid = sdlg + sh - 1;
				sdlg += sh;
			}
    }
	  else
		  if (level == "CMS")                                   // Crea commessa
		  {
		    if (fasinfo.parent() == LF_COMMESSE)
			  {
				  int h = ca_multilevel_code_info(LF_COMMESSE).levels();
          const int sh = ca_create_fields_compact(sm, 0, LF_FASI, 2, sy, sdlg, sdlg + 50);
	  			sy += 2;
		  		_scms_sid = sdlg;
			  	_scms_lid = sdlg + h - 1;
				  _sfase_sid = _scms_lid + 1;
  				_sfase_lid = sdlg + sh - 1;
	  			sdlg += sh;
		  	}
			  else
  			{
	  			const int sh = ca_create_fields_compact(sm, 0, LF_COMMESSE, 2, sy++, sdlg, sdlg + 50);
		  		_scms_sid = sdlg;
			  	_scms_lid = sdlg + sh - 1;
				  sdlg += sh;
  			}
	  	}
  }
  if (fasinfo.levels() > 0 && fasinfo.parent() <= 0)
	{
    const int sh = ca_create_fields_compact(sm, 0, LF_FASI, 2, sy++, sdlg, sdlg + 50);
		_sfase_sid = sdlg;
		_sfase_lid = sdlg + sh - 1;
		sdlg += sh;
	}

  const bool use_pdcc = ini.get_bool("UsePdcc");
	const int logicnum = use_pdcc ? LF_PCON : LF_PCONANA;
	const int nfields = ca_create_fields_compact(sm, 0, logicnum, 2, sy++, sdlg, sdlg + 50);
  _sconto_sid = sdlg;
  _sconto_lid = sdlg + nfields - 1;
	sdlg += nfields;

  for (short id = NQ_CONT4 + 100; id >= NQ_CDC1 + 100; id--)
  {
    const int pos = sm.id2pos(id);
    if (pos >= 0)
    {
      TMask_field& f = sm.fld(pos);
      const int size = f.size();
      const TString prompt = ((TEditable_field &)f).get_warning();
      s.set_column_header(id, prompt);
      s.set_column_justify(id, f.is_kind_of(CLASS_REAL_FIELD));
      s.set_column_width(id, (max(3+size, prompt.len()+1)) * CHARX);
			s.enable_column(id);
    }
    else
      s.delete_column(id);
  }
}

void TQuadra_movana_msk::get_row_anal_fields(TToken_string& row, TString& cdc, TString& cms, TString& fase, TString& codconto, const short sdlg)
{
	TSheet_field& sheet = sfield(sdlg);
  TMask& m = sheet.sheet_mask();
	TString val;

	cdc.cut(0);
	if (_scdc_sid >= 0)
		for ( short id = _scdc_sid; id <= _scdc_lid; id++)
		{
      val = row.get(sheet.cid2index(id));
			val.rpad(m.field(id).size());
			cdc << val;
		}
	cdc.trim();
	cms.cut(0);
	if (_scms_sid >= 0)
		for ( short id = _scms_sid; id <= _scms_lid; id++)
		{
			val = row.get(sheet.cid2index(id));
			val.rpad(m.field(id).size());
			cms << val;
		}
	cms.trim();
	fase.cut(0);
	if (_sfase_sid >= 0)
		for ( short id = _sfase_sid; id <= _sfase_lid; id++)
		{
			val = row.get(sheet.cid2index(id));
			val.rpad(m.field(id).size());
			fase << val;
		}
	fase.trim();

  if (_sconto_sid >= 0)
		for ( short id = _sconto_sid; id <= _sconto_lid; id++)
		{
			val = row.get(sheet.cid2index(id));
			val.rpad(m.field(id).size());
			codconto << val;
		}
	codconto.trim();
}

void TQuadra_movana_msk::put_row_anal_fields(TToken_string& row, const TString& cdc, const TString& cms, const TString& fase, const TString& codconto, const short sdlg)
{
	TSheet_field& s = sfield(sdlg);
	TMask& m = s.sheet_mask();
	int pos = 0;

	if (_scdc_sid >= 0)
		for (short id = _scdc_sid; id <= _scdc_lid; id++)
		{
			const int len = m.field(id).size();
			row.add(cdc.mid(pos, len), s.cid2index(id));
			pos += len;
		}
	pos = 0;
	if (_scms_sid >= 0)
		for (short id = _scms_sid; id <= _scms_lid; id++)
		{
			const int len = m.field(id).size();
			row.add(cms.mid(pos, len), s.cid2index(id));
			pos += len;
		}
	pos = 0;
	if (_sfase_sid >= 0)
		for (short id = _sfase_sid; id <= _sfase_lid; id++)
		{
			const int len = m.field(id).size();
			row.add(fase.mid(pos, len), s.cid2index(id));
			pos += len;
		}

  pos = 0;
	for (short id = _sconto_sid; id <= _sconto_lid; id++)
	{
		const int len = m.field(id).size();
		row.add(codconto.mid(pos, len), s.cid2index(id));
		pos += len;
	}
}

void TQuadra_movana_msk::get_conto(TString& conto)
{
  for (int i = 0; id2pos(F_CDC1 + i) > 0; i++)
	  conto << get(F_CDC1 + i);
}

void TQuadra_movana_msk::calcola_totale(TSheet_field& sheet)
{
  TImporto totale;
  TImporto imp;
  FOR_EACH_SHEET_ROW(sheet, r, riga)
  {
    TToken_string& row = *(TToken_string*)riga;
    imp = row;
    totale += imp;
  }
  totale.normalize('A');
  set(F_TOTRIGHE, totale.valore());
}

void TQuadra_movana_msk::riempi_sheets()
{
  const TDate    dadata   = get_date(F_DADATA);
  const TDate    adata    = get_date(F_ADATA);

  const long     numregcg = get_int(F_NUMREGCG);
  const real     totdoc   = get_real(F_TOTDOC);

  TConfig* conf = new TConfig("pd6342conf.ini", "MAIN");
  const TString4 codcau = conf->get("CodCau");
  
  TSheet_field& ls = sfield(F_MOVNNQUAD);
  TSheet_field& rs = sfield(F_MOVQUAD);

  TString query;
  query << "USE MOVANA KEY 2\n"
        << "SELECT (CODCAUS=\"" << codcau << "\")&&(TRASFERITO=\"X\")\n"
        << "FROM DATACOMP=#DADATA\n"
        << "TO DATACOMP=#ADATA\n";

  TISAM_recordset movana(query);
  movana.set_var("#DADATA", dadata);
  movana.set_var("#ADATA",  adata);

  for(bool ok = movana.move_first(); ok;  ok = movana.move_next())
  {
    TAnal_mov amov(movana.cursor()->curr());
    const TRecord_array& righe = amov.body();

    const int nrows = amov.body().rows();
		for (int r = 1; r <= nrows; r++)
		{
			const TRectype& row = amov.body().row(r);

      const char      sezione     = row.get_char(RMOVANA_SEZIONE);
      const real      importo     = row.get_real(RMOVANA_IMPORTO);
      const TString80 descrizione = row.get(RMOVANA_DESCR);
      const TString80 codcosto    = row.get(RMOVANA_CODCCOSTO);
      const TString80 codcms      = row.get(RMOVANA_CODCMS);
      const TString16 codfase     = row.get(RMOVANA_CODFASE);
      const TString80 codconto    = row.get(RMOVANA_CODCONTO);
      const long      numreg      = row.get_long(RMOVANA_NUMREG);
      const int       numriga     = row.get_int(RMOVANA_NUMRIG);
      const TDate     datacomp    = row.get_date(RMOVANA_DATACOMP);

      TToken_string& lrow = ls.row(-1);
      lrow.add(importo.string(), ls.cid2index(sezione == 'D' ? NQ_DARE : NQ_AVERE));
      lrow.add(descrizione,      ls.cid2index(NQ_DESCR));
      lrow.add(numreg,           ls.cid2index(NQ_NUMREG));
      lrow.add(numriga,          ls.cid2index(NQ_NUMRIGA));
      lrow.add(datacomp,         ls.cid2index(NQ_DATACOMP));
      put_row_anal_fields(lrow, codcosto, codcms, codfase, codconto, F_MOVNNQUAD);
    }
  }

  query.cut(0);
  query << "USE MOVANA KEY 3\n"
        << "FROM NUMREGCG=" << numregcg << "\n"
        << "TO NUMREGCG="   << numregcg << "\n";

  TISAM_recordset movanaquad(query);

  for(bool ok = movanaquad.move_first(); ok;  ok = movanaquad.move_next())
  {
    TAnal_mov amov(movanaquad.cursor()->curr());
    
    const int nrows = amov.rows();
		for (int r = 1; r <= nrows; r++)
		{
			const TRectype& row = amov.body().row(r);

      const char      sezione     = row.get_char(RMOVANA_SEZIONE);
      const real      importo     = row.get_real(RMOVANA_IMPORTO);
      const TString80 descrizione = row.get(RMOVANA_DESCR);
      const TString80 codcosto    = row.get(RMOVANA_CODCCOSTO);
      const TString80 codcms      = row.get(RMOVANA_CODCMS);
      const TString16 codfase     = row.get(RMOVANA_CODFASE);
      const TString80 codconto    = row.get(RMOVANA_CODCONTO);
      const long      numreg      = row.get_long(RMOVANA_NUMREG);
      const int       numriga     = row.get_int(RMOVANA_NUMRIG);
      const TDate     datacomp    = row.get_date(RMOVANA_DATACOMP);

      TToken_string& rrow = rs.row(-1);
      rrow.add(importo.string(), rs.cid2index(sezione == 'D' ? Q_DARE : Q_AVERE));
      rrow.add(descrizione,      rs.cid2index(Q_DESCR));
      rrow.add(numreg,           rs.cid2index(Q_NUMREG));
      rrow.add(numriga,          rs.cid2index(Q_NUMRIGA));
      rrow.add(datacomp,         rs.cid2index(Q_DATACOMP));
      put_row_anal_fields(rrow, codcosto, codcms, codfase, codconto, F_MOVQUAD);

      if(descrizione == "Riga di quadratura")
        rs.disable_row(r - 1);
    }
  }
  
  ls.force_update();
  rs.force_update();
  calcola_totale(rs);
}

void TQuadra_movana_msk::crea_riga_quadratura()
{
  TSheet_field& rs = sfield(F_MOVQUAD);
  FOR_EACH_SHEET_ROW_BACK(rs, r, riga)
  {
    TToken_string& row = *(TToken_string*)riga;
    const TString80 descrizione = row.get(rs.cid2index(Q_DESCR));

    if(descrizione == "Riga di quadratura")
    {
      rs.destroy(r);
      break;
    }
  }

  calcola_totale(rs);
  
  TString80 conto;
  get_conto(conto);

  const real totale   = get_real(F_TOTDOC);
  const real totrighe = get_real(F_TOTRIGHE);

  TImporto impquad('A', totale - totrighe);
  impquad.normalize();

  const char      sezione     = impquad.sezione();
  const real      importo     = impquad.valore();
  const TString80 descrizione = "Riga di quadratura";
  const TDate     datacomp(TODAY);

  TToken_string& rrow = rs.row(-1);
  rrow.add(importo.string(), rs.cid2index(sezione == 'D' ? Q_DARE : Q_AVERE));
  rrow.add(descrizione,      rs.cid2index(Q_DESCR));
  rrow.add(datacomp,         rs.cid2index(Q_DATACOMP));

  const TString16 cdc = "";
  const TString16 cms = "";
  const TString16 fase = "";

  put_row_anal_fields(rrow, cdc, cms, fase, conto, F_MOVQUAD);

  rs.force_update();
  calcola_totale(rs);
}

TQuadra_movana_msk::TQuadra_movana_msk() : TAutomask("pd6342400a")
{
  disable(DLG_CERCA);

  const TDate data(TODAY);
  const TDate primo(1, 1, data.year());
  set(F_DADATA, primo);

  TConfig& cfg = ca_config();
	const bool use_pdcc = cfg.get_bool("UsePdcc");

	const int logicnum = use_pdcc ? LF_PCON : LF_PCONANA;
	const int nfields = ca_create_fields_compact(*this, 0, logicnum, 2, 6, F_CDC1, F_CDC1 + 50);

	for (int i = 0; i < nfields; i++)
	{
		TMask_field& conto = field(F_CDC1 + i);
		conto.set_group(1);
		conto.check_type(CHECK_NORMAL);
	}

  //Parametri dell sheet di sinistra
  TSheet_field& ls = sfield(F_MOVNNQUAD);
  short lsdlg = NQ_CDC1 + 100;

  //Parametri dell sheet di destra
  TSheet_field& rs = sfield(F_MOVQUAD);
  short rsdlg = Q_CDC1  + 100;

  //sistema i campi degli sheet tenendo conto della configurazione dell'analitica
  costruisci_sheet(ls, lsdlg);
  costruisci_sheet(rs, rsdlg);	

  //rettangolo della finestra a video
  RCT wrect;
  xvt_vobj_get_client_rect(ls.parent(), &wrect);

  //rettangolo dello sheet
  RCT srect;

  //sistema le coordinate dello sheet di sinistra
  //non si può lavorare sullo coordinata sinistra perché se si modifica si incazza come una biscia!
  ls.get_rect(srect);
  srect.right = (wrect.left + wrect.right ) / 2 - CHARX;
  srect.bottom = wrect.bottom;
  ls.set_rect(srect);

  //sistema le coordinate dello sheet di destra
  rs.get_rect(srect);
  srect.right = wrect.right;
  srect.bottom = wrect.bottom;
  rs.set_rect(srect);
}

void TQuadra_movana_msk::registra()
{
  TSheet_field& rs = sfield(F_MOVQUAD);
  rs.sort(sort_by_numreg);
  rs.force_update();

  long numregold = -1;
  TLocalisamfile file(LF_MOVANA);
  TAnal_mov movana(0);

  FOR_EACH_SHEET_ROW(rs, r, riga)
  {
    TToken_string& row = *(TToken_string*)riga;
    
    TString80 descr = row.get(rs.cid2index(Q_DESCR));
    if(descr == "Riga di quadratura")
      continue;

    if(numregold < 0L)
      movana.read(row.get_long(rs.cid2index(Q_NUMREG)));
    else if(numregold < row.get_long(rs.cid2index(Q_NUMREG)))
    {
      movana.rewrite_write(file);
      movana.zero();
      movana.read(row.get_long(rs.cid2index(Q_NUMREG)));
    }
    movana.destroy_row(row.get_long(rs.cid2index(Q_NUMRIGA)), true);
  }
  movana.rewrite_write(file); 

  const TDate oggi(TODAY);

  TAnal_mov movanaquad(0);
  movanaquad.put(MOVANA_ANNOES,    oggi.year());
  movanaquad.put(MOVANA_DATAREG,   oggi);
  movanaquad.put(MOVANA_DATACOMP,  oggi);
  movanaquad.put(MOVANA_DESCR,     "Movimento Quadrato");
  movanaquad.put(MOVANA_NUMREGCG,  get_long(F_NUMREGCG));

  TImporto totale;

  FOR_EACH_SHEET_ROW(rs, r1, riga1)
  {
    TToken_string& r = *(TToken_string*)riga1;
    TImporto importo;
    importo = r;

    TRectype& rmovana = movanaquad.new_row();
    TString80 cdc;
    TString80 cms;
    TString80 fase;
    TString80 conto;
    get_row_anal_fields(r, cdc, cms, fase, conto, F_MOVQUAD);

    rmovana.put(RMOVANA_ANNOES, oggi.year());
    rmovana.put(RMOVANA_SEZIONE, importo.sezione());
    rmovana.put(RMOVANA_IMPORTO, importo.valore());
    rmovana.put(RMOVANA_DESCR, r.get(rs.cid2index(Q_DESCR)));
    rmovana.put(RMOVANA_CODCCOSTO, cdc);
    rmovana.put(RMOVANA_CODCMS, cms);
    rmovana.put(RMOVANA_CODFASE, fase);
    rmovana.put(RMOVANA_CODCONTO, conto);
    rmovana.put(RMOVANA_ANNOES, oggi.year());
    rmovana.put(RMOVANA_DATACOMP, oggi);

    totale += importo;
  }

  movanaquad.put(MOVANA_SEZIONE, totale.sezione());
  movanaquad.put(MOVANA_TOTDOC, totale.valore());
  movanaquad.write(file);

  TSheet_field& ls = sfield(F_MOVNNQUAD);
  TConfig* conf = new TConfig("pd6342conf.ini", "MAIN");
  const TString4 codcau = conf->get("CodCau");

  FOR_EACH_SHEET_ROW(ls, lr, lriga)
  {
    TToken_string& row = *(TToken_string*)lriga;

    const long numreg = row.get_long(ls.cid2index(NQ_NUMREG));
    TAnal_mov lmovana(0);
    int err = lmovana.read(numreg);

    if(err == NOERR && lmovana.get(MOVANA_DESCR) == "Movimento Quadrato")
    {
      row.add(0L, ls.cid2index(NQ_NUMREG));
      row.add(0L, ls.cid2index(NQ_NUMRIGA));
    }
  }

  TImporto totnnquad;

  TAnal_mov movananonquad(0);
  movananonquad.put(MOVANA_ANNOES,     oggi.year());
  movananonquad.put(MOVANA_DATAREG,    oggi);
  movananonquad.put(MOVANA_DATACOMP,   oggi);
  movananonquad.put(MOVANA_DESCR,      "Movimento Importato");
  movananonquad.put(MOVANA_CODCAUS,    codcau);
  movananonquad.put(MOVANA_TRASFERITO, true);
  movananonquad.put(MOVANA_NUMREGCG,   0L);

  FOR_EACH_SHEET_ROW(ls, lr1, lriga1)
  {
    TToken_string& r = *(TToken_string*)lriga1;

    const long numreg = r.get_long(ls.cid2index(NQ_NUMREG));

    if(numreg == 0L)
      continue;

    TImporto importo;
    importo = r;

    TRectype& rmovana = movananonquad.new_row();
    TString80 cdc;
    TString80 cms;
    TString80 fase;
    TString80 conto;
    get_row_anal_fields(r, cdc, cms, fase, conto, F_MOVQUAD);

    rmovana.put(RMOVANA_ANNOES, oggi.year());
    rmovana.put(RMOVANA_SEZIONE, importo.sezione());
    rmovana.put(RMOVANA_IMPORTO, importo.valore());
    rmovana.put(RMOVANA_DESCR, r.get(rs.cid2index(Q_DESCR)));
    rmovana.put(RMOVANA_CODCCOSTO, cdc);
    rmovana.put(RMOVANA_CODCMS, cms);
    rmovana.put(RMOVANA_CODFASE, fase);
    rmovana.put(RMOVANA_CODCONTO, conto);
    rmovana.put(RMOVANA_ANNOES, oggi.year());
    rmovana.put(RMOVANA_DATACOMP, oggi);

    totnnquad += importo;
  }

  movananonquad.put(MOVANA_SEZIONE, totnnquad.sezione());
  movananonquad.put(MOVANA_TOTDOC, totnnquad.valore());
  movananonquad.write(file);


}

bool TQuadra_movana_msk::on_field_event(TOperable_field& o, TField_event e, long jolly)
{ 
  switch(o.dlg())
  {
  case DLG_CERCA:
    if(e == fe_button && check_fields())
    {
      riempi_sheets();
      return false;
    }
    break;
  case DLG_OK:
    if(e == fe_button)
    {
      crea_riga_quadratura();
      return false;
    }
    break;
  case DLG_SALVA:
    if(e == fe_button)
    {
      registra();
      return false;
    }
    break;
  case DLG_ANNULLA:
    if(e == fe_button)
    {
      reset(F_DADATA);
      reset(F_ADATA);
      reset(F_NUMREGCG);
      reset(F_DESREGCG);
      reset(F_TOTDOC);
      reset(F_TOTRIGHE);

      TSheet_field& ls = sfield(F_MOVNNQUAD);
      ls.destroy();
      ls.force_update();

      TSheet_field& rs = sfield(F_MOVQUAD);
      rs.destroy();
      rs.force_update();
    }
    break;
  case DLG_USER:
    if(e == fe_button && jolly > 0)
    {
      const short id = o.mask().get_sheet()->dlg(); // id del mio sheet
      send_key(K_CTRL+'-', id); // simulo la cancellazione della riga corrente
    }
    break;
  case F_NUMREGCG:
    if(e == fe_modify)
    {
      if(get(F_NUMREGCG).full())
        enable(DLG_CERCA);
      else
      {
        disable(DLG_CERCA);
        reset(F_NUMREGCG);
      }
    }
    break;
  case F_MOVNNQUAD:
  case F_MOVQUAD:
    if (e == se_query_add) // Per riempire lo sheet devo simulare la pressione di "Cerca"
    {
      TSheet_field& ls = (TSheet_field&)o;
      TSheet_field& rs = sfield(F_MOVNNQUAD + F_MOVQUAD - o.dlg());
      if (ls.empty() && rs.empty())
        send_key(K_SPACE, DLG_CERCA);
      return false;
    }
    if (e == se_query_del)
    {
      TSheet_field& ls = (TSheet_field&)o;
      TSheet_field& rs = sfield(F_MOVNNQUAD + F_MOVQUAD - o.dlg());
      const TToken_string& row = ls.row(ls.selected());
      rs.row(-1) = row;
      rs.force_update();
      rs.select(rs.items()-1);
      
      calcola_totale(o.dlg() == F_MOVNNQUAD ? rs : ls);
    }
    break;
  default:  break;
  }
  return true;
}

///////////////////////////////////////////////////////////
// TQuadra_movana_app
///////////////////////////////////////////////////////////

class TQuadra_movana_app: public TSkeleton_application
{
protected:
  virtual bool check_autorization() const {return false;}
  virtual const char * extra_modules() const {return "ca";}

  virtual void main_loop();
  
  void elabora();
};

void TQuadra_movana_app::elabora()
{
}

void TQuadra_movana_app::main_loop()
{
  TQuadra_movana_msk m;
	bool running = true;

  while(m.run() == K_ENTER)
	{
		elabora();
	}
}

int pd6342400(int argc, char* argv[])
{  
  TQuadra_movana_app app;
  app.run(argc, argv, TR("Quadra movimenti analitici"));
  return 0;
}