% vim: set textwidth=78 autoindent:

\section{Guida all'installazione}\label{label_install}

% when the revision of a section has been finalized,
% comment out the following line:
% \updatedisclaimer

I capitoli seguenti forniscono informazioni sulla compilazione ed installazione per QGIS
Versione \CURRENT. Questo documento corrisponde più o meno ad una conversione \LaTeX~ del file INSTALL.t2t che si scarica dai sorgenti QGIS dal 16 dicembre 2008.

Una versione aggiornata di questa guida è disponibile sul wiki di QGIS andando su:
\htmladdnormallink{http://wiki.qgis.org/qgiswiki/BuildingFromSource}{http://wiki.qgis.org/qgiswiki/BuildingFromSource}

\subsection{Note generali di compilazione}
Dalla versione 0.8.1 QGIS non usa più gli strumenti automatici per compilarsi. QGIS, come un gran numero di progetti importanti (eg. KDE 4.0), usa ora cmake (\htmladdnormallink{http://www.cmake.org}{http://www.cmake.org}) per compilarsi dai sorgenti. Lo script di configurazione in questa directory semplicemente controlla che cmake esista e fornisce alcune indicazioni per compilare QGIS.

Per informazioni più complete, vedere wiki:
   \htmladdnormallink{http://wiki.qgis.org/qgiswiki/Building\_with\_CMake}{http://wiki.qgis.org/qgiswiki/Building\_with\_CMake}

\subsection{Panoramica delle dipendenze richieste per la compilazione}

\textbf{Dipendenze richieste per la compilazione}:

\begin{itemize}
\item CMake $>$= 2.4.3
\item Flex, Bison
\end{itemize}

\textbf{Dipendenze richieste per runtime}:

\begin{itemize}
\item Qt $>$= 4.3.0
\item Proj $>$= ? (noto funzionare con 4.4.x)
\item GEOS $>$= 2.2 (3.0 è supportato, forse funziona anche 2.1.x)
\item Sqlite3 $>$= ? (probabilmente 3.0.0)
\item GDAL/OGR $>$= 1.4.x
\end{itemize}

\textbf{Dipendenze opzionali}:

\begin{itemize}
\item per plugin GRASS - GRASS $>$= 6.0.0
\item per georeferenziatore - GSL $>$= ? (works with 1.8)
\item per supporto postgis e plugin SPIT - PostgreSQL $>$= 8.0.x
\item per plugin gps - expat $>$= ? (1.95 is OK)
\item per esportazione mapserver e PyQGIS - Python $>$= 2.3 (2.5+ preferita)
\item per PyQGIS - SIP $>$= 4.5, PyQt $>$= deve accordarsi con la versione Qt
\end{itemize}

\textbf{Dipendenze raccomandate per runtime}:

\begin{itemize}
\item per plugin gps - gpsbabel
\end{itemize}

\section{Compilazione in ambiente windows usando msys}\label{sec:install_windows}
\textbf{Nota:} Per una descrizione accurata della compilazione di tutte le dipendenze da soli, visitare il sito web di Marco Pasetti:

\htmladdnormallink{http://www.webalice.it/marco.pasetti/qgis+grass/BuildFromSource.html}{http://www.webalice.it/marco.pasetti/qgis+grass/BuildFromSource.html}

Leggere la parte sull'uso dell'approccio semplificato con librerie pre-costruite...

\subsection{MSYS:}
MSYS fornisce un ambiente di compilazione stile unix in windows. Abbiamo creato un archivio zip che contiene quasi tutte le dipendenze.

Scaricare questo: 

\htmladdnormallink{http://download.osgeo.org/qgis/win32/msys.zip}{http://download.osgeo.org/qgis/win32/msys.zip}

e estrarlo in c:$\backslash$msys

Se si vuole preparare l'ambiente msys da soli piuttosto che usarne uno già fatto, istruzioni dettagliate possono essere trovate altrove in questo documento.

\subsection{Qt4.3}
Scaricare qt4.3 opensource edizione precompilata e installare (incluso lo scaricamento e l'installazione di mingw) da qui:

\htmladdnormallink{http://www.trolltech.com/developer/downloads/qt/windows}{http://www.trolltech.com/developer/downloads/qt/windows}

Quando l'installatore chiede di MinGW, non è necessaro scricarlo e installarlo, solo indirizzare l'installatore a c:$\backslash$msys$\backslash$mingw

Quando l'installazione di Qt è completa:

Aprire C:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$qtvars.bat e aggiunger le seguenti linee:

\begin{verbatim}
set PATH=%PATH%;C:\msys\local\bin;c:\msys\local\lib 
set PATH=%PATH%;"C:\Program Files\Subversion\bin" 
\end{verbatim}

Suggerisco anche di aggiungere C:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$ al proprio percorso delle variabili dell'ambiente nella finestra delle preferenze di sistema.

Se si pianifica di fare debugging, sarà necessario compilare una versione debug di Qt:
C:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$qtvars.bat compile\_debug

\textbf{Nota:} C'è un problema nella compilazione della versione debug di Qt 4.3, lo script finisce con questo messaggio  "mingw32-make: *** No rule to make target `debug'.  Stop.". Per compilare la versione debug bisogna uscire dalla directory src ed eseguire il seguente comando:

\begin{verbatim}
c:\Qt\4.3.0 make 
\end{verbatim}

\subsection{Flex and Bison}
\textbf{Nota:} Penso che questa sezione possa essere rimossa dato che dovrebbe essere già installata nell'immagine msys.

Scaricare Flex

\url{http://sourceforge.net/project/showfiles.php?group\_id=23617&package\_id=16424} (zip bin) e estrarlo in c:$\backslash$msys$\backslash$mingw$\backslash$bin

\subsection{Materiale Python: (opzionale)}
Seguire questa sezione nel caso in cui si voglia usare binding Python per QGIS. Per riuscire a compilare i binding, bisogna compilare SIP e PyQt4 dai sorgenti dato che il loro installatore non include alcuni file di sviluppo che sono necessari.

\subsubsection{Scaricare e installare Python - uso dell'installatore di Windows}
(Non importa in quale cartella lo si istalli)

\htmladdnormallink{http://python.org/download/}{http://python.org/download/}

\subsubsection{Scaricare i sorgenti SIP and PyQt4}
\url{http://www.riverbankcomputing.com/software/sip/download} \\
\url{http://www.riverbankcomputing.com/software/pyqt/download}

Estrarre ognuno dei file zip qui sopra in una directory temporanea. Assicurarsi di prendere versioni che si adattino alla propria versione Qt installata.

\subsubsection{Compilare SIP}
\begin{verbatim}
c:\Qt\4.3.0\bin\qtvars.bat 
python configure.py -p win32-g++ 
make 
make install 
\end{verbatim}

\subsubsection{Compilare PyQt}
\begin{verbatim}
c:\Qt\4.3.0\bin\qtvars.bat 
python configure.py 
make 
make install 
\end{verbatim}

\subsubsection{Note finali python}

\textbf{Nota:} Si possono eliminare le directory in cui si sono estratti i sorgenti SIP and PyQt4 dopo un'installazione andata a buon fine, non sono più necessarie.

\subsection{Subversion:}
Per ottenere i sorgenti QGIS dall'archivio, è necessaria un client subversion. Questo client dovrebbe funzionare bene:

\htmladdnormallink{http://subversion.tigris.org/files/documents/15/36797/svn-1.4.3-setup.exe}{http://subversion.tigris.org/files/documents/15/36797/svn-1.4.3-setup.exe}

\subsection{CMake:}
CMake è il sistema di compilazione usato da Quantum GIS. Si scarica qui:

\htmladdnormallink{http://www.cmake.org/files/v2.4/cmake-2.4.6-win32-x86.exe}{http://www.cmake.org/files/v2.4/cmake-2.4.6-win32-x86.exe}

\subsection{QGIS:}
Eseguire una finestra cmd.exe (Inizio -$>$ Esegui -$>$ cmd.exe). Creare la directory di sviluppo e spostarsi in essa

\begin{verbatim}
md c:\dev\cpp 
cd c:\dev\cpp 
\end{verbatim}

Ottenere i sogenti per SVN 
Per svn head:

\begin{verbatim}
svn co https://svn.osgeo.org/qgis/trunk/qgis 
\end{verbatim}
Per svn 0.8 branch

\begin{verbatim}
 svn co https://svn.osgeo.org/qgis/branches/Release-0_8_0 qgis0.8
\end{verbatim}

\subsection{Compilare:}
Come inizio leggere le note generiche di compilazione con CMake alla fine di questo documento.

Eseguire una finestra cmd.exe ( Inizio -$>$ Esegui -$>$ cmd.exe ) se non se ne ha già una. Scrivere il percorso per il il compilatore e il nostro ambiente MSYS:

\begin{verbatim}
c:\Qt\4.3.0\bin\qtvars.bat 
\end{verbatim}

Per facilità d'uso aggiungere c:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$ alle proprie proprietà di sistema così si può soltanto scrivere qtvars.bat quando si apre la console cmd.
Creare la directory di compilazione e impostarla come directory attuale:

\begin{verbatim}
cd c:\dev\cpp\qgis 
md build 
cd build 
\end{verbatim}

\subsection{Configurazione}
\begin{verbatim}
cmakesetup ..  
\end{verbatim}

\textbf{Nota:} Si deve includere il '..' qui sopra.

Premere il pulsante "Configura". Quando richiesto, si deve scegliere "MinGW Makefiles" come generatore.

C'è un problema con MinGW Makefiles in ambiente Win2K. Se si compila da questa piattaforma, usare invece il generatore "MSYS Makefiles".

Tutte le dipendenze dovrebbero venir rislote automaticamente se il percorso è stato impostato correttamente. La sola cosa da cambiare è la destinazione dell'installazione (CMAKE\_INSTALL\_PREFIX) e/o impostare 'Debug'.

Per la compatibilità con il pacchetto di script NSIS si raccomanda di lasciare il prefisso d'installazione al suo default c:$\backslash$program files$\backslash$

Quando la configurazione è completata, premere "OK" per uscire dall'utility di impostazione.

\subsection{Compilazione and installazione}
\begin{verbatim}
 make make install 
\end{verbatim}

\subsection{Eseguire qgis.exe dalla directory dove è installato (CMAKE\_INSTALL\_PREFIX)}
Assicurarsi di copiare tutti i .dll necessari nella stessa directory dove si trova il binario qgis.exe, se non lo si è già fatto, altrimenti all'avvio QGIS si lamenterà della mancanza di librerie.

Il modo migliore per far questo è scaricare il pacchetto di installazione della versione attuale di QGIS da \htmladdnormallink{http://qgis.org/uploadfiles/testbuilds/}{http://qgis.org/uploadfiles/testbuilds/} e installarlo. Ora si copia la directory di installazione da C:$\backslash$Program Files$\backslash$Quantum GIS a c:$\backslash$Program
Files$\backslash$qgis-0.8.1 (o qualsiasi sia la versione attuale. Il nome dovrebbe coincidere con il numero della versione.) Dopo aver fatto questa copia, si può disinstallare la versione rilasciata diQGIS dalla directory c:$\backslash$Program Files usando il disinstallatore fornito. Controllare poi bene che la directory Quantum GIS dir sia completamente scomparsa da programmi.

Un'altra possibilità è eseguire qgis.exe quando il percorso contiene le directory
c:$\backslash$msys$\backslash$local$\backslash$bin e c:$\backslash$msys$\backslash$local$\backslash$lib, così i DLLs verranno usati da quella posizione.

\subsection{Creare il pacchetto d'installazione: (opzionale)}
Scaricare e installare NSIS da (\htmladdnormallink{http://nsis.sourceforge.net/Main\_Page}{http://nsis.sourceforge.net/Main\_Page})

Ora usando windows explorer, entrare nella directory the win\_build nel tuo albero sorgente QGIS. Leggere il file README che si trova lì e seguire le istruzioni. Poi fare click con il tasto destro del mouse su qgis.nsi e scegliere l'opzione "Compile NSIS Script".


\section{Compilare su Mac OSX usando frameworks e cmake (QGIS $>$ 0.8)}\label{sec:install_macosx}
In questo approccio si cercherà di evitare per quanto possibile di costruire dipendenze dal sorgente e piuttosto usare frameworks, quando possibile.

Sono incluse alcune note per compilare su Mac OS X 10.5 (\underline{Leopard}).

\subsection{Installare XCODE}
Si raccomanda di scaricare la più recente immagine xcode dmg dal sito web Apple XDC. Installare XCODE dopo che il download \~{}941mb è completo.

\textbf{Nota:} Può essere necessario creare certi symlinks dopo l'installazione di XCODE SDK (in particolare se si sta usando XCODE 2.5 su tiger):

\begin{verbatim}
cd /Developer/SDKs/MacOSX10.4u.sdk/usr/
sudo mv local/ local_
sudo ln -s /usr/local/ local
\end{verbatim}

\subsection{Installare Qt4 da .dmg}
Si rende necessario almeno Qt4.3.0. Si suggerisce di scaricare l'ultima versione (almeno al momento della scrittura di questo manuale).

\begin{verbatim}
ftp://ftp.trolltech.com/qt/source/qt-mac-opensource-4.3.2.dmg
\end{verbatim}

Se si vogliono librerie di debug, Qt fornisce anche un'immagine dmg che le contiene:

\begin{verbatim}
ftp://ftp.trolltech.com/qt/source/qt-mac-opensource-4.3.2-debug-libs.dmg
\end{verbatim}

Sto usando soltanto librerie di rilascio a questo stadio dato che scaricare l'immagine debug dmg è sostanzialmente più lungo. Se però si pianifica di fare debugging, probabilmente è meglio prendere l'immagine dmg con le librerie di debug. Una volta che si sia scaricata, aprire l'immagine dmg e lanciare l'installatore.

\textbf{Nota:} è necessario accesso di amministratore per installare.

Dopo l'installazione si devono fare due piccoli cambiamenti:

Primo, aprire \texttt{/Library/Frameworks/QtCore.framework/Headers/qconfig.h} e cambiare

\textbf{Nota:} questo non sembra essere necessario dalla versione 4.2.3

\texttt{QT\_EDITION\_Unknown} a \texttt{QT\_EDITION\_OPENSOURCE}

Secondo, cambiare il mkspec symlink di default che manda a macx-g++:

\begin{verbatim}
cd /usr/local/Qt4.3/mkspecs/ 
sudo rm default 
sudo ln -sf macx-g++ default
\end{verbatim}

\subsection{Installare i framework di sviluppo per le dipendenze QGIS}
Scaricare l'eccellente framework tutto in uno che include proj, gdal, sqlite3 etc di William Kyngesburye

\begin{verbatim}
http://www.kyngchaos.com/wiki/software:frameworks
\end{verbatim}

Una volta scaricato, aprire e installare i framework.

William fornisce un pacchetto d'installazione addizionale per Postgresql/PostGIS disponibile qui:

\begin{verbatim}
http://www.kyngchaos.com/wiki/software:postgres 
\end{verbatim}

Ci sono alcuna dipendenze addizionali che al momento di scrivere non sono fornite come framework così abbiamo bisogno di compilarle dal sorgente.

\subsubsection{Dipendenze addizionali: GSL}
Scaricare la Library Scientific Gnu da

\begin{verbatim}
curl -O ftp://ftp.gnu.org/gnu/gsl/gsl-1.8.tar.gz 
\end{verbatim}

Quindi estrarla e compilarla ad un prefisso di /usr/local:

\begin{verbatim}
tar xvfz gsl-1.8.tar.gz 
cd gsl-1.8 
./configure --prefix=/usr/local 
make
sudo make install
cd ..  
\end{verbatim}

\subsubsection{Dipendenze addizionali: Expat}
Scaricare i sorgenti expat:

\begin{verbatim}
http://sourceforge.net/project/showfiles.php?group_id=10127 
\end{verbatim}

\begin{verbatim}
tar xvfz expat-2.0.0.tar.gz 
cd expat-2.0.0 
./configure --prefix=/usr/local
make 
sudo make install 
cd ..  
\end{verbatim}

\subsubsection{Dipendenze addizionali: SIP}
Assicurarsi di avere l'ultima versione di Python da 

\begin{verbatim}
http://www.python.org/download/mac/
\end{verbatim}

\underline{Nota riguardo a Leopard:} Leopard include una versione Python 2.5 utilizzabile.  Comunque si può installare  Python da python.org se si preferisce.

Scaricare il toolkit SIP per i binding python da

\url{http://www.riverbankcomputing.com/software/sip/download}

Quindi estrarlo e compilarlo (questo si installa automaticamente nel framework Python):

\begin{verbatim}
tar xvfz sip-<version number>.tar.gz 
cd sip-<version number>
python configure.py 
make 
sudo make install 
cd ..  
\end{verbatim}

\underline{Note riguardo a Leopard:}

Se si compila in Leopard, usando il Pyton incluso in Leopard, SIP vuole installare nel percorso di sistema -- questa non è una buona idea. Usare questo comando di configurazione al posto delle configurazione base di sopra:

\begin{verbatim}
python configure.py -d /Library/Python/2.5/site-packages -b \
/usr/local/bin -e /usr/local/include -v /usr/local/share/sip
\end{verbatim}

\subsubsection{Dipendenze addizionali: PyQt}
Se si incontrano problemi compilando PyQt seguendo le istruzioni qui sotto, si può anche provare aggiungendo esplicitamente python dalla propria directory di framework al proprio percorso, ad es.

\begin{verbatim}
export PATH=/Library/Frameworks/Python.framework/Versions/Current/bin:$PATH$
\end{verbatim}

Scaricare il il toolkit per Qt per i binding python da

\begin{verbatim}
http://www.riverbankcomputing.com/software/pyqt/download
\end{verbatim}

Quindi estrarlo e compilarlo (si installa automaticamente nel framework Python):

\begin{verbatim}
tar xvfz PyQt-mac<version number here>
cd PyQt-mac<version number here>
export QTDIR=/Developer/Applications/Qt
python configure.py 
yes 
make 
sudo make install 
cd ..  
\end{verbatim}

\underline{Note riduardo a Leopard}

Se si compila in Leopard, usando il Python incluso in Leopard, PyQt vuole installarsi nel percorso di sistema -- questa non è una buona idea.  Usare questo comando di configurazione invece della configurazione base di cui sopra:

\begin{verbatim}
python configure.py -d /Library/Python/2.5/site-packages -b /usr/local/bin
\end{verbatim}

Può esserci un problema con simboli indefiniti in QtOpenGL sotto Leopard.  Aprire QtOpenGL/makefile e aggiungere -undefined dynamic\_lookup a LFLAGS.

\subsubsection{Dipendenze addizionali: Bison}
\underline{Nota riguardo a Leopard:} Leopard include Bison 2.3, quindi questo passaggio può essere saltato in Leopard.

La versione di bison disponibile di default in Mac OSX è troppo vecchia quindi è necessario procurarsi una versione priù recente per il proprio sistema:

\begin{verbatim}
curl -O http://ftp.gnu.org/gnu/bison/bison-2.3.tar.gz 
\end{verbatim}

Ora compilarla e installarla in un prefisso di /usr/local :

\begin{verbatim}
tar xvfz bison-2.3.tar.gz 
cd bison-2.3 
./configure --prefix=/usr/local 
make
sudo make install 
cd ..  
\end{verbatim}

\subsection{Installare CMAKE per OSX}
Procurarsi l'ultima versione rilasciata:

\begin{verbatim}
http://www.cmake.org/HTML/Download.html 
\end{verbatim}

Al tempo della scrittura di questo manuale ho preso:

\begin{verbatim}
curl -O http://www.cmake.org/files/v2.4/cmake-2.4.6-Darwin-universal.dmg
\end{verbatim}

Una volta scaricata, aprire l'immagine dmg ed eseguire l'installatore

\subsection{Installare subversion per OSX}
\underline{Nota riguardo a Leopard:} Leopard include SVN, così questo passaggio può essere saltato in Leopard.

Il progetto \url{http://sourceforge.net/projects/macsvn/} ha una versione compilata di svn scaricabile. Volendo si può anche reperire il loro client GUI. Reperire la linea di comando del client qui:

\begin{verbatim}
curl -O http://ufpr.dl.sourceforge.net/sourceforge/macsvn/Subversion_1.4.2.zip 
\end{verbatim}

Una volta scaricato, aprire il file zip ed eseguire l'installatore.

Può essere necessario installare anche BerkleyDB, disponibile allo stesso indirizzo
\url{http://sourceforge.net/projects/macsvn/}. Al momento della scrittura di questo manualeera qui:

\begin{verbatim}
curl -O http://ufpr.dl.sourceforge.net/sourceforge/macsvn/Berkeley_DB_4.5.20.zip 
\end{verbatim}

Ancora una volta aprire il file zip ed eseguire l'installatore. Infine dobbiamo assicurarci che la linea di comando svn eseguibile sia nel percorso. aggiungere la seguente linea alla fine di /etc/bashrc usando sudo:

\begin{verbatim}
sudo vim /etc/bashrc 
\end{verbatim}

E aggiungere questa riga in fondo prima di salvare e chiudere:

\begin{verbatim}
export PATH=/usr/local/bin:$PATH:/usr/local/pgsql/bin 
\end{verbatim}

/usr/local/bin deve essere primo nel percorso cosicchè il più recente bison (che sarà compilato dal sorgente più avanti) venga trovato prima del bison installato da MacOSX, che è molto vecchio.

Ora chiudere e riaprire la propria shell per avere le versioni aggiornate.

\subsection{Check out QGIS da SVN}
Ora facciamo il check out del sorgente per for QGIS. Prima si crea una directory per lavorarci:

\begin{verbatim}
mkdir -p ~/dev/cpp cd ~/dev/cpp 
\end{verbatim}

Ora si fa il check out del sorgente:

Trunk:

\begin{verbatim}
svn co https://svn.osgeo.org/qgis/trunk/qgis qgis 
\end{verbatim}

Per la branch svn 0.8 

\begin{verbatim}
svn co https://svn.osgeo.org/qgis/branches/Release-0_8_0 qgis0.8
\end{verbatim}

Per la branch svn 0.9 

\begin{verbatim}
svn co https://svn.qgis.org/qgis/branches/Release-0_9_0 qgis0.9
\end{verbatim}

la prima volta che si fa check out del sorgente QGIS sources si avrà probabilmente un messaggio di questo tipo:

\begin{verbatim}
 Error validating server certificate for 'https://svn.qgis.org:443':
 - The certificate is not issued by a trusted authority. Use the fingerprint to
   validate the certificate manually!  Certificate information:
 - Hostname: svn.qgis.org
 - Valid: from Apr  1 00:30:47 2006 GMT until Mar 21 00:30:47 2008 GMT
 - Issuer: Developer Team, Quantum GIS, Anchorage, Alaska, US
 - Fingerprint: 2f:cd:f1:5a:c7:64:da:2b:d1:34:a5:20:c6:15:67:28:33:ea:7a:9b
   (R)eject, accept (t)emporarily or accept (p)ermanently?  
\end{verbatim}

Si suggerisce di premere "p" per accettare la chiave in modo permanente.

\subsection{Configurare la versione compilata}
CMake supporta la compilazione fuori dal sorgente così possiamo creare una directory "di compilazione" per il processo di compilazione. Per convenzione si consiglia di compilare il software in una directory chiamata "apps" nella propria directory home. Se si hanno i permessi corretti si può voler compilare direttamente nella cartella /Applications. Le istruzioni sotto assumono che si stia compilando in una directory preesistente \$\{HOME\}/apps ...

\begin{verbatim}
cd qgis
mkdir build
cd build
cmake -D CMAKE_INSTALL_PREFIX=$HOME/apps/ -D CMAKE_BUILD_TYPE=Release ..
\end{verbatim}

\underline{Nota riguardo a Leopard:} Per trovare un'installazione personalizzata di SIP in Leopard, aggiungere ""-
D SIP\_BINARY\_PATH=/usr/local/bin/sip"" al comando cmake sopra, prima di .. alla fine, per esempio:

\begin{verbatim}
cmake -D CMAKE_INSTALL_PREFIX=$HOME/apps/ -D CMAKE_BUILD_TYPE=Release -
D SIP_BINARY_PATH=/usr/local/bin/sip ..
\end{verbatim}

Per usare la versione compilata di GRASS su OSX, si può altrimenti eseguire cmake nella maniera seguente (richiesto almeno GRASS 6.3, sostituire la versione GRASS come richiesto):

\begin{verbatim}
cmake -D CMAKE_INSTALL_PREFIX=${HOME}/apps/ \
      -D GRASS_INCLUDE_DIR=/Applications/GRASS-6.3.app/Contents/MacOS/
      include \
      -D GRASS_PREFIX=/Applications/GRASS-6.3.app/Contents/MacOS \
      -D CMAKE_BUILD_TYPE=Release \
      ..
\end{verbatim}

Oppure, per usare una versione di Grass Unix-style, si può eseguire cmake nella maniera seguente
(richiesta almeno una versione di GRASS come nei requisiti Qgis, sostituire il percorso GRASS e la versione come richiesto):

\begin{verbatim}
cmake -D CMAKE_INSTALL_PREFIX=${HOME}/apps/ \
  -D GRASS_INCLUDE_DIR=/user/local/grass-6.3.0/include \
  -D GRASS_PREFIX=/user/local/grass-6.3.0 \
  -D CMAKE_BUILD_TYPE=Release \
  ..
\end{verbatim}

\subsection{Compilazione}
Ora cominciamo il processo di compilazione:

\begin{verbatim}
make 
\end{verbatim}

se tutto compila senza errori si può passare all'installazione:

\begin{verbatim}
make install 
\end{verbatim}

\section{Compilare sotto GNU/Linux}\label{sec:install_linux}
\subsection{Compilare QGIS con Qt4.x}
\textbf{Requisiti:} Ubuntu Hardy / distro derivati Debian 

Queste note sono attuali per Ubuntu 7.10 - altre versioni e distro derivati Debian potrebbero richiedere piccole variazioni nei nomi dei pacchetti.

Queste note sono per chi vuole compilare QGIS dal sorgente. Uno dei principali scopi qui è mostrare come questo si possa fare usando pacchetti binari per dipendenze \textbf{*all*} - compilando solo la parte core di QGIS dal sorgente. Preferisco questo approccio perché significa che si può lasciare l'affare di gestire i pacchetti di sistema ad apt e preoccuparsi soltanto del codice QGIS! 

Questo documento assume che si abbia un'installazione recente e un sistema "pulito". Queste istruzioni dovrebbero funzionare se questo è un sistema che è già stato in uso per un po', si potrebbe aver bisogno solo di saltare quei passaggi che sono irrilevanti per noi.

\subsection{Preparare apt}
Il pacchetto qgis dipende dalla versione disponibile nel componente "universe" di Ubuntu. Questo non è attivo di default, quindi bisogna attivarlo:

1. Aprire il proprio file /etc/apt/sources.list
2. Decommentare tutte le linee che cominciano con "deb"

Sarà anche necessario eseguire (K)Ubuntu "edgy" o superiore per incontrare tutte le dipendenze.

Ora aggiornare il  database dei propri sorgente locali:

\begin{verbatim}
sudo apt-get update 
\end{verbatim}

\subsection{Installare Qt4}
\begin{verbatim}
sudo apt-get install libqt4-core libqt4-debug  \
libqt4-dev libqt4-gui libqt4-qt3support libqt4-sql lsb-qt4 qt4-designer \
qt4-dev-tools qt4-doc qt4-qtconfig uim-qt gcc libapt-pkg-perl resolvconf
\end{verbatim}

\textbf{Nota speciale:} Se si sta seguendo questo set di istruzioni su un sistema che già ha gli strumenti di sviluppo Qt3 installati, ci sarà un conflitto tra strumenti Qt3 e Qt4. Per esempio, qmake punterà alla versione Qt3 e non alla Qt4. In Ubuntu i pacchetti Qt4 e Qt3 sono fatti in modo da poter convivere. Questo significa per esempio che se si hanno installati entrambi si dovranno fare tre eseguibili:

\begin{verbatim}
/usr/bin/qmake -> /etc/alternatives/qmake 
/usr/bin/qmake-qt3
/usr/bin/qmake-qt4 
\end{verbatim}

Lo stesso vale per tutti gli altri Qt binari. Avrete notato sopra che il canonico "qmake" è gestito dalle alternative apt, quindi prima di cominciare a compilare QGIS, è necessario rendere Qt4 il predefinito. Per far poi tornare Qt3 a predefinito si può usare lo stesso procedimento.

si possono usare le alternative apt per correggere questo, così la versione Qt4 dell'applicazione verrà usata in tutti i casi:

\begin{verbatim}
sudo update-alternatives --config qmake
sudo update-alternatives --config uic 
sudo update-alternatives --config designer 
sudo update-alternatives --config assistant 
sudo update-alternatives --config qtconfig 
sudo update-alternatives --config moc 
sudo update-alternatives --config lupdate 
sudo update-alternatives --config lrelease 
sudo update-alternatives --config linguist 
\end{verbatim}

Usare la semplice finestra della linea di comando che appare dopo aver eseguito ognuno dei comandi sopra per selezionare la versione Qt4 dell'applicazione in questione.

\subsection{Installare dipendenze software additionali richieste da QGIS}
\begin{verbatim}
sudo apt-get install gdal-bin libgdal1-dev libgeos-dev proj \
libgdal-doc libhdf4g-dev libhdf4g-run python-dev \
libgsl0-dev g++ libjasper-dev libtiff4-dev subversion \
libsqlite3-dev sqlite3 ccache make libpq-dev flex bison cmake txt2tags \
python-qt4 python-qt4-dev python-sip4 sip4 python-sip4-dev
\end{verbatim}

\textbf{Nota:} Per gli utenti Debian dovrebbero usare libgdal-dev sopra piuttosto

\textbf{Nota:} Per i binding in linguaggio python SIP $>$= 4.5 e PyQt4 $>$= 4.1 è necessario! Alcuna distribuzioni stabili GNU/Linux (ad es. Debian o SuSE) forniscono soltanto SIP $<$ 4.5 e PyQt4 $<$ 4.1. Per includere il supporto ai binding in linguaggio python può essere necessario compilare e installare quei pacchetti dal sorgente.

Se non si ha già cmake installato:

\begin{verbatim}
sudo apt-get install cmake
\end{verbatim}

\subsection{Passaggi specifici GRASS}
\textbf{Nota:} Se non si ha bisogno di compilare con il supporto GRASS, si può saltare questa sezione.

Ora si può installare grass dal dapper:

\begin{verbatim}
sudo apt-get install grass libgrass-dev libgdal1-1.4.0-grass 
\end{verbatim}

/!$\backslash$ Può essere necessario specificare l'esatta versione grass, ad es. libgdal1-1.3.2-grass

\subsection{Impostare ccache (Opzionale)}
Si dovrebbe anche impostare ccache per velocizzare i tempi di compilazione:

\begin{verbatim}
cd /usr/local/bin 
sudo ln -s /usr/bin/ccache gcc 
sudo ln -s /usr/bin/ccache g++ 
\end{verbatim}

\subsection{Preparare il proprio ambiente di sviluppo}
Per convenzione svolgo il mio lavoro di sviluppo in \$HOME/dev/$<$language$>$, così in questo caso creeremo un ambiente di lavoro per lo sviluppo in C++ così:

\begin{verbatim}
mkdir -p ${HOME}/dev/cpp 
cd ${HOME}/dev/cpp 
\end{verbatim}

Questo percorso alla directory sarà assunto anche per tutte le istruzioni seguenti.

\subsection{Check out del codice sorgente QGIS}
Ci sono due modi per fare il check out del sorgente. Usare il metodo anonimo se non si hanno i privilegi per l'archivio dei sorgenti QGIS, o usare il check out da sviluppatore se si hanno i permessi per fare commit di cambiamenti al codice sorgente.

1.  Checkout Anonimo

\begin{verbatim}
cd ${HOME}/dev/cpp 
svn co https://svn.osgeo.org/qgis/trunk/qgis qgis
\end{verbatim}

2. Checkout Sviluppatore

\begin{verbatim}
cd ${HOME}/dev/cpp 
svn co --username <yourusername> https://svn.osgeo.org/qgis/trunk/qgis qgis 
\end{verbatim}

La prima volta che si fa check out del sorgente verrà richiesto di accettare il certificato qgis.org. Premere "p" per accettarlo permanentemente:

\begin{verbatim}
Error validating server certificate for 'https://svn.qgis.org:443':
   - The certificate is not issued by a trusted authority. Use the
     fingerprint to validate the certificate manually!  Certificate
     information:
   - Hostname: svn.qgis.org
   - Valid: from Apr  1 00:30:47 2006 GMT until Mar 21 00:30:47 2008 GMT
   - Issuer: Developer Team, Quantum GIS, Anchorage, Alaska, US
   - Fingerprint:
     2f:cd:f1:5a:c7:64:da:2b:d1:34:a5:20:c6:15:67:28:33:ea:7a:9b (R)eject,
     accept (t)emporarily or accept (p)ermanently?  
\end{verbatim}

\subsection{Cominciare a compilare}
\textbf{Nota:} La prossima sezione descrive come compilare i pacchetti debian

Io compilo le mie versioni di sviluppo di QGIS nella directory \~{}/apps per evitare possibili conflitti con i pacchetti Ubuntu che possono stare in /usr. In questo modo per esempio si può usare il pacchetto binario di QGIS sul proprio sistema insieme con la propria versione di sviluppo. Suggerisco di fare qualcosa di simile:

\begin{verbatim}
mkdir -p ${HOME}/apps 
\end{verbatim}

Ora si crea una directory di compilazione e si esegue ccmake:

\begin{verbatim}
cd qgis
mkdir build
cd build
ccmake ..
\end{verbatim}

Quando si esegue ccmake (notare che il " .." è richiesto!), un menu apparirà dove si possono configurare i vari aspetti della compilazione. Se non si ha accesso alla root o non si vuole sovrascrivere installazioni QGIS preesistenti (per mezzo del packagemanager per esempio), impostare il CMAKE\_BUILD\_PREFIX per una posizione dove si hanno i privilegi di scrittura (di solito uso /home/timlinux/apps). Ora premere "c" per configurare, "e" per ignorare qualsiasi messaggio d'errore che possa apparire e "g" per generare il file make. \textbf{Nota:} a volte "c" deve essere premuto più volte prima che l'opzione "g" divenga disponibile. Dopo che la generazione "g" è completa, premere "q" per uscire dalla finestra di dialogo interattiva di ccmake.

Si procede con la compilazione:

\begin{verbatim}
make
make install
\end{verbatim}

Ci può volere un po' mentre si costruiscono le dipendenze sulla propria piattaforma.

\subsection{Compilare i pacchetti Debian}
Invece di creare un'installazione personale come nel precedente passaggio si può anche creare un pacchetto debian. Questo si fa dalla directory root di qgis, dove si trova una directory debian.

Prima è necessario installare gli strumenti di impacchettamento debian:

\begin{verbatim}
apt-get install build-essential
\end{verbatim}

I pacchetti QGIS saranno creati con:

\begin{verbatim}
dpkg-buildpackage -us -us -b
\end{verbatim}

\textbf{Nota:} Se \texttt{dpkg-buildpackage} si lamenta riguardo dipendenze che non sono state incontrate, queste si possono installare usando \texttt{apt-get} e rieseguire il comando.

\textbf{Nota:} Se si ha \texttt{libqgis1-dev} installato, bisogna rimuoverlo prima usando \texttt{dpkg -r libqgis1-dev}.  Altrimenti \texttt{dpkg-buildpackage} si lamenterà riguardo un conflitto di compilazione.

I pacchetti vengono creati nella directory di origine (cioè un livello superiore).
Installarli usando dpkg.  Ad esempio:

\begin{verbatim}
sudo dpkg -i \
	../qgis_1.0preview16_amd64.deb \
	../libqgis-gui1_1.0preview16_amd64.deb \
	../libqgis-core1_1.0preview16_amd64.deb \
	../qgis-plugin-grass_1.0preview16_amd64.deb \
	../python-qgis_1.0preview16_amd64.deb
\end{verbatim}

\subsection{Eseguire QGIS}
Ora si può provare ad eseguire QGIS:

\begin{verbatim}
$HOME/apps/bin/qgis 
\end{verbatim}

Se tutto ha funzionato in modo giusto l'applicazione QGIS dovrebbe avviarsi e apparire sul vostro schermo.

\section{Creazione ambiente MSYS per la compilazione di Quantum GIS}
\subsection{Configurazione iniziale}
\subsubsection{MSYS}
Questo ambiente rende disponibili in Windows tante utilità del mondo UNIX ed è necessario a molte dipendenze per compilare correttamente.

Scaricare da qui:

\url{http://puzzle.dl.sourceforge.net/sourceforge/mingw/MSYS-1.0.11-2004.04.30-1.exe}

Installare in \texttt{c:$\backslash$msys}

Tutto ciò che si andrà a compilare finirà in questa directory (resp. sue sottodirectory).

\subsubsection{MinGW}
Scaricare da qui:

\url{http://puzzle.dl.sourceforge.net/sourceforge/mingw/MinGW-5.1.3.exe}

Installare in \texttt{c:$\backslash$msys$\backslash$mingw}

È sufficiente scaricare e installare soltanto i componenti \texttt{g++} e \texttt{mingw-make}.

\subsubsection{Flex e Bison}
Flex e Bison sono strumenti per la generazione dei parser, sono necessari per la compilazione di GRASS e QGIS.

Scaricare i seguenti pacchetti:

\url{http://gnuwin32.sourceforge.net/downlinks/flex-bin-zip.php}

\url{http://gnuwin32.sourceforge.net/downlinks/bison-bin-zip.php}

\url{http://gnuwin32.sourceforge.net/downlinks/bison-dep-zip.php}

Decomprimerli tutti in \texttt{c:$\backslash$msys$\backslash$local}

\subsection{Installare le dipendenze}
\subsubsection{Messa a punto}
Paul Kelly ha svolto un ottimo lavoro e ha preparato un pacchetto di librerie precompilate per GRASS.
Il pacchetto al momento include:

\begin{itemize}
\item zlib-1.2.3
\item libpng-1.2.16-noconfig
\item xdr-4.0-mingw2
\item freetype-2.3.4
\item fftw-2.1.5
\item PDCurses-3.1
\item proj-4.5.0
\item gdal-1.4.1
\end{itemize}

Scaricabile da qui:

\url{http://www.stjohnspoint.co.uk/grass/wingrass-extralibs.tar.gz}

Inoltre, ha anche lasciato delle note su come compilarlo (per quelli interessati):

\url{http://www.stjohnspoint.co.uk/grass/README.extralibs}

Decomprimere l'intero pacchetto in \texttt{c:$\backslash$msys$\backslash$local}

\subsubsection{GDAL livello uno}
Dato che Quantum GIS necessita GDAL con supporto GRASS, si deve compilare GDAL dal sorgente - il pacchetto di Paul Kelly non include il supporto GRASS in GDAL.
L'idea è la seguente:

\begin{enumerate}
\item compilare GDAL senza GRASS
\item compilare GRASS
\item compile GDAL con GRASS
\end{enumerate}

Quindi, si comincia scaricando i sorgenti di GDAL:

\url{http://download.osgeo.org/gdal/gdal141.zip}

Decomprimere in una directory, preferibilmente \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}.

Aprire la console MSYS, andare nella directory gdal-1.4.1 ed eseguire i comandi qui sotto. Si possono mettere tutti in uno script, ad es. build-gdal.sh ed eseguirli tutti in una volta. La ricetta è presa dalle istruzioni di Paul Kelly - in pratica assicurano che la libreria sarà creata come DLL ed i programmi di utilità saranno legati dinamicamente ad essa...

\begin{verbatim}
CFLAGS="-O2 -s" CXXFLAGS="-O2 -s" LDFLAGS=-s ./configure --without-libtool \
--prefix=/usr/local --enable-shared --disable-static --with-libz=/usr/local \
--with-png=/usr/local
make
make install
rm /usr/local/lib/libgdal.a
g++ -s -shared -o ./libgdal.dll -L/usr/local/lib -lz -lpng ./frmts/o/*.o ./gcore/*.o \
./port/*.o ./alg/*.o ./ogr/ogrsf_frmts/o/*.o ./ogr/ogrgeometryfactory.o \
./ogr/ogrpoint.o ./ogr/ogrcurve.o ./ogr/ogrlinestring.o ./ogr/ogrlinearring.o \
./ogr/ogrpolygon.o ./ogr/ogrutils.o ./ogr/ogrgeometry.o ./ogr/ogrgeometrycollection.o \
./ogr/ogrmultipolygon.o ./ogr/ogrsurface.o ./ogr/ogrmultipoint.o \
./ogr/ogrmultilinestring.o ./ogr/ogr_api.o ./ogr/ogrfeature.o ./ogr/ogrfeaturedefn.o \ 
./ogr/ogrfeaturequery.o ./ogr/ogrfeaturestyle.o ./ogr/ogrfielddefn.o \
./ogr/ogrspatialreference.o ./ogr/ogr_srsnode.o ./ogr/ogr_srs_proj4.o \
./ogr/ogr_fromepsg.o ./ogr/ogrct.o ./ogr/ogr_opt.o ./ogr/ogr_srs_esri.o \
./ogr/ogr_srs_pci.o ./ogr/ogr_srs_usgs.o ./ogr/ogr_srs_dict.o ./ogr/ogr_srs_panorama.o \
./ogr/swq.o ./ogr/ogr_srs_validate.o ./ogr/ogr_srs_xml.o ./ogr/ograssemblepolygon.o \
./ogr/ogr2gmlgeometry.o ./ogr/gml2ogrgeometry.o
install libgdal.dll /usr/local/lib
cd ogr
g++ -s ogrinfo.o -o ogrinfo.exe -L/usr/local/lib -lpng -lz -lgdal
g++ -s ogr2ogr.o -o ogr2ogr.exe -lgdal -L/usr/local/lib -lpng -lz -lgdal
g++ -s ogrtindex.o -o ogrtindex.exe -lgdal -L/usr/local/lib -lpng -lz -lgdal
install ogrinfo.exe ogr2ogr.exe ogrtindex.exe /usr/local/bin
cd ../apps
g++ -s gdalinfo.o -o gdalinfo.exe -L/usr/local/lib -lpng -lz -lgdal
g++ -s gdal_translate.o -o gdal_translate.exe -L/usr/local/lib -lpng -lz -lgdal
g++ -s gdaladdo.o -o gdaladdo.exe -L/usr/local/lib -lpng -lz -lgdal
g++ -s gdalwarp.o -o gdalwarp.exe -L/usr/local/lib -lpng -lz -lgdal
g++ -s gdal_contour.o -o gdal_contour.exe -L/usr/local/lib -lpng -lz -lgdal
g++ -s gdaltindex.o -o gdaltindex.exe -L/usr/local/lib -lpng -lz -lgdal
g++ -s gdal_rasterize.o -o gdal_rasterize.exe -L/usr/local/lib -lpng -lz -lgdal
install gdalinfo.exe gdal_translate.exe gdaladdo.exe gdalwarp.exe gdal_contour.exe \
gdaltindex.exe gdal_rasterize.exe /usr/local/bin

\end{verbatim}

Infine, modificare manualmente \texttt{gdal-config} in \texttt{c:$\backslash$msys$\backslash$local$\backslash$bin} per sostituire la libreria statica con -lgdal:

\begin{verbatim}
CONFIG_LIBS="-L/usr/local/lib -lpng -lz -lgdal"
\end{verbatim}
La procedure di compilazione di GDAL può essere enormemente semplificata per usare libtool con una linea di correzione di libtool:
configurare gdal come di seguito:
./configure --with-ngpython --with-xerces=/local/ --with-jasper=/local/ --with-grass=/local/grass-6.3.cvs/ --with-pg=/local/pgsql/bin/pg\_config.exe 

Quindi correggere libtool con:
mv libtool libtool.orig
cat libtool.orig $|$ sed 's/max\_cmd\_len=8192/max\_cmd\_len=32768/g' $>$ libtool

Libtool in windows assume una lunghezza limite di linea di 8192 per qualche ragione e cerca di raggiungere i collegamenti e fallisce miseramente. Questo è un modo per aggirare il problema.

Compilazione e installazione dovrebbero essere liberi da impedimenti dopo questo.

\subsubsection{GRASS}
Scaricare i sorgenti da CVS o usare una foto settimanale, vedere:

	\begin{quotation}
\htmladdnormallink{http://grass.itc.it/devel/cvs.php}{http://grass.itc.it/devel/cvs.php}
	\end{quotation}

Nella console MSYS andare alla directory dove si è decompresso o verificato i sorgenti
(e.g. \texttt{c:$\backslash$msys$\backslash$local$\backslash$src$\backslash$grass-6.3.cvs})

Eseguire questi comandi:

\begin{verbatim}
export PATH="/usr/local/bin:/usr/local/lib:$PATH"
./configure --prefix=/usr/local --bindir=/usr/local --with-includes=/usr/local/include \
--with-libs=/usr/local/lib --with-cxx --without-jpeg --without-tiff --with-postgres=yes \
--with-postgres-includes=/local/pgsql/include --with-pgsql-libs=/local/pgsql/lib \
--with-opengl=windows --with-fftw --with-freetype \
--with-freetype-includes=/mingw/include/freetype2 \
--without-x --without-tcltk \
--enable-x11=no --enable-shared=yes --with-proj-share=/usr/local/share/proj
make
make install
\end{verbatim}

Dovrebbe installarsi in \texttt{c:$\backslash$msys$\backslash$local$\backslash$grass-6.3.cvs}

In ogni caso, queste pagine possono essere utili:

\begin{itemize}
\item \htmladdnormallink{http://grass.gdf-hannover.de/wiki/WinGRASS\_Current\_Status}{http://grass.gdf-hannover.de/wiki/WinGRASS\_Current\_Status}
\item \htmladdnormallink{http://geni.ath.cx/grass.html}{http://geni.ath.cx/grass.html}
\end{itemize}

\subsubsection{GDAL livello due}
A questo stadio useremo i sorgenti GDAL usati prima, solo la compilazione sarà un po' diversa.

ma prima, per riuscire a compilare i sorgenti GDAL con l'attuale GRASS CVS, è necessario correggerli; ecco cosa si deve cambiare:

	\begin{quotation}
\htmladdnormallink{http://trac.osgeo.org/gdal/attachment/ticket/1587/plugin\_patch\_grass63.diff}{http://trac.osgeo.org/gdal/attachment/ticket/1587/plugin\_patch\_grass63.diff}
	\end{quotation}
(si può correggere a mano o usare patch.exe in \texttt{c:$\backslash$msys$\backslash$bin})

Ora nella console MSYS console si va alla directory dei sorgenti GDAL e si esegue lo stesso comando del livello uno, solo con queste differenze:

\begin{verbatim}
1) when running ./configure add this argument:
--with-grass=/usr/local/grass-6.3.cvs

2) when calling g++ on line 5 (which creates libgdal.dll), add these arguments: 
-L/usr/local/grass-6.3.cvs/lib -lgrass\_vect -lgrass\_dig2 -lgrass\_dgl -lgrass\_rtree \
-lgrass\_linkm -lgrass\_dbmiclient -lgrass\_dbmibase -lgrass\_I -lgrass\_gproj \ 
-lgrass\_vask -lgrass\_gmath -lgrass\_gis -lgrass\_datetime}
\end{verbatim}

Poi ancora, si modifica \texttt{gdal-config} e si cambia la linea con CONFIG\_LIBS

\begin{verbatim}
CONFIG_LIBS="-L/usr/local/lib -lpng -L/usr/local/grass-6.3.cvs/lib -lgrass_vect \
-lgrass_dig2 -lgrass_dgl -lgrass_rtree -lgrass_linkm -lgrass_dbmiclient \
-lgrass_dbmibase -lgrass_I -lgrass_gproj -lgrass_vask -lgrass_gmath -lgrass_gis \
-lgrass_datetime -lz -L/usr/local/lib -lgdal" 
\end{verbatim}

Ora, GDAL dovrebbe riuscire a lavorare anche coni layer raster di GRASS.

\subsubsection{GEOS}
Scaricare i sorgenti:

\url{http://geos.refractions.net/geos-2.2.3.tar.bz2}

Decomprimerli ad es. in \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}

Per compilare, correggere il sorgente: nel file \texttt{source/headers/timeval.h} linea 13.
Cambiarlo da:

\begin{verbatim}
#ifdef _WIN32
\end{verbatim}
a:

\begin{verbatim}
#if defined(_WIN32) && defined(_MSC_VER)
\end{verbatim}

Ora, nella console MSYS console, andare alla directory del sorgente e eseguire:

\begin{verbatim}
./configure --prefix=/usr/local
make
make install
\end{verbatim}

\subsubsection{SQLITE}
Si può usare DLL precompilate, non c'è bisogno di compilarle dal sorgente:

Scaricare questo archivio:


\url{http://www.sqlite.org/sqlitedll-3\_3\_17.zip}

e copiare sqlite3.dll in \texttt{c:$\backslash$msys$\backslash$local$\backslash$lib}

Quindi scaricare questo archivio:

\url{http://www.sqlite.org/sqlite-source-3\_3\_17.zip}

e copiare sqlite3.h in \texttt{c:$\backslash$msys$\backslash$local$\backslash$include}

\subsubsection{GSL}
Scaricare i sorgenti:

\url{ftp://ftp.gnu.org/gnu/gsl/gsl-1.9.tar.gz}

Estrarre in \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}

Eseguire dalla console MSYS nella directory del sorgente:

\begin{verbatim}
./configure
make
make install
\end{verbatim}

\subsubsection{EXPAT}
Scaricare i sorgenti:

\url{http://dfn.dl.sourceforge.net/sourceforge/expat/expat-2.0.0.tar.gz}

Decomprimere in \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}

Eseguire dalla console MSYS nella directory del sorgente:

\begin{verbatim}
./configure
make
make install
\end{verbatim}

\subsubsection{POSTGRES}
Si useranno binari precompilati. Usare il seguente link per scaricare:

\begin{verbatim}
http://wwwmaster.postgresql.org/download/mirrors-ftp?file=\%2Fbinary\%2Fv8.2.4\%2Fwin32 \
\%2Fpostgresql-8.2.4-1-binaries-no-installer.zip
\end{verbatim}

copiarei contenuti della directory pgsql directory dall'archivio a  \texttt{c:$\backslash$msys$\backslash$local}

\subsection{Ripulitura}
Siamo pronti con la preparazione dell'ambiente MSYS. Si può eliminare tutto il materiale in \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}: ci vuole un po' di spazio e questo materiale non è assolutamente necessario.


\section{Compilare con MS Visual Studio}
/!$\backslash$ Questa sezione descrive un processo in cui si compilano tutte le dipendenze da soli. Vedere la sezione seguente per una procedura di compilazione più semplice in cui abbiamo tutte le dipendenze necessarie pre-impacchettate e focalizziamoci solo sull'impostare Visual Studio Express e compilare QGIS.

\textbf{Nota:} questo non include al momento i plugin GRASS o Python.

\subsection{Impostazioni Visual Studio}
Questa sezione descrive la messa a punto richiesta per permettere di usare Visual Studio per compilare QGIS. 

\subsubsection{Express Edition}
La Express Edition gratuita manca della piattaforma SDK che contiene le intestazioni e così via che sono necessarie quando si compila QGIS. La piattaforma SDK può essere installata come descritto qui:


\url{http://msdn.microsoft.com/vstudio/express/visualc/usingpsdk/}

Una volta che questo sia fatto, bisogna modificare il file $<$vsinstalldir$>$$\backslash$Common7$\backslash$Tools$\backslash$vsvars come segue:

	\begin{quotation}
Aggiungere \texttt{\%PlatformSDKDir\%$\backslash$Include$\backslash$atl} e \texttt{\%PlatformSDKDir\%$\backslash$Include$\backslash$mfc} alla voce \texttt{@set INCLUDE}.
	\end{quotation}
Questo aggiungere più intestazioni al percorso di sistema INCLUDE. \textbf{Nota:} questo funzionerà soltanto quando si usa il command prompt di Visual Studio nel compilare. La maggior parte delle dipendenze sarà costruita con questo. Si deve anche fare le modifiche descritte qui per eliminare la necessità di una libreria che manca in Visual Studio Express:

\url{http://www.codeproject.com/wtl/WTLExpress.asp}


\subsubsection{Tutte le editioni}
Sono necessari stdint.h and unistd.h. unistd.h è distribuito con la versione GnuWin32 dei binari flex \& bison (vedere oltre). stdint.h si può trovare qui:

\url{http://www.azillionmonkeys.com/qed/pstdint.h}

Copiare entrambi in $<$vsinstalldir$>$$\backslash$VC$\backslash$include.

\subsection{Scaricare/installare dipendenze}
Questa sezione descrive come scaricare e installare le varie dipendenze di QGIS.

\subsubsection{Flex e Bison}
Flex e Bison sono strumenti per la generazione di parsers, sono necessari per la compilazione di GRASS e anche QGIS.

Scaricare i seguenti pacchetti e eseguire gli installatori:

\url{http://gnuwin32.sourceforge.net/downlinks/flex.php} \\
\url{http://gnuwin32.sourceforge.net/downlinks/bison.php}

\subsubsection{Per includere il supporto PostgreSQL in Qt}
Se si vuole compilare Qt con il supporto PostgreSQL bisogna scaricare PostgreSQL, installarlo e creare una libreria che si possa poi collegare con Qt.

Scaricare da .../binary/v8.2.5/win32/postgresql-8.2.5-1.zip da un
PostgreSQL.org Mirror e installare.

PostgreSQL è attualmente compilato con MinGW ed è distribuito con intestazioni e librerie per MinGW. Le intestazioni possono essere usate con Visual C++ fuori dal box, ma la libreria esiste soltanto in forma DLL e archive (.a) e quindi non può essere usata direttamente con Visual C++.

Per creare una libreria copiare il seguente script sed nel file mkdef.sed nella lib directory di PostgreSQL:

\begin{verbatim}
/Dump of file / {
	s/Dump of file \([^	 ]*\)$/LIBRARY \1/p
	a\
EXPORTS
}
/[ 	]*ordinal hint/,/^[	]*Summary/ {
 /^[ 	]\+[0-9]\+/ {
   s/^[ 	]\+[0-9]\+[ 	]\+[0-9A-Fa-f]\+[ 	]\+[0-9A-Fa-f]\+[ 	]\+\([^ 	=]\+\).*$/	\1/p
 }
}
\end{verbatim}

Eseguire il processo nella linea di comando di Visual Studio C++ (dal menu Programmi):

\begin{verbatim}
cd c:\Program Files\PostgreSQL\8.2\bin
dumpbin /exports ..\bin\libpq.dll | sed -nf ../lib/mkdef.sed >..\lib\libpq.def
cd ..\lib
lib /def:libpq.def /machine:x86
\end{verbatim}

Sarà necessario un sed per farlo lavorare nel proprio percorso (ad es. da cygwin o msys).

Questo è più o meno tutto. È solo necessario includere i percorsi include e lib verso INCLUDE e LIB in vcvars.bat rispettivamente.

\subsubsection{Qt}
Compilare Qt seguendo le istruzioni qui:

\url{http://wiki.qgis.org/qgiswiki/Building\_QT\_4\_with\_Visual\_C\%2B\%2B\_2005}

\subsubsection{Proj.4}
Ottenere il sorgente proj.4 da qui:

\url{http://proj.maptools.org/}

Usare il command prompt di Visual Studio (assicurarsi che l'ambiente sia impostato correttamente), lanciare il seguente nella directory src:

\begin{verbatim}
nmake -f makefile.vc
\end{verbatim}

Installare lanciando il seguente nella directory di più alto livello impostando PROJ\_DIR come appropriato:

\begin{verbatim}
set PROJ_DIR=c:\lib\proj

mkdir %PROJ_DIR%\bin
mkdir %PROJ_DIR%\include
mkdir %PROJ_DIR%\lib

copy src\*.dll %PROJ_DIR%\bin
copy src\*.exe %PROJ_DIR%\bin
copy src\*.h %PROJ_DIR%\include
copy src\*.lib %PROJ_DIR%\lib 
\end{verbatim}

Questo può anche essere aggiunto ad un file batch.

\subsubsection{GSL}
Ottenere il sorgente gsl source da qui:

\url{http://david.geldreich.free.fr/downloads/gsl-1.9-windows-sources.zip}

Compilare usando il file gsl.sln

\subsubsection{GEOS}
Ottenere geos from svn (svn checkout \htmladdnormallink{http://svn.refractions.net/geos/trunk}{http://svn.refractions.net/geos/trunk} geos).
Modificare geos$\backslash$source$\backslash$makefile.vc come segue:

Decommentare le linee 333 e 334 per consentire la copiatura di version.h.vc in version.h.
Decommentare le linee 338 e 339.

Rinominare geos\_c.h.vc a geos\_c.h.in nelle linee 338 e 339 per consentire la copiatura geos\_c.h.in in geos\_c.h.

Usando il command prompt di Visual Studio (assicurarsi che l'ambiente sia impostato correttamente), lanciare il seguente comando nella directory di livello più alto:

\begin{verbatim}
nmake -f makefile.vc 
\end{verbatim}

Lanciare il seguente nella directory di livello più alto, impostando GEOS\_DIR come appropriato:

\begin{verbatim}
set GEOS_DIR="c:\lib\geos"

mkdir %GEOS_DIR%\include
mkdir %GEOS_DIR%\lib
mkdir %GEOS_DIR%\bin

xcopy /S/Y source\headers\*.h %GEOS_DIR%\include
copy /Y capi\*.h %GEOS_DIR%\include
copy /Y source\*.lib %GEOS_DIR%\lib
copy /Y source\*.dll %GEOS_DIR%\bin
\end{verbatim}

Questo può anche essere aggiunto in un file batch.

\subsubsection{GDAL}
Get gdal from svn (svn checkout \htmladdnormallink{https://svn.osgeo.org/gdal/branches/1.4/gdal}{https://svn.osgeo.org/gdal/branches/1.4/gdal} gdal).

Edit nmake.opt to suit, it's pretty well commented.

Using the Visual Studio command prompt (ensures the environment is setup properly), run the following in the top level directory:

\begin{verbatim}
nmake -f makefile.vc 
\end{verbatim}

and

\begin{verbatim}
nmake -f makefile.vc devinstall 
\end{verbatim}

\subsubsection{PostGIS}
Get PostGIS and the Windows version of PostgreSQL from here:

\url{http://postgis.refractions.net/download/}

\textbf{Note:} the warning about not installing the version of PostGIS that comes with the PostgreSQL installer. Simply run the installers.

\subsubsection{Expat}
Get expat from here:

\url{http://sourceforge.net/project/showfiles.php?group\_id=10127}

You'll need expat-win32bin-2.0.1.exe.

Simply run the executable to install expat.

\subsubsection{CMake}
Get CMake from here:


\url{http://www.cmake.org/HTML/Download.html}

You'll need cmake-$<$version$>$-win32-x86.exe. Simply run this to install CMake.

\subsection{Building QGIS with CMAKE}
Get QGIS source from svn (svn co \htmladdnormallink{https://svn.osgeo.org/qgis/trunk/qgis}{https://svn.osgeo.org/qgis/trunk/qgis} qgis).

Create a 'Build' directory in the top level QGIS directory. This will be where all the build output will be generated.

Run Start--$>$All Programs--$>$CMake--$>$CMake. 

In the 'Where is the source code:' box, browse to the top level QGIS directory.

In the 'Where to build the binaries:' box, browse to the 'Build' directory you created in the top level QGIS directory.

Fill in the various *\_INCLUDE\_DIR and *\_LIBRARY entries in the 'Cache Values' list.

Click the Configure button. You will be prompted for the type of makefile that will be generated. Select Visual Studio 8 2005 and click OK.

All being well, configuration should complete without errors. If there are errors, it is usually due to an incorrect path to a header or library directory. Failed items will be shown in red in the list.

Once configuration completes without error, click OK to generate the solution and project files.

With Visual Studio 2005, open the qgis.sln file that will have been created in the Build directory you created earlier.

Build the ALL\_BUILD project. This will build all the QGIS binaries along with all the plugins.

 Install QGIS by building the INSTALL project. By default this will install to c:$\backslash$Program Files$\backslash$qgis$<$version$>$ (this can be changed by changing the CMAKE\_INSTALL\_PREFIX variable in CMake). 

 You will also either need to add all the dependency dlls to the QGIS install directory or add their respective directories to your PATH.

\section{Building under Windows using MSVC Express}
\textbf{Note:}: Building under MSVC is still a work in progress. In particular the following dont work yet: python, grass, postgis connections.

/!$\backslash$ This section of the document is in draft form and is not ready to be used yet.

Tim Sutton, 2007

\subsection{System preparation}
I started with a clean XP install with Service Pack 2 and all patches applied.
I have already compiled all the dependencies you need for gdal, expat etc,
so this tutorial wont cover compiling those from source too. Since compiling 
these dependencies was a somewhat painful task I hope my precompiled libs 
will be adequate. If not I suggest you consult the individual projects for
specific build documentation and support. Lets go over the process in a nutshell 
before we begin:

 * Install XP (I used a Parallels virtual machine)
 * Install the premade libraries archive I have made for you
 * Install Visual Studio Express 2005 sp1
 * Install the Microsoft Platform SDK
 * Install command line subversion client
 * Install library dependencies bundle
 * Install Qt 4.3.2
 * Check out QGIS sources
 * Compile QGIS
 * Create setup.exe installer for QGIS

\subsection{Install the libraries archive}
Half of the point of this section of the MSVC setup procedure is to make 
things as simple as possible for you. To that end I have prepared an
archive that includes all dependencies needed to build QGIS except Qt 
(which we will build further down). Fetch the archive from:

\begin{verbatim}
http://qgis.org/uploadfiles/msvc/qgis_msvc_deps_except_qt4.zip
\end{verbatim}

Create the following directory structure:

\begin{verbatim}
c:\dev\cpp\
\end{verbatim}

And then extract the libraries archive into a subdirectory of the above
directory so that you end up with:

\begin{verbatim}
c:\dev\cpp\qgislibs-release
\end{verbatim}

\textbf{Note:} that you are not obliged to use this directory layout, but you 
should adjust any instructions that follow if you plan to do things 
differently.

\subsection{Install Visual Studio Express 2005}
First thing we need to get is MSVC Express from here:

\htmladdnormallink{http://msdn2.microsoft.com/en-us/express/aa975050.aspx}{http://msdn2.microsoft.com/en-us/express/aa975050.aspx}

The page is really confusing so dont feel bad if you cant actually find the 
download at first! There are six coloured blocks on the page for the various  
studio family members (vb / c\# / j\# etc). Simply choose your language under 
the 'select your language' combo under the yellow C++ block, and your download 
will begin. Under internet explorer I had to disable popup blocking for the 
download to be able to commence.

Once the setup commences you will be prompted with various options. Here is what 
I chose :

 * Send useage information to Microsoft   (No)
 * Install options:
   * Graphical IDE                        (Yes)
   * Microsoft MSDN Express Edition       (No)
   * Microsoft SQL Server Express Edition (No)
 * Install to folder: C:$\backslash$Program Files$\backslash$Microsoft Visual Studio 8$\backslash$   (default)

It will need to download around 90mb of installation files and reports 
that the install will consume 554mb of disk space.

\subsection{Install Microsoft Platform SDK2}
Go to this page:

\htmladdnormallink{http://msdn2.microsoft.com/en-us/express/aa700755.aspx}{http://msdn2.microsoft.com/en-us/express/aa700755.aspx}

Start by using the link provided on the above page to download and install the
platform SDK2.

The actual SDK download page is once again a bit confusing since the links for 
downloading are hidden amongst a bunch of other links. Basically look for these 
three links with their associated 'Download' buttons and choose the correct 
link for your platform:

\begin{verbatim}
PSDK-amd64.exe  1.2 MB  Download 
PSDK-ia64.exe   1.3 MB  Download 
PSDK-x86.exe    1.2 MB  Download
\end{verbatim}

When you install make sure to choose 'custom install'. These instructions 
assume you are installing into the default path of:

\begin{verbatim}
C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\
\end{verbatim}

We will go for the minimal install that will give us a working environment, 
so on the custom installation screen I made the following choices:

\begin{verbatim}
Configuration Options
  + Register Environmental Variables            (Yes)
Microsoft Windows Core SDK
  + Tools                                       (Yes)
    + Tools (AMD 64 Bit)                        (No unless this applies)
    + Tools (Intel 64 Bit)                      (No unless this applies)
  + Build Environment
    + Build Environment (AMD 64 Bit)            (No unless this applies)
    + Build Environment (Intel 64 Bit)          (No unless this applies)
    + Build Environment (x86 32 Bit)            (Yes)
  + Documentation                               (No)
  + Redistributable Components                  (Yes)
  + Sample Code                                 (No)
  + Source Code                                 (No)
    + AMD 64 Source                             (No)
    + Intel 64 Source                           (No)
Microsoft Web Workshop                          (Yes) (needed for shlwapi.h)
  + Build Environment                           (Yes)
  + Documentation                               (No)
  + Sample Code                                 (No)
  + Tools                                       (No)
Microsoft Internet Information Server (IIS) SDK (No)
Microsoft Data Access Services (MDAC) SDK       (Yes) (needed by GDAL for odbc)
  + Tools
    + Tools (AMD 64 Bit)                        (No)
    + Tools (AMD 64 Bit)                        (No)
    + Tools (x86 32 Bit)                        (Yes)
  + Build Environment
    + Tools (AMD 64 Bit)                        (No)
    + Tools (AMD 64 Bit)                        (No)
    + Tools (x86 32 Bit)                        (Yes)
  + Documentation                               (No)
  + Sample Code                                 (No)
Microsodt Installer SDK                         (No)
Microsoft Table PC SDK                          (No)
Microsoft Windows Management Instrumentation    (No)
Microsoft DirectShow SDK                        (No)
Microsoft Media Services SDK                    (No)
Debuggin Tools for Windows                      (Yes)
\end{verbatim}

\textbf{Note:} that you can always come back later to add extra bits if you like.

\textbf{Note:} that installing the SDK requires validation with the 
Microsoft Genuine Advantage application. Some people have a philosophical 
objection to installing this software on their computers. If you are one 
of them you should probably consider using the MINGW build instructions 
described elsewhere in this document.

The SDK installs a directory called

\begin{verbatim}
C:\Office10
\end{verbatim}

Which you can safely remove.

After the SDK is installed, follow the remaining notes on the page link 
above to get your MSVC Express environment configured correctly. For your 
convenience, these are summarised again below, and I have added a couple 
more paths that I discovered were needed:

1) open Visual Studio Express IDE

2) Tools -$>$ Options -$>$ Projects and Solutions -$>$ VC++ Directories

3) Add:

\begin{verbatim}
Executable files: 
  C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Bin

Include files: 
  C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Include
  C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Include\atl
  C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Include\mfc
Library files: C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Lib
\end{verbatim}

4) Close MSVC Express IDE

5) Open the following file with notepad:

\begin{verbatim}
C:\Program Files\Microsoft Visual Studio 8\VC\VCProjectDefaults\corewin_express.vsprops
\end{verbatim}

and change the property:

\begin{verbatim}
AdditionalDependencies="kernel32.lib"
\end{verbatim}

To read:

\begin{verbatim}
AdditionalDependencies="kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib 
                        advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib"
\end{verbatim}

The notes go on to show how to build a mswin32 application which you can try if you like - 
I'm not going to recover that here.

\subsection{Edit your vsvars}
Backup your vsvars32.bat file in 

\begin{verbatim}
C:\Program Files\Microsoft Visual Studio 8\Common7\Tools
\end{verbatim}

and replace it with this one:

\begin{verbatim}
@SET VSINSTALLDIR=C:\Program Files\Microsoft Visual Studio 8
@SET VCINSTALLDIR=C:\Program Files\Microsoft Visual Studio 8\VC
@SET FrameworkDir=C:\WINDOWS\Microsoft.NET\Framework
@SET FrameworkVersion=v2.0.50727
@SET FrameworkSDKDir=C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0
@if "%VSINSTALLDIR%"=="" goto error_no_VSINSTALLDIR
@if "%VCINSTALLDIR%"=="" goto error_no_VCINSTALLDIR

@echo Setting environment for using Microsoft Visual Studio 2005 x86 tools.

@rem
@rem Root of Visual Studio IDE installed files.
@rem
@set DevEnvDir=C:\Program Files\Microsoft Visual Studio 8\Common7\IDE

@set PATH=C:\Program Files\Microsoft Visual Studio 8\Common7\IDE;C:\Program \
Files\Microsoft Visual Studio 8\VC\BIN;C:\Program Files\Microsoft Visual Studio 8\ \
Common7\Tools;C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\bin; \
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727;C:\Program Files\Microsoft Visual \
Studio 8\VC\VCPackages;%PATH%
@rem added by Tim
@set PATH=C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Bin;%PATH%
@set INCLUDE=C:\Program Files\Microsoft Visual Studio 8\VC\INCLUDE; \
%INCLUDE%
@rem added by Tim
@set INCLUDE=C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\ \
Include;%INCLUDE%
@set INCLUDE=C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\ \
Include\mfc;%INCLUDE%
@set INCLUDE=%INCLUDE%;C:\dev\cpp\qgislibs-release\include\postgresql
@set LIB=C:\Program Files\Microsoft Visual Studio 8\ \
VC\LIB;C:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\lib;%LIB%
@rem added by Tim
@set LIB=C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\Lib;%LIB%
@set LIB=%LIB%;C:\dev\cpp\qgislibs-release\lib
@set LIBPATH=C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727

@goto end

:error_no_VSINSTALLDIR
@echo ERROR: VSINSTALLDIR variable is not set. 
@goto end

:error_no_VCINSTALLDIR
@echo ERROR: VCINSTALLDIR variable is not set. 
@goto end

:end

\end{verbatim}

\subsection{Environment Variables}
Right click on 'My computer' then select the 'Advanced' tab. Click environment variables and 
create or augment the following '''System''' variables (if they dont already exist):

\begin{verbatim}
Variable Name:     Value:
--------------------------------------------------------------------------
EDITOR             vim
INCLUDE            C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2 \
\Include\.
LIB                C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2 \
\Lib\.
LIB_DIR            C:\dev\cpp\qgislibs-release
PATH               C:\Program Files\CMake 2.4\bin;
                   %SystemRoot%\system32;
                   %SystemRoot%;
                   %SystemRoot%\System32\Wbem;
                   C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2 \
                   \Bin\.;
                   C:\Program Files\Microsoft Platform SDK for Windows Server 2003 R2\  \
                   \Bin\WinNT\;
                   C:\Program Files\svn\bin;C:\Program Files\Microsoft Visual Studio 8 \
                   \VC\bin;
                   C:\Program Files\Microsoft Visual Studio 8\Common7\IDE;
                   "c:\Program Files\Microsoft Visual Studio 8\Common7\Tools";
                   c:\Qt\4.3.2\bin;
                   "C:\Program Files\PuTTY"
QTDIR              c:\Qt\4.3.2
SVN_SSH            "C:\\Program Files\\PuTTY\\plink.exe"
\end{verbatim}

\subsection{Building Qt4.3.2}
You need a minimum of Qt 4.3.2 here since this is the first version to officially 
support building the open source version of Qt for windows under MSVC.

Download Qt 4.x.x source for windows from

\begin{verbatim}
http:\\www.trolltech.com
\end{verbatim}

Unpack the source to 

\begin{verbatim}
c:\Qt\4.x.x\
\end{verbatim}

\subsubsection{Compile Qt}
Open the Visual Studio C++ command line and cd to c:$\backslash$Qt$\backslash$4.x.x where you
extracted the source and enter:

\begin{verbatim}
configure -platform win32-msvc2005
nmake
nmake install
\end{verbatim}

Add -qt-sql-odbc -qt-sql-psql to the configure line if your want odbc and
PostgreSQL support build into Qt.

\textbf{Note:} For me in some cases I got a build error on qscreenshot.pro. If you
are only interested in having the libraries needed for building Qt apps, you 
can probably ignore that. Just check in c:$\backslash$Qt$\backslash$4.3.2$\backslash$bin to check all dlls and 
helper apps (assistant etc) have been made.

\subsubsection{Configure Visual C++ to use Qt}
After building configure the Visual Studio Express IDE to use Qt:

1) open Visual Studio Express IDE

2) Tools -$>$ Options -$>$ Projects and Solutions -$>$ VC++ Directories

3) Add:

\begin{verbatim}
Executable files: 
  $(QTDIR)\bin

Include files: 
  $(QTDIR)\include
  $(QTDIR)\include\Qt
  $(QTDIR)\include\QtCore
  $(QTDIR)\include\QtGui
  $(QTDIR)\include\QtNetwork
  $(QTDIR)\include\QtSvg
  $(QTDIR)\include\QtXml
  $(QTDIR)\include\Qt3Support
  $(LIB_DIR)\include   (needed during qgis compile to find stdint.h and unistd.h)

Library files: 
  $(QTDIR)\lib

Source Files:
  $(QTDIR)\src
\end{verbatim}

Hint:  You can also add

\begin{verbatim}
QString = t=<d->data, su>, size=<d->size, i>
\end{verbatim}

to AutoExp.DAT in C:$\backslash$Program Files$\backslash$Microsoft Visual Studio 8$\backslash$Common7$\backslash$Packages$\backslash$Debugger before 

\begin{verbatim}
[Visualizer]
\end{verbatim}

That way the Debugger will show the contents of QString when you point at or
watch a variable in the debugger.  There are probably much more additions -
feel free to add some - I just needed QString and took the first hit in google
I could find.

\subsection{Install Python}
Download \htmladdnormallink{http://python.org/ftp/python/2.5.1/python-2.5.1.msi}{http://python.org/ftp/python/2.5.1/python-2.5.1.msi} and install it.

\subsection{Install SIP}
Download \htmladdnormallink{http://www.riverbankcomputing.com/Downloads/sip4/sip-4.7.1.zip}{http://www.riverbankcomputing.com/Downloads/sip4/sip-4.7.1.zip} and extract it 
into your c:$\backslash$dev$\backslash$cpp directory.
>From a Visual C++ command line cd to the directory where you extract SIP and run:

\begin{verbatim}
c:\python25\python configure.py -p win32-msvc2005
nmake
nmake install
\end{verbatim}

\subsection{Install PyQt4}
Download \htmladdnormallink{http://www.riverbankcomputing.com/Downloads/PyQt4/GPL/PyQt-win-gpl-4.3.1.zip}{http://www.riverbankcomputing.com/Downloads/PyQt4/GPL/PyQt-win-gpl-4.3.1.zip} and extract it 
into your c:$\backslash$dev$\backslash$cpp directory.
>From a Visual C++ command line cd to the directory where you extracted PyQt4 and run:

\begin{verbatim}
c:\python25\python configure.py -p win32-msvc2005
nmake
nmake install
\end{verbatim}

\subsection{Install CMake}
Download and install cmake 2.4.7 or better, making sure to enable the option: \texttt{Update path for all users}

\subsection{Install Subversion}
You '''must''' install the command line version if you want the CMake svn scripts to work.
Its a bit tricky to find the correct version on the subversion download site as they have 
som misleadingly named similar downloads. Easiest is to just get this file:

\htmladdnormallink{http://subversion.tigris.org/downloads/1.4.5-win32/apache-2.2/svn-win32-1.4.5.zip}{http://subversion.tigris.org/downloads/1.4.5-win32/apache-2.2/svn-win32-1.4.5.zip}

Extract the zip file to
\begin{verbatim}
C:\Program Files\svn
\end{verbatim}

And then add

\begin{verbatim}
C:\Program Files\svn\bin
\end{verbatim}

To your path.

\subsection{Initial SVN Check out}
Open a cmd.exe window and do:

\begin{verbatim}
cd \
cd dev
cd cpp
svn co https://svn.osgeo.org/qgis/trunk/qgis 
\end{verbatim}

At this point you will probably get a message like this:

\begin{verbatim}
C:\dev\cpp>svn co https://svn.osgeo.org/qgis/trunk/qgis
Error validating server certificate for 'https://svn.qgis.org:443':
 - The certificate is not issued by a trusted authority. Use the
   fingerprint to validate the certificate manually!
Certificate information:
 - Hostname: svn.qgis.org
 - Valid: from Sat, 01 Apr 2006 03:30:47 GMT until Fri, 21 Mar 2008 03:30:47 GMT
 - Issuer: Developer Team, Quantum GIS, Anchorage, Alaska, US
 - Fingerprint: 2f:cd:f1:5a:c7:64:da:2b:d1:34:a5:20:c6:15:67:28:33:ea:7a:9b
(R)eject, accept (t)emporarily or accept (p)ermanently?
\end{verbatim}

Press 'p' to accept and the svn checkout will commence.

\subsection{Create Makefiles using cmakesetup.exe}
I wont be giving a detailed description of the build process, because 
the process is explained in the first section (where you manually build 
all dependencies) of the windows build notes in this document. Just skip 
past the parts where you need to build GDAL etc, since this simplified 
install process does all the dependency provisioning for you.

\begin{verbatim}
cd qgis
mkdir build
cd build
cmakesetup ..
\end{verbatim}

Cmakesetup should find all dependencies for you automatically (it uses the 
LIB\_DIR environment to find them all in c:$\backslash$dev$\backslash$cpp$\backslash$qgislibs-release). 
Press configure again after the cmakesetup gui appears and when all the red 
fields are gone, and you have made any personalisations to the setup, press 
ok to close the cmake gui.

Now open Visual Studio Express and do: \texttt{File -$>$ Open -$>$ Project / Solution}

Now open the cmake generated QGIS solution which should be in :

\begin{verbatim}
c:\dev\cpp\qgis\build\qgisX.X.X.sln
\end{verbatim}

Where X.X.X represents the current version number of QGIS. Currently I 
have only made release built dependencies for QGIS (debug versions will follow 
in future), so you need to be sure to select 'Release' from the solution 
configurations toolbar. Next right click on ALL\_BUILD in the solution browser, and then choose build. Once the build completes right click on INSTALL in the solution browser and 
choose build. This will by default install qgis into c:$\backslash$program files$\backslash$qgisX.X.X.

\subsection{Running and packaging}
To run QGIS you need to at the minimum copy the dlls from c:$\backslash$dev$\backslash$cpp$\backslash$qgislibs-release$\backslash$bin 
into the c:$\backslash$program files$\backslash$qgisX.X.X directory.


