                                   Tux Paint
                                 version 0.9.30
                        Documentation sur l'installation

        Copyright © 2002-2023 by divers contributeurs; see AUTHORS.txt.
                             https://tuxpaint.org/

                                 mars 29, 2023

           +--------------------------------------------------------+
           |Table des matières                                      |
           |--------------------------------------------------------|
           |  * Exigences                                           |
           |       * Biliothèque Simple DirectMedia Layer (libSDL)  |
           |       * Autres bibliothèques                           |
           |  * Compilation et installation                         |
           |       * Windows                                        |
           |       * Linux/Unix                                     |
           |       * macOS                                          |
           |       * Android                                        |
           |  * Débogage                                            |
           |  * Désinstallation de Tux Paint                        |
           |       * Windows                                        |
           |       * macOS                                          |
           |       * Linux                                          |
           +--------------------------------------------------------+

                                   Exigences

Biliothèque Simple DirectMedia Layer (libSDL)

   Tux Paint nécessite la bibliothèque de couches DirectMedia simple
   (libSDL), une bibliothèque de programmation multimédia Open Source
   disponible sous la Licence publique générale limitée GNU (LGPL).

   Along with libSDL, Tux Paint depends on a number of other SDL 'helper'
   libraries: SDL_Image (for graphics files), SDL_gfx (for some graphical
   functions, like rotation), SDL_TTF and (optionally) SDL2_Pango (for True
   Type Font support) and, optionally, SDL_Mixer (for sound effects).

   Les bibliothèques SDL sont disponibles en tant que code source, ou en tant
   que paquets RPM ou Debian pour diverses distributions de Linux. Ils
   peuvent être téléchargés à partir de :

     * libSDL: http://www.libsdl.org/
     * SDL_image: https://github.com/libsdl-org/SDL_image
     * SDL_gfx:
       https://www.ferzkopp.net/wordpress/2016/01/02/sdl_gfx-sdl2_gfx/
       (https://sourceforge.net/projects/sdlgfx/)
     * SDL_ttf: https://github.com/libsdl-org/SDL_ttf
     * SDL2_Pango: https://github.com/markuskimius/SDL2_Pango (optionnel)
     * SDL_mixer: https://github.com/libsdl-org/SDL_mixer (optionnel)

   Elles sont aussi parmi les paquets inclus dans votre distribution (par ex.
   sur le media d'installation, ou via la maintenance de vos logiciels comme
   la commande apt de Debian).

   💡 Note: When installing libraries from packages, be sure to ALSO install
   the development versions of the packages. (For example, install both
   "SDL2-2.24.0.rpm" and "SDL2-devel-2.24.0.rpm".)

  Autres bibliothèques

   Tux Paint profite également d'un certain nombre d'autres bibliothèques
   gratuites LGPL. Sous Linux, tout comme SDL, ils devraient être soit déjà
   installées, soit facilement disponibles avec votre distribution Linux.

   libPNG

           Tux Paint utilise le format PNG (Portable Network Graphics) pour
           ses fichiers de données. SDL_image nécessitera l'installation de
           libPNG.

           http://www.libpng.org/pub/png/libpng.html

   gettext

           Tux Paint utilise les paramètres régionaux de votre système avec
           la bibliothèque "gettext" pour prendre en charge plusieurs langues
           (par exemple, l'espagnol). Vous aurez besoin d'installer la
           bibliothèque de gettext.

           http://www.gnu.org/software/gettext/

   libpaper (Linux/Unix uniquement)

           Depuis Tux Paint 0.9.17, Tux Paint peut déterminer le format de
           papier par défaut (par exemple, A4 ou Lettre), ou peut être invité
           à utiliser un format particulier, ceci grâce à libpaper.

           https://github.com/naota/libpaper

   FriBiDi

           Les outils "Texte" et "Étiquette" de Tux Paint supportent les
           langues bidirectionnelles, grâce à la bibliothèque "FriBidi".

           http://fribidi.org/

   Support des graphismes SVG

           À partir de Tux Paint 0.9.17, Tux Paint peut prendre en charge les
           images SVG (Scalable Vector Graphics) pour les tampons. Deux
           ensembles de bibliothèques sont pris en charge et le support SVG
           peut être complètement désactivé (via "make SVG_LIB:==")

                librsvg-2 & libCairo2 (nouvelles bibliothèques)
                           * libRSVG 2: http://librsvg.sourceforge.net/
                           * Cairo 2: http://www.cairographics.org/
                           * Celles-ci dépendent aussi de :
                                * GdkPixbuf & GLib: http://www.gtk.org/
                                * Pango: http://www.pango.org/

                Anciennes bibliothèques
                           * libcairo1, libsvg1, & libsvg-cairo1:
                             http://www.cairographics.org/
                           * Celles-ci dépendent aussi de :
                                * libxml2:
                                  https://gitlab.gnome.org/GNOME/libxml2

   Fonction d'exportation de GIF animés

           Pour prendre en compte l'exportation de GIF animés (diaporama), la
           bibliothèque "libimagequant" (issue du projet "pngquant" est
           nécessaire.

           https://github.com/ImageOptim/libimagequant

   Outils NetPBM (optionnel) ne sont plus utilisés par défaut

           📜 Sous Linux et Unix, les anciennes versions de Tux Paint
           utilisaient les outils NetPBM comme aide à l'impression. (Un PNG
           est généré par TuxPaint et converti en PostScript en utilisant en
           ligne de commande les outils NetPBM pngtopnm et pnmtops.)

           http://netpbm.sourceforge.net/

                          Compilation et installation

   Tux Paint est publié sous la licence publique générale GNU (GPL) (voir
   "COPYING.txt" pour plus de détails), et donc le 'code source' du programme
   est disponible gratuitement.

Windows

   juillet 10, 2022 Shin-ichi TOYAMA <dolphin6k@wmail.plala.or.jp>

  Réglages pour compilation

   Depuis février 2005 (à partir de Tux Paint 0.9.15), le "Makefile" inclut
   la prise en charge de la construction sur un système Windows à l'aide de
   MinGW/MSYS (https://sourceforge.net/projects/msys2/).

   Beaucoup d'outils et de bibliothèques sont nécessaires pour élaborer Tux
   Paint. Le système de gestion de paquet "pacman" apporte une aide pour
   installer automatiquement, en résolvant les dépendances nombreuses.

    MYSYS2

   Téléchargez le dernier environnement MSYS2 à partir de
   https://www.msys2.org/ et installez-le où vous voulez (par défaut
   "C:\msys64")

   Open the MSYS2 shell from the "Start Menu" -> "MSYS2 64bit" -> "MSYS2
   MSYS" and execute following command:

     $ yes "" | pacman -Syu

   This will update core system and the window will close automatically. Open
   the msys2 shell again and execute following command to finish remaining
   updating process.

     $ yes "" | pacman -Syu

   Sous le shell MSYS2, exécutez la commande suivante pour installer outils
   basiques pour le développement :

     $ yes "" | pacman -S make automake-wrapper autoconf-wrapper libtool git
     zip patch gperf dos2unix

   Allez à la prochaine section "chaînes d'outils MinGW 64bit (x86_64) ", ou
   bien à la section "chaînes d'outils MinGW 32bit (i686)" si vous ne voulez
   qu'un environnement de travail 32bit.

            -------------------------------------------------------

    MinGW 64bit (x86_64) compiler and tools

   Sous le shell MSYS2, exécutez la commande suivante pour installer 64bit
   compiler and basic development tools :

     $ yes "" | pacman -S mingw-w64-x86_64-{gcc,pkgconf,ntldd-git}

   "ntldd" est un petit outil qui examine les fichiers exécutables de windows
   en vue de lister les fichiers DLL (.dll) qui leur sont nécessaires. Le
   process de fabrication de Tux Paint pour fournir des fichiers binaires
   s'en sert pour trouver les fichiers .dll requis.

    64bit (x86_64) dependency libraries for Tux Paint and Tux Paint Config

   You can install tools and libraries required for compiling Tux Paint and
   Tux Paint Config on MSYS2/MINGW using "pacman" except for SDL2_Pango and
   libunibreak.

   FLTK is a cross-platform GUI toolkit used by "Tux Paint Config". You can
   skip installing it if you are only building "Tux Paint".

     $ pacman -S mingw-w64-x86_64-SDL_{image,ttf,gfx}
     $ pacman -S mingw-w64-x86_64-{librsvg,fribidi,libimagequant,fltk}

   💡 Nota : Fermez l'interpréteur de commandes avant de passer à la suite.

    Install SDL2_Pango and libunibreak on the 64bit environment

   SDL2_Pango and libunibreak should be installed manually.

   Cette fois-ci, utilisez le shell MinGW "64bit". Ouvrez le shell depuis le
   "Menu de Démarrage" -> "MSYS2 64bit" -> "MSYS2 MinGW 64-bit"

      SDL2_Pango

   You can fetch the source code from the Mark K. Kim's git repositry,
   compile and install it as follows.

     $ git clone https://github.com/markuskimius/SDL2_Pango
     $ cd SDL2_Pango
     $ ./configure --prefix=/mingw64 && make && make install

      libunibreak

   libunibreak is required for compiling Tux Paint Config. You can skip
   installing it if you are only building "Tux Paint".

   You can fetch the source code from the git repositry and compile it as
   follows.

     $ git clone https://github.com/adah1972/libunibreak libunibreak
     $ cd libunibreak
     $ ./augogen.sh --prefix=/mingw64 && make && make install

   Aller à la prochaine section "chaines d'outils MinGW 32bit (i686)", ou
   bien aller directement à la section "ImageMagick" si vous n'avez besoin
   que d'un environnement de travail 64bit.

            -------------------------------------------------------

    MinGW 32bit (i686) compiler and tools

   Sous le shell MSYS2, exécutez la commande suivante pour installer 32bit
   compiler and basic development tools :

     $ yes "" | pacman -S mingw-w64-i686-{gcc,pkgconf,ntldd-git}

   "ntldd" est un petit outil qui examine les fichiers exécutables de windows
   en vue de lister les fichiers DLL (.dll) qui leur sont nécessaires. Le
   process de fabrication de Tux Paint pour fournir des fichiers binaires
   s'en sert pour trouver les fichiers .dll requis.

    32bit (i686) dependency libraries for Tux Paint and Tux Paint Config

   You can install tools and libraries required for compiling Tux Paint and
   Tux Paint Config on MSYS2/MINGW using "pacman" except for SDL2_Pango and
   libunibreak.

   FLTK is a cross-platform GUI toolkit used by "Tux Paint Config". You can
   skip installing it if you are only building "Tux Paint".

     $ pacman -S mingw-w64-i686-SDL_{image,ttf,gfx}
     $ pacman -S mingw-w64-i686-{librsvg,fribidi,libimagequant,fltk}

   💡 Nota : Fermez l'interpréteur de commandes avant de passer à la suite.

    Install SDL2_Pango and libunibreak on the 32bit environment

   SDL2_Pango and libunibreak should be installed manually.

   Cette fois-ci, utilisez le shell MinGW "32bit". Ouvrez le shell depuis le
   "Menu de Démarrage" -> "MSYS2 64bit" -> "MSYS2 MinGW 32-bit"

      SDL2_Pango

   You can fetch the source code from the Mark K. Kim's git repositry,
   compile and install it as follows.

     $ git clone https://github.com/markuskimius/SDL2_Pango
     $ cd SDL2_Pango
     $ ./configure --prefix=/mingw32 && make && make install

      libunibreak

   libunibreak is required for compiling Tux Paint Config. You can skip
   installing it if you are only building "Tux Paint".

   You can fetch the source code from the git repositry and compile it as
   follows.

     $ git clone https://github.com/adah1972/libunibreak libunibreak
     $ cd libunibreak
     $ ./augogen.sh --prefix=/mingw32 && make && make install

  ImageMagick

   ImageMagick est un ensemble d'outils en ligne de commande pour créer,
   éditer, composer ou convertir des images bitmap, et qui supporte un grand
   nombre de formats d'image. Tux Paint utilise deux fonctions ("convert" et
   "composite") pour générer des vignettes pour les images de démarrage et
   des modèles durant le process de compilation.

   Using official binary release available from "Windows Binary Release" is
   recommended, due to the commands installed with "pacman" on MinGW/MSYS not
   working as expected!

   N'oubliez pas de cocher "Installer les utilitaires hérités (par ex.
   convert)" pour l'installation, car le processus de compilation de Tux
   Paint les utilise.

   Ajoutez le chemin où ImageMagick est installé au début de votre variable
   d'environnement "PATH". Par exemple :

     $ export PATH=/c/Program\ Files/ImageMagick-7.0.10-Q16-HDRI:$PATH

   Vous pouvez rendre ceci permanent en ajoutant ce qui précède à votre
   fichier de configuration du shell BASH, "~/.bash_profile".

  Tux Paint & Tux Paint Config.

   You can compile 64-bit binaries using "MSYS2 64bit" shell, and 32-bit
   binaries using "MSYS2 32bit" shell, respectively.

     * Choisissez "MSYS2 64bit" -> "MSYS2 MinGW 64-bit" dans le "Menu de
       Démarrage" pour ouvrir le shell 64bit.
     * Choisissez "MSYS2 64bit" -> "MSYS2 MinGW 32-bit" dans le "Menu de
       Démarrage" pour ouvrir le shell 32bit.

    Tux Paint Config.

   "Tux Paint Config" is a useful graphical tool for tweaking Tux Paint's
   behavior. You have to build this component before compiling Tux Paint if
   you want to have it included in your package.

   You can use either (a) a stable tar-ball release, or (b) the developing
   source tree.
    a. Using stable tar-ball release:
          * Download a source tar-ball
          * Expand the tar-ball and change the directory name so that the
            final packaging process can find related files.

              $ tar zxvf tuxpaint-config-A.B.C.tar.gz
              $ mv tuxpaint-config-A.B.C tuxpaint-config

    b. Using the developing source tree:
          * Fetch the developing source tree from git repository:

              $ git clone https://git.code.sf.net/p/tuxpaint/tuxpaint-config
              tuxpaint-config

   Now you can build Tux Paint Config. as follows:

     $ cd tuxpaint-config
     $ make win32

    Tux Paint

   You can use either (a) a stable tar-ball release, or (b) the developing
   source tree.
    a. Using stable tar-ball release:
          * Download a source tar-ball
          * Expand the tar-ball and change the directory name so that the
            final packaging process can find related files.

              $ tar zxvf tuxpaint-A.B.C.tar.gz
              $ mv tuxpaint-A.B.C tuxpaint

    b. Using the developing source tree:
          * Fetch the developing source tree from git repository:

              $ git clone https://git.code.sf.net/p/tuxpaint/tuxpaint
              tuxpaint

   Now you can build Tux Paint as follows:

     $ cd tuxpaint
     $ make bdist-win32

   Tous les fichiers nécessaires pour démarrer Tux Paint (et Tux Paint
   Config) sont rassemblés dans le répertoire de la distribution binaire
   "bdist", répertoire situé sous "win323. Vous pouvez les démarrer en
   double-cliquant leurs fichiers exéctutables (.exe) dans le répertoire
   "bdist".

  Building the Tux Paint Windows Installer

   Inno Setup est utilisé pour construire l'installeur exécutable de Tux
   Paint. Vous devez donc l'installer en premier.

   Officiellement Inno Setup prend en compte des traductions dans environ 20
   langues. Cependant, un des points majeurs de Tux Paint est qu'il supporte
   beaucoup de langues. Aussi, le script de mise au point "tuxpaint.iss" qui
   sert pour construire le programme d'installation est écrit en beaucoup
   plus de langues, y compris des non-officielles qui sont disponibles sur
   "Inno Setup Translations". Vous devez télécharger les fichiers de
   traduction (.isl) qui sont requis et les mettre dans le répertoire
   "Languages" sous le répertoire dans lequel Inno Setup est installé.

   Before building an installer, edit the "tuxpaint.iss" file and enable one
   of the lines starting with "#define BuildTarget=", depending on the
   architecture of the installer you want to create.

   Alors, vous pouvez facilement construire un installateur exécutable en
   cliquant-droit sur l'icône "tuxpaint.iss" du répertoires "win32" et
   sélectionner "Compile" dans la liste. Cela prendra un certain temps, et
   éventuellement vous obtiendrez un fichier
   "tuxpaint-X.Y.Z-windows-<arch>-installer.exe" dans le même répertoire.

  Running the Tux Paint Windows Installer

   Double-cliquez sur l'exécutable du programme d'installation de Tux Paint
   (fichier .EXE) et suivez les instructions.

   First, you will be asked to read the license. (It is the GNU General
   Public License (GPL), which is also available as "COPYING.txt".)

   Il vous sera ensuite demandé si vous souhaitez installer des raccourcis à
   Tux Paint dans votre menu Démarrer de Windows et sur votre bureau
   Windows.(Les deux options sont définies par défaut.)

   Puis, il vous sera demandé où vous souhaitez installer Tux Paint. La
   valeur par défaut devrait convenir, tant qu'il y a de l'espace disponible.
   Sinon, choisissez un autre emplacement.

   À ce stade, vous pouvez cliquer sur «Installer» pour installer Tux Paint !

  Changing the Settings Using the Shortcut

   Pour modifier les paramètres du programme, cliquez avec le bouton droit
   sur le raccourci TuxPaint et sélectionnez «Propriétés» (en bas).

   Assurez-vous que l'onglet "Raccourci" est sélectionné dans la fenêtre qui
   apparaît et examinez le champ «Cible:». Vous devriez voir quelque chose
   comme ceci :

     "C:\Program Files\TuxPaint\TuxPaint.exe"

   Vous pouvez maintenant ajouter des options de ligne de commande qui seront
   activées lorsque vous double-cliquez sur l'icône.

   Par exemple, pour faire fonctionner le jeu en mode plein écran, avec des
   formes simples (pas d'option de rotation) et en français, ajoutez les
   options (après 'TuxPaint.exe'), comme ceci :

     "C:\Program Files\TuxPaint\TuxPaint.exe" -f -s --lang french

   (Voir «README.txt» pour une liste complète des options de ligne de
   commande disponibles.)

   Si vous faites une erreur ou que tout disparaît, utilisez [Control] + [Z]
   pour annuler ou appuyez simplement sur la touche [Esc] et la boîte se
   fermera sans aucune modification (sauf si vous avez appuyé sur le bouton
   "Appliquer" !).

   Quand vous avez fini, appuyez sur "OK".

  If Something Goes Wrong

   If, when you double-click on the shortcut to run Tux Paint, nothing
   happens, it is probably because some of these command-line options are
   wrong. Open an Explorer, and look for a file called "stderr.txt" in your
   personal saving folder for TuxPaint which is normaly
   "C:\Users\username\AppData\Roaming\TuxPaint".

   Il contiendra une description de ce qui n'allait pas. Habituellement, ce
   sera simplement dû à une casse de caractère incorrecte (majuscule 'Z' à la
   place de 'z' minuscule) ou un '-' (tiret) manquant (en trop).

Linux/Unix

  Compilation :

   💡 Note: Tux Paint does not use autoconf/automake, so there is no
   "./configure" script to run. Compiling should be straight-forward though,
   assuming everything Tux Paint needs is installed.

   Pour compiler le programme à partir des sources, lancez simplement la
   commande suivante après une invite shell (par ex. "$") :

     $ make

  Désactivation du support SVG (donc des dépendances Cairo, libSVG, et
  svg-cairo)

   Pour désactiver le support de SVG (par ex. si votre système n'a pas de
   bibliothèque Cairo, ou d'autres choses dont SVG est dépendant), vous
   pouvez exécuter "make" avec "SVG_LIB= SVG_CFLAGS= NOSVGFLAG=NOSVG" :

     $ make SVG_LIB= SVG_CFLAGS=

  Désactivation du support Pango (donc des dépendances Pango, Cairo, etc ...)

   📜 Avant la version 0.9.18, Tuxpaint utilisait la bibliothèque libSDL_ttf
   pour gérer les fichiers utilisant les fontes True Type. Depuis la 09.18
   libSDL_Pango est utilisée, car il permet un meilleur support pour
   l'internationalisation. Cependant, si vous voulez désactiver l'utilisation
   de SDL_Pango, vous pouvez le faire en exécutant "make" avec
   "SDL_PANGO_LIB=" :

     $ make SDL_PANGO_LIB=

  Disabling Sound at Compile-time

   Si vous n'avez pas de carte son ou si vous préférez créer le programme
   sans support sonore (et donc sans dépendance SDL_mixer), vous pouvez
   exécuter "make" avec "SDL_MIXER_LIB=" comme paramètre :

     $ make SDL_MIXER_LIB=

  Other options

   Diverses autres options (par exemple, les dossiers d'installation) peuvent
   être remplacées; voir dans "Makefile" pour plus de détails.

  If you get errors

   Si vous avez des erreurs lors de la compilation, assurez-vous d'avoir les
   bibliothèques adéquates installées (voir ci-dessus). Si vous utilisez les
   versions issues des paquets des bibliothèques (par exemple, les RPM sous
   RedHat ou les DEB sous Debian), assurez-vous d'avoir choisi également les
   packages "-dev" ou "-devel" correspondants, sinon vous ne pourrez pas
   compiler Tux Paint (et d'autres programmes) provenant des sources !

  Installng

   En supposant qu'aucune erreur fatale ne se soit produite, vous pouvez
   maintenant installer le programme afin qu'il puisse être exécuté par les
   utilisateurs du système. Par défaut, cela doit être effectué par
   l'utilisateur "root" ("superutilisateur"). Passer à "root" en tapant la
   commande :

     $ su

   Entrez le mot de passe de "root" à l'invite. Vous devriez maintenant être
   "root" (avec une invite comme "#"). Pour installer le programme et ses
   fichiers de données, tapez :

     # make install

   Pour finir, vous pouvez revenir sur votre compte utilisateur en sortant du
   compte superutilisateur :

     # exit

   Autre manière : vous faites simplement utilisation de la commande "sudo"
   (par ex. sur Ubuntu) :

     $ sudo make install

   💡 Note: By default, "tuxpaint", the executable program, is placed in
   "/usr/local/bin/". The data files (images, sounds, etc.) are placed in
   "/usr/local/share/tuxpaint/".

    Changer où vont les fichiers

   Vous pouvez changer où iront les fichiers en définissant des variables
   pour "Makefile" sur la ligne de commande. "DESTDIR" est utilisé pour
   indiquer la sortie des résultats de la compilation. "PREFIX" est la base
   où tous les autres fichiers iront et est définie par défaut comme
   "/usr/local".

   Les autres variables sont :

   BIN_PREFIX
           Où le binaire "tuxpaint" sera installé. (Par défaut
           "$(PREFIX)/bin", par ex. "/usr/local/bin")

   DATA_PREFIX
           Où les fichiers de données (sons, graphiques, pinceaux, tampons,
           fontes) iront, et où Tux Paint ira les chercher pour tourner
           (Réglé à "$(PREFIX)/share/tuxpaint")

   DOC_PREFIX
           Où sera mise la documentation (les répertoires "docs". 'Réglé à
           "$(PREFIX)/share/doc/tuxpaint")

   MAN_PREFIX
           Où ira la page de manuel de Tuxpaint (Réglé à
           "$(PREFIX)/share/man")

   ICON_PREFIX — $(PREFIX)/share/pixmaps

   X11_ICON_PREFIX — $(PREFIX)/X11R6/include/X11/pixmaps

   GNOME_PREFIX — $(PREFIX)/share/gnome/apps/Graphics

   KDE_PREFIX — $(PREFIX)/share/applnk/Graphics
           Où iront les icônes et les lanceurs (pour GNOME et KDE)

   LOCALE_PREFIX
           Où iront les fichiers de traduction, et où Tux Paint ira les
           chercher. (Réglé à "$(PREFIX)/share/locale/") (la destination
           finale de la traduction sera dans le répertoire de la locale (par
           ex "es" pour l'espagnol, dans le sous-répertoire "LC_MESSAGES").

   💡 Note: This list is out of date. See "Makefile" and "Makefile-i18n" for a
   complete list.

macOS

   juin 5, 2022 Mark Kim <markuskimius@gmail.com>

   Starting with Tux Paint 0.9.23, Tux Paint for macOS is built as though it
   were a Linux application.

  Prérequis

   Bien Tux Paint puisse être construit sans Xcode IDE, ce dernier est
   toujours nécessaire. Téléchargez le = partir de l' the App Store, et
   lancez le une fois pour accepter ses accords de licence. Vous pouvez aussi
   installer les outils de ligne de commande de Xcode en tapant la commande :

     $ xcode-select --install

   Construire Tux Paint nécessite plusieurs bibliothèques. Nous les
   installons à partir de MacPorts quand c'est possible, sinon à partir du
   code source. Installez MacPorts avec le chemin par défaut /opt/local
   suivant les instructions données sur leur site : https://www.macports.org/
     * ImageMagick
     * cairo
     * fribidi
     * lbzip2
     * libimagequant^*
     * libpaper
     * libpng
     * librsvg
     * libsdl2
     * libsdl2_image
     * libsdl2_mixer
     * libsdl2_pango^*
     * libsdl2_ttf
     * libsdl2_gfx
     * pkgconfig
     * zlib
   ... mais vous devriez installer tout paquet requis par la dernière version
   de Tux Paint.

   ^* Non disponible depuis MacPorts à ce moment, voir ci-dessous.

    libimagequant

   libimagequant n'est pas disponible sur MacPorts à cette heure. Il peut
   être installé sur /opt/local (comme pour MacPorts) pour la bibliothèque
   devant être incluse dans TuxPaint.dmg.

     $ sudo port install rust cargo
     $ git clone https://github.com/ImageOptim/libimagequant.git
     $ cd libimagequant/imagequant-sys
     $ cargo build --release # Must use cargo from MacPorts
     $ sudo make PREFIX=/opt/local install

    sdl2_pango

   sdl2_pango is not available from MacPorts as of this writing. It can be
   installed from the source code as follows. It should be installed to
   /opt/local (same as MacPorts) for the library to be included in
   TuxPaint.dmg.

     $ git clone https://github.com/markuskimius/SDL2_Pango.git
     $ cd SDL2_Pango
     $ ./configure --prefix=/opt/local && make && sudo make install

   ATTENTION :Posséder des outils Unix à côté de MacPorts et Xcode, tels que
   Fink ou Brew, vous empêchera de créer un programme portable. V"rifiez que
   Fink et Brew ne soient pas accessibles via votre environnement de travail.

  Comment construire

   Tapez simplement :

     % make
     % make install

   ... to create the TuxPaint.app application bundle that can be run in-place
   or copied to /Applications. To create the DMG file for distribution, use
   'make TuxPaint.dmg'.

   Additional steps may be required when building for the Apple Silicon. See
   "Building for Apple Silicon" below.

  Problèmes connus

     * Un binaire macOS construit sur une version spécifique de macOS ne
       fonctionnera qu'avec cette version, ou une plus récente. Pour
       s'assurer que Tux Paint puisse tourner sur la plus vieille version de
       macOS possible, construisez le sur la plus vieille version de macOS
       disponible. Au moment où nous écrivons Tux Paint ne peut être
       construit pour tourner sur macOS 10.7 ou plus récent.

       Voyez "Vieilles Versions de macOS" ci-dessous pour les meilleures
       instructions pour obtenir, installer et construire Tux Paint sur des
       vieilles versions de macOS.

       Alternatively, Tux Paint and all of its library dependencies may be
       compiled with appropriate options to be runnable on older versions of
       macOS. These options are already set on Tux Paint, so only its
       dependencies (from MacPorts) need to be recompiled. See "Recompiling
       MacPorts" below for the instructions.

  Vieilles versions de macOS

   Quelques vieilles versions de macOS peuvent être téléchargées sur la page
   d'aide d'Apple : https://support.apple.com/en-us/HT211683

   macOS for Intel CPU does allow dual booting of multiple versions of the
   OS, but it's safer and easier to install the old macOS onto a flash drive.
   Wherever you're installing it, the target drive's partitioniong scheme and
   partition type must match what the old macOS expects, so use the Disk
   Utility to partition and format the flash drive accordingly.

   Dual booting multiple versions of macOS for Apple Silicon has been so far
   unsuccessful. Instead of installing an older version of macOS for Apple
   Silicon to build Tux Paint to run on the old version of macOS for Apple
   Silicon, use the instructions found in the "Recompiling MacPorts" section
   to build Tux Paint to run on older versions of macOS for Apple Silicon.

   À ce moment, l'ancienne version de macOS disponible sur le site d'Apple
   est la Yosemite 10.10, qui un partitionnement "GPT (GUID Partition Table)"
   au lieu de MBR, et "Mac OS Extended (Journalisé)" comme type de partition
   au lieu du nouveau type APFS.

   Au lancement de l'installateur, si vous avez un message disant que macOD
   est trop vieux ou trop récent pour être installé, un installateur bootable
   peut être créé en suivant les instructions données ici :
   https://support.apple.com/en-mide/HT201372

   Une fois l'ancienne version de macOS installée, vous pouvez trouver que le
   Xcode du App Store est trop récent pour tourner sur la version du vieux
   macOS. Des anciennes versions de Xcode peuvent être téléchargées sur le
   site des développeurs d'Apple dans une zone accessible après
   enregistrement gratuit : https://developer.apple.com/download/more/

   La liste des versions de macOS et de la dernière version de Xcode
   compatible avec celle-ci a été gentiment mise sur la page Wikipedia sur
   Xcode : https://en.wikipedia.org/wiki/Xcode#Table de comparaison des
   versions

   Comme Xcode a été installé manuellement, vous pouvez sauter l'étape
   d'installation des outils de commande en terminal (ne pas exécuter
   "xcode-select --install") mais alors vous compilez Tux Paint en utilisant
   les mêmes étapes décrites auparavant dans ce document.

  Recompiling MacPorts

   To recompile MacPorts to be usable on older versions of macOS, set the
   following options in /opt/local/etc/macports/macports.conf:

     buildfromsource always
     macosx_deployment_target 10.10

   Then uninstall all MacPorts packages:

     $ sudo port -fp uninstall installed

   Then reinstall all MacPorts packages needed by Tux Paint. Also rebuild
   libimagequant using the updated Cargo package from MacPorts.

   As of this writing, all libraries Tux Paint requires from MacPorts can be
   recompiled in this manner to run on macOS 10.10 Yosemite and later on
   Intel CPUs, and macOS 11.0 Big Sur and later on Apple Silicon.
   Unfortunately, although MacPorts has the option to enable the building of
   universal libraries, several libraries Tux Paint require cannot be built
   as universal libraries so they can only be built to run natively on the
   hardware on which they were built. See "Building a Universal Binary" below
   for instructions on how to build Tux Paint as a Universal Binary.

  Building for Apple Silicon

   macOS for Apple Silicon requires all native Apple Silicon applications be
   signed, even if it is signed "ad-hoc" (anonymously). Because of this,
   compilers that produce native Apple Silicon applications sign all produced
   binaries and libraries as a part of the compilation process.^* However,
   the Tux Paint compilation process modifies the libraries to be modular
   (using install_name_tool) so they can be added into the application
   bundle, which has the unfortunate side effect of breaking the signature.
   This can be addressed by signing the application bundle ad-hoc (example
   below) or using your own Apple Developer Identity if you have one. The DMG
   file, if needed, must be created after signing the App Bundle so the DMG
   file is created with signed App Bundle:

     $ codesign -s - TuxPaint.app
     $ make TuxPaint.dmg

   ^* For more information on the code signing requirements on the Apple
   Silicon, see
   https://developer.apple.com/documentation/macos-release-notes/macos-big-sur-11_0_1-universal-apps-release-notes#:~:text=New%20in%20macOS,pass%20through%20Gatekeeper.

   If you get an error that the application bundle is already signed, remove
   it before signing::

     $ codesign --remove-signature TuxPaint.app

   If you plan to combine the Apple Silicon bundle with the Intel CPU bundle
   to produce the Universal bundle, the code signing must be done after they
   are combined. See "Building a Universal Binary" below.

  Building a Universal Binary

   To build Tux Paint as a Universal Binary, compile Tux Paint for the Intel
   CPU and the Apple Silicon separately first. Then rename the app bundle for
   the Intel CPU to TuxPaint-x86_64.app, and the bundle for the Apple Silicon
   to TuxPaint-arm64.app, copy the app bundle from the Intel machine to the
   Apple Silicon machine, then use the provided build-universal.sh script to
   combine the two application bundles as below. The produced bundle must be
   signed (see "Building for Apple Silicon" above for more details). The DMG
   file, if required, must be built after the signing:

     $ macos/build-universal.sh
     $ codesign -s - TuxPaint.app
     $ make TuxPaint.dmg

Android

   mars 29, 2023 Pere Pujal i Carabantes <perepujal@gmail.com> (Edited by
   Bill Kendrick)

   As of March 2023, the Android build of Tux Paint is maintained in a
   separate code repository at GitHub:
   https://github.com/tux4kids/Tuxpaint-Android. Detailed instructions are
   there; this acts as an overview.

  Prérequis

   You will need recent versions of:
     * Gradle — build automation tool
     * Android Studio (Software Development Kit (SDK)) — to support Android
       app development (Java)
     * Android Native Development Kit (NDK) — to support native development
       in C/C++

   To compile the latest Tux Paint, one has to sync the main SourceForge
   project's tuxpaint Git repository with the GitHub project's
   TuxPaint-Android Git repository. (Pere uses a shell script that backs up
   the app/src/main/jni/tuxpaint directory in the Tuxpaint-Android GitHub
   repo and makes a build of SourceForge's tuxpaint to generate translations
   and other things that are not autogenerated in the Android builds, and
   then copies the SourceForge tuxpaint back to Tuxpaint-Android.) (FIXME: It
   should be checked-in somewhere. For now, see
   https://sourceforge.net/p/tuxpaint/feature-requests/224/)

   For it to run you need the tuxpaint and Tuxpaint-Android sources one next
   to one another, and the script in the directory containing both.

   Fill the app/src/main/assets directory by running cd
   app/src/main/jni/tuxpaint && ./mkzip_assets.sh

  Building

   The Gradle build generates some variants: PlayStore, debugPlayStore,
   offPlayStore and debugoffPlayStore. You must sign the non-debug ones to be
   able to install them. (FIXME: Link to info on how to sign.) (Note:
   "playStore" ones are intended to be uploaded to Google Play; this is
   currently managed by Terrence Sheflin —March 2023. "offPlayStore" is the
   flavor that we distribute as APK files on the Tux Paint website and
   SourceForge file hosting, and is the variant built by the F-Droid app.
   repository.)

   To trigger a build from F-droid, it suffices to tag a commit and push it
   to GitHub. That doesn't guarantee the build will succeed though, so Pere
   usually runs a local F-droid server to test the build and eventually adapt
   the F-droid's build receipt before pushing the tag to GitHub.

   The builds Pere distributes are all made with that local F-droid server.
   It has the advantage of packing the sources and logs, and signing the APK.
   Most importantly, it uses the same tools F-Droid will use to build Tux
   Paint, so you can detect problems beforehand.

   The receipt Pere uses for F-Droid builds is in the metadata dir of
   https://gitlab.com/fdroid/fdroiddata. The F-Droid server code is at
   https://gitlab.com/fdroid/fdroidserver. To generate the server you will
   need 1GB free on disk. Run the makebuildserver tool they provide, then,
   from the root of fdroiddata, run ../fdroidserver/fdroid build --server
   org.tuxpaint:NNNN (NNNN = version, e.g. 9288)

                                    Débogage

   ⚙ Le débogage — vers "STDOUT", avec Linux et Unix, vers un fichier
   "stdout.txt"avec Windows, et vers le fichier "/tmp/tuxpaint.log" avec
   macOS — peut être activé en définissant "DEBUG" (et, si un mode verbeux
   est souhaité, "VERBOSE") # define dans "src/debug.h, et en (re)compilant
   Tux Paint.

                          Désinstallation de Tux Paint

Windows

  Utilisation du désinstalleur

   Si vous avez installé les raccourcis du menu Démarrer (par défaut),
   accédez au dossier TuxPaint et sélectionnez "Désinstaller". Une boîte
   s'affichera qui confirme que vous êtes sur le point de désinstaller Tux
   Paint et, si vous en êtes certain et que vous souhaitez supprimer
   définitivement Tux Paint, cliquez sur le bouton 'Désinstaller'.

   Quand c'est fini, cliquez sur "Fermer".

  En utilisant le panneau de configuration

   Il est également possible d'utiliser l'entrée "TuxPaint (supprimer
   uniquement)" dans la Section Ajout / Suppression de programmes du Panneau
   de configuration.

macOS

   Enlevez "TuxPaint.app" du dossier "Applications". Les fichiers de données
   les fichiers de configuration, les tampons et les images sauvegardées
   peuvent être trouvées dans "/Library/Application Support/TuxPaint" (pour
   tous les utilisateurs) et "/Users/USERNAME/Library/Application
   Support/TuxPaint" pour les utilisateurs individuels.

Linux

   Dans le répertoire source de Tux Paint (où vous avez compilé Tux Paint),
   vous pouvez utiliser une cible "make uninstall" pour désinstaller Tux
   Paint. Par défaut, cela doit être fait par l'utilisateur "root"
   ("superutilisateur"), mais si vous avez installé Tux Paint à un autre
   endroit (par ex. en mettant "PREFIX=..." à "make" et "make install", vous
   ne pourrez pas, et il faudra fournir les mêmes réglages ici. (Voir <a
   href="#compiling-linux>les instructions d'installation ci-dessus pour plus
   d'informations.)
