campo-sirio/ve/ve2400.cpp

#include "velib.h"
#include "ve2400.h"
#include "ve2401.h"

#include "../ca/calib01.h"

#include <modaut.h>
#include <relapp.h>
#include <tabutil.h>
#include <urldefid.h>

//---------------------------------------------------
// MASCHERA ANAGRAFICA MAGAZZINO
//---------------------------------------------------
class TMask_anamag: public TMask 
{
  TRelation* _rel; // relazione principale
  
  TCodgiac_livelli* livelli_giac;// oggetto handler  per i livelli di giacenza
  TCodart_livelli* livelli_art;// oggetto handler  per i livelli di anagraficca
  int last_annogiac, last_annosto;
  
  int _type_cod, _altype_cod;
  TString4 _ean8_pref;
  TString8 _ean13_pref;
	bool		 _ean8_cin;
  TString16 _generated_code;

  TString4 _um_principale;
  TMagazzini *_magazzini;
  TEsercizi_contabili *_esercizi_contabili;

  static bool handle_codice(TMask_field &, KEY); // handler del campo codice articolo
  static bool handle_anno(TMask_field &, KEY); // handler del campo anno delle giacenze
  static bool handle_stoanno(TMask_field &, KEY); // handler del campo anno delle giacenze
  static bool handle_stoanno_row(TMask_field &, KEY); // handler del campo anno delle giacenze sulle righe
  static bool handle_sheet_um(TMask_field &, KEY); // handler dello sheet delle unit<69> di misura
  static bool notify_sheet_um(TSheet_field & s, int r, KEY k); // notify dello sheet delle unit<69> di misura
  static bool handle_sheet_deslin(TMask_field &, KEY); // handler dello sheet delle descrizioni in lingua
  static bool handle_sheet_cod(TMask_field &, KEY); // handler dello sheet dei codici alternativi
  static bool notify_sheet_cod(TSheet_field & s, int r, KEY k); // notify dello sheet delle unit<69> di misura
  static bool handle_codcorr(TMask_field &, KEY); // handler dello sheet dei codici alternativi
  static bool notify_sheet_giac(TSheet_field & s, int r, KEY k); // notify delle giacenze
  static bool handle_sheetgiac(TMask_field &, KEY); // handler dello sheet giacenze
  static bool notify_sheet_sto(TSheet_field & s, int r, KEY k); // notify dello storico
  static bool handle_sheetstomag(TMask_field &, KEY); // handler dello sheet storico giacenze
  static bool handle_sheet_um_um(TMask_field &, KEY); // handler del campo UM dello sheet delle unit<69> di misura
  static bool handle_sheet_um_price(TMask_field &, KEY); // handler del campo PREZZO e PREZZO_LORDO dello sheet delle unit<69> di misura
  static bool handle_sheet_giac_codmag(TMask_field &, KEY); // handler 
  static bool handle_sheet_giac_valgiac(TMask_field &, KEY); // handler 
  static bool handle_sheet_stomag_stoval(TMask_field &, KEY); // handler 
  static bool handle_autoinsert_livgiac(TMask_field &, KEY); // handler del campo 
  static bool handle_classdog2(TMask_field&, KEY); // handler del secondo sottocampo della classe doganale

  static void sheetgiac_get(TSheet_field &fld_righe, int item);
  static void sheetgiac_put(TSheet_field &fld_righe, int item);
  static void sheetsto_get(TSheet_field &fld_righe, int item);
  static void sheetsto_put(TSheet_field &fld_righe, int item);

  void clear_info_sto();
  bool info_sto_dirty();
  int add_totali_storico(TString &codmag);
  bool remove_totali_storico(TString & codmag);
  void update_totali_storico(TString & codmag);
  bool check_totali_storico();
	void create_user_fields();
  
public:
  bool generate_code(int _type = 0);
  void update_ordc_ordf();
  void set_parametered_fields();
  void ricalcola_giacenze();
  TCodart_livelli * get_livelli_art() const { return livelli_art; }

  const TString& generated_code() { return _generated_code; }
  TString& um_principale()  { return _um_principale; }
  TMagazzini& magazzini()   { return *_magazzini; }

  TEsercizi_contabili &esercizi_contabili()    {return *_esercizi_contabili;}

  TMask_anamag(TRelation * rel);
  virtual ~TMask_anamag();
};

//--------------------------------------------
//  APPLICAZIONE
//--------------------------------------------
class TAnagrafica_magazzino : public TRelation_application 
{
  TMask_anamag *_msk; // maschera principale
  TRelation *_rel; // relazione principale di un solo file (anagrafiche di magazzino)

protected:    
  virtual bool user_create();
  virtual bool user_destroy();                        
  virtual TMask *get_mask(int) { return _msk; }
  virtual bool changing_mask(int) { return false; }
  virtual void init_query_mode(TMask&);
  virtual void init_insert_mode(TMask&);
  virtual void init_modify_mode(TMask&);

  virtual void on_firm_change();
  bool search_on_file(const char * key, int file, int nkey, const char * field);
  virtual bool protected_record(TRectype&);
  
  virtual int read(TMask& m);
  void load_um(TMask& m);
  virtual bool remove();
  virtual int write(const TMask& m);             
  virtual int rewrite(const TMask& m);           
  
  virtual void ini2sheet(TConfig& ini, TSheet_field &sheet);
  virtual void sheet2ini(TSheet_field &sheet,TConfig& ini);

  static bool handle_copia(TMask_field &, KEY); // handler della copia articolo

public:
  virtual TRelation *get_relation() const { return _rel; }
  // @cmember Disabilita la verifica del modulo : essendo una anagrafica, va sempre abilitata
  virtual bool check_autorization() const { return false; }
  TAnagrafica_magazzino() { _rel = NULL; _msk = NULL;}
  virtual ~TAnagrafica_magazzino() {}
};

inline TAnagrafica_magazzino& app() { return (TAnagrafica_magazzino&) main_app(); }

//-------------------------------------------------------------------------------------------------
//  METODI DELLA MASCHERA
//-------------------------------------------------------------------------------------------------
//------------------------------------------
//gestione codice articolo multilivello
//------------------------------------------
static bool handle_subcodice(TMask_field &fld, KEY k)
{
  TMask &mask=fld.mask();
  if (k == K_TAB && (fld.focusdirty()||!mask.is_running())) //c'e' qualcosa nel campo
  { 
    //quale e' l'ultimo campo valido per codart in multilevel?
    short id_last = fld.dlg();
    while (id_last <= F_LIVART9 && mask.id2pos(id_last+1) > 0)
      id_last++;
    
    if (fld.empty())
    {
      //gira su tutti i campi di livart esistenti e successivi al livello corrente
      for(short id = fld.dlg()+1; id <= id_last; id++)
      {
        mask.set(id, "");
        mask.disable(id);
      }
    }
    else
    {
      const int pos = mask.id2pos(fld.dlg()+1);
      if (pos > 0)
      {
        TMask_field& next_fld = mask.fld(pos);
        next_fld.enable();
      }
    }
//riempie in automatico il campo codice complessivo
    TString80 stringone;
    bool completo = true;
    for(short id = F_LIVART1; id <= id_last; id++)
    {
      const TString& val = mask.get(id);
      if (val.blank())
      {
        completo = false;
        break;
      }
      stringone << val;
    }
    
    mask.set(F_CODART, stringone, fld.dlg()==id_last ? 0x3 : 0x0);
  }
  return true;
}

void create_browse1(TEdit_field& kfld, int level, short key_id, short des_id, const TCodart_livelli &cal, const bool chktyp)
{
  TFilename tmp; tmp.temp();
  ofstream out(tmp);

  out << "USE GCA" << endl; //usa la tabella dei livelli articolo

  const short id = key_id + level - 1;
  const TString& prompt = cal.name(level);
  const TString& picture = cal.picture(level);
  out << "IN CODTAB[1,1] \"" << level << "\"" << endl;
  out << "IN CODTAB[2,0] " << id << endl;
  out << "DI \"" << prompt;
  const int length = cal.code_length(level);
  if (length > prompt.len())
    out << '@' << length;
  out << "\" CODTAB[2,0]" << endl;
  out << "DI \"" << TR("Descrizione") << "@50\" S0" << endl; 
  out << "OU " << id << " CODTAB[2,0]" << endl;
  out << "OU " << (des_id + level -1) << " S0" << endl;

  if (chktyp)
  {
    if (level == 1)
      out << "CH RE" << endl;
    else
      out << "CH NO" << endl;
  }
  out << "EN" << endl;
  out.close();

  TScanner scan(tmp);
  while (scan.pop() != "EN")
    kfld.parse_item(scan);

  xvt_fsys_removefile(tmp);
}

void create_browse2(TEdit_field& kfld, int level, short key_id, short des_id, const TCodart_livelli &cal, const bool chktyp)
{
  TFilename tmp; tmp.temp();
  ofstream out(tmp);

  out << "USE GCA KE 2 SELECT CODTAB[1,1]=='" << level << "'" << endl;  //cerca per descrizione

  const short id = des_id + level - 1;
  out << "IN S0 " << id << endl;
  out << "DI \"" << TR("Descrizione") << "@50\" S0" << endl;
  
  const TString& prompt = cal.name(level);
  out << "DI \"" << prompt;
  const int length = cal.code_length(level);
  if (length > prompt.len())
    out << '@' << length;
  out << "\" CODTAB[2,0]" << endl;

  out << "CO OU " << (key_id + level -1) << endl;
  if (chktyp)
    out << "CH NO" << endl;
  out << "EN" << endl;
  out.close();

  TScanner scan(tmp);
  while (scan.pop() != "EN")
    kfld.parse_item(scan);

  xvt_fsys_removefile(tmp);
}

int create_fields(TMask& msk, int x, int y, short key_id, short des_id, const TCodart_livelli &cal, const bool chktyp)
{
  const int last_level = cal.last_level();

  int tab0 = x;
  int i;
  for (i = 1; i <= last_level; i++) //cicla su tutti i livelli del codart abilitati
  {
    // codice livello articolo
    const short kid = key_id+i-1;
    const TString& picture = cal.picture(i); 
    
    TString4 flags = "BU";
    if (picture[0] == '0')
      flags << 'Z';

    TEdit_field& kfld = msk.add_string(kid, 0, "", tab0, y, picture.len(), flags);
    kfld.set_key(1);
    create_browse1(kfld, i, key_id, des_id, cal, chktyp);

    kfld.set_handler(handle_subcodice);
    tab0 += picture.len()+3;
  }
  for (i = 1; i <= last_level; i++)
  {
    // descrizione livello articolo
    const short did = des_id+i-1;
    TEdit_field& dfld = msk.add_string(did, 0, "", 200, y, 50, "", 50);
    dfld.set_key(1);
    create_browse2(dfld, i, key_id, des_id, cal, chktyp);
  }
  
  return cal.last_level();
}

void TMask_anamag::set_parametered_fields()
{
  // abilitazioni parametriche
  
  if (livelli_giac)
    delete livelli_giac;
  if (livelli_art)
    delete livelli_art;
  if (_esercizi_contabili)
    delete _esercizi_contabili;
  if (_magazzini)
    delete _magazzini;
  
  _esercizi_contabili = new TEsercizi_contabili;
  _magazzini          = new TMagazzini;
  
  // imposta il puntatore al gestore livelli giacenze
  livelli_giac= new TCodgiac_livelli();
  livelli_art= new TCodart_livelli();
  // imposta il valore dell'anno per le giacenze
  last_annogiac=-1;
  last_annosto=-1;

  // Abilita la pagina delle giacenze 
  const bool gestmag = app().has_module(MGAUT) && magazzini().gestmag();

  if (gestmag)
  {
// sheet giacenze
    set_handler(F_ANNO, handle_anno );
    set_handler(F_SHEETGIAC, handle_sheetgiac);
    
    TSheet_field& sgiac = sfield(F_SHEETGIAC);
    sgiac.set_userget(sheetgiac_get);
    sgiac.set_userput(sheetgiac_put);
    sgiac.sheet_mask().set_handler(F_CODMAG, handle_sheet_giac_codmag);
    sgiac.sheet_mask().set_handler(F_VALGIAC, handle_sheet_giac_valgiac);
// sheet storico
    set_handler(F_SHEETSTOMAG, handle_sheetstomag);
    sfield(F_SHEETSTOMAG).set_notify(notify_sheet_sto);
    sfield(F_SHEETSTOMAG).set_userget(sheetsto_get);
    sfield(F_SHEETSTOMAG).set_userput(sheetsto_put);
    TMask& stomask = sfield(F_SHEETSTOMAG).sheet_mask();
  
    stomask.set_handler(F_STOVAL, handle_sheet_stomag_stoval);
    stomask.set_handler(F_STOANNOES, handle_stoanno_row);
    
    set_handler(F_STOANNO, handle_stoanno);
  }

  set_handler(F_CLASSDOG2, handle_classdog2);
    
  // setta i campi della maschera per la pagina giacenze
  TSheet_field &fld_stomag = sfield(F_SHEETSTOMAG); 
  TSheet_field &fld_giac = sfield(F_SHEETGIAC);
	fld_giac.set_notify(notify_sheet_giac);
  TSheet_field &fld_cod = sfield(F_SHEETCOD); 
  // disabilita le colonne quando non sono utilizzati i livelli di giacenza

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

      campo_liv.check_type(CHECK_SEARCH);
      campo_liv.set_handler(gestmag ? handle_autoinsert_livgiac : NULL);

      TMask_field & campo_liv_cod = fld_cod.sheet_mask().field(FS_LIV1+i);

      campo_liv_cod.check_type(CHECK_SEARCH);
    }
  }

  /*
  // disabilita la colonna numero distinte
  if (FALSE) 
  {
    fld_giac.delete_column(fld_giac.cid2index(F_NDIST));
    fld_giac.sheet_mask().field(F_NDIST).enable(FALSE);
  } 
*/
  // abilita la gestione delle ubicazioni (manuale/su tabella)
  const bool ubi = gestmag && magazzini().gestubi_man();
  fld_giac.sheet_mask().field(F_UBICAZ).show(!ubi);
  fld_giac.sheet_mask().field(F_UBICAZD).show(!ubi);
  fld_giac.sheet_mask().field(F_UBICAZ2).show(ubi);

  // abilita la gestione del monomagazzino
  const bool mm = gestmag && magazzini().gestmultimag();
  fld_giac.sheet_mask().field(F_DESMAG).enable(mm);
  fld_giac.enable_column(fld_giac.cid2index(F_CODMAG),mm);
  fld_giac.enable_column(fld_giac.cid2index(F_CODDEP),gestmag && magazzini().gestdep());
  fld_stomag.enable_column(fld_stomag.cid2index(F_STOCODMAG),mm);

  enable_page(PAGE_GIACENZE,gestmag);
  enable_page(PAGE_STORICO,gestmag);

  // abilita la visualizzazione dei campi per la vendita al dettaglio
	const bool dettaglio = app().has_module(VDAUT);

  show(-G_VD, dettaglio);
  // abilita la visualizzazione dei campi distinti per i livelli articolo 
  set_handler(F_CODART, handle_codice);
}

void TMask_anamag::create_user_fields()
{
  TConfig c(CONFIG_DITTA, "ve");

  _type_cod = c.get_int("GEN_EAN");
  _altype_cod = c.get_int("ALT_EAN");
  _ean8_pref = c.get("EAN8");
  _ean13_pref = c.get("EAN13");
  _ean8_cin = c.get_bool("EAN8CIN");
  _ean13_pref = c.get("EAN13");

  bool disable_user_page = true;

  TString80 prompt;
  
  for (int i = 1; i <= 10; i++)
  {                  
    if (c.get_bool("CHK_USER", "ve", i))
    {  
      TEditable_field * f = NULL;            
      prompt = c.get("PROMPT_USER", "ve", i);
      prompt.rpad(20);              
      const char type = c.get_char("TYPE_USER", "ve", i);
      if (type == 'S')
        f = &add_string(F_USER1 + i - 1, PAGE_USER, prompt, 2, 3 + i, c.get_int("LEN_USER", "ve", i));
      else
        if (type == 'N')
        {
          f = &add_number(F_USER1 + i - 1, PAGE_USER, prompt, 2, 3 + i, c.get_int("LEN_USER", "ve", i));
          ((TReal_field *) f)->set_decimals(c.get_int("DEC_USER", "ve", i));
        }
        else
          if (type == 'D')
            f = &add_date(F_USER1 + i - 1, PAGE_USER, prompt, 2, 3 + i);
          else
            if (type == 'I')
              f = &add_currency(F_USER1 + i - 1, PAGE_USER, prompt, 2, 3 + i, c.get_int("LEN_USER", "ve", i));
            else
              if (type == 'X')
                f = &add_boolean(F_USER1 + i - 1, PAGE_USER, prompt, 2, 3 + i);
       if (f != NULL) 
       {
         TString8 u; u.format("USER%d", i);
         f->set_field(u);
       }
      disable_user_page = false;
    }
  } 
 
  if (disable_user_page)
    disable_page(PAGE_USER);  
}

// costruttore della maschera anagrafica di magazzino
TMask_anamag::TMask_anamag(TRelation * rel) : TMask("ve2400")
{
  _rel=rel;

  // sheet unit<69> di misura
  set_handler(F_SHEETUM, handle_sheet_um);
  TSheet_field &f= sfield(F_SHEETUM);
  f.set_notify(notify_sheet_um);
  TMask &fm= f.sheet_mask();
  fm.set_handler(FS_CODUM, handle_sheet_um_um);
  fm.set_handler(FS_PREZZO, handle_sheet_um_price);
  fm.set_handler(FS_PREZZO_LORDO, handle_sheet_um_price);
  
  TRecord_array* um = new TRecord_array(LF_UMART, "NRIGA");
  f.set_lines_record(*um);

  // sheet descrizioni in lingua
  set_handler(F_SHEETDESLIN, handle_sheet_deslin);
  // sheet codici corrispondenti
  set_handler(F_SHEETCOD, handle_sheet_cod);
  TSheet_field &fc= sfield(F_SHEETCOD);
  TMask &fmc = fc.sheet_mask();
  fmc.set_handler(FS_CODARTALT, handle_codcorr);
  
  livelli_giac = NULL;
  livelli_art  = NULL;
  _esercizi_contabili = NULL;
  _magazzini = NULL;
  
  set_parametered_fields();

  ca_create_fields(*this, 1, LF_PCONANA, 1, 7, F_CONTOPCIA, F_DESCRCONTOPCIA, 0, ANAMAG_CONTOINDA);
  ca_create_fields(*this, 1, LF_PCONANA, 1,13, F_CONTOPCIV, F_DESCRCONTOPCIV, 0, ANAMAG_CONTOINDV);
  
  create_user_fields();

  if (livelli_art->enabled())
	{
    create_fields(*this, 1, 1, F_LIVART1, F_DESLIVART1, *livelli_art, true);
    first_focus(F_LIVART1);
	}
	else
  {
    if (advanced_codart_enabled())
    {
      TButton_field& bu = add_button(F_ADVANCED, 0, PR("Codice guidato"), 1, 1, 20);
      bu.set_handler(advanced_codart_handler);
    }
    first_focus(F_CODART);
  }
}

void TMask_anamag::sheetsto_put(TSheet_field &sheet_sto, int item)
{
  if (item>1) return;
  TMask_anamag & m=(TMask_anamag & )sheet_sto.mask();
  TRectype & first_rec=sheet_sto.record()->row(1,TRUE);
  first_rec.put(STOMAG_ULTCOS1,m.get_real(F_STOULTCOS1 ));
  first_rec.put(STOMAG_ULTCOS2,m.get_real(F_STOULTCOS2 ));
  first_rec.put(STOMAG_COSTSTD,m.get_real(F_STOCOSTOSTD ));
  first_rec.put(STOMAG_COSTOMEDIO,m.get_real(F_STOCOSTOMEDIO ));
  first_rec.put(STOMAG_CATVEN,m.get(F_STOCATVEN ));
  first_rec.put(STOMAG_CODLISTINO,m.get(F_STOCODLIST));
  first_rec.put(STOMAG_PRZLIST,m.get(F_STOPREZZOLIST ));
}

void TMask_anamag::sheetsto_get(TSheet_field &sheet_sto, int item)
{
  TMask_anamag & m=(TMask_anamag &) sheet_sto.mask();

  if (item>1) return;
  TRectype & first_rec=sheet_sto.record()->row(1,TRUE);
  m.set(F_STOULTCOS1,    first_rec.get_real(STOMAG_ULTCOS1));
  m.set(F_STOULTCOS2,    first_rec.get_real(STOMAG_ULTCOS2 ));
  m.set(F_STOCOSTOSTD,   first_rec.get_real( STOMAG_COSTSTD ));
  m.set(F_STOCOSTOMEDIO, first_rec.get_real(STOMAG_COSTOMEDIO));
  m.set(F_STOCATVEN ,    first_rec.get(STOMAG_CATVEN));
  m.set(F_STOCODLIST ,   first_rec.get(STOMAG_CODLISTINO));
  m.set(F_STOPREZZOLIST ,first_rec.get(STOMAG_PRZLIST));
}

bool TMask_anamag::info_sto_dirty()
{
  return 
  field(F_STOULTCOS1).focusdirty() ||
    field(F_STOULTCOS2).focusdirty() ||
      field(F_STOCOSTOSTD).focusdirty() ||
        field(F_STOCOSTOMEDIO).focusdirty()||
          field(F_STOCATVEN ).focusdirty()||
            field(F_STOCODLIST).focusdirty()||
              field(F_STOPREZZOLIST).focusdirty();
}


void TMask_anamag::clear_info_sto()
{
  reset(F_STOULTCOS1);
  reset(F_STOULTCOS2);
  reset(F_STOCOSTOSTD);
  reset(F_STOCOSTOMEDIO);
  reset(F_STOCATVEN );
  reset(F_STOCODLIST);
  reset(F_STOPREZZOLIST);
}
  

TMask_anamag::~TMask_anamag()
{
  if (livelli_art)
    delete livelli_art;
  if (livelli_giac)
    delete livelli_giac;
  if (_esercizi_contabili)
    delete _esercizi_contabili;
  if (_magazzini)
    delete _magazzini;
}


bool TMask_anamag::handle_autoinsert_livgiac(TMask_field &fld, KEY k)
{
  if (k == K_TAB && fld.focusdirty() && !fld.empty()) 
  {
    TMask_anamag & mask=(TMask_anamag &) fld.mask().get_sheet()->mask();
    const int levnum=fld.dlg()-F_LIV1+1;
    return mask.livelli_giac->autoinsert(levnum, fld);
  }
  return TRUE;
}


//  HANDLER DEL CODICE: controlla la corrispondenza al formato previsto
bool TMask_anamag::generate_code(int type)
{     
  if (type <= 0)
    type = _type_cod;
  if (type <= 0)
    return false;
               
  TString cod(20);
  long progr  = 0;
  
  if (type == 8)
  {
    if (_ean8_pref.empty())
      return false;
    cod = _ean8_pref;
    cod << "999";               
    if (_type_cod != 0)
    {
      TLocalisamfile anamag(LF_ANAMAG);
      anamag.put(ANAMAG_CODART, cod);

      if (anamag.read(_isgteq) != _isemptyfile)
      {
        cod = anamag.get(ANAMAG_CODART);
        
        if (_ean8_pref < cod.left(4))
        {
          anamag.prev();
          cod = anamag.get(ANAMAG_CODART);
        }  
        if (_ean8_pref == cod.left(4))
          progr = atol(cod.right(3));
      }
    }  
    else
    {
      TLocalisamfile codcorr(LF_CODCORR);
      codcorr.setkey(2);
      codcorr.put(CODCORR_CODARTALT, cod);
  
      if (codcorr.read(_isgteq) != _isemptyfile)
      {
        cod = codcorr.get(CODCORR_CODARTALT);
        
        if (_ean8_pref < cod.left(4))
        {
          codcorr.prev();
          cod = codcorr.get(CODCORR_CODARTALT);
        }  
        if (_ean8_pref == cod.left(4))
				{
					if (_ean8_cin)
				    progr = atol(cod.mid(4, 3));
					else
				    progr = atol(cod.right(3));
				}
      }
    }
    progr++;
    if (progr < 1000)
    {
		  _generated_code.format("%4s%03ld", (const char*)_ean8_pref, progr);
		  if (_ean8_cin)
		  {
			  int icin = (_generated_code[6]+_generated_code[4]+_generated_code[2]+_generated_code[0] - 4*'0')*3;
			  icin += _generated_code[5]+_generated_code[3]+_generated_code[1] - 3*'0';
        const char cin = '0' + (10-(icin % 10))%10;
	      _generated_code << cin;
		  }
    }
    else
      return error_box(FR("Sono gia' stati generati 1000 codici sul prefisso %s"), (const char*)_ean8_pref);
  }
  else
  {
    if (_ean13_pref.empty())
      return false;
    cod = _ean13_pref;
    cod << "999999";
    if (_type_cod != 0)
    {
      TLocalisamfile anamag(LF_ANAMAG);
      anamag.put(ANAMAG_CODART, cod);
    
      if (anamag.read(_isgteq) != _isemptyfile)
      {
        cod = anamag.get(ANAMAG_CODART);
        
        if (_ean13_pref < cod.left(6))
        {
          anamag.prev();
          cod = anamag.get(ANAMAG_CODART);
        }  
        if (_ean13_pref == cod.left(6))
          progr = atol(cod.right(6));
      }
    }  
    else
    {
      TLocalisamfile codcorr(LF_CODCORR);
      codcorr.setkey(2);
      codcorr.put(CODCORR_CODARTALT, cod);
  
      if (codcorr.read(_isgteq) != _isemptyfile)
      {
        cod = codcorr.get(CODCORR_CODARTALT);
        
        if (_ean13_pref < cod.left(6))
        {
          codcorr.prev();
          cod = codcorr.get(CODCORR_CODARTALT);
        }  
        if (_ean13_pref == cod.left(6))
          progr = atol(cod.right(6));
      }
    }
    progr++;
    _generated_code.format("%s%06ld", (const char *)_ean13_pref, progr);
  }             
  return true;
}

bool TMask_anamag::handle_codice(TMask_field &fld, KEY k)
{
  TMask_anamag &mask=(TMask_anamag &)fld.mask();

  if (k == K_TAB && !fld.get().blank() && mask.livelli_art->enabled()) 
  {
    TString80 codepart;
  
    int l;
    //ciclo di riempimento dei sottocodici articolo nella maschera
    for (l=1; l <= mask.livelli_art->last_level(); l++) 
    {
      const TString pezzo_di_codice = mask.livelli_art->unpack_grpcode(fld.get(),l);
      mask.set(F_LIVART1+l-1, pezzo_di_codice); //scrive nei campi del codice a livelli i pezzi
                                                //del codart completo
    }
    //ciclo di controllo dei sottocodici (devono esistere nella tabella GCA, tutti tranne l'ultimo)
    for (l=1; l<mask.livelli_art->last_level(); l++) 
    {
      const TString pezzo_di_codice = mask.livelli_art->unpack_grpcode(fld.get(),l);
      mask.set(F_LIVART1+l-1, pezzo_di_codice); 
      codepart.cut(0) << l << pezzo_di_codice;
      if (cache().get("GCA", codepart).empty())
      {
        fld.error_box("'%s' non appartiene a '%s'",(const char *)codepart.mid(1),(const char *)mask.livelli_art->name(l));
        return(FALSE);
      }  
    }
    codepart=mask.livelli_art->unpack_grpcode(fld.get(),mask.livelli_art->last_level());
    if (codepart.blank()) 
    {
    /* Controllo casuale che va migliorato per gestire i sottocodici opzionali
      fld.error_box("Il codice articolo non pu<70> essere vuoto");
      return(FALSE);
      */
      return true;  
    } 
    
    if (!mask.livelli_art->fit_to_format(codepart)) 
    {
      fld.error_box("Il codice articolo non corrisponde al formato previsto \n('%s' ?? '%s')",(const char *)codepart,(const char *)mask.livelli_art->code_format());
      return(FALSE);
    }  
  }
  if (k == K_F8)
  {
    if (mask.generate_code())
    {
      fld.set(mask.generated_code());
      mask.stop_run(K_INS);
    }
  }
  return(TRUE);
}
  
bool TMask_anamag::handle_anno(TMask_field &fld, KEY k)
{
  if (k == K_TAB)
  {
    TMask_anamag &mask=(TMask_anamag &)fld.mask();
    TSheet_field& fld_giac = mask.sfield(F_SHEETGIAC);

    if (mask.get(F_ANNO).empty() )
    {
      mask.set(F_ANNORIF, mask.esercizi_contabili().last()) ;
      mask.set(F_ANNO, mask.get(F_ANNORIF));
    }
    if (mask.last_annogiac>0 && mask.last_annogiac!=fld.mask().get_int(F_ANNO)) 
    {
      if (fld_giac.dirty() && handle_sheetgiac(fld_giac,K_ENTER)) 
      {
        if (fld.yesno_box("Salvare le righe di giacenza per l'anno %d",mask.last_annogiac )) 
        {
          fld_giac.autosave(*mask._rel);
          fld_giac.record()->rewrite();
        } 
      }
      mask.field(F_ANNORIF).set(fld.get());
      // rilegge le giacenze relative a quell'anno ed aggiorna il layout
      fld_giac.record()->read(*fld_giac.putkey(*mask._rel));
      fld_giac.autoload(*mask._rel);
      fld_giac.force_update();
      
      mask.update_ordc_ordf();         //chiamata del metodo successivo
    }
    mask.last_annogiac=mask.get_int(F_ANNO);
  }
  return(TRUE);
}
  

void TMask_anamag::update_ordc_ordf()
{ 
  real ordc,ordf;
  const TDate oggi(TODAY);
  int es_corr = esercizi_contabili().date2esc(oggi);   // setta l'esercizio corrente (data come intero)
  int es_pred = esercizi_contabili().pred(es_corr);    //   "        "      precedente       "
  
  TRecord_array arr(LF_MAG, MAG_NRIGA);
  TRectype rec(LF_MAG);                                 // crea un record vuoto di LF_MAG

  for (int j = 0; j < 2; j++)
  {                                                  
    const int anno = j != 0 ? es_pred : es_corr;
    if (anno == get_int(F_ANNORIF))
    {
      TSheet_field &fld_giac = sfield(F_SHEETGIAC);  
      const int pos_ordc = fld_giac.cid2index(F_ORDC);
      const int pos_ordf = fld_giac.cid2index(F_ORDF);
      
      FOR_EACH_SHEET_ROW(fld_giac,i,row)
      {
        ordc += real (row->get(pos_ordc));
        ordf += real (row->get(pos_ordf)); 
      }
    }
    else
    {
      rec.put(MAG_ANNOES, anno);  // riempio il record campione
      rec.put(MAG_CODART, get(F_CODART));
      arr.read(rec);
      for (int i = arr.last_row(); i > 0; i = arr.pred_row(i))
      {
         ordc += arr[i].get_real(MAG_ORDC);
         ordf += arr[i].get_real(MAG_ORDF);
      }
    } 
  }
  
  set(F_TOT_ORD_CLI, ordc);
  set(F_TOT_ORD_FOR, ordf);  
}

bool TMask_anamag::handle_stoanno(TMask_field &fld, KEY k)
{
  static bool in_handler = FALSE;
  if (k == K_TAB && fld.focusdirty() && !in_handler)
  {                                                
    in_handler = TRUE;
    TMask_anamag &mask=(TMask_anamag &)fld.mask();
    TSheet_field &fld_stomag= mask.sfield(F_SHEETSTOMAG);

    if (mask.last_annosto>0 && mask.last_annosto!=fld.mask().get_int(F_STOANNO))
    {
      if ((fld_stomag.dirty() || mask.info_sto_dirty())  && 
          fld_stomag.items()>0 ) 
      {
        if (fld.yesno_box("Salvare lo storico per l'anno %d",mask.last_annosto) && 
          handle_sheetstomag(fld_stomag,K_ENTER)) 
        {
          fld_stomag.autosave(*mask._rel);
          fld_stomag.record()->write(TRUE);
        } 
      } 
    }
      // rilegge lo storico relativo a quell'anno ed aggiorna il layout
    mask.field(F_STOANNORIF).set(fld.get());
    mask.clear_info_sto();      
    fld_stomag.record()->read(*fld_stomag.putkey(*mask._rel));
    fld_stomag.autoload(*mask._rel);
    handle_sheetstomag(fld_stomag,K_SPACE);
    fld_stomag.force_update();
    mask.last_annosto=mask.get_int(F_STOANNORIF);
    if (fld.focusdirty())
      TEsercizi_contabili::update();
    in_handler = FALSE;
  }
 
  return TRUE;
}
  
bool TMask_anamag::handle_stoanno_row(TMask_field &fld, KEY k)
{
  if (k == K_TAB && fld.focusdirty())
      TEsercizi_contabili::update();
 
  return TRUE;
}

bool TMask_anamag::handle_sheet_um(TMask_field &fld, KEY k)
{
  TSheet_field &f= (TSheet_field &)fld; // typecast del campo al suo sheet corrispondente
  TMask_anamag & m= (TMask_anamag &)(fld.mask());
  if (k == K_ENTER && !m.query_mode())
  {
    const int items = f.items();
    if (items > 0)
    {
      const char *codum=f.cell(0,f.cid2index(FS_CODUM));
      if (*codum<=' ')
        return error_box("La prima unit<69> di misura deve essere specificata"); 
      TAssoc_array v; // istanzia l'hash table per il controllo di univocit<69>
      for (int i= 0; i<items; i++)
      {               
        const TString16 um(f.cell(i,f.cid2index(FS_CODUM)));
        // aggiunge all'hash table l'elemento della riga corrente e controlla che non esista gi<67>
        if (v.add(um))
          return error_box("Le unit<69> di misura devono essere diverse tra loro"); 
      }
    }
    if (!m.um_principale().blank() && m.um_principale()!=f.cell(0,f.cid2index(FS_CODUM)))
    {
    	int i;
    	
      for (i= 0; i<f.items(); i++)
      {               
        if (m.um_principale()==f.cell(i,f.cid2index(FS_CODUM)))
          break;
      }
      if (i>=f.items())
      	return error_box("L'unit<69> di misura '%s' deve essere presente in tabella",(const char *)m.um_principale());
    }   
  }
  else
  	if (k==K_SPACE)
  		m.um_principale()=f.cell(0,f.cid2index(FS_CODUM));

  return true;
}

bool TMask_anamag::notify_sheet_um(TSheet_field &fld_um, int r, KEY k)
{
  if (k == K_TAB)
  {
    fld_um.sheet_mask().enable(DLG_DELREC, r > 0);
    if (r == 0)
    {
      if (fld_um.items() == 0)
        ((TToken_string &)fld_um.row(0)) = "|1"; // aggiunge una riga allo sheet
      else  
        ((TToken_string &)fld_um.row(0)).add("1",fld_um.cid2index(FS_FCUM)); // forza la prima unita' di misura a 1
      fld_um.disable_cell(0, fld_um.cid2index(FS_FCUM)); // mette in sola lettura il secondo campo della prima riga (il fattore di conversione della prima U.M. <20> fisso a 1)
      fld_um.force_update(0);
    }
  }
  return TRUE;
}


bool TMask_anamag::handle_sheet_deslin(TMask_field &fld, KEY k)
{
  if (k == K_ENTER)
  {
    TSheet_field &f= (TSheet_field &)fld; // typecast del campo al suo sheet corrispondente
    const int items = f.items(); 
    
    if (items > 0)
    {
      TAssoc_array v; // istanzia l'hash table per il controllo di univocit<69>
      
      for (int i= 0; i < items; i++) 
      {
        const TString16 codlin(f.cell(i,0));
        
        if (codlin.blank())
          return error_box("I codici lingua non possono essere vuoti");
        if (v.add(codlin))
          return error_box("I codici lingua devono essere diversi tra loro");  // aggiunge all'hash table l'elemento 0 (primo) della riga corrente e controlla che non esista gi<67>
      }   
    } 
  }
  return TRUE;
}

bool TMask_anamag::handle_sheet_cod(TMask_field &fld, KEY k)
{
  if (k==K_ENTER)
  {
    TSheet_field &f= (TSheet_field &)fld; // typecast del campo al suo sheet corrispondente
    const int items = f.items();
    
    if (items > 0)
    {
      TMask &m= fld.mask(); // prende la maschere d'origine del campo
      TAssoc_array v; // istanzia l'hash table per il controllo di univocit<69>
      
      TString80 codart = m.get(F_CODART);
      v.add(codart); // aggiunge all'hash table il codice articolo originale
      for (int i= 0; i< items; i++)
      {           
        codart = f.cell(i,0);
        if (codart.blank())
          return error_box("I codici alternativi non possono essere vuoti");
        if (v.add(codart))
          return error_box("I codici alternativi devono essere diversi tra loro e dal codice dell'articolo"); // aggiunge all'hash table l'elemento 0 (primo) della riga corrente e controlla che non esista gi<67>
      }
    }
  }
  return TRUE;
}

bool TMask_anamag::handle_codcorr(TMask_field &fld, KEY k)
{
  if (k == K_F8)
  {
    TMask &m = fld.mask(); // prende la maschere d'origine del campo
    TMask_anamag & mask = (TMask_anamag &) m.get_sheet()->mask(); 
    char val = fld.mask().get(FS_TIPO)[0];
    int type = val == '8' ? 8 : (val == '1' ? 13 : 0);
      
    if (type > 0 && mask.generate_code(type))
      fld.set(mask.generated_code());
  }
  return TRUE;
}

bool TMask_anamag::notify_sheet_cod(TSheet_field & s, int r, KEY k)
{
  switch (k)
  {
  case K_CTRL + K_INS:
    if (s.items() == 1) // Genero la prima riga in base ai parametri dei codici alternativi
    {
      TMask_anamag& mask = (TMask_anamag&)s.mask();
      if (mask._altype_cod > 0 && mask.generate_code(mask._altype_cod))
      {
        TToken_string& row = s.row(0);
        row = mask.generated_code();
        row.add(mask._altype_cod);
      }
    }
		break;
  case K_ENTER:
		{
			const TString & codice = s.row(s.selected()).get(s.cid2index(FS_CODARTALT));
			const TRectype &anamag = cache().get(LF_ANAMAG, codice);
		  const TMask_anamag& mask = (TMask_anamag&)s.mask();
			const TString80 codart(mask.get(F_CODART));

			if (!anamag.empty())
				return s.error_box("Il codice %s <20> gi<67> un articolo di magazzino", (const char *) codice);
			else
			{
				TLocalisamfile codcorr(LF_CODCORR);

				codcorr.setkey(2);
				codcorr.put(CODCORR_CODARTALT, codice);
				
				if (codcorr.read(_isgteq) == NOERR && codcorr.get(CODCORR_CODARTALT) == codice)
				{
					if (codcorr.get(CODCORR_CODART) != codart)
						return s.error_box("Il codice %s <20> gi<67> un codice corrispondente", (const char *) codice);
				}
			}

			TSheet_field & f = mask.sfield(F_SHEETUM);

			const int items = f.items();
			const TString4 um(s.row(s.selected()).get(s.cid2index(FS_CODUMCORR)));
			bool um_ok = false;

			if (items > 0)
			{
				for (int i= 0; !um_ok && i < items; i++)
				{               
					const TString4 umrow(f.cell(i, f.cid2index(FS_CODUM)));
					
					um_ok = (um == umrow);
				}
			}
			if (!um_ok)
      	return s.error_box("L'unit<69> di misura '%s' non e' prevista per l'articolo %s",(const char *) um, (const char *) codart);
    }   
    break;
  default: 
    break;
  }
  return true;
}

bool TMask_anamag::handle_sheetgiac(TMask_field &fld, KEY k)
{
  if (k == K_ENTER)
  {
    TSheet_field &f=(TSheet_field &)fld;
    TMask_anamag &m= (TMask_anamag&)f.mask(); // prende la maschere d'origine del campo
    const int items = f.items();
    
    if (items > 0 && m.magazzini().gestmultimag())
    {
      TAssoc_array v; // istanzia l'hash table per il controllo di univocit<69>
      
      for (int i= 0; i< items; i++)
      {           
        TString codgiac;
        m.livelli_giac->pack_grpcode(codgiac, f.cell(i,F_LIV1-FIRST_FIELD),1); 
        m.livelli_giac->pack_grpcode(codgiac, f.cell(i,F_LIV2-FIRST_FIELD),2); 
        m.livelli_giac->pack_grpcode(codgiac, f.cell(i,F_LIV3-FIRST_FIELD),3); 
        m.livelli_giac->pack_grpcode(codgiac, f.cell(i,F_LIV4-FIRST_FIELD),4); 
        
        codgiac << f.cell(i,F_CODMAG-FIRST_FIELD);
        codgiac << f.cell(i,F_CODDEP-FIRST_FIELD);
        if (codgiac.blank())
          return error_box("I codici delle giacenze non possono essere vuoti");
        // aggiunge all'hash table l'elemento 0 (primo) della riga corrente e controlla che non esista gi<67>
        if (v.add(codgiac))
          return error_box("Esistono due righe con lo stesso codice di giacenza"); 
        if (!notify_sheet_giac(f, i, K_ENTER))
          return FALSE;
      }
      // ordina le righe per livello+codmag
      // f.rows_array().sort();
    }
  }
  return TRUE;
}

bool TMask_anamag::handle_classdog2(TMask_field& f, KEY k)
{
  if (f.to_check(k))
  {
    TString8 str; str << atoi(f.get());
    if (str.len() < f.size())
      str.right_just(f.size(), '0');
    f.set(str);
  }
  return true;
}

int TMask_anamag::add_totali_storico(TString & codmag)
{
  TSheet_field &s =(TSheet_field &)field(F_SHEETSTOMAG);
  bool need_rigatotali(TRUE);
  int r;
  
  for (r=0 ; r < s.items() && codmag>=s.cell(r,s.cid2index(F_STOCODMAG)); r++) 
  {
    if (*s.cell(r,s.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI 
      && codmag==s.cell(r,s.cid2index(F_STOCODMAG)))
      need_rigatotali=FALSE;
  }
  if (need_rigatotali )
  {
    real totq,totval;
    TLocalisamfile mag(LF_MAG);
    mag.setkey(2);
    mag.put(MAG_ANNOES,get(F_STOANNORIF));
    //mag.put(MAG_CODART,get(F_CODART));
    mag.put(MAG_CODMAG,codmag);
    mag.read();
    while (!mag.eof() 
      && get_int(F_STOANNORIF)==mag.get_int(MAG_ANNOES)
        && strncmp((const char *)codmag,mag.get(MAG_CODMAG),3)==0)
    {
      if (get(F_CODART)==mag.get(MAG_CODART))
      {
        totq+=mag.get_real(MAG_RIM);
        totval+=mag.get_real(MAG_VALRIM);
      }
      mag.next();
    }
    s.insert(r,FALSE);
    s.row(r  ).add(SIMBOLO_TOTALI,s.cid2index(F_STOTIPORIGA));
    s.row(r  ).add(codmag,s.cid2index(F_STOCODMAG));
    s.row(r  ).add("Totale",s.cid2index(F_STOANNOES));
    s.disable_cell(r,-1);

    s.insert(r+1,FALSE);
    s.row(r+1).add(SIMBOLO_TOTALI,s.cid2index(F_STOTIPORIGA));
    s.row(r+1).add(codmag,s.cid2index(F_STOCODMAG));
    s.row(r+1).add("Rim.in",s.cid2index(F_STOANNOES));
    s.row(r+1).add(totq.string(),s.cid2index(F_STOQUANT));
    s.row(r+1).add(totval.string(),s.cid2index(F_STOVAL));
    s.disable_cell(r+1,-1);
  }
  update_totali_storico(codmag);
  return r;
}

void TMask_anamag::update_totali_storico(TString & codmag)
{
  TSheet_field &s =(TSheet_field &)field(F_SHEETSTOMAG);
  real tot1,tot2;
  // find first occourrence..
  int i=0 ;
  while (i< s.items() && codmag>s.cell(i,s.cid2index(F_STOCODMAG)))
    i++;
  // ...sum...
  for (; i< s.items() && *s.cell(i,s.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI ; i++) 
  {
    tot1+=real(s.cell(i,s.cid2index(F_STOQUANT)));
    tot2+=real(s.cell(i,s.cid2index(F_STOVAL)));
  }
  //... display
  if (i< s.items())
  {
    s.row(i).add(tot1.string(),s.cid2index(F_STOQUANT));
    s.row(i).add(tot2.string(),s.cid2index(F_STOVAL));
    s.force_update(i);
  }
}



bool TMask_anamag::remove_totali_storico(TString & codmag)
{
  if (codmag.blank())
    return FALSE;

  TSheet_field &s =(TSheet_field &)field(F_SHEETSTOMAG);
  bool found_some(FALSE);
  int r;

  for (r=0 ; !found_some && r< s.items()-1 && !(*s.cell(r,s.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI
             && codmag==s.cell(r,s.cid2index(F_STOCODMAG))); r++)
  {
    if (*s.cell(r,s.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI
      && codmag==s.cell(r,s.cid2index(F_STOCODMAG)))
      found_some=TRUE;
  }
  if (!found_some)
  {
    // ultima riga
    s.destroy(r,FALSE); 
    s.destroy(r,FALSE);
  }
  return !found_some;
} 


bool TMask_anamag::check_totali_storico()
{
  TSheet_field &s =(TSheet_field &)field(F_SHEETSTOMAG); 
  const int annogiac = get_int(F_ANNO);
  if (annogiac != last_annosto)
    return TRUE;
  for (int r=0 ; r< s.items() ; r++) 
  {
    // rintraccia il totale 
    for (; r< s.items() && *s.cell(r,s.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI; r++) ;
    real totq1(s.cell(r,s.cid2index(F_STOQUANT))),totq2(s.cell(r+1,s.cid2index(F_STOQUANT)));
    if (totq1!=totq2) 
      if (!yesno_box("La somma delle composizioni dello storico \nper il magazzino %s non corrisponde \nalla rimanenza iniziale.\n Proseguo ugualmente ?",
          (const char *)s.cell(r,s.cid2index(F_STOCODMAG))))
        return FALSE; 
    TCurrency totval1(real(s.cell(r,s.cid2index(F_STOVAL)))),
			        totval2(real(s.cell(r+1,s.cid2index(F_STOVAL))));
    if (totval1!=totval2) 
      return yesno_box("La somma del valore delle composizioni dello storico \n per il magazzino %s non corrisponde \nal valore della rimanenza iniziale.\n Proseguo ugualmente ?",
          (const char *)s.cell(r,s.cid2index(F_STOCODMAG))); 
    r++;
  }
  return TRUE;
}                          


bool TMask_anamag::notify_sheet_giac(TSheet_field &f, int i, KEY k)
{
  TMask_anamag & m=(TMask_anamag &)f.mask();

	const bool gestmag = app().has_module(MGAUT) && m.magazzini().gestmag();
	if (gestmag)
	{
		switch (k)                          
		{
			case (K_ENTER): // fine modifica
			{
				real ck(f.cell(i,f.cid2index(F_RIM)));
				ck+=real(f.cell(i,f.cid2index(F_ACQ)));
				ck+=real(f.cell(i,f.cid2index(F_ENTR)));
				ck-=real(f.cell(i,f.cid2index(F_VEN)));
				ck-=real(f.cell(i,f.cid2index(F_USC)));
				ck-=real(f.cell(i,f.cid2index(F_ACL)));
				ck+=real(f.cell(i,f.cid2index(F_INCL)));
				ck-=real(f.cell(i,f.cid2index(F_INPRODF)));
				ck+=real(f.cell(i,f.cid2index(F_INPRODC)));
				ck-=real(f.cell(i,f.cid2index(F_SCARTI)));
				ck-=real(f.cell(i,f.cid2index(F_GIAC)));

				if (!ck.is_zero())          
				{
					f.error_box("La giacenza deve essere pari a RIM+(ACQ+ENTR)-(VEN+USC)-(ACL-INCL)-(PRODF-PRODC) - SCARTI)");
					return FALSE;
				}
      
				m.update_ordc_ordf();  //chiama la funzione che calcola i totali degli ordinati
			}
			break;
			case (K_CTRL + K_INS): // richiesta di inserimento
			case (K_TAB): // modifica
			{
				if (*f.cell(i,f.cid2index(F_CODMAG))<=' ')
				{
					if (m.magazzini().standardmag().not_empty())
					{
						f.row(i).add(m.magazzini().standardmag(),f.cid2index(F_CODMAG));
						f.row(i).add(m.magazzini().standarddep(),f.cid2index(F_CODDEP));
					}
				}
			}
			break;
		}
	}	//if(gestmag...

	//campi presi da altri campi della maschera per..
	//..essere visualizzati nella pag. giacenze
	if (k == K_TAB)
	{
		TMask& sm = f.sheet_mask();	//maschera delle giacenze
		
		if (sm.field(F_LIV1).hidden())	//l'articolo appare solo se mancano i livelli di giacenza senno'..
		{														//..si sovrappongono
			sm.show(F_CODARTR);
			sm.show(F_DESCRR);
			sm.set(F_CODARTR, m.get(F_CODART));
			sm.set(F_DESCRR, m.get(F_DESCR));
		}
		else
		{
			sm.hide(F_CODARTR);
			sm.hide(F_DESCRR);
		}
		sm.set(F_ULC1R, m.get_real(F_ULC1));
		sm.set(F_DATAULC1R, m.get_date(F_DATAULC1));
		sm.set(F_ULC2R, m.get_real(F_ULC1));
		sm.set(F_DATAULC2R, m.get_date(F_DATAULC2));
	}
  return true;
}

bool TMask_anamag::handle_sheet_giac_codmag(TMask_field &f, KEY k)
{
  if (k==K_TAB && f.dirty())
  {
    TMask& m = f.mask();
    const TRectype& mag = ((TEdit_field&)f).browse()->cursor()->curr();
    const bool gesdep = mag.get_bool("B0");
    
    m.enable(F_CODDEP, gesdep);
    m.show(F_DESDEP, gesdep);
    if (gesdep)
      m.field(F_CODDEP).check();
    else
    {
      m.set(F_CODDEP, "");
      m.set(F_DESDEP, "");
    }
  }
  return TRUE;
}


bool TMask_anamag::handle_sheet_giac_valgiac(TMask_field &f, KEY k)
{
  if (k==K_TAB && f.dirty())
  {
    TMask& m = f.mask();
    real q=m.get_real(F_RIM)+m.get_real(F_ACQ);
    if (q.is_zero())
      f.set(q.string());
    else
    {
      q=(m.get_real(F_VRIM)+m.get_real(F_VACQ))/q;
      TPrice r(q);
      f.set(r.get_num().string());
    }
  }
  return TRUE;
}

bool TMask_anamag::handle_sheet_stomag_stoval(TMask_field &f, KEY k)
{
  if (k == K_TAB && f.dirty())
  {
    TMask& m = f.mask();
    const real val = m.get_real(F_STOQUANT) * m.get_real(F_STOVALUN);
    const TCurrency c(val);
    m.set(F_STOVAL, c);
  }
  return TRUE;
}

bool TMask_anamag::notify_sheet_sto(TSheet_field &s, int r, KEY k)
{
  static TString16 oldcodmag,newcodmag,oldanno,newanno;
  TMask_anamag & m=(TMask_anamag &)s.mask();

  switch (k)
  {
    case K_DEL:
      if (*s.cell(r,s.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI)
        return FALSE;
    break;  

    case (K_CTRL+K_DEL):
      if (m.remove_totali_storico(oldcodmag))
        s.force_update();
      break;  

    case K_TAB: // posizionamento sulla riga
      oldcodmag=s.cell(r,s.cid2index(F_STOCODMAG));
      oldanno=s.cell(r,s.cid2index(F_STOANNOES));
      break;  
  
    case (K_ENTER): // fine modifica

      newanno=(s.cell(r,s.cid2index(F_STOANNOES)));
      newcodmag=(s.cell(r,s.cid2index(F_STOCODMAG)));
      
      if (m.esercizi_contabili()[atoi(newanno)].inizio() >= m.esercizi_contabili()[m.get_int(F_STOANNO)].inizio())
      {
        s.row(r).add(oldanno,s.cid2index(F_STOANNOES));
        s.error_box("La rimanenza iniziale di un esercizio deve essere composta da parti provenienti da esercizi precedenti");
        return FALSE;
      }
      // modifica
      m.update_totali_storico(newcodmag);
      if (oldcodmag==s.cell(r,s.cid2index(F_STOCODMAG)))
      {
        if (oldanno==s.cell(r,s.cid2index(F_STOANNOES)) )
          break;  
      } else {
        m.remove_totali_storico(oldcodmag);
      } 
    case (K_CTRL + K_INS ): // fine inserimento
      if (*s.cell(r,s.cid2index(F_STOCODMAG))==' ' && m.magazzini().standardmag().not_empty())
      {
        // new line
        s.row(r).add(m.magazzini().standardmag(),s.cid2index(F_STOCODMAG));
      }

      newcodmag=(s.cell(r,s.cid2index(F_STOCODMAG)));
      newanno=(s.cell(r,s.cid2index(F_STOANNOES)));
      if (newcodmag != " ")
      {
        // ordina
        while (r< s.items()-1 && (newcodmag > s.cell(r+1,s.cid2index(F_STOCODMAG)) || 
          (newcodmag == s.cell(r+1,s.cid2index(F_STOCODMAG)) && 
            (newanno > s.cell(r+1,s.cid2index(F_STOANNOES)) && *s.cell(r+1,s.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI)) ))
        {
          s.swap_rows(r,r+1);
          r++;
        }
        while (r>0 && (newcodmag < s.cell(r-1,s.cid2index(F_STOCODMAG)) || 
          (newcodmag == s.cell(r-1,s.cid2index(F_STOCODMAG)) && 
            (newanno < s.cell(r-1,s.cid2index(F_STOANNOES)) || *s.cell(r-1,s.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI )) ))
        {
          s.swap_rows(r,r-1);
          r--;
        }
        m.add_totali_storico(newcodmag);
//        TSheet_field & s_um=(TSheet_field & )s.mask().field(F_SHEETUM); // qui verificare
        s.force_update();
      }
      break;  

    case (K_INS): // richiesta di inserimento
      break;

  }
  return TRUE;
}



bool TMask_anamag::handle_sheetstomag(TMask_field &fld, KEY k)
{
  TSheet_field & f=(TSheet_field &)fld;
  TMask_anamag &m=(TMask_anamag &) f.mask(); // prende la maschere d'origine del campo
  if (k==K_ENTER)
  {
    const int items = f.items();
    real totrim,totvalrim;
    
    if (items > 0)
    {
      if (!m.check_totali_storico())
        return FALSE;
      TAssoc_array v; // istanzia l'hash table per il controllo di univocit<69>
      int i;
      
      for (i= 0; i< items; i++)
      {           
        if (*f.cell(i,f.cid2index(F_STOTIPORIGA))!=SIMBOLO_TOTALI)
        {
          TString codmg(f.cell(i,f.cid2index(F_STOCODMAG)));
          TString codeser(f.cell(i,f.cid2index(F_STOANNOES)));
          if (codmg.blank())
            return error_box("Il codice del magazzino non pu<70> essere vuoto");
          if (codeser.blank())
            return error_box("I codici degli esercizi non possono essere vuoti");
          // aggiunge all'hash table l'elemento 0 (primo) della riga corrente e controlla che non esista gi<67>
          codmg.overwrite(codeser,3);
          if (v.add(codmg))
            return error_box("La composizione delle rimanenze deve far riferimento a esercizi tutti diversi tra loro"); 
          TLocalisamfile stor_aux(LF_STOMAG);
    
          stor_aux.put(STOMAG_CODART,fld.mask().get(F_CODART));
          stor_aux.put(STOMAG_ANNOESRIF,fld.mask().get(F_STOANNO));
          stor_aux.put(STOMAG_ANNOES,codeser);
            
          totrim=totrim+(real)f.cell(i,f.cid2index(F_STOQUANT));
          totvalrim=totvalrim+(real)f.cell(i,f.cid2index(F_STOVAL));
        }
      }
      for (i= 0; i< items;)
      {
        if (*f.cell(i,f.cid2index(F_STOTIPORIGA))==SIMBOLO_TOTALI)
          f.rows_array().remove(i,TRUE);
        else 
          i++;
      }
      // ordina le righe per ANNO
      //f.rows_array().sort();
      if ( m.get(F_STOANNO)<f.cell(f.items()-1,F_STOANNOES-FIRST_FIELD))
        return error_box("La composizione delle rimanenze non puo' comprendere anni seguenti"); 
    }
  
  } else 
  if (k==K_SPACE) 
  {
    for (int i=0; i< f.items();)
    {
      TString16 codmag(f.cell(i,f.cid2index(F_STOCODMAG)));
      i=m.add_totali_storico(codmag)+2;
    }
    f.force_update();
  }
  return TRUE;
}

bool TMask_anamag::handle_sheet_um_um(TMask_field &fld, KEY k)
{
  if (fld.focusdirty() && k == K_TAB)
  {
    TMask &m = fld.mask();         // prende la maschera d'origine del campo (maschera dello sheet)
    const TString16 curr_um(fld.get()); // prende il contenuto del campo corrente (unit<69> di misura corrente)
    
    if (!curr_um.blank())            // se il codice dell'unit<69> di misura <20> vuoto non viene fatto alcun calcolo
    {
      TSheet_field *f= m.get_sheet(); // prende lo sheet d'origine della maschera del campo

      CHECK(f != NULL, "Il puntatore allo sheet <20> nullo");
      if (f->selected() > 0)
      {
        
        // ALGORITMO DI PRECALCOLO DEL RAPPORTO DELLE UNITA' DI MISURA NELLO SHEET
        //
        // SHEET:
        // -----
        // riga    u.m.     f.c.
        // 1)       KM       1     -> kilometri (you), riferiti al metro (your) con f.c. 1000 (your_fc)
        // ...     ...      ...
        // ...)     MM       X     -> millimetri (me), riferiti al metro (my) con f.c. 0,001 (my_fc)
        //
        // se (your==my) allora X=(my_fc/your_fc) ...chiaro, no!? :-)
        
        TTable t("%UMS");
        real x;                                // fattore di conversione dell'unit<69> di misura corrente
        const TString16 first_um(f->row(0).get(0));    // prende l'unit<69> di misura di rapporto (dalla prima linea dello sheet)

        t.zero();
        t.put("CODTAB", curr_um);
        if (t.read() == NOERR)
        {
          const TString16 rif_um(t.get("S7"));   // prende l'unit<69> di misura di riferimento dell'unit<69> di misura corrente
          x = t.get_real("R10");   // prende il suo fattore di conversione
          
          if (rif_um != first_um)
          {
            t.zero();
            t.put("CODTAB", first_um);
            if (t.read() == NOERR)
            {
              TString16 rif_first_um(t.get("S7")); // prende l'unit<69> di misura di riferimento dell'unit<69> di misura di rapporto
              real rif_fc_first_um(t.get_real("R10")); // prende il suo fattore di conversione
              rif_fc_first_um = rif_fc_first_um.is_zero() ? 1 : rif_fc_first_um;

              if (rif_first_um == rif_um)
              {
                x /= rif_fc_first_um; // calcola il rapporto tra i fattori di conversione
                x.round(5); // arrotonda il risultato a 5 decimali
              } else {
                if (rif_first_um == curr_um) {
                  x= 1/rif_fc_first_um;
                }
              }
            }              
          }
        }
        if (x == ZERO)
          x = 1.00;
        m.set(FS_FCUM, x); // il risultato viene scritto nel campo del fattore di conversione
      } else {
        TString & um_p=((TMask_anamag &)f->mask()).um_principale();
        if (um_p.blank()) {
          f->mask().set(F_UMPRINCIPALE,curr_um);
          f->mask().set(F_UMPRINCIPALE2,curr_um);
          um_p=curr_um;
        }
      }
    }
  }
  return TRUE;
}

bool TMask_anamag::handle_sheet_um_price(TMask_field &f, KEY k)
{
  if (f.to_check(k,TRUE))
  {
    TMask& m = f.mask();
    TString codiva= m.get_sheet()->mask().get(F_CODIVA);// recuper il codice IVA dalla maschera principale
    real netto = 0.0;
    real lordo = 0.0;
    TCodiceIVA iva(codiva);

    if (f.dlg() == FS_PREZZO)
    {
      netto = real(m.get(FS_PREZZO));
      lordo = iva.lordo(netto, AUTO_PRICES_DECIMALS, TCurrency::get_firm_val());
      m.set(FS_PREZZO_LORDO,lordo.string());
    }
    else
    {
      lordo = real(m.get(FS_PREZZO_LORDO));
      real prec_lordo = lordo;
      const real imposta = iva.scorpora(lordo, AUTO_PRICES_DECIMALS, TCurrency::get_firm_val());
      netto = lordo;
      lordo += imposta;      
      if (lordo != prec_lordo)
      {
        warning_box("Scorporando l'iva dal prezzo lordo si e' dovuto\n"
                    "correggere quest'ultimo a causa di arrotondamenti.");
        m.set(FS_PREZZO_LORDO,lordo.string());
      }
      m.set(FS_PREZZO,netto.string());
    }
  }
  return TRUE;
}



void TMask_anamag::sheetgiac_get(TSheet_field &fld_righe, int item)
{
  TMask_anamag &m=(TMask_anamag &)fld_righe.mask();
  // prende il record della riga corrente dal record array
  TRectype &rec= fld_righe.record()->row(item, TRUE);
  TToken_string &row= fld_righe.row(item-1);
  // codici di livello
  row.add( m.livelli_giac->unpack_grpcode(rec.get("LIVELLO") ,1),fld_righe.cid2index(F_LIV1) );
  row.add( m.livelli_giac->unpack_grpcode(rec.get("LIVELLO") ,2),fld_righe.cid2index(F_LIV2) );
  row.add( m.livelli_giac->unpack_grpcode(rec.get("LIVELLO") ,3),fld_righe.cid2index(F_LIV3) );
  row.add( m.livelli_giac->unpack_grpcode(rec.get("LIVELLO") ,4),fld_righe.cid2index(F_LIV4) );
}


// item varies from 1 to items()
void TMask_anamag::sheetgiac_put(TSheet_field &fld_righe, int item)
{
  TMask_anamag &m=(TMask_anamag &)fld_righe.mask();
  TToken_string &row= fld_righe.row(item-1);
          
  TRectype &recrighe= fld_righe.record()->row(item, TRUE);
  // codici livello
  if (m.livelli_giac->enabled()) {
      TString16 packedcode;
      m.livelli_giac->pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV1)),1);
      m.livelli_giac->pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV2)),2);
      m.livelli_giac->pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV3)),3);
      m.livelli_giac->pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV4)),4);
      recrighe.put("LIVELLO", packedcode);
  }     
}  

// Aggiorna il valore delle giacenze in base al cambiamento dell'unit<69> di misura principale
void TMask_anamag::ricalcola_giacenze()
{
  real fc(1.0);
  TSheet_field & f=(TSheet_field  &)field(F_SHEETUM);
  if (!um_principale().blank() && um_principale()!=f.cell(0,f.cid2index(FS_CODUM)))
  {
  	int i;
  	
    for (i= 0; i<f.items(); i++)
    {               
      if (um_principale()==f.cell(i,f.cid2index(FS_CODUM)))
        break;
    }
    fc=f.cell(i,f.cid2index(FS_FCUM));
  }   
  if (fc != 1.0)  
  {
    TLocalisamfile mag(LF_MAG),stomag(LF_STOMAG);
    int annoes=esercizi_contabili().first();
    // ciclo sugli esercizi
    do {
      mag.zero();
      mag.put(MAG_ANNOES,annoes);
      mag.put(MAG_CODART,get(F_CODART));
      mag.read(_isgteq);
      // ciclo per le giacenze di questo esercizio
      while (!mag.eof() && get(F_CODART)==mag.get(MAG_CODART) && annoes==mag.get_int(MAG_ANNOES))
      {
        mag.put(MAG_LIVRIOR,mag.get_real(MAG_LIVRIOR)*fc); // update ..
        mag.put(MAG_LOTTORIOR,mag.get_real(MAG_LOTTORIOR)*fc); 
        // saldi
        mag.put(MAG_GIAC,mag.get_real(MAG_GIAC)*fc); // update ..
        mag.put(MAG_ACQ,mag.get_real(MAG_ACQ)*fc); 
        mag.put(MAG_ENT,mag.get_real(MAG_ENT)*fc); 
        mag.put(MAG_VEN,mag.get_real(MAG_VEN)*fc); 
        mag.put(MAG_USC,mag.get_real(MAG_USC)*fc); 
        mag.put(MAG_ORDC,mag.get_real(MAG_ORDC)*fc); 
        mag.put(MAG_ORDF,mag.get_real(MAG_ORDF)*fc); 
        mag.put(MAG_RIM,mag.get_real(MAG_RIM)*fc); 
        mag.put(MAG_SCARTI,mag.get_real(MAG_SCARTI)*fc); 
        mag.put(MAG_INCL,mag.get_real(MAG_INCL)*fc); 
        mag.put(MAG_ACL,mag.get_real(MAG_ACL)*fc); 
        mag.put(MAG_PRODCOMP,mag.get_real(MAG_PRODCOMP)*fc); 
        mag.put(MAG_PRODFIN,mag.get_real(MAG_PRODFIN)*fc); 
        mag.put(MAG_SCORTAMIN,mag.get_real(MAG_SCORTAMIN)*fc); 
        mag.rewrite();
        mag.next();
      }
      stomag.zero();
      stomag.put(STOMAG_ANNOESRIF,annoes);
      stomag.put(STOMAG_CODART,get(F_CODART));
      stomag.read(_isgteq);
      // ciclo per lo storico di questo esercizio
      while (!stomag.eof() && get(F_CODART)==stomag.get(STOMAG_CODART) && annoes==stomag.get_int(STOMAG_ANNOESRIF))
      {
        stomag.put(STOMAG_QUANT,stomag.get_real(STOMAG_QUANT)*fc); // update ..

        stomag.rewrite();
        stomag.next();
      }  
    }
    while ((annoes=esercizi_contabili().next(annoes)) > 0); // qui verificare
  }
  return;
}

//---------------------------------------
//fine gestione articolo multilivello
//---------------------------------------
 
//-------------------------------------------------------------------------------------------------
//  METODI DELL'APPLICAZIONE
//------------------------------------------------------------------------------------------------- 
void TAnagrafica_magazzino::on_firm_change()
{
  if (_msk)
    _msk->set_parametered_fields();
}

bool TAnagrafica_magazzino::search_on_file(const char * key, int file, int nkey, const char * field)
{                               
  TLocalisamfile f(file);

  if (f.empty())
    return FALSE;
  else
  {
    f.setkey(nkey);
    f.put(field, key);
    f.read();
    return f.get(field) == key;
  }                                                                                                
}

bool TAnagrafica_magazzino::protected_record(TRectype& rec)
{                               
  const TString art(rec.get(ANAMAG_CODART));
  const TRectype & dist = cache().get(LF_DIST, art);
  
  if (!dist.empty())
    return TRUE;
  else
    if (search_on_file(art, LF_RDIST, 2, "CODCOMP"))
      return TRUE;
    else
      return search_on_file(art, LF_RMOVMAG, 2, "CODART");
} 
                     
bool TAnagrafica_magazzino::user_create()
{
  open_files(LF_TAB, LF_TABCOM, LF_ANAMAG, LF_MAG, LF_STOMAG, 
             LF_UMART, LF_CODCORR, LF_DESLIN, LF_DIST, LF_RDIST, LF_RMOVMAG,
             LF_CLIFO, LF_PCON, 0);
  // crea l'oggetto per i parametri di livello giacenza
  // apre la maschera e dispone gli sheet
  _rel= new TRelation(LF_ANAMAG);

  _msk= new TMask_anamag(_rel);
  
  set_search_field(F_CODART); //serve per avere come campo di ricerca il codice articolo intero
                              //invece che l'ultimo campo del codice multilivello (se c'e')
  return TRUE;                
}

bool TAnagrafica_magazzino::user_destroy()
{
  
  delete _rel;
  delete _msk;
  
  return TRUE;
}

int TAnagrafica_magazzino::read(TMask& m)
{
  int err= TRelation_application::read(m);
  if (err == NOERR)
  {
    // LETTURA SHEET STORICO MAGAZZINO  IN AUTOMATICO
    TSheet_field &fld_stomag= m.sfield(F_SHEETSTOMAG); 
    fld_stomag.sheet_mask().field(F_STOCODART).set(m.field(F_CODART).get());  // necessario se lo sheet <20> vuoto
    
    // *****************************
    // LETTURA SHEET UNITA' DI MISURA
    load_um(m);
    ((TMask_anamag & ) m).update_ordc_ordf();  //chiama la funzione che calcola i totali degli ordinati
  }
  return err;
}

void TAnagrafica_magazzino::load_um(TMask& m)
{
  // *****************************
  // LETTURA SHEET UNITA' DI MISURA
  TSheet_field &fld_um= m.sfield(F_SHEETUM); // prende lo sheet delle unit<69> di misura
  get_relation()->curr().put(ANAMAG_CODART,m.get(F_CODART));
  fld_um.record()->read(*fld_um.putkey(*get_relation()));
  fld_um.autoload(*get_relation());
//  else  
//    ((TToken_string &)fld_um.row(0)).add("1",fld_um.cid2index(FS_FCUM)); // forza la prima unita' di misura a 1
//  fld_um.disable_cell(0, fld_um.cid2index(FS_FCUM)); // mette in sola lettura il secondo campo della prima riga (il fattore di conversione della prima U.M. <20> fisso a 1)
//  fld_um.force_update(0); // aggiorna lo stato della riga 0
  TString16  um_principale;
  um_principale=fld_um.cell(0, fld_um.cid2index(FS_CODUM));
  m.set(F_UMPRINCIPALE,um_principale);
  m.set(F_UMPRINCIPALE2,um_principale);
}

bool TAnagrafica_magazzino::remove()
{
  bool ok = TRelation_application::remove();
  if (ok)
  {
    TMask &m=curr_mask();
    TSheet_field &f= (TSheet_field &)m.field(F_SHEETUM); // prende lo sheet delle unit<69> di misura
    TLocalisamfile distinte(LF_DIST);
    distinte.put("CODDIST",m.get(F_CODART));
    int err=distinte.read();// esiste la distinta ?
    switch(err)
    { 
      case _iskeynotfound :
      case _isemptyfile :
      case _iseof:
        ok &= (f.record()->remove() == NOERR);
        break;
    }
  }
  return ok;
}

int TAnagrafica_magazzino::write(const TMask& m)
{
  int err =TRelation_application::write(m);
  if (err==NOERR)
  {
    TSheet_field &f= (TSheet_field &)m.field(F_SHEETUM); // prende lo sheet delle unit<69> di misura
    err|=f.record()->write(FALSE);
  }
  return err;
}

int TAnagrafica_magazzino::rewrite(const TMask& m)
{
  int err =TRelation_application::rewrite(m);
  if (err==NOERR)
  {
    TSheet_field& f= m.sfield(F_SHEETUM); // prende lo sheet delle unit<69> di misura
    err|=f.record()->write(TRUE);
  }
  ((TMask_anamag &)m).ricalcola_giacenze();
  return err;
}

static bool non_esiste_handler(TMask_field& f, KEY k)
{
  switch (k)
  {
  case K_TAB:
    if (!f.mask().is_running())
      f.reset();
    break;
  case K_ENTER:
    if (!cache().get(LF_ANAMAG, f.mask().get(F_CODART)).empty())
      return f.error_box(TR("Il codice articolo selezionato esiste gi<67>"));
  default:
    break;
  }
  return true;
}

bool TAnagrafica_magazzino::handle_copia(TMask_field &fld, KEY k)
{             
  if (k == K_SPACE)
  {
    TMask_anamag & m = (TMask_anamag &) fld.mask();
    const TString oldart = m.get(F_CODART);
  
    TString codart, descart;
    if (advanced_codart_enabled())
    {
      codart = oldart;
      if (!advanced_codart_ask(codart, descart))
        codart.cut(0);
    }
    else
    {
		  const TCodart_livelli* liv_art = m.get_livelli_art();

      TMask ask("ve2400k");
      ask.set_handler(F_CODART, non_esiste_handler);
		  if(liv_art && liv_art->enabled())
      {
			  create_fields(ask, 1, 1, F_LIVART1, F_DESLIVART1, *liv_art, false);
        for (int i = liv_art->last_level(); i > 0; i--)
        {
          const short id = F_LIVART1+i-1;
          ask.set(id, m.get(id));
        }
        ask.reset(F_CODART);
      }
      if (ask.run() == K_ENTER)
        codart = ask.get(F_CODART);
    }

    if (codart.full() && codart != oldart)
    {     
      if (descart.full())
        m.set(F_DESCR, descart);

      m.set(F_CODART, codart, TRUE);
      
      m.sfield(F_SHEETGIAC).destroy();
      m.sfield(F_SHEETSTOMAG).destroy();
  
      m.load_profile(0, FALSE);
          
      m.set_mode(MODE_INS);
      xvtil_statbar_set(TR("Inserimento"), TRUE);
    }
  }
  return TRUE;
}

void TAnagrafica_magazzino::init_query_mode(TMask &m)
{
  m.hide(F_COPY);

  if (advanced_codart_enabled())
    m.show(F_ADVANCED);
}

void TAnagrafica_magazzino::init_insert_mode(TMask &m)
{
  load_um(m);
  TSheet_field& f = m.sfield(F_SHEETUM);
  if (f.items() == 0)
    f.row(0) = " |1"; // aggiunge una riga allo sheet

  if (advanced_codart_enabled())
    m.hide(F_ADVANCED);
}

void TAnagrafica_magazzino::init_modify_mode(TMask &m)
{
  m.set_handler(F_COPY, handle_copia);
  m.show(F_COPY);

  if (advanced_codart_enabled())
    m.hide(F_ADVANCED);
}

void TAnagrafica_magazzino::ini2sheet(TConfig& ini, TSheet_field &sheet)
{                               
  switch(sheet.dlg())
  {
  case F_SHEETGIAC:
  case F_SHEETSTOMAG:
    break; // do nothing
  default:  
    TRelation_application::ini2sheet(ini, sheet);
  }
}

void TAnagrafica_magazzino::sheet2ini(TSheet_field &sheet,TConfig& ini)
{
  switch(sheet.dlg())
  {
  case F_SHEETGIAC:
  case F_SHEETSTOMAG:
    break; // do nothing
  default:  
    TRelation_application::sheet2ini(sheet, ini);
  }
}
 
// ************************
//
int ve2400(int argc, char* argv[])
{
  TAnagrafica_magazzino a;
  
  a.run(argc, argv, "Anagrafica di magazzino");
  return 0;
}