campo-sirio/include/applicat.cpp

#include <stdlib.h>

#define STRICT
#define XVT_INCL_NATIVE
#include <xvt.h>

#include <stdlib.h>

#if XVT_OS == XVT_OS_WIN
#  include <toolhelp.h> 
#endif

#include <applicat.h>
#include <colors.h>
#include <config.h>
#include <mask.h>
#include <prefix.h>
#include <printer.h>
#include <progind.h>
#include <extcdecl.h>
#include <modaut.h>
#include <relation.h>
#include <urldefid.h>
#include <utility.h>
#include <xvtility.h>
#include <controls.h>

#include <bagn002.h>

#define  BITTEST(w,p) (((w) & (0x0001 << (p))) != 0)


///////////////////////////////////////////////////////////
// Metodi di accesso globali all'applicazione corrente
///////////////////////////////////////////////////////////

HIDDEN TApplication* _application = NULL;

// @doc EXTERNAL

// @func Ritorna l'applicazione in corso
//
// @rdesc Ritorna il reference all'applicazione in corso
TApplication& main_app()
{
  CHECK(_application, "NULL application!");
  return *_application;
}

// @doc INTERNAL

// @func Controlla se si sta eseguendo xvt
//
// @rdesc Ritorna i seguenti valori:
//
// @flag TRUE | Se se e' stata definita una <c TApplication>
// @flag FALSE | Se se non e' stata definita una <c TApplication>
bool xvt_running() 
{ return _application != NULL; }


///////////////////////////////////////////////////////////
// Gestione dello sfondo della finestra principale
///////////////////////////////////////////////////////////

HIDDEN long backdrop_eh( WINDOW  win, EVENT* ep)
{
  xvt_dwin_clear(win, MASK_DARK_COLOR);
  return 0L;
}

HIDDEN void create_backdrop( void )
{
#if XVT_OS == XVT_OS_WIN || XVT_OS == XVT_OS_NT
  xvt_create_statbar();
  xvt_statbar_set("");
#else
  xvt_app_escape(XVT_ESC_CH_COLOR, XVT_CH_CLR_MENU,     COLOR_BLACK, COLOR_WHITE);
  xvt_app_escape(XVT_ESC_CH_COLOR, XVT_CH_CLR_DIALOG,   COLOR_BLUE,  COLOR_WHITE);
  xvt_app_escape(XVT_ESC_CH_COLOR, XVT_CH_CLR_WINDOW,   COLOR_RED,   COLOR_WHITE);
  xvt_app_escape(XVT_ESC_CH_COLOR, XVT_CH_CLR_CONTROL,  COLOR_BLACK, COLOR_WHITE);
  xvt_app_escape(XVT_ESC_CH_COLOR, XVT_CH_CLR_DISABLED, COLOR_GRAY,  COLOR_WHITE);
  xvt_app_escape(XVT_ESC_CH_COLOR, XVT_CH_CLR_MNEMONIC, COLOR_RED,   COLOR_WHITE);

  RCT rct;
  xvt_vobj_get_client_rect( TASK_WIN, &rct );
  xvt_win_create(W_PLAIN, &rct, (char*) 0, 0, TASK_WIN,
                 WSF_NO_MENUBAR | WSF_CH_BACKDROP , EM_UPDATE,
                 backdrop_eh, 0L );
#endif
}

///////////////////////////////////////////////////////////
// Gestione del banner iniziale
///////////////////////////////////////////////////////////

class TBanner : public TWindow
{ 
protected:
  virtual void handler(WINDOW win, EVENT* ep);

public:
  TBanner();
  virtual ~TBanner();
};

TBanner::TBanner()
{
  create(-1, 6, 72, 6, "BANNER", WSF_NONE, W_PLAIN);
  hide_brush();
  open();
  do_events();
}

TBanner::~TBanner()
{      
  if (is_open())
    close();
}

void TBanner::handler(WINDOW win, EVENT* ep)
{
  if (ep->type == E_UPDATE)
  { 
    const int BIGY = 3*CHARY/2;
    
    clear(COLOR_LTGRAY);
    RCT r; xvt_vobj_get_client_rect(win, &r);

    set_color(COLOR_WHITE, COLOR_LTGRAY);
    set_font(XVT_FFN_TIMES, XVT_FS_BOLD | XVT_FS_ITALIC, BIGY);
    char* t = (char*)(const char*)main_app().title();
    int w = xvt_dwin_get_text_width(win, t, -1);
    int a; xvt_dwin_get_font_metrics(win, NULL, &a, NULL);
    int x = (r.right-w)>>1, y = (r.bottom+a)>>1 ;
    xvt_dwin_draw_text(win, x+1, y+1, t, -1);
    set_color(COLOR_BLACK, COLOR_LTGRAY);
    xvt_dwin_draw_text(win, x, y, t, -1);

    set_font(XVT_FFN_TIMES);
    t = "PRASSI S.p.A.";
    w = xvt_dwin_get_text_width(win, t, -1);
    x = (r.right-r.left-w)>>1, y = BIGY;
    xvt_dwin_draw_text(win, x, y, t, -1);

    t = "Caricamento in corso";
    w = xvt_dwin_get_text_width(win, t, -1);
    x = (r.right-r.left-w)>>1, y = r.bottom - CHARY;
    xvt_dwin_draw_text(win, x, y, t, -1);

    r.left += 5; r.right -= 4;
    r.top += 5; r.bottom -= 4;
    set_pen(COLOR_WHITE); xvt_dwin_draw_rect(win, &r);
    xvt_rect_offset(&r, -1, -1);
    set_pen(COLOR_BLACK); xvt_dwin_draw_rect(win, &r);
    
    xvt_dwin_draw_icon(win, CHARX<<1, CHARX<<1, ICON_RSRC); 
  }
  else
    TWindow::handler(win, ep);
}

long XVT_CALLCONV1 TApplication::task_eh(WINDOW win, EVENT *ep)
{
  switch (ep->type)
  {
  case E_CREATE:
    _application->pre_create();
    customize_controls(TRUE);
    create_backdrop();
#if defined(DBG) && XVT_OS == XVT_OS_SCOUNIX
    message_box("Attach to process %d ...", getpid());
#endif
    do_events();
    allow_another_instance(); 
    break;
#if XVT_OS == XVT_OS_WIN || XVT_OS == XVT_OS_NT
  case E_UPDATE:
    backdrop_eh(win, ep);
    break;
#endif
  default:
    break;
  }

  return _application->handler(win, ep);
}

long TApplication::handler(WINDOW win, EVENT* ep)
{
  switch (ep->type)
  {
  case E_CREATE:
  {
    TBanner banner;
    _create_ok = create();
  }    
  if (_create_ok)  
  {
    on_firm_change();
    on_config_change();
#if XVT_OS == XVT_OS_SCOUNIX
    do_events();
#endif
  }  
  else
    stop_run();
  break;
  case E_COMMAND:
    switch(ep->v.cmd.tag)
    {
    case M_FILE_QUIT:
      if (can_close())
        stop_run();
      break;
    case M_FILE_PG_SETUP:
      printer().set();
      break;
    case M_FILE_PRINT:
      print();
      break;
    case M_FILE_NEW:
      set_firm();
      break;
    case M_FILE_REVERT:
      if (config())
        on_config_change();
      break;
    case (M_FILE+11):
      about();
      break;
    default:
      if (ep->v.cmd.tag >= BAR_ITEM(1))
      {
        if(!menu(ep->v.cmd.tag))
          stop_run();
      }   
      break;
    }
    break;
  case E_CLOSE:
    if (can_close())
      stop_run();
    break;
  case E_FONT:                    
    {
      XVT_FNTID new_font = ep->v.font.font_id; 
      char font_ser_desc[512];          
      TConfig font(CONFIG_USER, "Font");
                                              
      xvt_font_serialize(new_font, font_ser_desc, sizeof(font_ser_desc));                                             
      font.set("FontDesc", font_ser_desc);
      font.set_paragraph("Colors");    // Forza la scrittura del paragrafo
      
      xvt_load_default_font();
    }
    break;
  case E_QUIT:
    if (ep->v.query) 
    {
      if (can_close())
        xvt_app_allow_quit();
    } 
    else 
      stop_run();
    break;
  default:
    break;
  }

  return 0L;
}


void TApplication::stop_run()
{
  if (_savefirm) prefix().set_codditta(_savefirm);
  terminate();
  xvt_app_destroy();
}


bool TApplication::add_menu(TString_array& menu, MENU_TAG id)
{                                          
  TTemp_window tw(TASK_WIN);
  return tw.add_menu(menu,id,TRUE);
}

bool TApplication::remove_menu(MENU_TAG id)
{
  TTemp_window tw(TASK_WIN);
  return tw.remove_menu(id);
}


TApplication::TApplication() : _savefirm(0), _create_ok(FALSE)
  ,   _bar(TASK_MENUBAR)
{}


TApplication::~TApplication()
{}

bool TApplication::create()
{
  return TRUE;
}


bool TApplication::destroy()
{ 
  return TRUE;
}


void TApplication::terminate()
{
  close_all_dialogs();
  
  if (_create_ok)
  {
    destroy();                    // Distruzione files e maschere
#if XVT_OS == XVT_OS_WIN || XVT_OS == XVT_OS_NT
    const word WM_WAKEUP = RegisterWindowMessage("WAKEUP");
    const HTASK ht = GetCurrentTask();
    SendMessage(HWND_BROADCAST, WM_WAKEUP, (unsigned int)ht, 0L);
#endif
    
#if XVT_OS == XVT_OS_WIN ||  XVT_OS == XVT_OS_NT
    if (fexist("prassi.hlp"))
    {
      HWND hwnd = (HWND)xvt_vobj_get_attr(TASK_WIN, ATTR_NATIVE_WINDOW);
      WinHelp(hwnd, "prassi.hlp", HELP_QUIT, 0L);
    }  
#endif  
  }
  do_events();
  
  if (use_files())           
    free_global_vars();           // Distruzione variabili globali
  
  printer_destroy();  

  customize_controls(FALSE);      // Rilascio eventuali DLL
}


const char* TApplication::get_module_name() const
{
  TScanner scanner("prassi.aut");

  bool ok = FALSE;
  for (int aut = 0; scanner.line() != ""; aut++)
    if (strncmp(scanner.token(), _name, 2) == 0) { ok = TRUE; break; }

  TString module(scanner.token().mid(3));
  if (ok) ok = has_module(aut);
  

  if (!ok)                          
  {
    TToken_string em(extra_modules());
    const int items = em.items();
    if (items != 0)
      for (int j = 0; j < items; j++)
      {
        ok = has_module(em.get_int());
        if (!ok)
          break;
      }
    if (!ok) 
    {
      error_box("Il modulo '%s' non e' autorizzato", (const char*)module);
      module = "";
    }
  }  
  return module;
}


void TApplication::set_perms()
{   
  CGetAut(1);
  _dongle_aut.set(0, TRUE);
  for (int i = 1 ; i < ENDAUT; i++)
  {
    const int af = i - 1;
    const bool val = BITTEST(_int_tab0[af / 16], af % 16);
    _dongle_aut.set(i, val);
  }
  _user_aut.set(0, TRUE);
  
  const TString& utente = user();
  if (utente.not_empty())
  {
    if (utente == "PRASSI")
    {
      for (int i = 1 ; i < ENDAUT; i++)
        _user_aut.set(i);
    }
    else
    {                   
      if (use_files())
      {
        TLocalisamfile users(LF_USER);
      
        users.zero();
        users.put("USERNAME", utente);
        if (users.read() == NOERR)
        {
          const TString& aut = users.get("AUTSTR");
          for (int i = aut.len()-1; i > 0; i--)
            _user_aut.set(i, aut[i] == 'X');
        }
      }
    }
  }
}

// @doc EXTERNAL

// @mfunc Legge il parametro /uUTENTE e lo toglie dalla lista
void TApplication::check_parameters(
     int & argc,   // @parm Numero del parametro da controllare
     char* argv[]) // @parm Array di paramentri da passare all'applicazione

// @comm Nel caso si identifichi che il paramentro <p argc> sia il nome dell'utente
//   si setta la variabile col nome dell'utente, altrimenti l'utente diventa PRASSI,
//   e si diminuisce di uno il numero di argomenti da passare.
{                         
  if (argc > 1)
  {
    const TFixed_string u(argv[argc-1]);
    if (u.compare("-u", 2, TRUE) == 0 || u.compare("/u", 2, TRUE) == 0)
    {
      user() = u.mid(2);
      argc--;
    }  
#ifdef DBG  
    else user() = "PRASSI";
#endif    
  }

#if XVT_OS == XVT_OS_WIN || XVT_OS == XVT_OS_NT
  const long twin_style = WSF_ICONIZABLE | WSF_SIZE | WSF_CLOSE | WSF_MAXIMIZED;
  xvt_vobj_set_attr(NULL_WIN,ATTR_WIN_PM_TWIN_STARTUP_STYLE, twin_style);
#endif
}

// @doc EXTERNAL

// @mfunc Fa partire l'applicazione
void TApplication::run(
     int argc,    // @parm Numero deglia argomenti da passara all'applicazione
     char* argv[],  // @parm Argomenti da passare all'applicazione
     const char* title) // @parm Titolo dell'applicazione

// @comm E' in questa fase che si controlla se esiste la chiave e' attaccata
{
  TFilename base(argv[0]);
  base.ext(""); base.lower();

  _title = title;

  if (user().empty())
    check_parameters(argc, argv);

  __argc = argc;
  __argv = (const char**)argv;

  int addbar = 0;
  if (argc > 1 && argv[1][0] == '-')
  {
    addbar = atoi(argv[1]+1);
    _name = cmd2name(argv[0], argv[1]);
  }
  else
  {
    addbar = 0;
    _name = cmd2name(argv[0]);
  }
  
  const int sn = get_serial_number();
  if (sn < 0)  
  {
    error_box("Perhaps you forgot to connect the dongle");
    return;
  }  
  
  if (use_files())
    init_global_vars();
  else
    CGetPref();           
  
  set_perms();

  const TFixed_string mod(get_module_name());
  if (mod.empty()) return;
  
  TString caption; caption << "PRASSI S.p.A. - " << mod;

  XVT_CONFIG cfg;
  cfg.base_appl_name = (char*)base.name();
  cfg.appl_name      = (char*)(const char*)_title;
  cfg.taskwin_title  = (char*)(const char*)caption;
  cfg.menu_bar_ID    = TASK_MENUBAR+addbar;
  cfg.about_box_ID   = 0;
  
  xvt_vobj_set_attr(NULL_WIN,ATTR_WIN_PM_DRAWABLE_TWIN, TRUE);

  _application = this;
  xvt_app_create(argc, argv, 0L, task_eh, &cfg);
}


// About box: risposta alla opzione Informazioni del menu File
void TApplication::about() const
{                                               
#include <prassi.ver>             
  const TFilename n(__argv[0]);
  message_box("PRASSI Versione %s\nProgramma %s\nLibreria del %s\nN.ro di serie %d-%s", 
              VERSION, (const char*)n.name(), __DATE__, SerNo, INTERNAL_VERSION);
}

// Risposta alla selezione Stampa del menu File
void TApplication::print()
{
#ifdef DBG
  error_box("Non saprei bene cosa stampare!");
#endif
}

void TApplication::check_menu_item(MENU_TAG item)
{
  xvt_menu_set_item_checked(TASK_WIN, item, TRUE);
  xvt_menu_update(TASK_WIN);
}

void TApplication::uncheck_menu_item(MENU_TAG item)
{
  xvt_menu_set_item_checked(TASK_WIN, item, FALSE);
  xvt_menu_update(TASK_WIN);
}

// @doc EXTERNAL

// @mfunc Permette di abilitare/disabilitare una voce di menu'
void TApplication::enable_menu_item(
     MENU_TAG item,   // @parm Voce del menu' da abilitare/disabilitare
     bool on)       // @parm Operazione da svolgere sulla voce del menu':
      //
      // @flag TRUE | Viene abilitata la voce del menu'
      // @flag FALSE | Viene disabilitata la voce del menu'

{
  xvt_menu_set_item_enabled(TASK_WIN, item, on);
  xvt_menu_update(TASK_WIN);
}

void TApplication::dispatch_e_menu(MENU_TAG item)
{
#if XVT_OS == XVT_OS_WIN || XVT_OS == XVT_OS_NT
  HWND w = (HWND)xvt_vobj_get_attr(TASK_WIN, ATTR_NATIVE_WINDOW);
  PostMessage(w, WM_COMMAND, item, 0L);
#else
  ::dispatch_e_menu(TASK_WIN, item);
#endif  
}

// @cmember Setta il cursore a clessidra  (To be removed soon)
void TApplication::begin_wait()
{
  ::begin_wait();
}

// @cmember Setta il cursore standard     (To be removed soon)
void TApplication::end_wait()
{ 
  ::end_wait();
}

bool TApplication::has_module(int module, int checktype) const
{
  bool ok = TRUE;
  if (checktype == CHK_ALL || checktype == CHK_DONGLE)
    ok = _dongle_aut[module];
  if (ok && checktype == CHK_ALL || checktype == CHK_USER)
    ok = _user_aut[module];
  return ok;
}


long TApplication::get_firm() const
{
  return prefix().get_codditta();
}

const char* TApplication::get_firm_dir() const
{
  return format("%s%s", __ptprf, prefix().name());
}


bool TApplication::set_firm(long newfirm)
{
  const long oldfirm = get_firm();

  if (newfirm < 1)
  {
    TMask mask("bagn002");
    TString80 pp(__ptprf); pp.cut(pp.len()-1);
    mask.set(F_PATHPREF, pp);

    mask.show(-2, extended_firm());

    disable_menu_item(M_FILE_NEW);
    const KEY k = mask.run();
    enable_menu_item(M_FILE_NEW);

    if (k == K_ENTER)
    {
      newfirm = mask.get_long(F_CODDITTA);
      const int tipodir = mask.get_int(F_TIPO);

      if (tipodir == 0 && !prefix().exist(newfirm) &&
          !build_firm_data(newfirm))
        return FALSE;
      if (tipodir > 0)
      {
        if (_savefirm == 0) _savefirm = oldfirm;   // E' necessario ricordare la ditta ...
        prefix().set(tipodir == 1 ? "com" : "");   // ... se si setta il prefix a com
        return TRUE;
      }
    }
  }

  if (newfirm == oldfirm || newfirm < 1)
    return newfirm > 0;

  if (prefix().test(newfirm))
  {
    prefix().set_codditta(newfirm);
    _savefirm = 0;
    
    WINDOW w = cur_win();
    if (w != NULL_WIN)
    {      
      TWindow * win = (TWindow *) xvt_vobj_get_data(w);
      
      win->on_firm_change();
    }
    on_firm_change();
    on_config_change();
  }

  return TRUE;
}

// @doc INTERNAL

// @mfunc Gestisce le voci di configurazione
//
// @rdesc Ritorna TRUE se sono state cambiate delle voci
bool TApplication::config()

// @comm Le si passa il file in cui cercare il proprio paragrafo (comunque relativo
//       alla ditta) se non c'e', viene creato copiando il default la variabile EdMask 
//       di quel paragrafo specifica la maschera da usare.

{                          
  bool ok = FALSE;

  TConfig cnf(CONFIG_DITTA);
  const TFilename maskname = cnf.get("EdMask");
  if (maskname.empty())
    return warning_box("Nessun parametro da configurare");
  
  TMask* msk = new TMask(maskname);    // Evito problemi di stack
  TMask& m = *msk;
  
  // carica campi
  for (int i = 0; i < m.fields(); i++)
  {
    TEditable_field& f = (TEditable_field&)m.fld(i);
    const TFieldref* fref = f.field();
    if (fref != NULL)
    {
      const char* fname = fref->name();
      if (fname != NULL)
      {
        TString& oldvl = cnf.get(fname);
        if (!oldvl.empty())
          f.set(oldvl);
      }
    }
  }
  
  // run mask
  disable_menu_item(M_FILE_REVERT);
  
  if (m.run() == K_ENTER && m.dirty())
  {
    // aggiusta campi
    for (i = 0; i < m.fields(); i++)
    {
      TEditable_field& f = (TEditable_field&)m.fld(i);
      if (f.dirty())
      {
        const TFieldref* fref = f.field();
        if (fref != NULL)
          cnf.set(fref->name(), f.get(), NULL, TRUE);
      }
    }
    ok = TRUE;
  }
  
  delete msk;
  enable_menu_item(M_FILE_REVERT);
  return ok;
}

// @doc EXTERNAL

// @mfunc Controlla se al programma corrente e' concesso cambiare ditta da menu.
//
// @rdesc Ritorna i seguenti valori:
//
// @flag TRUE | Se e' abilitata la voce di menu' per il cambio della ditta
// @flag FALSE | Se non e' possibile cambiare ditta da menu'
bool TApplication::firm_change_enabled() const

// @comm Praticamente controlla se e' stato lanciato da ba0 o dal program manager
{   
#if XVT_OS == XVT_OS_WIN || XVT_OS == XVT_OS_NT
  static bool can = 2;
  if (can == 2)
  {
#if XVT_OS == XVT_OS_WIN
    TASKENTRY te; te.dwSize = sizeof(TASKENTRY); 
    HTASK ct = GetCurrentTask();
    TaskFindHandle(&te, ct);
    TaskFindHandle(&te, te.hTaskParent);
    can = stricmp(te.szModule, "BA0") == 0 ||
#ifdef DBG
      stricmp(te.szModule, "CVW4") == 0 ||
      stricmp(te.szModule, "MSVC") == 0 ||
#endif    
        stricmp(te.szModule, "PROGMAN") == 0;
#else
    can = TRUE;
#endif
  }        
  return can;
#else
  return TRUE;
#endif  
}



void TApplication::on_firm_change()
{}

void TApplication::on_config_change()
{}