These instructions need to be updated for Subsurface 4.6.1. Please look at the English version of this page

License: GPLv2

Vous pouvez récupérer les sources de la version en dévelopement via le dépôt git ou vous pouvez télécharger Subsurface-4.2.tgz depuis notre site.

Subsurface utilise quelques bibliothèques et framework pour faire son travail. Les plus importantes sont libdivecomputer, Qt4, Marble (plus précisement libmarble; ce qui crée la dépendance envers Qt4 puisque Marble n’a pas encore été mis à jour pour Qt5), libxml2, libxslt, libsqlite3, et libzip.

Suivent les instructions pour construire Subsurface sous les distributions Linux populaire, pour construire Subsurface avec Homebrew sous Mac, et pour compiler Subsurface pour Windows. Le manque d’un système de gestion de paquets pour Windows rend très difficile la compilation de Subsurface directement sous Windows; il y a quelques information pour le faire dans le fichier INSTALL présent dans les sources.

Les options de compilations de Subsurface

Les options suivantes peuvent être passé à qmake (laisser en anglais):

 -config debug        Create a debug build
 -config release      Create a release build
		      The default depends on how Qt was built.
 V=1                  Disable the "silent" build mode
 LIBDCDEVEL=1         Search ../libdivecomputer for libdivecomputer
 INCLUDEPATH+=xxx     Add xxx to the include paths to the compiler
		      (pass the actual path, without -I)
 LIBS+=xxx            Add xxx to the linker flags. -l and -L 
		      options are recognized.

Les options INCLUDEPATH et LICS sont utiles pour instruire le système par rapport à des chemins d’installation non-standard pour les dépendances (tell que Marble). Ces options peuvent être répétée aussi souvent que nécessaire, ou plusieur arguments peuvent être donné au même paramètre, en les séparant d’un espace. Par exemple:

  qmake LIBS+="-L$HOME/marble/lib -L$HOME/libdivecomputer/lib" 
	INCLUDEPATH+="$HOME/marble/include 
                        $HOME/libdivecomputer/include"

Construire subsurface pour Linux

Sous Fedora vous pouvez faire:

sudo yum install qt-devel marble-devel libzip-devel libxml2-devel 
         libxslt-devel libsqlite3x-devel libudev-devel 
         libtool autoconf libusb-devel qtwebkit-devel

Sous Debian et ses dérivées, vous pouvez installer les dépendences requises via (une fois que la version Qt de Subsurface est disponible pour votre distribution)

$ sudo apt-get build-dep subsurface

Si vous voulez installé les dépendences requises individuellement, vous pouvez utiliser:

$ sudo apt-get install libqt4-dev qt4-qmake libxml2-dev 
         libxslt1-dev zlib1g-dev libzip-dev libmarble-dev 
         libsqlite3-dev libqtwebkit-dev libusb-1.0-0-dev 
         libtool autoconf

Malheureusement, la version de Marble présente dans la version stable de Debian (et éventuellement Ubuntu) semble manquer un fichier d’entête utilisé par Subsurface. Nous avons contourné le problème en incluant le fichier manquant, mais cela peut poser des conflits de versions.

Pour compiler libdivecomputer:

$ git clone git://git.libdivecomputer.org/libdivecomputer
$ cd libdivecomputer
$ git checkout master
$ autoreconf --install
$ ./configure --disable-shared
$ make
$ sudo make install

Pour compiler Subsurface:

$ git clone git://subsurface-divelog.org/subsurface.git
$ cd subsurface
$ qmake # qmake-qt4 on some flavors of Linux
$ make
$ sudo make install     [optionally, add: prefix=/usr/local]

Note: sous Fedora qmake apparait comme qmake-qt4

Construire Subsurface sous MacOS X

1) Installer Homebrew

$ ruby -e "$(curl -fsSL https://raw.github.com/mxcl/homebrew/go/install)"

2) Installer les dépendences requises

$ brew install asciidoc libzip qt5 sqlite cmake libusb pkg-config 
  automake libtool

3) Faire de la version de sqlite installé par brew, la version par défaut

$ brew link --force sqlite

4) Installer Marble

$ mkdir -p marble_dir/build
$ git clone git://anongit.kde.org/marble marble_dir/repo
$ cd marble_dir/build
$ /usr/local/opt/cmake/bin -DCMAKE_BUILD_TYPE=Release -DQTONLY=TRUE 
  -DCMAKE_PREFIX_PATH=/usr/local/opt/qt5/lib/cmake 
  -DCMAKE_INSTALL_PREFIX=/usr/local ../repo
$ cd src/lib/marble
$ make -j4
$ install_name_tool -id 
  /usr/local/lib/$(echo libmarblewidget.??.dylib) 
  libmarblewidget.dylib
$ cp -v *dylib /usr/local/lib/
$ mkdir -p /usr/local/include/marble
$ cp -v $(find ../../../../repo/src/lib -name '*.h') 
  /usr/local/include/marble/

5) Installer Libdivecomputer

$ git clone git://git.libdivecomputer.org/libdivecomputer
$ cd libdivecomputer
$ autoreconf --install
$ ./configure --disable-shared
$ make
$ make install

6) Compiler Subsurface

$ git clone git://subsurface-divelog.org/subsurface.git
$ cd subsurface
$ qmake 
  INCLUDEPATH+="/usr/local/include /usr/local/opt/sqlite/include" 
  LIBS+="-L/usr/local/lib -L/usr/local/opt/sqlite/lib"
$ make
$ make install_mac_bundle

After the above is done, Subsurface will be installed to /Applications.

Another option is to create a .dmg for distribution:

$ make mac-create-dmg

Notes: macdeployqt s’attend à trouver les plugins à côté du framework. Ce framework is lié depuis /usr/local/lib -- mais les plugins ne sont pas dans /usr/local/plugins. Le plus simple pour contourner se problème est de créer un lien symbolic depuis /usr/local/plugins vers /usr/local/opt/qt5/plugins.

Compiler Subsurface pour Windows sous Linux

Subsurface compile sans problèmes par MinGW -- le paquet officiel sont construit sous Linux (en ce moment Fedora 19). Un script shell pour le faire (et le fichier .nsi utilisé pour créer l’installeur avec makensis) sont inclus dans le dossier packaging/windows des sources.

La meilleur manière de construire libdivecomputer est:

$ mkdir -p ~/src
$ git clone git://git.libdivecomputer.org/libdivecomputer ~/src/libdivecomputer
$ cd ~/src/libdivecomputer
$ git checkout master
$ mingw32-configure --disable-shared
$ mingw32-make
$ sudo mingw32-make install

To compile Marble, use:

$ mkdir -p ~/src/marble/build
$ git clone -b KDE/4.13 git://anongit.kde.org/marble ~/src/marble/sources
$ cd ~/src/marble/build
$ mingw32-cmake -DCMAKE_BUILD_TYPE=Debug -DQTONLY=TRUE ../sources
 - or -
$ mingw32-cmake -DCMAKE_BUILD_TYPE=Release -DQTONLY=TRUE ../sources
$ mingw32-make -j4
$ mingw32-make install

Pour compiler Subsurface, utilisez:

$ mkdir -p ~/src/subsurface
$ git clone git://subsurface-divelog.org/subsurface.git ~/src/subsurface
$ cd ~/src/subsurface
$ packaging/windows/mingw-make.sh
$ packaging/windows/mingw-make.sh install
$ packaging/windows/mingw-make.sh installer

Cette dernière étape s’attend à ce que vous ayez un lien depuis packaging/windows/dll vers le bon dossier de votre installation MinGW. Dans mon système c’est le dossier /usr/i686-w64-mingw32/sys-root/mingw/bin. Parrallèment, les chemins utilisés dans packaging/windows/mingw-make.sh peuvent avoir besoin d’être ajuster en fonction de votre distribution Linux.

L’application Subsurface Companion sur Android

Cette application est disponible sur le Google Play Store. Il est aussi sous license GPLv2 et les sources sont disponibles à git://subsurface-divelog.org/subsurface-companion.git