#include <automask.h>
#include <defmask.h>
#include <modaut.h>
#include <printer.h>
#include <recset.h>
#include <tabapp.h>
#include <utility.h>

#include "velib.h"
#include "../ca/calib01.h"
#include "veuml.h"
#include "veini.h"
#include "verig.h"

#include "vetbatr.h"
#include "vetbgmc.h"
#include "vetbnum.h"
#include "vetbprs.h"
#include "vetbrss.h"
#include "vetbspp.h"
#include "vehntip.h"
#include "vehntri.h"
#include "vetbtip.h"
#include "vetbtri.h"

#define TAB_GRMERC      "GMC"

HIDDEN void add_frr_list(TEdit_field & e)
{
	TList_sheet * sh = e.sheet();
	
	if (sh != NULL)
	{
		TString_array & items = sh->rows_array();
		TISAM_recordset r("USE %FRR");

	  for (bool ok = r.move_first(); ok; ok = r.move_next())
		{
			TToken_string data(r.get("CODTAB").as_string());

			data.add(r.get("S0").as_string());
			items.add(data);
		}
	}
}

HIDDEN void add_frd_list(TEdit_field & e)
{
	TList_sheet * sh = e.sheet();
	
	if (sh != NULL)
	{
		TString_array & items = sh->rows_array();
		TISAM_recordset r("USE %FRD");

	  for (bool ok = r.move_first(); ok; ok = r.move_next())
		{
			TToken_string data(r.get("CODTAB").as_string());

			data.add(r.get("S0").as_string());
			items.add(data);
		}
  }
}

HIDDEN void add_fld_list(TEdit_field & e, int logicnum)
{
	TList_sheet* sh = e.sheet();
	if (sh != NULL)
	{
		TString_array& items = sh->rows_array();
    TRelation rel(logicnum);
    TRelation_description reldes(rel);

    const RecDes& rd = prefix().get_recdes(logicnum);
    for (int i = 0; i < rd.NFields; i++)
    {
      const RecFieldDes& fd = rd.Fd[i];
			TToken_string data;

			data << logicnum << '.' << fd.Name;
			data.add(reldes.get_field_description(fd.Name));
			items.add(data);
    }
  }
}

///////////////////////////////////////////////////////////
// TVendite_mask
///////////////////////////////////////////////////////////

class TVendite_mask : public TAutomask
{
  TString4 _tab;  // Voglio la tabella sempre sotto mano

protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

  bool is_table(const char* tab) const { return _tab == tab; }
  
  void get_printer_config(TString& name) const;
  bool get_printer_name(TString& name) const;
  void reset_printer_config() const;

  bool on_tri_event(TOperable_field& o, TField_event e, long jolly);
  bool on_tip_event(TOperable_field& o, TField_event e, long jolly);
  bool on_num_event(TOperable_field& o, TField_event e, long jolly);

public:
  const TString& table_code() const { return _tab; }

  TVendite_mask(const char* name);
  virtual ~TVendite_mask() { }
};

///////////////////////////////////////////////////////////
// TTIP_handlers_mask
///////////////////////////////////////////////////////////

class TTIP_handlers_mask : public TAutomask
{
	TDocumento_mask * _docmask;

protected:
	void add_mask_items(TList_field& l);
	void build_items(TEdit_field& e, const char * flist);
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
	void mask2prof(TTipo_documento & tipo);
	void prof2mask(TTipo_documento & tipo);

	TTIP_handlers_mask(const char * tipodoc);
  virtual ~TTIP_handlers_mask() { delete _docmask; }
};

///////////////////////////////////////////////////////////
// TTRI_handlers_mask
///////////////////////////////////////////////////////////

class TTRI_handlers_mask : public TAutomask
{
	TMask* _rigamask;

protected:
	void add_mask_items(TList_field& l);
	void build_items(TEdit_field& e, const char * flist);
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
	void mask2prof(TTipo_riga_documento & tipo);
	void prof2mask(TTipo_riga_documento & tipo);

	TTRI_handlers_mask(const TTipo_riga_documento & tiporiga);
  virtual ~TTRI_handlers_mask() { delete _rigamask; }
};

void TVendite_mask::get_printer_config(TString& config) const
{
  config = _tab;  
  for (TEditable_field* f = get_key_field(1, true); f; f = get_key_field(1, false)) 
  {
    if (f->shown())
      config << f->get();
  }
}

bool TVendite_mask::get_printer_name(TString& name) const
{
  TString parag; get_printer_config(parag);  
  TConfig ini(CONFIG_STAMPE, parag);              
  name = ini.get("Name");
  return name.full();
}

void TVendite_mask::reset_printer_config() const
{
  TString parag; get_printer_config(parag);  
  TConfig ini(CONFIG_STAMPE, parag);              
  ini.remove_all();
}

static TString4 __tab_codnum;

static bool tab_tip_filter(const TRelation* r)
{
	if (__tab_codnum.blank())
		return true;
	
	const TString4 tipo = r->curr().get("CODTAB");
  const TCodice_numerazione& cod_num = cached_numerazione(__tab_codnum);
	for (int i = 0; i < cod_num.ntipi_doc(); i++ )
	{
		const TString& curtipo = cod_num.tipo_doc(i);
		if (curtipo == tipo) 
      return true;
	}

  return false;
}

bool TVendite_mask::on_tip_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
  case F_PROFILO:
    if (e == fe_init || e == fe_modify)
      enable(DLG_CONFIG, !o.empty());
    break;
	case DLG_CONFIG:
		if (e == fe_button && get(F_PROFILO).full())
		{
			TTipo_documento t(get(F_CODTAB));
			TTIP_handlers_mask m(get(F_CODTAB));

			m.set(F_NAMETIP, get(F_PROFILO));
			m.prof2mask(t);
			if (m.run() == K_ENTER)
				m.mask2prof(t);
		}
    break;
  default: break;
	}
	return true;
}

bool TVendite_mask::on_tri_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
  case F_CODTAB:
    if (e == fe_init || e == fe_modify)
      enable(DLG_CONFIG, !o.empty());
    break;
	case DLG_CONFIG:
		if (e == fe_button)
		{
			TTipo_riga_documento t(get(F_CODTAB));
			TTRI_handlers_mask m(t);
			TString name("verig");

			name << t.codice();
			m.set(F_NAMETRI, name);
			m.prof2mask(t);
			if (m.run() == K_ENTER)
				m.mask2prof(t);
		}
    break;
  default: break;
	}
	return true;
}

bool TVendite_mask::on_num_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
		case FN_CODNUM:
			if (e == fe_init || e == fe_modify)
      {
				__tab_codnum = o.get();
        efield(FN_TIPODOC).browse()->cursor()->set_filterfunction(tab_tip_filter);
      }
			break;
		default:
			break;
	}
	return true;	//metodo che gestiva la stampante per le numerazioni documenti
}

bool TVendite_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  if (is_table("NUM"))
    return on_num_event(o, e, jolly);
  if (is_table("TIP"))
    return on_tip_event(o, e, jolly);
  if (is_table("TRI"))
    return on_tri_event(o, e, jolly);
  return true;
}

TVendite_mask::TVendite_mask(const char* name) : TAutomask(name) 
{ 
  const TFixed_string n(name);
  _tab = n.mid(4,3);
  _tab.upper();
}

void TTIP_handlers_mask::mask2prof(TTipo_documento & tipo)
{
	TFilename profname;
	
	tipo.profile_name(profname);
	profname.custom_path();
	if (profname.find("custom") < 0)
	{
		TFilename srcname(profname);

		profname = prefix().get_studio();
		profname << SLASH << "custom" << SLASH << srcname;
		fcopy(srcname, profname);
	}

	TConfig profile(profname, "MAIN");

  profile.set("MODULE", get(F_MODULE)); 
	profile.set("TIPOCR", get(F_TIPOCR));
  profile.set("CONTROLLO_PREZZI", get(F_CNTPRZ));
	profile.set(RDOC_PREZZO, get(F_PREZZO));
	profile.set(RDOC_QTA, get(F_QTA));
	profile.set(RDOC_QTAEVASA, get(F_QTAEVASA));
	profile.set("QTA_MAG", get(F_QTAMAG));
	profile.set("QTAEVASA_MAG", get(F_QTAEVASAMAG));
	profile.set("TOTALECONT", get(F_TOTALECONT));
  profile.set("CHECK_QTA", get(F_CHECK_QTA));
  profile.set("LOAD_CONT", get(F_LOAD_CONT));
  profile.set("DESCRIZIONE_DOC", get(F_DESCDOC));
  profile.set("DESCRIZIONE_RDOC", get(F_DESCRDOC));
  profile.set("NASCONDI_RIGHE_EVASE", get(F_HIDEEVASE));
  profile.set("NON_EVADERE", get(F_NOTEVADI)); 

	profile.remove_array("Title");
	TSheet_field & sl = sfield(F_LABELS);

	FOR_EACH_SHEET_ROW(sl, rl, rowl)
		profile.set("Title", rowl->get(0), NULL, true, rl + 1);
	profile.set_paragraph("HANDLERS");
	profile.remove_array("Handler");
	for (int i = 0 ; i < 10; i++)
		profile.remove(format("%d", i));

	TSheet_field & sh = sfield(F_HANDLERS);

	FOR_EACH_SHEET_ROW(sh, r, row)
	{
		const short id = row->get_int(1);

		profile.set("Handler", row->get_int(0), NULL, true, id);
	}

	profile.set_paragraph("DEFAULT");
	profile.remove_array("Default");

	TSheet_field & sd = sfield(F_DEFAULTS);

	FOR_EACH_SHEET_ROW(sd, dr, drow)
	{
		const short id = drow->get_int(0);

		profile.set("Default", drow->get(), NULL, true, id);
	}
}

void TTIP_handlers_mask::prof2mask(TTipo_documento & tipo)
{
	TFilename profname;

	tipo.profile_name(profname);
  
	TConfig profile(profname, "MAIN");
  
  profile.write_protect();
	set(F_MODULE, profile.get("MODULE")); 
	set(F_TIPOCR, profile.get("TIPOCR"));
	set(F_CNTPRZ, profile.get("CONTROLLO_PREZZI"));
	set(F_PREZZO, profile.get(RDOC_PREZZO));
	set(F_QTA, profile.get(RDOC_QTA));
	set(F_QTAEVASA, profile.get(RDOC_QTAEVASA));
	set(F_QTAMAG, profile.get("QTA_MAG"));
	set(F_QTAEVASAMAG, profile.get("QTAEVASA_MAG"));
	set(F_TOTALECONT, profile.get("TOTALECONT"));
  set(F_CHECK_QTA, profile.get("CHECK_QTA"));
  set(F_LOAD_CONT, profile.get("LOAD_CONT"));
  set(F_DESCDOC, profile.get("DESCRIZIONE_DOC"));
  set(F_DESCRDOC, profile.get("DESCRIZIONE_RDOC"));
  set(F_HIDEEVASE, profile.get("NASCONDI_RIGHE_EVASE"));
  set(F_NOTEVADI, profile.get("NON_EVADERE")); 

	TSheet_field & sl = sfield(F_LABELS);
	int npages = 1;
	for (; _docmask->page_win(npages) != NULL_WIN; npages++);

	if (_docmask->id2pos(F_CDC1) >= 0)
		npages--;
	sl.destroy();
	for (int i = 1 ; i <= npages; i++)
	{
		TToken_string & row = sl.row(i - 1);

		row = profile.get("Title", NULL, i, "");
	}
	profile.set_paragraph("HANDLERS");
	TAssoc_array& handlers = profile.list_variables();
	TSheet_field & sh = sfield(F_HANDLERS);

	sh.destroy();
	FOR_EACH_ASSOC_STRING(handlers, obj, key, str)
  {
		TToken_string & row = sh.row(-1);
    int id = 0, hd = 0;
    if (*key == 'H' && strchr(str, '|') == NULL)  // Provo a gestire il caso Handler(105) = 3
    {
      row.add(atoi(str));

			const TFixed_string k(key);

      row.add(atoi(k.after('(')));
    }
    else                                          // Provo a gestire il caso 1 = 105|3
    {
      TToken_string riga = str;

			row.add(riga.get_int(1));
      row.add(riga.get_int(0));
    }
		sh.check_row(sh.items() - 1);
	}
	profile.set_paragraph("DEFAULT");
	TSheet_field & sd = sfield(F_DEFAULTS);

	sd.destroy();
	TAssoc_array& defaults = profile.list_variables();

  FOR_EACH_ASSOC_STRING(defaults, obj, dkey, dstr)
  {
		TToken_string & row = sd.row(-1);
    if (strchr(dstr, '|') == NULL)  // Provo a gestire il caso Default(105) = 3
    {
      const TFixed_string k(dkey);
      
			row.add(atoi(k.after('(')));
			row.add(dstr);
    }
    else   // Provo a gestire il caso Default(0) = 105|3
			row = dstr; 
	}
}

void TTIP_handlers_mask::add_mask_items(TList_field& l)
{
	TToken_string codes;
	TToken_string descrs;

	FOR_EACH_MASK_FIELD(*_docmask, i, f)
	{
		const short id = f->dlg();
		
		if (f->is_editable() && f->enabled_default() && f->shown_default())
		{
				TString descr;

				codes.add(id);
				descr << id << " - " << f->prompt();
				const TFieldref * fld = f->field();
				if (fld != NULL)
					descr << " - " << fld->name();
				descr.strip(":!");
				descr.strip_double_spaces();
				descrs.add(descr);
		}
	}
	l.replace_items(codes, descrs);
}

void TTIP_handlers_mask::build_items(TEdit_field& e, const char * flist)
{
	TList_sheet * l = e.sheet();

	if (l != NULL)
	{
		TString_array & data = l->rows_array();

		data.destroy();
		if (flist && *flist)
		{
			TToken_string tok(flist);
			FOR_EACH_TOKEN(tok, sid)
			{
				short id = atoi(sid);
				const int pos = _docmask->id2pos(id);

				if (pos >= 0)
				{
						TString descr(_docmask->fld(pos).prompt());
						TToken_string r;

						r.add(id);
						descr.strip(":-!");
						descr.strip_double_spaces();
						r.add(descr);
						data.add(r);
				}
			}
		}
		FOR_EACH_MASK_FIELD(*_docmask, i, f)
		{
			const short id = f->dlg();
			
			if (id >= F_USERFLD && id < BASE_PIEDE)
			{
				TString descr(f->prompt());

				if (descr.full())
				{
					TToken_string r;

					r.add(id);
					descr.strip(":-!");
					descr.strip_double_spaces();
					r.add(descr);
					data.add(r);
				}
			}
		}
		if (data.items() == 0)
			data.add("|Non utilizzabile");
	}
}

bool TTIP_handlers_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
		case FH_HANDLER:
			if ((o.mask().get_sheet()->dlg() == F_HANDLERS) && (e == fe_init || e == fe_modify))
      {
				const int hnum = (int) o.get_long();
				switch (hnum)
				{
					case 1:
						build_items(o.mask().efield(FH_FIELD), TOSTRING(F_ORAPART));
						break;
					case 2:
						build_items(o.mask().efield(FH_FIELD), "");
						break;
					case 3:
						build_items(o.mask().efield(FH_FIELD), TOSTRING(F_NUMDOCRIF));
						break;
					case 4:
						build_items(o.mask().efield(FH_FIELD), "");
						break;
					case 6:
						build_items(o.mask().efield(FH_FIELD), "");
						break;
					default: 
						break;
				} 
      }
			break;
		default:
			break;
	}
  return true;
}

TTIP_handlers_mask::TTIP_handlers_mask(const char * tipodoc) : TAutomask("vehntip")
{
	_docmask = new TDocumento_mask(tipodoc);
	add_frr_list(efield(F_PREZZO));
	add_frd_list(efield(F_TOTALECONT));
	add_frr_list(efield(F_QTA));
	add_frr_list(efield(F_QTAEVASA));
	add_frr_list(efield(F_QTAMAG));
	add_frr_list(efield(F_QTAEVASAMAG));
	add_mask_items(sfield(F_DEFAULTS).sheet_mask().lfield(FD_FIELD));
}

void TTRI_handlers_mask::add_mask_items(TList_field& l)
{
	TToken_string codes;
	TToken_string descrs;

	FOR_EACH_MASK_FIELD(*_rigamask, i, f)
	{
		const short id = f->dlg();
		
		if (f->is_editable() && f->enabled_default() && f->shown_default() && id < FR_END)
		{
				TString descr;
				TString fldname;

				codes.add(id);
				descr << id << " - " << f->prompt();
				switch (id)
				{
					case FR_TIPORIGA :
						fldname = RDOC_TIPORIGA;
						break;
					case FR_CODMAG :
					case FR_CODDEP :
						fldname = RDOC_CODMAG;
						break;
					case FR_CODART :
						fldname = RDOC_CODART;
						break;
					case FR_LIV1 :
					case FR_LIV2 :
					case FR_LIV3 :
					case FR_LIV4 :
						fldname = RDOC_LIVELLO;
						break;
				case FR_DESCR :
						fldname = RDOC_DESCR;
						break;
				case FR_UMQTA :
						fldname = RDOC_UMQTA;
						break;
				case FR_PREZZO :
						fldname = RDOC_PREZZO;
						break;
				case FR_CODIVA :
						fldname = RDOC_CODIVA;
						break;
				case FR_QTA :
						fldname = RDOC_QTA;
						break;
				case FR_QTAEVASA :
						fldname = RDOC_QTAEVASA;
						break;
				case FR_RIGAEVASA :
						fldname = RDOC_RIGAEVASA;
						break;
				case FR_TARA :
						fldname = RDOC_TARA;
						break;
				case FR_PNETTO :
						fldname = RDOC_PNETTO;
						break;
				case FR_NCOLLI :
						fldname = RDOC_NCOLLI;
						break;
				case FR_DAEVADERE :
						fldname = RDOC_DAEVADERE;
						break;
				case FR_SCONTO :
						fldname = RDOC_SCONTO;
						break;
				case FR_PERCPROV :
						fldname = RDOC_PERCPROV;
						break;
				case FR_IMPFISUN :
						fldname = RDOC_IMPFISUN;
						break;
				case FR_IMPFISSO :
						fldname = RDOC_IMPFISSO;
						break;
				case FR_ADDIVA :
						fldname = RDOC_ADDIVA;
						break;
				case FR_ASPBENI :
						fldname = RDOC_ASPBENI;
						break;
				case FR_CAUS :
						fldname = RDOC_CAUSMAG;
						break;
				case FR_CODMAGC :
				case FR_CODDEPC :
						fldname = RDOC_CODMAGC;
						break;
				case FR_DATACONS :
						fldname = RDOC_DATACONS;
						break;
				case FR_CODARTMAG :
						fldname = RDOC_CODARTMAG;
						break;
				case FR_CHECKED :
						fldname = RDOC_CHECKED;
						break;
				case FR_QTAGG1 :
						fldname = RDOC_QTAGG1;
						break;
				case FR_QTAGG2 :
						fldname = RDOC_QTAGG2;
						break;
				case FR_QTAGG3 :
						fldname = RDOC_QTAGG3;
						break;
				case FR_QTAGG4 :
						fldname = RDOC_QTAGG4;
						break;
				case FR_QTAGG5 :
						fldname = RDOC_QTAGG5;
						break;
				case FR_IMPIANTO :
						fldname = RDOC_IMPIANTO;
						break;
				case FR_LINEA :
						fldname = RDOC_LINEA;
						break;
				case FR_CODAGG1 :
						fldname = RDOC_CODAGG1;
						break;
				case FR_CODAGG2 :
						fldname = RDOC_CODAGG2;
						break;
				case FR_RIDPREZZO :
						fldname = RDOC_RIDPREZZO;
						break;
				case FR_PERCPROV1 :
						fldname = RDOC_PERCPROV1;
						break;
				case FR_TIPODET :
						fldname = RDOC_TIPODET;
						break;
				default:
						const TFieldref * fld = f->field();
						if (fld != NULL)
							fldname = fld->name();
					break;
				}
				if (fldname.full())
					descr << " - " << fldname;
  			descr.strip(":!");
				descr.strip_double_spaces();
				descrs.add(descr);
		}
	}
	l.replace_items(codes, descrs);
}

void TTRI_handlers_mask::build_items(TEdit_field& e, const char * flist)
{
	TList_sheet * l = e.sheet();

	if (l != NULL)
	{
		TString_array & data = l->rows_array();

		data.destroy();
		if (flist && *flist)
		{
			TToken_string tok(flist);

			FOR_EACH_TOKEN(tok, sid)
			{
				short id = atoi(sid);
				const int pos = _rigamask->id2pos(id);

				if (pos >= 0)
				{
						TString descr(_rigamask->fld(pos).prompt());
						TToken_string r;

						r.add(id);
						descr.strip(":_-!");
						descr.strip_double_spaces();
						r.add(descr);
						data.add(r);
				}
			}
		}
		FOR_EACH_MASK_FIELD(*_rigamask, i, f)
		{
			const short id = f->dlg();

			if 	(((id >= FR_JOLLY1 && id <= FR_JOLLY10) ||
					 (id >= FR_CODAGG1 && id <= FR_CODAGG2)))
			{
				TString descr(f->prompt());

				if (descr.full())
				{
					TToken_string r;

					r.add(id);
					descr.strip(":-!");
					descr.strip_double_spaces();
					r.add(descr);
					data.add(r);
				}
			}
		}
		if (data.items() == 0)
			data.add("|Non utilizzabile");
	}
}

bool TTRI_handlers_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
		case FH_HANDLERR:
			if ((o.mask().get_sheet()->dlg() == F_HANDLERSR) && (e == fe_init || e == fe_modify))
      {
				const int hnum = (int) o.get_long();
				switch (hnum)
				{
					case 1:
						build_items(o.mask().efield(FH_FIELDR), TOSTRING(FR_PREZZO));
						break;
					case 3:
						build_items(o.mask().efield(FH_FIELDR), TOSTRING(FR_CODART));
						break;
					case 4:
						build_items(o.mask().efield(FH_FIELDR), TOSTRING(FR_CODART));
						break;
					case 5:
						build_items(o.mask().efield(FH_FIELDR), TOSTRING(FR_CODART));
						break;
					case 6:
						build_items(o.mask().efield(FH_FIELDR), TOSTRING(FR_CODART));
						break;
					case 7:
						build_items(o.mask().efield(FH_FIELDR), TOSTRING(FR_CODART));
						break;
					case 8:
						build_items(o.mask().efield(FH_FIELDR), TOSTRING(FR_LIV1) "|" TOSTRING(FR_LIV2) "|" TOSTRING(FR_LIV3) "|" TOSTRING(FR_LIV4));
						break;
					default:
						build_items(o.mask().efield(FH_FIELDR),"\"" "\"");
						break;
				}
      }
			break;
		default:
			break;
	}
  return true;
}

void TTRI_handlers_mask::mask2prof(TTipo_riga_documento & tipo)
{
	TFilename profname("verig");

	profname << tipo.codice();
	profname.ext("ini");
	profname.custom_path();
	if (profname.find("custom") < 0)
	{
		TFilename srcname(profname);

		profname = prefix().get_studio();
		profname << SLASH << "custom" << SLASH << srcname;
		fcopy(srcname, profname);
	}

	TConfig profile(profname, "MAIN");

  profile.set("NODESC", get(F_NODESC)); 
	profile.set("VARP+", get(F_VARP));
	profile.set("VARP-", get(F_VARN));
	profile.set(RDOC_PREZZO, get(F_PREZZO));
	profile.set(RDOC_QTA, get(F_QTAR));
	profile.set(RDOC_QTAEVASA, get(F_QTAEVASAR));
	profile.set("QTA_MAG", get(F_QTAMAGR));
	profile.set("QTAEVASA_MAG", get(F_QTAEVASAMAGR));
	profile.set("LIVGEN", get(F_LIVGEN1), NULL, true, 1);
	profile.set("LIVGEN", get(F_LIVGEN2), NULL, true, 2);
	profile.set("LIVGEN", get(F_LIVGEN3), NULL, true, 3);
	profile.set("LIVGEN", get(F_LIVGEN4), NULL, true, 4);
	profile.set("SEARCNUMS", get(F_SEARCNUMS));
	profile.set("MAXROWSART", get(F_MAXROWSART));
	profile.set("SEARCHACTDOCS", get(F_SEARCHACTDOCS));
	profile.set("SELCLIFO", get(F_SELCLIFO));
	profile.set("FIELDSTOUPDATE", get(F_FIELDSTOUPDATE));
	profile.set_paragraph("HANDLERS");
	profile.remove_array("Handler");
	profile.remove("NHANDLERS");
	for (int i = 0 ; i < 10; i++)
		profile.remove(format("%d", i));

  TSheet_field& sh = sfield(F_HANDLERSR);
	FOR_EACH_SHEET_ROW(sh, r, row)
	{
		const short id = row->get_int(1);
		profile.set("Handler", row->get_int(0), NULL, true, id);
	}
	profile.set_paragraph("DEFAULT");
	profile.remove_array("Default");

	TSheet_field& sd = sfield(F_DEFAULTSR);
	FOR_EACH_SHEET_ROW(sd, dr, drow)
	{
		const short id = drow->get_int(0);
		profile.set("Default", drow->get(), NULL, true, id);
	}
}

void TTRI_handlers_mask::prof2mask(TTipo_riga_documento & tipo)
{
	TFilename profname;

	tipo.profile_name(profname);
  
	TConfig profile(profname, "MAIN");
  
  profile.write_protect();  // Altrimenti non si distrugge!!!
	set(F_NODESC, profile.get("NODESC")); 
	set(F_VARP, profile.get("VARP+"));
	set(F_VARN, profile.get("VARP-"));
	set(F_PREZZO, profile.get(RDOC_PREZZO));
	set(F_QTAR, profile.get(RDOC_QTA));
	set(F_QTAEVASAR, profile.get(RDOC_QTAEVASA));
	set(F_QTAMAGR, profile.get("QTA_MAG"));
	set(F_QTAEVASAMAGR, profile.get("QTAEVASA_MAG"));
	set(F_LIVGEN1, profile.get("LIVGEN", NULL, 1));
	set(F_LIVGEN2, profile.get("LIVGEN", NULL, 2));
	set(F_LIVGEN3, profile.get("LIVGEN", NULL, 3));
	set(F_LIVGEN4, profile.get("LIVGEN", NULL, 4));
	set(F_SERCHYEARS, profile.get("SERCHYEARS"));
	set(F_SEARCNUMS, profile.get("SEARCNUMS"));
	set(F_MAXROWSART, profile.get("MAXROWSART"));
	set(F_SEARCHACTDOCS, profile.get("SEARCHACTDOCS"));
	set(F_SELCLIFO, profile.get("SELCLIFO"));
	set(F_FIELDSTOUPDATE, profile.get("FIELDSTOUPDATE"));

	profile.set_paragraph("HANDLERS");

	TAssoc_array& handlers = profile.list_variables();
	TSheet_field & sh = sfield(F_HANDLERSR);

	sh.destroy();
	FOR_EACH_ASSOC_STRING(handlers, obj, key, str)
  {
    int id = 0, hd = 0;
    if (*key == 'H' && strchr(str, '|') == NULL)  // Provo a gestire il caso Handler(105) = 3
    {
      const TFixed_string k(key);
      id = atoi(k.after('('));
      hd = atoi(str);
    }
    else                                          // Provo a gestire il caso 1 = 105|3
			if (*key != 'N')
			{
				const TToken_string riga = str;
				riga.get(0, id); 
				riga.get(1, hd);
			}
		if (hd > 0)
		{
			TToken_string & row = sh.row(-1);
			row.add(hd);
			row.add(id);
			sh.check_row(sh.items() - 1);
		}
	}
	profile.set_paragraph("DEFAULT");
	TSheet_field & sd = sfield(F_DEFAULTSR);

	sd.destroy();
	TAssoc_array& defaults = profile.list_variables();

  FOR_EACH_ASSOC_STRING(defaults, obj, dkey, s)
  {
		TToken_string & row = sd.row(-1);
    if (strchr(s, '|') == NULL)  // Provo a gestire il caso Default(105) = 3
    {
      const TFixed_string k(dkey);
      
			row.add(atoi(k.after('(')));
			row.add(s);
    }
    else   // Provo a gestire il caso Default(0) = 105|3
			row = s;
	}
}

TTRI_handlers_mask::TTRI_handlers_mask(const TTipo_riga_documento & tiporiga) : TAutomask("vehntri")
{
	TString name;
	

	tiporiga.mask_name(name);
	_rigamask = new TMask(name);
	add_frd_list(efield(F_TOTALECONT));
	add_frr_list(efield(F_QTAR));
	add_frr_list(efield(F_QTAEVASAR));
	add_frr_list(efield(F_QTAMAGR));
	add_frr_list(efield(F_QTAEVASAMAGR));
	for (int i = 0 ; i < 4; i++)
	{
		const short id = F_LIVGEN1 + i;
		TEdit_field & e = efield(id);

		add_fld_list(e, LF_ANAMAG);
		add_fld_list(e, LF_DOC);
		add_fld_list(e, LF_RIGHEDOC);
	}
	add_mask_items(sfield(F_DEFAULTSR).sheet_mask().lfield(FD_FIELDR));
}

///////////////////////////////////////////////////////////
// TVendite_tabapp
///////////////////////////////////////////////////////////

class TVendite_tabapp : public TTable_application
{
protected:
	virtual const char* extra_modules() const {return "dt";}
  virtual TMask* set_mask(TMask* m);
  virtual void add_anal_fields(TVendite_mask& vm);
  virtual void init_query_mode(TMask& m);
  virtual int read(TMask& m);
  virtual int write(const TMask& m);
  virtual int rewrite(const TMask& m);
  virtual bool user_create();
  virtual bool get_next_key(TToken_string& key);
  void write_gmc(const TMask& m, TRectype& curr);
  static bool codgmc_handler(TMask_field& f, KEY k);

  bool is_table(const char* tab) const { return get_tabname() == tab; }

public:
};

void TVendite_tabapp::add_anal_fields(TVendite_mask& vm)
{
	int y = 4;
	short dlg = F_ANAL1;
	int nfields = 0;
	const TMultilevel_code_info& fasinfo = ca_multilevel_code_info(LF_FASI);
	const TMultilevel_code_info& cominfo = ca_multilevel_code_info(LF_COMMESSE);
	const TMultilevel_code_info& cdcinfo = ca_multilevel_code_info(LF_CDC);
	int fasi_fields = fasinfo.levels();
	const int cdc_fields = cdcinfo.levels();
	const int com_fields = cominfo.levels();
	const bool use_fsc = fasi_fields > 0;

	if (use_fsc && fasinfo.parent() == LF_CDC)
	{
		nfields = ca_create_fields(vm, 1, LF_FASI, 2, y, dlg, dlg+50, 0x0, "S1", 20);

		const int dlgf = dlg + com_fields;
		fasi_fields -= com_fields;
		const int offset = 61 - vm.field(dlgf).field()->from();

		for (short i = 0 ; i< fasi_fields; i++)
		{
			TFieldref * fr = (TFieldref *) vm.field(dlgf + i).field();

			if (fr != NULL)
			{
				TEdit_field & fld = vm.efield(dlgf + i);
        TString16 str;
				
				str.format("S1[%d,%d]", fr->from() + offset + 1, fr->to() + offset);
        fld.set_field(str);
			}
		}
	}
	else
		nfields = ca_create_fields(vm, 1, LF_CDC, 2, y, dlg, dlg+50, 0x0, "S1", 20);
	dlg += nfields;
	y += nfields;
	if (use_fsc && fasinfo.parent() == LF_COMMESSE)
	{
		nfields = ca_create_fields(vm, 1, LF_FASI, 2, y, dlg, dlg+50, 0x0, "S1", 40);
		const int dlgf = dlg + com_fields;
		fasi_fields -= com_fields;
		const int offset = 60 - vm.field(dlgf).field()->from();

		for (short i = 0 ; i < fasi_fields; i++)
		{
			TFieldref * fr = (TFieldref *) vm.field(dlgf + i).field();

			if (fr != NULL)
			{
				TEdit_field & fld = vm.efield(dlgf + i);
        TString16 str;
				
				str.format("S1[%d,%d]", fr->from() + offset + 1, fr->to() + offset);
        fld.set_field(str);
			}
		}
	}
	else
		nfields = ca_create_fields(vm, 1, LF_COMMESSE, 2, y, dlg, dlg+50, 0x0, "S1", 40);
	dlg += nfields;
	y += nfields;
	if (use_fsc && fasinfo.parent() <= 0)
		nfields = ca_create_fields(vm, 1, LF_FASI, 2, y, dlg, dlg+50, 0x0, "S1", 60);

}

TMask* TVendite_tabapp::set_mask(TMask* m)
{
  if (m == NULL)
  {
    TFilename mn; get_mask_name(mn);
    TVendite_mask* vm = new TVendite_mask(mn);

    if (ca_config().get_int("Authorizations") != 0)
    {
       // Crea i campi per i conti analitici (vendite e acquisti)
      if (vm->table_code() == "SPP")
      {
        ca_create_fields(*vm, 0, LF_PCONANA, 2, 11, SPP_CDC_V1, SPP_CDC_V1+50, 0x0, "S1");
        ca_create_fields(*vm, 0, LF_PCONANA, 2, 16, SPP_CDC_A1, SPP_CDC_A1+50, 0x0, "S2");
				add_anal_fields(*vm);
      } else
      if (vm->table_code() == "PRS")
      {
        ca_create_fields(*vm, 0, LF_PCONANA, 2, 12, PRS_CDC_V1, PRS_CDC_V1+10, 0x0, "S1");
				ca_create_fields(*vm, 0, LF_PCONANA, 2, 18, PRS_CDC_A1, PRS_CDC_A1+10, 0x0, "S2");
				add_anal_fields(*vm);
      } else
      if (vm->table_code() == "RSS")
      {
        ca_create_fields(*vm, 0, LF_PCONANA, 2, 16, RSS_CDC_V1, RSS_CDC_V1+10, 0x0, "S1");
				add_anal_fields(*vm);
      } else
      if (vm->table_code() == "ATR")
      {
        ca_create_fields(*vm, 0, LF_PCONANA, 2, 12, ATR_CDC_V1, ATR_CDC_V1+10, 0x0, "S1");
				add_anal_fields(*vm);
      }
    }
    m = vm;
  }
  return TTable_application::set_mask(m);
}

void TVendite_tabapp::init_query_mode(TMask& m)
{
  if (is_table("RSS"))
  {
    m.enable(RSS_RAGSOC);
  }
}

bool TVendite_tabapp::get_next_key(TToken_string& key)
{
  if (is_table("NAR"))
  {
    long n = 1;
    TEdit_field& codice = curr_mask().efield(101);
    TCursor& cur = *codice.browse()->cursor();
    if (cur.items() > 0)
    {
      cur = cur.items()-1;
      n += cur.curr().get_long("CODTAB");
    }
    key.format("101|%6ld", n);
    return true;
  }
  return TTable_application::get_next_key(key);
}

int TVendite_tabapp::read(TMask& m)
{
	int err = Tab_application::read(m);
  if (err == NOERR)
  {
    const TRectype& curr = get_relation()->curr();

    if (curr.exist("R10") && curr.get_real("R10").is_zero())
    {
      const TString& r0 = curr.get("R0");
		  if (is_table("SPP"))
			  m.set(SPP_PREZZO, r0); else
			if (is_table("PRS"))
			  m.set(PRS_PREZZO, r0); else
			if (is_table("RSS"))
				m.set(RSS_PREZZO, r0); else
			if (is_table("ATR"))
			  m.set(ATR_PREZZO, r0);
    }

    //in caso dei grmerc sono cazzi, perchè lo sheet va riempito usando il contenuto di S1 ed S2, che sono tokenstring..
    //..di tokenstrings!
    if (is_table("GMC"))
    {
      //intanto deve controllare da configurazione se enablare o meno la colonna CATVEN

      TSheet_field& listini = m.sfield(F_RIGHE_LIS);
      listini.enable_column(S_CATVEN, ini_get_bool(CONFIG_DITTA, "ve", "GESLISCV"));

      TToken_string stringona(140, ';');
      TString s = curr.get("S1");
      if (s.full())
      {
        stringona.add(s);
        s = curr.get("S2");
        if (s.full())
          stringona.add(s);
      }
                 
      listini.destroy();
      //questo serve per settare il separatore in modo che non mandi in confusione l'editor degli archivi..
      //..separator è definito nella maschera
      TToken_string stringhina(16, listini.separator());
      FOR_EACH_TOKEN(stringona, str)
      {
        stringhina = str;
        if (stringhina.find('|') >= 0)    //converte eventuali pipe standard in broken pipe
          stringhina.replace('|', stringhina.separator());
        listini.row(-1) = stringhina;
        listini.check_row(listini.items() - 1);
      }
      listini.force_update();
    }
  }
  return err;
}

bool TVendite_tabapp::codgmc_handler(TMask_field& f, KEY k)
{
  TMask& m = f.mask();
  if (m.query_mode() && k == K_ENTER)
  {
    const TString& codice = m.get(f.dlg()); //stringa immessa nella maschera
    const TString& codtab = cache().get("GMC", codice, "CODTAB"); //stringa cercata nella tabella
    if (codtab.empty()) //se non trovi la stringa in tabella (in codice magazzino non esiste->se in insert mode)
    {
      const int lungh = codice.len();
      if (lungh > 0 && lungh < 3)
        return f.error_box("Il codice del gruppo merceologico deve avere obbligatoriamente lunghezza 3");
    }
  }

  return true;
}

void TVendite_tabapp::write_gmc(const TMask& m, TRectype& curr)
{
  //la tabella gmc è + incasinata causa la presenza di uno sheet che va salvato come tokenstring(;separated)..
  //di tokenstrings(|separated) in uno o due campi alfanumerici
  TSheet_field& listini = m.sfield(F_RIGHE_LIS);
  TToken_string s1(70, ';'), s2(70, ';');
  FOR_EACH_SHEET_ROW (listini, r, riga)
  {
    TToken_string mini_string(12, SAFE_PIPE_CHR);   //separatore broken_pipe !!!
    mini_string.add(riga->get(0));      //catven
    mini_string.add(riga->get());       //codlis
    mini_string.add(riga->get());       //ricarico
    mini_string.trim();
    if (!mini_string.empty_items())
    {
      if (s1.len() + mini_string.len() < 70)
        s1.add(mini_string);
      else
      {
        if (s2.len() + mini_string.len() < 70)
          s2.add(mini_string);
      }
    }
  }
  curr.put("S1", s1);
  curr.put("S2", s2);
}

int TVendite_tabapp::write(const TMask& m)
{
  TRectype& curr = get_relation()->curr();
	if (is_table("SPP"))
		curr.put("R0",	m.get(SPP_PREZZO)); else
	if (is_table("PRS"))
		curr.put("R0",	m.get(PRS_PREZZO));	else
	if (is_table("RSS"))
		curr.put("R0",	m.get(RSS_PREZZO));	else
	if (is_table("ATR"))
		curr.put("R0",	m.get(ATR_PREZZO));
  if (is_table("GMC"))
    write_gmc(m ,curr);

  return Tab_application::write(m);
}

int TVendite_tabapp::rewrite(const TMask& m)
{
  TRectype& curr = get_relation()->curr();

	if (is_table("SPP"))
		curr.put("R0",	m.get(SPP_PREZZO)); else
	if (is_table("PRS"))
		curr.put("R0",	m.get(PRS_PREZZO));	else
	if (is_table("RSS"))
		curr.put("R0",	m.get(RSS_PREZZO));	else
	if (is_table("ATR"))
		curr.put("R0",	m.get(ATR_PREZZO));
  if (is_table("GMC"))
    write_gmc(m ,curr);

	return Tab_application::rewrite(m);
}


bool TVendite_tabapp::user_create()
{
  bool ok = TTable_application::user_create();
  if (ok) 
  {
    const TString& name = get_tabname();
    if (name == TAB_GRMERC)
    {
      TMask& mask = *get_mask();
      mask.set_handler(201, codgmc_handler);
    }
  }
  return ok;
}


int ve0400(int argc, char* argv[])
{
  TVendite_tabapp vta;
  vta.run(argc, argv, TR("Tabella Vendite"));
  return 0;
}