//Il sorgente va scritto in notazione ungherese.
//Le variabili seguono la seguente regola: 'acronimo tipo'+'nome variabile cammellata' 
//Es. wxArrayString 'as' + 'AcceptRefuse' -> asAcceptRefuse
#include "wxinc.h"

#include <wx/dir.h>
#include <wx/fileconf.h>
#include <wx/filepicker.h>
#include <wx/gbsizer.h>
#include <wx/html/htmlwin.h>
#include <wx/mimetype.h>
#include <wx/progdlg.h>
#include <wx/radiobox.h>
#include <wx/txtstrm.h>
#include <wx/wfstream.h>
#include <wx/wizard.h>
#include <wx/zipstrm.h>

#ifdef WIN32
#include <shlobj.h>
#endif

#include "setupkey.h"

#define HGAP 4
#define VGAP 2

///////////////////////////////////////////////////////////
// Utilities
///////////////////////////////////////////////////////////

wxString GetDefaultDestination()
{
  wxString strDest;
//scelta della directory di installazione di default
#ifdef WIN32
  TCHAR strFolder[MAX_PATH];
  ::SHGetFolderPath(NULL, CSIDL_PROGRAM_FILES, NULL, SHGFP_TYPE_CURRENT, strFolder);
  strDest = strFolder;
#endif

  if (strDest.IsEmpty())
  {
    // Forse è la cartella base dove è installato Word?
    wxFileType* pDoc = wxTheMimeTypesManager->GetFileTypeFromExtension(wxT("doc"));
    if (pDoc != NULL)
    {
      wxFileName strFilename = pDoc->GetOpenCommand(wxT("pippo.doc"));
      while (strFilename.GetDirCount() > 1)
        strFilename.RemoveLastDir();
      strDest = strFilename.GetPath().After('"');
      if (strDest.StartsWith(wxT("C\\")))
        strDest = wxT("C:") + strDest.Mid(1);
    }
  }

  return strDest;
}

///////////////////////////////////////////////////////////
// CampoWizardPage
///////////////////////////////////////////////////////////
class CampoWizardPage;  //predefinizione di CampoWizardPage (magia nera!!)
//predefinizione pure della CampoWizard con tutti i suoi metodi per poterlo usare nel metodo GetWizard (magia nerissima!!)
class CampoWizard : public wxWizard
{
  enum { m_nPages = 10 };  
  CampoWizardPage* m_pPage[m_nPages];

  wxString _strDestinationPath;       //path di aggiornamento/installazione
  unsigned int _uInstallationType;    //tipo di installazione selezionata (standard,server,client,aggiornamento)
  unsigned int _uDongleType;          //tipo di chiave di protezione (hardlock,eutron,server)

  wxString _strPrgLocPath;  //path programmi in locale
  wxString _strPrgNetPath;  //path programmi in remoto (server programmi directory per client)
  wxString _strDataPath;    //path dati (creare o usare)

  bool _bInstDemoData;      //installa dati dimostrativi
  bool _bInstUseAuth;       //installa/usa server authoriz
  wxString _strSrvAuth;     //nome server authoriz
  bool _bInstUseDict;       //installa/usa server diction
  wxString _strSrvDict;     //nome server diction
  
  unsigned int _iSrvAutostartMode;  //tipologia di esecuzione dei server
  bool _bDesktopShortcut;   //crea il link sul desktop

protected:
  DECLARE_EVENT_TABLE();
  void OnNext(wxCommandEvent& e);

  int Pages() const { return m_nPages; }
  CampoWizardPage& Page(int p) const { wxASSERT(p >= 0 && p < m_nPages); return *m_pPage[p]; }
 
public:
  bool Run();
  wxString Get(wxWindowID id) const;
  int GetSelection(wxWindowID id) const;
  bool GetBool(wxWindowID id) const;
  void Set(wxWindowID id, const wxString str);
  
  //metodi per il passaggio tra le finestre dei parametri di installazione!
  void SetDestinationPath(const wxString& strPath);
  const wxString& GetDestinationPath() const;
  void SetInstallationType(const unsigned int uType);
  const unsigned int GetInstallationType() const;
  void SetDongleType(const unsigned int uType);
  const unsigned int GetDongleType() const;

  void SetPrgLocPath(const wxString& strPrgLocPath);
  const wxString& GetPrgLocPath() const;
  void SetPrgNetPath(const wxString& strPrgNetPath);
  const wxString& GetPrgNetPath() const;
  void SetDataPath(const wxString& strDataPath);
  const wxString& GetDataPath() const;

  void SetInstDemoData(const bool bInstDemoData);
  const bool GetInstDemoData() const;

  void SetInstUseAuth(const bool bInstUseAuth);
  const bool GetInstUseAuth() const;
  void SetSrvAuth(const wxString& strSrvAuth);
  const wxString& GetSrvAuth() const;

  void SetInstUseDict(const bool bInstUseDict);
  const bool GetInstUseDict() const;
  void SetSrvDict(const wxString& strSrvDict);
  const wxString& GetSrvDict() const;

  void SetSrvAutostartMode(const int iSrvAutostartMode);
  const int GetSrvAutostartMode() const;

  void SetDesktopShortcut(const bool bDesktopShortcut);
  const bool GetDesktopShortcut() const;

  CampoWizard(wxWindow* pParent);
};

////////////////////////////////////////////////////////////////////////////////////////////
//Classe per la gestione dei files di configurazione tipo campo.ini
class CampoIniFile : public wxFileConfig
{
protected:
public:
  wxString Get(const wxString strVariable) const;
  bool GetBool(const wxString strVariable) const;
  bool Set(const wxString strVariable, const wxString strValue);//, const wxString strParagraph) const;
  bool Set(const wxString strVariable, const int uValue);

  CampoIniFile(const wxString strIniPath, wxString strValue);
};

CampoIniFile::CampoIniFile(const wxString strIniPath, const wxString strParagraph)
            : wxFileConfig (wxEmptyString, wxEmptyString, strIniPath, wxEmptyString,
              wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_NO_ESCAPE_CHARACTERS)
{
  if (!strParagraph.IsEmpty())
    SetPath(strParagraph);
}

wxString CampoIniFile::Get(const wxString strVariable) const
{
  return Read(strVariable);
}

bool CampoIniFile::GetBool(const wxString strVariable) const
{
  wxString strBool = Get(strVariable);
  return strBool == "X" || strBool == "Y";
}

bool CampoIniFile::Set(const wxString strVariable, const wxString strValue)//, const wxString strParagraph) const
{
  return Write(strVariable, strValue);
}

bool CampoIniFile::Set(const wxString strVariable, const int uValue)//, const wxString strParagraph) const
{
  return Write(strVariable, uValue);
}

////////////////////////////////////////////////////////////////////////////////////////////
//Campo wizard page (pagina generica del programma, di cui saranno figlie le singole pagine)
class CampoWizardPage : public wxWizardPageSimple
{
  wxHtmlWindow* m_pText;

protected:
  CampoWizard& GetWizard() const {return *(CampoWizard*)GetParent();}
  void SetHTMLText(const wxString strTitle, const wxString strBody);
  void SetHTMLPage(const wxString strFile);
  wxString Bold(const wxString strStr) const;
  void AddLabel(wxSizer* pSizer, const wxChar* label);
  void AddLabel(wxGridBagSizer* pSizer, const wxChar* label, unsigned int row, unsigned int column);
  bool CheckDataDir(wxString& strDataPath) const;

public:
  virtual bool ForwardValidate() { return true; }
  wxString Get(wxWindowID id) const;
  bool GetBool(wxWindowID id) const;
  bool Set(wxWindowID id, const wxString& str);
  bool Set(wxWindowID id, const bool bul);
  int GetSelection(wxWindowID id) const;
  
  CampoWizardPage(wxWizard* parent);
};

wxString CampoWizardPage::Get(wxWindowID id) const
{
  wxWindow* pWnd = FindWindowById(id);
  return pWnd ? pWnd->GetLabel() : wxEmptyString;
}

bool CampoWizardPage::GetBool(wxWindowID id) const
{
  wxCheckBox* pWnd = (wxCheckBox*)FindWindowById(id);
  return pWnd != NULL && pWnd->IsChecked();
}

bool CampoWizardPage::Set(wxWindowID id, const wxString& str)
{
  wxWindow* pWnd = FindWindowById(id);
  if (pWnd)
    pWnd->SetLabel(str);
  return (pWnd != NULL);
}

bool CampoWizardPage::Set(wxWindowID id, const bool bul)
{
  wxCheckBox* pWnd = (wxCheckBox*)FindWindowById(id);
  if (pWnd)
    pWnd->SetValue(bul);
  return (pWnd != NULL);
}

int CampoWizardPage::GetSelection(wxWindowID id) const
{
  int n = -1;
  wxWindow* pWnd = FindWindowById(id);
  if (pWnd)
  {
    wxChoice* pList = (wxChoice*)pWnd;
    n = pList->GetSelection();
  }
  return n;
}

void CampoWizardPage::SetHTMLPage(const wxString strFile)
{
   m_pText->LoadPage(strFile);
}

//parte html della finestra standard
void CampoWizardPage::SetHTMLText(wxString strTitle, wxString strBody)
{
  wxString strAppName = wxT("<i>"); strAppName += Bold(APPNAME); strAppName += wxT("</i>");
  strTitle.Replace(wxT("APPNAME"), strAppName);
  strBody.Replace(wxT("APPNAME"), strAppName);

  wxString str;
  str += wxT("<html><body>");
  str += wxT("<p align=center><b>"); str += strTitle; str += wxT("</b></p>");
  str += wxT("<hr>");
  str += wxT("<div align=justify>"); str += strBody; str += wxT("</div>");
  str += wxT("</body></html>");

  m_pText->SetPage(str);
}

wxString CampoWizardPage::Bold(const wxString strStr) const
{
  wxString strBold;
  strBold << "<b>" << strStr << "</b>";
  return strBold;
}

//metodo per aggiungere i prompt agli oggetti contenuti nelle GridSize e similia
void CampoWizardPage::AddLabel(wxSizer* pSizer, const wxChar* label)
{
  pSizer->Add(new wxStaticText(this, wxID_ANY, label), 0, wxALL|wxALIGN_CENTER_VERTICAL);
}

void CampoWizardPage::AddLabel(wxGridBagSizer* pSizer, const wxChar* label, unsigned int row, unsigned int column)
{
  pSizer->Add(new wxStaticText(this, wxID_ANY, label), wxGBPosition(row, column));
}

//metodo per il controllo della validita' di un'area dati
bool CampoWizardPage::CheckDataDir(wxString& strDataPath) const
{
  wxDir dirDataPath(strDataPath);
  bool ok_data = false;
  //deve esistere non vuota, e contenere la sottodirectory "com" con i dati comuni
  if (dirDataPath.Exists(strDataPath) && dirDataPath.HasSubDirs("com"))
  {
    strDataPath << "/com";
    wxFileName fnFileToCheck(strDataPath, "tabcom");
    fnFileToCheck.SetExt("dbf");
    if (fnFileToCheck.FileExists())
      ok_data = true;
  }
  return ok_data;
}

//costruttore della finestra standard
CampoWizardPage::CampoWizardPage(wxWizard* parent)
            : wxWizardPageSimple(parent)
{ 
  wxBoxSizer* pSizer = new wxBoxSizer(wxVERTICAL);
  m_pText = new wxHtmlWindow(this, 100, wxDefaultPosition, wxSize(512, 312));
  pSizer->Add(m_pText, 0, wxALL, 0);
  pSizer->AddSpacer(5);
  SetSizer(pSizer);
}
/**********************************************************************************************************/
/*    1   Pagina di benvenuto                                                                             */
/**********************************************************************************************************/
class CampoWizardPage1 : public CampoWizardPage
{
public:
  CampoWizardPage1(wxWizard* parent);
};

CampoWizardPage1::CampoWizardPage1(wxWizard* parent) : CampoWizardPage(parent)
{
  //contenuto della prima schermata (pagina benvenuto)
  wxString strTitle = wxT("Benvenuti in <b>APPNAME</b>");
  wxString strBody = wxT("<p>Questo programma vi guiderà passo a passo nell'installazione / aggiornamento del software.</p>");
  strBody += wxT("<p><u><b>Leggere attentamente le istruzioni</u> che saranno visualizzate nelle finestre di questo programma di installazione!</b></p>");
  strBody += wxT("<p>Prima di proseguire con l'installazione / aggiornamento <u>assicurarsi di avere effettuato il login a Windows con un utente di tipo 'Amministratore' di sistema.</u></p>");
  strBody += wxT("<p>In caso si desideri aggiornare una postazione tipo server di APPNAME su cui sia attivo il gestore dei servizi di APPNAME, arrestare prima tale gestore dei servizi.</p>");
  SetHTMLText(strTitle, strBody);
}


/**********************************************************************************************************/
//    2   Pagina con Accetta / Rifiuta la licenza
//*********************************************************************************************************/
class CampoWizardPage2 : public CampoWizardPage
{
protected:
  virtual bool ForwardValidate();

public:
  CampoWizardPage2(wxWizard* parent);
};

bool CampoWizardPage2::ForwardValidate()
{
  if (GetSelection(201) == 1)
    return ErrorBox("Impossibile proseguire se non si accetta la licenza sul software!!");

  return true;
}

CampoWizardPage2::CampoWizardPage2(wxWizard* parent) : CampoWizardPage(parent)
{
  SetHTMLPage("licenza.htm");

  //radiobutton Accetta / Rifiuta
  wxArrayString asAccRef;
  asAccRef.Add("Accetta");
  asAccRef.Add("Rifiuta");
  wxRadioBox* radio_box = new wxRadioBox(this, 201, "Selezionare 'Accetta' per proseguire con l'installazione, 'Rifiuta' per terminare l'installazione", wxDefaultPosition, 
                                         wxDefaultSize, asAccRef, 0, wxRA_SPECIFY_COLS);

  radio_box->SetSelection(1);
  GetSizer()->Add(radio_box);
}


/**********************************************************************************************************/
/*    3   Pagina con la scelta di Aggiornamento / Tipo Installazione                                      */
/**********************************************************************************************************/
class CampoWizardPage3 : public CampoWizardPage
{
  wxRadioBox* m_pRadioBox;

protected:
  virtual bool ForwardValidate();

public:
  CampoWizardPage3(wxWizard* parent);
};

bool CampoWizardPage3::ForwardValidate()
{
  const int iLastRow = m_pRadioBox->GetRowCount() - 1;
  const int iSelectedRow = m_pRadioBox->GetSelection();
  wxString strPrgPath;
  wxString strStudy;
  wxString strSrvAuth;
  wxString strSrvDict;

  //analizza il campo.ini dell'installazione selezionata (si usa < perche' l'ultima row e' la nuova installazione!)
  if (iSelectedRow < iLastRow)
  {
    strPrgPath = m_pRadioBox->GetStringSelection();
    CampoIniFile CampoIni(strPrgPath + "/campo.ini", "Main");
    
    const bool bTestDatabase = CampoIni.GetBool("TestDatabase");

    //non si puo' aggiornare un client da cd!! va fatto dal programma
    const bool bTestPrograms = CampoIni.GetBool("TestPrograms");
    if (bTestPrograms)
    {
      CampoIniFile InstallIni(strPrgPath + "/install.ini", "Main");
      wxString strDiskPath = InstallIni.Get("DiskPath");
      wxString strMsg = "Per aggiornare questa stazione di lavoro e' necessario aggiornare prima il Server di ";
      strMsg << APPNAME << " in " << strDiskPath << " !\n";
      strMsg << "Questa stazione di lavoro si aggiornera' automaticamente alla prima esecuzione del programma " << APPNAME;
      return ErrorBox(strMsg);
    }

    strStudy = CampoIni.Get("Study");
    CampoIniFile CampoServerIni(strPrgPath + "/campo.ini", "Server");
    strSrvAuth = CampoServerIni.Get("Dongle");
    strSrvDict = CampoServerIni.Get("Dictionary");

    if (!CheckDataDir(strStudy))
      return ErrorBox("La cartella indicata come area dati NON e' valida!\nInterrompere l'installazione e selezionare un'area dati valida\ncon il programma APPNAME");
    GetWizard().SetDataPath(strStudy);

    if (!strSrvAuth.IsEmpty())
      GetWizard().SetSrvAuth(strSrvAuth);
    if (!strSrvDict.IsEmpty())
      GetWizard().SetSrvDict(strSrvDict);

    //setta alla pagina riassuntiva i valori della pagina attuale...
    GetWizard().SetDestinationPath(strPrgPath); //va alla pagina riassuntiva
    GetWizard().SetPrgLocPath(strPrgPath);      //questo serve solo per la creazione del link sul desktop!
    GetWizard().SetInstallationType(3);         //e' un aggiornamento!!
    GetWizard().SetDesktopShortcut(false);      //e' sempre un aggiornamento!
  }
  else  //resetta il path in caso si scelga nuova installazione dopo aver scelto aggiornamento
  {
    GetWizard().SetDestinationPath("");
    GetWizard().SetDesktopShortcut(true);
  }
 
  return true;
}

CampoWizardPage3::CampoWizardPage3(wxWizard* parent) : CampoWizardPage(parent)
{
  //deve cercare campo.stp
  CampoIniFile campo_stp("C:\\campo.stp", "");
  wxString group;
  long index;
  const wxString program = "Program";
  wxArrayString asGroups, asCampi;

  //cerca se esiste campo.stp;se lo trova cerca quelle che sono le installazioni valide;se ne trova..
  //..le aggiunge ad un array di stringhe (asCampi) da cui genera un radiobutton di scelte
  for (bool ok = campo_stp.GetFirstGroup(group, index); ok; ok = campo_stp.GetNextGroup(group, index))
  {
    asGroups.Add(group);
  }
  int prechecked = -1;
  for (unsigned int i = 0; i < asGroups.GetCount(); i++)
  {
    CampoIniFile campo_stp("C:\\campo.stp", asGroups[i]);
    wxString path = campo_stp.Get(program);
  
    //sono installazioni valide quelle che presentano la coppia di files campo.ini e campo.aut (senza..
    //..questi 2 soggetti il programma non parte)
    wxString campo_ini = path;
    campo_ini << "/campo.ini";
    wxString campo_aut = path;
    campo_aut << "/campo.aut";
    if (wxFileName::FileExists(campo_ini) && wxFileName::FileExists(campo_aut))
    {
      asCampi.Add(path);
      //cerca l'eventuale installazione server se ci sono piu' installazioni sulla stessa macchina
      if (prechecked < 0)
      {
        CampoIniFile ini(campo_ini, "Main");
        if (ini.GetBool("TestDatabase") && !ini.GetBool("TestPrograms"))
          prechecked = i;
      }
    }
  }

  wxString strTitle, strBody;
  //se non ci sono delle installazioni da aggiornare propone solo installazioni..
	if (asCampi.IsEmpty())
	{
    strTitle += wxT("Scelta Installazione");
    strBody += wxT("<p>E' possibile <b>INSTALLARE <i>APPNAME</i></b> in un nuovo direttorio.</p>");

    asCampi.Add("Nuova installazione"); //voce di nuova installazione!
    m_pRadioBox = new wxRadioBox(this, 301, "Installazione del software", wxDefaultPosition, 
                               wxDefaultSize, asCampi, 0, wxRA_SPECIFY_ROWS);
  }
  //..senno' propone di aggiornare
  else
  {
    strTitle += wxT("Scelta Aggiornamento / Installazione");
    strBody += wxT("<p>E' possibile <b>AGGIORNARE (scelta consigliata)</b> una installazione di <b><i>APPNAME</i></b> gia' presente oppure <b>INSTALLARE</b> in un nuovo direttorio.</p>");
    strBody += wxT("<p>Selezionare l'opzione desiderata nel riquadro sottostante. In caso di piu' di una installazione ");
    strBody += wxT("presente sara' preselezionata la eventuale installazione di tipo <b>Server</b>, in quanto <u>deve essere aggiornata per prima</u>! ");
    strBody += wxT("<p>In questo caso procedere all'aggiornamento di tale installazione Server e <u>aggiornare successivamente le postazioni client ");
    strBody += wxT("lanciando il programma <b><i>APPNAME</i></b> su di esse</u></p>");

    //radiobutton con le scelte aggiornamento
    asCampi.Add("Nuova installazione");
    m_pRadioBox = new wxRadioBox(this, 301, "Selezionare l'installazione da aggiornare (consigliato) o Nuova installazione", wxDefaultPosition, 
                               wxDefaultSize, asCampi, 0, wxRA_SPECIFY_ROWS);
    if (prechecked > 0)
      m_pRadioBox->SetSelection(prechecked);
  }

  strBody += wxT("<p>Prima di proseguire accertarsi che non vi sia alcuna sessione di <b><i>APPNAME</i></b> attiva! ");
  strBody += wxT("Terminare quindi le eventuali sessioni di <b><i>APPNAME</i></b> attive e proseguire.</p>");
  SetHTMLText(strTitle, strBody);
  GetSizer()->Add(m_pRadioBox);
}


/**********************************************************************************************************/
/*    4   Pagina con la gestione della chiave di protezione                                               */
/**********************************************************************************************************/
class CampoWizardPage4 : public CampoWizardPage
{

protected:
  DECLARE_EVENT_TABLE();
  void OnHLPick(wxCommandEvent& e);
  void OnEUPick(wxCommandEvent& e);
  void OnSRPick(wxCommandEvent& e);

  virtual bool ForwardValidate();
  virtual bool TransferDataToWindow();

  int DongleTest();
  wxString DecodeString(const wxString& data);
  int VersionYear();
  void BuildKey(char* key);

public:
  CampoWizardPage4(wxWizard* parent);
};

//metodi per la gestione dei bottoni per l'esecuzione dei programmi di installazione delle chiavi
BEGIN_EVENT_TABLE(CampoWizardPage4, CampoWizardPage)
  EVT_BUTTON(401, OnHLPick)
  EVT_BUTTON(402, OnEUPick)
  EVT_BUTTON(403, OnSRPick)
END_EVENT_TABLE()

void CampoWizardPage4::OnHLPick(wxCommandEvent& e)
{
  wxString path("../../chiavi/hardlock/hldrv32.exe");
  wxExecute(path, wxEXEC_SYNC);
}

void CampoWizardPage4::OnEUPick(wxCommandEvent& e)
{
  wxString path("../../chiavi/eutron/sdi.exe");
  wxExecute(path, wxEXEC_SYNC);
}

void CampoWizardPage4::OnSRPick(wxCommandEvent& e)
{
  static bool bSemaforo = false;
  if (!bSemaforo)
  {
    bSemaforo = true;
    wxBusyCursor hourglass;
    wxString strSrvName;
    int year = 0;
    unsigned short serno = ServerLogin(year, strSrvName);
    if (!strSrvName.IsEmpty())
      Set(404, strSrvName);
    bSemaforo = false;
  }
}

bool CampoWizardPage4::ForwardValidate()
{ 
  //per poter proseguire deve aver trovato una chiave o un server!

  GetWizard().SetSrvAuth(Get(404));
  int nDongleType = DongleTest();
  if (nDongleType == 0)
    return ErrorBox("Per proseguire e' NECESSARIO installare una chiave locale o collegarsi ad una chiave di rete!");

  return true;
}

bool CampoWizardPage4::TransferDataToWindow()
{
  FindWindowById(401)->Disable();
  FindWindowById(402)->Disable();
  FindWindowById(403)->Disable();
  FindWindowById(404)->Disable();

  //controlla preventivamente se la chiave c'e' ed eventualmente quale e' (hardlock,eutron,server di chiavi)
  const int nDongleType = DongleTest();
  GetWizard().SetDongleType(nDongleType);

  wxString strTitle = wxT("Controllo della chiave hardware di protezione");
  wxString strBody = wxT("<p>La versione commerciale del software richiede l'installazione e la presenza della chiave hardware di protezione</p>");
  switch (nDongleType)
  {
  case 1:
    strBody += wxT("<p>E' stata rilevata una chiave tipo <b>Hardlock</b>:</p>");
    strBody += wxT("<p align=center><img src=\"../servers/hardlock.gif\" /></p>");
    strBody += wxT("<p>Si puo' procedere con l'installazione /aggiornamento del software <b><i>APPNAME</i></b>. Premere il pulsante \"Avanti\".</p>");
    break;
  case 2:
    strBody += wxT("<p>E' stata rilevata una chiave tipo <b>Eutron</b>:</p>");
    strBody += wxT("<p align=center><img src=\"../servers/eutron.gif\" /></p>");
    strBody += wxT("<p>Si puo' procedere con l'installazione /aggiornamento del software <b><i>APPNAME</i></b>. Premere il pulsante \"Avanti\".</p>");
    break;
  case 3:
    strBody += wxT("<p>E' stato rilevata una chiave remota condivisa in rete con il servizio di gestione autorizzazioni:</p>");
    strBody += wxT("<p align=center><img src=\"../servers/autho.gif\" /></p>");
    strBody += wxT("<p>Si puo' procedere con l'installazione /aggiornamento del software <b><i>APPNAME</i></b>. Premere il pulsante \"Avanti\".</p>");
    Set(404, GetWizard().GetSrvAuth());
    break;

  default:
    strBody += wxT("<p><b>Non e' stata rilevata alcuna chiave hardware installata sul computer!</b></p>");
    strBody += wxT("<p>Per procedere all'installazione della chiave hardware, <b>collegarla al computer e premere il bottone corrispondente</b> alla tipologia della chiave stessa per installarne i driver.</p>");
    strBody += wxT("<p>Se si utilizza una chiave remota collegata ad un altro computer e condivisa in rete attraverso il servizio gestione di autorizzazioni ");
    strBody += wxT("premere il bottone <u>Cerca</u> per attivare la ricerca automatica della chiave remota. Qualora tale ricerca fallisse digitare il nome del computer ");
    strBody += wxT("(o l'indirizzo IP) cui e' collegata la chiave di rete e su cui e' <b>installato e attivo</b> il gestore di autorizzazioni. ");
    FindWindowById(401)->Enable();
    FindWindowById(402)->Enable();
    FindWindowById(403)->Enable();
    FindWindowById(404)->Enable();
    break;
  }
  
  SetHTMLText(strTitle, strBody);

  return true;
}

void CampoWizardPage4::BuildKey(char* key)
{
  for (int i = 0; i < 8; i++)  
    key[i] = 'A'+ rand()%26;
}

wxString CampoWizardPage4::DecodeString(const wxString& data)
{                             
  char key[8] = "";
  BuildKey(key);

  char tmp[256];
  int i;
  for (i = 0; data[i]; i++)
    tmp[i] = data[i] - (i < 8 ? key[i] : tmp[i - 8]);
  tmp[i] = '\0';
  return tmp;
}

int CampoWizardPage4::VersionYear()
{                                                             
  char ver[32];
  GetPrivateProfileString("ba", "Versione", "", ver, sizeof(ver), "../../program/install.ini");
  ver[4] = '\0';
  return atoi(ver);
}

int CampoWizardPage4::DongleTest()
{ 
	int dongle_type = 0;
  int yearKey = 0;
  
  unsigned int serno = 0xFFFF;

  wxString strSrvName = GetWizard().GetSrvAuth(); //nome del server di autorizzazioni (se c'e')
  if (!strSrvName.IsEmpty())
  {
    serno = ServerLogin(yearKey, strSrvName);
	  if (serno != 0xFFFF)
   	  dongle_type = 3;		//chiave remota
  }

  if (serno == 0xFFFF)
  {
    serno = HardlockLogin(yearKey);
    if (serno == 0xFFFF)
	  {
      serno = EutronLogin(yearKey);   
		  if (serno != 0xFFFF)
			  dongle_type = 2;		//chiave eutron
	  }
	  else
		  dongle_type = 1;	//chiave hardlock
  }    
  
  if (serno == 0)	// Chiave di sviluppo
    return dongle_type;          
	if (serno == 0xFFFF)	// Chiave inesistente o invisibile = Prima installazione o demo
		return dongle_type;
  
  const int verYear = VersionYear();
  if (yearKey < verYear) // Chiave già programmata con assistenza pagata
	{  
		bool ok = false;
		wxFileInputStream file("../dninst.zip");
		if (file.IsOk())
		{
      wxTextInputStream keys(file);
			wxString line = keys.ReadLine();
			srand(883);
			const int ass_year = atoi(DecodeString(line));
			if (ass_year > yearKey) // Non devo abbassare l'anno di assistenza!
			{
				srand(ass_year);
				while (!file.Eof())
				{
					line = keys.ReadLine();
					line = DecodeString(line);
					unsigned int sn = (unsigned int)atol(line);
					if (sn == serno || line[0] == '*')
					{
						ok = true;
						break;
					}
				}
				if (ok)
				{
					const int n = ass_year%10;
					const int y = (ass_year / 1000) * 1000 + (ass_year%1000) /10;
					line.Printf("Il contratto di manutenzione %d/%d verrà attivato automaticamente\ndurante l'installazione del software", y, n);
					WarningBox(line);
				}
				else  
				{
					line.Printf("È necessario contattare l'assistenza tecnica\n"
												 "per l'abilitazione del contratto di manutenzione %d", verYear);
					WarningBox(line);
				}
			}
		} 
		else
		{
			ErrorBox("Impossibile verificare il contratto di manutenzione");
		}
	}
  return dongle_type;
}

CampoWizardPage4::CampoWizardPage4(wxWizard* parent) : CampoWizardPage(parent)
{
  //procedura per la costruzione dei bottoni e delle immagini per l'installazione dei driver di chiave
  //"griglia" contenitrice degli oggetti

  //griglia per sistemare i campi
  wxGridBagSizer* gbsButtSizer = new wxGridBagSizer(VGAP, HGAP);
  GetSizer()->Add(gbsButtSizer);

  //prima riga della griglia
  //Hardlock label
  AddLabel(gbsButtSizer, "Installa chiave locale di tipo Hardlock", 0, 0);
  //Hardlock image
  wxBitmap bmp_HL("../servers/hardlock.gif", wxBITMAP_TYPE_GIF);
  wxStaticBitmap* s_bmp_HL = new wxStaticBitmap(this, wxID_ANY, bmp_HL);
  gbsButtSizer->Add(s_bmp_HL, wxGBPosition(0, 1));
  //bottone Hardlock
  wxButton* bHlButton = new wxButton(this, 401, wxT("Hardlock"), wxDefaultPosition, wxSize(64, -1));
  gbsButtSizer->Add(bHlButton, wxGBPosition(0, 2), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);  

  //seconda riga della griglia
  //Eutron label
  AddLabel(gbsButtSizer, "Installa chiave locale di tipo Eutron", 1, 0);
  //Eutron image
  wxBitmap bmp_EU("../servers/eutron.gif", wxBITMAP_TYPE_GIF);
  wxStaticBitmap* s_bmp_EU = new wxStaticBitmap(this, wxID_ANY, bmp_EU);
  gbsButtSizer->Add(s_bmp_EU, wxGBPosition(1, 1));
  //bottone Eutron
  wxButton* bEuButton = new wxButton(this, 402, wxT("Eutron"), wxDefaultPosition, wxSize(64, -1));
  gbsButtSizer->Add(bEuButton, wxGBPosition(1, 2), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);  

  //terza riga della griglia
  //Server label
  AddLabel(gbsButtSizer, "Nome o indirizzo IP del server di autorizzazioni", 2, 0);
  //nome Server
  wxTextCtrl* tcSrvName = new wxTextCtrl(this, 404, "", wxDefaultPosition, wxSize(128,-1));
  gbsButtSizer->Add(tcSrvName, wxGBPosition(2, 1)); 
  //bottone Eutron
  wxButton* bSrvButton = new wxButton(this, 403, wxT("Cerca"), wxDefaultPosition, wxSize(64, -1));
  gbsButtSizer->Add(bSrvButton, wxGBPosition(2, 2), wxDefaultSpan, wxALIGN_CENTER_VERTICAL); 
 
}

/**********************************************************************************************************/
//    5 Scelta tipo installazione
/**********************************************************************************************************/
class CampoWizardPage5 : public CampoWizardPage
{
  wxRadioBox* m_pRadioBox;

protected:
  virtual bool ForwardValidate();

public:
  CampoWizardPage5(wxWizard* parent);
};

bool CampoWizardPage5::ForwardValidate()
{
  const unsigned int type = m_pRadioBox->GetSelection();
  GetWizard().SetInstallationType(type);
  return true;
}

CampoWizardPage5::CampoWizardPage5(wxWizard* parent) : CampoWizardPage(parent)
{
  //Istruzioni per l'uso!
  wxString strTitle = wxT("Scelta del tipo di installazione");
  wxString strBody = wxT("<p><b>Standard (scelta consigliata)</b>. Installazione su postazione singola, con programmi e dati sul disco locale del computer</p>");
  strBody += wxT("<p><b>Installazioni di rete</b> (per utenti esperti)</p>");
  strBody += wxT("<p><b>Server</b>: Computer in rete sul quale sono presenti una copia, utilizzata o meno, dei programmi (server programmi) e l’area dati (server dati). ");
  strBody += wxT("In una installazione in rete di <b><i>APPNAME</i></b> e' necessario sia presente un unica postazione di tipo server, ");
  strBody += wxT("e deve essere installata per prima!</p>");
  strBody += wxT("<p><b>Client</b>: Computer in rete sul quale e' presente una copia dei programmi ma non l'area dati. ");
  strBody += wxT("I client possono essere installati solo dopo l'installazione del server!</p>");
  SetHTMLText(strTitle, strBody);

  //radiobutton con i tipi di installazione
  wxArrayString asInstType;
  asInstType.Add("Standard");
  asInstType.Add("Server");
  asInstType.Add("Client");

  m_pRadioBox = new wxRadioBox(this, 501, "Selezionare il tipo di installazione", wxDefaultPosition, 
                             wxDefaultSize, asInstType, 0, wxRA_SPECIFY_ROWS);
  //setta il default a Standard
  m_pRadioBox->SetSelection(0);
  GetSizer()->Add(m_pRadioBox);

}


/**********************************************************************************************************/
//    6   Installazione standard
/**********************************************************************************************************/
class CampoWizardPage6 : public CampoWizardPage
{
protected:
  DECLARE_EVENT_TABLE();
  void OnDirPick(wxCommandEvent& e);
  virtual bool ForwardValidate();

public:
  CampoWizardPage6(wxWizard* parent);
};

BEGIN_EVENT_TABLE(CampoWizardPage6, CampoWizardPage)
  EVT_BUTTON(602, OnDirPick)
  EVT_BUTTON(604, OnDirPick)
END_EVENT_TABLE()

void CampoWizardPage6::OnDirPick(wxCommandEvent& e)
{
  const wxWindowID wiTargetField = e.GetId() - 1;
  wxString strPath = Get(wiTargetField);
  wxDirDialog dlg(this, wxDirSelectorPromptStr, strPath, 
                  wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
  if (dlg.ShowModal() == wxID_OK)
  {
    strPath = dlg.GetPath();
    Set(wiTargetField, strPath);
  }
}

//metodo per il controllo dell'area dati;se la directory indicata non e' vuota non puoi usarla ne' crearla
bool CampoWizardPage6::ForwardValidate()
{
  //controllo esistenza directory vuota per i programmi in locale
  const wxString strPrgLocPath = Get(601);
  wxDir dirPrgLocPath(strPrgLocPath);
  if (dirPrgLocPath.Exists(Get(601)) && (dirPrgLocPath.HasFiles() || dirPrgLocPath.HasSubDirs()))
    return ErrorBox("La cartella selezionata per l'installazione dei programmi NON e' valida! Selezionarne un'altra!");

  const wxString strDataPath = Get(603);
  wxDir dirDataPath(strDataPath);
  if (dirDataPath.Exists(strDataPath) && (dirDataPath.HasFiles() || dirDataPath.HasSubDirs()))
    return ErrorBox("La cartella indicata per la creazione dell'area dati non e' vuota! Selezionarne un'altra!");

  //setta alla pagina riassuntiva i valori della pagina attuale...
  GetWizard().SetPrgLocPath(strPrgLocPath);
  GetWizard().SetDataPath(strDataPath);

  //...e pure quegli stupidi datidemo che nessuno ha mai installato!!
  const bool bInstDemoData = GetBool(605);
  GetWizard().SetInstDemoData(bInstDemoData);

  return true;
}

CampoWizardPage6::CampoWizardPage6(wxWizard* parent) : CampoWizardPage(parent)
{
  wxString strTitle = wxT("Installazione di tipo Standard");
  wxString strBody = wxT("<p>Digitare nel campo <b>'Cartella programma'</b> il percorso completo della cartella dove si desidera installare il programma. ");
  strBody += wxT("Il percorso di default (consigliato) e' <i>C:\\APPNAME</i> </p>");
  strBody += wxT("<p>Digitare nel campo <b>'Cartella Dati'</b> il percorso completo della cartella dove si desidera installare l'area dati. ");
  strBody += wxT("Il percorso di default (consigliato) e' <i>C:\\APPNAME\\dati</i> </p>");
  strBody += wxT("<p><b>Dati dimostrativi:</b> area dati precompilata per installazioni di tipo dimostrativo del funzionamento del software. ");
  strBody += wxT("<b>NON</b> vanno caricati nel caso di una normale installazione!</p>");
  SetHTMLText(strTitle, strBody);

  //griglia per sistemare i campi
  wxGridBagSizer* gbsSizer = new wxGridBagSizer(VGAP, HGAP);
  GetSizer()->Add(gbsSizer);
  
  //prima riga della griglia
  //prompt
  AddLabel(gbsSizer, "Cartella programmi", 0, 0);
  //campo testo
  wxString strPath;
  strPath = "C:\\";
  strPath += APPNAME;
  wxTextCtrl* tcPrgPath = new wxTextCtrl(this, 601, strPath, wxDefaultPosition, wxSize(320,-1));
  gbsSizer->Add(tcPrgPath, wxGBPosition(0, 1));
  //bottone 'sfoglia'
  wxButton* bPrgButton = new wxButton(this, 602, wxT("Sfoglia"), wxDefaultPosition, wxSize(48, -1));
  gbsSizer->Add(bPrgButton, wxGBPosition(0, 2));

  //seconda riga della griglia
  //prompt
  AddLabel(gbsSizer, "Cartella dati", 1, 0);
  //campo testo
  strPath += "/dati";
  wxTextCtrl* tcDataPath = new wxTextCtrl(this, 603, strPath, wxDefaultPosition, wxSize(320,-1));
  gbsSizer->Add(tcDataPath, wxGBPosition(1, 1));
  //bottone 'sfoglia'
  wxButton* bDataButton = new wxButton(this, 604, wxT("Sfoglia"), wxDefaultPosition, wxSize(48, -1));
  gbsSizer->Add(bDataButton, wxGBPosition(1, 2));

  //terza riga della griglia
  wxCheckBox* chDataDemo = new wxCheckBox(this, 605, wxT("Carica i dati dimostrativi"));
  chDataDemo->SetValue(false);
  gbsSizer->Add(chDataDemo, wxGBPosition(2, 1));
}

/**********************************************************************************************************/
//    7   Installazione server
/**********************************************************************************************************/
class CampoWizardPage7 : public CampoWizardPage
{
  wxRadioBox* m_pRadioBox;

protected:
  DECLARE_EVENT_TABLE();
  virtual bool ForwardValidate();
  void OnDirPick(wxCommandEvent& e);
  void OnSrvClick(wxCommandEvent& e);

public:
  CampoWizardPage7(wxWizard* parent);
};

BEGIN_EVENT_TABLE(CampoWizardPage7, CampoWizardPage)
  EVT_BUTTON(702, OnDirPick)
  EVT_BUTTON(704, OnDirPick)
  EVT_CHECKBOX(705, OnSrvClick)
  EVT_CHECKBOX(707, OnSrvClick)
END_EVENT_TABLE()

void CampoWizardPage7::OnDirPick(wxCommandEvent& e)
{
  const wxWindowID wiTargetField = e.GetId() - 1;
  wxString strPath = Get(wiTargetField);
  wxDirDialog dlg(this, wxDirSelectorPromptStr, strPath, 
                  wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
  if (dlg.ShowModal() == wxID_OK)
  {
    strPath = dlg.GetPath();
    Set(wiTargetField, strPath);
  }
}

void CampoWizardPage7::OnSrvClick(wxCommandEvent& e)
{
  //nome del server
  wxWindow* pWnd = FindWindowById(e.GetId() + 1);
  if (pWnd)
    pWnd->Enable(e.IsChecked());
  //tipo installazione server
  pWnd = FindWindowById(709);
  if (pWnd)
    pWnd->Enable(GetBool(705) || GetBool(707));
}

bool CampoWizardPage7::ForwardValidate()
{
  //controllo esistenza directory vuota per i programmi in locale
  const wxString strPrgLocPath = Get(701);
  wxDir dirPrgLocPath(strPrgLocPath);
  if (dirPrgLocPath.Exists(strPrgLocPath) && (dirPrgLocPath.HasFiles() || dirPrgLocPath.HasSubDirs()))
    return ErrorBox("La cartella selezionata per l'installazione dei programmi NON e' valida! Selezionarne un'altra!");

  //controllo della directory dell'area dati: deve essere nuova o vuota affinche' possa essere utilizzata!!
  const wxString strDataPath = Get(703);
  wxDir dirDataPath(strDataPath);
  if (dirDataPath.Exists(strDataPath) && (dirDataPath.HasFiles() || dirDataPath.HasSubDirs()))
    return ErrorBox("La cartella indicata per la creazione dell'area dati non e' vuota! Selezionarne un'altra!");

  //setta alla pagina riassuntiva i valori della pagina attuale...
  GetWizard().SetPrgLocPath(strPrgLocPath);
  GetWizard().SetDataPath(strDataPath);
  //...compresi eventuali stupidi servers!
  const bool bInstAuth = GetBool(705);
  if (bInstAuth)
  {
    GetWizard().SetInstUseAuth(bInstAuth);
    const wxString strSrvAuth = Get(706);
    if (strSrvAuth.IsEmpty())
      return ErrorBox("Specificare il server gestore delle autorizzazioni!");
    GetWizard().SetSrvAuth(strSrvAuth);
  }
  else
    GetWizard().SetSrvAuth("");

  const bool bInstDict = GetBool(707);
  if (bInstDict)
  {
    GetWizard().SetInstUseDict(bInstDict);
    const wxString strSrvDict = Get(708);
    if (strSrvDict.IsEmpty())
      return ErrorBox("Specificare il server gestore dei dizionari!");
    GetWizard().SetSrvDict(strSrvDict);
  }
  else
    GetWizard().SetSrvDict("");

  //..e loro modalita' di esecuzione
  if (bInstAuth || bInstDict)
  {
    GetWizard().SetSrvAutostartMode(m_pRadioBox->GetSelection());
  }
  else
    GetWizard().SetSrvAutostartMode(-1);

  return true;
}

CampoWizardPage7::CampoWizardPage7(wxWizard* parent) : CampoWizardPage(parent)
{
  wxString strTitle = wxT("Installazione di tipo Server");
  wxString strBody = wxT("<p>Digitare nel campo <b>'Cartella programma'</b> il percorso completo della cartella dove si desidera installare il programma. ");
  strBody += wxT("Il percorso consigliato e' <i>C:\\APPNAME</i> </p>");
  strBody += wxT("<p>Digitare nel campo <b>'Cartella dati'</b> il percorso completo della cartella dove si desidera installare l'area dati. ");
  strBody += wxT("Il percorso consigliato e' <i>C:\\APPNAME\\dati</i> </p>");
  strBody += wxT("<p>Le cartelle del programma e dei dati <b><u>dovranno essere condivise in modalita' lettura/scrittura</u></b> agli utenti di sistema e di rete che utilizzeranno il software <b><i>APPNAME</i></b>. ");
  strBody += wxT("In mancanza di tale condivisione nessun client potra' accedere al server!</p>");
  strBody += wxT("<p><b>Gestore autorizzazioni:</b> e' il software che permette di gestire una chiave di protezione hardware multiutenza condivisa in rete. ");
  strBody += wxT("Installando tale software e' necessario specificare il computer su cui e' montata la chiave di protezione multiutenza.");
  strBody += wxT("Viene di default proposto il computer su cui si sta eseguendo l'installazione di APPNAME (localhost).</p>");
  strBody += wxT("<p><b>Gestore dizionari:</b> e' il software che permette di utilizzare APPNAME in lingue diverse dall'italiano. ");
  strBody += wxT("Per l'installazione di questo software viene di default proposto il computer su cui si sta eseguendo l'installazione di APPNAME (localhost).</p>");
  strBody += wxT("<p><b>Modalita' di esecuzione programmi di gestione</b><br>");
  strBody += wxT("<u>Come servizi:</u> i programmi di gestione vengono eseguiti come servizi di Windows; questa e' la modalita' consigliata ed e' obbligatoria in caso di installazione con Windows 2003<br>");
  strBody += wxT("<u>Nel menu esecuzione automatica:</u> i programmi di gestione vengono eseguiti automaticamente al primo accesso di un utente al server di APPNAME; usare questa modalita' solo nell'impossibilita' di utilizzare la precedente</p>");

  SetHTMLText(strTitle, strBody);

  //griglia per sistemare i campi
  wxGridBagSizer* gbsSizer = new wxGridBagSizer(VGAP, HGAP);
  GetSizer()->Add(gbsSizer);

  //prima riga della griglia
  //prompt
  AddLabel(gbsSizer, "Cartella programmi", 0, 0);
  //campo testo
  wxString strPath;
  strPath = "C:\\";
  strPath += APPNAME;
  wxTextCtrl* tcPrgPath = new wxTextCtrl(this, 701, strPath, wxDefaultPosition, wxSize(320,-1));
  gbsSizer->Add(tcPrgPath, wxGBPosition(0, 1));
  //bottone 'sfoglia'
  wxButton* bPrgButton = new wxButton(this, 702, wxT("Sfoglia"), wxDefaultPosition, wxSize(48, -1));
  gbsSizer->Add(bPrgButton, wxGBPosition(0, 2));

  //seconda riga della griglia
  //prompt
  AddLabel(gbsSizer, "Cartella dati", 1, 0);
  //campo testo
  strPath += "/dati";
  wxTextCtrl* tcDataPath = new wxTextCtrl(this, 703, strPath, wxDefaultPosition, wxSize(320,-1));
  gbsSizer->Add(tcDataPath, wxGBPosition(1, 1));
  //bottone 'sfoglia'
  wxButton* bDataButton = new wxButton(this, 704, wxT("Sfoglia"), wxDefaultPosition, wxSize(48, -1));
  gbsSizer->Add(bDataButton, wxGBPosition(1, 2));

  //terza riga della griglia
  //check installa authoriz
  wxCheckBox* chAuthoriz = new wxCheckBox(this, 705, wxT("Installa il gestore delle autorizzazioni"));
  chAuthoriz->SetValue(false);
  gbsSizer->Add(chAuthoriz, wxGBPosition(2, 1));
  //server authoriz
  wxTextCtrl* tcAuthoriz = new wxTextCtrl(this, 706, "localhost", wxDefaultPosition, wxSize(96,-1));
  tcAuthoriz->Disable();
  gbsSizer->Add(tcAuthoriz, wxGBPosition(2, 2));

  //quarta riga della griglia
  //check installa diction
  wxCheckBox* chDictionary = new wxCheckBox(this, 707, wxT("Installa il gestore dei dizionari"));
  chDictionary->SetValue(false);
  gbsSizer->Add(chDictionary, wxGBPosition(3, 1));
  //server diction
  wxTextCtrl* tcDiction = new wxTextCtrl(this, 708, "localhost", wxDefaultPosition, wxSize(96,-1));
  tcDiction->Disable();
  gbsSizer->Add(tcDiction, wxGBPosition(3, 2));

  //quinta riga della griglia
  //radiobutton con i tipi di installazione
  wxArrayString asInstType;
  asInstType.Add("Come servizi (consigliato)");
  asInstType.Add("Nel menu esecuzione automatica");

  m_pRadioBox = new wxRadioBox(this, 709, "Modalita' di esecuzione gestori", wxDefaultPosition, 
                             wxDefaultSize, asInstType, 0, wxRA_SPECIFY_COLS);
  //setta il default a "come servizio"
  m_pRadioBox->SetSelection(0);
  m_pRadioBox->Disable();
  gbsSizer->Add(m_pRadioBox, wxGBPosition(4, 1));

}


/**********************************************************************************************************/
//    8   Installazione client
/**********************************************************************************************************/
class CampoWizardPage8 : public CampoWizardPage
{
protected:
  DECLARE_EVENT_TABLE();
  virtual bool ForwardValidate();
  virtual bool TransferDataToWindow();
  void OnDirPick(wxCommandEvent& e);
  void OnSrvClick(wxCommandEvent& e);

public:
  CampoWizardPage8(wxWizard* parent);
};

BEGIN_EVENT_TABLE(CampoWizardPage8, CampoWizardPage)
  EVT_BUTTON(802, OnDirPick)
  EVT_BUTTON(804, OnDirPick)
  EVT_BUTTON(806, OnDirPick)
  EVT_CHECKBOX(807, OnSrvClick)
END_EVENT_TABLE()

void CampoWizardPage8::OnDirPick(wxCommandEvent& e)
{
  const wxWindowID wiTargetField = e.GetId() - 1;
  wxString strPath = Get(wiTargetField);
  wxDirDialog dlg(this, wxDirSelectorPromptStr, strPath, 
                  wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
  if (dlg.ShowModal() == wxID_OK)
  {
    strPath = dlg.GetPath();
    Set(wiTargetField, strPath);
  }
}

void CampoWizardPage8::OnSrvClick(wxCommandEvent& e)
{
  wxWindow* pWnd = FindWindowById(e.GetId() + 1);
  if (pWnd)
    pWnd->Enable(e.IsChecked());
}

bool CampoWizardPage8::TransferDataToWindow()
{
  return true;
}

bool CampoWizardPage8::ForwardValidate()
{
  //controllo esistenza directory vuota per i programmi in locale
  const wxString strPrgLocPath = Get(801);
  wxDir dirPrgLocPath(strPrgLocPath);
  if (dirPrgLocPath.Exists(strPrgLocPath) && (dirPrgLocPath.HasFiles() || dirPrgLocPath.HasSubDirs()))
    return ErrorBox("La cartella selezionata per l'installazione dei programmi NON e' valida! Selezionarne un'altra!");

  //controllo esistenza directory e programmi sul server
  const wxString strPrgNetPath = Get(803);
  wxDir dirPrgPath(strPrgNetPath);
  bool ok_prg = false;
  //deve esistere non vuota, e contenere almeno campo.ini,install.ini,campo.aut,ba0.exe
  if (dirPrgPath.Exists(strPrgNetPath) && dirPrgPath.HasFiles() && dirPrgPath.HasSubDirs())
  {
    wxFileName fnFileToCheck(strPrgNetPath, "campo");
    fnFileToCheck.SetExt("ini");
    if (fnFileToCheck.FileExists())
    {
      fnFileToCheck.SetName("install");
      fnFileToCheck.SetExt("ini");
      if (fnFileToCheck.FileExists())
      {
        fnFileToCheck.SetName("campo");
        fnFileToCheck.SetExt("aut");
        if (fnFileToCheck.FileExists())
        {
          fnFileToCheck.SetName("ba0");
          fnFileToCheck.SetExt("exe");
          if (fnFileToCheck.FileExists())
          {
            ok_prg = true;
          }
        }
      }
    }
  }
  if (!ok_prg)
    return ErrorBox("La cartella selezionata come origine dei programmi NON e' valida!");

  //controllo esistenza dati sul server
  wxString strDataPath = Get(805);
  if (!CheckDataDir(strDataPath))
    return ErrorBox("La cartella selezionata come area dati NON e' valida!");

  //setta alla pagina riassuntiva i valori della pagina attuale
  GetWizard().SetPrgLocPath(strPrgLocPath);
  GetWizard().SetPrgNetPath(strPrgNetPath);
  GetWizard().SetDataPath(strDataPath);

  //...compresi eventuali stupidi servers!
  const wxString strSrvDict = Get(807);
  //se c'e' un nome di dictionary server e non lo trova si incazza
  if (!strSrvDict.IsEmpty() && !DictionaryLogin(strSrvDict))
  {
    wxString strMsg;
    strMsg << "Impossibile contattare il server " << strSrvDict << " per la gestione dei dizionari!";
    return ErrorBox(strMsg);
  }
  else
    GetWizard().SetSrvDict(strSrvDict);

  return true;
}

CampoWizardPage8::CampoWizardPage8(wxWizard* parent) : CampoWizardPage(parent)
{
  wxString strTitle = wxT("Installazione di tipo Client");
  wxString strBody = wxT("<p>Digitare nel campo <b>'Cartella locale programma'</b> il percorso completo della cartella dove si desidera installare il programma. ");
  strBody += wxT("Il percorso consigliato e' <i>C:\\APPNAME</i> </p>");
  strBody += wxT("<p>Digitare nel campo <b>'Cartella remota origine programmi'</b> il percorso completo della cartella di rete dove sono i files origine del programma. ");
  strBody += wxT("E' la cartella di programmi condivisa dal server precedentemente installato.</p>");
  strBody += wxT("<p>Digitare nel campo <b>'Cartella remota dati da utilizzare'</b> il percorso completo della cartella di rete dove sono i dati. ");
  strBody += wxT("E' la cartella dei dati condivisa dal server precedentemente installato.</p>");
  strBody += wxT("<p><b>Gestore dizionari:</b> e' il computer gestore dei dizionari di APPNAME in lingue diverse dall'italiano. Generalmente e' il computer agente da server di APPNAME in rete. ");
  strBody += wxT("Premere il bottone <u>Cerca</u> per attivare la ricerca automatica di tale computer. Qualora tale ricerca fallisse digitare il nome del computer gestore dei dizionari</p>");

  SetHTMLText(strTitle, strBody);

  //griglia per sistemare i campi
  wxGridBagSizer* gbsSizer = new wxGridBagSizer(VGAP, HGAP);
  GetSizer()->Add(gbsSizer);

  //prima riga della griglia
  //prompt
  AddLabel(gbsSizer, "Cartella locale programma", 0, 0);
  //campo testo
  wxString strPath;
  strPath = "C:\\";
  strPath += APPNAME;
  wxTextCtrl* tcDestPrgPath = new wxTextCtrl(this, 801, strPath, wxDefaultPosition, wxSize(256,-1));
  gbsSizer->Add(tcDestPrgPath, wxGBPosition(0, 1));
  //bottone 'sfoglia'
  wxButton* bDestPrgButton = new wxButton(this, 802, wxT("Sfoglia"), wxDefaultPosition, wxSize(48, -1));
  gbsSizer->Add(bDestPrgButton, wxGBPosition(0, 2));

  //seconda riga della griglia
  //prompt
  AddLabel(gbsSizer, "Cartella remota origine programmi", 1, 0);
  //campo testo
  strPath = "Z:\\";
  strPath += APPNAME;
  wxTextCtrl* tcSrcPrgPath = new wxTextCtrl(this, 803, strPath, wxDefaultPosition, wxSize(256,-1));
  gbsSizer->Add(tcSrcPrgPath, wxGBPosition(1, 1));
  //bottone 'sfoglia'
  wxButton* bSrcPrgButton = new wxButton(this, 804, wxT("Sfoglia"), wxDefaultPosition, wxSize(48, -1));
  gbsSizer->Add(bSrcPrgButton, wxGBPosition(1, 2));

  //terza riga della griglia
  //prompt
  AddLabel(gbsSizer, "Cartella remota dati da utilizzare", 2, 0);
  //campo testo
  strPath += "/dati";
  wxTextCtrl* tcDataPath = new wxTextCtrl(this, 805, strPath, wxDefaultPosition, wxSize(256,-1));
  gbsSizer->Add(tcDataPath, wxGBPosition(2, 1));
  //bottone 'sfoglia'
  wxButton* bDataButton = new wxButton(this, 806, wxT("Sfoglia"), wxDefaultPosition, wxSize(48, -1));
  gbsSizer->Add(bDataButton, wxGBPosition(2, 2));

  //terza riga della griglia
  //Server dizionari label
  AddLabel(gbsSizer, "Nome o indirizzo IP del server dei dizionari", 3, 0);
  //nome Server dizionari
  wxTextCtrl* tcSrvName = new wxTextCtrl(this, 807, "", wxDefaultPosition, wxSize(256,-1));
  gbsSizer->Add(tcSrvName, wxGBPosition(3, 1)); 
  //bottone Cerca
  wxButton* bSrvButton = new wxButton(this, 808, wxT("Cerca"), wxDefaultPosition, wxSize(48, -1));
  gbsSizer->Add(bSrvButton, wxGBPosition(3, 2), wxDefaultSpan, wxALIGN_CENTER_VERTICAL);

}


/**********************************************************************************************************/
//    9   pagina con la creazione icona sul desktop e lanciatore del lurch
/**********************************************************************************************************/
class CampoWizardPage9 : public CampoWizardPage
{
protected:
  virtual bool TransferDataToWindow();
  virtual bool ForwardValidate();

public:
  CampoWizardPage9(wxWizard* parent);
};

bool CampoWizardPage9::TransferDataToWindow()
{
  return Set(901, GetWizard().GetDesktopShortcut());
}

bool CampoWizardPage9::ForwardValidate()
{
  const bool bDesktopShortcut = GetBool(901);
  GetWizard().SetDesktopShortcut(bDesktopShortcut);
  return true;
}

CampoWizardPage9::CampoWizardPage9(wxWizard* parent) : CampoWizardPage(parent)
{
  wxString strTitle = wxT("Collegamenti");
  wxString strBody;
  strBody += wxT("<p>E' possibile creare l'icona di APPNAME sul desktop </p>");

  SetHTMLText(strTitle, strBody);

  wxCheckBox* pIcon = new wxCheckBox(this, 901, wxT("Creare l'icona sul desktop"));
  GetSizer()->Add(pIcon, 0, wxALL, 0);

  GetSizer()->AddSpacer(5);

  //wxCheckBox* pLink = new wxCheckBox(this, 1002, wxT("Associare i file .caz al programma"));
  //pLink->SetValue(true);
  //GetSizer()->Add(pLink, 0, wxALL, 0);
}


/**********************************************************************************************************/
//    10   pagina con la selezione di destinazione
/**********************************************************************************************************/
class CampoWizardPage10 : public CampoWizardPage
{
  unsigned int _uInstallType;
  wxString _strInstallType;
  wxString _strPrgLocPath;
  wxString _strPrgNetPath;
  wxString _strDataPath;
  wxString _strSrvAuth;
  wxString _strSrvDict;
  unsigned int _iSrvAutostartMode;
  bool _bInstDemoData;
  bool _bDesktopShortcut;

protected:
  virtual bool TransferDataToWindow();

public:
  CampoWizardPage10(wxWizard* parent);
};

bool CampoWizardPage10::TransferDataToWindow()
{
  CampoWizard& cw = GetWizard();

  _uInstallType = cw.GetInstallationType();
  switch (_uInstallType)
  {
  case 1: //server
    _strInstallType = "Server";
    _strPrgLocPath = cw.GetPrgLocPath();
    _strDataPath = cw.GetDataPath();
    _strSrvAuth = cw.GetSrvAuth();
    _strSrvDict = cw.GetSrvDict();
    if (!_strSrvAuth.IsEmpty() || !_strSrvDict.IsEmpty())
      _iSrvAutostartMode = cw.GetSrvAutostartMode();
    break;
  case 2: //client
    _strInstallType = "Client";
    _strPrgLocPath = cw.GetPrgLocPath();
    _strPrgNetPath = cw.GetPrgNetPath();
    _strDataPath = cw.GetDataPath();
    _strSrvAuth = cw.GetSrvAuth();
    _strSrvDict = cw.GetSrvDict();
    break;
  case 3: //aggiornamento
    _strInstallType = "";
    _strPrgLocPath = cw.GetDestinationPath();
    _strDataPath = cw.GetDataPath();
    _strSrvAuth = cw.GetSrvAuth();
    _strSrvDict = cw.GetSrvDict();
    break;
  default:  //standard
    _strInstallType = "Standard";
    _strPrgLocPath = cw.GetPrgLocPath();
    _strDataPath = cw.GetDataPath();
    _bInstDemoData = cw.GetInstDemoData();
    break;
  }
  //questo vale per tutti
  _bDesktopShortcut = cw.GetDesktopShortcut();

  //se installazione o aggiornamento cambia sia il titolo che i contenuti
  wxString strTitle;
  wxString strBody;

  //Aggiornamento
  if (_uInstallType == 3)
  {
    strTitle += wxT("AGGIORNAMENTO: riepilogo configurazione");
    
    strBody = wxT("<p>Cartella programma da aggiornare:  ");
    strBody += wxT(Bold(_strPrgLocPath) + "</p>");
    strBody += wxT("<p>Cartella dati in uso:  ");
    strBody += wxT(Bold(_strDataPath) + "</p>");
  }
  else  //Installazione
  {
    strTitle += wxT("INSTALLAZIONE: riepilogo configurazione");

    strBody = wxT("<p>Tipo installazione selezionata:  ");
    strBody += wxT(Bold(_strInstallType) + "</p>");
    strBody += wxT("<p>Cartella dove installare il programma:  ");
    strBody += wxT(Bold(_strPrgLocPath) + "</p>");
    if (_uInstallType == 2)
    {
      strBody += wxT("<p>Cartella di origine dei files del programma:  ");
      strBody += wxT(Bold(_strPrgNetPath) + "</p>");
    }
    strBody += wxT("<p>Cartella dati da creare:  ");
    strBody += wxT(Bold(_strDataPath) + "</p>");
  }
  //installazione servers...
  if (!_strSrvAuth.IsEmpty())
  {
    strBody += wxT("<p>Computer gestore delle autorizzazioni:  ");
    strBody += wxT(Bold(_strSrvAuth) + "</p>");
  }
  if (!_strSrvDict.IsEmpty())
  {
    strBody += wxT("<p>Computer gestore dei dizionari:  ");
    strBody += wxT(Bold(_strSrvDict) + "</p>");
  }
  //...e loro modalita' di lancio (solo installazione server!)
  if (_uInstallType == 1 && (!_strSrvAuth.IsEmpty() || !_strSrvDict.IsEmpty()) && _iSrvAutostartMode >= 0)
  {
    strBody += wxT("<p>Modalita' di esecuzione dei programmi di gestione:  ");
    if (_iSrvAutostartMode == 0)
      strBody += wxT(Bold("Come servizi") + "</p>");
    else
      strBody += wxT(Bold("Nel menu esecuzione automatica") + "</p>");
  }

  //installazione dati demo (solo in postazione singola)
  if (_uInstallType == 0 && _bInstDemoData)
    strBody += wxT("<p>Installazione area dati dimostrativa</p>");

  if (_bDesktopShortcut)
    strBody += wxT("<p>Creazione dell' icona sul desktop</p>");

  SetHTMLText(strTitle, strBody);

  return true;
}

CampoWizardPage10::CampoWizardPage10(wxWizard* parent) : CampoWizardPage(parent)
{
}


///////////////////////////////////////////////////////////
// CampoWizard
///////////////////////////////////////////////////////////
//la dichiarazione della classe e' prima in quanto alcuni suoi metodi sono usati da altre classi scritte piu' su
BEGIN_EVENT_TABLE(CampoWizard, wxWizard)
  EVT_BUTTON(wxID_FORWARD, CampoWizard::OnNext)
END_EVENT_TABLE()

void CampoWizard::OnNext(wxCommandEvent& e)
{
  CampoWizardPage* p = (CampoWizardPage*)GetCurrentPage();
  if (p->ForwardValidate())
    e.Skip();
}

bool CampoWizard::Run() 
{ return RunWizard(m_pPage[0]); }

wxString CampoWizard::Get(wxWindowID id) const
{
  wxWindow* pWnd = FindWindowById(id);
  return pWnd ? pWnd->GetLabel() : wxEmptyString;
}

int CampoWizard::GetSelection(wxWindowID id) const
{
  int n = -1;
  wxWindow* pWnd = FindWindowById(id);
  if (pWnd)
  {
    wxChoice* pList = (wxChoice*)pWnd;
    n = pList->GetSelection();
  }
  return n;
}

bool CampoWizard::GetBool(wxWindowID id) const
{
  wxCheckBox* pWnd = (wxCheckBox*)FindWindowById(id);
  return pWnd != NULL && pWnd->IsChecked();
}


void CampoWizard::Set(wxWindowID id, const wxString str)
{
  wxWindow* pWnd = FindWindowById(id);
  if (pWnd != NULL)
    pWnd->SetLabel(str);
}

//lunga litania di metodi per gettare e settare i valori tra le pagine
void CampoWizard::SetDestinationPath(const wxString& path)
{
  _strDestinationPath = path;
  //Se il path di destinazione e' vuoto -> nuova installazione, senno' e' un aggiornamento della installazione..
  //..che sta in _strDestinationPath
  if (_strDestinationPath.IsEmpty())
  {
    wxWizardPageSimple::Chain(m_pPage[3], m_pPage[4]);  //installazione nuova
  }
  else
  {
    wxWizardPageSimple::Chain(m_pPage[3], m_pPage[8]);  //aggiornamento
  }
}

const wxString& CampoWizard::GetDestinationPath() const
{
  return _strDestinationPath;
}

void CampoWizard::SetInstallationType(const unsigned int type)
{
  _uInstallationType = type;
  //in base al tipo di installazione spara l'utente alla pagina corretta
  switch (_uInstallationType)
  {
  case 1: //server
    wxWizardPageSimple::Chain(m_pPage[4], m_pPage[6]);  //manda l'utente alla pagina server
    wxWizardPageSimple::Chain(m_pPage[6], m_pPage[8]);  //dal server alla pagina riassuntiva
    break;
  case 2: //client
    wxWizardPageSimple::Chain(m_pPage[4], m_pPage[7]);  //manda l'utente alla pagina client
    wxWizardPageSimple::Chain(m_pPage[7], m_pPage[8]);  //dal client alla pagina riassuntiva
    break;
  case 3: //aggiornamento installazione precedente
    wxWizardPageSimple::Chain(m_pPage[3], m_pPage[8]);  //manda l'utente alla pagina riassuntiva
    break;
  default:  //standard
    wxWizardPageSimple::Chain(m_pPage[4], m_pPage[5]);  //manda l'utente alla pagina standard
    wxWizardPageSimple::Chain(m_pPage[5], m_pPage[8]);  //dalla standard alla pagina riassuntiva
    break;
  }
}

const unsigned int CampoWizard::GetInstallationType() const
{
  return _uInstallationType;
}

void CampoWizard::SetPrgLocPath(const wxString& strPrgLocPath)
{
  _strPrgLocPath = strPrgLocPath;
}

const unsigned int CampoWizard::GetDongleType() const
{
  return _uDongleType;
}

void CampoWizard::SetDongleType(const unsigned int uType)
{
  _uDongleType = uType;
}

const wxString& CampoWizard::GetPrgLocPath() const
{
  return _strPrgLocPath;
}

void CampoWizard::SetPrgNetPath(const wxString& strPrgNetPath)
{
  _strPrgNetPath = strPrgNetPath;
}

const wxString& CampoWizard::GetPrgNetPath() const
{
  return _strPrgNetPath;
}

void CampoWizard::SetDataPath(const wxString& strDataPath)
{
  _strDataPath = strDataPath;
}

const wxString& CampoWizard::GetDataPath() const
{
  return _strDataPath;
}

void CampoWizard::SetInstUseAuth(const bool bInstUseAuth)
{
  _bInstUseAuth = bInstUseAuth;
}

const bool CampoWizard::GetInstUseAuth() const
{
  return _bInstUseAuth;
}

void CampoWizard::SetSrvAuth(const wxString& strSrvAuth)
{
  _strSrvAuth = strSrvAuth;
}

const wxString& CampoWizard::GetSrvAuth() const
{
  return _strSrvAuth;
}

void CampoWizard::SetInstUseDict(const bool bInstUseDict)
{
  _bInstUseDict = bInstUseDict;
}

const bool CampoWizard::GetInstUseDict() const
{
  return _bInstUseDict;
}

void CampoWizard::SetSrvDict(const wxString& strSrvDict)
{
  _strSrvDict = strSrvDict;
}

const wxString& CampoWizard::GetSrvDict() const
{
  return _strSrvDict;
}

void CampoWizard::SetSrvAutostartMode(const int iSrvAutostartMode)
{
  _iSrvAutostartMode = iSrvAutostartMode;
}

const int CampoWizard::GetSrvAutostartMode() const
{
  return _iSrvAutostartMode;
}

void CampoWizard::SetInstDemoData(const bool bInstDemoData)
{
  _bInstDemoData = bInstDemoData;
}

const bool CampoWizard::GetInstDemoData() const
{
  return  _bInstDemoData;
}

void CampoWizard::SetDesktopShortcut(const bool bDesktopShortcut)
{
  _bDesktopShortcut = bDesktopShortcut;
}

const bool CampoWizard::GetDesktopShortcut() const
{
  return  _bDesktopShortcut;
}
//...fine litania metodi di passaggio valori tra le finestre



CampoWizard::CampoWizard(wxWindow* pParent)
{
  //resettatore dei booleans (che senno' prendono valore casuale ad ogni esecuzione)
  _bInstDemoData = false;      //installa dati dimostrativi
  _bInstUseAuth = false;       //installa/usa server authoriz
  _bInstUseDict = false;       //installa/usa server diction
  _bDesktopShortcut = false;   //creazione link sul desktop

  wxBitmap bitmap;
  wxString strName = wxT("logo.gif");
  bitmap.LoadFile(strName, wxBITMAP_TYPE_GIF);

  Create(pParent, wxID_ANY, APPNAME, bitmap);

  m_pPage[0] = new CampoWizardPage1(this);   //benvenuto con logo
  m_pPage[1] = new CampoWizardPage2(this);   //licenza
  m_pPage[2] = new CampoWizardPage3(this);   //scelta aggiornamento/tipo installazione
  m_pPage[3] = new CampoWizardPage4(this);   //test ed installazione chiavi
  m_pPage[4] = new CampoWizardPage5(this);   //selezione tipo installazione
  m_pPage[5] = new CampoWizardPage6(this);   //installazione standard
  m_pPage[6] = new CampoWizardPage7(this);   //installazione server
  m_pPage[7] = new CampoWizardPage8(this);   //installazione client
  m_pPage[8] = new CampoWizardPage9(this);   //creazione icona sul desktop e in start/programmi/campo
  m_pPage[9] = new CampoWizardPage10(this);  //riassuntino installazione


  for (int p = 1; p < m_nPages; p++)
    wxWizardPageSimple::Chain(m_pPage[p-1], m_pPage[p]);

  GetPageAreaSizer()->Add(m_pPage[0]);

  //bottoni di navigazione
  Set(wxID_FORWARD, "Avanti");
  Set(wxID_BACKWARD, "Indietro");
  Set(wxID_CANCEL, "Annulla");
}


///////////////////////////////////////////////////////////
//  CampoFrame
///////////////////////////////////////////////////////////

class CampoFrame : public wxFrame
{
protected:
  DECLARE_EVENT_TABLE();
  virtual void OnErase(wxEraseEvent& e);
public:
  CampoFrame();
};

BEGIN_EVENT_TABLE(CampoFrame, wxFrame)
  EVT_ERASE_BACKGROUND(CampoFrame::OnErase)
END_EVENT_TABLE()

void CampoFrame::OnErase(wxEraseEvent& e)
{
  //preparazione background
  wxDC& dc = *e.GetDC();
  const wxRect rect = GetClientSize();
  wxColour c0 = wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT);
  wxColour c1 = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
  wxColour c2 = wxSystemSettings::GetColour(wxSYS_COLOUR_3DDKSHADOW);
  
  wxRect rect1 = rect; rect1.SetBottom(rect.GetBottom() / 2);
  dc.GradientFillLinear(rect1, c0, c1, wxSOUTH);

  wxRect rect2 = rect; rect2.SetTop(rect.GetBottom() / 2);
  dc.GradientFillLinear(rect2, c1, c2, wxDOWN);

  const int nHeight = rect.GetHeight()/8;
  wxFont* pFont = wxTheFontList->FindOrCreateFont(nHeight, wxFONTFAMILY_SWISS, wxFONTSTYLE_ITALIC, 
                                                  wxFONTWEIGHT_BOLD);
  dc.SetFont(*pFont);
  dc.SetBackgroundMode(wxTRANSPARENT);

  const int k = nHeight / 16 + 1;

  dc.SetTextForeground(c2);
  dc.DrawText(APPNAME, k, k);
  dc.SetTextForeground(c1);
  dc.DrawText(APPNAME, k/2, k/2);

  int w, h;
  const wxString strSetup = wxT("Setup");
  dc.GetTextExtent(strSetup, &w, &h);

  dc.SetTextForeground(c2);
  dc.DrawText(strSetup, rect.GetRight()-w-k/2, rect.GetHeight()-h-k/2);
  dc.SetTextForeground(c1);
  dc.DrawText(strSetup, rect.GetRight()-w-k, rect.GetHeight()-h-k);
}

CampoFrame::CampoFrame()
       : wxFrame(NULL, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0)
{
  ShowFullScreen(true);
}

///////////////////////////////////////////////////////////
// CampoSetup
///////////////////////////////////////////////////////////
//classe principale, ovvero applicazione
class CampoSetup : public wxApp
{
  CampoFrame* m_pMainFrame;
  wxLocale m_locale;
  wxString m_strSetupPath;

  CampoWizard* m_pWizard;

private:
  bool WriteRegistryKey(HKEY hBaseKey, const wxString strKey, const wxString& strValue) const;
  wxString ReadRegistryKey(HKEY hBaseKey, const wxString strKey) const;
  wxString GetFolderPath(unsigned int uPathID) const;

protected:
  DECLARE_EVENT_TABLE()
  void OnTimer(wxTimerEvent& e);
  bool CreateIcon(unsigned int csidl, const wxFileName& strExeFile) const;
  bool CreateAutostartMode(const int iSrvAutostartMode, const wxString& strPath);
  void AssociateExtension(const wxFileName& strExeFile, const wxString strExt);
  
  wxString ReadRootRegistryKey(const wxString strKey) const;
  wxString ReadLocalMachineRegistryKey(const wxString strKey) const;
  bool WriteRootRegistryKey(const wxString strKey, const wxString& strValue) const;
  bool WriteLocalMachineRegistryKey(const wxString strKey, const wxString& strValue) const;

  void CheckAndMakeDir(const wxString& strDir, const wxString& strMsg) const;
  bool UnzipFile(const char* strZipFile, const char* strDestdir) const;
  size_t GetZipList(const char* strZipFile, wxArrayString& aFiles) const;
  const wxString GetSourceDir(const wxString strDirName) const;
  void UnzipSystem(const wxString& strPrgLocPath) const;

public:
  virtual bool OnInit();
};

IMPLEMENT_APP(CampoSetup)

BEGIN_EVENT_TABLE(CampoSetup, wxApp)
  EVT_TIMER(883, OnTimer)
END_EVENT_TABLE()


//metodi di lettura/scrittura registry di windows (fantastici!)
wxString CampoSetup::ReadRegistryKey(HKEY hBaseKey, const wxString strKey) const
{
  wxString strValue;
  HKEY hKey = NULL;
  wxString strPath, strName;
  wxFileName::SplitPath(strKey, &strPath, &strName, NULL);

  bool ok = ::RegOpenKeyEx(hBaseKey, strPath, 0, KEY_READ, &hKey) == ERROR_SUCCESS;
  if (ok)
  {
    BYTE buff[512];
    DWORD type = REG_SZ;
    DWORD dw = sizeof(buff);
    ok = ::RegQueryValueEx(hKey, strName, NULL, &type, buff, &dw) == ERROR_SUCCESS;
    if (ok)
      strValue = buff;
    ::RegCloseKey(hKey);
  }
  return strValue;
}

wxString CampoSetup::ReadRootRegistryKey(const wxString strKey) const
{
  return ReadRegistryKey(HKEY_CLASSES_ROOT, strKey);
}

wxString CampoSetup::ReadLocalMachineRegistryKey(const wxString strKey) const
{
  return ReadRegistryKey(HKEY_LOCAL_MACHINE, strKey);
}

bool CampoSetup::WriteRegistryKey(HKEY hBaseKey, const wxString strKey, const wxString& strValue) const
{
  HKEY hKey = NULL;
  DWORD dw = 0;
  //splitta la stringa in path e valore
  wxString strPath, strName;
  wxFileName::SplitPath(strKey, &strPath, &strName, NULL);

  bool ok = ::RegCreateKeyEx(hBaseKey, strPath, 0, REG_NONE,
				     REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL, &hKey, &dw) == ERROR_SUCCESS;
  if (ok)
  {
    ok = ::RegSetValueEx(hKey, strName, 0, REG_SZ, 
           (BYTE*)(const wxChar*)strValue, DWORD(2*strValue.Len()+2)) == ERROR_SUCCESS;
    ::RegCloseKey(hKey);
  }
  return ok;
}

bool CampoSetup::WriteRootRegistryKey(const wxString strKey, const wxString& strValue) const
{
  return WriteRegistryKey(HKEY_CLASSES_ROOT, strKey, strValue);
}

bool CampoSetup::WriteLocalMachineRegistryKey(const wxString strKey, const wxString& strValue) const
{
  return WriteRegistryKey(HKEY_LOCAL_MACHINE, strKey, strValue);
}

wxString CampoSetup::GetFolderPath(unsigned int uPathID) const
{
  TCHAR szPath[MAX_PATH] = wxT("");
	HRESULT hres = ::SHGetFolderPath(NULL, uPathID, NULL, SHGFP_TYPE_CURRENT, szPath);
  return szPath;
}

void CampoSetup::AssociateExtension(const wxFileName& strExeFile, const wxString strExt)
{
  // Register icon and application
  WriteRootRegistryKey(strExt, APPNAME);

  wxString str = strExeFile.GetFullPath(); str += wxT(",0");
  WriteRootRegistryKey(wxT("Campo\\DefaultIcon"), str);

  str = strExeFile.GetFullPath(); str += wxT(" \"%1\"");
  WriteRootRegistryKey(wxT("Campo\\shell\\open\\command"), str);
}

bool CampoSetup::CreateAutostartMode(const int iSrvAutostartMode, const wxString& strPath)
{
  //creazione dei filenames e dei path necessari in giro per la funzione
  //filename (con path quindi) di Lurch.exe
  wxFileName strExe(strPath, wxT("lurch.exe"));
  strExe.AppendDir("servers");
  //stringa path della cartella Servers in base alle scelte dell'utente
  const wxString strSrvPath = strPath + "\\servers";

  switch (iSrvAutostartMode)
  {
  //esecuzione server come servizi (magia!)
  case 0:
    {
      //cerca se non esiste per caso gia' da una precedente installazione..
      //..non serve piu' a un cazzo ma si e' tenuto come prova in debug di lettura del registry!
      wxString strValue = ReadLocalMachineRegistryKey("SYSTEM\\CurrentControlSet\\Services\\Lurch\\Parameters\\Application");
      
      //elimina un eventuale servizio precedente (senno' col cavolo che lo riesce a modificare!)
      //utilizza il programma instsrv.exe dentro la cartella servers installata
      wxString strRemove = strSrvPath + "\\instsrv Lurch REMOVE";
      const long lRemove = wxExecute(strRemove, wxEXEC_SYNC);

      //aggiunge la voce ai servizi di windows (dentro strumenti di amministrazione)
      //utilizza i programmi instrv.exe e srvany.exe dentro la cartella servers installata
      wxString strCreateService = strSrvPath + "\\instsrv Lurch ";
      strCreateService += strSrvPath;
      strCreateService += "\\srvany.exe";
      //esegue il programma di installazione servizi di Windows creando la voce
      const long lExec = wxExecute(strCreateService, wxEXEC_SYNC);
      if (lExec >= 0)
      {
        //crea le voci nel registry di windows
        WriteLocalMachineRegistryKey("SYSTEM\\CurrentControlSet\\Services\\Lurch\\Parameters\\Application", strExe.GetFullPath());
        wxString strExecService = GetFolderPath(CSIDL_SYSTEM);
        strExecService += "\\NET START Lurch";
        //avvia il servizio
        const long lExecLurch = wxExecute(strExecService, wxEXEC_SYNC);
        if (lExecLurch < 0)
          WarningBox("Impossibile eseguire il servizio del gestore applicazioni.\nLanciarlo manualmente dagli strumenti di amministrazione nel pannello di controllo!");
      }
      else
        WarningBox("Impossibile registrare il servizio per l'esecuzione automatica del gestore applicazioni.\nSelezionare una diversa modalita' di esecuzione!");

    }
    break;
  //link nella cartella esecuzione automatica
  case 1:
    {
      CreateIcon(CSIDL_COMMON_STARTUP, strExe);
    }
    break;
  default:
    break;
  }
  return true;
}

bool CampoSetup::CreateIcon(unsigned int csidl, const wxFileName& strExeFile) const
{
  //csidl = CSIDL_COMMON_DESKTOPDIRECTORY = desktop
  //csidl = CSIDL_COMMON_STARTUP = all users esecuzione automatica
  wxString strDesktopPath = GetFolderPath(csidl);

  if (!strDesktopPath.IsEmpty())
  {
    CoInitialize(NULL);

    // Get a pointer to the IShellLink interface. 
	  IShellLink* psl; 
    HRESULT hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&psl); 
    if (SUCCEEDED(hres)) 
	  { 
      IPersistFile* ppf; 

      // Set the path to the shortcut target and add the description. 
      psl->SetPath(strExeFile.GetFullPath());
		  psl->SetWorkingDirectory(strExeFile.GetPath());
      psl->SetDescription(APPNAME); 

     // Query IShellLink for the IPersistFile interface for saving the 
     // shortcut in persistent storage. 
      hres = psl->QueryInterface(IID_IPersistFile, (void**)&ppf); 

      if (SUCCEEDED(hres)) 
		  { 
        wxFileName strLnk;
        if (csidl == CSIDL_COMMON_STARTUP)
          strLnk.Assign(strDesktopPath, wxT("Lurch.lnk"));
        else
          strLnk.Assign(strDesktopPath, wxT("Campo.lnk"));

        // Save the link by calling IPersistFile::Save.
        wxString stringa = strLnk.GetFullPath();
        wchar_t buff[_MAX_PATH];
        memset(buff, 0, sizeof(buff));
        wxConvLocal.MB2WC(buff, stringa, stringa.Len());
        hres = ppf->Save(buff, true); 
        ppf->Release(); 
      } 
      psl->Release();
    } 
    CoUninitialize();
  }
  return true;
}

void CampoSetup::CheckAndMakeDir(const wxString& strDir, const wxString& strMsg) const
{
  if (!wxDir::Exists(strDir))
  {
    const wxFileName fname(strDir + "\\*.*");
    const wxArrayString& asDirs = fname.GetDirs();
    wxString strCartella = fname.GetVolume();
    strCartella += fname.GetVolumeSeparator();
    for (size_t i = 0; i < asDirs.GetCount(); i++)
    {
      strCartella += "\\";
      strCartella += asDirs[i];
      if (!wxDir::Exists(strCartella) && !wxMkdir(strCartella))
      {  
        wxString strError = "Impossibile creare la cartella ";
        strError += strMsg;
        strError += " ";
        strError += strCartella;
        strError += "\nAssicurarsi di avere il permesso di scrittura sul disco e che vi sia spazio a sufficienza";
        ErrorBox(strMsg);
        return;
      }
    }
  }
  if (!strMsg.IsEmpty())  //se il messaggio e' vuoto NON deve fare alcun controllo (installazione sistema)
  {
    wxDir dirDir(strDir);
    if(dirDir.HasFiles()) //se la dir di destinazione dovesse esistere gia' (installazione abortita) almeno sia vuota
    {
      ErrorBox("La cartella di destinazione non e' vuota!\nInstallazione interrotta!");
      return;
    }
  }
}

size_t CampoSetup::GetZipList(const char* strZipFile, wxArrayString& aFiles) const
{
	wxFFileInputStream fin(strZipFile);
  wxZipInputStream zip(fin);
  for (wxZipEntry* z = zip.GetNextEntry(); z; z = zip.GetNextEntry())
  {
    const wxString str = z->GetInternalName();
    aFiles.Add(str);
  }

	return aFiles.GetCount();
}

bool CampoSetup::UnzipFile(const char* strZipFile, const char* strDestDir) const
{
	wxArrayString aFiles;
	const size_t files = GetZipList(strZipFile, aFiles);

  wxProgressDialog pi("Unzip", "", (int)files, NULL, wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT);

	for (unsigned int f = 0; f < files; f++)
	{
    const wxString& strFileName = aFiles[f];
    if (!pi.Update(f, strFileName))
      break;

    if (wxEndsWithPathSeparator(strFileName) || strFileName.Find('.') < 0)  // Is dir name
    {
		  wxString strOutDir = strDestDir;
      if (!wxEndsWithPathSeparator(strOutDir))
		    strOutDir += wxFILE_SEP_PATH;
		  strOutDir += strFileName;
		  if (!::wxDirExists(strOutDir))
			  ::wxMkdir(strOutDir);
    }
    else
    {
		  wxZipInputStream fin(strZipFile, strFileName);

		  wxString strOutFile = strDestDir;
      if (!wxEndsWithPathSeparator(strOutFile) && !wxIsPathSeparator(strFileName[0]))
		    strOutFile += wxFILE_SEP_PATH;
		  strOutFile += strFileName;

		  wxString strPath;
		  ::wxSplitPath(strOutFile, &strPath, NULL, NULL);
      CheckAndMakeDir(strPath, wxEmptyString);
	
      wxFileOutputStream fout(strOutFile);
		  fout.Write(fin);
    }
	}
	return files > 0;
}

static int PatchCompare(const wxString& first, const wxString& second)
{
  const wxFileName fn1(first);
  const wxFileName fn2(second);
  const wxString strName1 = fn1.GetName().Lower();
  const wxString strName2 = fn2.GetName().Lower();
  if (strName1 == "syinst1")
    return -1;
  if (strName2 == "syinst1")
    return 1;

  return strName1.CompareTo(strName2);
}


const wxString CampoSetup::GetSourceDir(const wxString strDirName) const
{
  wxFileName strSourcePath(m_strSetupPath, "pippo.txt");
  strSourcePath.AppendDir("..");
  strSourcePath.AppendDir("..");
  strSourcePath.AppendDir(strDirName);
  strSourcePath.MakeAbsolute();
  const wxString strSrc = strSourcePath.GetPath();
  return strSrc;
 }

void CampoSetup::UnzipSystem(const wxString& strPrgLocPath) const
{
  wxArrayString asFilesList;
  const wxString strSrc = GetSourceDir("program");
  //..contando anche quanti sono e memorizzandoli in un array asFileList
  const size_t uFilesToCopy = wxDir::GetAllFiles(strSrc, &asFilesList, "sy*.zip");
  if (uFilesToCopy > 0)
  {
    //ordina le patch per numero crescente ma mette davanti a tutte il pacco (sysinst1)
    asFilesList.Sort(PatchCompare);
    for (size_t i = 0; i < uFilesToCopy; i++)
    {  
      UnzipFile(asFilesList[i] , strPrgLocPath);
    }

    //aggiorna l'install.ini in base al numero di patch e versione dell'ultimo file zip di sistema
    //ci vuole un giro allucinogeno per trasformare il .zip in .ini e togliere quel cazzo di 1 in fondo
    wxFileName strLastFile(asFilesList[uFilesToCopy - 1]);    //zip con path completo
    wxString strWrk = strLastFile.GetName();
    strWrk.Truncate(strWrk.Len() - 1);
    strLastFile.SetName(strWrk);
    strLastFile.SetExt("ini");
    strWrk = strLastFile.GetFullPath();

    //adesso che ha trovato quello sporco ultimo .ini prende versione e patch e le copia nell'install.ini..
    //..nella dir dei programmi; lo fa paragrafo x paragrafo ([sy],[sy1]..)
    //potrebbe sembrare assurdo un for, ma e' per futuri sottomoduli con numero > 1
    for (int j = 0; j < 2; j++)
    {
      wxString strParagraph = "sy";
      if (j > 0)
        strParagraph << j;
      CampoIniFile SyLastPatch(strWrk, strParagraph);
      const wxString strVersion = SyLastPatch.Get("Versione");
      const wxString strPatch = SyLastPatch.Get("Patch");

      CampoIniFile InstallIni(strPrgLocPath + "/install.ini", strParagraph);
      InstallIni.Set("Versione", strVersion);
      InstallIni.Set("Patch", strPatch);
    }
  }
}

//metodo principale dell'applicazione che gestisce l'ordine degli eventi nella installazione vera e propria
void CampoSetup::OnTimer(wxTimerEvent& WXUNUSED(e))
{
  m_pWizard = new CampoWizard(m_pMainFrame);

  wxFileName strPath = argv[0];
  strPath.SetCwd();
  //path del programma setup.exe in esecuzione; serve in seguito in quanto alcuni metodi (tipo la GetAllFiles)..
  //..fanno perdere questo path
  m_strSetupPath = strPath.GetPath();

  if (m_pWizard->Run())
  {

    // 1) RACCOLTA PARAMETRI GENERALI INSTALLAZIONE (tipo,path,cartelle,servers,...)
    //------------------------------------------------------------------------------
    //tipo di installazione/aggiornamento
    const unsigned int uInstallationType = m_pWizard->GetInstallationType();
    const bool bNewInstallation = uInstallationType < 3;
    //installazione servers? solo per server di campo
    const bool bInstallLurch = uInstallationType == 1 && (m_pWizard->GetInstUseAuth() || m_pWizard->GetInstUseDict());
    //uso servers? sarebbe solo per i client ma lo teniamo buono per tutti
    const bool bUseLurch = uInstallationType != 1 && (!m_pWizard->GetSrvAuth().IsEmpty() || !m_pWizard->GetSrvDict().IsEmpty());
    //installazione datidemo? (oddio speriamo di no!; comunque vale solo per installazione standard)
    const bool bInstallDemoData = uInstallationType == 0 && m_pWizard->GetInstDemoData();
    //cartelle selezionate dall'utente
    const wxString& strPrgLocPath = m_pWizard->GetPrgLocPath();
    const wxString& strDataPath = m_pWizard->GetDataPath();

    //se nuova installazione deve anche creare la directory di destinazione
    if (bNewInstallation)
    {
      //creazione della directory dei programmi (compreso l'intero albero directory)
      CheckAndMakeDir(strPrgLocPath, "programmi");
      //creazione della directory dei dati (compreso l'intero albero directory)
      CheckAndMakeDir(strDataPath, "dati");
    }
 

    // 2) COPIA DEI FILES DI INSTALLAZIONE DALLA CARTELLA CAMPO (E SUBDIRS) (SU CD) ALLA CARTELLA DESTINAZIONE
    //--------------------------------------------------------------------------------------------------------
    //copia del contenuto della cartella campo nella cartella di destinazione (installaz/aggiornam)
    //per prima cosa cerca la cartella dei files sorgente...
    wxArrayString asFilesList;
    wxFileName strSourcePath(m_strSetupPath, "*.*");
    strSourcePath.AppendDir("..");
    strSourcePath.MakeAbsolute();
    //stringa inutile al programma ma decisiva per il programmatore
    const wxString strSrc = strSourcePath.GetPath();
    //..contando anche quanti sono e memorizzandoli in un array asFileList
    const size_t uFilesToCopy = wxDir::GetAllFiles(strSrc, &asFilesList);

    //per ogni file da copiare controlla i path sorgente e destinazione(problema con sottodirectory tipo dati)
    wxString strFileCurr;
    const size_t nPathLenght = strSourcePath.GetPath().Len();
    //progress bar
    wxProgressDialog pi("Installazione Dati e Programmi di base...", "", (int)uFilesToCopy, NULL, wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT);
    
    for (size_t i = 0; i < uFilesToCopy; i++)
    {    
      //aggiorna la progind
      if (!pi.Update((int)i, asFilesList[i]))
        break;
      //files dei dati standard! solo in caso di nuova installazione!!
      if (asFilesList[i].Lower().Find("\\dati\\") > 0)
      {
        //i DATI NON VANNO MAI installati in caso di aggiornamento!!!
        //e nemmeno in caso si scelga di installare i dati demo (senno' sporca la dir dati e i datidemo non si installano)
        //Ricordare che c'e' gia' stato il controllo nella Forward della pagina di selezione, quindi la cartella..
        //..di destinazione e' comunque vuota
        if (bNewInstallation && !bInstallDemoData)
        {
          strFileCurr = strDataPath;
          strFileCurr += asFilesList[i].Mid(nPathLenght + 5);
        }
      }
      else
      {
        //che fare con i servers? copiare la directory..potrebbe servire
        if (asFilesList[i].Lower().Find("\\servers\\") > 0)
        {
          if (bInstallLurch)
          {
            strFileCurr = strPrgLocPath;
            strFileCurr += "\\servers";
            strFileCurr += asFilesList[i].Mid(nPathLenght + 8);
          }
        }
        else  //files dei programmi
        {
          strFileCurr = strPrgLocPath;
          strFileCurr += asFilesList[i].Mid(nPathLenght);
        }
      }
      //copia i files nella cartella di destinazione (programmi,dati,cazzi e mazzi);se il nome del file..
      //..di destinazione e' vuoto significa che non lo deve copiare!! (es. dati in aggiornamento)
      if (!strFileCurr.IsEmpty())
      {
        strFileCurr.MakeLower();  //minuscolizzazione di sicurezza
        const wxFileName strFileName(strFileCurr);

        //i files .ini vanno trattati con i guanti (se esistono gia' non vanno copiati!!!)
        if (strFileName.GetExt() == "ini")
        {
          const wxString strName = strFileName.GetName();
          //campo.ini e install.ini vanno lasciati stare se esistono (aggiornamento)!!!
          if ((strName == "campo" || strName == "install") && strFileName.FileExists())
            continue;
        }
        //eventuali sottodirectory le crea (solo se hanno un nome)
        const wxString strDir = strFileName.GetPath();
        if (!strDir.IsEmpty() && !wxDirExists(strDir))
          wxMkdir(strDir);

        if(!wxCopyFile(asFilesList[i], strFileCurr))
        {
          wxString strErr = "Impossibile copiare il file ";
          strErr += asFilesList[i];
          strErr += " in ";
          strErr += strFileCurr;
          strErr += "\nInstallazione interrotta!";
          ErrorBox(strErr);
          break;
        }
      } //if (!strFileCurr.IsEmpty()..
    } //for(size_t...
 
    // 3) INSTALLAZIONE DATI DEMO
    //---------------------------
    //installazione dei dati dimostrativi (che schifo!).Non si puo' fare in aggiornamento!
    if (bInstallDemoData && uInstallationType < 3)
    {
      //trova la cartella datidemo da copiare
      wxArrayString asDataList;
      const wxString strSrc = GetSourceDir("datidemo");
      //conta i files da copiare e si lancia nell'operazione di copiatura...
      //Vale quanto detto per l'installazione dell'area dati
      const size_t uFilesToCopy = wxDir::GetAllFiles(strSrc, &asDataList);
      wxString strFileCurr;
      const size_t nPathLenght = strSrc.Len();
      wxProgressDialog pi("Installazione Dati Demo...", "", (int)uFilesToCopy, NULL, wxPD_AUTO_HIDE | wxPD_APP_MODAL | wxPD_CAN_ABORT);      
      for (size_t i = 0; i < uFilesToCopy; i++)
      {
        if (!pi.Update((int)i, asDataList[i]))
          break;

        asDataList[i].Lower();
        strFileCurr = strDataPath;
        strFileCurr += asDataList[i].Mid(nPathLenght);
               
        if (!strFileCurr.IsEmpty())
        {
          strFileCurr.MakeLower();
          const wxFileName strFileName(strFileCurr);

          const wxString strDir = strFileName.GetPath();
          if (!strDir.IsEmpty() && !wxDirExists(strDir))
          wxMkdir(strDir);

          if(!wxCopyFile(asDataList[i], strFileCurr))
          {
            wxString strErr = "Impossibile copiare il file ";
            strErr += asDataList[i];
            strErr += " in ";
            strErr += strFileCurr;
            strErr += "\nInstallazione interrotta!";
            ErrorBox(strErr);
            break;
          }
        } //if (!strFileCurr.IsEmpty()..
      } //for (size_t i = 0...
    } //if(bInstallDemoData...


    // 4) COMPILAZIONE CAMPO.INI CON CONFIGURAZIONE NUOVA INSTALLAZIONE
    //-----------------------------------------------------------------
    //adesso deve compilare il campo.ini se nuova installazione..
    if (bNewInstallation)
    {
      { //parentesi necessaria per la scrittura immediata (non cancellare! serve per debug)
        //paragrafo [Main]
        CampoIniFile CampoIniMain(strPrgLocPath + "/campo.ini", "Main");
        const unsigned int uDongleType = m_pWizard->GetDongleType();
        CampoIniMain.Set("Donglehw", uDongleType);
        CampoIniMain.Set("Study", strDataPath);
        CampoIniMain.Set("Firm", "com");
        //client o non client?
        if (uInstallationType == 2) //client
        {
          CampoIniMain.Set("TestDatabase", "N");
          CampoIniMain.Set("TestPrograms", "X");
        }
        else    //altri (standard,server)
        {
          CampoIniMain.Set("TestDatabase", "X");
          CampoIniMain.Set("TestPrograms", "N");
        }
      }
      //paragrafo [Server]
      if (bInstallLurch || bUseLurch)
      {
        CampoIniFile CampoIniSrv(strPrgLocPath + "/campo.ini", "Server");
        CampoIniSrv.Set("Dongle", m_pWizard->GetSrvAuth());
        CampoIniSrv.Set("Dictionary", m_pWizard->GetSrvDict());
      }
    }  //if(bNewInstallation...


    // 5) COMPILAZIONE\AGGIORNAMENTO INSTALL.INI CON DISKPATH
    //-------------------------------------------------------
    //..e modificare comunque l'install.ini aggiornando eventualmente l'origine dei programmi
    //parentesi necessaria per la scrittura immediata (non cancellare! serve per debug)
    {
      CampoIniFile CampoInstall(strPrgLocPath + "/install.ini", "Main");
      if (uInstallationType == 2) //client: directory origine sul server
        CampoInstall.Set("DiskPath", m_pWizard->GetPrgNetPath());
      else  //e' il path assoluto dell'install.ini che sta in 'program' (es. D:\program)
      {
        wxFileName strSourcePath(m_strSetupPath + "/install.ini");
        const wxString strSrc = GetSourceDir("program");
        CampoInstall.Set("DiskPath", strSrc);
      }
    }


    // 6) CREAZIONE AUTOSTART DEI SERVERS (SE CI SONO)
    //------------------------------------------------
    //solo se sta installando campo in postazione server e deve installare un gestore di servizi..
    //..avvia la procedura della creazione dell'autostart(un casino)
    if (bInstallLurch)
    {
      const int iSrvAutostartMode = m_pWizard->GetSrvAutostartMode();
      CreateAutostartMode(iSrvAutostartMode, strPrgLocPath);
    }
    

    // 7) AGGIORNAMENTO DEL MODULO SY CON EVENTUALI PATCH PRESENTI IN PROGRAM DEL CD E AGGIORNAMENTO INSTALL.INI
    //----------------------------------------------------------------------------------------------------------
    //procede poi al caricamento delle patch eventuali di sistema all'interno della dir 'program' e al..
    //..conseguente riaggiornamento del livello versione/patch del SY in install.ini
    UnzipSystem(strPrgLocPath);


    // 8) CREAZIONE DELL'ICONA SUL DESKTOP
    //------------------------------------
    const wxFileName strExe(strPrgLocPath, wxT("ba0.exe"));
    const bool bDesktopShortcut = m_pWizard->GetDesktopShortcut();
    if (bDesktopShortcut)
      CreateIcon(CSIDL_COMMON_DESKTOPDIRECTORY, strExe);


    // 9) AGGIORNAMENTO CAMPO.STP
    //---------------------------
    if (bNewInstallation)
    {
      //deve aggiungere la nuova installazione al campo.stp
      for (int i = 1;; i++)
      { 
        wxString strGroup;
        strGroup << i;
        CampoIniFile CampoStp("C:\\campo.stp", strGroup);
        wxString strPath = CampoStp.Get("Program");
        if (strPath.IsEmpty())
        {
          CampoStp.Set("Program", strPrgLocPath);
          break;
        }
      }
    }
    

    // 10) CHIUDE IL SETUP LANCIANDO BA1 -6 PER INSTALLAZIONE MODULI
    //-------------------------------------------------------------
    //lanciare ba1.exe -6 in uscita (non va qui! e' solo per ricordarsi di farlo!)
    wxSetWorkingDirectory(strPrgLocPath);
    wxExecute("ba1 -6 /uADMIN");

  }  //if (m_pWizard->Run())...
  m_pWizard->Destroy();

  //finestrina x chiudere a mano il programma (sconsigliata causa lancio ba1.exe)
//  ::wxMessageBox(wxT("Installazione terminata"), APPNAME,  wxOK | wxICON_INFORMATION);
  m_pMainFrame->Destroy();
}

bool CampoSetup::OnInit()
{
  wxInitAllImageHandlers();
  m_locale.Init();

  m_pMainFrame = new CampoFrame;
  SetTopWindow(m_pMainFrame);

  wxTimerEvent e(883);
  AddPendingEvent(e);   
  
  return true;
}