campo-sirio/setup/Setup.cpp

//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/protocol/http.h>
#include <wx/snglinst.h>

#include "key.h"
#include "wizard.h"
#include "utils.h"

#include <shlobj.h>

///////////////////////////////////////////////////////////
//  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(rect1.GetBottom());
  dc.GradientFillLinear(rect2, c1, c2, wxDOWN);

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

  int w = 0, h = 0; dc.GetTextExtent(RESELLER, &w, &h);
  while (w > rect.width)
  {
    nHeight = nHeight * rect.width / w;
    pFont = wxTheFontList->FindOrCreateFont(nHeight, wxFONTFAMILY_SWISS, wxFONTSTYLE_ITALIC, wxFONTWEIGHT_BOLD);
    dc.SetFont(*pFont);
    dc.GetTextExtent(RESELLER, &w, &h);
  }

  const int k = nHeight / 16 + 1;

  dc.SetBackgroundMode(wxTRANSPARENT);
  dc.SetTextForeground(c2);
  dc.DrawText(RESELLER, rect.GetRight()-w-k/2, rect.GetHeight()-h-k/2);
  dc.SetTextForeground(c1);
  dc.DrawText(RESELLER, rect.GetRight()-w-k, rect.GetHeight()-h-k);

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

  wxFont* pSmallFont = wxTheFontList->FindOrCreateFont(nHeight/6, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_LIGHT);
  dc.SetFont(*pSmallFont);
  const wxString strTime = __TIMESTAMP__;
  dc.GetTextExtent(strTime, &w, &h);
  dc.SetTextForeground(c2);
  dc.DrawText(strTime, rect.GetRight()-w, 0);
 
}

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;
  bool m_bLurchWasRunning;

  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()

  //metodi principali dell'applicazione
  void OnTimer(wxTimerEvent& e);
  void DiskUpdate();
  void InternetUpdate();
  void ClientUpdate();
  void NormalSetup();
  bool SystemRunning(const wxString& strAppName, wxString strMsg) const;
  int  LurchRunning() const;
  bool CampoIsRunning() const;

  //metodi di interfaccia con Windows
  bool CreateIcon(unsigned int csidl, const wxFileName& strExeFile, const wxString& strLinkName) const;
  void AssociateExtension(const wxFileName& strExeFile, const wxString strExt);
  //...per i servers
  bool CreateAutostartLurch(const LurchMode iSrvAutostartMode, const wxString& strPath);
  bool StopLurch() const;
  bool StartLurch(const wxString& strPrgLocPath) const;
  bool LurchWasRunning() const { return m_bLurchWasRunning; }

  //metodi di interfaccia con il registry di Windows
  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;

  //metodi di utility per i vari modi di aggiornamento
  const wxString GetSourceDir(const wxString strDirName) const;
  const wxString& GetSetupDir() const { return m_strSetupPath; }
  void EmptyOutDir(const wxString& strDir) const;
  bool UnzipModule(const wxString& strPrgLocPath, const wxString& strSrc, const wxString& strModule) const;
  void CopyDir(const wxString& strSourceDir, const wxString& strDestDir) const;
  bool CopyFilesAndDirs(const wxString& FilesListI, wxString strFileCurr, const bool bIni) const;  
  void UpdateInstallIni(const wxString strSourcePath, const wxString strDestPath, const wxString& strModule) const;
  bool HTTPGet(const wxString& strLocalPath, const wxString& strWebPath) const;

  //metodi di aggiornamento non standard (client, da disco e via web con installazione moduli)
  int ClientUpdateModule(const wxString& strLocalPath, const wxString& strRemotePath, const wxString strModule) const;
  bool DiskUpdateModule(const wxString& strLocalPath, const wxString& strWebPath, const wxString strModule) const;
  bool InternetUpdateModule(const wxString& strLocalPath, const wxString& strWebPath, const wxString strModule) 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);
}

//----------------------------------
// Metodi di interfaccia con Windows
//----------------------------------
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(APPNAME + wxT("\\DefaultIcon"), str);

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

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

    // Get a pointer to the IShellLink interface. 
	  IShellLink* psl = NULL; 
    HRESULT hres = ::CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&psl); 
    if (SUCCEEDED(hres)) 
	  {  
      // Set the path to the shortcut target and add the description. 
      psl->SetPath(strExeFile.GetFullPath());
		  psl->SetWorkingDirectory(strExeFile.GetPath());
      psl->SetDescription(APPNAME);

      //sceglie l'icona da quelle possibili legate al .exe in base al tipo di installazione
      const InstallationType uInstallationType = m_pWizard->GetInstallationType();

      //anche l'icona deve essere scelta in base al reseller
      wxString strIcon = Icon();
      //path completo del file icona, in modo da legarlo al link sul desktop;comincia con il path di Campo
      wxString strPath = m_pWizard->GetPrgLocPath();

      if (!strIcon.IsEmpty())
      {
        strPath += "/setup/";   //se esiste l'icona del reseller sta in setup
      }
      else
      {
        strPath += "/res/";   //se non trova l'icona del reseller prende quella standard in res
      }

      const int nPos = strIcon.Len() - 4;
      switch (uInstallationType)
      {
      case it_server: strIcon.insert(nPos, "Srv"); break;
      case it_client: strIcon.insert(nPos, "Cln"); break;
      default: break;
      }

      strPath << strIcon;
      psl->SetIconLocation(strPath, 0);

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

      if (SUCCEEDED(hres)) 
		  { 
        wxFileName fnLnk;
        wxString strName = strLinkName + ".lnk";
        fnLnk.Assign(strDesktopPath, strName);

        // Save the link by calling IPersistFile::Save.
        wxString strPath = fnLnk.GetFullPath();
        wchar_t buff[_MAX_PATH];
        wxConvLibc.ToWChar(buff, _MAX_PATH, strPath);
        hres = ppf->Save(buff, true); 
        ppf->Release(); 
      } 
      psl->Release();

      if (FAILED(hres))
        ok = ErrorBox(wxT("Impossibile creare l'icona del collegamento: eseguire l'installazione come amministratore"));
    } 
    CoUninitialize();
  }

  return ok;
}


//-------------------------------------------
//  ..per i servers di Campo
//-------------------------------------------
bool CampoSetup::StopLurch() const
{
  const wxString strExecService = "Servers/SSAservice -stop";
  return wxExecute(strExecService, wxEXEC_SYNC) > 0;
}

bool CampoSetup::StartLurch(const wxString& strPrgLocPath) const
{
  const wxString strExecService = strPrgLocPath + "Servers/SSAservice -start";
  return wxExecute(strExecService) > 0;
}

bool CampoSetup::CreateAutostartLurch(const LurchMode iSrvAutostartMode, const wxString& strPath)
{
  if (LurchRunning())
    StopLurch();

  const wxString strCreateService = "Servers/SSAservice -install";
  return wxExecute(strCreateService) > 0;
}


//----------------------------------------------------------------
// Metodi di utility per i vari tipi di aggiornamento
//----------------------------------------------------------------
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.Mid(2, 4) == "inst")
    return -1;
  if (strName2.Mid(2, 4) == "inst")
    return 1;

  return strName1.CompareTo(strName2);
}

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

//metodo per aggiornare il modulo SY in install.ini
void CampoSetup::UpdateInstallIni(const wxString strSourcePath, const wxString strDestPath, const wxString& strModule) const
{
  for (int j = 0; j < 2; j++)
  {
    wxString strParagraph = strModule;
    if (j > 0)
      strParagraph << j;
    CampoIniFile InstallIniSource(strSourcePath, strParagraph);
    CampoIniFile InstallIniDest(strDestPath, strParagraph);

    wxString strWrk;
    long nIndex;
    for (bool ok = InstallIniSource.GetFirstEntry(strWrk, nIndex); ok; ok = InstallIniSource.GetNextEntry(strWrk, nIndex))
    {
      InstallIniDest.Set(strWrk, InstallIniSource.Get(strWrk));
    }
  }
}

bool CampoSetup::UnzipModule(const wxString& strPrgLocPath, const wxString& strSrc, const wxString& strModule) const
{
  bool ok = false;
  wxArrayString asFilesList;
  size_t uFilesToCopy = 0;
  //..contando anche quanti sono e memorizzandoli in un array asFileList
  if(wxDir::Exists(strSrc))
  {
    uFilesToCopy = wxDir::GetAllFiles(strSrc, &asFilesList, strModule+"*.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
      UpdateInstallIni(strWrk, strPrgLocPath + "/install.ini", strModule);
    }
  }

  //Adesso puo' far ripartire il server di chiavi
  if (strModule == "sr" && LurchWasRunning())
    StartLurch(strPrgLocPath);

  return uFilesToCopy > 0;
}

bool CampoSetup::CopyFilesAndDirs(const wxString& FilesListI, wxString strFileCurr, const bool bIni) const
{
  bool ok = true;

  //i files .ini vanno trattati con i guanti (se esistono gi<67> non vanno copiati!!!)
  //parte da eseguire solo in caso sia indicata la trattazione degli ini (bIni true)
  if (bIni)
  {
    strFileCurr.MakeLower();  //minuscolizzazione di sicurezza
    const wxFileName strFileName(strFileCurr);
    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())
        ok = false;
    }
  }

  if (ok)
    ok = CopiaFile(FilesListI, strFileCurr);

  return ok;
}

//metodo per copiare una directory e tutti i files che contiene
void CampoSetup::CopyDir(const wxString& strSourceDir, const wxString& strDestDir) const
{
  if (wxDir::Exists(strSourceDir))
  {
    wxArrayString asFilesList;
    const size_t uFilesToCopy = wxDir::GetAllFiles(strSourceDir, &asFilesList, "*.*");
    const size_t uFrom = strSourceDir.Len();
    for (size_t i = 0; i < uFilesToCopy; i++)
    {
      wxString strFileDest = strDestDir + asFilesList[i].Mid(uFrom);
      CopiaFile(asFilesList[i], strFileDest);
    }
  }
}

//metodo per accoppare tutti i files di una directory
void CampoSetup::EmptyOutDir(const wxString& strDir) const
{
  if (wxFileName::DirExists(strDir))
  {
    wxArrayString asFilesList;
    const size_t uFilesToKill = wxDir::GetAllFiles(strDir, &asFilesList, "*.*");
    for (size_t i = 0; i < uFilesToKill; i++)
      ::wxRemoveFile(asFilesList[i]);
  }
}


//-----------------------------------------------------
//  METODI BASSO LIVELLO PER AGGIORNAMENTI NON STANDARD
//-----------------------------------------------------
//----------------------------
//  1) AGGIORNAMENTO CLIENT
//----------------------------
//Aggiornatore client. Copia i files del programma da una directory remota su un server campo nella directory...
//...locale di campo
int CampoSetup::ClientUpdateModule(const wxString& strLocalPath, const wxString& strRemotePath, const wxString strModule) const
{
  int nLocVer, nLocPatch, nRemVer, nRemPatch;
  {
    CampoIniFile iniLocalInstall(strLocalPath + "/install.ini", strModule);
    nLocVer = iniLocalInstall.GetInt("Versione");
    nLocPatch = iniLocalInstall.GetInt("Patch");

    CampoIniFile iniRemoteInstall(strRemotePath + "/install.ini", strModule);
    nRemVer = iniRemoteInstall.GetInt("Versione");
    nRemPatch = iniRemoteInstall.GetInt("Patch");
  }
  int cmp = nLocVer - nRemVer;
  if (cmp == 0)
    cmp = nLocPatch - nRemPatch;

  //il client e' piu' indietro e quindi va aggiornato!
  if (cmp < 0)
  {
    bool bOk = true;

    CampoProgressDialog pi("Aggiornamento elenco files dal server...", 100, m_pWizard); 
    
    wxArrayString asGroups;
    {
      wxString strGroup;
      long nIndex;
      CampoIniFile iniRemoteInstall(strRemotePath + "/install.ini", "");
      for (bool ok = iniRemoteInstall.GetFirstGroup(strGroup, nIndex); ok; ok = iniRemoteInstall.GetNextGroup(strGroup, nIndex))
      {
        if(strGroup.Len() > 2 && strGroup.StartsWith(strModule))
          asGroups.Add(strGroup);
      }
    }

    //controlla tutti i sottomoduli del modulo [sy1],[sy2]...
    for (size_t i = 0; i < asGroups.GetCount() && bOk; i++)
    {
      const wxString& strParagraph = asGroups[i];
      CampoIniFile iniRemoteInstallModule(strRemotePath + "/install.ini", strParagraph);

      //install.ini locale che deve essere aggiornato durante la copia dei files!
      CampoIniFile iniLocalInstall(strLocalPath + "/install.ini", strParagraph);

      //ogni file dell'elenco del sottomodulo corrente va copiato
      for (int j = 0;; j++)
      {
        pi.Pulse(); //magica barra modello supercar!

        const wxString strVarName = wxString::Format("File(%d)", j);
        wxString strCurrFile = iniRemoteInstallModule.Get(strVarName);
        if (strCurrFile.IsEmpty())
           break;

        strCurrFile = strCurrFile.BeforeFirst('|');
   
        const wxString strSrcPath = strRemotePath + "/" + strCurrFile;
        const wxString strDstPath = strLocalPath + "/" + strCurrFile;

        //copia il file remoto di origine sul file locale di destinazione (overwrite=true di default)
        if (!CopiaFile(strSrcPath, strDstPath))
        {
          wxString strError;
          strError += "\nAssicurarsi che il client locale di ";
          strError += APPNAME;
          strError += " non sia in funzione.\n";
          strError += "Assicurarsi che il server di ";
          strError += APPNAME;
          strError += " sia in funzione e raggiungibile in rete.\n";
          strError += "Aggiornamento interrotto!";
          ErrorBox(strError);
          bOk = false;
          break;
        }

        //se ci sono zip deve scompattarli (per ora esiste solo res.zip)
        if (strCurrFile.EndsWith("res.zip")) // Non confonderti con dninst.zip
        {
          UnzipFile(strDstPath, strLocalPath + "/res");
        }

        //se riesce la copia del file aggiorna l'install.ini sul file (se non lo facesse non comparirebbero...
        //...eventuali nuovi files
        iniLocalInstall.Set(strVarName, strCurrFile);

      } //for(int j...

      //una volta termiata la copia dei files del sottmodulo[i] scatta l'aggiornamento dell'install.ini locale...
      //...al livello versione/patch appena copiate sempre del sottomodulo[i]
      iniLocalInstall.Set("Versione", nRemVer);
      iniLocalInstall.Set("Patch", nRemPatch);

    } //for(int i...

    //una volta termiata la copia dei files dell'intero modulo scatta l'aggiornamento dell'install.ini locale al..
    //..livello versione/patch appena copiate
    CampoIniFile iniLocalInstall(strLocalPath + "/install.ini", strModule);
    iniLocalInstall.Set("Versione", nRemVer);
    iniLocalInstall.Set("Patch", nRemPatch);

  } //if(cmp<0...

  return cmp;
}


//----------------------------
//  2) AGGIORNAMENTO DA DISCO
//----------------------------
//Aggiornatore da disco. Copia i files delle patch da una directory su disco in una directory di appoggio...
//...temporanea dove esegue lo scompattamento con destinazione la directory locale
bool CampoSetup::DiskUpdateModule(const wxString& strLocalPath, const wxString& strDiskPath, const wxString strModule) const
{
  //puo' chiamare direttamente il metodo che scompatta tutte le patch del modulo a partire dal pacco iniziale...
  //...fino all'ultima;il metodo le ordina gi<67> in modo crescente di numero d'ordine
  return UnzipModule(strLocalPath, strDiskPath, strModule);
}

//-------------------------------
//  3) AGGIORNAMENTO DA INTERNET
//-------------------------------
bool CampoSetup::HTTPGet(const wxString& strLocalPath, const wxString& strWebSite) const
{
  wxString strWebPath = strWebSite;
  if (strWebPath.StartsWith("http://"))
    strWebPath.Remove(0, 7);
  int nSlash = strWebPath.First('/');
  wxString strServer = strWebPath.Left(nSlash);
  wxString strPath = strWebPath.Mid(nSlash);

  wxHTTP http;
  //connessione al server web con le patch
  if (http.Connect(strServer))
  {
    wxInputStream* pStream = http.GetInputStream(strPath);
    if (pStream != NULL)
    {
      //compila un file di testo temporaneo con l'elenco dei files che trova sul server
      wxFileOutputStream fos(strLocalPath);
      fos.Write(*pStream);
      delete pStream;
      return true;
    }
  }
  return false;
}

//Aggiornatore via web. Copia i files delle patch da una directory web remota in una directory di appoggio...
//...temporanea dove esegue lo scompattamento con destinazione la directory locale
bool CampoSetup::InternetUpdateModule(const wxString& strLocalPath, const wxString& strWebPath, const wxString strModule) const
{
  bool ok = false;
  int nLocVer = 20911000, nLocPatch = 100; // Fingo la versione 10.0
  {
    CampoIniFile iniLocalInstall(strLocalPath + "/install.ini", strModule);
    nLocVer = iniLocalInstall.GetInt("Versione");
    nLocPatch = iniLocalInstall.GetInt("Patch");
  }

  //Svuota,elimina e ricrea una directory temporanea di appoggio ove mettere i files delle patch da scompattare
  //E' necessaria questa operazione per non trovarsi ancora files di vecchie patch parcheggiati nella dir!
  const wxString strTempDir = wxFileName::GetTempDir() + "/setup/";
  if (wxDir::Exists(strTempDir))
  {
    EmptyOutDir(strTempDir);    //deve svuotare la directory dai files per poterla eliminare!!!
    ::wxRmdir(strTempDir);  //elimina la dir adesso vuota
  }
  CheckAndMakeDir(strTempDir, wxEmptyString);   //la ricrea con i permessi dell'utente windows corrente!!

  const wxString strTempFile = strTempDir + "httpdir.txt";
  if (HTTPGet(strTempFile, strWebPath))
  {
    //partendo dal file temporaneo ne compila un secondo con i soli nomi dei file validi da scaricare
    //i criteri di selezione sono il nome del modulo ed il livello patch
    wxTextFile tfFilesList;
    if (tfFilesList.Open((strTempFile)))
    {
      CampoProgressDialog pi("Aggiornamento elenco files dal server...", (int)tfFilesList.GetLineCount(), m_pWizard); 
      for (wxString strWrk = tfFilesList.GetFirstLine(); !tfFilesList.Eof(); strWrk = tfFilesList.GetNextLine())
      {
        int nPos = strWrk.Find("href");
        if (nPos > 0)
        {
          wxString strHref = strWrk.Mid(nPos + 5, 16);
          strHref = strHref.AfterFirst('"');
          strHref = strHref.BeforeLast('"');
          
          if (!pi.Update((int)tfFilesList.GetCurrentLine(), strHref))
            break;

          //lavora solo con i files del modulo in questione
          if (strHref.StartsWith(strModule))
          {
            const wxString strExt = strHref.Right(4).Lower();
            if (strExt!=".ini" && strExt!=".zip")
              continue;

            const wxString strPatch = strHref.Mid(2, 4).Lower();
            //  1) e' un pacco
            //se e' un pacco devo sapere se e' piu' recente della installazione corrente (potrebbe essere un pacco nuovo..
            //..ricompattato) oppure se e' piu' vecchio e non va toccato (e' ad esempio il pacco originale)
            if (strPatch == "inst")
            {
              if (strExt == ".ini")  //operazioni sull'ini x sapere versione e patch
              {
                HTTPGet(strTempDir+strHref, strWebPath+strHref);
                CampoIniFile iniInst(strTempDir+strHref, strModule);
                const int nRemoteVer = iniInst.GetInt("Versione");
                const int nRemotePatch = iniInst.GetInt("Patch");

                //se deve aggiornarsi con il pacco scarica pure lo zip cosi' e' a posto
                if ((nRemoteVer > nLocVer) || ((nRemoteVer == nLocVer) && (nRemotePatch > nLocPatch)))
                {
                  const int nDot = strHref.Find('.', true);
                  strHref = strHref.Left(nDot) + "1.zip";
                  HTTPGet(strTempDir+strHref, strWebPath+strHref);
                }
                else  //se non deve aggiornarsi elimina l'ini in modo da non avere una mezza patch che farebbe incazzare l'unzipper
                  wxRemoveFile(strTempDir+strHref);
              } //if(strHref.EndsWith("ini")...
            } //if(strPatch == "inst")...
            //  2) e' una patch
            else  //se invece e' una normale patch... else di if(strPatch=="inst"..
            {
              //controlla che sia pi<70> avanti del suo livello patch e che sia un file utile (servono solo .ini e .zip)
              if (atoi(strPatch) > nLocPatch)
                HTTPGet(strTempDir+strHref, strWebPath+strHref);
            }  
          } //if(strHref.StartsWith(strModule))...
        } //if(nPos>0)...
      } //for(wxString strWrk = tf...
      //chiude il file temporaneo
      tfFilesList.Close();
    } //if(tfFilesList...
    
    //scompatta le patch di sistema e aggiorna l'install.ini locale
    ok = UnzipModule(strLocalPath, strTempDir, strModule);
  } //if(HTTPGet(...
  return ok;
}

//-----------------------------------------------------
//  METODI ALTO LIVELLO PER AGGIORNAMENTI NON STANDARD
//-----------------------------------------------------
//---------------------------------------------------------------
// 1) metodo per l'aggiornamento dei client di rete in automatico
//---------------------------------------------------------------
void CampoSetup::ClientUpdate()
{
  wxFileName fn(GetSetupDir());
  fn.AppendDir("..");
  fn.MakeAbsolute();
  fn.SetFullName("install.ini");
  const wxString strLocalPath = fn.GetPath();

  wxString strRemotePath;
  {
    CampoIniFile iniLocalInstall(fn.GetFullPath(), "Main");
    strRemotePath = iniLocalInstall.Get("DiskPath");
  }

  ClientUpdateModule(strLocalPath, strRemotePath, "sy");

  wxSetWorkingDirectory(strLocalPath);
  wxExecute("ba1 -6 /uADMIN");
}

//-----------------------------------------------------------------------------------------------
// 2) metodo per l'aggiornamento da disco attraverso il menu di Manutenzione/Installazione moduli
//-----------------------------------------------------------------------------------------------
void CampoSetup::DiskUpdate()
{
  wxFileName fn(GetSetupDir());
  fn.AppendDir("..");
  fn.MakeAbsolute();
  fn.SetFullName("install.ini");
  const wxString strLocalPath = fn.GetPath();

  wxString strRemotePath;
  {
    CampoIniFile iniLocalInstall(fn.GetFullPath(), "Main");
    strRemotePath = iniLocalInstall.Get("DiskPath");
  }

  //aggiornamento dei moduli SY ed SR da disco
  //il modulo SY va aggiornato comunque
#ifndef NDEBUG
  strRemotePath = "c:/campo12/cd/program/";
  DiskUpdateModule(strLocalPath, strRemotePath, "sc");
#else
  DiskUpdateModule(strLocalPath, strRemotePath, "sy");
  //il modulo SR va aggiornato solo se usato (si sta aggiornando il cpu con il gestore delle chiavi)
  if (m_bLurchWasRunning)
    DiskUpdateModule(strLocalPath, strRemotePath, "sr");
#endif

  wxSetWorkingDirectory(strLocalPath);
  wxExecute("ba1 -6 /uADMIN");
}

//----------------------------------------------------------------------------------------
// 3) metodo per l'aggiornamento via internet attraverso Manutenzione/Installazione moduli
//----------------------------------------------------------------------------------------
void CampoSetup::InternetUpdate()
{
  //install.ini locale dove setup.exe e' in esecuzione
  wxFileName fn(GetSetupDir());
  fn.AppendDir("..");
  fn.MakeAbsolute();
  fn.SetFullName("install.ini");
  const wxString strLocalPath = fn.GetPath();

  //quale e' il path web da cui aggiornarmi?
  wxString strRemotePath;
  {
    //Install.ini locale da cui leggere il path di dove sta il mio server web
    CampoIniFile iniLocalInstall(fn.GetFullPath(), "Main");
    strRemotePath = iniLocalInstall.Get("WebPath");
  }

  //aggiornamento dei moduli SY e SR via web
  //il modulo SY va aggiornato comunque
  InternetUpdateModule(strLocalPath, strRemotePath, "sy");
  //il modulo SR va aggiornato solo se usato (si sta aggiornando il cpu con il gestore delle chiavi)
  if (m_bLurchWasRunning)
    InternetUpdateModule(strLocalPath, strRemotePath, "sr");

  //lanciare ba1.exe -6 in uscita
  wxSetWorkingDirectory(strLocalPath);
  wxExecute("ba1 -6 /uADMIN");
}

//--------------------------------------------------------------------------
//metodo per tutte le installazioni e gli aggiornamenti automatici in locale
//--------------------------------------------------------------------------
void CampoSetup::NormalSetup()
{
  //creazione del CampoWizard, ovvero dell'insieme di finestre per gestire installazione/aggiornamento
  m_pWizard = new CampoWizard(m_pMainFrame);

  if (m_pWizard->Run())
  {
    //e' una DEMO o una versione normale?
    const bool bInstallDemoVersion = m_pWizard->GetInstDemoVersion();


    // 1) RACCOLTA PARAMETRI GENERALI INSTALLAZIONE (tipo,path,cartelle,servers,...)
    //------------------------------------------------------------------------------
    //tipo di installazione/aggiornamento
    const InstallationType uInstallationType = m_pWizard->GetInstallationType();
    const bool bNewInstallation = uInstallationType != it_upgrade;
    //installazione servers? solo per server di campo
    const bool bInstallLurch = uInstallationType == it_server && (m_pWizard->GetInstUseAuth() || m_pWizard->GetInstUseDict()) && (!bInstallDemoVersion);
    //uso servers? sarebbe solo per i client ma lo teniamo buono per tutti
    const bool bUseLurch = uInstallationType != it_server && (!m_pWizard->GetSrvAuth().IsEmpty() || !m_pWizard->GetSrvDict().IsEmpty()) && (!bInstallDemoVersion);
    //installazione datidemo? (oddio speriamo di no!; comunque vale solo per installazione standard)
    const bool bInstallDemoData = uInstallationType == (it_standalone && m_pWizard->GetInstDemoData()) || (bInstallDemoVersion);
    //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)
      //un client NON installa i dati!! (senno' e' una installazione locale semplice)
      if (uInstallationType != it_client)
        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(GetSetupDir(), "*.*");
    strSourcePath.AppendDir("..");
    strSourcePath.AppendDir("..");
    strSourcePath.AppendDir("campo"); // NOME fisso della cartella del CD, non mettere APPNAME
    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);

    const size_t nPathLenght = strSrc.Len();
    //progress bar
    CampoProgressDialog pi("Installazione Dati e Programmi di base...", (int)uFilesToCopy, m_pWizard);
    
    for (size_t i = 0; i < uFilesToCopy; i++)
    { 
      //per ogni file da copiare controlla i path sorgente e destinazione(problema con sottodirectory tipo..
      //..dati); strFileCurr va lasciato qui perche' DEVE ESSERE AZZERATO ad ogni cambio file!!!!!!
      wxString strFileCurr;

      //controlla se il file corrente e' dentro una sottodirectory (tipo dati,servers,ecc...) oppure e' al..
      //..primo livello (quindi e' un file di programma)
      wxString strSourceFile = asFilesList[i].Lower();
      NormalizeSlash(strSourceFile);

      //e' in una subdir se la lunghezza del suo path prima dell'ultimo '/' e' > della lunghezza del path di root
      const bool bIsSubDir = strSourceFile.Find('/', true) > (int)nPathLenght;

      //2A) files con subdirectory
      if (bIsSubDir)
      {
        //files dei dati standard! solo in caso di nuova installazione!! E NON installazione DEMO!!
        if (strSourceFile.Find("/dati/") > 0)
        {
          //i DATI NON VANNO MAI installati in caso di aggiornamento!!!
          //i DATI NON VANNO MAI installati in caso di installazione client!!!
          //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' gi<67> stato il controllo nella Forward della pagina di selezione, quindi la cartella..
          //..di destinazione e' comunque vuota
          if (bNewInstallation && uInstallationType != it_client && !bInstallDemoData)
          {
            strFileCurr = strDataPath;
            strFileCurr += asFilesList[i].Mid(nPathLenght + 5);
            //Ulteriore controllo di sicurezza: se trova il file di destinazione gi<67> presente..
            //..NON lo sovrascrive (lo mette vuoto cosi' non lo copia)
            if (wxFileName::FileExists(strFileCurr))
              strFileCurr = "";
          }
          else
            strFileCurr = "";

        } else
        if (strSourceFile.Find("/datidemo/") > 0)
        {
          //i DATIDEMO vanno copiati solo in caso di installazione DEMO o di installazione standalone con specifica..
          //richiesta di installazione DATIDEMO
          if (bInstallDemoData)
          {
            strFileCurr = strDataPath;
            strFileCurr += asFilesList[i].Mid(nPathLenght + 9);
            if (wxFileName::FileExists(strFileCurr))
              strFileCurr = "";
          }
          else
            strFileCurr = "";

        } else
        if (strSourceFile.Find("/servers/") > 0) //che fare con i servers? copiare la directory...
        {
          if (bInstallLurch && !bInstallDemoVersion)  //..ma solo se devi installare i servers
          {
            strFileCurr = strPrgLocPath;
            strFileCurr += "/servers";
            strFileCurr += asFilesList[i].Mid(nPathLenght + 8);
          }
          else
            strFileCurr = "";
        }
        else  //files vari di altre subdirectory che si installano sempre (es. recdesc)
        {
          strFileCurr = strPrgLocPath;
          strFileCurr += asFilesList[i].Mid(nPathLenght);
        }
      }
      //2B) files senza subdirectory (programmi!)
      else
      {
        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())
      {
        //aggiorna la progind
        if (!pi.Update((int)i, asFilesList[i]))
          break;
        //normalizza per sicurezza il nome (completo di path) del file (visto che ci sono metodi cui piace..
        //..aggiungere / o \ a piacere..
        NormalizeSlash(strFileCurr);

        //eventuali sottodirectory le crea (solo se hanno un nome) e poi copia fisicamente i files
        //se un file non si copia interrompe l'installazione con un ErrorBox
        if (!CopyFilesAndDirs(asFilesList[i], strFileCurr, true))
          break;
      } //if (!strFileCurr.IsEmpty()..
    } //for(size_t...
 
    UpdateInstallIni(strSrc + "/install.ini", strPrgLocPath + "/install.ini", "sy");
    if (bInstallLurch)
      UpdateInstallIni(strSrc + "/install.ini", strPrgLocPath + "/install.ini", "sr");


    // 3) COPIA DELLA CARTELLA SETUP DA CD (PROGRAM\SETUP) A CARTELLA DI DESTINAZIONE
    //-------------------------------------------------------------------------------
    //Funziona tutto come al punto 2)! Cambiano solo i path (sorgente = program\setup, destinazione = destdir\setup)
    wxArrayString asSetupFilesList;
    wxFileName fnSetupSourcePath(GetSetupDir(), "*.*");
    fnSetupSourcePath.MakeAbsolute();

    const wxString strSetupSrc = fnSetupSourcePath.GetPath();
    const wxString strSetupDst = strPrgLocPath + "/setup";

    const size_t uSetupFilesToCopy = wxDir::GetAllFiles(strSetupSrc, &asSetupFilesList);
    const size_t nSetupPathLenght = strSetupSrc.Len();
    CampoProgressDialog po(_("Copia cartella Setup..."), (int)uSetupFilesToCopy, m_pWizard);
    
    wxString strFileCurr;
    
    for (size_t i = 0; i < uSetupFilesToCopy; i++)
    {
      wxString strSourceFile = asSetupFilesList[i].Lower();
      NormalizeSlash(strSourceFile);
      strFileCurr = strSetupDst;
      strFileCurr += asSetupFilesList[i].Mid(nSetupPathLenght);

      if (!strFileCurr.IsEmpty())
      {
        if (!po.Update((int)i, asSetupFilesList[i]))
          break;
        NormalizeSlash(strFileCurr);

        if (!CopyFilesAndDirs(asSetupFilesList[i], strFileCurr, true))
          break;
      }
    }

    // ?) 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();
      CampoProgressDialog pi("Installazione Dati Demo...", (int)uFilesToCopy, m_pWizard);      
      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())
        {
          //eventuali sottodirectory le crea (solo se hanno un nome) e poi copia fisicamente i files
          //se un file non si copia interrompe l'installazione con un ErrorBox
          if (!CopyFilesAndDirs(asDataList[i], strFileCurr, false))
            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(); // 3 o 4 dopo la morte delle chiavi hw
        CampoIniMain.Set("Donglehw", uDongleType);
        CampoIniMain.Set("Study", strDataPath);
        CampoIniMain.Set("Firm", "com");
        //server,client o standalone?
        CampoIniMain.Set("Type", uInstallationType);
      }
      //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...
    else  //e' un aggiornamento! scrive il type
    {
      CampoIniFile CampoIniMain(strPrgLocPath + "/campo.ini", "Main");
      //SOLO se sta aggiornando una versione antecedente alla 10.0 scrive la variabile Type nel campo.ini..
      //..ovvero deve testare se Type = 0
      if (CampoIniMain.GetInt("Type") == 0)
        CampoIniMain.Set("Type", CampoIniMain.GetInstallationType());
    }


    // 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 == it_client) //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)
      {
        const wxString strSrc = GetSourceDir("program");
        CampoInstall.Set("DiskPath", strSrc);
      }
    }
    

    // 6) AGGIORNAMENTO DI ADMIN.INI CON IL TEMA DEL RESELLER
    //---------------------------------------------------------
    //carica il tema predefinito del reseller dentro l'admin.ini che sta in cartella programmi\dati\config..
    //..in modo da vederli subito quando lancer<65> ba1 (e successivamente ba0)
    if (bNewInstallation)
    {
      //file sorgente
      const wxString strThemeFileName = Theme();
      wxString strSrcThemePath = GetSetupDir();
      strSrcThemePath << strThemeFileName;
      CampoIniFile CampoTheme(strSrcThemePath, "Standard");

      //file di destinazione
      CampoIniFile CampoDestAdmin(strDataPath + "/config/admin.ini", "Colors");

      //copia del tema standard nell'admin.ini di destinazione
      long nIndex;
      wxString strKey;
      //ciclo su tutte le variabili del paragrafo di origine
      for (bool ok = CampoTheme.GetFirstEntry(strKey, nIndex); ok; ok = CampoTheme.GetNextEntry(strKey, nIndex))
      {
        //copia nel corrispondente paragrafo di destinazione
        CampoDestAdmin.Set(strKey, CampoTheme.Get(strKey));
      }
    }


    // 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 di SY ed SR in install.ini
    const wxString strPrgCDPath = GetSourceDir("program");
    if (wxFileName::DirExists(strPrgCDPath))
    {
      const wxString strSetupCDPath = strPrgCDPath + "/setup";
      const wxString strSetupLocPath = strPrgLocPath + "/setup";
      //Procedura di salvataggio del corrente OEM (reseller) del prg gi<67> installato; in questo modo anche..
      //..mandando un CD AGA (che generalmente funziona!) ad un cliente di un distributore non AGA, il reseller..
      //..a video non cambia. Per cambiare reseller si dovr<76> intervenire a mano sull'oem.ini cambiando il valore..
      //..di OEM dopo l'installazione
      const wxString strOemLocPath = strSetupLocPath + "/oem.ini";
      CampoIniFile CampoIniOem(strOemLocPath, "MAIN");
      const int nOldOem = CampoIniOem.GetInt("OEM");
      //svuota proprio la directory setup in modo da non coservare files indesiderati
      EmptyOutDir(strOemLocPath);
      //copia la directory setup da CD a locale
      CopyDir(strSetupCDPath, strSetupLocPath);
      //rimette a posto la candela...cio<69>, il reseller
      CampoIniOem.Set("OEM", nOldOem);
      //..Fine dell'aggiornamento della cartella setup

      //scompattamento dei moduli e delle patch che eventualmente trova su CD per quanto riguarda i moduli SY..
      UnzipModule(strPrgLocPath, strPrgCDPath, wxString("sy"));
      //..ed SR ma solo se richiesto in fase di installazione
      if (bInstallLurch)
        UnzipModule(strPrgLocPath, strPrgCDPath, wxString("sr"));
    }


    // 8) CREAZIONE AUTOSTART DEI SERVERS (SE CI SONO)
    // ------------------------------------------------
    // Se sta installando Campo in postazione server e deve installare un gestore di servizi,
    // avvia la procedura della creazione dell'autostart(un casino). 
    // Questa procedura non puo' valere per l'aggiornamento, che agisce in modo diverso
    if (bNewInstallation)
    {
      const LurchMode iSrvAutostartMode = m_pWizard->GetSrvAutostartMode();
      if (iSrvAutostartMode != lm_none)
        CreateAutostartLurch(iSrvAutostartMode, strPrgLocPath);
    }


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

      CampoIniFile CampoIniMain(strPrgLocPath + "/campo.ini", "Main");
      InstallationType nInstType = CampoIniMain.GetInstallationType();
      
      wxString strLnk = Product();
      switch (nInstType)
      {
      case it_server: strLnk += " (Server)"; break;
      case it_client: strLnk += " (Client)"; break;
      default: break;
      }

      //crea comunque l'icona
      CreateIcon(CSIDL_COMMON_DESKTOPDIRECTORY, strExe, strLnk);
    }


    // 10) 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);
        const wxString strPath = CampoStp.Get("Program");
        if (strPath.IsEmpty() || strPath.CmpNoCase(strPrgLocPath) == 0)
        {
          CampoStp.Set("Program", strPrgLocPath);
          break;
        }
      }
    }
    

    // 11) CHIUDE IL SETUP LANCIANDO BA1 -6 PER INSTALLAZIONE MODULI
    //-------------------------------------------------------------
    //lanciare ba1.exe -6 in uscita
    if (wxSetWorkingDirectory(strPrgLocPath))
      wxExecute("ba1 -6 /uADMIN");
    else
      ErrorBox("Impossibile installare i moduli: cartella di destinazione irraggiungibile!");


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

//------------------------------------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////////
//  Metodi per il controllo preventivo di eventuali cazzate in procinto di accadere
////////////////////////////////////////////////////////////////////////////////////

bool CampoSetup::SystemRunning(const wxString& strAppName, wxString strMsg) const
{
  strMsg.Replace(wxT("PRODUCT"), PRODUCT);
  strMsg += "\nSi desidera ritentare?";

  bool bRunning = false;
  bool bRetry = true;
  while (bRetry)
  {
    int i;
    for (i = 10; i > 0 && FindProcessId(strAppName); i--)
      wxSleep(1);

    bRetry = false;
    bRunning = i <= 0;
    if (bRunning && !strMsg.IsEmpty())
    {
      bRetry = YesNoBox(strMsg);
    }
  }

  return bRunning;
}


int CampoSetup::LurchRunning() const
{
  //cerca SSAservice che funziona come servizio
  int run = 0;
  if (SystemRunning("SSAservice", wxEmptyString))
    run |= 1;
  if (!run)
  {
    //...se non lo trova cerca il solo Authoriz come programma...
    if (SystemRunning("Authorization", wxEmptyString))
      run |= 2;
  }
  return run;
}


bool CampoSetup::CampoIsRunning() const
{
  //ricerca di campo.aut per avere la lista dei moduli
  //prima tenta con aggiornamento da disco...
  wxString strInstallPath = "../install.ini";
  //...poi con aggiornamento da CD
  if (!wxFileName::FileExists(strInstallPath))
    strInstallPath = "../../campo/install.ini";
 
  //fa un giro sull'install.ini alla ricerca di tutti i moduli (sono i paragrafi lunghi 2) installati (se aggiornamento..
  //..da disco) o da installare (se sta installando da CD)
  wxArrayString asModuli;
  if (wxFileName::FileExists(strInstallPath))
  {
    wxString strModulo;
    long nIndex;
    CampoIniFile iniInstall(strInstallPath, strModulo);
    for (bool ok = iniInstall.GetFirstGroup(strModulo, nIndex); ok; ok = iniInstall.GetNextGroup(strModulo, nIndex))
    {
      if (strModulo.Len() == 2)
        asModuli.Add(strModulo);  //aggiunge all'array tutti i moduli che trova in install.ini
    }
  }
  else  //non trova nessun install.ini (non dovrebbe mai accadere) e tenta i moduli pi<70> importanti
  {
    asModuli.Add("ba");
    asModuli.Add("cg");
    asModuli.Add("ve");
  }
  
  //scandisce l'array dei moduli alla ricerca di un eventuale programma di campo ancora running a sua insaputa
  wxString strAppName;
  for (size_t i = 0; i < asModuli.GetCount(); i++)
  {
    for (size_t j = 0; j <= 9; j++)
    {
      strAppName = asModuli[i];
      strAppName += ('0'+j);
      wxSingleInstanceChecker sicProgram(strAppName);
      if (sicProgram.IsAnotherRunning())
      {
        strAppName << " <20> in esecuzione! E' necessario terminarlo utilizzando la Gestione Attivit<69> di Windows.";
        ErrorBox(strAppName);
        return true;
      }

    }
  }
  return false; //campo non sta andando
}

//metodo principale che sceglie la modalit<69> di lancio del programma
void CampoSetup::OnTimer(wxTimerEvent& WXUNUSED(e))
{
  //controllo di un eventuale setup gi<67> lanciato (tipico di utonti e della premiata ditta bib<69> & bib<69>)
   wxSingleInstanceChecker sicSetup("SetCmpUp");
   if (sicSetup.IsAnotherRunning())
   {
      wxString msg;
      msg << "Un'installazione di " << PRODUCT << " <20> gi<67> in esecuzione!";
      ErrorBox(msg);
      m_pMainFrame->Destroy();
     return;
   }

  //controllo di eventuali Campo o servers attivi e conseguente interruzione dell'installazione
  m_bLurchWasRunning = LurchRunning() != 0;
  if (m_bLurchWasRunning)
  {
    wxString msg;
    msg << "Per poter aggiornare/installare il programma " << PRODUCT   
        << " deve temporaneamente essere disattivato il gestore delle licenze!\n"
        << "Prima di disattivare il gestore delle licenze accertarsi che tutti gli utenti spengano il programma!!\n"
        << "Proseguire con la disattivazione?";
    if (YesNoBox(msg))
      StopLurch();
    else
    {
      m_pMainFrame->Destroy();
      return;
    }
  }

  if (SystemRunning("ba0", "Uscire dal programma PRODUCT prima di procedere con l'aggiornamento/installazione!") ||
      SystemRunning("ba1", "Uscire dal programma di manutenzione di PRODUCT\n prima di procedere con l'aggiornamento/installazione!"))
  {
    m_pMainFrame->Destroy();
    return;
  }

  if (CampoIsRunning())
  {
    wxString msg;
    msg << "Un applicativo di " << PRODUCT << " <20> ancora in esecuzione!\n"
        << "L'installazione sar<61> interrotta immediatamente";
    ErrorBox(msg);
    m_pMainFrame->Destroy();
    return;
  }

  //path del programma setup.exe in esecuzione; serve in seguito in quanto alcuni metodi (tipo la GetAllFiles)..
  //..fanno perdere questo path
  //attenzione!!! il path DEVE terminare con "\" senn<6E> in base al tipo di chiamata (-uw,-uc,-ud) i rispettivi..
  //..metodi funzionano a casaccio!!!
  const wxString strCommand = argv[1];

  if (strCommand.IsEmpty())
  {
    TCHAR strFileName[260];
    ::GetModuleFileName(NULL, strFileName, 260);
   
    wxFileName strPath(strFileName);
    strPath.MakeAbsolute();
    m_strSetupPath = strPath.GetPath();
    if (!m_strSetupPath.EndsWith(wxT("\\")))
      m_strSetupPath << '\\';

    wxSetWorkingDirectory(m_strSetupPath);

    //installazione normale da CD
    NormalSetup();
  }
  else
  {
    //attenzione: modifica richiesta perch<63> la cartella di esecuzione di setup <20> diversa nel caso sia un..
    //..aggiornamento o una installazione da CD
    m_strSetupPath = wxGetCwd();
    m_strSetupPath.MakeLower();
    if (!m_strSetupPath.EndsWith("setup"))
    { 
      if (!m_strSetupPath.EndsWith(wxT("\\")))
        m_strSetupPath << '\\';
      m_strSetupPath << "setup";
      wxSetWorkingDirectory(m_strSetupPath);
    }
    if (!m_strSetupPath.EndsWith(wxT("\\")))
      m_strSetupPath << '\\';

    //aggiornamento da disco,client,web
    if (strCommand == "-ud")
      DiskUpdate(); else
    if (strCommand == "-uc")
      ClientUpdate(); else
    if (strCommand == "-uw")
      InternetUpdate();
  }
  // 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_pWizard = NULL; //finestra di programma nulla;deve esistere solo per il NormalSetup dove viene inizializzata
  m_pMainFrame = new CampoFrame;
  SetTopWindow(m_pMainFrame);

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