\section{Guide d'installation}\label{label_install}

% when the revision of a section has been finalized,
% comment out the following line:
% \updatedisclaimer
%
%The following chapters provide build and installation information for QGIS
%Version \CURRENT. This document corresponds almost to a \LaTeX~ conversion of
%the INSTALL.t2t file coming with the QGIS sources from December, 16th 2008.
%
%A current version is also available at the wiki, see:
%\htmladdnormallink{http://wiki.qgis.org/qgiswiki/BuildingFromSource}{
%http://wiki.qgis.org/qgiswiki/BuildingFromSource}

Ce chapitre comporte les informations nécessaires à la compilation et à
l'installation de QGIS \CURRENT. Ce document est une conversion \LaTeX~ du
fichier INSTALL.t2t embarqué dans les sources de QGIS depuis le 16 décembre
2008.

Une version est maintenue continuellement sur le wiki :
\htmladdnormallink{http://wiki.qgis.org/qgiswiki/BuildingFromSource}{
http://wiki.qgis.org/qgiswiki/BuildingFromSource}

%\subsection{General Build Notes}
%At version 0.8.1 QGIS no longer uses the autotools for building. QGIS, like a
%number of major projects (eg. KDE 4.0), now uses cmake
(\htmladdnormallink{http://www.cmake.org}{http://www.cmake.org})
%for building from source. The configure script in this directory simply checks
%for the existence of cmake and provides some clues to build QGIS.
%
%For complete information, see the wiki at:
%  
% \htmladdnormallink{http://wiki.qgis.org/qgiswiki/Building\_with\_CMake}{
% http://wiki.qgis.org/qgiswiki/Building\_with\_CMake}

\subsection{General Build Notes}
Depuis la version 0.8.1, QGIS n'utilise plus les autotools pour la compilation
mais le logiciel cmake
(\htmladdnormallink{http://www.cmake.org}{http://www.cmake.org}). Le script de
configuration vérifie seulement la présence de cmake.

Pour plus d'informations :
  
\htmladdnormallink{http://wiki.qgis.org/qgiswiki/Building\_with\_CMake}{
http://wiki.qgis.org/qgiswiki/Building\_with\_CMake}

%\subsection{An overview of the dependencies required for building}
%
%\textbf{Required build deps}:
%
%\begin{itemize}
%\item CMake $>$= 2.4.3
%\item Flex, Bison
%\end{itemize}
%
%\textbf{Required runtime deps}:
%
%\begin{itemize}
%\item Qt $>$= 4.3.0
%\item Proj $>$= ? (known to work with 4.4.x)
%\item GEOS $>$= 2.2 (3.0 is supported, maybe 2.1.x works too)
%\item Sqlite3 $>$= ? (probably 3.0.0)
%\item GDAL/OGR $>$= 1.4.x
%\end{itemize}

\subsection{Un aperçu des dépendances requises}

\textbf{Dépendances requises pour la compilation}:

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

\textbf{Dépendances requises pour l'exécution}:

\begin{itemize}
\item Qt $>$= 4.3.0
\item Proj $>$= ? (fonctionne avec la 4.4.x)
\item GEOS $>$= 2.2 (3.0 est supporté, la 2.1.x marche peut-etre)
\item Sqlite3 $>$= ? (probablement 3.0.0)
\item GDAL/OGR $>$= 1.4.x
\end{itemize}

%\textbf{Optional dependencies}:
%
%\begin{itemize}
%\item for GRASS plugin - GRASS $>$= 6.0.0
%\item for georeferencer - GSL $>$= ? (works with 1.8)
%\item for postgis support and SPIT plugin - PostgreSQL $>$= 8.0.x
%\item for gps plugin - expat $>$= ? (1.95 is OK)
%\item for mapserver export and PyQGIS - Python $>$= 2.3 (2.5+ preferred)
%\item for PyQGIS - SIP $>$= 4.5, PyQt $>$= must match Qt version
%\end{itemize}
%
%\textbf{Recommended runtime deps}:
%
%\begin{itemize}
%\item for gps plugin - gpsbabel
%\end{itemize}

\textbf{Dépendances optionnelles}:

\begin{itemize}
\item pour l'extension GRASS plugin - GRASS $>$= 6.0.0
\item pour le géoreferencement - GSL $>$= ? (marche avec la 1.8)
\item pour le support de PostGIS et de l'extension SPIT - PostgreSQL $>$= 8.0.x
\item pour l'extension GPS - expat $>$= ? (1.95 is OK)
\item pour l'exportation vers mapserver PyQGIS - Python $>$= 2.3 (2.5+
preferred)
\item pour PyQGIS - SIP $>$= 4.5, PyQt $>$= doit s'accorder avec la version de
Qt
\end{itemize}

\textbf{Dépendances recommandées}:

\begin{itemize}
\item pour l'extension GPS - gpsbabel
\end{itemize}

%\section{Building under windows using msys}\label{sec:install_windows}
%\textbf{Note:} For a detailed account of building all the dependencies yourself
% you 
%can visit Marco Pasetti's website here:
%
%\htmladdnormallink{
% http://www.webalice.it/marco.pasetti/qgis+grass/BuildFromSource.html}{
% http://www.webalice.it/marco.pasetti/qgis+grass/BuildFromSource.html}
%
%Read on to use the simplified approach with pre-built libraries...
%
%\subsection{MSYS:}
%MSYS provides a unix style build environment under windows. We have created a
%zip archive that contains just about all dependencies.
%
%Get this: 
%
%\htmladdnormallink{http://download.osgeo.org/qgis/win32/msys.zip}{
% http://download.osgeo.org/qgis/win32/msys.zip}
%
%and unpack to c:$\backslash$msys
%
%If you wish to prepare your msys environment yourself rather than using 
%our pre-made one, detailed instructions are provided elsewhere in this
%document.

\section{Compiler sous Windows avec msys}\label{sec:install_windows}
\textbf{Note:} Pour connaître dans le détail la manière de compiler vous-même
les dépendances, vous pouvez visiter le site de Marco Pasetti :

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

\subsection{MSYS:}
MSYS fournit un environment de compilation similaire à celui d'Unix mais sous
Windows. Nous avons créé une archive zip contenant toutes les dépendances, à
télécharger ici : 

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

et à extraire vers c:$\backslash$msys

Si vous voulez configurer votre environnement msys vous-même, de plus amples
instructions sont disponibles dans ce document.

%\subsection{Qt4.3}
%Download qt4.3 opensource precompiled edition exe and install (including the
%download and install of mingw) from here:
%
%\htmladdnormallink{http://www.trolltech.com/developer/downloads/qt/windows}{
% http://www.trolltech.com/developer/downloads/qt/windows}
%
%When the installer will ask for MinGW, you don't need to download and install
%it, just point the installer to c:$\backslash$msys$\backslash$mingw
%
%When Qt installation is complete:
%
%Edit C:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$qtvars.bat and
% add the following lines:

\subsection{Qt4.3}
Téléchargez l'édition open source de Qt 4.3 (incluant le téléchargement et 
l'installation de MinGW) à cette adresse : 

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

Quand l'installateur vous demande MinGW, vous n'avez pas besoin de le
télécharger et de l'installer, mais juste de pointer vers le répertoire
c:$\backslash$msys$\backslash$mingw

Quand l'installation de Qt est terminée :

Éditez C:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$qtvars.bat et
rajoutez les lignes suivantes:

%\begin{verbatim}
%set PATH=%PATH%;C:\msys\local\bin;c:\msys\local\lib 
%set PATH=%PATH%;"C:\Program Files\Subversion\bin" 
%\end{verbatim}
%
%I suggest you also add
% C:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$ to your
% Environment
% %Variables Path in the windows system preferences.
% %If you plan to do some debugging, you'll need to compile debug version of Qt:
% %C:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$qtvars.bat
% compile\_debug
% %
% %\textbf{Note:} there is a problem when compiling debug version of Qt 4.3, the
% script ends with
%this message  "mingw32-make: *** No rule to make target `debug'.  Stop.". To 
%compile the debug version you have to go out of src directory and execute the
%following command:
%
%\begin{verbatim}
%c:\Qt\4.3.0 make 
%\end{verbatim}

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

Je vous sugère également d'ajouter
C:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$ aux variables
d'environnements de votre système.

Si vous comptez faire du débuggage, vous devrez compiler une version debug de Qt
:
C:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$qtvars.bat
compile\_debug

\textbf{Note:} il existe un problème lors de la compilation d'une version debug
de Qt 4.3, le script se finit avec le message 'minggw32-make: *** No rule to make target `debug'. Stop.".
Pour réussir la compilation, vous devez allez dans le répertoire src et lancez la commande suivante :

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

% \subsection{Python stuff: (optional)}
% Follow this section in case you would like to use Python bindings for QGIS.  To
% be able to compile bindings, you need to compile SIP and PyQt4 from sources as
% their installer doesn't include some development files which are necessary.

 \subsection{Python : (optionnel)}
 Suivez cette section si vous souhaitez utiliser Python pour QGIS. Afin de pouvoir 
 utiliser Python pour QGIS, vous avez besoin de compiler SIP et PyQt4 à partir des 
 sources car leurs programmes d'installation n'incluent pas certains fichiers qui sont nécessaires.

 %\subsubsection{Download and install Python - use Windows installer}
%(It doesn't matter to what folder you'll install it)
%
%\htmladdnormallink{http://python.org/download/}{http://python.org/download/}
%
%\subsubsection{Download SIP and PyQt4 sources}
%\url{http://www.riverbankcomputing.com/software/sip/download} \\
%\url{http://www.riverbankcomputing.com/software/pyqt/download}
%
%Extract each of the above zip files in a temporary directory. Make sure
%to get versions that match your current Qt installed version.

\subsubsection{Télécharger et installer Python - utilisation de l'installateur sous Windows}
(le répertoire d'installation n'a aucune importance)

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

\subsubsection{Télécharger SIP et les sources de PyQt4}
\url{http://www.riverbankcomputing.com/software/sip/download} \\
\url{http://www.riverbankcomputing.com/software/pyqt/download}

Il faut extraire chacune des archives zip dans un répertoire temporaire. Assurez-vous d'avoir des versions qui correspondent bien à votre version de Qt.

%\subsubsection{Compile SIP}
%\begin{verbatim}
%c:\Qt\4.3.0\bin\qtvars.bat 
%python configure.py -p win32-g++ 
%make 
%make install 
%\end{verbatim}
%
%\subsubsection{Compile PyQt}
%\begin{verbatim}
%c:\Qt\4.3.0\bin\qtvars.bat 
%python configure.py 
%make 
%make install 
%\end{verbatim}
%
%\subsubsection{Final python notes}
%
%\textbf{Note:} You can delete the directories with unpacked SIP and PyQt4 sources after a
%successfull install, they're not needed anymore.

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

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

\subsubsection{Notes finales pour Python}

\textbf{Note :} Vous pouvez effacer les répertoires contenants les fichiers désarchivés de SIP et PyQt4 après l'installation, ils ne sont plus nécessaires.

\subsection{Subversion :}
De manière à obtenir les sources depuis le répertoire svn de QGIS, vous avez besoin de Subversion :

\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 est le système de compilation de Quantum GIS. Téléchargez le ici :

\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 :}
Lancez une fenêtre cmd.exe ( Démarrer -$>$ Exécuter -$>$ cmd.exe ). Créez un répertoire de développement et déplacez dans ce répertoire :

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

Obtenez les dernières versions des sources avec svn:

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

Pour la branche 1.0

\begin{verbatim}
svn co https://svn.osgeo.org/qgis/branches/Version-1_0
\end{verbatim}

\subsection{Compiler :}
%As a background read the generic building with CMake notes at the end of this document.
Pour votre culture, vous pouvez lire à la fin de ce document quelques lignes sur la façon de compiler avec CMake.

Lancez une fenêtre cmd.exe ( Démarrer -$>$ Exécuter -$>$ cmd.exe ) si vous ne l'avez pas encore fait. Ajoutez les chemins vers le compilateur et l'environnement MSYS :

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

Pour faciliter les choses, ajoutez aussi c:$\backslash$Qt$\backslash$4.3.0$\backslash$bin$\backslash$ pour que vous n'ayez qu'à taper qtvars.bat dans la console. Créez le répertoire de compilation et établissez-le en tant que répertoire courant :

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

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

\textbf{Note:} Vous devez inclure les '..' marqués ci-dessus.

Cliquez sur le bouton 'Configure'.  lorsque c'est demandé, vous devez choisir 'MinGW Makefiles' comme générateur.

Sous Windows 2000, du fait d'un bug avec MinGW choisissez plutôt 'MSYS Makefiles'.

Toutes les dépendances devraient être sélectionnées automatiquement si vous avez spécifié les chemins correctement. La seule chose que vous ayez à changer est la destination de l'installation avec (CMAKE\_INSTALL\_PREFIX)et/ou 'Debug'.

Pour plus de compatibilité avec les scripts NSIS, je vous recommande de laisser le préfixe d'installation par défaut  c:$\backslash$program files$\backslash$

Quand la configuration est terminée, cliquez sur OK pour quitter l'utilitaire d'installation.

\subsection{Compilation et installation}
\begin{verbatim}
 make make install 
\end{verbatim}

% \subsection{Run qgis.exe from the directory where it's installed
% (CMAKE\_INSTALL\_PREFIX)}
% Make sure to copy all .dll:s needed to the same directory as the qgis.exe
% binary is installed to, if not already done so, otherwise QGIS will complain
% about missing libraries when started.
% 
% The best way to do this is to download both the QGIS current release installer
% package from
% \htmladdnormallink{http://qgis.org/uploadfiles/testbuilds/}{
% http://qgis.org/uploadfiles/testbuilds/} and install it. Now copy
% the installation dir from C:$\backslash$Program Files$\backslash$Quantum GIS
% into c:$\backslash$Program
% Files$\backslash$qgis-0.8.1 (or whatever the current version is. The name should
% strictly
% match the version no.) After making this copy you can uninstall the release
% version of QGIS from your c:$\backslash$Program Files directory using the
% provided
% uninstaller. Double check that the Quantum GIS dir is completely gone under
% program files afterwards.
% 
% Another possibility is to run qgis.exe when your path contains
% c:$\backslash$msys$\backslash$local$\backslash$bin and
% c:$\backslash$msys$\backslash$local$\backslash$lib directories, so the DLLs will
% be
% used from that place.

\subsection{Lancez qgis.exe depuis son répertoire d'installation (CMAKE\_INSTALL\_PREFIX)}
Copiez toutes les .dll:s nécessaire dans le même répertoire que l'exécutable de qgis ou QGIS signalera des bibliothèques absentes lors de son lancement.

La meilleure façon de procéder est de télécharger l'installateur de QGIS depuis \htmladdnormallink{http://qgis.org/uploadfiles/testbuilds/}{http://qgis.org/uploadfiles/testbuilds/} et de l'installer. Maintenant, copiez le répertoire d'installation C:$\backslash$Program Files$\backslash$Quantum GIS
vers c:$\backslash$Program Files$\backslash$qgis-0.8.1 (ou tout autre numéro de version. Le nom doit être strictement identique au numéro de version.). Une fois que cela est fait, vous pouvez désinstaller la version téléchargée. Vérifiez que le répertoire correspondant n'apparaît plus dans c:$\backslash$Program Files 

Une autre possibilité est de lancer qgis.exe quand vos chemins comportent les répertoires c:$\backslash$msys$\backslash$local$\backslash$bin et c:$\backslash$msys$\backslash$local$\backslash$lib, auquel cas les DLLs seront utilisées depuis ces emplacements.

% \subsection{Create the installation package: (optional)}
% Downlad and install NSIS from
% (\htmladdnormallink{http://nsis.sourceforge.net/Main\_Page}{
% http://nsis.sourceforge.net/Main\_Page})
% 
% Now using windows explorer, enter the win\_build directory in your QGIS source
% tree. Read the READMEfile there and follow the instructions. Next right click
% on qgis.nsi and choose the option 'Compile NSIS Script'. 

\subsection{Création du fichier d'installation : (optionnel)}
Téléchargez et installez NSIS depuis (\htmladdnormallink{http://nsis.sourceforge.net/Main\_Page}{http://nsis.sourceforge.net/Main\_Page})

En passant par l'explorateur de fichier, entrez dans le répertoire win\_build se situant dans l'arborescence des sources de QGIS. Lisez le fichier README  et suivez les instructions. Ensuite, faites un clic droit sur qgis.nsi et sélectionnez l'option 'Compile NSIS Script'. 

% \section{Building on Mac OSX using frameworks and cmake (QGIS $>$
% 0.8)}\label{sec:install_macosx}
% In this approach I will try to avoid as much as possible building dependencies
% from source and rather use frameworks wherever possible.
% 
% Included are a few notes for building on Mac OS X 10.5 (\underline{Leopard}).

\section{Compilation sous Mac OSX en utilisant XCODE et cmake (QGIS $>$
0.8)}\label{sec:install_macosx}

Avec cette approche, nous allons essayer d'éviter de construire les dépendances depuis les sources, mais plutôt utiliser ce qui est déjà disponible.

Quelques notes pour compiler sous Mac OS X 10.5 (\underline{Leopard}) sont également disponibles.

% \subsection{Install XCODE}
% I recommend to get the latest xcode dmg from the Apple XDC Web site. Install
% XCODE after the \~{}941mb download is complete.
% 
% \textbf{Note:} It may be that you need to create some symlinks after installing 
% the XCODE SDK (in particular if you are using XCODE 2.5 on tiger):
% 
% \begin{verbatim}
% cd /Developer/SDKs/MacOSX10.4u.sdk/usr/
% sudo mv local/ local_
% sudo ln -s /usr/local/ local
% \end{verbatim}

\subsection{Installer XCODE}
Je vous recommande d'obtenir la dernière version de xcode depuis le site Apple XDC.

\textbf{Note:} Il sera peut être nécessaire de créer des liens symboliques après l'installation (surtout si vous utilisez xcode 2.5 sur Tiger):

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

% \subsection{Install Qt4 from .dmg}
% You need a minimum of Qt4.3.0. I suggest getting the latest (at time of
% writing).
% 
% \begin{verbatim}
% ftp://ftp.trolltech.com/qt/source/qt-mac-opensource-4.3.2.dmg
% \end{verbatim}
% 
% If you want debug libs, Qt also provide a dmg with these:
% 
% \begin{verbatim}
% ftp://ftp.trolltech.com/qt/source/qt-mac-opensource-4.3.2-debug-libs.dmg
% \end{verbatim}
% 
% I am going to proceed using only release libs at this stage as the download for
% the debug dmg is substantially bigger. If you plan to do any debugging though
% you probably want to get the debug libs dmg. Once downloaded open the dmg and
% run the installer. 

\subsection{Installer Qt4 depuis un .dmg}
Vous aurez besoin d'une version au moins égale à Qt4.3.0 bien que je vous suggère de prendre la dernière version en date.

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

Si vous voulez les bibliothèques de débogage, Qt fournit aussi un .dmg les contenant:

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

Une fois le téléchargement effectué, lancez l'installateur.

% \textbf{Note:} you need admin access to install.
% 
% After installing you need to make two small changes:
% 
% First edit \texttt{/Library/Frameworks/QtCore.framework/Headers/qconfig.h} and
% change 
% 
% \textbf{Note:} this doesnt seem to be needed since version 4.2.3
% 
% \texttt{QT\_EDITION\_Unknown} to \texttt{QT\_EDITION\_OPENSOURCE}
% 
% Second change the default mkspec symlink so that it points to macx-g++:
% 
% \begin{verbatim}
% cd /usr/local/Qt4.3/mkspecs/ 
% sudo rm default 
% sudo ln -sf macx-g++ default
% \end{verbatim}

\textbf{Note:} vous avez besoin des accès administrateurs pour l'installation.

Après installation, vous devez faire deux modifications minimes:

Ouvrez \texttt{/Library/Frameworks/QtCore.framework/Headers/qconfig.h} et changez

\textbf{Note:} cela ne semble plus nécessaire depuis la version 4.2.3

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

Le second changement porte sur le lien symbolique de mkspec pour qu'il pointe sur macx-g++:

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

% \subsection{Install development frameworks for QGIS dependencies}
% Download William Kyngesburye's excellent all in one framework that includes
% proj, gdal, sqlite3 etc
% 
% \begin{verbatim}
% http://www.kyngchaos.com/wiki/software:frameworks
% \end{verbatim}
% 
% Once downloaded, open and install the frameworks.
% 
% William provides an additional installer package for Postgresql/PostGIS. Its
% available here:
% 
% \begin{verbatim}
% http://www.kyngchaos.com/wiki/software:postgres 
% \end{verbatim}
% 
% There are some additional dependencies that at the time of writing are not
% provided as frameworks so we will need to build these from source.

\subsection{Installer l'environnement de développement pour les dépendances de QGIS}
Téléchargez et installez l'excellent environnement de William Kyngesburye qui inclut proj, gdal, sqlite3 etc

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

William fournit un autre installateur pour Postgresql/PostGIS. Il est disponible ici:

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

Il y a d'autres dépendances qui ne sont pas incluses (au moment où le manuel a été écrit) et que nous devrons compiler depuis les sources.

% \subsubsection{Additional Dependencies : GSL}
% Retrieve the Gnu Scientific Library from
% 
% \begin{verbatim}
% curl -O ftp://ftp.gnu.org/gnu/gsl/gsl-1.8.tar.gz 
% \end{verbatim}
% 
% Then extract it and build it to a prefix of /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{Dépendances supplémentaires : GSL}
Téléchargez la Bibliothèque Scientifique Gnu (Gnu Scientific Library)

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

Puis extrayez là et faites la compilation vers un préfixe de /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{Additional Dependencies : Expat}
% Get the expat sources:
% 
% \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{Dépendances supplémentaires : Expat}
Obtenez les sources d'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{Additional Dependencies : SIP}
% Make sure you have the latest Python fom 
% 
% \begin{verbatim}
% http://www.python.org/download/mac/
% \end{verbatim}
% 
% \underline{Leopard note:} Leopard includes a usable Python 2.5.  Though you can
% install Python from python.org if preferred.
% 
% Retrieve the python bindings toolkit SIP from
% 
% \url{http://www.riverbankcomputing.com/software/sip/download}
% 
% Then extract and build it (this installs by default into the Python framework):
% 
% \begin{verbatim}
% tar xvfz sip-<version number>.tar.gz 
% cd sip-<version number>
% python configure.py 
% make 
% sudo make install 
% cd ..  
% \end{verbatim}
% 
% \underline{Leopard notes}
% 
% If building on Leopard, using Leopard's bundled Python, SIP wants to install in
% the system path -- this is not a good idea.  Use this configure command instead
% of the basic configure above:
% 
% \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{Dépendances supplémentaires : SIP}
Soyez sûr d'avoir la dernière version de Python

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

\underline{Note:} Leopard inclut déjà Python 2.5.  Vous pouvez cependant utiliser la version de python.org .

Téléchargez les liens python de SIP à

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

Puis extrayez-les et faites la compilation (l'installation se fera par défaut dans l'environnement 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{Notes}

Si vous compilez sous Leopard avec la version de Python embarquée, SIP voudra s'installer dans le chemin système -- ce qui n'est pas une bonne idée. Utilisez cette commande de configuration à la place la commande précédente:

\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{Additional Dependencies : PyQt}
% If you encounter problems compiling PyQt using the instructions 
% below you can also try adding python from your frameworks dir
% explicitly to your path e.g.
% 
% \begin{verbatim}
% export PATH=/Library/Frameworks/Python.framework/Versions/Current/bin:$PATH$
% \end{verbatim}
% 
% Retrieve the python bindings toolkit for Qt from
% 
% \begin{verbatim}
% http://www.riverbankcomputing.com/software/pyqt/download
% \end{verbatim}
% 
% Then extract and build it (this installs by default into the Python framework):
% 
% \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{Leopard notes}
% 
% If building on Leopard, using Leopard's bundled Python, PyQt wants to install in
% the system path -- this is not a good idea.  Use this configure command instead
% of the basic configure above:
% 
% \begin{verbatim}
% python configure.py -d /Library/Python/2.5/site-packages -b /usr/local/bin
% \end{verbatim}
% 
% There may be a problem with undefined symbols in QtOpenGL on Leopard.  Edit
% QtOpenGL/makefile and add -undefined dynamic\_lookup to LFLAGS.

\subsubsection{Dépendances supplémentaires : PyQt}
Si vous rencontrez des problèmes pour compiler PyQt en suivant les instructions suivantes, vous pouvez essayez d'ajouter explicitement le chemin vers votre environnement python:

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

Obtenez les liens python pour Qt depuis

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

Puis extrayez et compilez :

\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{Notes}

Si vous compilez sous Leopard avec la version de Python embarquée, PyQt voudra s'installer dans le chemin système -- ce qui n'est pas une bonne idée. Utilisez cette commande de configuration à la place la commande précédente:

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

Un problème avec des symboles non définis dans QtOpenGL peut se présenter sous Leopard.  Éditez
QtOpenGL/makefile et ajoutez -undefined dynamic\_lookup aux LFLAGS.

\subsubsection{Dépendances supplémentaires : Bison}
\underline{Note:} Leopard inclut Bison 2.3, cette étape peut être ignorée.

La version par défaut de bison sous Mac OSX est trop ancienne ancienne pour vos besoins, télécharger une version plus récente:

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

Maintenant compilez et installez dans un préfix de /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{Installer CMAKE pour OSX}
Obtenez la dernière version à:

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

La version utilisée au moment de l'écriture de cette partie est:

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

Une fois téléchargé, installez le fichier .dmg

\subsection{Installer subversion pour OSX}
\underline{Note:} Leopard inclut SVN, cette étape peut donc être ignorée sous Leopard.

Ce \url{http://sourceforge.net/projects/macsvn/} projet a une version téléchargeable de svn. Si vous préférez une interface, pensez à prendre leur client graphique. Téléchargez l'interface console ici:

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

Vous devez également installer BerkleyDB disponible à \url{http://sourceforge.net/projects/macsvn/}. 

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

Une fois encore, extrayez l'archive zip et exécuter l'installateur qu'elle contient. Enfin, nous devons nous assurer que la commande svn a le bon chemin. Ajoutez la ligne suivante à la fin de /etc/bashrc en utilisant sudo:

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

Et ajoutez cette ligne en bas avant de sauvegarder et quitter:

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

/usr/local/bin doit être le premier sur le chemin pour que la nouvelle version de bison (que nous allons compiler par la suite) soit trouvée avant celle embarquée par MacOSX.

Maintenant, fermez et rouvrez votre console pour bénéficier des variables à jour.

% \subsection{Check out QGIS from SVN}
% Now we are going to check out the sources for QGIS. First we will create a
% directory for working in:
% 
% \begin{verbatim}
% mkdir -p ~/dev/cpp cd ~/dev/cpp 
% \end{verbatim}
% 
% Now we check out the sources:
% 
% Trunk:
% 
% \begin{verbatim}
% svn co https://svn.osgeo.org/qgis/trunk/qgis qgis 
% \end{verbatim}
% 
% For svn 0.8 branch
% 
% \begin{verbatim}
% svn co https://svn.osgeo.org/qgis/branches/Release-0_8_0 qgis0.8
% \end{verbatim}
% 
% For svn 0.9 branch
% 
% \begin{verbatim}
% svn co https://svn.qgis.org/qgis/branches/Release-0_9_0 qgis0.9
% \end{verbatim}
% 
% The first time you check out QGIS sources you will probably get a message like
% this:
% 
% \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}
% 
% I suggest you press 'p' to accept the key permanently.

\subsection{Obtenir QGIS avec SVN}
Nous allons maintenant vérifier les sources de QGIS. Nous allons d'abord créer un répertoire de travail:

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

Maintenant nous téléchargeons les sources:

Pour la branche principale:

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

Pour la branche de la version 

\begin{verbatim}
svn co https://svn.osgeo.org/qgis/branches/Version-1_0
\end{verbatim}

Au premier téléchargement, vous allez sans doute avoir le message suivant:

\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}

Je vous recommande d'appuyer sur 'p' pour accepter la clé de manière permanente.

% \subsection{Configure the build}
% CMake supports out of source build so we will create a 'build' dir for the
% build process. By convention I build my software into a dir called 'apps' in
% my home directory. If you have the correct permissions you may want to build
% straight into your /Applications folder. The instructions below assume you are
% building into a pre-existing \$\{HOME\}/apps directory ...
% 
% \begin{verbatim}
% cd qgis
% mkdir build
% cd build
% cmake -D CMAKE_INSTALL_PREFIX=$HOME/apps/ -D CMAKE_BUILD_TYPE=Release ..
% \end{verbatim}
% 
% \underline{Leopard note:} To find the custom install of SIP on Leopard, add ""-
% D SIP\_BINARY\_PATH=/usr/local/bin/sip"" to the cmake command above,
% before the .. at the end, ie:
% 
% \begin{verbatim}
% cmake -D CMAKE_INSTALL_PREFIX=$HOME/apps/ -D CMAKE_BUILD_TYPE=Release -
% D SIP_BINARY_PATH=/usr/local/bin/sip ..
% \end{verbatim}
% 
% To use the application build of GRASS on OSX, you can optionally use the
% following cmake invocation (minimum GRASS 6.3 required, substitute the GRASS
% version as required):
% 
% \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}
% 
% Or, to use a Unix-style build of GRASS, use the following cmake invocation
% (minimum GRASS version as stated in the Qgis requirements, substitute the GRASS
% path and version as required):
% 
% \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{Configurer la compilation}
Nous allons créer un dossier 'build' pour le processus de compilation. Par convention, je compile mes logiciels dans un répertoire 'apps' présent dans mon dossier personnel /home. Si les permissions sont accrodées, vous pouvez directement compiler dans votre répertoire /Applications. Les instructions qui suivent présupposent que vous travaillez dans le dossier \$\{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{Note:} Pour trouver l'installation personnalisée de SIP sous Leopard, ajoutez ""-D SIP\_BINARY\_PATH=/usr/local/bin/sip"" à la commande cmake ci-dessus, avant les .. de la fin:

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

Pour utiliser GRASS depuis le dossier Applications sous OSX, vous pouvez utilisez l'option cmake suivante (GRASS 6.3 est la version minimum requise, modifier le numéro au besoin):

\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}

Ou, dans un style Unix, utilisez l'option suivante:

\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{Building}
% Now we can start the build process:
% 
% \begin{verbatim}
% make 
% \end{verbatim}
% 
% If all built without errors you can then install it:
% 
% \begin{verbatim}
% make install 
% \end{verbatim}
% 
% \section{Building on GNU/Linux}\label{sec:install_linux}
% \subsection{Building QGIS with Qt4.x}
% \textbf{Requires:} Ubuntu Hardy / Debian derived distro
% 
% These notes are current for Ubuntu 7.10 - other versions and Debian derived 
% distros may require slight variations in package names.
% 
% These notes are for if you want to build QGIS from source. One of the major
% aims here is to show how this can be done using binary packages for
% \textbf{*all*}
% dependencies - building only the core QGIS stuff from source. I prefer this
% approach because it means we can leave the business of managing system packages
% to apt and only concern ourselves with coding QGIS! 
% 
% This document assumes you have made a fresh install and have a 'clean' system.
% These instructions should work fine if this is a system that has already been
% in use for a while, you may need to just skip those steps which are irrelevant
% to you.

\subsection{Compilation}
maintenant nous pouvons démarrer la compilation de QGIS:

\begin{verbatim}
make 
\end{verbatim}

Si tout se passe sans erreurs ou avertissements, vous pouvez l'installer avec:

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

\section{Compilation sous GNU/Linux}\label{sec:install_linux}
\subsection{Compiler QGIS avec Qt4.x}
\textbf{Requiert:} Ubuntu Hardy / Debian

Ces notes sont pour Ubuntu 7.10 - d'autres versions ou distributions dérivées de Debian peuvent nécessiter de légères adaptations.

Le but principal est de vous montrer que l'on compiler QGIS en utilisant exclusivement des paquets binaires pour \textbf{*toutes*} les dépendances - en n'utilisant les sources que pour le coeur de QGIS. Je préfère cette approche, car elle signifie que nous pouvons concentrer sur QGIS en laissant apt se dépatouiller pour toute la gestion.

Ce document part du principe que votre installation vient juste d'être installée. Si vous l'avez déjà utilisée pendant quelque temps, vous aurez sans doute à sauter quelques passages inutiles.

% \subsection{Prepare apt}
% The packages qgis depends on to build are available in the "universe" component
% of Ubuntu. This is not activated by default, so you need to activate it:
% 
% 1. Edit your /etc/apt/sources.list file.  
% 2. Uncomment the all the lines starting with "deb"
% 
% Also you will need to be running (K)Ubuntu 'edgy' or higher in order for 
% all dependencies to be met.
% 
% Now update your local sources database:
% 
% \begin{verbatim}
% sudo apt-get update 
% \end{verbatim}

\subsection{Préparer apt}
Les paquets desquels dépend QGIS sont disponibles dans la source "universe"d'Ubuntu. Vous devez l'activer manuellement:

1. Éditez votre fichier /etc/apt/sources.list   
2. Décommentez toutes les lignes début par "deb"

Vous aurez besoin d'utiliser (K)Ubuntu 'edgy' ou supérieur pour que toutes les dépendances puissent être résolues.

Mettez à jour les bases de données des sources:

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

% \subsection{Install 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{A Special Note:} If you are following this set of instructions on
% a system where you already have Qt3 development tools installed, there will
% be a conflict between Qt3 tools and Qt4 tools. For example, qmake will
% point to the Qt3 version not the Qt4. Ubuntu Qt4 and Qt3 packages are
% designed to live alongside each other. This means that for example if you
% have them both installed you will have three qmake exe's:
% 
% \begin{verbatim}
% /usr/bin/qmake -> /etc/alternatives/qmake 
% /usr/bin/qmake-qt3
% /usr/bin/qmake-qt4 
% \end{verbatim}
% 
% The same applies to all other Qt binaries. You will notice above that the
% canonical 'qmake' is managed by apt alternatives, so before we start to
% build QGIS, we need to make Qt4 the default. To return Qt3 to default later
% you can use this same process.
% 
% You can use apt alternatives to correct this so that the Qt4 version of
% applications is used in all cases:
% 
% \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}
% 
% Use the simple command line dialog that appears after running each of the
% above commands to select the Qt4 version of the relevant applications.

\subsection{Installer 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{Note spéciale:} Si vous suivez ce guide sur un système où les outils de développements de Qt3 sont déjà installés, vous risquez des conflits avec Qt4 notemment avec qmake. Par exemple, qmake peut pointer vers Qt3 et par vers Qt4. Les pacquets Ubuntu Qt3 et Qt4 sont pour être indépedants. Ubuntu gère cette situation en fournissant 3 exécutables différents pour qmake:

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

La même règle s'applique à tous les autres exécutables de Qt. Vous remarquerez que le nom générique 'qmake' est géré par apt. Avant de compiler QGIS, il faut s'assurer les outils Qt4 soient sélectionnés. Pour revenir à la version antérieure Qt3, vous pouvez utiliser le même processus.

\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}

Utilisez le dialogue console qui se présente après chacune de ces commandes pour définir la version de Qt pour chacune des applications.

% \subsection{Install additional software dependencies required by 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{Note:} Debian users should use libgdal-dev above rather
% 
% \textbf{Note:} For python language bindings SIP $>$= 4.5 and PyQt4 $>$= 4.1 is
% required! Some stable GNU/Linux
% distributions (e.g. Debian or SuSE) only provide SIP $<$ 4.5 and PyQt4 $<$ 4.1.
% To include support for python 
% language bindings you may need to build and install those packages from source.
% 
% If you do not have cmake installed already:
% 
% \begin{verbatim}
% sudo apt-get install cmake
% \end{verbatim}

\subsection{Installer les dépendances additionnelles requises par 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{Note:} Les utilisateurs Debian devraient plutôt utiliser libgdal-dev ci-dessus.

\textbf{Note:} Pour les liens python, SIP $>$= 4.5 and PyQt4 $>$= 4.1 sont requis. Certaines distributions (e.g. Debian ou SuSE) fournissent seulement SIP $<$ 4.5 and PyQt4 $<$ 4.1. Il vous faudra compiler ces paquets depuis les sources.

Si cmake n'est pas encore installé:

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

% \subsection{GRASS Specific Steps}
% \textbf{Note:} If you don't need to build with GRASS support,  you can
% skip this section.
% 
% Now you can install grass from dapper:
% 
% \begin{verbatim}
% sudo apt-get install grass libgrass-dev libgdal1-1.4.0-grass 
% \end{verbatim}
% 
% /!$\backslash$ You may need to explicitly state your grass version e.g.
% libgdal1-1.3.2-grass

\subsection{Etapes spécifiques à GRASS}
\textbf{Note:} Si vous n'avez pas besoin du support de GRASS, vous pouvez passer cette partie.

Vous pouvez installer GRASS depuis dapper:

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

/!$\backslash$ Vous aurez peut-être à définir votre version de grass, e.g. libgdal1-1.3.2-grass

% \subsection{Setup ccache (Optional)}
% You should also setup ccache to speed up compile times:
\subsection{Installer ccache (Optionnel)}
Vous pouvez installer ccache pour accélérer la compilation:

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

% \subsection{Prepare your development environment}
% As a convention I do all my development work in \$HOME/dev/$<$language$>$, so in
% this case we will create a work environment for C++ development work like
% this:
% This directory path will be assumed for all instructions that follow.

\subsection{Preparer votre environnement de développement}
Par convention, je fais mon développement dans \$HOME/dev/$<$langage$>$, donc dans le cas présent nous allons créer un répertoire pour le C++: Ce répertoire sera valable pour toutes les commandes qui suivent.

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

% \subsection{Check out the QGIS Source Code}
% There are two ways the source can be checked out. Use the anonymous method
% if you do not have edit privaleges for the QGIS source repository, or use
%   the developer checkout if you have permissions to commit source code
%   changes.
% 
% 1. Anonymous Checkout
% 
% 2. Developer Checkout
% 
% The first time you check out the source you will be prompted to accept the
% qgis.org certificate. Press 'p' to accept it permanently:

\subsection{Obtenir le code source de QGIS}
Il ya deux façons de faire, utilisez la méthode anonyme si vous n'avez aucun droit d'édition sur le répertoire svn de QGIS, ou la méthode développeur si vous pouvez soumettre des changements aux sources.

1. Méthode anonyme

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

2.Méthode développeur

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

Au premier essai, il vous faudra accepter le certificat de sécurité de QGIS. Appuyez sur 'p' pour que ce soit permanent:

\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{Starting the compile}
% \textbf{Note:} The next section describes howto build debian packages
% 
% I compile my development version of QGIS into my \~{}/apps directory to avoid
% conflicts with Ubuntu packages that may be under /usr. This way for example
% you can use the binary packages of QGIS on your system along side with your
% development version. I suggest you do something similar:
% 
% \begin{verbatim}
% mkdir -p ${HOME}/apps 
% \end{verbatim}
% 
% Now we create a build directory and run ccmake:
% 
% \begin{verbatim}
% cd qgis
% mkdir build
% cd build
% ccmake ..
% \end{verbatim}
% 
% When you run ccmake (note the .. is required!), a menu will appear where 
% you can configure various aspects of the build. If you do not have root
% access or do not want to overwrite existing QGIS installs (by your
% packagemanager for example), set the CMAKE\_BUILD\_PREFIX to somewhere you
% have write access to (I usually use /home/timlinux/apps). Now press
% 'c' to configure, 'e' to dismiss any error messages that may appear.
% and 'g' to generate the make files. \textbf{Note:} that sometimes 'c' needs to 
% be pressed several times before the 'g' option becomes available.
% After the 'g' generation is complete, press 'q' to exit the ccmake 
% interactive dialog.
% 
% Now on with the build:
% 
% \begin{verbatim}
% make
% make install
% \end{verbatim}
% 
% It may take a little while to build depending on your platform.

\subsection{Commencer la compilation}
\textbf{Note:} La section suivante explique comment faire un paquet Debian

Je compile les versions de développements de QGIS dans mon répertoire \~{}/apps pour éviter des conflits avec les paquets Ubuntu présents dans /usr. De cette manière, vous pouvez utiliser une version de développement en même temps que la version la distribution. Je vous conseille de faire de même:

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

maintenant créons un répertoire de travail et lançons ccmake:

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

Quand nous lançons ccmake (les .. sont requis), un menu apparaît pour vous laisser configurer différents aspects de la compilation. Si vous n'avez pas l'accès root ou ne voulez pas écraser une version existante, définissez CMAKE\_BUILD\_PREFIX vers un autre emplacement (/home/timlinux/apps). Maintenant appuyez sur 'c' pour configurer, 'e' pour écarter les différents messages d'erreurs et 'g' pour générer les fichiers make. \textbf{Note:} quelquefois il faut appuyez sur 'c' à plusieurs reprises pour permettre de disposer de 'g'.
Quand la génération est terminée, appuyez sur 'q' pour sortir du dialogue interactif de ccmake.

passons à la compilation:

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

Cela peut prendre plus ou moins de temps selon votre ordinateur.

% \subsection{Building Debian packages}
% Instead of creating a personal installation as in the previous step you can
% also create debian package.  This is done from the qgis root directory, where
% you'll find a debian directory.
% 
% First you need to install the debian packaging tools once:
% 
% \begin{verbatim}
% apt-get install build-essential
% \end{verbatim}
% 
% The QGIS packages will be created with:
% 
% \begin{verbatim}
% dpkg-buildpackage -us -us -b
% \end{verbatim}
% 
% \textbf{Note:} If \texttt{dpkg-buildpackage} complains about unmet build
% dependencies
% you can install them using \texttt{apt-get} and re-run the command.
% 
% \textbf{Note:} If you have \texttt{libqgis1-dev} installed, you need to remove
% it first
% using \texttt{dpkg -r libqgis1-dev}.  Otherwise \texttt{dpkg-buildpackage} will
% complain about a
% build conflict.
% 
% The the packages are created in the parent directory (ie. one level up).
% Install them using dpkg.  E.g.:
% 
% \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{Construire un paquet Debian}
Au lieu de créer une installation personnalisée comme dans les étapes précédentes, vous créer un paquet Debian réutilisable. 	
Cela se fait à partir du répertoire racine QGIS, où vous trouverez un répertoire debian.

vous avez d'abord besoin d'installer les outils de paquetage de Debian:

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

Le paquet QGIS se crée avec la commande suivante:

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

\textbf{Note:} Si \texttt{dpkg-buildpackage} se plaint de dépendances non résolues, vous devrez les installer avec \texttt{apt-get} et relancer la commande.

\textbf{Note:} Si vous avez installé \texttt{libqgis1-dev}, vous devez l'effacer avec \texttt{dpkg -r libqgis1-dev} ou \texttt{dpkg-buildpackage} se plaindra d'un conflit.

Les paquets sont créés dans le répertoire Parent ( ie, un niveau au-dessus).
Installez-les avec dpkg:

\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{Running QGIS}
% Now you can try to run QGIS:
% 
% \begin{verbatim}
% $HOME/apps/bin/qgis 
% \end{verbatim}
% 
% If all has worked properly the QGIS application should start up and appear
% on your screen.

\subsection{Lancer QGIS}
Vous pouvez essayer d'exécuter QGIS:

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

Si tout à bien fonctionné, l'application devrait apparaître sur votre écran.

% \section{Creation of MSYS environment for compilation of Quantum GIS}
% \subsection{Initial setup}
% \subsubsection{MSYS}
% This is the environment that supplies many utilities from UNIX world in Windows
% and is needed
% by many dependencies to be able to compile.
% 
% Download from here:
% 
% \url{
% http://puzzle.dl.sourceforge.net/sourceforge/mingw/MSYS-1.0.11-2004.04.30-1.exe}
% 
% Install to \texttt{c:$\backslash$msys}
% 
% All stuff we're going to compile is going to get to this directory (resp. its
% subdirs).

\section{Création d'un environnement MSYS pour la compilation de Quantum GIS}
\subsection{Installation initiale}
\subsubsection{MSYS}
Cet environnement fournit des utilitaires UNIX pour Windows et est nécessaire pour compiler nombre de dépendances.

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

Installez le dans \texttt{c:$\backslash$msys}

Tout ce que nous allons compiler sera placé dans ce répertoire.

% \subsubsection{MinGW}
% Download from here:
% 
% \url{http://puzzle.dl.sourceforge.net/sourceforge/mingw/MinGW-5.1.3.exe}
% 
% Install to \texttt{c:$\backslash$msys$\backslash$mingw}
% 
% It suffices to download and install only \texttt{g++} and \texttt{mingw-make}
% components.

\subsubsection{MinGW}
A télécharger depuis:

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

Installez le à \texttt{c:$\backslash$msys$\backslash$mingw}

Il suffit de télécharger et d'installer les composants \texttt{g++} et \texttt{mingw-make}.

% \subsubsection{Flex and Bison}
% Flex and Bison are tools for generation of parsers, they're needed for GRASS and
% also QGIS compilation.
% 
% Download the following packages:
% 
% \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}
% 
% Unpack them all to \texttt{c:$\backslash$msys$\backslash$local}

\subsubsection{Flex et Bison}
Flex et Bison sont des outils indispensables à la compilation de GRASS et QGIS. 

Téléchargez les paquets suivants:

\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}

extrayez les vers \texttt{c:$\backslash$msys$\backslash$local}

% \subsection{Installing dependencies}
% \subsubsection{Getting ready}
% Paul Kelly did a great job and prepared a package of precompiled libraries for
% GRASS.
% The package currently includes:
% 
% \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}
% 
% It's available for download here:
% 
% \url{http://www.stjohnspoint.co.uk/grass/wingrass-extralibs.tar.gz}
% 
% Moreover he also left the notes how to compile it (for those interested):
% 
% \url{http://www.stjohnspoint.co.uk/grass/README.extralibs}
% 
% Unpack the whole package to \texttt{c:$\backslash$msys$\backslash$local}

\subsection{Installation des dépendances}
\subsubsection{Préparation}
Paul Kelly a fourni un énorme travail en préparant un paquet contenant des bibliothèques précompilées pour GRASS:

\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}

C'est disponible à:

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

Et pour ceux qui sont intéressés, il a laissé des notes sur la façon de les compiler:

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

extrayez le tout vers \texttt{c:$\backslash$msys$\backslash$local}

% \subsubsection{GDAL level one}
% Since Quantum GIS needs GDAL with GRASS support, we need to compile GDAL
% from source - Paul Kelly's package doesn't include GRASS support in GDAL.
% The idea is following:
% 
% \begin{enumerate}
% \item compile GDAL without GRASS
% \item compile GRASS
% \item compile GDAL with GRASS
% \end{enumerate}
% 
% So, start with downloading GDAL sources:
% 
% \url{http://download.osgeo.org/gdal/gdal141.zip}
% 
% Unpack it to some directory, preferably
% \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}.
% 
% Start MSYS console, go to gdal-1.4.1 directory and run the commands below.
% You can put them all to a script, e.g. build-gdal.sh and run them at once.
% The recipe is taken from Paul Kelly's instructions - basically they
% just make sure that the library will be created as DLL and the utility
% programs will be dynamically linked to it...

\subsubsection{GDAL étape une}
Puisque Quantum GIS nécessite GDAL avec un support GRASS, nous avons besoin de compiler GDAL depuis les sources, car le paquet de Paul Kelly ne contient pas ce support.
Le programme est le suivant:

\begin{enumerate}
\item compiler GDAL sansGRASS
\item compiler GRASS
\item compiler GDAL avec GRASS
\end{enumerate}

Donc, commençons par télécharger les sources de GDAL:

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

Extrayez le dans un répertoire, de préférence \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}.

Lancez une console MSYS, allez dans le répertoire de gdal-1.4.1 et exécutez la commande suivante. Vous pouvez toutes les placer dans un script shell, p. ex. build-gdal.sh, puis le lancer. Cette procédure permet de s'assurer que la bibliothèque est bien créée en tant que DLL et que les programmes lui seront dynamiquement liés.

\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}

% Finally, manually edit \texttt{gdal-config} in
% \texttt{c:$\backslash$msys$\backslash$local$\backslash$bin} to replace the
% static library reference with -lgdal:
% 
% \begin{verbatim}
% CONFIG_LIBS="-L/usr/local/lib -lpng -lz -lgdal"
% \end{verbatim}
% GDAL build procedure can be greatly simplified to use libtool with a libtool
% line patch:
% configure gdal as below:
% ./configure --with-ngpython --with-xerces=/local/ --with-jasper=/local/
% --with-grass=/local/grass-6.3.cvs/ --with-pg=/local/pgsql/bin/pg\_config.exe 
% 
% Then fix libtool with:
% mv libtool libtool.orig
% cat libtool.orig $|$ sed 's/max\_cmd\_len=8192/max\_cmd\_len=32768/g' $>$
% libtool
% 
% Libtool on windows assumes a line length limit of 8192 for some reason and tries
% to page the linking and fails miserably. This is a work around.
% 
% Make and make install should be hassle free after this.

Finalement, éditez manuellement \texttt{gdal-config} dans \texttt{c:$\backslash$msys$\backslash$local$\backslash$bin} pour remplacer les références statiques par -lgdal:

\begin{verbatim}
CONFIG_LIBS="-L/usr/local/lib -lpng -lz -lgdal"
\end{verbatim}
la procédure de compilation de GDAL peut être simplifié en utilisant libtool grâçe à un petit rectificatif, configurer gdal comme il suit:
./configure --with-ngpython --with-xerces=/local/ --with-jasper=/local/
--with-grass=/local/grass-6.3.cvs/ --with-pg=/local/pgsql/bin/pg\_config.exe 

puis corriger libtool avec:
mv libtool libtool.orig
cat libtool.orig $|$ sed 's/max\_cmd\_len=8192/max\_cmd\_len=32768/g' $>$
libtool

Libtool sous Windows gére une longueur de ligne de 8192 et essaye de rechercher les liaisons mais il se plante lamentablement. C'est le moyen de le contourner.

Make et make install devraient fonctionner sans souci après ça.

% \subsubsection{GRASS}
% Grab sources from CVS or use a weekly snapshot, see:
% 
%  \begin{quotation}
% \htmladdnormallink{http://grass.itc.it/devel/cvs.php}{
% http://grass.itc.it/devel/cvs.php}
%  \end{quotation}
% 
% In MSYS console go to the directory where you've unpacked or checked out sources
% (e.g.
% \texttt{
% c:$\backslash$msys$\backslash$local$\backslash$src$\backslash$grass-6.3.cvs})
% 
% Run these commands:

\subsubsection{GRASS}
Obtenez les sources depuis CVS ou téléchargez un instantané hebdomadaire:

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

Dans la console MSYS allez dans le répertoire où vous avez placé les sources (e.g. \texttt{c:$\backslash$msys$\backslash$local$\backslash$src$\backslash$grass-6.3.cvs})

Lancez ces commandes:

\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}

% It should get installed to
% \texttt{c:$\backslash$msys$\backslash$local$\backslash$grass-6.3.cvs}
% 
% By the way, these pages might be useful:

L'installation devrait se faire dans \texttt{c:$\backslash$msys$\backslash$local$\backslash$grass-6.3.cvs}

Ces pages pourraient aussi être utiles:

\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 level two}
% At this stage, we'll use GDAL sources we've used before, only the compilation
% will be a bit different.
% 
% But first in order to be able to compile GDAL sources with current GRASS CVS,
% you need to patch them, here's what you need to change:
% 
%  \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}
% (you can patch it by hand or use patch.exe in
% \texttt{c:$\backslash$msys$\backslash$bin})
% 
% Now in MSYS console go to the GDAL sources directory and run the same commands
% as in level one, only with these differences:

\subsubsection{GDAL étape deux}
À cette étape, nous allons utiliser les sources de GDAL que nous avons utilisé précédemment, seule la compilation diffère.

Mais d'abord, vous devez pouvoir compiler GDAL avec le CVS actuel de GRASS en le fixant avec:

 \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}
(vous pouvez les fixer à la main ou avec patch.exe dans \texttt{c:$\backslash$msys$\backslash$bin})

maintenant dans la console MSYS allez dans le répertoire des sources de GDAL et lancez les mêmes commandes que l'étape une, avec une différence:

\begin{verbatim}
1)rajoutez cet argument lors de ./configure:
--with-grass=/usr/local/grass-6.3.cvs

2) quand vous faites appel à g++ à la ligne 5 (ce qui crée libgdal.dll), ajoutez ces 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}

% Then again, edit \texttt{gdal-config} and change line with CONFIG\_LIBS
Puis encore une fois éditez \texttt{gdal-config} et changez la ligne 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}

% Now, GDAL should be able to work also with GRASS raster layers.
Maintenant GDAL devrait fonctionner avec les couches vecteurs de GRASS.

% \subsubsection{GEOS}
% Download the sources:
% 
% \url{http://geos.refractions.net/geos-2.2.3.tar.bz2}
% 
% Unpack to e.g. \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}
% 
% To compile, I had to patch the sources: in file
% \texttt{source/headers/timeval.h} line 13.
% Change it from:

\subsubsection{GEOS}
Téléchargez les sources depuis:

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

Extrayez les vers \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}

Pour compiler, j'ai du changer le fichier \texttt{source/headers/timeval.h} à la ligne 13:

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

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

% Now, in MSYS console, go to the source directory and run:
Dans la console MSYS, allez dans le répertoire source et faites:

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

% \subsubsection{SQLITE}
% You can use precompiled DLL, no need to compile from source:
% 
% Download this archive:
% 
% 
% \url{http://www.sqlite.org/sqlitedll-3\_3\_17.zip}
% 
% and copy sqlite3.dll from it to
% \texttt{c:$\backslash$msys$\backslash$local$\backslash$lib}
% 
% Then download this archive:
% 
% \url{http://www.sqlite.org/sqlite-source-3\_3\_17.zip}
% 
% and copy sqlite3.h to
% \texttt{c:$\backslash$msys$\backslash$local$\backslash$include}

\subsubsection{SQLITE}
Vous pouvez utiliser la DLL précompilé en téléchargeant cette archive:
\url{http://www.sqlite.org/sqlitedll-3\_3\_17.zip}

et copiez sqlite3.dll vers \texttt{c:$\backslash$msys$\backslash$local$\backslash$lib}

Puis télécharger:

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

et copiez sqlite3.h vers \texttt{c:$\backslash$msys$\backslash$local$\backslash$include}

% \subsubsection{GSL}
% Download sources:
% 
% \url{ftp://ftp.gnu.org/gnu/gsl/gsl-1.9.tar.gz}
% 
% Unpack to \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}
% 
% Run from MSYS console in the source directory:
% 
% \begin{verbatim}
% ./configure
% make
% make install
% \end{verbatim}
\subsubsection{GSL}
Sources à télécharger:

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

A extraire vers \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}

Allez dans le répertoire des sources via la console MSYS:

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

% \subsubsection{EXPAT}
% Download sources:
% 
% \url{http://dfn.dl.sourceforge.net/sourceforge/expat/expat-2.0.0.tar.gz}
% 
% Unpack to \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}
% 
% Run from MSYS console in the source directory:
% 
% \begin{verbatim}
% ./configure
% make
% make install
% \end{verbatim}

\subsubsection{EXPAT}
Téléchargez les sources:

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

Extrayez vers \texttt{c:$\backslash$msys$\backslash$local$\backslash$src}

Allez dans le répertoire des sources via la console MSYS:

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

% \subsubsection{POSTGRES}
% We're going to use precompiled binaries. Use the link below for download:
% 
% \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}
% 
% copy contents of pgsql directory from the archive to
% \texttt{c:$\backslash$msys$\backslash$local}

\subsubsection{POSTGRES}
On va utiliser les binaires précompilés que vous pouvez télécharger ici:

\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}

copiez le contenu du répertoire pgsql depuis l'archive vers \texttt{c:$\backslash$msys$\backslash$local}

% \subsection{Cleanup}
% We're done with preparation of MSYS environment. Now you can delete all stuff in
% \texttt{c:$\backslash$msys$\backslash$local$\backslash$src} - it takes quite a
% lot
% of space and it's not necessary at all.

\subsection{Nettoyage}
Nous avons terminé la création d'un environnement MSYS, vous pouvez effacer tout ce qui ce trouve dans \texttt{c:$\backslash$msys$\backslash$local$\backslash$src},ce n'est plus utile et gâche de l'espace disque.

% \section{Building with MS Visual Studio}
% /!$\backslash$ This section describes a process where you build all dependencies
% yourself. See the section
% after this for a simpler procedure where we have all the dependencies you need
% pre-packaged
% and we focus just on getting Visual Studio Express set up and building QGIS.
% 
% \textbf{Note:} that this does not currently include GRASS or Python plugins.

\section{Compiler avec MS Visual Studio}
/!$\backslash$ Cette section décrit comment compiler soi-même toutes les dépendances. Lisez la prochaine section pour une procédure plus simple où toutes les dépendances sont déjà préparées.

\textbf{Note:} Cela n'inclut actuellement pas GRASS et Python.

% \subsection{Setup Visual Studio}
% This section describes the setup required to allow Visual Studio to be used to
% build QGIS. 

\subsection{Installer Visual Studio}
Cette section décrit la configuration requise pour permettre à Visual Studio d'être utilisé pour compiler QGIS. 

% \subsubsection{Express Edition}
% The free Express Edition lacks the platform SDK which contains headers and so on
% that are needed when building QGIS. The platform SDK can be installed as
% described here:

\subsubsection{Express Edition}
La version Express est gratuite mais ne dispose pas du SDK qui contient les en-têtes qui sont indispensables à la compilation de QGIS. 
Le SDK peut être installé comme décrit ici:

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

% Once this is done, you will need to edit the
% $<$vsinstalldir$>$$\backslash$Common7$\backslash$Tools$\backslash$vsvars file as
% follows:
% 
%  \begin{quotation}
% Add \texttt{\%PlatformSDKDir\%$\backslash$Include$\backslash$atl} and
% \texttt{\%PlatformSDKDir\%$\backslash$Include$\backslash$mfc} to the
% \texttt{@set INCLUDE} entry.
%  \end{quotation}
% This will add more headers to the system INCLUDE path. \textbf{Note:} that this
% will only work when you use the Visual Studio command prompt when building. Most
% of the dependencies will be built with this.
% You will also need to perform the edits described here to remove the need for a
% library that Visual Studio Express lacks:
% 
% \url{http://www.codeproject.com/wtl/WTLExpress.asp}

Une fois cela fait, vous devez éditez le fichier $<$vsinstalldir$>$$\backslash$Common7$\backslash$Tools$\backslash$vsvars comme il suit:

 \begin{quotation}
Ajoutez \texttt{\%PlatformSDKDir\%$\backslash$Include$\backslash$atl} et \texttt{\%PlatformSDKDir\%$\backslash$Include$\backslash$mfc} à l'entrée \texttt{@set INCLUDE}.
 \end{quotation}
Cela ajoutera plus d'en-têtes dans le chemin INCLUDE du système. \textbf{Note:} Cela ne fonctionne que si vous utilisez la console de commandes quand vous compilez avec Visual Studio. Vous devez également faire une modification pour pallier l'absence d'une bibliothèque dans Visual Studio Express:

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

% \subsubsection{All Editions}
% You will need stdint.h and unistd.h. unistd.h comes with GnuWin32 version of
% flex \& bison binaries (see later). stdint.h can be found here:
% 
% \url{http://www.azillionmonkeys.com/qed/pstdint.h}
% 
% Copy both of these to $<$vsinstalldir$>$$\backslash$VC$\backslash$include.

\subsubsection{Toutes les Éditions}
Vous avez besoin de stdint.h et unistd.h. unistd.h vient avec la version GnuWin32 des binaires de flex \& bison (à voir par la suite). stdint.h peut se trouver ici:

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

Copiez les deux vers $<$vsinstalldir$>$$\backslash$VC$\backslash$include.

% \subsection{Download/Install Dependencies}
% This section describes the downloading and installation of the various QGIS
% dependencies.

\subsection{Télécharger/Installer les Dépendances}
Cette section décrit le téléchargement et l'installation des différentes dépendances de QGIS.

% \subsubsection{Flex and Bison}
% Flex and Bison are tools for generation of parsers, they're needed for GRASS and
% also QGIS compilation.
% 
% Download the following packages and run the installers:

\subsubsection{Flex et Bison}
Télécharger les paquets suivants et lancez les installateurs:

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

% \subsubsection{To include  PostgreSQL support in Qt}
% If you want to build Qt with PostgreSQL support you need to download
% PostgreSQL, install it and create a library you can later link with Qt.
% 
% Download from .../binary/v8.2.5/win32/postgresql-8.2.5-1.zip from an
% PostgreSQL.org Mirror and install.
% 
% PostgreSQL is currently build with MinGW and comes with headers and libraries
% for MinGW.  The headers can be used with Visual C++ out of the box, but the
% library
% is only shipped in DLL and archive (.a) form and therefore cannot be used with
% Visual C++ directly.
% 
% To create a library copy following sed script to the file mkdef.sed in
% PostgreSQL lib directory:

\subsubsection{Pour inclure le support de PostgreSQL dans Qt}
Vous devez télécharger PostgreSQL, l'installer et créer une bibliothèque que vous pourrez ensuite lier à Qt.

Téléchargez  .../binary/v8.2.5/win32/postgresql-8.2.5-1.zip depuis un serveur de PostgreSQL.org.

PostgreSQL est actuellement compilé avec MinGW et dispose d'en-têtes et une bibliothèque pour MinGW.   Les en-têtes peuvent être utilisés directement avec Visual C++ mais la bibliothèque est seulement fournit sous forme DLL ou archive (.a) et ne peut donc pas être utilisés directement avec Visual C++.
Visual C++ directly.

Pour créer une bibliothèque, copiez le script sed suivant dans le fichier mkdef.sed dans répertoire lib de 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}

% and process execute in the Visual Studio C++ command line (from Programs menu):
et éxucter ces commandes dans la console de Visual Studio C++:

\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}

% You'll need an sed for that to work in your path (e.g. from cygwin or msys).
% 
% That's almost it. You only need to the include and lib path to INCLUDE and LIB
% in vcvars.bat respectively.

Vous aurez besoin de sed pour que ça marche (e.g. venant de cygwin ou de msys).

On y est presque. Vous devez modifier les chemins INCLUDE et LIB dans vcvars.bat.

\subsubsection{Qt}
% Build Qt following the instructions here:
Compiler Qt avec ces instructions:

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

% \subsubsection{Proj.4}
% Get proj.4 source from here:
% 
% \url{http://proj.maptools.org/}
% 
% Using the Visual Studio command prompt (ensures the environment is setup
% properly), run the following in the src directory:
% 
% \begin{verbatim}
% nmake -f makefile.vc
% \end{verbatim}
% 
% Install by running the following in the top level directory setting PROJ\_DIR as
% appropriate:

\subsubsection{Proj.4}
Téléchargez les sources de proj.4 source depuis:

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

Avec la commande de Visual Studio, exécutez ce qui suit dans le répertoire src:

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

Installez en lançant les commandes suivantes dans le répertoire supérieur pour configurer correctement PROJ\_DIR:

\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}

Vous pouvez rassembler ces commandes dans un script.

% \subsubsection{GSL}
% Get gsl source from here:
% 
% \url{http://david.geldreich.free.fr/downloads/gsl-1.9-windows-sources.zip}
% 
% Build using the gsl.sln file

\subsubsection{GSL}
À télécharger depuis:

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

Compilez en utilisant le fichier gsl.sln.

% \subsubsection{GEOS}
% Get geos from svn (svn checkout
% \htmladdnormallink{http://svn.refractions.net/geos/trunk}{
% http://svn.refractions.net/geos/trunk} geos).
% Edit geos$\backslash$source$\backslash$makefile.vc as follows:
% 
% Uncomment lines 333 and 334 to allow the copying of version.h.vc to version.h.
% 
% Uncomment lines 338 and 339.
% 
% Rename geos\_c.h.vc to geos\_c.h.in on lines 338 and 339 to allow the copying of
% geos\_c.h.in to geos\_c.h.
% 
% 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}
% 
% Run the following in top level directory, setting GEOS\_DIR as appropriate:

\subsubsection{GEOS}
Téléchargez geos depuis svn (svn checkout \htmladdnormallink{http://svn.refractions.net/geos/trunk}{http://svn.refractions.net/geos/trunk} geos).
Editez geos$\backslash$source$\backslash$makefile.vc comme il suit:

Décommentez les lignes 333 et 334 pour permettre de copier de la version.h.vc vers la version.h.

Décommentez les lignes 338 et 339.

Renommez geos\_c.h.vc vers geos\_c.h.in aux lignes 338 and 339 pour permettre de copier geos\_c.h.in vers geos\_c.h.

Avec la commande de Visual Studio (assurez que l'environnement est bien configuré), lancez ça dans le répertoire supérieur:

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

Lancez les commandes suivantes dans le répertoire supérieur pour configurer correctement GEOS\_DIR:

\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}

\subsubsection{GDAL}
Téléchargez gdal depuis svn(svn checkout \htmladdnormallink{https://svn.osgeo.org/gdal/branches/1.4/gdal}{https://svn.osgeo.org/gdal/branches/1.4/gdal} gdal).

Éditez nmake.opt pour qu'il s'intègre correctement, le tout est assez bien commenté.

Avec la commande de Visual Studio (assurez que l'environnement est bien configuré), lancez ça dans le répertoire supérieur:

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

et

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

\subsubsection{PostGIS}
Télécharger la version Windows de PostgreSQl et PostGIS ici:

\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}
Téléchargez Expat depuis:

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

Vous avez besoin de expat-win32bin-2.0.1.exe.

Lancez l'exécutable pour installer expat.

\subsubsection{CMake}
Télécharger CMake depuis:

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

Vous avez besoin de cmake-$<$version$>$-win32-x86.exe. Lancez-le pour installer CMake.

\subsection{Building QGIS with CMAKE}
Téléchargez les sources QGIS depuis svn (svn co \htmladdnormallink{https://svn.osgeo.org/qgis/trunk/qgis}{https://svn.osgeo.org/qgis/trunk/qgis} qgis).

Créer un répertoire 'Build' dans le dossier supérieur de QGIS pour accueillir le résultat de la compilation.

Cliquez sur Démarrer--$>$Tout les programmes--$>$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.

Dans la boîte 'Where is the source code:', allez jusqu'au répertoire supérieur de QGIS.

Dans la boîte 'Where to build the binaries:', allez dans le répertoire 'Build' que vous avez créé.

Remplissez les différentes entrées *\_INCLUDE\_DIR et *\_LIBRARY dans la liste 'Cache Values'.

Cliquez le bouton Configure. Il vous est demandé quel type de makefile va être généré, sélectionnez Visual Studio 8 2005 et cliquez OK.

Si tout va bien la compilation devrait se faire sans erreurs. Si il y en a, c'esthabituellement dû à un chemin incorrect vers le répertoire de l'en-tête ou de la bibliothèque. Les objets qui ont échoué sont marqués en rouge.

% 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.

Une fois la configuration correctement terminée, cliquez sur OK pour générer les fichiers de projet.

Avec Visual Studio 2005, ouvrez le fichier qgis.sln qui a été créé dans le répertoire 'Build'.

Compiler le projet ALL\_BUILD. Cela compilera tout les binaires QGIS ainsi que toutes les extensions.

Installez QGIS en lançant le projet INSTALL. Par défaut, l'installation se fera dans c:$\backslash$Program Files$\backslash$qgis$<$version$>$ (ce qui peut être changé avec la variable CMAKE\_INSTALL\_PREFIX de CMake). 

Vous allez aussi avoir besoin d'ajouter toutes les DLLs des dépendances dans le répertoire d'installation de QGIS ou bien ajouter leurs répertoires respectifs dans votre chemin (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.

\section{Compiler sous Windows avec MSVC Express}
\textbf{Note:}: La compilation sous Windows à l'aide de MSVC Express est un travail en cours. En particulier, les choses suivantes ne fonctionnent pas:
python, grass, postgis connections.
/!$\backslash$ Cette partie de document est à l'état de brouillon et ne peut donc pas encore être utilisé.

Tim Sutton, 2007

\subsection{Préparation du système}
J'ai commencé avec une installation récente de Windows XP avec le Service Pack 2 et tous les correctifs appliqués. J'ai déjà compilé toutes les dépendances nécessaires pour gdal, expat etc, donc ce guide ne couvrira également pas leurs compilation depuis les sources. Du fait de la difficulté de les compiler, j'espère que mes binaires vous seront utiles. Dans le cas contraire, je vous conseille de consulter les documentations spécifiques des différents projets. Résumons rapidement le processus avant de commencer:

 * Installer XP 
 * Installer les binaires que j'ai fait
 * Installer Visual Studio Express 2005 sp1
 * Installer le Microsoft Platform SDK
 * Installer le client console de SVN
 * Installer l'ensemble des dépendances
 * Installer Qt 4.3.2
 * obtenir les sources de QGIS
 * Compiler QGIS
 * Créer un installateur setup.exe pour QGIS

\subsection{Installer les bibliothèques}
Cette procédure a essentiellement pour but de vous simplifier les choses. A cette fin, j'ai créé une archive qui inclue  toutes les dépendances nécessaires pour compiler QGIS à l'exception de Qt (que nous compilerons par la suite). Récupérer ce fichier à:

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

Créez cette structure de répertoire:

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

Extrayez l'archive dans un sous-répertoire de manière à avoir:

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

\textbf{Note:} vous n'êtes pas obligés se suivre cette structure, mais dans ce cas vous devrez adapté les instructions qui suivent.

\subsection{Installer Visual Studio Express 2005}
la première chose à faire est de télécharger MSVC Express depuis:

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

Voici les options que j'ai choisies :

 * Envoyer les informations d'usage à Microsoft (Non)
 * Options d'installation:
   * IDE  graphique                      (Oui)
   * Microsoft MSDN Express Edition        (Non)
   * Microsoft SQL Server Express Edition  (Non)
 * Installation vers le dossier C:$\backslash$Program Files$\backslash$Microsoft Visual
Studio 8$\backslash$   (default)

\subsection{Installer Microsoft Platform SDK2}
Allez à cette page:

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

Cherchez ces 3 fichiers et sélectionnez celui qui correspond à votre plateforme:

\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}

Faites une installation personnalisée et installez le logiciel vers:

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

Nous allons faire une installation minimale pour avoir un environnement fonctionnel:

\begin{verbatim}
Configuration Options
  + Register Environmental Variables            (Oui)
Microsoft Windows Core SDK
  + Tools                                       (Oui)
    + Tools (AMD 64 Bit)                        (Non à moins que ce soit le cas)
    + Tools (Intel 64 Bit)                      (Non à moins que ce soit le cas)
  + Build Environment
    + Build Environment (AMD 64 Bit)            (Non à moins que ce soit le cas)
    + Build Environment (Intel 64 Bit)          (Non à moins que ce soit le cas)
    + Build Environment (x86 32 Bit)            (Oui)
  + Documentation                               (Non)
  + Redistributable Components                  (Oui)
  + Sample Code                                 (Non)
  + Source Code                                 (Non)
    + AMD 64 Source                             (Non)
    + Intel 64 Source                           (Non)
Microsoft Web Workshop                          (Oui) (nécessaire pour shlwapi.h)
  + Build Environment                           (Oui)
  + Documentation                               (Non)
  + Sample Code                                 (Non)
  + Tools                                       (Non)
Microsoft Internet Information Server (IIS) SDK (Non)
Microsoft Data Access Services (MDAC) SDK       (Oui) (nécessaire pour GDAL/odbc)
  + Tools
    + Tools (AMD 64 Bit)                        (Non)
    + Tools (AMD 64 Bit)                        (Non)
    + Tools (x86 32 Bit)                        (Oui)
  + Build Environment
    + Tools (AMD 64 Bit)                        (Non)
    + Tools (AMD 64 Bit)                        (Non)
    + Tools (x86 32 Bit)                        (Oui)
  + Documentation                               (Non)
  + Sample Code                                 (Non)
Microsodt Installer SDK                         (Non)
Microsoft Table PC SDK                          (Non)
Microsoft Windows Management Instrumentation    (Non)
Microsoft DirectShow SDK                        (Non)
Microsoft Media Services SDK                    (Non)
Debuggin Tools for Windows                      (Oui)
\end{verbatim}

\textbf{Note:} vous pourrez toujours rajouter des éléments par la suite.

\textbf{Note:} l'installation du SDK requiert la validation du Microsoft Genuine Advantage application. Si vous ne pouvez ou ne voulez pas, il vous faudra recourir aux instructions de compilations avec MINGW  de ce document.

Le SDK créé un répertoire nommé

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

Que vous pouvez effacer sans crainte.

Après son installation, suivez les notes restantes sur la page indiquée précédemment pour finir la configuration de votre environnement MSVC Express. Pour votre confort, voici un bref résumé de ces étapes avec quelques autres détails:

1) Ouvrez Visual Studio Express IDE

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

3) Ajoutez:

\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) Fermer MSVC Express IDE

5) Ouvrez le fichier suivant avec notepad:

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

et changez la propriété:

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

Pour:

\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}

\subsection{Editer vos vsvars}
Faites une sauvegarde de votre fichier vsvars32.bat présent dans

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

et remplacez le par:

\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{Variables d'environnement}
Clic-droit sur 'Poste de travail' puis sélectionnez le panneau 'Avancé'. Cliquez sur les variables d'environnement et créez ou ouvrez les variables '''Système''':

\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{Compiler Qt4.3.2}
Qt 4.3.2 est la version miniale requise puisque c'est la première version à supporter la compilation la version Open source de Qt avec MSVC.

Téléchargez les sources Qt 4.x.x depuis:

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

Extrayez les sources vers 

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

\subsubsection{Compiler Qt}
Ouvrez la ligne de commande de Visual Studio C++ et déplacez-vous vers c:$\backslash$Qt$\backslash$4.x.x et entrez:

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

Ajoutez -qt-sql-odbc -qt-sql-psql dans ligne  'configure' si vous voulez le support odbc et PostgreSQL dans Qt.

\textbf{Note:}J'ai eu quelques erreurs avec qscreenshot.pro. Si vous ne voulez que compiler des applications Qt vous pouvez l'ignorer. Vérifiez dans c:$\backslash$Qt$\backslash$4.3.2$\backslash$bin que toutes les DLLs et les aides (assistant, etc.) ont été créés.

\subsubsection{Configuration de Visual C++ pour utiliser Qt}
Après la compilation, configurez Visual Studio Express IDE pour utiliser Qt:

1) ouvrez Visual Studio Express IDE

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

3) Ajoutez:

\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.
Comme cela, le debugger montrera le contenu de QString quand vous en aurez besoin. On peut aussi ajouter d'autres choses (faites le si vous en avez besoin) j'avais juste besoin de QString et j'ai pris la première occurence que j'ai pu trouver dans google


\subsection{Installer Python}
Télécharger \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} et installez-le.

\subsection{Installer SIP}
Téléchargez \htmladdnormallink{http://www.riverbankcomputing.com/Downloads/sip4/sip-4.7.1.zip}{http://www.riverbankcomputing.com/Downloads/sip4/sip-4.7.1.zip}et extrayez le dans votre répertoire c:$\backslash$dev$\backslash$cpp.
Depuis la console de Visual C++, déplacez vous dans ce dossier et faites:

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

\subsection{Installer PyQt4}
Téléchargez \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} et extrayez-le dans votre répertoire c:$\backslash$dev$\backslash$cpp.
Depuis la console de Visual C++, déplacez-vous dans ce dossier et faites:

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

\subsection{Installer CMake}
Téléchargez et installez cmake 2.4.7 ou plus récent, assurez-vous d'activer cette option:
\texttt{Update path for all users}

\subsection{Installer Subversion}
Vous '''devez''' installer la version en ligne de commande si vous voulez que les scripts CMake pour svn fonctionnent. Il est difficile de trouver la version correcte sur le site du projet subversion du fait des noms parfois similaires, dirigez-vous plutôt vers ce fichier:

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

Extrayez le fichier zip vers
\begin{verbatim}
C:\Program Files\svn
\end{verbatim}

Et ajoutez

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

à votre chemin.

\subsection{Récupération SVN initiale}
Ouvrer une fenêtre cmd.exe et faites:

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

A ce point, vous allez sûrement avoir un message comme celui-ci:

\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}

Appuyez sur 'p' pour accepter et la récupération svn devrait débuter.

\subsection{Créer des Makefiles avec cmakesetup.exe}
Je ne vais pas donner une description détaillée du processus de compilation car il est déjà expliqué dans la première partie de ce guide. Sautez les étapes sur la compilation de GDAL etc., puisque ce processus d'installation simplifié prend en charge les dépendances à votre place.

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

Cmakesetup devrait récupérer toutes les dépendances pour vous, et ce automatiquement (il utilise l'environnement LIB\_DIR pour les repérer dans c:$\backslash$dev$\backslash$cpp$\backslash$qgislibs-release). 
Appuyez encore sur configurer après l'apparition de l'interface de cmakesetup et quand tous les champs en rouges ont disparu, appuyez sur OK pour fermer cmake.

Maintenat ouvrez Visual Studio Express et faites: \texttt{File -$>$ Open -$>$ Project /Solution}

Puis ouvrez le fichier QGIS généré par cmake qui devrait être dans:

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

Où X.X.X représente la version actuelle de QGIS. Pour le moment j'ai seulement distribué les dépendances pour QGIS, les versions de débug devraient suivre, vous devez donc sélectionner 'Release' dans la barre de configuration. Ensuite, faites un clic droit sur ALL\_BUILD dans le navigateur et choisissez 'build'. Une fois la compilation achevée, faites un clic droit sur INSTALL dans le navigateur et choisissez 'build'. Cela installera par défaut QGIS dans c:$\backslash$program files$\backslash$qgisX.X.X.

\subsection{Executer et empaqueter}
Pour lancer QGIS vous aurez besoin d'une copie des DLLs de c:$\backslash$dev$\backslash$cpp$\backslash$qgislibs-release$\backslash$bin vers c:$\backslash$program files$\backslash$qgisX.X.X directory.