Gtk apps on windows

Introduction

This article guides how to set up and write applications with GTK4 on the windows operating system.

GTK

GTK (formerly GIMP ToolKit then GTK+) is a free and open-source cross-platform widget toolkit for creating graphical user interfaces (GUIs).

[wikipedia] [Official Website]

Setup

meson setup -Dmedia-gstreamer=disabled -Dbuild-tests=disabled build
meson compile -C build
meson install -C build

MSYS2

MSYS2 is a collection of tools and libraries providing you with an easy-to-use environment for building, installing, and running native Windows software.

1. Install the latest version MSYS2 from their website.
2. Navigate to C:\msys2\ and launch mingw64.exe.
3. to update available repositories and packages, run:
   pacman -Syyu
4. install gtk4, gcc (llvm should work too!), pkg-config:
   pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-gtk4 mingw-w64-x86_64-pkg-config

Now add Mingw64 directories to System Path so that windows can find them:
add the following to the system path:

C:\\msys64\\mingw64\\include
C:\\msys64\\mingw64\\bin
C:\\msys64\\mingw64\\lib

Картинка с сайта: stdin.top

1. We also need to pass the output of pkg-config to gcc while compiling. firstly, open CMD and get the output of pkg-config --cflags --libs gtk4.

It will produce something like this:

-mfpmath=sse -msse -msse2 -pthread -mms-bitfields -IC:/msys64/mingw64/include/gtk-4.0 -IC:/msys64/mingw64/include -IC:/msys64/mingw64/include/pango-1.0 -IC:/msys64/mingw64/include/harfbuzz -IC:/msys64/mingw64/include/pango-1.0 -IC:/msys64/mingw64/include/fribidi -IC:/msys64/mingw64/include -IC:/msys64/mingw64/include/gdk-pixbuf-2.0 -IC:/msys64/mingw64/include/libpng16 -IC:/msys64/mingw64/include -IC:/msys64/mingw64/include/cairo -IC:/msys64/mingw64/include/lzo -IC:/msys64/mingw64/include -IC:/msys64/mingw64/include/freetype2 -IC:/msys64/mingw64/include/libpng16 -IC:/msys64/mingw64/include/harfbuzz -IC:/msys64/mingw64/include -IC:/msys64/mingw64/include/pixman-1 -IC:/msys64/mingw64/include -IC:/msys64/mingw64/include/graphene-1.0 -IC:/msys64/mingw64/lib/graphene-1.0/include -IC:/msys64/mingw64/include -IC:/msys64/mingw64/include/glib-2.0 -IC:/msys64/mingw64/lib/glib-2.0/include -IC:/msys64/mingw64/include -LC:/msys64/mingw64/lib -lgtk-4 -lpangowin32-1.0 -lpangocairo-1.0 -lpango-1.0 -lharfbuzz -lgdk_pixbuf-2.0 -lcairo-gobject -lcairo -lvulkan -lgraphene-1.0 -lgio-2.0 -lgobject-2.0 -lglib-2.0 -lintl

copy the output and add it as a System Variable (I saved it as GTK4-PKG-CONFIG):

Картинка с сайта: stdin.top

Visual Studio Code

I prefer Visual studio code for all my coding tasks. You can get the latest version of Visual studio code from their website.

1. Create a new folder and open it in VSCode.
2. create a new file .vscode/c_cpp_properties.json and put the following in it:

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}\\**",
                "C:\\msys64\\mingw64\\include\\**",
                "C:\\msys64\\mingw64\\lib\\glib-2.0\\include",
                "C:\\msys64\\mingw64\\lib\\graphene-1.0\\include"
            ]
        }
    ],
    "version": 4
}

notice the C:\msys64\mingw64\include\**, C:\msys64\mingw64\lib\glib-2.0\include and C:\msys64\mingw64\lib\graphene-1.0\include. these are the header files we need for auto complete suggestions which will make our life easier.

1. create a new file, hello_world.c file, and paste the Hello World C program from GTK.org:

// Include gtk
#include <gtk/gtk.h>

static void on_activate (GtkApplication *app) {
  // Create a new window
  GtkWidget *window = gtk_application_window_new (app);
  // Create a new button
  GtkWidget *button = gtk_button_new_with_label ("Hello, World!");
  // When the button is clicked, close the window passed as an argument
  g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_window_close), window);
  gtk_window_set_child (GTK_WINDOW (window), button);
  gtk_window_present (GTK_WINDOW (window));
}

int main (int argc, char *argv[]) {
  // Create a new application
  GtkApplication *app = gtk_application_new ("com.example.GtkApplication",
                                             G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (on_activate), NULL);
  return g_application_run (G_APPLICATION (app), argc, argv);
}

1. Compile the program:
   gcc hello_world.c -o hello_world.exe -mwindows %GTK4-PKG-CONFIG%
2. Run the program by clicking on generated .exe file.

Debugging

Setting up debugging enviroment is quite easy. Defaults should just work fine as long as you select the correct compiler when prompted, I’ve added -mwindows to compile flags for good measure.

.vscode/launch.json

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "gcc.exe - Build and debug active file",
            "type": "cppdbg",
            "request": "launch",
            "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "${fileDirname}",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "C:\\msys64\\mingw64\\bin\\gdb.exe",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "C/C++: gcc.exe build active file"
        }
    ]
}

.vscode/tasks.json

{
    "tasks": [
        {
            "type": "cppbuild",
            "label": "C/C++: gcc.exe build active file",
            "command": "C:\\msys64\\mingw64\\bin\\gcc.exe",
            "args": [
                "-g",
                "${file}",
                "-o",
                "${fileDirname}\\${fileBasenameNoExtension}.exe",
                "-mwindows",
                "%GTK4-PKG-CONFIG%"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "Task generated by Debugger."
        }
    ],
    "version": "2.0.0"
}

Add breakpoint wherever you wish and debug away!

Картинка с сайта: stdin.top

A bit complicated example…

Let’s make things a little complicated, suppose we want to make an application to show the current time using Win32 API, this is how it can be done:

#include <stdio.h>
#include <windows.h>
#include <gtk/gtk.h>


void get_current_time(GtkButton *btn, GtkLabel *label){

  SYSTEMTIME st, lt;
  printf("Button Clicked!\n");
    
  GetSystemTime(&st);
  GetLocalTime(&lt);

  char buf[1024];
  sprintf(buf, "%02d:%02d:%02d %d/%d/%d", st.wHour, st.wMinute, st.wSecond, st.wDay, st.wMonth, st.wYear);
  gtk_label_set_label(label, buf);
  
}

static void on_activate (GtkApplication *app) {
  // Create a new window
  GtkWidget *window = gtk_application_window_new (app);

  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);

  GtkWidget *label = gtk_label_new("Hello GTK!");
  GtkWidget *btn = gtk_button_new_with_label("Get Current Time");
  gtk_widget_set_margin_start(GTK_WIDGET(btn), 4);
  gtk_widget_set_margin_end(GTK_WIDGET(btn), 4);
  g_signal_connect_after(btn , "clicked", (GCallback)get_current_time, label);

  gtk_box_append(GTK_BOX(box), label);
  gtk_box_append(GTK_BOX(box), btn);

  gtk_window_set_child (GTK_WINDOW (window), box);
  gtk_window_present (GTK_WINDOW (window));
}

int main (int argc, char *argv[]) {
  // Create a new application
  GtkApplication *app = gtk_application_new ("com.example.GtkApplication",
                                             G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (on_activate), NULL);
  return g_application_run (G_APPLICATION (app), argc, argv);
}

Compile the program with:

gcc whatismytime.c -o whatismytime -mwindows %GTK4-PKG-CONFIG%

Картинка с сайта: stdin.top

Meson Build System

Available on Github.

Meson is the official build system used by GNOME. I’ve taken the above example and made it into a Meson Project.

tree
├── meson.build
├── README.md
└── src
    ├── meson.build
    └── whatismytime.c

1 directory, 4 files

meson uses ninja to build/compile. get the latest ninja from their Github page and add the extracted directory to System Path.

to build:

meson build
ninja -C build

and then navigate to build/src and execute whatismytime.exe

Exploring the compatibility of GTK apps on the Windows operating system has long been a topic of intrigue and discussion among tech enthusiasts. The question of whether these apps can seamlessly transition from the Linux environment to Windows has remained a mystery to many. In this article, we delve into the complexities of GTK app portability and the challenges that developers and users face in achieving optimal functionality on the Windows platform. By uncovering the intricacies of this compatibility issue, we aim to provide insights and solutions that can enhance the user experience and promote cross-platform usability of these applications.

Overview Of Gtk Applications

GTK (Gimp Toolkit) is a popular open-source cross-platform widget toolkit for creating graphical user interfaces. It is primarily used to develop applications with a graphical interface for the Linux operating system. GTK applications are known for their user-friendly and aesthetically pleasing design, making them a top choice for developers looking to create visually appealing software.

One of the key features of GTK applications is their customizable nature, allowing developers to create unique and interactive user interfaces. GTK provides a wide range of widgets and tools that aid in the development process, making it easier to design applications that are both functional and visually appealing.

While traditionally associated with Linux environments, GTK applications can indeed work on Windows systems with the right configurations and dependencies in place. By understanding how GTK applications function and leveraging compatibility tools, developers can ensure a seamless user experience for Windows users wanting to utilize GTK-based software.

Windows Compatibility Challenges

When it comes to running GTK apps on Windows, there are several compatibility challenges that users may encounter. One major hurdle is the differences in how GTK apps interact with the Windows operating system compared to their native environment. Since GTK is primarily developed for Unix-based systems, issues arise when trying to seamlessly transition these apps to Windows.

Another obstacle is the lack of standardized tools and support for running GTK apps on Windows. While there are workarounds available, they often require additional software or configurations that may not guarantee full compatibility. This can lead to performance issues, UI discrepancies, and overall instability when running GTK apps on a Windows platform.

Moreover, updates and version compatibility between GTK libraries and Windows can present ongoing challenges. Ensuring that the GTK libraries are compatible with the specific version of Windows being used is crucial for a smooth user experience. Navigating these compatibility challenges is essential for users looking to make GTK apps work seamlessly on Windows.

Tools For Gtk App Porting To Windows

When it comes to porting GTK apps to Windows, developers have several tools at their disposal to facilitate the process. One popular tool is MSYS2, which provides a POSIX compatibility layer that allows GTK applications to run on Windows seamlessly. By utilizing MSYS2, developers can easily compile and build GTK apps for the Windows platform without significant modifications to the codebase.

Another essential tool for GTK app porting to Windows is MSVC (Microsoft Visual C++). MSVC is a versatile compiler that supports a wide range of programming languages, including C and C++. Developers can use MSVC to build GTK applications for Windows, taking advantage of its robust features and optimizations for the Windows operating system. By leveraging these tools in combination with best practices for cross-platform development, developers can ensure that their GTK apps work seamlessly on Windows, providing users with a consistent and reliable experience across different platforms.

Customization And Integration Considerations

When customizing and integrating GTK apps on Windows, compatibility and consistency play key roles. Ensuring that the user interface elements align with Windows standards is essential for a seamless user experience. Developers need to consider adapting visual styles, icon sets, and fonts to match the native Windows environment, maintaining a cohesive look and feel throughout the application.

Furthermore, integration with Windows-specific features like taskbar behavior, file dialogs, notifications, and system tray icons is crucial. By harmonizing these aspects, GTK apps can function more cohesively within the Windows ecosystem, enhancing user acceptance and usability. Testing across different versions of Windows is also important to address any compatibility issues and refine the app’s performance on a variety of Windows platforms.

Overall, by meticulously addressing customization and integration considerations, developers can bridge the gap between GTK apps and the Windows operating system, offering users a more polished and intuitive software experience.

Testing And Debugging On Windows Platform

When testing and debugging GTK apps on the Windows platform, developers face unique challenges stemming from the differences in how GTK functions across operating systems. It is crucial to ensure that the app’s UI elements, interactions, and overall performance remain consistent and functional on Windows machines. Compatibility issues may arise due to the underlying system architecture, so thorough testing is essential to identify and address any glitches or errors.

Developers can utilize various tools and techniques to streamline the testing and debugging process on Windows. Emulators and virtual machines can help simulate different Windows environments for comprehensive compatibility checks. Leveraging debugging tools specific to Windows, such as Visual Studio Debugger, can aid in pinpointing and resolving issues more efficiently. Additionally, gathering feedback from Windows users during beta testing phases can provide valuable insights for further refining the app’s performance and user experience on the platform.

User Experience And Performance Implications

When it comes to user experience and performance implications of running GTK apps on Windows, there are several factors to consider. The primary concern often revolves around how well the GTK apps can integrate with the native Windows environment. While GTK apps may look and feel slightly different on Windows compared to their native Linux environment, developers have been working to bridge this gap and enhance user experience.

Performance implications also play a crucial role in determining the feasibility of running GTK apps on Windows. Factors such as system resources utilization, responsiveness, and overall speed can impact the user experience significantly. While GTK apps may not always perform as optimally on Windows as they do on Linux due to differences in underlying system architecture, advancements in compatibility layers and optimizations are continuously being made to improve performance.

Overall, the user experience and performance implications of running GTK apps on Windows are gradually improving as developers and the community work on enhancing compatibility and performance optimization. As technology continues to evolve and compatibility layers become more robust, the differences in user experience and performance between running GTK apps on Windows versus Linux are expected to diminish over time.

Case Studies Of Successful Gtk Apps On Windows

Case Studies of Successful GTK Apps on Windows offer real-life examples of the successful integration of GTK apps on the Windows platform. One such case study is GIMP, a popular open-source image editing software developed using GTK toolkit. GIMP has been optimized to seamlessly function on Windows, providing users with a consistent experience across different operating systems. Its success on Windows showcases the adaptability and robustness of GTK apps in diverse environments.

Another notable case study is Inkscape, a powerful vector graphics editor also built using GTK. Inkscape has been well-received by Windows users due to its intuitive interface and rich feature set. The smooth performance of Inkscape on the Windows platform demonstrates how GTK apps can maintain their functionality and performance on different operating systems. These case studies highlight the potential for GTK apps to thrive on Windows, opening up new possibilities for developers and users alike.

Future Prospects And Recommendations

Looking ahead, the seamless compatibility of GTK apps on Windows holds promising future prospects. As technology continues to advance, further enhancements and optimizations can be expected, potentially bridging the gap between different operating systems and promoting cross-platform application development.

To fully leverage the potential of GTK apps on Windows, it is recommended that developers focus on improving performance, responsiveness, and user experience. Collaborative efforts within the open-source community can facilitate the sharing of knowledge and best practices to streamline the development process and ensure compatibility across various platforms.

Ultimately, by embracing the interoperability of GTK apps on Windows and emphasizing continuous innovation and refinement, the landscape of software development stands to benefit from increased flexibility and opportunities for developers and users alike.

FAQ

What Is Gtk And How Does It Relate To Windows Compatibility?

GTK, or the GIMP Toolkit, is a cross-platform widget toolkit for creating graphical user interfaces. Developed originally for the GNU Image Manipulation Program (GIMP), GTK is widely used in many open-source projects to create desktop applications. In terms of Windows compatibility, GTK allows developers to write applications that can run on multiple operating systems, including Windows. By using GTK, developers can create applications that have a consistent look and feel across different platforms, making it easier to maintain and support their software on Windows systems.

Are There Any Limitations To Running Gtk Apps On Windows?

While GTK apps can run on Windows, there are some limitations to be aware of. One limitation is that not all GTK features and themes may work seamlessly on a Windows environment, which could impact the overall user experience. Additionally, certain GTK applications may require additional dependencies or configurations to run properly on Windows, which can lead to compatibility issues. However, with proper adjustments and support, GTK apps can still be used effectively on Windows systems.

What Steps Are Required To Make Gtk Apps Work Seamlessly On Windows?

To make GTK apps work seamlessly on Windows, developers need to ensure that the necessary GTK runtime environment is installed on the Windows system. This can be achieved by bundling the GTK runtime libraries with the application installer or directing users to download and install the GTK runtime separately. Additionally, developers should thoroughly test their GTK apps on Windows to ensure compatibility and address any platform-specific issues that may arise. By following these steps, GTK apps can provide a consistent and reliable user experience on the Windows operating system.

Can Gtk Themes Be Used When Running Gtk Apps On Windows?

GTK themes cannot be directly used when running GTK apps on Windows because Windows uses a different theming system. However, there are tools available that allow GTK apps on Windows to be themed to resemble GTK themes, such as the GTK+ for Windows project and various third-party utilities. These tools can help achieve a similar look and feel to GTK themes on Windows, although some customization options may be limited compared to running GTK apps on a Linux system.

Are There Any Performance Differences When Using Gtk Apps On Windows Compared To Other Platforms?

GTK apps may experience slight performance differences on Windows compared to other platforms due to the translation layer required to make them compatible with the Windows operating system. This can lead to a small decrease in performance, such as slower rendering speeds or higher resource usage. However, the impact on performance is typically minimal and may not be noticeable for everyday use. Overall, GTK apps should still function effectively on Windows, but users may experience some slight differences in performance compared to running them on native platforms.

The Bottom Line

In the quest for cross-platform compatibility, the feasibility of GTK apps seamlessly functioning on Windows has been a topic of intrigue and debate. As this discussion unfolded, it became evident that with the right tools and configurations, GTK applications can indeed operate effectively on the Windows platform. Through thorough exploration and experimentation, developers have uncovered methods to bridge the gap between these two environments, providing users with a cohesive experience irrespective of their operating system.

Embracing the potential convergence of GTK apps on Windows marks a significant stride towards enhancing user accessibility and software versatility. By leveraging the strengths of both platforms and fostering greater collaboration within the development community, the barriers to cross-platform utilization can be dismantled, opening up new opportunities for innovation and accessibility in the realm of software applications.

# Background

Since developing SQL client tool Kangaroo, I met the major trouble is how to deploy Kangaroo app to user, then searched all of solutions from internet, finally, I found a great article GTK+3 Installation Tutorial for Windows (opens new window), it provides clear guide to deploy GTK based app, so the honor belongs to the author of article.

# Precondition

The app must be compiled and executed in environment: MSYS2 (opens new window)

# Solution

# Prepare app directory structure

To deploy GTK based app, the app must follow the directory structure like linux:

# Copy dependent libraries of app

List of GTK dependencies
GTK depends on several libraries:

• GLib
• cairo
• Pango
• ATK
• gdk-pixbuf

To run GTK programs you will also need:

• gettext-runtime
• fontconfig
• freetype
• expat
• libpng
• zlib

How to get the file list and copy them to target dir?

the solution is a series of linux commands combination like this:

Done the commands above is all right? No!!!

Some components in the GTK framework have plugins like gdk-pixbuf / libgda, so we must use the commands to copy them one by one.

# Copy app resource file

• /etc

  • /gtk-3.0/settings.ini : applications-wide settings.
  • *: miscellaneous files.

• /lib

  • /gdk-pixbuf-2.0 : GDK-Pixbuf modules. SVG support.
  • /gtk-3.0 : GTK+-IM modules.
  • /pango : Pango modules.
  • *: import libraries, headers, pkg-config files… only needed for development.

• /share

  • /doc : license and copyleft.
  • /gtk-3.0 : resource files for gtk3-demo program.
  • /gtk-doc : documentation in HTML format.
  • /icons : icon themes, used by gtk3-demo and gtk3-widget-factory.
  • /locale : localization files. Internationalized text support.
  • /themes : graphical themes.
  • *: miscellaneous files.

# Compare the runtime dependency view

Execute the app under user environment and the app under dev environment in full function mode, compare the runtime dependency view, check the count of dll file and dll file name. make sure they are the same.

Runtime dependency dll view tool Process Explorer (opens new window)

# Full source code

Last Updated: 2023-10-17T03:57:42.000Z