<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <?xml-stylesheet href="/s/inc/rss.xsl" type="text/xsl"?>
    <rss version="2.0"  xmlns:atom="http://www.w3.org/2005/Atom">
        <channel>
            <title>RSS feed for tag qmake on Raymii.org</title> 
            <link>https://raymii.org/s/tags/qmake.xml</link> 
            <description>RSS feed for tag qmake on Raymii.org</description>
            <atom:link href="https://raymii.org/s/tags/qmake.xml" rel="self" type="application/rss+xml" />
    
            <item>
                <title>Qt Property Macro (Q_PROPERTY with 95% less code)</title> 
                <link>https://raymii.org/s/blog/Qt_Property_Macro_Q_PROPERTY_with_95_percent_less_code.html?utm_medium=rss&amp;utm_source=raymii&amp;utm_campaign=tagrss</link> 
                <guid>https://raymii.org/s/blog/Qt_Property_Macro_Q_PROPERTY_with_95_percent_less_code.html</guid>
                <description>Adding [properties to QObject based classes](https://web.archive.org/web/20240529180113/https://doc.qt.io/qt-6/properties.html) is cumbersome. Although [the property system](https://web.archive.org/web/20240529180113/https://doc.qt.io/qt-6/properties.html) and [Signals and Slots](https://web.archive.org/web/20240529180002/https://doc.qt.io/qt-6/signalsandslots.html) are great to use, especially with QML, it takes a lot of boilerplate code to add such properties to a class, at least 15 to 20 lines for each property. I've cobbled up a macro that saves you about 95% of lines when using a `Q_PROPERTY`. (22 lines to 1 line).</description> 
                <pubDate>Wed, 29 May 2024 22:00:00 GMT</pubDate>
                <lastBuildDate>Wed, 29 May 2024 22:00:00 GMT</lastBuildDate>
            </item>
    
            <item>
                <title>A docker image for Qt 5.15 LTS for Android, including OpenSSL and the KDE patch collection</title> 
                <link>https://raymii.org/s/blog/Qt_5.15_LTS_Docker_Image_for_Android_with_OpenSSL.html?utm_medium=rss&amp;utm_source=raymii&amp;utm_campaign=tagrss</link> 
                <guid>https://raymii.org/s/blog/Qt_5.15_LTS_Docker_Image_for_Android_with_OpenSSL.html</guid>
                <description>Recently I got an email from Google regarding the API level of [Leaf Node Monitoring](https://leafnode.nl), my open source monitoring app for Windows, Linux and Android. The Play Store version must be updated to target API level 33.
For Windows and Linux I'm building the app automatically in a CI environment but the Android build was still a manual process. Until now, because after a bunch of messing around with Android NDK versions, OpenSSL library paths and Qt compile flags I can automatically build Leaf Node Monitoring in my CI.

I'm using Woodpecker CI and that requires every build step to be executed in a Docker image. There are a few Qt docker images floating around but they are all using the pre-built 5.15.2 version by extracting it from the Qt Online Installer. That version is quite old, 5.15.15 LTS was released [a few days ago for Commercial License Holders](http://web.archive.org/web/20230902132649/https://www.qt.io/blog/commercial-lts-qt-5.15.15-released) on August 31, so after 1 year it will become available as open source.
My docker image builds Qt from source using the `5.15 KDE Qt Patch Collection` branch for Android and it includes OpenSSL. This is as far as I know the most up to date docker image for Qt 5.15, currently at 5.15.10 LTS.</description> 
                <pubDate>Wed, 13 Sep 2023 22:00:00 GMT</pubDate>
                <lastBuildDate>Wed, 13 Sep 2023 22:00:00 GMT</lastBuildDate>
            </item>
    
            <item>
                <title>Johnnie 'QObject' Walker, replace a service locator pattern while you're at it</title> 
                <link>https://raymii.org/s/software/Johnnie_QObject_Walker_replace_a_servicelocator_pattern.html?utm_medium=rss&amp;utm_source=raymii&amp;utm_campaign=tagrss</link> 
                <guid>https://raymii.org/s/software/Johnnie_QObject_Walker_replace_a_servicelocator_pattern.html</guid>
                <description>I've seen many C++ code bases where there was the concept of a service locator. An global static object that anyone can query to get a class. This is handy with old legacy spiderweb intertwined code that gets everything from everywhere, but not so useful when you're trying to unit test code, it is not visible from the header what dependencies you need. My preference goes to dependency injection, give all the dependencies to the class' constructor and use them that way. Makes it easy to mock and if you have many dependencies, it serves as a starting point to refactor in to a more clearly separated architecture. This article shows a piece of code that uses QObject, the Qt object base class, to replace a servicelocator. All QObjects can have a parent QObject, thus a tree is formed, which you can walk back up and search. This effectively replaces the servicelocator, since you can just request a certain type of QObject.</description> 
                <pubDate>Sat, 14 Jan 2023 04:30:00 GMT</pubDate>
                <lastBuildDate>Sat, 14 Jan 2023 04:30:00 GMT</lastBuildDate>
            </item>
    
            <item>
                <title>Add moc includes to speed up Qt compilation</title> 
                <link>https://raymii.org/s/blog/Qt_add_moc_includes_to_speed_up_compilation.html?utm_medium=rss&amp;utm_source=raymii&amp;utm_campaign=tagrss</link> 
                <guid>https://raymii.org/s/blog/Qt_add_moc_includes_to_speed_up_compilation.html</guid>
                <description>The Meta-Object Compiler, `moc`, handles Qt's C++ extensions and it is required for signals and slots and properties in Qt. `moc` reads C++ header files and if the `Q_OBJECT` macro is used, it generates an extra `.cpp` file named `moc_filename.cpp` containing extra (meta-object) code. This post has a bit of background information and a shell script to automatically include `moc_*.cpp` files in your code whenever `Q_OBJECT` is used. If you use `qmake`, this will probably speed up your build and if you use `cmake`, this will probably speed up incremental builds (when `CMAKE_AUTOMOC` is `on`).</description> 
                <pubDate>Mon, 12 Dec 2022 00:00:00 GMT</pubDate>
                <lastBuildDate>Mon, 12 Dec 2022 00:00:00 GMT</lastBuildDate>
            </item>
    
            <item>
                <title>Embed the source code directly in your Qt app with qmake and qrc, for GPL compliance</title> 
                <link>https://raymii.org/s/articles/Embed_the_source_code_directly_in_your_Qt_app.html?utm_medium=rss&amp;utm_source=raymii&amp;utm_campaign=tagrss</link> 
                <guid>https://raymii.org/s/articles/Embed_the_source_code_directly_in_your_Qt_app.html</guid>
                <description>In my earlier [post on selling GPL software](/s/blog/Selling_GPL_Software_part_1_lots_of_hurdles.html) I outlined a few points that make it hard to sell GPL software. One of them is the availability of the source code. You could put it online but then everyone has access without paying. Other options like putting it behind a login or sending a link after purchase require extra systems and saving more user information, lots of extra hassle for me and the users.
One of my ideas for 'solving' this issue is by shipping the actual source code directly inside the application. This article shows you how to do that, by creating an archive of the current source code on every build with `qmake` and embedding that inside the application using `qrc`, including a button to save the archive locally to disk. It works on the desktop as well as Android, including the required permissions.</description> 
                <pubDate>Sat, 12 Feb 2022 00:00:00 GMT</pubDate>
                <lastBuildDate>Sat, 12 Feb 2022 00:00:00 GMT</lastBuildDate>
            </item>
    
        </channel>
    </rss>
    
    