                                   Tux Paint
                                 versión 0.9.28
                          Documentación da instalación

    Copyright © 2002-2022 por varios colaboradores; vexa AUTHORS (AUTORES).
                             https://tuxpaint.org/

                             20 de Xaneiro de 2022

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

   +----------------------------------------------------+
   |Índice                                              |
   |----------------------------------------------------|
   |  * Requirements                                    |
   |       * Simple DirectMedia Layer library (libSDL)  |
   |       * Outras bibliotecas                         |
   |  * Compiling and Installation                      |
   |       * Usuarios de Windows                        |
   |       * Usuarios de Linux/Unix                     |
   |       * Usuarios de macOS                          |
   |  * Debugging                                       |
   |  * Uninstalling Tux Paint                          |
   |       * Windows                                    |
   |       * macOS                                      |
   |       * Linux                                      |
   +----------------------------------------------------+

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

Requirements

  Simple DirectMedia Layer library (libSDL)

       Tux Paint require a «Simple DirectMedia Layer Library (libSDL)», unha
       biblioteca de programación multimedia de código aberto dispoñíbel
       baixo a licenza pública GNU Lesser General Public License (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) SDL_Pango (for
       True Type Font support) and, optionally, SDL_Mixer (for sound
       effects).

    Usuarios de Linux/Unix:

         As bibliotecas SDL están dispoñíbeis como código fonte ou como
         paquetes RPM ou Debian para varias distribucións de Linux. Pódense
         descargar dende:

           * libSDL: http://www.libsdl.org/
           * SDL_Image: http://www.libsdl.org/projects/SDL_image/
           * SDL_gfx:
             https://www.ferzkopp.net/wordpress/2016/01/02/sdl_gfx-sdl2_gfx/
             (https://sourceforge.net/projects/sdlgfx/)
           * SDL_TTF: http://www.libsdl.org/projects/SDL_ttf/
           * SDL_Pango: http://sourceforge.net/projects/sdlpango/ (opcional)
           * SDL_Mixer: http://www.libsdl.org/projects/SDL_mixer/ (opcional)

         Normalmente tamén están dispoñíbeis xunto coa súa distribución de
         Linux (p. ex.: nun medio de instalación ou dispoñíbeis a través dun
         software de mantemento de paquetes como «apt» de Debian).

         Nota: Cando instale bibliotecas a partir de paquetes, asegúrese de
         instalar TAMÉN as versións de desenvolvemento dos paquetes. (Por
         exemplo, instale tanto «SDL-1.2.4.rpm» como «SDL-1.2.4-devel.rpm».).

  Outras bibliotecas

       Tux Paint tamén aproveita outras bibliotecas libres con licenza LGPL.
       En Linux, do mesmo xeito que SDL, deberían estar xa instaladas ou
       estar dispoñíbeis para a súa instalación como parte da súa
       distribución de Linux.

    libPNG

         Tux Paint utiliza o formato PNG (Portable Network Graphics –
         Gráficos de Rede Portátiles) para os seus ficheiros de datos. A
         imaxe SDL requirirá a instalación de libPNG.

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

    gettext

         Tux Paint utiliza a configuración local do sistema xunto coa
         biblioteca «gettext» para admitir varios idiomas (p. ex., o
         español). Necesitará ter a biblioteca gettext instalada.

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

    libpaper (Só Linux/Unix)

         A partir de Tux Paint 0.9.17, Tux Paint pode determinar o tamaño de
         papel predeterminado do seu sistema (p. ex.: A4 ou Carta), ou
         pódeselle indicar que use un tamaño de papel particular, grazas a
         «libpaper».

         https://github.com/naota/libpaper

    FriBiDi

         As ferramentas «Texto» e «Etiqueta» de Tux Paint admiten linguaxes
         bidireccionais grazas á biblioteca «FriBiDi».

         http://fribidi.org/

    Compatibilidade de SVG

         A partir de Tux Paint 0.9.17, Tux Paint pode cargar imaxes SVG
         (Scalable Vector Graphics — Gráficos Vectoriais Escalábeis) como
         selos. Admítense dous conxuntos de bibliotecas e pódese desactivar
         completamente a compatibilidade SVG (a través de «make SVG_LIB:=»)

      librsvg-2 & libCairo2 (bibliotecas máis recentes)

           * libRSVG 2: http://librsvg.sourceforge.net/
           * Cairo 2: http://www.cairographics.org/
           * Estes tamén dependen do seguinte:
                * GdkPixbuf & GLib: http://www.gtk.org/
                * Pango: http://www.pango.org/

      Bibliotecas SVG máis antigas

           * libcairo1, libsvg1, & libsvg-cairo1:
             http://www.cairographics.org/
           * Estes tamén dependen do seguinte:
                * libxml2: https://gitlab.gnome.org/GNOME/libxml2

    Función de exportación de GIF animado

         Para a compatibilidade da exportación de GIF animados (presentacións
         de diapositivas), é necesaria a biblioteca «libimagequant» (do
         proxecto «pngquant2»).

         https://github.com/ImageOptim/libimagequant

    Ferramentas NetPBM (opcional) Xa non se usa, de xeito predeterminado

         En Linux e Unix, as versións anteriores de Tux Paint utilizaban as
         ferramentas NetPBM para axudar á impresión. (Tux Paint xera un PNG e
         convértese nun PostScript usando as ferramentas da liña de ordes
         NetPBM «pngtopnm» e «pnmtops»).

         http://netpbm.sourceforge.net/

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

Compiling and Installation

     Tux Paint publícase baixo a Licenza Pública Xeral de GNU (GPL) (consulte
     «COPYING.txt» para máis detalles) e, polo tanto, o «código fonte» do
     programa está dispoñíbel libremente.

  Usuarios de Windows

     3 de Novembro de 2021 Shin-ichi TOYAMA shin1@wmail.plala.or.jp
     <shin1@wmail.plala.or.jp>

    Compiling Set-Up

         A partir de febreiro de 2005 (comezando con Tux Paint 0.9.15), o
         «Makefile» inclúe compatibilidade para construír nun sistema Windows
         usando MinGW/MSYS (https://sourceforge.net/projects/msys2/).

         Many tools and libraries are required to build Tux Paint. The
         package management system "pacman" helps you install them
         automatically solving complicated dependencies.

         Download the latest MSYS2 environment from
         https://sourceforge.net/projects/msys2/files/Base/ and install it
         where you'd like (the default is "C:\msys64")

         Open the MSYS2 shell from the "Start Menu" -> "MSYS2 64bit" ->
         "MSYS2 MSYS" and execute following command (press [Intro] or
         [Retorno] to accept the defaults for all questions):

           pacman -Syu

         This will update core system and the window will close
         automatically. Repeat the steps above one more time to finish the
         remaining update process.

         Within the MSYS2 shell, run the following command to install basic
         development tools:

           pacman -S base-devel msys2-devel git

       Proceed to the next "MinGW 64bit (x86_64) toolchains" section, or skip
       to the "MinGW 32bit (i686) toolchains" section if you need only a
       32bit build environment.

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

    MinGW 64bit (x86_64) toolchains

         Within the MSYS2 shell, run the following command to install basic
         64bit development tools:

           pacman -S mingw-w64-x86_64-toolchain

    64bit (x86_64) dependency libraries for Tux Paint

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

         "ntldd" is a small tool which examine windows executable files to
         list Dynamic Link Library (.dll) files they depends on. Tux Paint's
         packaging process for binary distribution uses it to find required
         .dll files.

         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,mixer,ttf,gfx}
           $ pacman -S mingw-w64-x86_64-librsvg
           $ pacman -S mingw-w64-x86_64-fribidi
           $ pacman -S mingw-w64-x86_64-libimagequant
           $ pacman -S mingw-w64-x86_64-fltk
           $ pacman -S mingw-w64-x86_64-ntldd-git

         Note: Close the shell before proceeding to the remaining process.

    Install SDL_Pango on the 64bit environment

         SDL_Pango should be installed manually.

         This time, use the MinGW "64bit" shell. Open the shell from the
         "Start Menu" -> "MSYS2 64bit" -> "MSYS2 MinGW 64-bit"

      SDL_Pango

           At first, you have to prepare source tar-ball and a required patch
           in the same directory.

             * Download source tar-ball of SDL_Pango-0.1.2 from SDL_Pango's
               page on Sourceforge.net.
             * Download a patch file from John Popplewell's "Tux Paint -
               MinGW/MSYS build instructions" webpage. (This adds some extra
               (required) functionality to SDL_Pango.)

           Build and install SDL_Pango as follows.

             $ tar zxvf SDL_Pango-0.1.2.tar.gz
             $ cd SDL_Pango-0.1.2/
             $ patch -p0 < ../SDL_Pango-configure-extra-api.patch
             $ ./configure --prefix=/mingw64 && make && make install

       Proceed to the next "MinGW 32bit (i686) toolchains" section, or skip
       to the "ImageMagick" section if you need only a 64bit build
       environment.

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

    MinGW 32bit (i686) toolchains

         Within the MSYS2 shell, run the following command to install basic
         32bit development tools:

           pacman -S mingw-w64-i686-toolchain

    32bit (i686) dependency libraries for Tux Paint

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

         "ntldd" is a small tool which examine windows executable files to
         list Dynamic Link Library (.dll) files they depends on. Tux Paint's
         packaging process for binary distribution uses it to find required
         .dll files.

         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,mixer,ttf,gfx}
           $ pacman -S mingw-w64-i686-librsvg
           $ pacman -S mingw-w64-i686-fribidi
           $ pacman -S mingw-w64-i686-libimagequant
           $ pacman -S mingw-w64-i686-fltk
           $ pacman -S mingw-w64-i686-ntldd-git

         Note: Close the shell before proceeding to the remaining process.

    Install SDL_Pango on the 32bit environment

         SDL_Pango should be installed manually.

         This time, use the MinGW "32bit" shell. Open the shell from the
         "Start Menu" -> "MSYS2 64bit" -> "MSYS2 MinGW 32-bit"

      SDL_Pango

           At first, you have to prepare source tar-ball and a required patch
           in the same directory.

             * Download source tar-ball of SDL_Pango-0.1.2 from SDL_Pango's
               page on Sourceforge.net.
             * Download a patch file from John Popplewell's "Tux Paint -
               MinGW/MSYS build instructions" webpage. (This adds some extra
               (required) functionality to SDL_Pango.)

           Build and install SDL_Pango as follows.

             $ tar zxvf SDL_Pango-0.1.2.tar.gz
             $ cd SDL_Pango-0.1.2/
             $ patch -p0 < ../SDL_Pango-configure-extra-api.patch
             $ ./configure --prefix=/mingw32 && make && make install

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

    ImageMagick

         ImageMagick is a compilation of command line tools to create, edit,
         compose, or convert bitmap images supporting quite a large number of
         image formats. Tux Paint uses two functions ("convert" and
         "composite") in it to generate thumbnails for startar images and
         templates during the build process.

         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!

         Do not forget to enable "Install legacy utilities (e.g. convert)"
         while installing it, because Tux Paint's build process uses them.

         Add the path to the directory in which ImageMagick is installed at
         the top of your "PATH" environment variable. For example:

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

         You can make this permanent by adding the above to your the BASH
         shell configuration file, "~/.bash_profile".

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

    Tux Paint

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

           * Select "MSYS2 64bit" -> "MSYS2 MinGW 64-bit" from the "Start
             Menu" to open the 64bit shell.
           * Select "MSYS2 64bit" -> "MSYS2 MinGW 32-bit" from the "Start
             Menu" to open the 32bit shell.

         Compile Tux Paint with the following command:

           $ make bdist-win32

         Note: At this point, you will want to build "Tux Paint Config." for
         Windows, so it can be included along with "Tux Paint", if you're
         making an official (or test) release. The build process will look
         for it in a directory named "tuxpaint-config" (with no version
         number, e.g., "tuxpaint-config-X.Y.Z"). See "Tux Paint Config."'s
         INSTALL.txt documentation for details.

         All the files needed for starting Tux Paint (and Tux Paint Config.)
         are collected in the directory for binary distribution "bdist"
         directory under "win32". You can start them by double-clicking their
         executable (.exe) files in the "bdist" directory.

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

    Building the Tux Paint Windows Installer:

         Inno Setup is used to build executable installer for Tux Paint.
         Therefore you have to install it in the first place.

         Inno Setup officially supports translations for only about 20
         languages. However, one of the great points of Tux Paint is it
         supports so many languages. Therefore, the set up script
         "tuxpaint.iss" to build the installer is written to use much more
         translations including unofficial one which are available on "Inno
         Setup Translations". You have to download translation files (.isl)
         required and put them in "Languages" directory under the directory
         in which Inno Setup is installed.

         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.

         Then, you can easily build an executable installer by right-clicking
         on the "tuxpaint.iss" icon in the "win32" directory and selecting
         "Compile" on the list. It will run for a while, and eventually you
         will find a "tuxpaint-X.Y.Z-windows-<arch>-installer.exe" file in
         the same directory.

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

    Running the Tux Paint Windows Installer:

         Faga dobre clic no executábel do instalador de Tux Paint (ficheiro
         .EXE) e siga as instrucións.

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

         Após preguntaráselle se quere instalar accesos directos a Tux Paint
         no seu menú de inicio de Windows e no escritorio de Windows.
         (Ámbalas dúas opcións están definidas de xeito predeterminado.)

         A seguir preguntaráselle onde quere instalar Tux Paint. O valor
         predeterminado debería ser axeitado, sempre que haxa espazo
         dispoñíbel. Se non, escolla un lugar diferente.

         Neste punto, pode premer en «Instalar» para instalar Tux Paint.

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

    Cambiar os axustes usando o acceso directo:

         Para cambiar os axustes do programa, prema co botón dereito no
         atallo de TuxPaint e seleccione «Propiedades» (na parte inferior).

         Asegúrese de que a lapela «Atallo» está seleccionada na xanela que
         aparece e examine o campo «Obxectivo:». Debería ver algo así:

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

         Agora pode engadir opcións de liña de ordes que se activarán ao
         facer dobre clic na icona.

         Por exemplo, para que o xogo se execute en modo de pantalla
         completa, con formas sinxelas (sen opción de rotación) e en francés,
         engada as opcións (após «TuxPaint.exe»), así:

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

         (Vexa a documentación principal para obter unha lista completa das
         opcións dispoñíbeis da liña de ordes.)

         Se se trabuca ou desaparece todo, use [Ctrl] + [Z] para desfacer ou
         só prema a tecla [Esc] e a caixa pecharase sen facer cambios (a non
         ser que premera o botón «Aplicar»).

         Cando teña rematado, prema en «Aceptar».

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

    Se algo vai mal:

         Se ao facer dobre clic no atallo para executar Tux Paint, non ocorre
         nada, probabelmente sexa porque algunhas destas opcións da liña de
         ordes son incorrectas. Abra un explorador de ficheiros coma antes e
         busque un ficheiro chamado «stderr.txt» no cartafol TuxPaint.

         Conterá unha descrición do que estaba mal. Normalmente só se debe a
         maiúsculas e minúsculas incorrectas (maiúsculas «Z» no canto de
         minúsculas «z») ou a falta (ou exceso) de «-» (guións).

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

  Usuarios de Linux/Unix

    Compilación:

         Nota: Tux Paint non usa autoconf/automake, polo que non hai ningún
         script «./configure» para executar. Non obstante, a compilación
         debería ser directa, supoñendo que todo o que precisa Tux Paint está
         instalado.

         Para compilar o programa dende o código fonte, simplemente execute a
         seguinte orde dende un indicador do sistema (p. ex.: «$»):

           $ make

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

    Desactivar a compatibilidade de «SVG» (e, polo tanto, as dependencias de
    «Cairo, libSVG, e svg-cairo»:

         Para desactivar a compatibilidade con SVG (por exemplo, se o seu
         sistema non é compatíbel coa biblioteca de Cairo ou outras
         dependencias relacionadas co SVG), pode executar «make» engadindo
         «SVG_LIB= SVG_CFLAGS= NOSVGFLAG=NOSVG»:

           $ make SVG_LIB= SVG_CFLAGS=

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

    Desactivar a compatibilidade de «Pango» (e, polo tanto, as dependencias de
    «Pango, Cairo, etc.»:

         Antes da versión 0.9.18, Tux Paint utilizaba a biblioteca libSDL_ttf
         para renderizar texto usando tipos de letra TrueType. Dende o 0.9.18
         úsase libSDL_Pango, xa que ten unha mellor compatibilidade coa
         internacionalización. Non obstante, se quere desactivar o uso de
         SDL_Pango, pode facelo executando «make» engadindo «SDL_PANGO_LIB=»:

           $ make SDL_PANGO_LIB=

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

    Desactivación do son en tempo de compilación:

         Se non te unha tarxeta de son ou prefire construír o programa sen
         asistencia de son (e polo tanto sen a dependencia SDL_mixer), pode
         executar «make» con «SDL_MIXER_LIB=» engadido:

           $ make SDL_MIXER_LIB=

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

    Outras opcións:

         Outras opcións (p. ex.: rutas de instalación) poden ser anuladas;
         véxaas en «Makefile» para máis detalles.

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

    Se se producen erros:

         Se recibe algún erro durante o tempo de compilación, asegúrese de
         ter instaladas as bibliotecas axeitadas (ver máis arriba). Se está a
         empregar versións empaquetadas das bibliotecas (por exemplo, RPM en
         RedHat ou DEB en Debian), asegúrese de obter tamén os
         correspondentes paquetes «-dev» ou «-devel», se non, non poderá
         compilar Tux Paint (e outros programas) dende o código fonte.

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

    Instalar:

         Supoñendo que non se produciron erros graves, agora pode instalar o
         programa para que os usuarios do sistema poidan executalo. De xeito
         predeterminado, isto debe facelo o usuario «root» («superusuario»).
         Cambie a «root» escribindo a orde:

           $ su

         Introduza o contrasinal de «root» no indicador do sistema. Agora
         debería ser «root» (cun indicador como «#»). Para instalar o
         programa e os seus ficheiros de datos, escriba:

           # make install

         Finalmente, pode volver ao seu usuario habitual saíndo do modo de
         superusuario:

           # exit

         Como alternativa, pode simplemente usar a orde «sudo» (po.ex.: en
         Ubuntu Linux):

           $ sudo make install

         Nota: De xeito predeterminado, «tuxpaint», o programa executábel,
         colócase en «/usr/local/bin/». Os ficheiros de datos (imaxes, sons,
         etc.) colócanse en «/usr/local/share/tuxpaint/».

      Cambiar onde van as cousas

           Pode cambiar onde irán as cousas axustando as variábeis de
           «Makefile» na liña de ordes. «DESTDIR» úsase para colocar a saída
           nunha área de espera para a creación de paquetes. «PREFIX» é a
           base de onde van todos os demais ficheiros e, de xeito
           predeterminado, está estabelecido en «/usr/local».

           Outras variábeis son:

           BIN_PREFIX
                   Onde se instalará o binario «tuxpaint». (Estabelécese como
                   «$(PREFIX)/bin»como predeterminado, p. ex.:
                   «/usr/local/bin»)

           DATA_PREFIX
                   Onde irán os ficheiros de datos (son, gráficos, pinceis,
                   selos, tipos de letra) e onde os buscará Tux Paint cando
                   se execute. (Estabelecer en «$(PREFIX)/share/tuxpaint»)

           DOC_PREFIX
                   Onde irán os ficheiros de texto da documentación (o
                   directorio «docs»). (Estabelecer como
                   «$(PREFIX)/share/doc/tuxpaint»)

           MAN_PREFIX
                   Onde irá a páxina do manual de Tux Paint. (Estabelecer
                   como «$(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
                   Onde irán as iconas e os lanzadores (para GNOME e KDE).

           LOCALE_PREFIX
                   Onde irán os ficheiros de tradución para Tux Paint e onde
                   os buscará Tux Paint. (Estabelécese en
                   «$(PREFIX)/share/locale/») (A localización final dun
                   ficheiro de tradución estará no directorio da
                   configuración local (por exemplo, «es» para o español),
                   dentro do subdirectorio «LC_MESSAGES»).

           Nota: Esta lista non está actualizada. Consulte «Makefile» e
           «Makefile-i18n» para ver unha lista completa.

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

  Usuarios de macOS

     20 de Xaneiro de 2022 Mark Kim <markuskimius@gmail.com>

       Tux Paint 0.9.22 and earlier required building Tux Paint from the
       Xcode IDE. Starting with 0.9.23, however, Tux Paint for macOS is built
       as though it were a Linux application.

    Prerequisites

         Although Tux Paint is built without the Xcode IDE, Xcode itself is
         still required to build Tux Paint. Download it from the App Store,
         and launch it once to accept its license agreements. You may also
         need to install the Xcode command line tools using the command:

           xcode-select --install

         Building Tux Paint also requires various libraries. We install them
         from MacPorts where possible, source code otherwise. Install
         MacPorts to the default /opt/local path according to the
         instructions found on their website: https://www.macports.org/
           * ImageMagick
           * cairo
           * fribidi
           * lbzip2
           * libimagequant^*
           * libpaper
           * libpng
           * librsvg
           * libsdl
           * libsdl_image
           * libsdl_mixer
           * libsdl_pango
           * libsdl_ttf
           * libsdl_gfx
           * pkgconfig
           * zlib
         ... but you should install any package that is required by the
         latest version of Tux Paint.

         ^* Not available from MacPorts as of this writing, see below.

      libimagequant

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

             $ 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

         WARNING: Having any UNIX-like toolset installed on your Mac besides
         MacPorts and Xcode, such as Fink or Brew, will prevent your app
         bundle from being portable. Be sure Fink and Brew are not accessible
         from your build environment.

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

    How to Build

         Simply, run:

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

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

    Known Issues

           * A macOS binary built on a specific version of macOS only runs on
             that version of macOS or later. To ensure Tux Paint can run on
             the oldest version of macOS possible, build it on the oldest
             version of macOS available. As of this writing we know Tux Paint
             cannot be built to run on macOS 10.7 or earlier.

             See "Old Versions of macOS" below for best-effort instructions
             on how to obtain, install, and build Tux Paint on an old version
             of 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.

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

    Old Versions of macOS

         Some old versions of macOS can be downloaded from Apple's support
         page: 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.

         As of this writing, the oldest version of macOS available on Apple's
         support site is Yosemite 10.10, which expects "GPT (GUID Partition
         Table)" partitioning scheme instead of the older MBR scheme, and
         "Mac OS Extended (Journaled)" as the partition type instead of the
         newer APFS partition type.

         Upon launching the installer, if you get a popup about macOS being
         too old or new to be installed, a bootable installer can be created
         using the instructions found here:
         https://support.apple.com/en-mide/HT201372

         Once the old macOS is installed, you may find the Xcode on the App
         Store is too new to run on the version of the old macOS. Old
         versions of Xcode can be downloaded from Apple's Developer site in
         an area accessible with free registration:
         https://developer.apple.com/download/more/

         The list of macOS versions and the last version of Xcode compatible
         with them are laid out nicely on the Wikipedia page on Xcode:
         https://en.wikipedia.org/wiki/Xcode#Version_comparison_table

         And because Xcode is being installed manually, you can skip the step
         to install the Xcode command line tools (do not run "xcode-select
         --install") but otherwise build Tux Paint using the same steps
         described in the earlier part of this 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 Applie 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

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

Debugging

     Debugging output — to "STDOUT" on Linux and Unix, to a "stdout.txt" file
     on Windows, and to the file "/tmp/tuxpaint.log" on macOS — can be
     enabled by setting "DEBUG" (and, if verbose logging is wanted,
     "VERBOSE") #defines in "src/debug.h" and (re)compiling Tux Paint.

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

Uninstalling Tux Paint

  Windows

    Uso do desinstalador

         Se instalou os atallos do menú Inicio (o predeterminado), vaia ao
         cartafol TuxPaint e seleccione «Desinstalar». Amosarase unha caixa
         que confirmará que está a piques de desinstalar Tux Paint e, se está
         seguro de que quere eliminar permanentemente Tux Paint, prema no
         botón «Desinstalar».

         Cando remate, prema no botón pechar.

    Usar o Panel de control

         Tamén é posíbel usar a entrada «TuxPaint (só eliminar)« na sección
         Engadir/Eliminar programas do Panel de control.

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

  macOS

       Delete "TuxPaint.app" from the "Applications" folder. Data files,
       including the configuration files, stamps, and saved pictures, may be
       found in "Library/Application Support/TuxPaint" (all users) and
       "/Users/USERNAME/Library/Application Support/TuxPaint" (individual
       users).

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

  Linux

       Within the Tux Paint source directory (where you compiled Tux Paint),
       you can use the "make uninstall" target to uninstall Tux Paint. By
       default, this must be done by the "root" user ('superuser'), but if
       you installed Tux Paint somewhere else (e.g., using a "PREFIX=..."
       setting to "make" and "make install"), you may not, and will want to
       provide those same settings here. (See the installation instructions
       above for further information.)
