root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/setup/Setup.cpp
luca 8a1a187ba3 Patch level : 
Files correlati     :
Ricompilazione Demo : [ ]
Commento            :


git-svn-id: svn://10.65.10.50/trunk@15576 c028cbd2-c16b-5b4b-a496-9718f37d4682
2007-08-24 13:45:53 +00:00

2370 lines
80 KiB
C++
Executable File
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

//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/radiobox.h>
#include <wx/txtstrm.h>
#include <wx/wfstream.h>
#include <wx/wizard.h>
#ifdef WIN32
#include <shlobj.h>
#endif
extern "C"
{
#include "../xvaga/hlapi_c.h"
#include "../xvaga/skeylink.h"
}
#define HGAP 4
#define VGAP 2
///////////////////////////////////////////////////////////
// Utilities
///////////////////////////////////////////////////////////
bool ErrorBox(const wxString str)
{
wxMessageBox(str, APPNAME, wxOK | wxICON_ERROR);
return false;
}
bool WarningBox(const wxString str)
{
wxMessageBox(str, APPNAME, wxOK | wxICON_EXCLAMATION);
return false;
}
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;
}
class CampoDirCopier : public wxDirTraverser
{
wxString m_strSrc, m_strDst;
protected:
virtual wxDirTraverseResult OnDir(const wxString& dirname);
virtual wxDirTraverseResult OnFile(const wxString& filename);
public:
void RenameDLL(const wxString& strDLL, bool bOpenGL) const;
bool Copy(const wxString& src, const wxString& dst, bool bOpenGL);
};
wxDirTraverseResult CampoDirCopier::OnDir(const wxString& dirname)
{
return wxDIR_CONTINUE;
}
wxDirTraverseResult CampoDirCopier::OnFile(const wxString& filename)
{
wxFileName strSource(filename);
strSource.MakeRelativeTo(m_strSrc);
wxString str = m_strDst;
str += strSource.GetPathSeparator();
str += strSource.GetFullPath();
wxFileName strDest(str);
if (!strDest.DirExists())
strDest.Mkdir();
::wxCopyFile(filename, str);
return wxDIR_CONTINUE;
}
void CampoDirCopier::RenameDLL(const wxString& strDLL, bool bOpenGL) const
{
wxFileName file1(m_strDst, strDLL);
file1.SetExt(bOpenGL ? wxT("dll") : wxT("old"));
if (file1.FileExists())
{
wxFileName file2(file1);
file2.SetExt(bOpenGL ? wxT("old") : wxT("dll"));
wxRename(file1.GetFullPath(), file2.GetFullPath());
}
}
bool CampoDirCopier::Copy(const wxString& src, const wxString& dst, bool bOpenGL)
{
wxBusyCursor hourglass;
m_strSrc = src;
m_strDst = dst;
if (!wxDirExists(m_strDst)) // Utile precauzione
wxMkdir(m_strDst);
wxDir dir(m_strSrc);
dir.Traverse(*this);
RenameDLL(wxT("OpenGL32.dll"), bOpenGL);
RenameDLL(wxT("glu32.dll"), bOpenGL);
return true;
}
#ifdef WIN32
#endif
///////////////////////////////////////////////////////////
// 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();
int Pages() const { return m_nPages; }
CampoWizardPage* Page(int p) const { return m_pPage[p]; }
void OnNext(wxCommandEvent& e);
public:
bool Run();
wxString Get(wxWindowID id) const;
int GetSelection(wxWindowID id) const;
bool GetBool(wxWindowID id) const;
//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, wxEmptyString, strIniPath,
wxCONFIG_USE_GLOBAL_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, 256));
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 la scelta di Aggiornamento / Tipo Installazione */
/**********************************************************************************************************/
class CampoWizardPage2 : public CampoWizardPage
{
wxRadioBox* m_pRadioBox;
protected:
virtual bool ForwardValidate();
public:
CampoWizardPage2(wxWizard* parent);
};
bool CampoWizardPage2::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 Campo");
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);
}
else //resetta il path in caso si scelga nuova installazione dopo aver scelto aggiornamento
{
GetWizard().SetDestinationPath("");
GetWizard().SetDesktopShortcut(true);
}
return true;
}
CampoWizardPage2::CampoWizardPage2(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>Campo</i></b> in un nuovo direttorio.</p>");
asCampi.Add("Nuova installazione"); //voce di nuova installazione!
m_pRadioBox = new wxRadioBox(this, 201, "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>Campo</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>Campo</i></b> su di esse</u></p>");
//radiobutton con le scelte aggiornamento
asCampi.Add("Nuova installazione");
m_pRadioBox = new wxRadioBox(this, 201, "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>Campo</i></b> attiva! ");
strBody += wxT("Terminare quindi le eventuali sessioni di <b><i>Campo</i></b> attive e proseguire.</p>");
SetHTMLText(strTitle, strBody);
GetSizer()->Add(m_pRadioBox);
}
/**********************************************************************************************************/
// 3 Pagina con Accetta / Rifiuta la licenza
//*********************************************************************************************************/
class CampoWizardPage3 : public CampoWizardPage
{
protected:
virtual bool ForwardValidate();
public:
CampoWizardPage3(wxWizard* parent);
};
bool CampoWizardPage3::ForwardValidate()
{
if (GetSelection(301) == 1)
return ErrorBox("Impossibile proseguire se non si accetta la licenza sul software!!");
return true;
}
CampoWizardPage3::CampoWizardPage3(wxWizard* parent) : CampoWizardPage(parent)
{
SetHTMLPage("licenza.htm");
//radiobutton Accetta / Rifiuta
wxArrayString asAccRef;
asAccRef.Add("Accetta");
asAccRef.Add("Rifiuta");
wxRadioBox* radio_box = new wxRadioBox(this, 301, "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);
}
/**********************************************************************************************************/
/* 4 Pagina con la gestione della chiave di protezione */
/**********************************************************************************************************/
class CampoWizardPage4 : public CampoWizardPage
{
int _dongle_type;
wxButton* _butt_HL;
wxButton* _butt_EU;
protected:
DECLARE_EVENT_TABLE();
void OnHLPick(wxCommandEvent& e);
void OnEUPick(wxCommandEvent& e);
int DongleTest();
int ThisYear();
wxString DecodeString(const wxString& data);
int VersionYear();
void BuildKey(char* key);
bool HardlockGarble(unsigned short* data);
unsigned short HardlockLogin(int& year);
void EncodeEutronPassword(char* str);
unsigned short EutronLogin(int& year);
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)
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);
}
///////////////////////////////
// Gestione chiave Hardlock //
///////////////////////////////
bool CampoWizardPage4::HardlockGarble(unsigned short* data)
{
HL_CODE(data, 1);
return true;
}
unsigned short CampoWizardPage4::HardlockLogin(int& year)
{
unsigned short serno = 0xFFFF;
unsigned char REFKEY[16] = "CAMPOKEY";
unsigned char VERKEY[16] = "ìpÙˆ¬cê<";
if (HL_LOGIN(26952, LOCAL_DEVICE, REFKEY, VERKEY) == STATUS_OK)
{
unsigned short eprom[64]; memset(eprom, 0, sizeof(eprom));
HL_READBL((unsigned char*)eprom);
unsigned short data[4];
memcpy(data, eprom, sizeof(data));
HardlockGarble(data);
if (data[0] == 0xFAE8)
serno = data[1];
else
serno = 0;
memcpy(data, &eprom[60], sizeof(data));
if (HardlockGarble(data))
year = (int)data[0];
}
return serno;
}
///////////////////////////////
// Gestione chiave Eutron //
///////////////////////////////
void CampoWizardPage4::EncodeEutronPassword(char* str)
{
const char* const key = "QSECOFR-";
char tmp[16];
int i;
for (i = 0; str[i]; i++)
tmp[i] = str[i] + (i < 8 ? key[i] : str[i - 8]);
tmp[i] = '\0';
strcpy(str, tmp);
}
unsigned short CampoWizardPage4::EutronLogin(int& year)
{
unsigned short serno = 0xFFFF;
const char* const login[2] = { "AGA.CAMPO", "25EBAI" };
for (int i = 0; i < 2; i++)
{
KEY_NET eutron_key;
memset(&eutron_key, 0, sizeof(KEY_NET));
eutron_key.net_command = NET_KEY_OPEN;
eutron_key.command = LOCATING_MODE;
const char* const chiaro = login[i];
char cifrato[16];
strcpy(cifrato, chiaro);
EncodeEutronPassword(cifrato);
memset(eutron_key.label, 0, LABEL_LENGTH);
strcpy((char*)eutron_key.label, chiaro);
memset(eutron_key.password, 0, PASSWORD_LENGTH);
strcpy((char*)eutron_key.password, cifrato);
smartlink(&eutron_key);
if (eutron_key.status == ST_OK)
{
eutron_key.net_command = NET_KEY_ACCESS;
eutron_key.command = BLOCK_READING_MODE;
short* pointer = (short*)(&eutron_key.data[0]);
short* number = (short*)(&eutron_key.data[2]);
*pointer = 0; // Posizione in cui leggere
*number = 8; // Words da leggere
smartlink(&eutron_key);
if (eutron_key.status == ST_OK)
{
serno = (unsigned short)atol((const char*)eutron_key.data+4);
if (i == 0)
{
const unsigned short y = *(unsigned short*)(eutron_key.data+12);
if (y > 2000 && y < 3000)
year = y;
}
else
year = ThisYear();
break;
}
}
}
return serno;
}
/////////////////////////////////////////////////////////
// Metodi generici per le chiavi ed i relativi codici //
/////////////////////////////////////////////////////////
void CampoWizardPage4::BuildKey(char* key)
{
for (int i = 0; i < 8; i++)
key[i] = 'A'+ rand()%26;
}
int CampoWizardPage4::ThisYear()
{
int anno = 2006;
time_t lt;
if (time(&lt) == 0)
{
struct tm* timeloc = localtime(&lt) ;
if (timeloc != NULL)
anno = timeloc->tm_year + 1900;
}
return anno;
}
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()
{
_dongle_type = 0;
int yearKey = 0;
unsigned int 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("./program/dninst.zip");
if (file.IsOk())
{
wxTextInputStream keys(file);
wxString line = keys.ReadLine();
srand(883);
DecodeString(line);
const int ass_year = atoi(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", 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)
{
_dongle_type = DongleTest(); //controlla se la chiave c'e' ed eventualmente quale e'
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 (_dongle_type)
{
case 1:
strBody += wxT("<p>E' stata rilevata una chiave tipo <b>Hardlock</b>:</p>");
strBody += wxT("<p align=center><img src=\"hardlock.gif\" /></p>");
strBody += wxT("<p>Si puo' procedere con l'installazione /aggiornamento del software <b><i>Campo</i></b>. Premere il pulsante \"Next\".</p>");
break;
case 2:
strBody += wxT("<p>E' stata rilevata una chiave tipo <b>Eutron</b>:</p>");
strBody += wxT("<p align=center><img src=\"eutron.gif\" /></p>");
strBody += wxT("<p>Si puo' procedere con l'installazione /aggiornamento del software <b><i>Campo</i></b>. Premere il pulsante \"Next\".</p>");
break;
//case 3: e' il caso del server di chiavi;la DongleTest() per ora non lo fa
//break;
default:
strBody += wxT("<p><b>Non e' stata rilevata alcuna chiave hardware installata !</b></p>");
strBody += wxT("<p>Per procedere all'installazione dei driver della chiave hardware collegata al computer premere il bottone corrispondente alla tipologia della chiave stessa.</p>");
strBody += wxT("<p>Se si desidera proseguire nell'installazione del software senza installare la chiave hardware cliccare su \"Next\".</p>");
strBody += wxT("<p>Quest'ultima procedura e' consigliata solo in caso di installazione tipo <b>Client</b> di rete senza chiave propria, ma che utilizza un server di autorizzazioni gia' installato e funzionante in rete.</p>");
//procedura per la costruzione dei bottoni e delle immagini per l'installazione dei driver di chiave
//"griglia" contenitrice degli oggetti
wxBoxSizer* butt_box = new wxBoxSizer(wxHORIZONTAL);
GetSizer()->Add(butt_box, 0, wxALIGN_CENTER_HORIZONTAL, 0);
//Hardlock img e button
wxBitmap bmp_HL("hardlock.gif", wxBITMAP_TYPE_GIF);
wxStaticBitmap* s_bmp_HL = new wxStaticBitmap(this, wxID_ANY, bmp_HL);
butt_box->Add(s_bmp_HL, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 8);
_butt_HL = new wxButton(this, 401, "Hardlock", wxDefaultPosition, wxSize(100, 50));
butt_box->Add(_butt_HL, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 8);
//spaziatore centrale
butt_box->AddSpacer(24);
//Eutron img e button
_butt_EU = new wxButton(this, 402, "Eutron", wxDefaultPosition, wxSize(100, 50));
butt_box->Add(_butt_EU, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 8);
wxBitmap bmp_EU("eutron.gif", wxBITMAP_TYPE_GIF);
wxStaticBitmap* s_bmp_EU = new wxStaticBitmap(this, wxID_ANY, bmp_EU);
butt_box->Add(s_bmp_EU, 0, wxALIGN_CENTER_HORIZONTAL | wxALL, 8);
break;
}
SetHTMLText(strTitle, strBody);
//aggiorna il tipo di chiave per poterlo scrivere sul campo.ini
GetWizard().SetDongleType(_dongle_type);
}
/**********************************************************************************************************/
// 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>Campo</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:\\Campo</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:\\Campo\\dati</i> </p>");
strBody += wxT("<p><b>Dati dimostrativi:</b> area dati precompilata per esemplificare il funzionamento del software. ");
strBody += wxT("Di norma <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:\\Campo</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:\\Campo\\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>Campo</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();
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)
EVT_CHECKBOX(809, 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::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 bool bUseAuth = GetBool(807);
if (bUseAuth)
{
GetWizard().SetInstUseAuth(bUseAuth);
const wxString strSrvAuth = Get(808);
if (strSrvAuth.IsEmpty())
return ErrorBox("Specificare il computer gestore delle autorizzazioni!");
GetWizard().SetSrvAuth(strSrvAuth);
}
else
GetWizard().SetSrvAuth("");
const bool bUseDict = GetBool(809);
if (bUseDict)
{
GetWizard().SetInstUseDict(bUseDict);
const wxString strSrvDict = Get(810);
if (strSrvDict.IsEmpty())
return ErrorBox("Specificare il computer gestore dei dizionari!");
GetWizard().SetSrvDict(strSrvDict);
}
else
GetWizard().SetSrvDict("");
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:\\Campo</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 autorizzazioni:</b> e' il computer gestore di una chiave di protezione hardware multiutenza condivisa in rete. ");
strBody += wxT("Generalmente e' il computer che agente da server di APPNAME e su cui <u>deve essere montata la chiave di protezione multiutenza.</u></p>");
strBody += wxT("<p><b>Gestore dizionari:</b> e' il computer gestore dei dizionari di APPNAME in lingue diverse dall'italiano. ");
strBody += wxT("Generalmente e' il computer che agente da server di APPNAME.</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(320,-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(320,-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(320,-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));
//quarta riga della griglia
//check usa authoriz
wxCheckBox* chAuthoriz = new wxCheckBox(this, 807, wxT("Utilizza il gestore delle autorizzazioni"));
chAuthoriz->SetValue(false);
gbsSizer->Add(chAuthoriz, wxGBPosition(3, 1));
//quale e' il server authoriz
wxTextCtrl* tcAuthoriz = new wxTextCtrl(this, 808, "nomeserverautorizzazioni", wxDefaultPosition, wxSize(96,-1));
tcAuthoriz->Disable();
gbsSizer->Add(tcAuthoriz, wxGBPosition(3, 2));
//quarta riga della griglia
//check usa diction
wxCheckBox* chDictionary = new wxCheckBox(this, 809, wxT("Utilizza il gestore dei dizionari"));
chDictionary->SetValue(false);
gbsSizer->Add(chDictionary, wxGBPosition(4, 1));
//quale e' il server diction
wxTextCtrl* tcDiction = new wxTextCtrl(this, 810, "nomeserverdizionario", wxDefaultPosition, wxSize(96,-1));
tcDiction->Disable();
gbsSizer->Add(tcDiction, wxGBPosition(4, 2));
}
/**********************************************************************************************************/
// 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();
_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 && _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(Page(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();
}
//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); //scelta aggiornamento/tipo installazione
m_pPage[2] = new CampoWizardPage3(this); //licenza
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]);
}
///////////////////////////////////////////////////////////
// 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;
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;
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 dei ";
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;
}
}
}
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;
}
}
//metodo principale dell'applicazione che gestisce l'ordine degli eventi nella installazione vera e propria
void CampoSetup::OnTimer(wxTimerEvent& WXUNUSED(e))
{
CampoWizard* pWizard = new CampoWizard(m_pMainFrame);
if (pWizard->Run())
{
wxFileName strPath = argv[0];
strPath.SetCwd();
//tipo di installazione/aggiornamento
const unsigned int uInstallationType = pWizard->GetInstallationType();
const bool bNewInstallation = uInstallationType < 3;
//installazione servers?
const bool bInstallLurch = uInstallationType == 1 && (pWizard->GetInstUseAuth() | pWizard->GetInstUseDict());
//cartelle selezionate dall'utente
const wxString& strPrgLocPath = pWizard->GetPrgLocPath();
const wxString& strDataPath = 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");
}
//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(wxGetCwd(), "*.*");
strSourcePath.AppendDir("..");
strSourcePath.AppendDir(APPNAME);
strSourcePath.MakeAbsolute();
//..contando anche quanti sono e memorizzandoli in un array asFileList
const size_t uFilesToCopy = wxDir::GetAllFiles(strSourcePath.GetPath(), &asFilesList);
//per ogni files da copiare controlla i path sorgente e destinazione(problema con sottodirectory tipo dati)
wxString strFileCurr;
const size_t nPathLenght = strSourcePath.GetPath().Len();
for (size_t i = 0; i < uFilesToCopy; i++)
{
/* che fare con i servers? copiare la directory comunque o saltarli?
if (asFilesList[i].Lower().Find("\\servers\\") > 0 && bInstallLurch)
{
strFileCurr = strPrgLocPath;
strFileCurr += asFilesList[i].Mid(nPathLenght);
}
else*/
//files dei dati standard! solo in caso di nuova installazione!!
if (asFilesList[i].Lower().Find("\\dati\\") > 0)
{
if (bNewInstallation) //i DATI NON VANNO MAI installati in caso di aggiornamento!!!
{
strFileCurr = strDataPath;
strFileCurr += asFilesList[i].Mid(nPathLenght + 5);
}
}
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...
//adesso deve compilare il campo.ini se nuova installazione..
if (bNewInstallation)
{
//paragrafo [Main]
CampoIniFile CampoIniMain(strPrgLocPath + "/campo.ini", "Main");
const unsigned int uDongleType = pWizard->GetDongleType();
CampoIniMain.Set("Dongle", 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)
{
CampoIniFile CampoIniSrv(strPrgLocPath + "/campo.ini", "Server");
if (pWizard->GetInstUseAuth())
CampoIniSrv.Set("Authoriz", pWizard->GetSrvAuth());
if (pWizard->GetInstUseDict())
CampoIniSrv.Set("Dictionary", pWizard->GetSrvDict());
}
}
//..e modificare comunque l'install.ini aggiornando eventualmente l'origine dei programmi
CampoIniFile CampoInstall(strPrgLocPath + "/install.ini", "Main");
if (uInstallationType == 2) //client: directory origine sul server
CampoInstall.Set("DiskPath", pWizard->GetPrgNetPath());
else //e' il path assoluto dell'install.ini che sta in 'program' (es. D:\program)
{
wxFileName strSourcePath(wxGetCwd());
strSourcePath.AppendDir("program");
strSourcePath.MakeAbsolute();
const wxString strSrc = strSourcePath.GetPath();
CampoInstall.Set("DiskPath", strSrc);
}
//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 = pWizard->GetSrvAutostartMode();
CreateAutostartMode(iSrvAutostartMode, strPrgLocPath);
}
//creazione dell'icona sul desktop
const wxFileName strExe(strPrgLocPath, wxT("ba0.exe"));
const bool bDesktopShortcut = pWizard->GetDesktopShortcut();
if (bDesktopShortcut)
CreateIcon(CSIDL_COMMON_DESKTOPDIRECTORY, strExe);
// 1) terminato il tutto scrive/aggiorna/lascia stare il campo.stp
if (bNewInstallation)
{
CampoIniFile CampoStp("C:\\campo.stp", "");
}
// 2) procede poi al caricamento delle patch eventuali di sistema all'interno della dir 'program'
//la procedura di unzippamento dovrebbe essere quella di ba1.exe
// 3) riaggiorna eventualmente il livello versione/patch del SY in install.ini
// 4) lanciare ba1.exe -6 in uscita (non va qui! e' solo per ricordarsi di farlo!)
//questo e' un esempio di associazione automatica di estensione file
//if (pWizard->GetBool(bAssocExtension))
// AssociateExtension(strExe, wxT(".caz"));
}
pWizard->Destroy();
::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;
}
Reference in New Issue View Git Blame Copy Permalink