Compilando Fritzing en ArchLinux

Para instalar Fritzing en Archlinux no la tenemos en los repositorios oficiales así que nos quedan las siguientes opciones una es AppImage, de pago, bajada de la propia pagina pero no me suelen gustar las AppImage otra opción es usar AUR ya sea con «yay» o directamente pero después de las ultimas noticias de malware no me siento seguro.

Así que decidí volver a la compilación directa de programas que no están en los repositorios oficiales y si estan en github perfecto pues los actualizo cuando deseo. La verdad es que me base un poco en que hacia AUR pero eso me obligo a comprobar por completo el AUR y ademas solucione algunos problemas que vi.

Sin mas empezamos con sus diferentes fases:

1.- Instalar las dependencias

Lo primero que deberemos hacer es instalar los programas necesarios para compilar, así como librerías y dependencias.

sudo pacman -S base-devel cmake 
sudo pacman -S qt6-5compat 
sudo pacman -S --asdeps boost git patchelf qt6-tools
sudo pacman -S glibc libgcc libgit2 libstdc++ 
sudo pacman -S qt6-base qt6-serialport qt6-svg quazip-qt6 ngspice zlib

Seria interesante también instalar polyclipping pero no se encuentra en los repositorios oficiales, así que lo resolveremos descargando los ficheros de clipperV1, como veremos más adelante.

Con las dependencias instaladas crearemos un directorio de trabajo, que es donde descargaremos los ficheros fritzing y librerías necesarias que no están disponibles en los repositorios oficiales.

mkdir -p ~/Fritzing
cd ~/Fritzing

2.- Descarga de fuentes y librerías necesarias

Lo primero es clonar los repositorios de fritzing, tanto del programa como componentes.

git clone https://github.com/fritzing/fritzing-app.git
git clone https://github.com/fritzing/fritzing-parts.git

La primera librería que necesitaremos, en realidad solo las cabeceras sera las de SVG++ ademas de descargarlas la desempaquetaremos y las instalaremos en un directorio dentro del nuestro de trabajo con un nombre especial que se utilizara en los ficheros de compilación que tocaremos.

wget https://github.com/svgpp/svgpp/archive/refs/tags/v1.3.1.tar.gz
mv v1.3.1.tar.gz svgpp-1.3.1.tar.gz  
tar -xvf svgpp-1.3.1.tar.gz

Después las cabeceras de clipper, y su fuente y se instalara en un directorio especial, que crearemos, de la aplicación fritzing.

mkdir -p fritzing-app/src/lib/clipper

curl -sSL https://sourceforge.net/p/polyclipping/code/HEAD/tree/trunk/cpp/clipper.hpp?format=raw -o fritzing-app/src/lib/clipper/clipper.hpp

curl -sSL https://sourceforge.net/p/polyclipping/code/HEAD/tree/trunk/cpp/clipper.xpp?format=raw -o fritzing-app/src/lib/clipper/clipper.xpp

3.- Parcheo de código y ficheros configuración

Lo primero sera situarnos en el directorio de aplicación que se creo con git clone..

cd ~/Fritzing/fritzing-app

Primer fichero a modificar phoenix.pro, que es el fichero principal de proyecto de QMake (QMake Project File). para saber qué y cómo compilar. En el se definen las estructuras de archivos y gestiona los modulos Qt, que es lo que realmente nos importa pues añadiremos el modulo «core5compat» para poder usar «quazip-qt6«.

phoenix.pro
   Añadir a QT core5compat para tener quazip-qt6
			QT += concurrent core gui network printsupport serialport sql svg widgets xml svgwidgets openglwidgets core5compat
   Borrar las siguiente slineas para evitar el requerimiento de versión QT
      QT_LEAST=6.5.3
      QT_MOST=6.10.10
      !versionAtLeast(QT_VERSION, $${QT_LEAST}):error("Use at least Qt version $${QT_LEAST}")
      !versionAtMost(QT_VERSION, $${QT_MOST}):error("Use at most Qt version $${QT_MOST}")

Ahora continuaremos con otros archivos que son auxiliares de phoenix.pro. El primer fichero es «pri/quazipdetect.pri» antes de eso veremos el PATH de QuaZip-Qy6 con el comando «pacman -Ql quazip-qt6 | grep include«

pri/quazipdetect.pri   (Dejamos solo este código)
   SOURCES += \
       src/zlibdummy.c \
	 
   message("including Arch's quazip library")
   INCLUDEPATH += /usr/include/QuaZip-Qt6-1.7.2/
   LIBS += -lquazip1-qt6

Continuamos con «pri/spicedetect.pri» que nos permitirá encontrar ngspice y debe quedar de la siguiente forma.

pri/spicedetect.pri     
   message("Using customized ngspice detect script.")
   NGSPICEPATH = "/usr/include/ngspice/"
	 
   exists($$NGSPICEPATH) {
      message("using $${NGSPICEPATH}")
      INCLUDEPATH += $$NGSPICEPATH
   } else {
       error("ngspice not found in $${NGSPICEPATH}")
   }

El siguiente archivo .pri a modificar es clipper1detect.pri que nos permitirá encontrar los encabezados y fuentes de clipper.

pri/clipper1detect.pri    
   # 1. Definir el módulo como presente para el proyecto
   DEFINES += MINGW_CLIPPER
   # 2. Agregar la carpeta local al include path para que encuentre clipper.hpp
   INCLUDEPATH += $$PWD/../src/lib/clipper
   # 3. Incluir las fuentes de Clipper en el proceso de compilación
   HEADERS += $$PWD/../src/lib/clipper/clipper.hpp
   SOURCES += $$PWD/../src/lib/clipper/clipper.cpp

Ahora antes de compilar nos queda modificar un ultimo fichero que es «org.fritzing.Fritzing.desktop» que nos permitirá lanzar Frtizing.

sed -i 's/Exec=Fritzing/Exec=env QT_AUTO_SCREEN_SCALE_FACTOR=0 Fritzing/' org.fritzing.Fritzing.desktop

4.- Compilación

Ya empezamos con lo fuerte, pues tardara un ratito, que es la compilación decir que en caso de que se aborte y queramos limpiar lo compilado porque modifiquemos algo en un fichero ejecutaremos «rm -rf build .qmake.stash«.

Las fases, siempre que estemos en «fritzing-app», seran:

• Generar las traducciones
• Crear y situarnos en la carpeta de compilación
• Generar Makefile QT6
• Compilar

/usr/bin/lrelease-pro6 phoenix.pro
mkdir build && cd build
qmake6  ..
make

5.- Instalación

Una vez llegado a este punto solo nos queda instalarlo y podremos borrar el directorio de trabajo, yo no lo borro pero todo depende del espacio que dispongamos en el disco así si ejecuto «git pull» en «fritzing-app» y veo que lo han actualizado lo recompilo.

En este caso nos situaremos en el directorio build que es donde se compilo el programa, seguramente todavía estemos en el. Las fases serán:

• Instala los ficheros compilados.
• Copia la ruta de componentes a las rutas del sistema.
• Generamos la Base de Datos «parts.db»
• Borramos temporales de las partes innecesarios.

sudo make install 

sudo cp -dr ../../fritzing-parts /usr/share/fritzing/

sudo Fritzing -db /usr/share/fritzing/fritzing-parts/parts.db -pp /usr/share/fritzing/fritzing-parts -f  /usr/share/fritzing -platform offscreen

sudo rm -rf /usr/share/fritzing/fritzing-parts/.git{,ignore}

Esperemos que os sea útil, es cierto que es un poco más costoso en tiempo que un AUR directamente y que si se actualiza debemos de comprobarlo nosotros a mano con «git pull» pero la verdad es que se aprende mucho y me quita el miedo de AUR.