# comment
FROM alpine:edge

WORKDIR /mnt
ENV MY_WORKDIR=/mnt

ARG MINGW=/mingw64
ENV MY_MINGW=${MINGW}

ARG MINGW_PREFIX=x86_64-w64-mingw32
ENV MY_MINGW_PREFIX=${MINGW_PREFIX}

ARG NUM_JOBS=2
ENV MY_NUM_JOBS=${NUM_JOBS}

ARG TOOLCHAIN_FILE_CMAKE=/cmake_toolchain.cmake
ENV MY_TOOLCHAIN_FILE_CMAKE=${TOOLCHAIN_FILE_CMAKE}
RUN echo -e \
  "set(CMAKE_SYSTEM_NAME Windows)\n"\
  "set(CMAKE_CXX_COMPILER ${MY_MINGW_PREFIX}-g++)\n"\
  "set(CMAKE_C_COMPILER ${MY_MINGW_PREFIX}-gcc)\n"\
  "set(CMAKE_FIND_ROOT_PATH ${MY_MINGW})\n"\
  "set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)\n"\
  "set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)\n"\
  "set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)\n"\
  "set(CMAKE_Fortran_COMPILER ${MY_MINGW_PREFIX}-gfortran)\n"\
  "set(CMAKE_INSTALL_PREFIX ${MY_MINGW})\n"\
  "set(CMAKE_RC_COMPILER ${MY_MINGW_PREFIX}-windres)\n"\
    > ${MY_TOOLCHAIN_FILE_CMAKE}

ARG TOOLCHAIN_FILE_MESON=/meson_cross_file.txt
ENV MY_TOOLCHAIN_FILE_MESON=${TOOLCHAIN_FILE_MESON}
RUN echo -e \
  "[binaries]\n"\
  "ar = '${MY_MINGW_PREFIX}-ar'\n"\
  "c = '${MY_MINGW_PREFIX}-gcc'\n"\
  "cpp = '${MY_MINGW_PREFIX}-g++'\n"\
  "ld = '${MY_MINGW_PREFIX}-ld'\n"\
  "objcopy = '${MY_MINGW_PREFIX}-objcopy'\n"\
  "pkg-config = 'pkg-config'\n"\
  "strip = '${MY_MINGW_PREFIX}-strip'\n"\
  "windres = '${MY_MINGW_PREFIX}-windres'\n"\
  "exe_wrapper = 'wine64'\n"\
  "[properties]\n"\
  "c_args = []\n"\
  "c_link_args = []\n"\
  "[host_machine]\n"\
  "cpu = 'x86_64'\n"\
  "cpu_family = 'x86_64'\n"\
  "endian = 'little'\n"\
  "system = 'windows'\n"\
    > ${MY_TOOLCHAIN_FILE_MESON}

RUN apk add \
      autoconf \
      automake \
      bash \
      binutils \
      bison \
      bzip2 \
      clang17-extra-tools \
      cmake \
      flex \
      g++ \
      gcc \
      gettext \
      git \
      gmp \
      gmp-dev \
      gperf \
      gtkmm3-dev \
      intltool \
      isl-dev \
      libtool \
      linux-headers \
      make \
      mpc1 \
      mpc1-dev \
      mpfr \
      mpfr-dev \
      ninja \
      openssl \
      p7zip \
      patch \
      perl \
      py3-pip \
      python3 \
      ruby \
      unzip \
      wget \
      wine \
      xz \
      zlib \
      zlib-dev 

SHELL [ "/bin/bash", "-c" ]

RUN set -ex \
    \
    && mkdir -p \
      ${MY_MINGW}/bin \
      ${MY_MINGW}/include \
      ${MY_MINGW}/lib/pkgconfig \
      ${MY_MINGW}/lib64/pkgconfig

ENV LDFLAGS="-L${MY_MINGW}/lib -L${MY_MINGW}/lib64"
ENV PATH="${MY_MINGW}/bin:/usr/local/bin:${PATH}"
ENV PKG_CONFIG_PATH="${MY_MINGW}/lib/pkgconfig:${MY_MINGW}/lib64/pkgconfig"

ARG BINUTILS_VERSION=2.41
ENV MY_BINUTILS_VERSION=${BINUTILS_VERSION}
RUN set -ex \
    \
    && wget -q https://ftp.gnu.org/gnu/binutils/binutils-${MY_BINUTILS_VERSION}.tar.xz -O - | tar -xJ \
    && cd binutils-${MY_BINUTILS_VERSION} \
    && ./configure \
        --disable-lto \
        --disable-multilib \
        --disable-nls \
        --disable-plugins \
        --disable-shared \
        --disable-werror \
        --enable-static \
        --prefix=/usr/local \
        --target=${MY_MINGW_PREFIX} \
        --with-system-zlib \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r binutils-${MY_BINUTILS_VERSION}

ARG MINGW_VERSION=11.0.1
ENV MY_MINGW_VERSION=${MINGW_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/mingw-w64/mingw-w64/archive/refs/tags/v${MINGW_VERSION}.tar.gz -O - | tar -xz \
    && mkdir mingw-w64 \
    && cd mingw-w64 \
    && ../mingw-w64-${MY_MINGW_VERSION}/mingw-w64-headers/configure \
        --enable-sdk=all \
        --host=${MY_MINGW_PREFIX} \
        --prefix=/usr/local/${MY_MINGW_PREFIX} \
    && make install

ARG GCC_VERSION=13.2.0
ENV MY_GCC_VERSION=${GCC_VERSION}
RUN set -ex \
    \
    && wget -q https://ftp.gnu.org/gnu/gcc/gcc-${MY_GCC_VERSION}/gcc-${MY_GCC_VERSION}.tar.xz -O - | tar -xJ \
    && mkdir gcc \
    && cd gcc \
    && ../gcc-${MY_GCC_VERSION}/configure \
        --disable-libssp \
        --disable-libstdcxx-debug \
        --disable-libstdcxx-pch \
        --disable-multilib \
        --disable-nls \
        --disable-rpath \
        --disable-symvers \
        --disable-werror \
        --disable-win32-registry \
        --enable-checking=release \
        --enable-fully-dynamic-string \
        --enable-graphite \
        --enable-languages=c,c++ \
        --enable-libatomic \
        --enable-libgomp \
        --enable-libstdcxx-filesystem-ts \
        --enable-libstdcxx-time \
        --enable-lto \
        --enable-shared \
        --enable-static \
        --enable-threads=posix \
        --libexecdir=/usr/local/lib \
        --prefix=/usr/local \
        --target=${MY_MINGW_PREFIX} \
        --with-arch=nocona \
        --with-boot-ldflags="-static-libstdc++" \
        --with-gnu-as \
        --with-gnu-ld \
        --with-libiconv \
        --with-native-system-header-dir=/usr/local/include \
        --with-stage1-ldflags="-static-libstdc++" \
        --with-system-zlib \
        --with-tune=generic \
        --with-{gmp,mpfr,mpc,isl}=/usr/local \
    && make -j${MY_NUM_JOBS} all-gcc \
    && make install-gcc

RUN set -ex \
    \
    && cd mingw-w64 \
    && ../mingw-w64-${MY_MINGW_VERSION}/mingw-w64-crt/configure \
        --disable-lib32 \
        --enable-lib64 \
        --enable-wildcard \
        --host=${MY_MINGW_PREFIX} \
        --prefix=/usr/local/${MY_MINGW_PREFIX} \
    && (make || make || make || make) \
    && make install

RUN set -ex \
    \
    && cd mingw-w64 \
    && ../mingw-w64-${MY_MINGW_VERSION}/mingw-w64-libraries/winpthreads/configure \
        --enable-shared \
        --enable-static \
        --host=${MY_MINGW_PREFIX} \
        --prefix=/usr/local/${MY_MINGW_PREFIX} \
    && make -j${MY_NUM_JOBS} \
    && make install

RUN set -ex \
    \
    && cd gcc \
    && make -j${MY_NUM_JOBS} \
    && make install

RUN set -ex \
    \
    && cp /usr/local/${MY_MINGW_PREFIX}/lib/*.dll ${MY_MINGW}/bin \
    && cp /usr/local/${MY_MINGW_PREFIX}/bin/*.dll ${MY_MINGW}/bin \
    && rm -r gcc gcc-${MY_GCC_VERSION} \
    && rm -r mingw-w64 mingw-w64-${MY_MINGW_VERSION}

ARG PKG_CONFIG_VERSION=0.29.2
ENV MY_PKG_CONFIG_VERSION=${PKG_CONFIG_VERSION}
RUN set -ex \
    \
    && wget -q https://pkg-config.freedesktop.org/releases/pkg-config-${MY_PKG_CONFIG_VERSION}.tar.gz -O - | tar -xz \
    && cd pkg-config-${MY_PKG_CONFIG_VERSION} \
    && ./configure \
        --disable-nls \
        --disable-shared \
        --prefix=/usr/local \
        --with-internal-glib \
        --with-pc-path=${MINGW}/lib/pkgconfig \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r pkg-config-${MY_PKG_CONFIG_VERSION}

RUN python3 -m pip install --break-system-packages -U mako
RUN python3 -m pip install --break-system-packages -U meson
RUN python3 -m pip install --break-system-packages -U packaging

ARG ZLIB_VERSION=1.3.1
ENV MY_ZLIB_VERSION=${ZLIB_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/madler/zlib/releases/download/v${ZLIB_VERSION}/zlib-${ZLIB_VERSION}.tar.gz -O - | tar -xz \
    && cd zlib-${MY_ZLIB_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DBUILD_SHARED_LIBS=ON \
      -DBUILD_STATIC_LIBS=ON \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r zlib-${MY_ZLIB_VERSION}

ARG OPENSSL_VERSION=3.2.0
ENV MY_OPENSSL_VERSION=${OPENSSL_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/openssl/openssl/releases/download/openssl-${MY_OPENSSL_VERSION}/openssl-${MY_OPENSSL_VERSION}.tar.gz -O - | tar -xz \
    && cd openssl-${MY_OPENSSL_VERSION} \
    && ./Configure \
      --cross-compile-prefix=${MY_MINGW_PREFIX}- \
      --prefix=${MY_MINGW} \
      mingw64 \
      no-apps \
      no-docs \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r openssl-${MY_OPENSSL_VERSION}

ARG CURL_VERSION=8.5.0
ENV MY_CURL_VERSION=${CURL_VERSION}
RUN set -ex \
    \
    && wget -q https://curl.se/download/curl-${MY_CURL_VERSION}.tar.gz -O - | tar -xz \
    && cd curl-${MY_CURL_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DBUILD_CURL_EXE=ON \
      -DBUILD_SHARED_LIBS=ON \
      -DBUILD_STATIC_LIBS=ON \
      -DBUILD_TESTING=OFF \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
      -DCURL_CA_BUNDLE=./cacert.pem \
      -DCURL_CA_FALLBACK=ON \
      -DCURL_DISABLE_LDAP=ON \
      -DCURL_USE_LIBPSL=OFF \
      -DCURL_USE_LIBSSH2=OFF \
      -DCURL_USE_OPENSSL=ON \
      -DCURL_ZLIB=ON \
      -DENABLE_THREADED_RESOLVER=ON \
      -DOPENSSL_USE_STATIC_LIBS=ON \
      -DUSE_LIBIDN2=OFF \
      -DUSE_WIN32_CRYPTO=OFF \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r curl-${MY_CURL_VERSION}

ARG LIBPCRE2_VERSION=10.43-RC1
ENV MY_LIBPCRE2_VERSION=${LIBPCRE2_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/PCRE2Project/pcre2/releases/download/pcre2-${MY_LIBPCRE2_VERSION}/pcre2-${MY_LIBPCRE2_VERSION}.tar.gz -O - | tar -xz \
    && cd pcre2-${MY_LIBPCRE2_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DBUILD_SHARED_LIBS=ON \
      -DBUILD_STATIC_LIBS=ON \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
      -DPCRE2_BUILD_PCRE2_16=ON \
      -DPCRE2_SUPPORT_LIBBZ2=OFF \
      -DPCRE2_SUPPORT_LIBEDIT=OFF \
      -DPCRE2_SUPPORT_LIBZ=OFF \
      -DPCRE2_SUPPORT_UNICODE=ON \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r pcre2-${MY_LIBPCRE2_VERSION}

ARG EXPAT_VERSION=2.5.0
ENV MY_EXPAT_VERSION=${EXPAT_VERSION}
ARG EXPAT_VERSION2=2_5_0
ENV MY_EXPAT_VERSION2=${EXPAT_VERSION2}
RUN set -ex \
    \
    && wget -q https://github.com/libexpat/libexpat/releases/download/R_${MY_EXPAT_VERSION2}/expat-${MY_EXPAT_VERSION}.tar.gz -O - | tar -xz \
    && cd expat-${MY_EXPAT_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DBUILD_SHARED_LIBS=ON \
      -DBUILD_STATIC_LIBS=ON \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
      -DEXPAT_BUILD_DOCS=OFF \
      -DEXPAT_BUILD_EXAMPLES=OFF \
      -DEXPAT_BUILD_TESTS=OFF \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r expat-${MY_EXPAT_VERSION}

ARG LIBXML2_VERSION=2.12.4
ENV MY_LIBXML2_VERSION=${LIBXML2_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/GNOME/libxml2/archive/refs/tags/v${MY_LIBXML2_VERSION}.tar.gz -O - | tar -xz \
    && cd libxml2-${MY_LIBXML2_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DBUILD_SHARED_LIBS=ON \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
      -DLIBXML2_WITH_ICONV=OFF \
      -DLIBXML2_WITH_LZMA=OFF \
      -DLIBXML2_WITH_PYTHON=OFF \
      -DLIBXML2_WITH_TESTS=OFF \
      -DLIBXML2_WITH_ZLIB=OFF \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r libxml2-${MY_LIBXML2_VERSION}

ARG FREETYPE2_VERSION=2.13.2
ENV MY_FREETYPE2_VERSION=${FREETYPE2_VERSION}
RUN set -ex \
    \
    && wget -q https://download.savannah.gnu.org/releases/freetype/freetype-${MY_FREETYPE2_VERSION}.tar.gz -O - | tar -xz \
    && cd freetype-${MY_FREETYPE2_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r freetype-${MY_FREETYPE2_VERSION}

ARG FONTCONFIG_VERSION=2.15.0
ENV MY_FONTCONFIG_VERSION=${FONTCONFIG_VERSION}
RUN set -ex \
    \
    && wget -q https://gitlab.freedesktop.org/fontconfig/fontconfig/-/archive/${MY_FONTCONFIG_VERSION}/fontconfig-${MY_FONTCONFIG_VERSION}.tar.gz -O - | tar -xz \
    && cd fontconfig-${MY_FONTCONFIG_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Ddoc=disabled \
      -Dtests=disabled \
      -Dtools=disabled \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r fontconfig-${MY_FONTCONFIG_VERSION}

ARG OPENAL_VERSION=1.23.1
ENV MY_OPENAL_VERSION=${OPENAL_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/kcat/openal-soft/archive/refs/tags/${MY_OPENAL_VERSION}.tar.gz -O - | tar -xz \
    && cd openal-soft-${MY_OPENAL_VERSION} \
    && mkdir _build \
    && cd _build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && mv ${MY_MINGW}/bin/OpenAL32.dll ${MY_MINGW}/bin/openal32.dll \
    && cd ${MY_WORKDIR} \
    && rm -r openal-soft-${MY_OPENAL_VERSION}
   
ARG PIXMAN_VERSION=0.43.0
ENV MY_PIXMAN_VERSION=${PIXMAN_VERSION}
RUN set -ex \
    \
    && wget -q https://gitlab.freedesktop.org/pixman/pixman/-/archive/pixman-${MY_PIXMAN_VERSION}/pixman-pixman-${MY_PIXMAN_VERSION}.tar.gz -O - | tar -xz \
    && cd pixman-pixman-${MY_PIXMAN_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dtests=disabled \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r pixman-pixman-${MY_PIXMAN_VERSION}

ARG GLIB_VERSION=2.79.0
ENV MY_GLIB_VERSION=${GLIB_VERSION}
RUN set -ex \
    \
    && wget -q https://gitlab.gnome.org/GNOME/glib/-/archive/${MY_GLIB_VERSION}/glib-${MY_GLIB_VERSION}.tar.gz -O - | tar -xz \
    && cd glib-${MY_GLIB_VERSION} \
    && rmdir subprojects/gvdb \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Ddocumentation=false \
      -Dforce_posix_threads=true \
      -Dinstalled_tests=false \
      -Dintrospection=disabled \
      -Dman-pages=disabled \
      -Dtests=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r glib-${MY_GLIB_VERSION}

RUN set -ex \
    \
    && ln -sf  /usr/bin/glib-compile-resources /mingw64/bin/ \
    && ln -sf  /usr/bin/glib-compile-schemas /mingw64/bin/

ARG MESA_VERSION=23.3.3
ENV MY_MESA_VERSION=${MESA_VERSION}
RUN set -ex \
    \
    && wget -q https://gitlab.freedesktop.org/mesa/mesa/-/archive/mesa-${MY_MESA_VERSION}/mesa-mesa-${MY_MESA_VERSION}.tar.gz -O - | tar -xz \
    && cd mesa-mesa-${MY_MESA_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Degl=enabled \
      -Dgles1=enabled \
      -Dgles2=enabled \
      -Dopengl=true \
      -Dshared-glapi=true \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r mesa-mesa-${MY_MESA_VERSION}

ARG CAIRO_VERSION=1.18.0
ENV MY_CAIRO_VERSION=${CAIRO_VERSION}
RUN set -ex \
    \
    && wget -q https://gitlab.freedesktop.org/cairo/cairo/-/archive/1.18.0/cairo-${MY_CAIRO_VERSION}.tar.gz -O - | tar -xz \
    && cd cairo-${MY_CAIRO_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Ddwrite=enabled \
      -Dfontconfig=enabled \
      -Dfreetype=enabled \
      -Dglib=enabled \
      -Dgtk_doc=false \
      -Dpng=enabled \
      -Dquartz=disabled \
      -Dtee=disabled \
      -Dtests=disabled \
      -Dxlib-xcb=disabled \
      -Dxlib=disabled \
      -Dzlib=enabled \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r cairo-${MY_CAIRO_VERSION} 

ARG PANGO_VERSION=1.50.1
ENV MY_PANGO_VERSION=${PANGO_VERSION}
RUN set -ex \
    \
    && wget -q https://gitlab.gnome.org/GNOME/pango/-/archive/${MY_PANGO_VERSION}/pango-${MY_PANGO_VERSION}.tar.gz -O - | tar -xz \
    && cd pango-${MY_PANGO_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dcairo=enabled \
      -Dfontconfig=enabled \
      -Dfreetype=enabled \
      -Dgtk_doc=false \
      -Dharfbuzz:cairo=enabled \
      -Dharfbuzz:directwrite=enabled \
      -Dharfbuzz:freetype=enabled \
      -Dharfbuzz:gdi=enabled \
      -Dharfbuzz:glib=enabled \
      -Dharfbuzz:gobject=enabled \
      -Dharfbuzz:graphite2=disabled \
      -Dharfbuzz:introspection=disabled \
      -Dharfbuzz:tests=disabled \
      -Dinstall-tests=false \
      -Dxft=disabled \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r pango-${MY_PANGO_VERSION}

ARG ATK_VERSION=2.38.0
ENV MY_ATK_VERSION=${ATK_VERSION}
RUN set -ex \
    \
    && wget -q https://gitlab.gnome.org/GNOME/atk/-/archive/${MY_ATK_VERSION}/atk-${MY_ATK_VERSION}.tar.gz -O - | tar -xz \
    && cd atk-${MY_ATK_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Ddocs=false \
      -Dintrospection=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r atk-${MY_ATK_VERSION}

ARG LIBEPOXY_VERSION=1.5.10
ENV MY_LIBEPOXY_VERSION=${LIBEPOXY_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/anholt/libepoxy/archive/refs/tags/${MY_LIBEPOXY_VERSION}.tar.gz -O - | tar -xz \
    && cd libepoxy-${MY_LIBEPOXY_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Ddocs=false \
      -Dtests=false \
      -Dx11=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r libepoxy-${MY_LIBEPOXY_VERSION}

ARG GDK_PIXBUF_VERSION=2.42.10
ENV MY_GDK_PIXBUF_VERSION=${GDK_PIXBUF_VERSION}
RUN set -ex \
    \
    && wget -q https://gitlab.gnome.org/GNOME/gdk-pixbuf/-/archive/${MY_GDK_PIXBUF_VERSION}/gdk-pixbuf-${MY_GDK_PIXBUF_VERSION}.tar.gz -O - | tar -xz \
    && cd gdk-pixbuf-${MY_GDK_PIXBUF_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dbuiltin_loaders=all \
      -Ddocs=false \
      -Dgtk_doc=false \
      -Dinstalled_tests=false \
      -Dintrospection=disabled \
      -Dman=false \
      -Dtests=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r gdk-pixbuf-${MY_GDK_PIXBUF_VERSION}

ARG GTK3_VERSION=3.24.40
ENV MY_GTK3_VERSION=${GTK3_VERSION}
RUN set -ex \
    \
    && wget -q https://gitlab.gnome.org/GNOME/gtk/-/archive/${MY_GTK3_VERSION}/gtk-${MY_GTK3_VERSION}.tar.gz -O - | tar -xz \
    && cd gtk-${MY_GTK3_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dbroadway_backend=false \
      -Dbuiltin_immodules=all \
      -Ddemos=false \
      -Dexamples=false \
      -Dgtk_doc=false \
      -Dinstalled_tests=false \
      -Dintrospection=false \
      -Dman=false \
      -Dquartz_backend=false \
      -Dtests=false \
      -Dwayland_backend=false \
      -Dwin32_backend=true \
      -Dx11_backend=false \
      -Dxinerama=no \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r gtk-${MY_GTK3_VERSION}

ARG LIBSIGCPP_VERSION=2.12
ENV MY_LIBSIGCPP_VERSION=${LIBSIGCPP_VERSION}
ARG LIBSIGCPP_VERSION2=${LIBSIGCPP_VERSION}.1
ENV MY_LIBSIGCPP_VERSION2=${LIBSIGCPP_VERSION2}
RUN set -ex \
    \
    && wget -q "https://download.gnome.org/sources/libsigc++/${MY_LIBSIGCPP_VERSION}/libsigc%2B%2B-${MY_LIBSIGCPP_VERSION2}.tar.xz" -O - | tar -xJ \
    && cd libsigc++-${MY_LIBSIGCPP_VERSION2} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dbuild-documentation=false \
      -Dbuild-examples=false \
      -Dbuild-tests=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r libsigc++-${MY_LIBSIGCPP_VERSION2}

ARG GLIBMM_VERSION=2.66
ENV MY_GLIBMM_VERSION=${GLIBMM_VERSION}
ARG GLIBMM_VERSION2=${GLIBMM_VERSION}.6
ENV MY_GLIBMM_VERSION2=${GLIBMM_VERSION2}
RUN set -ex \
    \
    && wget -q https://download.gnome.org/sources/glibmm/${MY_GLIBMM_VERSION}/glibmm-${MY_GLIBMM_VERSION2}.tar.xz -O - | tar -xJ \
    && cd glibmm-${MY_GLIBMM_VERSION2} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dbuild-examples=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r glibmm-${MY_GLIBMM_VERSION2}

ARG CAIROMM_VERSION=1.14.5
ENV MY_CAIROMM_VERSION=${CAIROMM_VERSION}
RUN set -ex \
    \
    && wget -q https://www.cairographics.org/releases/cairomm-${MY_CAIROMM_VERSION}.tar.xz -O - | tar -xJ \
    && cd cairomm-${MY_CAIROMM_VERSION} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dbuild-documentation=false \
      -Dbuild-examples=false \
      -Dbuild-tests=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r cairomm-${MY_CAIROMM_VERSION}

ARG PANGOMM_VERSION=2.46
ENV MY_PANGOMM_VERSION=${PANGOMM_VERSION}
ARG PANGOMM_VERSION2=${PANGOMM_VERSION}.3
ENV MY_PANGOMM_VERSION2=${PANGOMM_VERSION2}
RUN set -ex \
    \
    && wget -q https://download.gnome.org/sources/pangomm/${MY_PANGOMM_VERSION}/pangomm-${MY_PANGOMM_VERSION2}.tar.xz -O - | tar -xJ \
    && cd pangomm-${MY_PANGOMM_VERSION2} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dbuild-documentation=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r pangomm-${MY_PANGOMM_VERSION2}

ARG ATKMM_VERSION=2.28
ENV MY_ATKMM_VERSION=${ATKMM_VERSION}
ARG ATKMM_VERSION2=${ATKMM_VERSION}.1
ENV MY_ATKMM_VERSION2=${ATKMM_VERSION2}
RUN set -ex \
    \
    && wget -q https://download.gnome.org/sources/atkmm/${MY_ATKMM_VERSION}/atkmm-${MY_ATKMM_VERSION2}.tar.xz -O - | tar -xJ \
    && cd atkmm-${MY_ATKMM_VERSION2} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dbuild-documentation=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r atkmm-${MY_ATKMM_VERSION2}

ARG GTKMM_VERSION=3.24
ENV MY_GTKMM_VERSION=${GTKMM_VERSION}
ARG GTKMM_VERSION2=${GTKMM_VERSION}.8
ENV MY_GTKMM_VERSION2=${GTKMM_VERSION2}
RUN set -ex \
    \
    && wget -q https://download.gnome.org/sources/gtkmm/${MY_GTKMM_VERSION}/gtkmm-${MY_GTKMM_VERSION2}.tar.xz -O - | tar -xJ \
    && cd gtkmm-${MY_GTKMM_VERSION2} \
    && meson setup \
      --cross-file ${MY_TOOLCHAIN_FILE_MESON} \
      --prefix=${MY_MINGW} \
      -Dbuild-demos=false \
      -Dbuild-documentation=false \
      -Dbuild-tests=false \
      _build \
    && meson compile \
      -C _build \
    && meson install \
      -C _build \
    && cd ${MY_WORKDIR} \
    && rm -r gtkmm-${MY_GTKMM_VERSION2}

ARG FMT_VERSION=10.2.1
ENV MY_FMT_VERSION=${FMT_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/fmtlib/fmt/archive/refs/tags/${MY_FMT_VERSION}.tar.gz -O - | tar -xz \
    && cd fmt-${MY_FMT_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
      -DBUILD_SHARED_LIBS=ON \
      -DBUILD_STATIC_LIBS=ON \
      -DFMT_DOC=OFF \
      -DFMT_TEST=OFF \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r fmt-${MY_FMT_VERSION}

ARG SPDLOG_VERSION=1.13.0
ENV MY_SPDLOG_VERSION=${SPDLOG_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/gabime/spdlog/archive/refs/tags/v${MY_SPDLOG_VERSION}.tar.gz -O - | tar -xz \
    && cd spdlog-${MY_SPDLOG_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
      -DSPDLOG_BUILD_EXAMPLE=OFF \
      -DSPDLOG_BUILD_SHARED=ON \
      -DSPDLOG_BUILD_STATIC=ON \
      -DSPDLOG_BUILD_TESTS=OFF \
      -DSPDLOG_FMT_EXTERNAL=ON \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r spdlog-${MY_SPDLOG_VERSION}

ARG OGG_VERSION=1.3.5
ENV MY_OGG_VERSION=${OGG_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/xiph/ogg/archive/refs/tags/v${MY_OGG_VERSION}.tar.gz -O - | tar -xz \
    && cd ogg-${MY_OGG_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DBUILD_SHARED_LIBS=ON \
      -DBUILD_STATIC_LIBS=ON \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r ogg-${MY_OGG_VERSION}

ARG VORBIS_VERSION=1.3.7
ENV MY_VORBIS_VERSION=${VORBIS_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/xiph/vorbis/archive/refs/tags/v${MY_VORBIS_VERSION}.tar.gz -O - | tar -xz \
    && cd vorbis-${MY_VORBIS_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DBUILD_SHARED_LIBS=OFF \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r vorbis-${MY_VORBIS_VERSION}

ARG FLAC_VERSION=1.4.3
ENV MY_FLAC_VERSION=${FLAC_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/xiph/flac/archive/refs/tags/${MY_FLAC_VERSION}.tar.gz -O - | tar -xz \
    && cd flac-${MY_FLAC_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DBUILD_SHARED_LIBS=ON \
      -DBUILD_STATIC_LIBS=ON \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
      -DINSTALL_MANPAGES=OFF \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r flac-${MY_FLAC_VERSION}

ARG SFML_VERSION=2.6.1
ENV MY_SFML_VERSION=${SFML_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/SFML/SFML/archive/refs/tags/${MY_SFML_VERSION}.tar.gz -O - | tar -xz \
    && cd SFML-${MY_SFML_VERSION} \
    && sed -i s/set_target_properties\(\$\{target\}\ PROPERTIES\ PREFIX\ \"\"\)// \
      cmake/Macros.cmake \
    && sed -i s/set_target_properties\(\$\{target\}\ PROPERTIES\ IMPORT_SUFFIX\ \"\.a\"\)// \
      cmake/Macros.cmake \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DBUILD_SHARED_LIBS=ON \
      -DBUILD_STATIC_LIBS=ON \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r SFML-${MY_SFML_VERSION}

ARG LIBSODIUM_VERSION=1.0.19
ENV MY_LIBSODIUM_VERSION=${LIBSODIUM_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/jedisct1/libsodium/archive/refs/tags/${MY_LIBSODIUM_VERSION}-RELEASE.tar.gz -O - | tar -xz \
    && cd libsodium-${MY_LIBSODIUM_VERSION}-RELEASE \
    && CFLAGS="-Ofast -fomit-frame-pointer -m64 -mtune=westmere" ./configure \
      --enable-shared \
      --enable-static \
      --host=${MY_MINGW_PREFIX} \
      --prefix=${MY_MINGW} \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r libsodium-${MY_LIBSODIUM_VERSION}-RELEASE

ARG BOOST_MAJOR_VERSION=1
ENV MY_BOOST_MAJOR_VERSION=${BOOST_MAJOR_VERSION}
ARG BOOST_MINOR_VERSION=84
ENV MY_BOOST_MINOR_VERSION=${BOOST_MINOR_VERSION}
ARG BOOST_PATCH_VERSION=0
ENV MY_BOOST_PATCH_VERSION=${BOOST_PATCH_VERSION}
ENV MY_BOOST_VERSION=${MY_BOOST_MAJOR_VERSION}.${MY_BOOST_MINOR_VERSION}.${MY_BOOST_PATCH_VERSION}
ENV MY_BOOST_VERSION2=${MY_BOOST_MAJOR_VERSION}_${MY_BOOST_MINOR_VERSION}_${MY_BOOST_PATCH_VERSION}
RUN set -ex \
    \
    && wget -q https://boostorg.jfrog.io/artifactory/main/release/${MY_BOOST_VERSION}/source/boost_${MY_BOOST_VERSION2}.tar.gz -O - | tar -xz \
    && cd boost_${MY_BOOST_VERSION2} \
    && echo "using gcc : gcc : ${MY_MINGW_PREFIX}-g++ ;" \
      >./user-config.jam \
    && ./bootstrap.sh \
      --prefix=${MY_MINGW} \
      --with-libraries=atomic,chrono,date_time,filesystem,random,regex,serialization,system,thread \
      address-model=64 \
      architecture=x86 \
      link=static,shared \
      target-os=windows \
      threading=multi \
      variant=release \
    && ./b2 \
      --prefix=${MY_MINGW} \
      --user-config=./user-config.jam \
      address-model=64 \
      architecture=x86 \
      link=static,shared \
      target-os=windows \
      threading=multi \
      variant=release \
      install \
    && cd ${MY_WORKDIR} \
    && rm -r boost_${MY_BOOST_VERSION2}

ARG WXWIDGETS_VERSION=3.2.4
ENV MY_WXWIDGETS_VERSION=${WXWIDGETS_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/wxWidgets/wxWidgets/releases/download/v${MY_WXWIDGETS_VERSION}/wxWidgets-${MY_WXWIDGETS_VERSION}.tar.bz2 -O - | tar -xj \
    && cd wxWidgets-${MY_WXWIDGETS_VERSION} \
    && mkdir _build \
    && cd _build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DCMAKE_BUILD_TYPE=Release \
      -DBUILD_SHARED_LIBS=ON \
      -DBUILD_STATIC_LIBS=ON \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
      -DwxBUILD_MONOLITHIC=ON \
      -DwxUSE_OPENGL=ON \
      -DwxUSE_UNICODE_UTF8=ON \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r wxWidgets-${MY_WXWIDGETS_VERSION} 

ARG GTEST_VERSION=1.14.0
ENV MY_GTEST_VERSION=${GTEST_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/google/googletest/archive/refs/tags/v${GTEST_VERSION}.tar.gz -O - | tar -xz \
    && cd googletest-${MY_GTEST_VERSION} \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DCMAKE_BUILD_TYPE=Release \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r googletest-${MY_GTEST_VERSION} 

ARG ROCKSDB_VERSION=8.10.0
ENV MY_ROCKSDB_VERSION=${ROCKSDB_VERSION}
RUN set -ex \
    \
    && wget -q https://github.com/facebook/rocksdb/archive/refs/tags/v${MY_ROCKSDB_VERSION}.tar.gz -O - | tar -xz \
    && cd rocksdb-${MY_ROCKSDB_VERSION} \
    && echo -e "add_definitions(-include cstdint)">>CMakeLists.txt \
    && mkdir build \
    && cd build \
    && cmake .. -DCMAKE_TOOLCHAIN_FILE=${MY_TOOLCHAIN_FILE_CMAKE} \
      -DCMAKE_BUILD_TYPE=Release \
      -DCMAKE_INSTALL_PREFIX=${MY_MINGW} \
      -DPORTABLE=ON \
      -DROCKSDB_INSTALL_ON_WINDOWS=ON \
      -DWITH_BENCHMARK_TOOLS=OFF \
      -DWITH_CORE_TOOLS=OFF \
      -DWITH_TESTS=OFF \
      -DWITH_TOOLS=OFF \
      -DWITH_ZLIB=ON \
    && make -j${MY_NUM_JOBS} \
    && make install \
    && cd ${MY_WORKDIR} \
    && rm -r rocksdb-${MY_ROCKSDB_VERSION} 

RUN set -ex \
    \
    && mv ${MY_MINGW}/lib/*.dll ${MY_MINGW}/bin \
    && mv ${MY_MINGW}/lib/gcc_x64_dll/*.dll ${MY_MINGW}/bin/ \
    && chmod 0777 -R ${MY_MINGW}