#include <defmask.h>
#include <recarray.h>
#include <relapp.h>                                                                           
#include <msksheet.h>

#include "../cg/cglib01.h"
#include "../db/dblib.h"
#include "../mg/mglib.h"
#include "../ve/veconf.h"

#include "mg1100.h"
#include <cfven.h>

// maschera dell'applicazione "Gestione interattiva movimenti di magazzino"
//
class TMask_movmag : public TMask 
{
  static TArticolo_giacenza* _curr_art;
  
  TEsercizi_contabili   esercizi;  
  TMov_mag * _mov_mag;
  TString _price_codart;
  real price_quant;
  bool price_proposed;
  real proposed_price(const char * codart, real quant,const char * causrig);

  // aggiorna la riga di magazzino aggiungendo righe automatiche o esplosioni
  bool update_rigamov(int r, const char * old_codcaus, const char * old_codart, const real & old_quant);
  bool add_autorows(int r, const char * old_codcaus, const char * old_codart, const real & old_quant);
  bool add_explrows(int r);
  TMagazzini _magazzini;   
  
  bool qta_inventory(real & qta);

  static bool notify_righe(TSheet_field & fld_righe, int item, KEY k); // notify delle righe di sheet
  static bool handle_righe(TMask_field &f, KEY k); // handler delle righe
  static bool handle_righeprezzo1(TMask_field &f, KEY k); // handler del prezzo delle righe
  static bool handle_righeprezzo2(TMask_field &f, KEY k); // handler del prezzo delle righe
  static bool handle_codcaus(TMask_field &fld, KEY k); // handler della causale
  static bool handle_datacomp(TMask_field &, KEY k); // handler del numero di registrazione
  static bool handle_checksosp(TMask_field &fld, KEY k); // handler 
  static bool handle_codarticolo(TMask_field &fld, KEY k); // handler 
  static bool handle_causrig(TMask_field &fld, KEY k); // handler 
  static bool handle_giacattuale(TMask_field &fld, KEY k); // handler della giacenza attuale
  static bool codgrp_handler(TMask_field &fld, KEY k); // handler del codice gruppo
  static void sheetrighe_put(TSheet_field &fld_righe, int item);
  static void sheetrighe_get(TSheet_field &fld_righe, int item);
public:
  TArticolo_giacenza& curr_art();
  const TMagazzini & magazzini() const 
    {return _magazzini;} 
  TMask_movmag(TMov_mag * m_m);
  virtual ~TMask_movmag();
};

TArticolo_giacenza* TMask_movmag::_curr_art = NULL;

// HANDLER DEL CODICE LIVELLO anagrafica
bool TMask_movmag::codgrp_handler(TMask_field& f, KEY k)
{        
  if ((k == K_TAB && f.focusdirty() ||k == K_ENTER ) && !f.empty())
  {                  
    if (!livelli_giacenza().enabled())
    {
      f.error_box(TR("Livelli del codice non abilitati"));
      return FALSE;  
    }
    const int levnum=1+f.dlg()-F_LIV1;
    return livelli_giacenza().autoinsert(levnum,f);
  }
  return TRUE;  
}


// costruttore della maschera anagrafica di magazzino
//TMask_movmag::TMask_movmag() : 
TMask_movmag::TMask_movmag(TMov_mag * m_m) 
  : TMask("mg1100")
{
  _mov_mag = m_m;
  // setta handler e notify
  TSheet_field & ss=(TSheet_field &)field(F_RIGHE);
  set_handler(F_DATACOMP, handle_datacomp);
  set_handler(F_CODCAUS, handle_codcaus);
  ss.sheet_mask().field(F_QUANT).set_handler(handle_righeprezzo1);
  ss.sheet_mask().field(F_CAUSRIG).set_handler(handle_causrig);
  ss.sheet_mask().field(F_CODART).set_handler(handle_codarticolo);
  ss.sheet_mask().field(F_GIAC).set_handler(handle_giacattuale);
  ss.set_notify(notify_righe);
  ss.set_handler(handle_righe);
  ss.set_userget(sheetrighe_get);
  ss.set_userput(sheetrighe_put);
  ss.set_lines_record(m_m->body());
  // setta i campi della maschera
  // per la pagina giacenze
  TSheet_field &fld_righe = sfield(F_RIGHE); 

  // setta le colonne in base all'abilitazione dei livelli di giacenza
  livelli_giacenza().set_sheet_columns(fld_righe,F_LIV1);

  // abilita i controlli
  for (int l=0; l<4; l++)
    if (livelli_giacenza().autoinsert(1+l))
    {
      ss.sheet_mask().efield(F_LIV1+l).check_type(CHECK_SEARCH);
      ss.sheet_mask().field(F_LIV1+l).set_handler(codgrp_handler);
    }
  TConfig prassid(CONFIG_DITTA, "ve"); // apre il file di configurazione della ditta corrente
  if (prassid.get_bool("GES", NULL, A_LISTINI))
    field(F_CATVEN).show(prassid.get_bool("GESLISCV"));
  else 
    field(F_CATVEN).hide();  

  ss.sheet_mask().field(F_DESMAG).enable(magazzini().gestmultimag());
  ss.enable_column(ss.cid2index(F_CODMAG),magazzini().gestmultimag());
}


TMask_movmag::~TMask_movmag()
{
}

// item varies from 1 to items()
void TMask_movmag::sheetrighe_get(TSheet_field &fld_righe, int item)
{
  // 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( livelli_giacenza().unpack_grpcode(rec.get("LIVGIAC") ,1),fld_righe.cid2index(F_LIV1) );
  row.add( livelli_giacenza().unpack_grpcode(rec.get("LIVGIAC") ,2),fld_righe.cid2index(F_LIV2) );
  row.add( livelli_giacenza().unpack_grpcode(rec.get("LIVGIAC") ,3),fld_righe.cid2index(F_LIV3) );
  row.add( livelli_giacenza().unpack_grpcode(rec.get("LIVGIAC") ,4),fld_righe.cid2index(F_LIV4) );
}

// item varies from 1 to items()
void TMask_movmag::sheetrighe_put(TSheet_field &fld_righe, int item)
{
  TToken_string &row= fld_righe.row(item-1);
          
    TRectype &recrighe= fld_righe.record()->row(item, TRUE);
    // codici livello
    if (livelli_giacenza().enabled()) {
      TString16 packedcode;
      livelli_giacenza().pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV1)),1);
      livelli_giacenza().pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV2)),2);
      livelli_giacenza().pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV3)),3);
      livelli_giacenza().pack_grpcode(packedcode,row.get(fld_righe.cid2index(F_LIV4)),4);
      recrighe.put("LIVGIAC", packedcode);
    }     
}  
  
bool TMask_movmag::handle_righe(TMask_field &f, KEY k)
{
  if (k == K_ENTER)  
  {
    TSheet_field& ss = (TSheet_field&)f;

    const int codart = ss.cid2index(F_CODART);
    for (int i = ss.items()-1; i >= 0; i--)
    {
      if (*ss.cell(i,codart) <= ' ') // Riga senza codice articolo = vuota
        ss.destroy(i);
    }
    
    const int codmag = ss.cid2index(F_CODMAG);
    if (ss.column_enabled(codmag))
    {
      for (int i = 0; i < ss.items(); i++)
      {
        if (*ss.cell(i,codmag) <= ' ')
        {
          f.error_box(FR("Nella riga %d manca l'indicazione del magazzino "),i+1);
          return FALSE;
        }
      }
    }
  }
  return TRUE;
}

bool TMask_movmag::notify_righe(TSheet_field & ss, int r, KEY key)
{
  TMask_movmag &m=(TMask_movmag &)ss.mask();
  static TString16 old_codcaus;
  static TString old_codart(20);
  static real old_quant(1);
  if ( key == K_DEL ) // Cancellazione 
  {
    if (*ss.cell(r,ss.cid2index( F_AUTOMATICA))==riga_automatica)
      return FALSE; // can't remove auto lines directly
    while (r < ss.items()-1 && *ss.cell(r+1,ss.cid2index( F_AUTOMATICA))==riga_automatica)
    {
      // autoremove automatic lines along with the original one
      ss.destroy(r+1);
    }

  } else if (key == K_INS) { // Inserimento              
    if (r < ss.items() && *ss.cell(r,ss.cid2index( F_AUTOMATICA))==riga_automatica)
      return FALSE; // cannot insert between a row and its generated one

  } else if (key == K_CTRL + K_INS) { // Inserimento accordato
    // Magazzino e Deposito di default: controlla prima quelli della causale,
    // quindi se non sono settati, prende quelli di default
    TString16 stdmag;
    TString16 stddep;
    TToken_string key;                   
                
    key.add(m.get(F_TIPOCF));
    key.add(m.get(F_CODCF));
    stdmag = cache().get(LF_CFVEN, key, CFV_CODMAG);

		if (stdmag.not_empty())
			stddep = cache().get(LF_CFVEN, key, CFV_CODDEP);
		else
		{
			TCausale_magazzino cau = cache().get("%CAU",m.get(F_CODCAUS));
		
			if (cau.default_magdep().not_empty())
			{
				stdmag = cau.default_mag();
				stddep = cau.default_dep();
			}
			else
			{
				stdmag  = m.magazzini().standardmag();
				stddep  = m.magazzini().standarddep();
			}
		}

    if (stdmag.not_empty())
    {
      ss.row(r).add(stdmag, ss.cid2index(F_CODMAG));
      ss.row(r).add(stddep, ss.cid2index(F_CODDEP));
    }
    ss.select(r);

  } else if (key == K_SPACE) {
    old_codcaus = ss.sheet_mask().get(F_CAUSRIG);
    if (old_codcaus.blank())
      old_codcaus = ss.mask().get(F_CODCAUS);
    if (old_quant != ss.sheet_mask().get_real(F_QUANT))
    {
      old_quant = ss.sheet_mask().get_real(F_QUANT);
      m.qta_inventory(old_quant);
    }
    old_codart = ss.sheet_mask().get(F_CODART);

  } else if (key == K_ENTER)  {
    if (m.get_bool(F_INVENTORYMODE))
    {
      real diff = ss.sheet_mask().get_real(F_QUANT) ;
      m.qta_inventory(diff);
      if (diff != old_quant)
      {
        ss.sheet_mask().set(F_QUANT, diff);
        ss.row(r).add(diff.string(), ss.cid2index(F_QUANT));
      }
    }
    if (m.update_rigamov(r,old_codcaus,old_codart,old_quant))
       ss.select(r);
  }
  return TRUE;
}

bool TMask_movmag::qta_inventory(real & qta)
{
  if (get_bool(F_INVENTORYMODE))
  {
    const TMask & sm = sfield(F_RIGHE).sheet_mask();
    qta -= sm.get_real(F_GIAC);

    TString8 codcau(sm.get(F_CAUSRIG));
    if (codcau.blank())
      codcau = get(F_CODCAUS);
    if (codcau.blank())
      return error_box(TR("La causale non e' indicata"));

    TCausale_magazzino cau = cache().get("%CAU",codcau);
    switch (cau.sgn(s_giac))
    {
      case  1: break;
      case -1: qta = - qta; break;
      default: message_box(TR("La causale indicata non movimenta la giacenza"));
    }
  }
  return TRUE;
}

// proposta soft: solo se il prezzo è non nullo (già impostato)
bool TMask_movmag::handle_righeprezzo1(TMask_field &f, KEY k)
{      
  if (f.mask().get(F_PREZZO).blank())
    return handle_righeprezzo2(f, k);
  return TRUE;
}

// proposta hard: propone il prezzo in ogni caso
bool TMask_movmag::handle_righeprezzo2(TMask_field &f, KEY k)
{
  if (k == K_TAB)
  {                 
    TMask& m = f.mask();
    TMask_movmag& mmm = (TMask_movmag&)m.get_sheet()->mask();
    const TString& codart = m.get(F_CODART);
    if (f.focusdirty())
    {
      //  propone il prezzo in base alla causale
      if (codart.not_empty() && codart != mmm._price_codart)
      {
        TMask_movmag& mmm = (TMask_movmag&)m.get_sheet()->mask();
        real prz = mmm.proposed_price(codart, m.get_real(F_QUANT), m.get(F_CAUSRIG));
        m.set(F_PREZZO, prz);
      }
    }
    mmm._price_codart = codart;
  }
  return TRUE;
}

TArticolo_giacenza& TMask_movmag::curr_art()
{
  if (_curr_art == NULL)
    _curr_art = new TArticolo_giacenza;
  return *_curr_art;  
}

bool TMask_movmag::handle_checksosp(TMask_field &f, KEY k)
{
  if (k==K_TAB && f.focusdirty())
  {
    TMask_movmag& mov_mask = (TMask_movmag &)f.mask().get_sheet()->mask();
    TMask & row_mask = f.mask();
    TString16 caus(row_mask.get(F_CAUSRIG));

    mov_mask.curr_art().read(row_mask.get(F_CODART));
        
    if (caus.empty())
      caus = mov_mask.get(F_CODCAUS);
      
    const TCausale_magazzino c(caus);
        
    if (!c.movimenta_sospesi() && mov_mask.curr_art().get_bool("SOSPESO")) 
      return error_box(FR("Articolo %s sospeso, quindi non movimentabile"), (const char *)f.get());

  }
  return TRUE;
}

bool TMask_movmag::handle_codarticolo(TMask_field &f, KEY k)
{
  bool ok = true;

  if (k==K_TAB && f.focusdirty())
  {
		TSheet_field * s = f.mask().get_sheet();
    TMask_movmag& mov_mask = (TMask_movmag &)s->mask();
    TMask & row_mask = f.mask();
		TCodice_articolo codart(row_mask.get(F_CODART));   
    TRectype anamag = cache().get(LF_ANAMAG, codart);  // anamag puo' cambiare
    
    if (anamag.empty())
    {
      TLocalisamfile codalt(LF_CODCORR);
      
      codalt.setkey(2);
      codalt.put(CODCORR_CODARTALT, codart);
      if (codalt.read() == NOERR)
      {                                   
        codart = codalt.get(CODCORR_CODART);
        anamag = cache().get(LF_ANAMAG, codart);
        if (!anamag.empty())
					row_mask.set(F_CODART, codart, 0x2);
				else
					return error_box(TR("Articolo assente"));
      }
    }

		f.check_type(CHECK_REQUIRED);
		ok = f.check(STARTING_CHECK);
		f.check_type(CHECK_SEARCH);

    if (ok)
		{
			mov_mask.curr_art().read(codart);
			ok = handle_checksosp(f, k);
			if (ok)
		    handle_righeprezzo2(f, k);
		}
		else 
			error_box(TR("Articolo assente"));
  }             

  return ok;
}

bool TMask_movmag::handle_causrig(TMask_field &f, KEY k)
{
  if (k==K_TAB && f.focusdirty())  
  {
    if (!handle_checksosp(f, k))
      return FALSE;        
    handle_righeprezzo1(f, k);
  }

  return TRUE;
}

// proposta hard: propone il prezzo in ogni caso
bool TMask_movmag::handle_giacattuale(TMask_field &f, KEY k)
{
  TMask & maskrighe =f.mask();
  TMask_movmag &maskmov=(TMask_movmag &)maskrighe.get_sheet()->mask();
  if (k==K_TAB && (!maskmov.is_running() || f.focusdirty()))
  {
    TString codliv;
    // codici livello
    if (livelli_giacenza().enabled()) 
    {
      livelli_giacenza().pack_maskgrpcodes(codliv,maskrighe,F_LIV1,4);
      codliv.rtrim();
    }
    TString16 codmag(maskrighe.get(F_CODMAG));
    codmag.insert(maskrighe.get(F_CODDEP),3);

    const TString& um = maskrighe.get(F_UM);
    if (um.not_empty())
    {
      TArticolo_giacenza & art = maskmov.curr_art();
      real disp = art.disponibilita(maskmov.get(F_ANNOES),codmag,codliv,TRUE);
      disp = art.convert_to_um(disp, um, NULL, false);
      f.set(disp.string());
    } 
  }
  return TRUE;
}     


bool TMask_movmag::update_rigamov (int r, const char * old_codcaus, const char * old_codart, const real & old_quant)
{
  bool added_some=add_autorows(r, old_codcaus, old_codart, old_quant);
  if (added_some)
    add_explrows(r+1);
  added_some |=add_explrows(r);
  return added_some;
}

bool TMask_movmag::add_autorows (int r, const char * old_codcaus, const char * old_codart, const real & old_quant)
{
  bool added_some=FALSE;
  TSheet_field & ss=(TSheet_field & )field(F_RIGHE);
  real new_factor(ss.cell(r,ss.cid2index(F_QUANT)));
  new_factor = old_quant.is_zero() ? ZERO : new_factor / old_quant;
  TString16 new_codcaus(ss.cell(r,ss.cid2index(F_CAUSRIG)));
  if (new_codcaus.blank())
    new_codcaus=get(F_CODCAUS);

  TCausale_magazzino oldcau = cache().get("%CAU",old_codcaus);
  TCausale_magazzino cau    = cache().get("%CAU",new_codcaus);
  bool rimuovi_righe_coll=FALSE;
  bool inserisci_righe_coll= *cau.caus_collegata()!='\0' && *ss.cell(r,ss.cid2index(F_ESPLOSA)) == ' ';
  if (inserisci_righe_coll)
  {
    // *******************************
    // deve esserci una riga collegata
    TCausale_magazzino cau_coll = cache().get("%CAU",cau.caus_collegata());

    if (old_codcaus !=  new_codcaus)
    {
      rimuovi_righe_coll = TRUE;
    }
    else
      if ((r < ss.items()-1 && *ss.cell(r+1,ss.cid2index( F_AUTOMATICA)) == riga_automatica) 
           && cau_coll.esplodente())
      {
        if (strcmp(old_codart,ss.cell(r,ss.cid2index( F_CODART)))!=0 )
          // ho cambiato il codice articolo del finito: rimuovo le righe automatiche esplose
          rimuovi_righe_coll = TRUE;
        else 
          inserisci_righe_coll=FALSE;
      }
  }
  else
    if (*oldcau.caus_collegata()!='\0') // ho cambiato causale, passando ad una che non ha collegamenti
      rimuovi_righe_coll=TRUE;
  // ******************
  if (rimuovi_righe_coll)
  {
    while (r < ss.items()-1 
      && *ss.cell(r+1,ss.cid2index( F_AUTOMATICA)) == riga_automatica)
      ss.destroy(r + 1);
  }

  // ******************
  if (inserisci_righe_coll)
  {
    TCausale_magazzino cau_coll   =cache().get("%CAU",cau.caus_collegata());
    TString16 mag, dep;
    mag = cau_coll.default_mag();
    dep = cau_coll.default_dep();
    TString tmpstr;
    int offset=1;
#define COPIA_SU_AUTO(colnum) {tmpstr=(ss.row(r).get(ss.cid2index(colnum))); ss.row(r+offset).add(tmpstr,ss.cid2index(colnum));}
    if ((r == ss.items()-1 || r < ss.items()-1 && *ss.cell(r+1,ss.cid2index( F_AUTOMATICA)) != riga_automatica))
    {
      // manca, la inserisco
      ss.insert(r+offset);
      TToken_string & newrow = ss.row(r+offset);
      newrow = ss.row(r);
      newrow.add(TString(1,riga_automatica),ss.cid2index(F_AUTOMATICA));
      if (cau_coll.has_default_mag())
        newrow.add(mag,ss.cid2index(F_CODMAG));
      if (cau_coll.has_default_dep())
        newrow.add(dep,ss.cid2index(F_CODDEP));
      COPIA_SU_AUTO(F_PREZZO);
      added_some= TRUE;
    } 
    while (r+offset < ss.items() && *ss.cell(r+offset,ss.cid2index( F_AUTOMATICA))==riga_automatica)
    {
      // riporta eventuali cambiamenti della riga "Master" sulle righe automatice
      if (*ss.cell(r+offset,ss.cid2index( F_ESPLOSA)) <=' ')
      {
        COPIA_SU_AUTO(F_CODART);
        COPIA_SU_AUTO(F_LIV1);
        COPIA_SU_AUTO(F_LIV2);
        COPIA_SU_AUTO(F_LIV3);
        COPIA_SU_AUTO(F_LIV4);
        COPIA_SU_AUTO(F_UM);
        COPIA_SU_AUTO(F_QUANT);
        ss.row(r+offset).add(cau.caus_collegata(),ss.cid2index(F_CAUSRIG));
        ss.check_row(r+offset);
        ss.force_update(r+offset);
      } else {
        if (new_factor != 1.0)
        {
          real q(ss.row(r+offset).get(ss.cid2index(F_QUANT)));
          q*=new_factor;
          tmpstr=q.string(); 
          ss.row(r+offset).add(tmpstr,ss.cid2index(F_QUANT));
          ss.force_update(r+offset);
        }
      }
        
      offset++;
    }
  } 
  return added_some;
}

bool TMask_movmag::add_explrows(int r)
{
  TSheet_field & sheet=(TSheet_field & )field(F_RIGHE);
  TString16 new_codcaus(sheet.cell(r,sheet.cid2index(F_CAUSRIG)));
  if (new_codcaus.blank())
    new_codcaus=get(F_CODCAUS);

  bool added_some=FALSE;

  TCausale_magazzino cau = cache().get("%CAU",new_codcaus);
  TArticolo articolo;
  
  if (cau.esplodente() && *sheet.cell(r,sheet.cid2index(F_ESPLOSA)) == ' ')
  {
    TDistinta_tree  distinta;
    TArticolo       articolo;
    TArray boom;
    // *******************************
    // c'e' una riga di movimento esplodente non ancora esplosa: 
    // va sostituita con n righe esplose
    real prezzo,quant;  
    const char tipo_costo = cau.get("S11")[0];
    const int livello = cau.get_int("I0");
    const TString codart = sheet.cell(r,sheet.cid2index(F_CODART));
    bool ok = distinta.set_root(codart);
    const int rigaprec = r - 1;
    const bool is_coll = rigaprec >= 0 && *sheet.cell(r, sheet.cid2index(F_AUTOMATICA)) == riga_automatica;
    if (ok)
    {
      distinta.explode(boom, TRUE, RAGGR_EXP_NONE, livello, "A");
      for (int newrow=0; newrow < boom.items() ; newrow++)
      {
        TRiga_esplosione & riga_esp=(TRiga_esplosione & )(boom[newrow]);
        sheet.insert(r+newrow+1);
        TToken_string & nuova_riga=sheet.row(r+newrow+1);
        nuova_riga=sheet.row(r);
        nuova_riga.add(riga_esp.articolo()  ,sheet.cid2index(F_CODART));
        nuova_riga.add(riga_esp.um() , sheet.cid2index(F_UM));
        quant=sheet.row(r).get(sheet.cid2index(F_QUANT));
        quant*=riga_esp.val();
        nuova_riga.add(quant.string() , sheet.cid2index(F_QUANT));

        articolo.read(riga_esp.articolo());
        char coll_type = articolo.get_char(ANAMAG_COLLTYPE);
        TString16 codmag;
            
        if (coll_type == 'M')
        { 
          if (is_coll)
            codmag = *sheet.cell(rigaprec, sheet.cid2index(F_CODMAG));
        }
        else
          if (coll_type == 'F')
          {                         
            TString key("F|");                   
                
            key << articolo.get(ANAMAG_CODFORN);
            codmag = cache().get(LF_CFVEN, key, CFV_CODMAG);
          }
          else
            if (coll_type == 'A')
              codmag = articolo.get(ANAMAG_CODMAG);
        if (codmag.not_empty()) 
        {                           
          const TString16 mag(codmag.left(3));
          const TString16 dep(codmag.mid(3));
          
          nuova_riga.add(mag ,sheet.cid2index(F_CODMAG));
          nuova_riga.add(dep ,sheet.cid2index(F_CODDEP));
        }
        articolo.read(riga_esp.articolo());
        if (tipo_costo == 'U')
          prezzo = articolo.get_real(ANAMAG_ULTCOS1);
        else
          if (tipo_costo == 'S')
            prezzo = articolo.get_real(ANAMAG_COSTSTD);
        if (!prezzo.is_zero())
          nuova_riga.add(prezzo.string(),sheet.cid2index(F_PREZZO));
        nuova_riga.add("X",sheet.cid2index(F_ESPLOSA));
  
        sheet.check_row(r+1+newrow);
        sheet.force_update(r+1+newrow);
        added_some=TRUE;
      }
      // elimino la riga "padre"
      if (boom.items() > 0)
      {
        if (boom.items() == 1 && codart == ((TRiga_esplosione &)boom[0]).articolo())
          error_box(TR("Distinta %s ciclica"), (const char *)codart);
        sheet.destroy(r);
      }
      else
        message_box(FR("Impossibile esplodere l'articolo %s"), (const char *)codart);


    }
  }
  return added_some;
}

real TMask_movmag::proposed_price(const char *codart, 
        real quant, const char *causrig)
{ 
  real rv;
  TCausale_magazzino cau(causrig && *causrig ? causrig : (const char *) get(F_CODCAUS));
  TLocalisamfile anamag(LF_ANAMAG);
  anamag.put("CODART",codart);
  anamag.read();
  switch (cau.tipoprz()) 
  {
    // prezzo 
    case 'P': 
    {
      TLocalisamfile umart(LF_UMART);
      TConfig cfgditta(CONFIG_DITTA);
      TCondizione_vendita cv(&cfgditta,&anamag,&umart);
      cv.put_listino(get(F_CODLIST),get(F_CATVEN));
      cv.ricerca(codart,quant);
      rv=cv.get_prezzo();
    }
    break;
    // costo
    case 'C': 
      {
	      TLocalisamfile umart(LF_UMART);
		    TConfig cfgditta(CONFIG_DITTA);
			  TCondizione_vendita cv(&cfgditta,&anamag,&umart);
				cv.put_listino(get(F_CODLIST),get(F_CATVEN));
				cv.ricerca(codart,quant);
				rv=cv.get_prezzo();
				if (rv == ZERO)
					rv=anamag.get_real("ULTCOS1");
      }
    break;
  }
  return rv;
}

bool TMask_movmag::handle_codcaus(TMask_field &fld, KEY k)
{
  static TString16 old_codcaus;

  if (k == K_TAB && fld.focusdirty() && old_codcaus!="")  
  {
    // aggiorna le righe di sheet
    TMask_movmag &m=(TMask_movmag &)fld.mask();
    TSheet_field & ss=(TSheet_field & )m.field(F_RIGHE);
    bool added_some = FALSE;
    
    // aggiorna le righe che dipendono dalla causale movimento
    for (int i=0; i< ss.items(); i++)
    {
      if (*ss.cell(i,ss.cid2index(F_CAUSRIG)) ==' ')
        added_some &=(m.update_rigamov(i,old_codcaus,ss.cell(i,ss.cid2index(F_CODART)), real(ss.cell(i,ss.cid2index(F_QUANT)))));
    }
    if (added_some)
    {
      ss.dirty();
      ss.set_focus();
    }
  }
  if (k == K_TAB) 
    old_codcaus=fld.get();
  return TRUE;
}

bool TMask_movmag::handle_datacomp(TMask_field &fld, KEY k)
{
  if (k == K_TAB) // && fld.focusdirty()) 
  {
    TMask_movmag& m = (TMask_movmag&) fld.mask();
    const int codes=m.esercizi.date2esc(TDate(fld.get()));
    if (codes>0) {
      fld.mask().field(F_ANNOES).set(codes);
      fld.mask().field(H_ANNOES).set(codes);
    } 
    else 
      return fld.error_box(TR("La data indicata non appartiene a nessuno degli esercizi contabili inseriti ")) ;
  }
  return TRUE;
}

class TApp_movmag: public TRelation_application 
{
  TMask_movmag *_msk; // maschera principale
  TRelation * _rel;   // relazione contenente il file movimenti

  virtual bool user_create();
  virtual bool user_destroy();                        
  virtual TMask *get_mask(int) { return _msk; }
  virtual void init_query_mode(TMask&) ;
  virtual void init_insert_mode(TMask&) ;
  virtual void init_modify_mode(TMask&) ;
  virtual bool changing_mask(int) { return FALSE; }
  virtual TRelation *get_relation() const { return _rel; }
  virtual const char *get_next_key();
  virtual int read(TMask& m);
  TString16 _nextcod;    

public:
  TApp_movmag() {};
  virtual ~TApp_movmag() {};
};


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

int TApp_movmag::read(TMask& m)
{
  TArticolo_giacenza & art = _msk->curr_art();
              
  art.read("");        
  return TRelation_application::read(m);
}                                       

void TApp_movmag::init_query_mode(TMask& m)
{
  m.enable(F_INVENTORYMODE);     
  TRelation_application::init_query_mode(m);
}
void TApp_movmag::init_modify_mode(TMask& m)
{
  m.disable(F_INVENTORYMODE);
  const bool inventory = m.get_bool(F_INVENTORYMODE);
  TSheet_field & ss = m.sfield(F_RIGHE);
  ss.sheet_mask().field(F_QUANT).check_type(inventory ? CHECK_NONE : CHECK_REQUIRED);
  TRelation_application::init_modify_mode(m);
}
void TApp_movmag::init_insert_mode(TMask& m)
{
  m.disable(F_INVENTORYMODE);
  const bool inventory = m.get_bool(F_INVENTORYMODE);
  TSheet_field & ss = m.sfield(F_RIGHE);
  ss.sheet_mask().field(F_QUANT).check_type(inventory ? CHECK_NONE : CHECK_REQUIRED);
  TRelation_application::init_insert_mode(m);
}

bool TApp_movmag::user_create()
{
  open_files(LF_ANAMAG, LF_UMART, LF_CODCORR, LF_DESLIN, LF_MOVMAG,LF_RMOVMAG, LF_MAG, LF_STOMAG, LF_TABCOM,0);
  
  TMov_mag * m_m= new TMov_mag(); // record del movimento di magazzino
  m_m->enable_autoload(LF_RMOVMAG);
  
  // maschera specifica con gli handler dei movimenti
  _msk= new TMask_movmag(m_m);                                                                             
  // relazione con un solo file (LF_MOVMAG) ma col record Head_Body
  _rel= new TRelation(LF_MOVMAG);
  _rel->lfile().set_curr(m_m);
      
  return TRUE;
}

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

// autonumerazione
const char *TApp_movmag::get_next_key()
{
  const char* nk = ((TMov_mag &)_rel->curr()).get_next_key();
  return _nextcod.format("%d|%s",F_NUMREG, nk);
}

int mg1100(int argc, char* argv[])
{
  TApp_movmag a;
  a.run(argc, argv, TR("Movimenti di magazzino"));
  exit(0);
  return 0;
}