campo-sirio/ef/ef0200.cpp

#include <applicat.h>
#include <mask.h>
#include <sheet.h>
#include <msksheet.h>

#include "ef0.h"
#include "ef0200.h"

#include <clifo.h>
#include <effetti.h>

class Creazione_Effetti_da_EC : public TSkeleton_application
{
  TMask * _msk;
  TArray_sheet * _Partite_aperte;
  real _residuo;

  void          Load_Partite_Aperte(const long cli);
  static  bool  Gen_Handler(TMask_field& f, KEY k);
  static  bool  Gen_Notify(TSheet_field& sheet, int r, KEY k);                               
  static  bool  Cli_Handler(TMask_field& f, KEY k);
  virtual bool  create();
  virtual bool  destroy();
  virtual void  main_loop();
public:
  real get_res() {return _residuo;}
  void set_res(const real& a) {_residuo = a;}
  TMask* get_msk() {return _msk;}
  Creazione_Effetti_da_EC() : _residuo(0.0) {}
};

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

void Creazione_Effetti_da_EC::Load_Partite_Aperte(const long cli)
{
  /*
     Caricamento partite aperte da E.C.

     Questo che segue e' pseudo-codice; andra' verificato non appena 
     sara' completato lo scadenziario.

     TLocalisamfile Ec(LF_........);

     * Carica tutte le partite aperte del cliente *

     Ec.zero();
     Ec.put(EC_CODCLI,cli);
     Ec.read();

     Finche' si tratta dello stesso cliente...

     while (Ec.good() && Ec.get_long(EC_CODCLI) == cli) 
     {

     Controlla se la partita esaminata e' aperta...

     if (Ec.get(EC_APERTA)) 
     {
     Con questo le carica tutte nello sheet...

     TToken_string riga(80);
     riga.cut(0);
     riga.add(Ec.get(EC_ANNO));
     riga.add(Ec.get(EC_NUMERO));
     riga.add(Ec.get(EC_DATADOC));
     riga.add(Ec.get(EC_SALDO));
     _Partite_aperte->add(riga);
     }

     Legge il prossimo record

     Ec.next()
     }
     */
  TToken_string riga(80);
  riga.cut(0);
  riga.add("");
  riga.add("1994");
  riga.add("1");
  riga.add("10-11-94");
  riga.add("19000000");
  _Partite_aperte->add(riga);
  riga.cut(0);
  riga.add("");
  riga.add("1994");
  riga.add("2");
  riga.add("11-11-94");
  riga.add("18000000");
  _Partite_aperte->add(riga);
  riga.cut(0);
  riga.add("");
  riga.add("1994");
  riga.add("3");
  riga.add("16-11-94");
  riga.add("23009000");
  _Partite_aperte->add(riga);
  riga.cut(0);
  riga.add("");
  riga.add("1994");
  riga.add("4");
  riga.add("19-11-94");
  riga.add("450600");
  _Partite_aperte->add(riga);
}

bool Creazione_Effetti_da_EC::Gen_Handler(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.focusdirty())
  {        
    TMask& m = f.mask();
    real importo = m.get(F_RATA);
    importo += m.get_real(F_SPESE);
    importo += m.get_real(F_BOLLI);
    m.set(F_IMPEFF, importo);
    f.set_focusdirty(FALSE);
  }
  return TRUE;
}

bool Creazione_Effetti_da_EC::Gen_Notify(TSheet_field& sheet, int r, KEY k)
{
  if (k == K_CTRL + K_DEL)
    return TRUE;
  if (k == K_INS)
  {
    if (app().get_res().is_zero())
    {
      warning_box("Residuo da ripartire gia' annullato");
      return FALSE;
    }
    else
      return TRUE;
  }
  
  TToken_string & row = sheet.row(r);
  const real importo(row.get(1));
  static real old_rata;

  switch (k)
  {
  case K_SPACE:
    old_rata = importo;
    break;
  case K_DEL:       
    {      
      const real new_res = app().get_res() + importo;

      app().set_res(new_res);
    }
    break;
  case K_ENTER:
    {
      const real new_res = app().get_res() - importo + old_rata;
      if (new_res < ZERO)
      {
        warning_box("Non e' possibile superare l'importo da ripartire");
        if (old_rata.is_zero()) 
        {
          row.add(app().get_res().string(),1);
          app().set_res(ZERO);
        }
        else
          row.add(old_rata.string(),1);
      }      
      else
        app().set_res(new_res);
      real totale = importo;   
      totale+= real(row.get(2));
      totale+= real(row.get(3));
      row.add(totale.string(),4);
    }
    break;
  default:
    break;
  }
  sheet.mask().set(F_RESIDUO,app().get_res());
  return TRUE;
}

bool Creazione_Effetti_da_EC::Cli_Handler(TMask_field&f, KEY k)
{
  if (f.focusdirty())
  {
    TSheet_field& sheet =(TSheet_field&)f.mask().field(F_SHEET_EFF);
    sheet.reset();
    sheet.force_update();
  }
  return TRUE;
}

bool Creazione_Effetti_da_EC::create()
{
  _msk = new TMask("ef0200a");
  TSheet_field& sheet = _msk->sfield(F_SHEET_EFF);
  sheet.set_notify(Gen_Notify);
  sheet.enable_column(4,FALSE);
  TMask& mask= sheet.sheet_mask();
  mask.set_handler(F_RATA,Gen_Handler);
  mask.set_handler(F_SPESE,Gen_Handler);
  mask.set_handler(F_BOLLI,Gen_Handler);
  _msk->set_handler(F_CODCF,Cli_Handler);
  
  return TSkeleton_application::create();
}

bool Creazione_Effetti_da_EC::destroy()
{
  if (_msk != NULL) delete _msk;
  return TRUE;
}

void Creazione_Effetti_da_EC::main_loop()
{
  KEY tasto;

  do {
    tasto=get_msk()->run();
    switch (tasto)
    {
    case K_ENTER:       // first check if the application can write effects 
    {
      TSheet_field& sheet =(TSheet_field&)get_msk()->field(F_SHEET_EFF);
      if (!_residuo && sheet.items()>0)
        message_box("Perform writing procedure...");
      break;
    }
  case K_F6: //Selects opened counts from E.C.
  {
    _Partite_aperte = new TArray_sheet(-1,1,0,-1,"Selezione partite aperte","@1|Anno|Numero|Data documento|Saldo@15", 0, 1);
    Load_Partite_Aperte(get_msk()->get_long(F_CODCF));
    if (_Partite_aperte->run() == K_ENTER)
    {
      _residuo = ZERO;       
      for (int i = 0; i < _Partite_aperte->items(); i++)
        if (_Partite_aperte->checked(i))
          _residuo += real(_Partite_aperte->row(i).get(4));
      get_msk()->set(F_RESIDUO,_residuo);
      TSheet_field& sheet = (TSheet_field&)get_msk()->field(F_SHEET_EFF);
      sheet.reset();
    }      
    delete _Partite_aperte;
    break;
  }
  default:
    break;
  }
  } while (tasto!=K_QUIT);
}

int ef0200(int argc, char* argv[])
{
  Creazione_Effetti_da_EC a ;
  a.run(argc, argv, "Creazione effetti da E.C.");
  return 0;
}