Apéndice C: Compilar desde fuentes

Otra opción es compilar las librerías a partir del código fuente. Esto nos da la posibilidad de obtener diferentes configuraciones de librerías, y lo que es más importante, disponer siempre que queramos de una versión actualizada, sin tener que esperar a que otras personas generen los binarios y los pongan a nuestra disposición.

Compilar la versión monolítica o no monolítica

En el momento de escribir esto, la última versión estable es la 3.2.4. Hay que descargar el código fuente en el formato que prefieras, y descomprimirlo en una carpeta del disco duro. Por ejemplo C:/wxwidgets.

La página oficial dispone de guías detalladas para compilar la librería para distintas plataformas y usando diferentes compiladores. Ver compilar wxWidgets con MinGW.

Para compilar es necesario que la variable de entorno de Windows "path" contenga la ruta al compilador.

Si usamos Code::Blocks 20.03 con el compilador incluido, asumiremos que está instalado en C:/codeblocks, la ruta es: C:\CodeBlocks\MinGW\bin.

En caso de que se haya instalado TDM-GCC de 64 bits, asumiremos que está en la carpeta C.\TDM-GCC-64.

Si hemos instalado el compilador usando MSYS2, probablemente la ruta correspondiente al compilador ya esté en el PATH, y será, algo parecido a C:\msys64\mingw64.

Si usas otra versión, u otra ubicación, tendrás que hacer las correcciones oportunas.

También se asume que hemos descomprimido los ficheros fuente de wxWidgets en la carpeta C:\wxwidget.

Abriremos una consola de Windows, y desde el directorio donde están los ficheros correspondientes a la versión de la librería para Windows ejecutamos las siguientes ordenes:

  CD c:\wxwidgets\build\msw
  mingw32-make -f makefile.gcc  RUNTIME_LIBS=static USE_XRC=1 MONOLITHIC=1 SHARED=0 UNICODE=1 BUILD=release TARGET_CPU=X64  CXXFLAGS="-std=gnu++11"
  mingw32-make -f makefile.gcc  RUNTIME_LIBS=dynamic USE_XRC=1 MONOLITHIC=1 SHARED=1 UNICODE=1 BUILD=release TARGET_CPU=X64 CXXFLAGS="-std=gnu++11"
  mingw32-make -f makefile.gcc  RUNTIME_LIBS=static USE_XRC=1 MONOLITHIC=1 SHARED=0 UNICODE=1 BUILD=debug TARGET_CPU=X64 CXXFLAGS="-std=gnu++11"
  mingw32-make -f makefile.gcc  RUNTIME_LIBS=dynamic USE_XRC=1 MONOLITHIC=1 SHARED=1 UNICODE=1 BUILD=debug TARGET_CPU=X64 CXXFLAGS="-std=gnu++11"

Con estos parámetros se crearán cuatro versiones de las librerías. Respectivamente, las librerías estáticas de desarrollo (release), las dinámicas de desarrollo, las estáticas de depuración y las dinámicas de depuración.

Las versiones de depuración son opcionales, podemos depurar nuestros programas con las versiones de desarrollo, y probablemente no necesitemos depurar las librerías.

Si no queremos generar las versiones monolíticas, usaremos el parámetro MONOLITHIC=0.

Con estas opciones crearemos las versiones con soporte para caracteres Unicode y para 64 bits. Para crear las versiones de 32 bits se usa el valor X86.

La opción USE_XRC=1 permite usar XML Based Resource System (XRC), un sistema de recursos basado en XML.

Puedes ver otras opciones en el enlace de la Wiki anterior.

Nota: En mi caso he tenido problemas al tener instalados PowerShell, lo que provoca el error 5. Si también es ese tu caso, se soluciona añadiendo SHELL=CMD.exe a la lista de parámetros:

  mingw32-make SHELL=CMD.exe -f makefile.gcc  RUNTIME_LIBS=static USE_XRC=1 MONOLITHIC=1 SHARED=0 UNICODE=1 BUILD=release TARGET_CPU=X64  CXXFLAGS="-std=gnu++11"

El proceso de compilación puede requerir mucho tiempo, dependiendo del procesador y de otras opciones del hardware de tu equipo. La documentación indica que si se dispone de una CPU multiprocesador se puede añadir el parámetro -j_n, donde n es un número entero que indica el número de procesadores dedicados a la tarea, por ejemplo -j4. Sin embargo, no he podido verificar este punto.

Este método es igualmente válido si se usa el compilador TDM-GCC, que no deja de ser una versión parcheada del compilador y el API de MinGW.

En el artículo TDM-GCC en Code::Blocks se explica cómo usar este compilador con Code::Blocks.

Compilar usando MYS2

Si has optado por usar una versión actualizada de MinGW mediante MSYS2, el paquete MSYS2 para wxWidgets no parece que contenga una versión de desarrollo funcional, por lo que será necesario compilarla desde el código fuente.

Aunque el método anterior probablemente funcionará correctamente, la página de wxWidgets recomienda otro método para compilar los fuentes: https://docs.wxwidgets.org/latest/plat_msw_msys2.html.

El método es muy detallado y fácil de seguir, aunque está destinado a MinGW-32 y a crear las librerías estáticas.

Lo primero es asegurarse de que tenemos instalados todos lo paquetes necesarios:

 pacman -S --needed --noconfirm make
 pacman -S --needed --noconfirm ${MINGW_PACKAGE_PREFIX}-libjpeg-turbo
 pacman -S --needed --noconfirm ${MINGW_PACKAGE_PREFIX}-libpng
 pacman -S --needed --noconfirm ${MINGW_PACKAGE_PREFIX}-libtiff
 pacman -S --needed --noconfirm ${MINGW_PACKAGE_PREFIX}-gcc
 pacman -S --needed --noconfirm ${MINGW_PACKAGE_PREFIX}-gcc-libs
 pacman -S --needed --noconfirm ${MINGW_PACKAGE_PREFIX}-expat
 pacman -S --needed --noconfirm ${MINGW_PACKAGE_PREFIX}-xz
 pacman -S --needed --noconfirm ${MINGW_PACKAGE_PREFIX}-zlib

Desde la consola de MSYS2 cambiamos al directorio en el que se encuentran los fuentes de wxWidgets:

cd C:/wxWidgets

Es importante que la ruta use las barras '/', ya que las invertidas no funcionarán.

Ahora, dependiendo de qué versión de las librerías queramos el procedimiento varia ligeramente.

Crearemos una nueva carpeta donde se crearán los nuevos ficheros de librería. Conviene elegir un nombre descriptivo, por ejemplo, 'build-x86_64-msw-dynamic', que indica que las librerías van a ser compiladas para un procesador intel de 64 bits, para Windows (msw), y serán las DLL, y las correspondientes librerías estáticas para poder usarlas.

Para indicar el procesador podemos usar la macro MSYSTEM_CARCH. Así, por ejemplo, para crear la carpeta para las librerías de enlace dinámico no monolíticas usaremos este comando:

mkdir -p build-${MSYSTEM_CARCH}-msw-dynamic

O para las librerías monolíticas de enlazado estático:

mkdir -p build-${MSYSTEM_CARCH}-msw-static-monolithic

Y así con el resto.

El siguiente paso consiste en crear el fichero de configuración que se usará para compilar las librerías. Aquí es donde se especificarán las opciones que deciden qué tipo de librerías se generarán.

El comando para generar el fichero de configuración se llama "configure", y tendremos que indicar algunas opciones:

• --with-mnw: esta opción es obligatoria para generar las librerías para Windows.
• --disable-shared: deshabilita la generación de DLLs, es decir, crea las librerías de enlazado estático.
• --enable-monolithic: crea la versión monolítica de las librerías.
• --disable-unicode: crea la versión sin soporte UNICODE.
• -- enable-debug: crea la versión de depuración de las librerías.
• -- with-libjpeg: crea la librería para soporte jpeg (necesaria).
• -- with-libpng: crea la librería para soporte png (necesaria).
• -- with-libtiff: crea la librería para soporte tiff (recomendada).
• -- with-zlib: crea la librería para soporte zlib (necesaria).
• -- with-expat: crea la librería para soporte expat (recomendada).
• -- with-regex: crea la librería para soporte regex (necesaria). Se crea por defecto.

No he probado a generar las versiones de depuración, así que no estoy seguro de si hay que añadir las opciones --enable-debug_info y --enable_degub_gdb.

De modo que para generar, por ejemplo, las librerías dinámicas monolíticas usaremos los siguientes comandos.

1. Crear la carpeta:

   mkdir -p build-${MSYSTEM_CARCH}-msw-dynamic-monolithic
   

2. Crear el fichero de configuración:

   cd build-${MSYSTEM_CARCH}-msw-dynamic-monolithic && \
   ../configure --with-msw --with-libjpeg=yes --with-libpng=yes --with-libtiff=yes --with-expat=yes -with-zlib=yes --enable-monolithic && \
    cd ..
   

Los caracteres && se usan para combinar varios comandos, la barra invertida para escribir los comandos en líneas separadas.

Por último, compilamos las librerías usando el comando:

cd build-${MSYSTEM_CARCH}-msw-dynamic-monolithic && make && cd ..

Ahora hay que tener paciencia. En mi ordenador este proceso requiere unos cincuenta minutos.