campo-sirio/mr/mr0400.cpp

// Gestione parametri ditta MRP

#ifndef __CONFAPP_H
#include <confapp.h>
#endif

#include "mrplib.h"
#include "mr0400.h"

#define NTURNI    8

class TConf_MRP_mask : public TCalendar_mask
{
protected:
  virtual bool on_field_event(TOperable_field& o, TField_event e, long jolly);

public:
  TConf_MRP_mask(const char* name, int num = 0);
  virtual ~TConf_MRP_mask();
};

bool TConf_MRP_mask::on_field_event(TOperable_field& o, TField_event e, long jolly)
{
  switch (o.dlg())
  {
    case F_YEAR:
      if (e == fe_init || e == fe_modify)
        update_calendar(F_CALENDAR, F_YEAR);
      break;
    default:
      break;
  }
  return TRUE;
}

TConf_MRP_mask::TConf_MRP_mask(const char* name, int num)
         : TCalendar_mask(name, num)
{
  set_handlers();
}

TConf_MRP_mask::~TConf_MRP_mask()
{
}

//////////////////////////////////////////////////
// TConf_MRP_application
//////////////////////////////////////////////////
class TConf_MRP_application : public TConfig_application
{
  TConf_MRP_mask *_mask;

protected:
  virtual TMask* get_mask() { return _mask; }
  virtual TMask* create_mask(const TFilename& f) { if (_mask == NULL) _mask = new TConf_MRP_mask(f); return _mask;}
  virtual void   destroy_mask()                  { delete _mask; _mask = NULL; }
  virtual void load_mask();
  virtual void save_mask(bool tosave);

public:
  virtual bool preprocess_config (TMask& mask, TConfig& config);
  virtual bool postprocess_config (TMask& mask, TConfig& config);
  virtual bool user_create();
  virtual bool user_destroy();

  TConf_MRP_application() : TConfig_application(CONFIG_DITTA) { _mask = NULL;}
  virtual ~TConf_MRP_application() {}
};

void TConf_MRP_application::load_mask()
{
  TMask* mask = get_mask();
  if (mask==NULL) 
    return;
  TConfig* config_ditta = get_config();
  TConfig_application::load_mask();
  TToken_string workstring = config_ditta->get("NumOrdProd");
  TSheet_field& sf_num = mask->sfield(F_TIPONUM);
  sf_num.destroy();
  FOR_EACH_TOKEN(workstring, tok)
  {
    sf_num.row(-1) = tok;
    sf_num.check_row(sf_num.items()-1);
  }

  TSheet_field& sf_tip = mask->sfield(F_TIPOTIP);
  sf_tip.destroy();
  for (int k = 0; config_ditta->exist("TipOrdProd", k); k++)
  {
    workstring= config_ditta->get("TipOrdProd", NULL, k);
    TToken_string& row = sf_tip.row(-1);
    row.add(workstring.get(0), 0);
    row.add(workstring.get(1), 2);
    row.add(workstring.get(2), 3);
    sf_tip.check_row(sf_tip.items()-1);
  }
}

void TConf_MRP_application::save_mask(bool tosave)
{
  TMask* mask = get_mask();
  if (mask==NULL) 
    return;
  bool ask_save = mask->dirty() && !tosave;
  if (ask_save)
    tosave = yesno_box("Modifiche non registrate. Salvare?");
  if (tosave)
  {
    TConfig* config_ditta = get_config();
    TConfig_application::save_mask(tosave);

    //salva sul file di configurazione della ditta una tokenstring con lo sheet delle numerazioni..
    TToken_string workstring;
    TSheet_field& sf_num = mask->sfield(F_TIPONUM);
    FOR_EACH_SHEET_ROW(sf_num, i, row)
    {
      workstring.add(row->get(0));
    }
    config_ditta->set("NumOrdProd",workstring);

    //...e poi anche con i tipi dello sheet          
    //per prima cosa va svuotato il paragrafo dalle precedenti "TipOrdProd" 
    for (int k = 0; config_ditta->exist("TipOrdProd", k); k++)
      config_ditta->remove("TipOrdProd", k);

    TSheet_field& sf_tip = mask->sfield(F_TIPOTIP);
    int c = 0;
    FOR_EACH_SHEET_ROW(sf_tip, j, line)
    {
      workstring.cut(0);
      workstring.add(line->get(0));
      if (!workstring.blank())
      {
        workstring.add(line->get(2));
        workstring.add(line->get(3));
        config_ditta->set("TipOrdProd", workstring, NULL, true, c++);
      }
    }
  }
}

bool TConf_MRP_application::preprocess_config (TMask& mask, TConfig& c)
{
  TMRP_config& config=(TMRP_config&)c;
  for (int i = 0; i < NTURNI; i++)
  {
    const  short h = F_T1HINIZIO+(i*4);
    // inizio turno
    mask.set(h  , config.ora_inizio_turno(i)); // Hour...
    mask.set(h+1, config.min_inizio_turno(i)); // Minutes...
    // durata turno
    mask.set(h+2, config.ore_durata_turno(i));
    mask.set(h+3, config.min_durata_turno(i));
    mask.set(F_T1NUMPERS+i,config.numpers_turno(i));
  }
  // Carica il calendario
  ((TCalendar_mask&)mask).update_calendar(F_CALENDAR, F_YEAR);

  return TRUE;
}

bool TConf_MRP_application::postprocess_config (TMask& mask, TConfig& c)
{
  TMRP_config& config=(TMRP_config&)c;
  for (int i = 0; i < NTURNI; i++)
  {
    // Traduce le ore ed i minuti
    const short h = F_T1HINIZIO+(i*4);
    config.set_inizio_turno(i,mask.get_int(h)  ,mask.get_int(h+1));
    config.set_durata_turno(i,mask.get_int(h+2),mask.get_int(h+3));
    // numero di persone
    config.set_numpers_turno(i,mask.get_int(F_T1NUMPERS+i));
  }
  config.set_gestimpianti(mask.get_bool(F_GESTIMPIANTI));
  config.set_turni(mask.get_int(F_NTURNI));
  
  TString paragraph(config.get_paragraph());
  config.set_paragraph(""); // Akkrokkio per salvare il calendario...
  ((const TCalendar_mask&)mask).calendar().write();
  config.set_paragraph(paragraph); // re-read

  return TRUE;
}


bool TConf_MRP_application::user_create()
{
  TConfig conf(CONFIG_DITTA);
  conf.set( "EdMask", "mr0400a", "mr");
  return TRUE;
}

bool TConf_MRP_application::user_destroy()
{
  return TRUE;
}

int mr0400(int argc, char* argv[])
{
  TConf_MRP_application app;

  app.run(argc, argv, TR("Parametri gestione MRP"));
  return 0;
}