campo-sirio/ve/ve2600.cpp

#include <automask.h>
#include <defmask.h>
#include <msksheet.h>
#include <mask.h>
#include <recarray.h>
#include <recset.h>
#include <tabapp.h>

#include <multirel.h>
#include "../mg/anamag.h"
#include "../mg/mglib.h"
#include "ve2600a.h"

#define FILE_KEY "ARTLV"

///////////////////////////////////////////////////////////
// TArtgiac_mask maschera
///////////////////////////////////////////////////////////

class TArtgiac_mask : public TAutomask
{
	TString _query;
	bool _filter_changed;
	TCodgiac_livelli * _livelli_giac;

public:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);
	TCodgiac_livelli & livelli_giac() const { return *_livelli_giac;}

  TArtgiac_mask();
	~TArtgiac_mask() { delete _livelli_giac; }
};

TArtgiac_mask::TArtgiac_mask() : TAutomask("ve2600a")
{
	_livelli_giac = new TCodgiac_livelli() ;
	TSheet_field & sh = sfield(F_LIVGIAC);
	TMask & sh_mask = sh.sheet_mask();
	TString80 prompt;

  for (int i=0; i < 4; i++)          
  {
    _livelli_giac->set_sheetcolumn(sh,F_LIV1+i,i+1);
    if (_livelli_giac->autoinsert(i+1))
    {
      // codice autoinseribile
      TMask_field & campo_liv = sh.sheet_mask().field(F_LIV1+i);

      campo_liv.check_type(CHECK_SEARCH);
    }
  }
}

bool TArtgiac_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
	switch (o.dlg())
	{
		case F_LIV1:
		case F_LIV2:
		case F_LIV3:
		case F_LIV4:
			if (e == fe_modify && !o.empty()) 
			{
				
				const int levnum = o.dlg()-F_LIV1+1;
				return _livelli_giac->autoinsert(levnum, o);
			}
			break;
		case F_LIVGIAC:
			if (e == se_notify_add)
			{
				TSheet_field & sf = (TSheet_field &) o;
				TMask & m = sf.sheet_mask();
				const int nrow = sf.selected() + 1; 
				TToken_string & row = sf.row(nrow);

				row.add("X", sf.cid2index(F_ATTIVO));
				sf.check_row(nrow);
				sf.force_update(nrow);
			}
			else
			if (e == se_query_del)
			{
				TSheet_field & sf = (TSheet_field &) o;
				TMask & m = sf.sheet_mask();
			  TString80 codgiac;

				livelli_giac().pack_grpcode(codgiac, m.get(F_LIV1), 1); 
				livelli_giac().pack_grpcode(codgiac, m.get(F_LIV2), 2); 
				livelli_giac().pack_grpcode(codgiac, m.get(F_LIV3), 3); 
				livelli_giac().pack_grpcode(codgiac, m.get(F_LIV4), 4); 
				return codgiac.blank();
			}
		default:
			break;
	}
  return true;
}

class TRelArticoligiac_multirel_app : public TMultirel_application
{
	TArtgiac_mask * _mask;
	TRelation * _rel;

protected:
	virtual void get_mask_name(TString& tabname) const { tabname = "ve2600a";}

	//magico metodo per impedire la navigazione su tabelle diverse da quella corrente del cursore
	virtual bool has_filtered_cursor() const { return true; }
  virtual bool user_create();
  virtual bool user_destroy() ;
	virtual int read(TMask& m);
  virtual int rewrite(const TMask& m);
  virtual int write(const TMask& m) { return rewrite(m);}
  virtual bool remove();
  virtual void  init_insert_mode(TMask& m) { read(m); }
  virtual bool find(word key = 0);
	virtual TMask* get_mask(int mode = MODE_QUERY) { return (TMask *) _mask;}
  virtual TRelation* get_relation() const { return _rel;}
  
public:
  TRelArticoligiac_multirel_app() {}
  virtual ~TRelArticoligiac_multirel_app() {}
};

bool TRelArticoligiac_multirel_app::user_create()
{
	TMultirel_application::user_create();
	_mask = new TArtgiac_mask;
	
	if (!_mask->livelli_giac().enabled())
		return warning_box("gestione livelli di giacenza non abilitata");
	_rel = new TRelation(LF_ANAMAG);
	set_search_field(F_CODART);

	return true;
}

bool TRelArticoligiac_multirel_app::user_destroy()
{
	delete _mask;
	delete _rel;
	return TMultirel_application::user_destroy();
}

int TRelArticoligiac_multirel_app::read(TMask& m)
{
	TLocalisamfile multirel(LF_MULTIREL);
	TArtgiac_mask & mask = (TArtgiac_mask &) m;
	TString80 codart(m.get(F_CODART));
	const TString & cod = get_relation()->lfile().get(ANAMAG_CODART);
	TSheet_field & sf = m.sfield(F_LIVGIAC);
	const int col_lev1 = sf.cid2index(F_LIV1);
	const int col_lev2 = sf.cid2index(F_LIV2);
	const int col_lev3 = sf.cid2index(F_LIV3);
	const int col_lev4 = sf.cid2index(F_LIV4);
	const int col_attivo = sf.cid2index(F_ATTIVO);
	int i = 0;
	
	if (cod.full() && cod != codart)
	{
		codart = cod;
		m.set(F_CODART, codart, 0x2);
	}
	sf.destroy();
	multirel.zero();
	multirel.put(MULTI_COD, FILE_KEY);
	multirel.put(MULTI_FIRST, codart);
  for ( int err = multirel.read(_isgteq); err == NOERR && codart == multirel.get(MULTI_FIRST); err = multirel.next())
	{
		TToken_string & row = sf.row(i++);
	  const TString & codgiac =	multirel.get(MULTI_SECOND);
		
		row.add(mask.livelli_giac().unpack_grpcode(codgiac, 1), col_lev1);
		row.add(mask.livelli_giac().unpack_grpcode(codgiac, 2), col_lev2);
		row.add(mask.livelli_giac().unpack_grpcode(codgiac, 3), col_lev3);
		row.add(mask.livelli_giac().unpack_grpcode(codgiac, 4), col_lev4);
		row.add("X", col_attivo);
		sf.check_row(i - 1);
	}

  return NOERR;
}

int TRelArticoligiac_multirel_app::rewrite(const TMask& m)
{
	int err = NOERR;
	TLocalisamfile multirel(LF_MULTIREL);
	TSheet_field & sf = m.sfield(F_LIVGIAC);
	const TString& codart = m.get(F_CODART);
	TArtgiac_mask & mask = (TArtgiac_mask &) m;
	const int col_lev1 = sf.cid2index(F_LIV1);
	const int col_lev2 = sf.cid2index(F_LIV2);
	const int col_lev3 = sf.cid2index(F_LIV3);
	const int col_lev4 = sf.cid2index(F_LIV4);
  TString80 codgiac;

  for (int i = 0; i < sf.items(); i++)
  {
		TToken_string & row = sf.row(i);
		bool selected = *row.get(sf.cid2index(F_ATTIVO)) > ' ';

		mask.livelli_giac().pack_grpcode(codgiac, row.get(col_lev1), 1); 
    mask.livelli_giac().pack_grpcode(codgiac, row.get(col_lev2), 2); 
    mask.livelli_giac().pack_grpcode(codgiac, row.get(col_lev3), 3); 
    mask.livelli_giac().pack_grpcode(codgiac, row.get(col_lev4), 4); 
		if (codgiac.full())
		{
			multirel.zero();
			multirel.put(MULTI_COD, FILE_KEY);
			multirel.put(MULTI_FIRST, codart);
			multirel.put(MULTI_SECOND, codgiac);

			bool exist = multirel.read(_isequal) == NOERR;

			if (exist && !selected)
				err = multirel.remove();
			else
				if (!exist && selected)
				{
					multirel.zero();
					multirel.put(MULTI_COD, FILE_KEY);
					multirel.put(MULTI_FIRST, codart);
					multirel.put(MULTI_SECOND, codgiac);
					err = multirel.write();
				}
		}
	}
	TRelation & r = *get_relation();

	r.lfile().put(ANAMAG_CODART, codart);
	r.read(_isequal);
	return err;
}

bool TRelArticoligiac_multirel_app::remove()
{
	int err;
	TLocalisamfile multirel(LF_MULTIREL);
	const TString& codart = _mask->get(F_CODART);

	multirel.put(MULTI_COD, FILE_KEY);
	multirel.put(MULTI_FIRST, codart);

  for (err = multirel.read(_isgteq); err == NOERR && codart == multirel.get(MULTI_FIRST); err = multirel.next())
		err = multirel.remove();
	return err == NOERR || err == _iseof;
}

bool TRelArticoligiac_multirel_app::find(word key)
{
	bool ok = false;
	const TString& codart = _mask->get(F_CODART);
	
	if (codart.full())
	{
		TLocalisamfile multirel(LF_MULTIREL);

		multirel.put(MULTI_COD, FILE_KEY);
		multirel.put(MULTI_FIRST, codart);
		ok = (multirel.read(_isgteq) == NOERR) && (codart == multirel.get(MULTI_FIRST));
		if (ok)
		{
			TRelation & r = *get_relation();

			r.lfile().put(ANAMAG_CODART, codart);
			r.read(_isequal);
		}
	}
	return ok;
}

int ve2600(int argc, char* argv[])
{
  TRelArticoligiac_multirel_app a;
  a.run(argc, argv, TR("Relazioni articoli livelli di giacenza"));
  return 0;
}