RSS Advisory Board

Jump to navigation

Sorry

This feed does not validate.

• line 176, column 82: XML parsing error: <unknown>:176:82: not well-formed (invalid token) [help]

  ...  - Create GUI Applications with Python & Qt, Released &#8212;</title>
                                               ^

In addition, interoperability with the widest range of feed readers could be improved by implementing the following recommendations.

• line 8, column 91: Self reference doesn't match document location [help]

  ...  rel="self" type="application/rss+xml"/>
                                               ^

• line 50, column 102: title should not contain HTML: – [help]

  ... &amp;#8211; The Complete Guide with demo</title>
                                               ^

• line 107, column 14: title should not be blank [help]

        <title/>
                ^

Source: http://planet.qt-project.org/rss20.xml

1. <?xml version="1.0"?>
2. <rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:atom="http://www.w3.org/2005/Atom">
3.  <channel>
4.    <title>Planet Qt</title>
5.    <link>http://planet.qt.io</link>
6.    <language>en</language>
7.    <description>"Planet Qt - http://planet.qt.io/"</description>
8.    <atom:link href="http://planet.qt.io/rss20.xml" rel="self" type="application/rss+xml"/>
9.    <item>
10.      <guid isPermaLink="false">https://www.qt.io/blog/qt-for-android-automotive-6.8.4</guid>
11.      <title>The Qt Company Blog: Qt for Android Automotive 6.8.4</title>
12.      <pubDate>Wed, 16 Jul 2025 03:00:00 GMT</pubDate>
13.      <link>https://www.qt.io/blog/qt-for-android-automotive-6.8.4</link>
14.      <description>&lt;div class="hs-featured-image-wrapper"&gt;
15.      <a class="hs-featured-image-link" href="https://www.qt.io/blog/qt-for-android-automotive-6.8.4?hsLang=en" title=""><img alt="Qt for Android Automotive 6.8.4" class="hs-featured-image" src="https://www.qt.io/hubfs/Screenshot%202025-07-08%20at%2015-11-42%20cluster-web-04%20%281%29.webp%20%28WEBP%20Image%201360%20%C3%97%201088%20pixels%29.png" style="width: auto !important; float: left; margin: 0 15px 15px 0;"></a>
16.    </div>
17.    <p>
18.      The latest patch release for Android Automotive 6.8.4 is just released. This release is based on <a href="https://www.qt.io/blog/commercial-lts-qt-6.8.4-released?hsLang=en">Qt LTS 6.8.4</a> with 1200 <span>bug fixes, security updates, and other improvements done to Qt base</span>. There are no additional Qt for Android Automotive features delivered with 6.8.4.
19.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Fqt-for-android-automotive-6.8.4&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
20.    </item>
21.    <item>
22.      <guid isPermaLink="false">https://www.qt.io/blog/commercial-lts-qt-6.8.4-released</guid>
23.      <title>The Qt Company Blog: Commercial LTS Qt 6.8.4 Released</title>
24.      <pubDate>Fri, 11 Jul 2025 12:59:38 GMT</pubDate>
25.      <link>https://www.qt.io/blog/commercial-lts-qt-6.8.4-released</link>
26.      <description>&lt;div class="hs-featured-image-wrapper"&gt;
27.      <a class="hs-featured-image-link" href="https://www.qt.io/blog/commercial-lts-qt-6.8.4-released?hsLang=en" title=""><img alt="Commercial LTS Qt 6.8.4 Released" class="hs-featured-image" src="https://www.qt.io/hubfs/_website/Qt_8M0A6557_overlay.jpg" style="width: auto !important; float: left; margin: 0 15px 15px 0;"></a>
28.    </div>
29.    <p>
30.      We have released Qt 6.8.4 LTS for commercial license holders today. This is the first LTS Commercial release on the Qt 6.8 series. As a patch release, Qt 6.8.4 does not add any new functionality but provides bug fixes and other improvements.
31.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Fcommercial-lts-qt-6.8.4-released&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
32.    </item>
33.    <item>
34.      <guid isPermaLink="false">https://www.qt.io/blog/security-advisory-recently-reported-denial-of-service-issue-in-qcolortransfergenericfunction-impacts-qt</guid>
35.      <title>The Qt Company Blog: Security advisory: Recently reported denial of service issue in QColorTransferGenericFunction impacts Qt</title>
36.      <pubDate>Fri, 11 Jul 2025 09:00:00 GMT</pubDate>
37.      <link>https://www.qt.io/blog/security-advisory-recently-reported-denial-of-service-issue-in-qcolortransfergenericfunction-impacts-qt</link>
38.      <description>&lt;p&gt;
39.      When passing values outside of the expected range to QColorTransferGenericFunction it can cause a denial of service, for example, this can happen when passing a specifically crafted ICC profile to QColorSpace::fromICCProfile.
40.    </p>
41.    <p>
42.      This has been assigned the CVE id CVE-2025-5992.
43.    </p><br>
44.    <p>
45.       
46.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Fsecurity-advisory-recently-reported-denial-of-service-issue-in-qcolortransfergenericfunction-impacts-qt&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
47.    </item>
48.    <item>
49.      <guid isPermaLink="false">https://scythe-studio.com/en/blog/how-to-use-qt-webassembly-the-complete-guide-with-demo</guid>
50.      <title>Scythe Studio Qt Blog: How to use Qt WebAssembly &amp;#8211; The Complete Guide with demo</title>
51.      <pubDate>Thu, 10 Jul 2025 15:38:15 GMT</pubDate>
52.      <link>https://scythe-studio.com/en/blog/how-to-use-qt-webassembly-the-complete-guide-with-demo</link>
53.      <description>&lt;p&gt;
54.      Hey, welcome back to another blog post. Today we’re going to talk about the new Qt WebAssembly. This post will […]
55.    &lt;/p&gt;</description>
56.    </item>
57.    <item>
58.      <guid isPermaLink="false">https://www.qt.io/blog/get-better-qml-code-completions-with-codellama-13b-qml-and-7b-qml-v2.0</guid>
59.      <title>The Qt Company Blog: Get Better QML Code Completions with CodeLlama 13B-QML and 7B-QML v3</title>
60.      <pubDate>Thu, 10 Jul 2025 11:40:10 GMT</pubDate>
61.      <link>https://www.qt.io/blog/get-better-qml-code-completions-with-codellama-13b-qml-and-7b-qml-v2.0</link>
62.      <description>&lt;div class="hs-featured-image-wrapper"&gt;
63.      <a class="hs-featured-image-link" href="https://www.qt.io/blog/get-better-qml-code-completions-with-codellama-13b-qml-and-7b-qml-v2.0?hsLang=en" title=""><img alt="Get Better QML Code Completions with CodeLlama 13B-QML and 7B-QML v3" class="hs-featured-image" src="https://www.qt.io/hubfs/CodeCompletionRectangularShadowClip-converted.gif" style="width: auto !important; float: left; margin: 0 15px 15px 0;"></a>
64.    </div>
65.    <p>
66.      <span>Today, we released updated versions of the fine-tuned CodeLlama 13B-QML and 7B -QML models.</span> <span>The updated versions include the first skills to complete code for Qt Quick enhancements in Qt 6.9 and Qt 6.10.</span>
67.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Fget-better-qml-code-completions-with-codellama-13b-qml-and-7b-qml-v2.0&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
68.    </item>
69.    <item>
70.      <guid isPermaLink="false">https://www.qt.io/blog/testing-qt-quick-for-android-applications-with-squish</guid>
71.      <title>The Qt Company Blog: Testing Qt Quick for Android applications with Squish</title>
72.      <pubDate>Fri, 04 Jul 2025 11:02:46 GMT</pubDate>
73.      <link>https://www.qt.io/blog/testing-qt-quick-for-android-applications-with-squish</link>
74.      <description>&lt;div class="hs-featured-image-wrapper"&gt;
75.      <a class="hs-featured-image-link" href="https://www.qt.io/blog/testing-qt-quick-for-android-applications-with-squish?hsLang=en" title=""><img alt="Testing Qt Quick for Android applications with Squish" class="hs-featured-image" src="https://www.qt.io/hubfs/AI-Generated%20Media/Images/Automated%20Android%20testing-3.jpeg" style="width: auto !important; float: left; margin: 0 15px 15px 0;"></a>
76.    </div>
77.    <p>
78.      <span>In previous blog posts (</span><a href="https://www.qt.io/blog/qt-quick-in-android-as-a-view?hsLang=en"><span>here</span></a><span>,</span> <a href="https://www.qt.io/blog/qt-tools-for-android-studio?hsLang=en"><span>here</span></a> <span>and</span> <a href="https://www.qt.io/blog/qt-for-android-a-novel-approach?hsLang=en"><span>here</span></a><span>), we’ve talked about embedding QML components into native Android apps – a concept we call </span><a href="https://doc.qt.io/qt-6/qtquick-for-android.html"><span>Qt Quick for Android</span></a><span>. It provides an easy way to spice up your Android application with Qt or even write the whole UI in QML without leaving the warm, cuddly comfort of Android Studio and the Android build system.</span> <span>In this blog post we'll take a look at how you can leverage Qt Quality Assurance tools to test the apps you create with this technology.</span>
79.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Ftesting-qt-quick-for-android-applications-with-squish&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
80.    </item>
81.    <item>
82.      <guid isPermaLink="false">https://www.qt.io/blog/how-to-reach-cra-compliance</guid>
83.      <title>The Qt Company Blog: How to Reach CRA Compliance</title>
84.      <pubDate>Thu, 03 Jul 2025 09:55:01 GMT</pubDate>
85.      <link>https://www.qt.io/blog/how-to-reach-cra-compliance</link>
86.      <description>&lt;div class="hs-featured-image-wrapper"&gt;
87.      <a class="hs-featured-image-link" href="https://www.qt.io/blog/how-to-reach-cra-compliance?hsLang=en" title=""><img alt="How to Reach CRA Compliance" class="hs-featured-image" src="https://www.qt.io/hubfs/CRA%20Compliance%20Interview%20with%20Maurice%20Kalinowski.webp" style="width: auto !important; float: left; margin: 0 15px 15px 0;"></a>
88.    </div>
89.    <p style="font-size: 18px;">
90.      As the deadlines for the <a href="https://www.qt.io/cyber-resilience-act?hsLang=en">EU Cyber Resilience Act (CRA)</a> are fast approaching, reaching CRA compliance is turning cybersecurity an essential theme for many. Already strictly regulated industries, such as medical or automotive, have shown how regulation can foster creating secure solutions. Now with the CRA, a similar level of security is about to be required from a broader number of product manufacturers.
91.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Fhow-to-reach-cra-compliance&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
92.    </item>
93.    <item>
94.      <guid isPermaLink="false">https://www.qt.io/blog/qt-extension-1.6.0-for-vs-code-released</guid>
95.      <title>The Qt Company Blog: Qt Extension 1.6.0 for VS Code released</title>
96.      <pubDate>Thu, 03 Jul 2025 07:37:04 GMT</pubDate>
97.      <link>https://www.qt.io/blog/qt-extension-1.6.0-for-vs-code-released</link>
98.      <description>&lt;div class="hs-featured-image-wrapper"&gt;
99.      <a class="hs-featured-image-link" href="https://www.qt.io/blog/qt-extension-1.6.0-for-vs-code-released?hsLang=en" title=""><img alt="Screenshot of Visual Studio Code on the extensions page with one of the Qt extensions selected." class="hs-featured-image" src="https://www.qt.io/hubfs/vscodeext-installation.webp" style="width: auto !important; float: left; margin: 0 15px 15px 0;"></a>
100.    </div>
101.    <p>
102.      <span>We’re happy to announce the official release of <span style="font-weight: normal;">version 1.6.0</span> of the <span style="font-weight: normal;">Qt Extension for Visual Studio Code</span>! After spending some time as pre-release <span style="font-weight: normal;">1.5.0</span> in the Marketplace, it’s now graduated to a full release. Let's have a look at what's new!</span>
103.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Fqt-extension-1.6.0-for-vs-code-released&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
104.    </item>
105.    <item>
106.      <guid isPermaLink="false">https://www.qt.io/blog/qtgrpc-tips-tricks-sweet-spots</guid>
107.      <title/>
108.      <pubDate>Mon, 30 Jun 2025 09:42:39 GMT</pubDate>
109.      <link>https://www.qt.io/blog/qtgrpc-tips-tricks-sweet-spots</link>
110.      <description>&lt;div class="hs-featured-image-wrapper"&gt;
111.      <a class="hs-featured-image-link" href="https://www.qt.io/blog/qtgrpc-tips-tricks-sweet-spots?hsLang=en" title=""><img alt="QtGrpc - Tips, Tricks & Sweet Spots" class="hs-featured-image" src="https://www.qt.io/hubfs/togrpc_or_not_to.png" style="width: auto !important; float: left; margin: 0 15px 15px 0;"></a>
112.    </div>
113.    <p>
114.      Since Qt 6.8, the <a href="https://doc.qt.io/qt-6/qtgrpc-index.html">Qt GRPC</a> and <a href="https://doc.qt.io/qt-6/qtprotobuf-index.html" style="font-weight: normal;">Qt Protobuf</a> modules have officially moved out of technical preview and are now fully supported parts of the Qt framework. In this blog post, we’ll take a look at what’s changed, where things are headed, and what we’ve learned along the way—from performance benchmarks to hidden gems worth knowing about.
115.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Fqtgrpc-tips-tricks-sweet-spots&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
116.    </item>
117.    <item>
118.      <guid isPermaLink="false">https://www.qt.io/blog/security-advisory-recently-reported-incomplete-cleanup-issue-in-qts-schannel-handling-can-impact-qt</guid>
119.      <title>The Qt Company Blog: Security advisory: Recently reported incomplete cleanup issue in Qt's Schannel handling can impact Qt</title>
120.      <pubDate>Mon, 30 Jun 2025 09:00:00 GMT</pubDate>
121.      <link>https://www.qt.io/blog/security-advisory-recently-reported-incomplete-cleanup-issue-in-qts-schannel-handling-can-impact-qt</link>
122.      <description>&lt;p&gt;
123.      There is a "Incomplete Cleanup" problem in Qt’s Schannel handling when it is used to provide a server handling incoming TLS connections. 
124.    </p>
125.    <p>
126.      This has been assigned the CVE id CVE-2025-6338.
127.    </p><br>
128.    <p>
129.       
130.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Fsecurity-advisory-recently-reported-incomplete-cleanup-issue-in-qts-schannel-handling-can-impact-qt&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
131.    </item>
132.    <item>
133.      <guid isPermaLink="false">https://www.qt.io/blog/why-cyber-resilience-requires-a-cultural-shift</guid>
134.      <title>The Qt Company Blog: Why Cyber Resilience Requires a Cultural Shift</title>
135.      <pubDate>Thu, 26 Jun 2025 07:04:24 GMT</pubDate>
136.      <link>https://www.qt.io/blog/why-cyber-resilience-requires-a-cultural-shift</link>
137.      <description>&lt;div class="hs-featured-image-wrapper"&gt;
138.      <a class="hs-featured-image-link" href="https://www.qt.io/blog/why-cyber-resilience-requires-a-cultural-shift?hsLang=en" title=""><img alt="Why Cyber Resilience Requires a Cultural Shift" class="hs-featured-image" src="https://www.qt.io/hubfs/Oyku-Isik-CyberResilience-QtWS2025-tinified.webp" style="width: auto !important; float: left; margin: 0 15px 15px 0;"></a>
139.    </div>
140.    <p style="font-size: 18px;">
141.      The countdown to the European Union’s <a href="https://www.qt.io/cyber-resilience-act?hsLang=en">Cyber Resilience Act (CRA)</a> is underway. The new regulation lays out an extensive set of cybersecurity requirements throughout the lifecycle of products with digital elements (PDEs) sold in the EU market. This brings about a need for a fundamental shift for organizations from cyber security to cyber resilience.
142.    &lt;/p&gt;&lt;img alt="" height="1" src="https://track.hubspot.com/__ptq.gif?a=149513&amp;k=14&amp;r=https%3A%2F%2Fwww.qt.io%2Fblog%2Fwhy-cyber-resilience-requires-a-cultural-shift&amp;bu=https%253A%252F%252Fwww.qt.io%252Fblog&amp;bvt=rss" width="1"&gt;</description>
143.    </item>
144.    <item>
145.      <guid isPermaLink="false">https://www.basyskom.de/?p=12122</guid>
146.      <title>Qt &#x2013; basysKom GmbH: Pitfalls in PySide6</title>
147.      <pubDate>Mon, 23 Jun 2025 08:56:31 GMT</pubDate>
148.      <link>https://www.basyskom.de/pitfalls-in-pyside6/</link>
149.      <description>&lt;p&gt;
150.      <a href="https://www.basyskom.de/pitfalls-in-pyside6/"><img align="left" alt="Pitfalls in PySide6" height="160" src="https://www.basyskom.de/wp-content/uploads/2025/06/Qtforpython.png" style="margin: 0 20px 20px 0;" width="224"></a>
151.    </p>
152.    <p>
153.      PySide6 is easy to use and powerful but there’s a few pitfalls to look out for. We’ll investigate a performance issue in a large data model, find out that function calls are expensive, and that some of Qt’s C++ APIs had to be adapted to work in a Python environment.
154.    </p>
155.    <p>
156.      <a href="https://www.basyskom.de/pitfalls-in-pyside6/" rel="nofollow">Continue reading Pitfalls in PySide6 at basysKom GmbH.</a>
157.    &lt;/p&gt;</description>
158.    </item>
159.    <item>
160.      <guid isPermaLink="false">https://www.basyskom.de/?p=12064</guid>
161.      <title>Qt &#x2013; basysKom GmbH: Improved Black Box Testing with Cucumber-CPP</title>
162.      <pubDate>Fri, 13 Jun 2025 09:11:03 GMT</pubDate>
163.      <link>https://www.basyskom.de/improved-black-box-testing-with-cucumber-cpp/</link>
164.      <description>&lt;p&gt;
165.      <a href="https://www.basyskom.de/improved-black-box-testing-with-cucumber-cpp/"><img align="left" alt="Improved Black Box Testing with Cucumber-CPP" height="300" src="https://www.basyskom.de/wp-content/uploads/2025/06/cucumber-logo.svg" style="margin: 0 20px 20px 0;" width="300"></a>
166.    </p>
167.    <p>
168.      Learn how to use Cucumber-CPP and Gherkin to implement better black box tests for a C++ library. We developed a case-study based on Qt OPC UA.
169.    </p>
170.    <p>
171.      <a href="https://www.basyskom.de/improved-black-box-testing-with-cucumber-cpp/" rel="nofollow">Continue reading Improved Black Box Testing with Cucumber-CPP at basysKom GmbH.</a>
172.    &lt;/p&gt;</description>
173.    </item>
174.    <item>
175.      <guid isPermaLink="false">tag:www.pythonguis.com,2025-06-11:/blog/pyqt6-pyside6-books-updated-2025/</guid>
176.      <title>Python GUIs - qt: 6th Edition - Create GUI Applications with Python & Qt, Released &#8212;</title>
177.      <pubDate>Wed, 11 Jun 2025 08:00:00 GMT</pubDate>
178.      <link>https://www.pythonguis.com/blog/pyqt6-pyside6-books-updated-2025/</link>
179.      <description/>
180.    </item>
181.    <item>
182.      <guid isPermaLink="false">https://scythe-studio.com/en/blog/modbus-protocol-and-qt-integration-for-embedded-systems</guid>
183.      <title>Scythe Studio Qt Blog: Modbus Protocol and Qt Integration for Embedded Systems</title>
184.      <pubDate>Tue, 10 Jun 2025 13:41:13 GMT</pubDate>
185.      <link>https://scythe-studio.com/en/blog/modbus-protocol-and-qt-integration-for-embedded-systems</link>
186.      <description>&lt;p&gt;
187.      Technical managers in the embedded space often face a classic challenge: integrating industrial communication protocols into modern applications. One such […]
188.    &lt;/p&gt;</description>
189.    </item>
190.    <item>
191.      <guid isPermaLink="false">https://www.basyskom.de/?page_id=11922</guid>
192.      <title>Qt &#x2013; basysKom GmbH: Interactive Plots with PySide6</title>
193.      <pubDate>Wed, 28 May 2025 09:25:12 GMT</pubDate>
194.      <link>https://www.basyskom.de/interactive-plots-with-pyside6/</link>
195.      <description>&lt;p&gt;
196.      <a href="https://www.basyskom.de/interactive-plots-with-pyside6/"><img align="left" alt="Interactive Plots with PySide6" height="150" src="https://www.basyskom.de/wp-content/uploads/2020/07/Qt_logo_space-01-01-300x150.png" style="margin: 0 20px 20px 0;" width="300"></a>
197.    </p>
198.    <p>
199.      Nowadays it is getting more and more popular to write Qt applications in Python using a binding module like PySide6. One reason for this is probably Python's rich data science ecosystem which makes it a breeze to load and visualize complex datasets. In this article we focus (although not exclusively) on the widespread plotting library Matplotlib: We demonstrate how you can embed it in PySide applications and how you can customize the default look and feel to your needs. We round off the article with an outlook into Python plotting libaries beyond Matplotlib and their significance for Qt.
200.    </p>
201.    <p>
202.      <a href="https://www.basyskom.de/interactive-plots-with-pyside6/" rel="nofollow">Continue reading Interactive Plots with PySide6 at basysKom GmbH.</a>
203.    &lt;/p&gt;</description>
204.    </item>
205.    <item>
206.      <guid isPermaLink="false">https://www.basyskom.de/?p=11858</guid>
207.      <title>Qt &#x2013; basysKom GmbH: Modern TableView in QML: What&#x2019;s New in Qt 6.8 and Beyond</title>
208.      <pubDate>Thu, 08 May 2025 08:02:20 GMT</pubDate>
209.      <link>https://www.basyskom.de/modern-tableview-in-qml-whats-new-in-qt-6-8-and-beyond/</link>
210.      <description>&lt;p&gt;
211.      <a href="https://www.basyskom.de/modern-tableview-in-qml-whats-new-in-qt-6-8-and-beyond/"><img align="left" alt="Modern TableView in QML: What’s New in Qt 6.8 and Beyond" height="150" src="https://www.basyskom.de/wp-content/uploads/2020/07/Qt_logo_space-01-01-300x150.png" style="margin: 0 20px 20px 0;" width="300"></a>
212.    </p>
213.    <p>
214.      Over the years, the capabilities of QtQuick's TableView have evolved dramatically-from early custom implementations to well supported feature in Qt 6.8 and newer. In this article we explore the progression of QtQuick/QML's TableView, outline the limitations of early versions, and highlight newer features such as custom selection modes, header synchronization, and lightweight editing delegates. Check it out.
215.    </p>
216.    <p>
217.      <a href="https://www.basyskom.de/modern-tableview-in-qml-whats-new-in-qt-6-8-and-beyond/" rel="nofollow">Continue reading Modern TableView in QML: What’s New in Qt 6.8 and Beyond at basysKom GmbH.</a>
218.    &lt;/p&gt;</description>
219.    </item>
220.    <item>
221.      <guid isPermaLink="false">https://scythe-studio.com/en/blog/how-to-ensure-high-cyber-security-in-qt-apps</guid>
222.      <title>Scythe Studio Qt Blog: How to Ensure High Cyber-security in Qt apps?</title>
223.      <pubDate>Mon, 05 May 2025 15:33:45 GMT</pubDate>
224.      <link>https://scythe-studio.com/en/blog/how-to-ensure-high-cyber-security-in-qt-apps</link>
225.      <description>&lt;p&gt;
226.      Qt is a powerful tool and framework for building modern cross-platform applications. From embedded devices to desktop software, Qt enables […]
227.    &lt;/p&gt;</description>
228.    </item>
229.    <item>
230.      <guid isPermaLink="false">https://scythe-studio.com/en/blog/what-is-qt-framework-and-how-to-create-gui-with-it</guid>
231.      <title>Scythe Studio Qt Blog: What is Qt framework and how to use it for GUI development?</title>
232.      <pubDate>Fri, 25 Apr 2025 13:15:23 GMT</pubDate>
233.      <link>https://scythe-studio.com/en/blog/what-is-qt-framework-and-how-to-create-gui-with-it</link>
234.      <description>&lt;p&gt;
235.      We cover Qt-related issues on our blog, but only recently realized that many of our readers may not even know […]
236.    &lt;/p&gt;</description>
237.    </item>
238.    <item>
239.      <guid isPermaLink="false">https://scythe-studio.com/en/blog/how-to-use-qt-and-qml-with-visual-studio-code-and-wsl</guid>
240.      <title>Scythe Studio Qt Blog: How to use Qt and QML with Visual Studio Code and WSL?</title>
241.      <pubDate>Fri, 18 Apr 2025 15:04:30 GMT</pubDate>
242.      <link>https://scythe-studio.com/en/blog/how-to-use-qt-and-qml-with-visual-studio-code-and-wsl</link>
243.      <description>&lt;p&gt;
244.      Qt and QML provide a powerful framework for developing modern, cross-platform applications with a sleek and responsive UI. While Qt […]
245.    &lt;/p&gt;</description>
246.    </item>
247.    <item>
248.      <guid isPermaLink="false">tag:www.pythonguis.com,2025-04-03:/examples/pyside6-desktop-sticky-notes/</guid>
249.      <title>Python GUIs - qt: Build a Desktop Sticky Notes Application with PySide6 & SQLAlchemy &#8212; Create moveable desktop reminders with Python</title>
250.      <pubDate>Thu, 03 Apr 2025 12:01:00 GMT</pubDate>
251.      <link>https://www.pythonguis.com/examples/pyside6-desktop-sticky-notes/</link>
252.      <description>&lt;p&gt;
253.      Do you ever find yourself needing to take a quick note of some information but have nowhere to put it? Then this app is for you! This virtual sticky notes (or Post-it notes) app allows you to keep short text notes quickly from anywhere via the system tray. Create a new note, paste what you need in. It'll stay there until you delete it.
254.    </p>
255.    <p>
256.      The application is written in PySide6 and the notes are implemented as decoration-less windows, that is windows without any controls. Notes can be dragged around the desktop and edited at will. Text in the notes and note positions are stored in a SQLite database, via SQLAlchemy, with note details and positions being restored on each session.
257.    </p>
258.    <p class="admonition admonition-note">
259.      This is quite a complicated example, but we'll be walking through it slowly step by step. The <a href="https://www.pythonguis.com/d/sticky-notes-pyside6.zip">full source code</a> is available, with working examples at each stage of the development if you get stuck.
260.    </p>
261.    <div class="toc">
262.      <span class="toctitle">Table of Contents</span>
263.      <ul>
264.        <li>
265.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#setting-up-the-working-environment">Setting Up the Working Environment</a>
266.        </li>
267.        <li>
268.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#building-the-notes-gui">Building the Notes GUI</a>
269.        </li>
270.        <li>
271.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#styling-our-notes">Styling our notes</a>
272.        </li>
273.        <li>
274.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#remove-window-decorations">Remove Window Decorations</a>
275.        </li>
276.        <li>
277.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#movable-notes">Movable notes</a>
278.        </li>
279.        <li>
280.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#multiple-notes">Multiple notes</a>
281.        </li>
282.        <li>
283.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#adding-notes-to-the-tray">Adding Notes to the Tray</a>
284.        </li>
285.        <li>
286.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#adding-a-menu">Adding a Menu</a>
287.        </li>
288.        <li>
289.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#setting-up-the-notes-database">Setting up the Notes database</a>
290.        </li>
291.        <li>
292.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#integrating-the-data-model-into-our-ui">Integrating the Data Model into our UI</a>
293.        </li>
294.        <li>
295.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#starting-up">Starting up</a>
296.        </li>
297.        <li>
298.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#conclusion">Conclusion</a>
299.        </li>
300.      </ul>
301.    </div>
302.    <h2 id="setting-up-the-working-environment">
303.      Setting Up the Working Environment
304.    </h2>
305.    <p>
306.      In this tutorial, we'll use the PySide6 library to build the note app's GUI. We'll assume that you have a basic understanding of PySide6 apps.
307.    </p>
308.    <p class="admonition admonition-info">
309.      To learn the basics of PySide6, check out the complete &lt;a href="https://www.pythonguis.com/pyside6-tutorial/"&gt;PySide6 Tutorials&lt;/a&gt; or my book &lt;a href="https://www.pythonguis.com/pyside6-book/"&gt;Create GUI Applications with Python & PySide6</a>
310.    </p>
311.    <p>
312.      To store the notes between sessions, we will use <a href="https://www.sqlalchemy.org/"><code>SQLAlchemy</code></a> with a SQLite database (a file). Don't worry if you're not familiar with SQLAlchemy, we won't be going deep into that topic & have working examples you can copy.
313.    </p>
314.    <p>
315.      With that in mind, let's create a <a href="https://www.pythonguis.com/tutorials/python-virtual-environments/">virtual environment</a> and install our requirements into it. To do this, you can run the following commands:
316.    </p>
317.    <div class="tabbed-area multicode">
318.      <ul class="tabs">
319.        <li class="tab-link current">macOS
320.        </li>
321.        <li class="tab-link">Windows
322.        </li>
323.        <li class="tab-link">Linux
324.        </li>
325.      </ul>
326.      <div class="tab-content current code-block-outer" id="bff18f077dd14488aeaf24276846a792">
327.        <div class="code-block">
328.          <span class="code-block-language code-block-sh">sh</span>
329.          <pre><code class="sh">$ mkdir notes/
330. $ cd notes
331. $ python -m venv venv
332. $ source venv/bin/activate
333. (venv)$ pip install pyside6 sqlalchemy
334. </code></pre>
335.        </div>
336.      </div>
337.      <div class="tab-content code-block-outer" id="d7a8ec492304480c902622dcfeefd5d3">
338.        <div class="code-block">
339.          <span class="code-block-language code-block-cmd">cmd</span>
340.          <pre><code class="cmd">&gt; mkdir notes/
341. > cd notes
342. > python -m venv venv
343. > venv\Scripts\activate.bat
344. (venv)> pip install pyside6 sqlalchemy
345. </code></pre>
346.        </div>
347.      </div>
348.      <div class="tab-content code-block-outer" id="c56b1323795a4d5ea1e7c8022a849378">
349.        <div class="code-block">
350.          <span class="code-block-language code-block-sh">sh</span>
351.          <pre><code class="sh">$ mkdir notes/
352. $ cd notes
353. $ python -m venv venv
354. $ source venv/bin/activate
355. (venv)$ pip install pyside6 sqlalchemy
356. </code></pre>
357.        </div>
358.      </div>
359.    </div>
360.    <p>
361.      With these commands, you create a <code>notes/</code> folder for storing your project. Inside that folder, you create a new virtual environment, activate it, and install <a href="https://pypi.org/project/PySide6/">PySide6</a> and <a href="https://pypi.org/project/SQLAlchemy/">SQLAlchemy</a> from PyPi.
362.    </p>
363.    <p class="admonition admonition-info">
364.      For platform-specific troublshooting, check the <a href="https://www.pythonguis.com/tutorials/python-virtual-environments/">Working With Python Virtual Environments</a> tutorial.
365.    </p>
366.    <h2 id="building-the-notes-gui">
367.      Building the Notes GUI
368.    </h2>
369.    <p>
370.      Let's start by building a simple notes UI where we can create, move and close notes on the desktop. We'll deal with persistance later.
371.    </p>
372.    <p>
373.      The UI for our desktop sticky notes will be <em>a bit strange</em> since there is no central window, all the windows are independent yet look identical (aside from the contents). We also need the app to remain open in the background, using the system tray or toolbar, so we can show/hide the notes again without closing and re-opening the application each time.
374.    </p>
375.    <p>
376.      We'll start by defining a single note, and then deal with these other issues later. Create a new file named <code>notes.py</code> and add the following outline application to it.
377.    </p>
378.    <div class="code-block">
379.      <span class="code-block-language code-block-python">python</span>
380.      <pre><code class="python">import sys
381.  
382. from PySide6.QtWidgets import QApplication, QTextEdit, QVBoxLayout, QWidget
383.  
384. app = QApplication(sys.argv)
385.  
386.  
387. class NoteWindow(QWidget):
388.    def __init__(self):
389.        super().__init__()
390.        layout = QVBoxLayout()
391.        self.text = QTextEdit()
392.        layout.addWidget(self.text)
393.        self.setLayout(layout)
394.  
395.  
396. note = NoteWindow()
397. note.show()
398. app.exec()
399. </code></pre>
400.    </div>
401.    <p>
402.      In this code we first create a Qt <code>QApplication</code> instance. This needs to be done before creating our widgets. Next we define a simple custom window class <code>NoteWindow</code> by subclassing <code>QWidget</code>. We add a vertical layout to the window, and enter a single <code>QTextEdit</code> widget. We then create an instance of this window object as <code>note</code> and show it by calling <code>.show()</code>. This puts the window on the desktop. Finally, we start up our application by calling <code>app.exec()</code>.
403.    </p>
404.    <p>
405.      You can run this file like any other Pythons script.
406.    </p>
407.    <div class="code-block">
408.      <span class="code-block-language code-block-sh">sh</span>
409.      <pre><code class="sh">python notes.py
410. </code></pre>
411.    </div>
412.    <p>
413.      When the applicaton launches you'll see the following on your desktop.
414.    </p>
415.    <p>
416.      <img alt="Our editable "note" on the desktop" height="533" src="https://www.pythonguis.com/static/examples/qt/desktop-notes/notes-window.png" width="730"> <em>Simple "notes" window on the desktop</em>
417.    </p>
418.    <p>
419.      If you click in the text editor in the middle, you can enter some text.
420.    </p>
421.    <p>
422.      <em>Technically</em> this is a note, but we can do better.
423.    </p>
424.    <h2 id="styling-our-notes">
425.      Styling our notes
426.    </h2>
427.    <p>
428.      Our note doesn't look anything like a sticky note yet. Let's change that by applying some simple styles to it.
429.    </p>
430.    <p>
431.      Firstly we can change the colors of the window, textarea and text. In Qt there are multiple ways to do this -- for example, we could override the system palette definition for the window. However, the simplest approach is to use QSS, which is Qt's version of CSS.
432.    </p>
433.    <div class="code-block">
434.      <span class="code-block-language code-block-python">python</span>
435.      <pre><code class="python">import sys
436.  
437. from PySide6.QtWidgets import QApplication, QTextEdit, QVBoxLayout, QWidget
438.  
439. app = QApplication(sys.argv)
440.  
441.  
442. class NoteWindow(QWidget):
443.    def __init__(self):
444.        super().__init__()
445.        self.setStyleSheet(
446.            "background: #FFFF99; color: #62622f; border: 0; font-size: 16pt;"
447.        )
448.        layout = QVBoxLayout()
449.        self.text = QTextEdit()
450.        layout.addWidget(self.text)
451.        self.setLayout(layout)
452.  
453.  
454. note = NoteWindow()
455. note.show()
456. app.exec()
457. </code></pre>
458.    </div>
459.    <p>
460.      In the code above we have set a background color of hex <code>#ffff99</code> for our note window, and set the text color to hex <code>#62622f</code> a sort of muddy brown. The <code>border:0</code> removes the frame from the text edit, which otherwise would appear as a line on the bottom of the window. Finally, we set the font size to 16 points, to make the notes easier to read.
461.    </p>
462.    <p>
463.      If you run the code now you'll see this, much more notely note.
464.    </p>
465.    <p>
466.      <img alt="The note with our QSS styles applied" height="541" src="https://www.pythonguis.com/static/examples/qt/desktop-notes/notes-styled.png" width="791"> <em>The note with the QSS styling applied</em>
467.    </p>
468.    <h2 id="remove-window-decorations">
469.      Remove Window Decorations
470.    </h2>
471.    <p>
472.      The last thing breaking the illusion of a sticky note on the desktop is the window decorations -- the titlebar and window controls. We can remove these using Qt <em>window flags</em>. We can also use a window flag to make the notes appear on top of other windows. Later we'll handle hiding and showing the notes via a tray application.
473.    </p>
474.    <div class="code-block">
475.      <span class="code-block-language code-block-python">python</span>
476.      <pre><code class="python">import sys
477.  
478. from PySide6.QtCore import Qt
479. from PySide6.QtWidgets import (
480.    QApplication,
481.    QTextEdit,
482.    QVBoxLayout,
483.    QWidget,
484. )
485.  
486. app = QApplication(sys.argv)
487.  
488.  
489. class NoteWindow(QWidget):
490.    def __init__(self):
491.        super().__init__()
492.        self.setWindowFlags(
493.            self.windowFlags()
494.            | Qt.WindowType.FramelessWindowHint
495.            | Qt.WindowType.WindowStaysOnTopHint
496.        )
497.        self.setStyleSheet(
498.            "background: #FFFF99; color: #62622f; border: 0; font-size: 16pt;"
499.        )
500.        layout = QVBoxLayout()
501.  
502.        self.text = QTextEdit()
503.        layout.addWidget(self.text)
504.        self.setLayout(layout)
505.  
506.  
507. note = NoteWindow()
508. note.show()
509. app.exec()
510. </code></pre>
511.    </div>
512.    <p>
513.      To set window flags, we need to import the Qt flags from the <code>QtCore</code> namespace. Then you can set flags on the window using <code>.setWindowFlags()</code>. Note that since windows have flags already set, and we don't want to replace them all, we get the current flags with <code>.windowFlags()</code> and then add the additional flags to it using boolean OR <code>|</code>. We've added two flags here -- <code>Qt.WindowType.FramelessWindowHint</code> which removes the window decorations, and <code>Qt.WindowType.WindowStaysOnTopHint</code> which keeps the windows on top.
514.    </p>
515.    <p>
516.      Run this and you'll see a window with the decorations removed.
517.    </p>
518.    <p>
519.      <img alt="Note with the window decorations removed" height="462" src="https://www.pythonguis.com/static/examples/qt/desktop-notes/notes-nodecoration.png" width="781"> <em>Note with the window decorations removed</em>
520.    </p>
521.    <p class="admonition admonition-tip">
522.      With the window decorations removed you no longer have access to the close button. But you can still close the window using Alt-F4 (Windows) or the application menu (macOS).
523.    </p>
524.    <p>
525.      While you can close the window, it'd be nicer if there was a button to do it. We can add a custom button using <code>QPushButton</code> and hook this up to the window's <code>.close()</code> method to re-implement this.
526.    </p>
527.    <div class="code-block">
528.      <span class="code-block-language code-block-python">python</span>
529.      <pre><code class="python">import sys
530.  
531. from PySide6.QtCore import Qt
532. from PySide6.QtWidgets import (
533.    QApplication,
534.    QHBoxLayout,
535.    QPushButton,
536.    QTextEdit,
537.    QVBoxLayout,
538.    QWidget,
539. )
540.  
541. app = QApplication(sys.argv)
542.  
543.  
544. class NoteWindow(QWidget):
545.    def __init__(self):
546.        super().__init__()
547.        self.setWindowFlags(
548.            self.windowFlags()
549.            | Qt.WindowType.FramelessWindowHint
550.            | Qt.WindowType.WindowStaysOnTopHint
551.        )
552.        self.setStyleSheet(
553.            "background: #FFFF99; color: #62622f; border: 0; font-size: 16pt;"
554.        )
555.        layout = QVBoxLayout()
556.        # layout.setSpacing(0)
557.  
558.        buttons = QHBoxLayout()
559.        self.close_btn = QPushButton("×")
560.        self.close_btn.setStyleSheet(
561.            "font-weight: bold; font-size: 25px; width: 25px; height: 25px;"
562.        )
563.        self.close_btn.setCursor(Qt.CursorShape.PointingHandCursor)
564.        self.close_btn.clicked.connect(self.close)
565.        buttons.addStretch()  # Add stretch on left to push button right.
566.        buttons.addWidget(self.close_btn)
567.        layout.addLayout(buttons)
568.  
569.        self.text = QTextEdit()
570.        layout.addWidget(self.text)
571.        self.setLayout(layout)
572.  
573.  
574. note = NoteWindow()
575. note.show()
576. app.exec()
577. </code></pre>
578.    </div>
579.    <p>
580.      Our close button is created using <code>QPushButton</code> with a unicode multiplication symbol (an x) as the label. We set a stylesheet on this button to size the label and button. Then we set a custom cursor on the button to make it clearer that this is a clickable <em>thing</em> that performs an action. Finally, we connect the <code>.clicked</code> signal of the button to the window's close method <code>self.close</code>. The button will close the window.
581.    </p>
582.    <p class="admonition admonition-note">
583.      Later we'll use this button to delete notes.
584.    </p>
585.    <p>
586.      To add the close button to the top right of the window, we create a horizontal layout with <code>QHBoxLayout</code>. We first add a stretch, then the push button. This has the effect of pushing the button to the right. Finally, we add our buttons layout to the main layout of the note, before the text edit. This puts it at the top of the window.
587.    </p>
588.    <p>
589.      Run the code now and our note is complete!
590.    </p>
591.    <p>
592.      <img alt="The complete note UI with close button" height="503" src="https://www.pythonguis.com/static/examples/qt/desktop-notes/notes-complete.png" width="888"> <em>The complete note UI with close button</em>
593.    </p>
594.    <h2 id="movable-notes">
595.      Movable notes
596.    </h2>
597.    <p>
598.      The note <em>looks</em> like a sticky note now, but we can't move it around and there is only one (unless we run the application multiple times concurrently). We'll fix both of those next, starting with the moveability of the notes.
599.    </p>
600.    <p>
601.      This is fairly straightforward to achieve in PySide because Qt makes the raw mouse events available on all widgets. To implement moving, we can intercept these events and update the position of the window based on the distance the mouse has moved.
602.    </p>
603.    <p>
604.      To implement this, add the following two methods to the bottom of the <code>NoteWindow</code> class.
605.    </p>
606.    <div class="code-block">
607.      <span class="code-block-language code-block-python">python</span>
608.      <pre><code class="python">class NoteWindow(QWidget):
609.    # ... existing code skipped
610.  
611.    def mousePressEvent(self, e):
612.        self.previous_pos = e.globalPosition()
613.  
614.    def mouseMoveEvent(self, e):
615.        delta = e.globalPosition() - self.previous_pos
616.        self.move(self.x() + delta.x(), self.y() + delta.y())
617.        self.previous_pos = e.globalPosition()
618. </code></pre>
619.    </div>
620.    <p>
621.      Clicking and dragging a window involves three actions: the mouse press, the mouse move and the mouse release. We have defined two methods here <code>mousePressEvent</code> and <code>mouseMoveEvent</code>. In <code>mousePressEvent</code> we receive the initial press of the mouse and store the position where the click occurred. This method is only called on the initial press of the mouse when starting to drag the window.
622.    </p>
623.    <p>
624.      The <code>mouseMoveEvent</code> is called on every <em>subsequent</em> move while the mouse button <em>remains</em> pressed. On each move we take the new mouse position and subtract the previous position to get the <em>delta</em> -- that is, the change in mouse position from the initial press to the current event. Then we <em>move</em> the window by that amount, storing the new previous position after the move.
625.    </p>
626.    <p>
627.      The effect of this is that ever time the <code>mouseMoveEvent</code> method is called, the window moves by the amount that the mouse has moved since the last call. The window moves -- or is dragged -- by the mouse.
628.    </p>
629.    <h2 id="multiple-notes">
630.      Multiple notes
631.    </h2>
632.    <p>
633.      The note looks like a note, it is now moveable, but there is still only a single note -- not hugely useful! Let's fix that now.
634.    </p>
635.    <p>
636.      Currently we're creating the <code>NoteWindow</code> when the application starts up, just before we call <code>app.exec()</code>. If we create new notes while the application is running it will need to happen in a function or method, which is triggered somehow. This introduces a new problem, since we need to have some way to store the <code>NoteWindow</code> objects so they aren't automatically deleted (and the window closed) when the function or method exits.
637.    </p>
638.    <p class="admonition admonition-note">
639.      Python automatically deletes objects when they fall out of scope if there aren't any remaining references to them.
640.    </p>
641.    <p>
642.      We can solve this by storing the <code>NoteWindow</code> objects somewhere. Usually we'd do this on our main window, but in this app there is no main window. There are a few options here, but in this case we're going to use a simple dictionary.
643.    </p>
644.    <div class="code-block">
645.      <span class="code-block-language code-block-python">python</span>
646.      <pre><code class="python">import sys
647.  
648. from PySide6.QtCore import Qt
649. from PySide6.QtWidgets import (
650.    QApplication,
651.    QHBoxLayout,
652.    QPushButton,
653.    QTextEdit,
654.    QVBoxLayout,
655.    QWidget,
656. )
657.  
658. app = QApplication(sys.argv)
659.  
660. # Store references to the NoteWindow objects in this, keyed by id.
661. active_notewindows = {}
662.  
663.  
664. class NoteWindow(QWidget):
665.    def __init__(self):
666.        super().__init__()
667.        self.setWindowFlags(
668.            self.windowFlags()
669.            | Qt.WindowType.FramelessWindowHint
670.            | Qt.WindowType.WindowStaysOnTopHint
671.        )
672.        self.setStyleSheet(
673.            "background: #FFFF99; color: #62622f; border: 0; font-size: 16pt;"
674.        )
675.        layout = QVBoxLayout()
676.  
677.        buttons = QHBoxLayout()
678.        self.close_btn = QPushButton("×")
679.        self.close_btn.setStyleSheet(
680.            "font-weight: bold; font-size: 25px; width: 25px; height: 25px;"
681.        )
682.        self.close_btn.clicked.connect(self.close)
683.        self.close_btn.setCursor(Qt.CursorShape.PointingHandCursor)
684.        buttons.addStretch()  # Add stretch on left to push button right.
685.        buttons.addWidget(self.close_btn)
686.        layout.addLayout(buttons)
687.  
688.        self.text = QTextEdit()
689.        layout.addWidget(self.text)
690.        self.setLayout(layout)
691.  
692.        # Store a reference to this note in the
693.        active_notewindows[id(self)] = self
694.  
695.    def mousePressEvent(self, e):
696.        self.previous_pos = e.globalPosition()
697.  
698.    def mouseMoveEvent(self, e):
699.        delta = e.globalPosition() - self.previous_pos
700.        self.move(self.x() + delta.x(), self.y() + delta.y())
701.        self.previous_pos = e.globalPosition()
702.  
703.  
704. def create_notewindow():
705.    note = NoteWindow()
706.    note.show()
707.  
708.  
709. create_notewindow()
710. create_notewindow()
711. create_notewindow()
712. create_notewindow()
713. app.exec()
714.  
715. </code></pre>
716.    </div>
717.    <p>
718.      In this code we've added our <code>active_notewindows</code> dictionary. This holds references to our <code>NoteWindow</code> objects, keyed by <code>id()</code>. Note that this is Python's internal id for this object, so it is consistent and unique. We can use this same id to remove the note. We add each note to this dictionary at the bottom of it's <code>__init__</code> method.
719.    </p>
720.    <p>
721.      Next we've implemented a <code>create_notewindow()</code> function which creates an instance of <code>NoteWindow</code> and shows it, just as before. Nothing else is needed, since the note itself handles storing it's references on creation.
722.    </p>
723.    <p>
724.      Finally, we've added multiple calls to <code>create_notewindow()</code> to create multiple notes.
725.    </p>
726.    <p>
727.      <img alt="Multiple notes on the desktop" height="881" src="https://www.pythonguis.com/static/examples/qt/desktop-notes/notes-multiple.png" width="1282"> <em>Multiple notes on the desktop</em>
728.    </p>
729.    <h2 id="adding-notes-to-the-tray">
730.      Adding Notes to the Tray
731.    </h2>
732.    <p>
733.      We can now create multiple notes programatically, but we want to be able to do this from the UI. We could implement this behavior on the notes themselves, but then it wouldn't work if al the notes had been closed or hidden. Instead, we'll create a tray application -- this will show in the system tray on Windows, or on the macOS toolbar. Users can use this to create new notes, and quit the application.
734.    </p>
735.    <p>
736.      There's quite a lot to this, so we'll step through it in stages.
737.    </p>
738.    <p>
739.      Update the code, adding the imports shown at the top, and the rest following the definition of <code>create_notewindow</code>.
740.    </p>
741.    <div class="code-block">
742.      <span class="code-block-language code-block-python">python</span>
743.      <pre><code class="python">import sys
744.  
745. from PySide6.QtCore import Qt
746. from PySide6.QtGui import QIcon
747. from PySide6.QtWidgets import (
748.    QApplication,
749.    QHBoxLayout,
750.    QPushButton,
751.    QSystemTrayIcon,
752.    QTextEdit,
753.    QVBoxLayout,
754.    QWidget,
755. )
756.  
757. # ... code hidden up to create_notewindow() definition
758.  
759. create_notewindow()
760.  
761. # Create system tray icon
762. icon = QIcon("sticky-note.png")
763.  
764. # Create the tray
765. tray = QSystemTrayIcon()
766. tray.setIcon(icon)
767. tray.setVisible(True)
768.  
769.  
770. def handle_tray_click(reason):
771.    # If the tray is left-clicked, create a new note.
772.    if (
773.        QSystemTrayIcon.ActivationReason(reason)
774.        == QSystemTrayIcon.ActivationReason.Trigger
775.    ):
776.        create_notewindow()
777.  
778.  
779. tray.activated.connect(handle_tray_click)
780.  
781. app.exec()
782. </code></pre>
783.    </div>
784.    <p>
785.      In this code we've first create an <code>QIcon</code> object passing in the filename of the icon to use. I'm using a sticky note icon from the <a href="http://p.yusukekamiyamane.com/">Fugue icon set</a> by designer Yusuke Kamiyamane. Feel free to use any icon you prefer.
786.    </p>
787.    <p class="admonition admonition-note">
788.      We're using a relative path here. If you don't see the icon, make sure you're running the script from the same folder <em>or</em> provide the path.
789.    </p>
790.    <p>
791.      The system tray icon is managed through a <code>QSystemTrayIcon</code> object. We set our icon on this, and set the tray icon to visible (so it is not automatically hidden by Windows).
792.    </p>
793.    <p>
794.      <code>QSystemTrayIcon</code> has a signal <code>activated</code> which fires whenever the icon is activated in some way -- for example, being clicked with the left or right mouse button. We're only interested in a single left click for now -- we'll use the right click for our menu shortly. To handle the left click, we create a handler function which accepts <code>reason</code> (the reason for the activation) and then checks this against <code>QSystemTrayIcon.ActivationReason.Trigger</code>. This is the reason reported when a left click is used.
795.    </p>
796.    <p>
797.      If the left mouse button has been clicked, we call <code>create_notewindow()</code> to create a new instance of a note.
798.    </p>
799.    <p>
800.      If you run this example now, you'll see the sticky note in your tray and clicking on it will create a new note on the current desktop! You can create as many notes as you like, and once you close them all the application will close.
801.    </p>
802.    <p>
803.      <img alt="The sticky note icon in the tray" height="146" src="https://www.pythonguis.com/static/examples/qt/desktop-notes/notes-tray-windows.png" width="322"> <em>The sticky note icon in the tray</em>
804.    </p>
805.    <p class="admonition admonition-note">
806.      This is happening because by default Qt will close an application once all it's windows have closed. This can be disabled, but we need to add another way to quit before we do it, otherwise our app will be <em>unstoppable</em>.
807.    </p>
808.    <h2 id="adding-a-menu">
809.      Adding a Menu
810.    </h2>
811.    <p>
812.      To allow the notes application to be closed from the tray, we need a menu. Sytem tray menus are normally accessible through right-clicking on the icon. To implement that we can set a <code>QMenu</code> as a <em>context</em> menu on the <code>QSystemTrayIcon</code>. The actions in menus in Qt are defined using <code>QAction</code>.
813.    </p>
814.    <div class="code-block">
815.      <span class="code-block-language code-block-python">python</span>
816.      <pre><code class="python">import sys
817.  
818. from PySide6.QtCore import Qt
819. from PySide6.QtGui import QAction, QIcon
820. from PySide6.QtWidgets import (
821.    QApplication,
822.    QHBoxLayout,
823.    QMenu,
824.    QPushButton,
825.    QSystemTrayIcon,
826.    QTextEdit,
827.    QVBoxLayout,
828.    QWidget,
829. )
830.  
831. # ... code hidden up to handle_tray_click
832.  
833. tray.activated.connect(handle_tray_click)
834.  
835.  
836. # Don't automatically close app when the last window is closed.
837. app.setQuitOnLastWindowClosed(False)
838.  
839. # Create the menu
840. menu = QMenu()
841. add_note_action = QAction("Add note")
842. add_note_action.triggered.connect(create_notewindow)
843. menu.addAction(add_note_action)
844.  
845. # Add a Quit option to the menu.
846. quit_action = QAction("Quit")
847. quit_action.triggered.connect(app.quit)
848. menu.addAction(quit_action)
849.  
850. # Add the menu to the tray
851. tray.setContextMenu(menu)
852.  
853.  
854. app.exec()
855. </code></pre>
856.    </div>
857.    <p>
858.      We create the menu using <code>QMenu</code>. Actions are created using <code>QAction</code> passing in the label as a string. This is the text that will be shown for the menu item. The <code>.triggered</code> signal fires when the action is clicked (in a menu, or toolbar) or activated through a keyboard shortcut. Here we've connected the add note action to our <code>create_notewindow</code> function. We've also added an action to quit the application. This is connected to the built-in <code>.quit</code> slot on our <code>QApplication</code> instance.
859.    </p>
860.    <p>
861.      The menu is set on the tray using <code>.setContextMenu()</code>. In Qt context menus are automatically shown when the user right clicks on the tray.
862.    </p>
863.    <p>
864.      Finally, we have also disabled the behavior of closing the application when the last window is closed using <code>app.setQuitOnLastWindowClosed(False)</code>. Now, once you close all the windows, the application will remain running in the background. You can close it by going to the tray, right-clicking and selecting "Quit".
865.    </p>
866.    <p class="admonition admonition-tip">
867.      If you find this annoying while developing, just comment this line out again.
868.    </p>
869.    <p>
870.      We've had a lot of changes so far, so here is the current complete code.
871.    </p>
872.    <div class="code-block">
873.      <span class="code-block-language code-block-python">python</span>
874.      <pre><code class="python">import sys
875.  
876. from PySide6.QtCore import Qt
877. from PySide6.QtGui import QIcon
878. from PySide6.QtWidgets import (
879.    QApplication,
880.    QHBoxLayout,
881.    QPushButton,
882.    QSystemTrayIcon,
883.    QTextEdit,
884.    QVBoxLayout,
885.    QWidget,
886. )
887.  
888. app = QApplication(sys.argv)
889.  
890. # Store references to the NoteWindow objects in this, keyed by id.
891. active_notewindows = {}
892.  
893.  
894. class NoteWindow(QWidget):
895.    def __init__(self):
896.        super().__init__()
897.        self.setWindowFlags(
898.            self.windowFlags()
899.            | Qt.WindowType.FramelessWindowHint
900.            | Qt.WindowType.WindowStaysOnTopHint
901.        )
902.        self.setStyleSheet(
903.            "background: #FFFF99; color: #62622f; border: 0; font-size: 16pt;"
904.        )
905.        layout = QVBoxLayout()
906.  
907.        buttons = QHBoxLayout()
908.        self.close_btn = QPushButton("×")
909.        self.close_btn.setStyleSheet(
910.            "font-weight: bold; font-size: 25px; width: 25px; height: 25px;"
911.        )
912.        self.close_btn.clicked.connect(self.close)
913.        self.close_btn.setCursor(Qt.CursorShape.PointingHandCursor)
914.        buttons.addStretch()  # Add stretch on left to push button right.
915.        buttons.addWidget(self.close_btn)
916.        layout.addLayout(buttons)
917.  
918.        self.text = QTextEdit()
919.        layout.addWidget(self.text)
920.        self.setLayout(layout)
921.  
922.        # Store a reference to this note in the active_notewindows
923.        active_notewindows[id(self)] = self
924.  
925.    def mousePressEvent(self, e):
926.        self.previous_pos = e.globalPosition()
927.  
928.    def mouseMoveEvent(self, e):
929.        delta = e.globalPosition() - self.previous_pos
930.        self.move(self.x() + delta.x(), self.y() + delta.y())
931.        self.previous_pos = e.globalPosition()
932.  
933.  
934. def create_notewindow():
935.    note = NoteWindow()
936.    note.show()
937.  
938.  
939. create_notewindow()
940.  
941. # Create the icon
942. icon = QIcon("sticky-note.png")
943.  
944. # Create the tray
945. tray = QSystemTrayIcon()
946. tray.setIcon(icon)
947. tray.setVisible(True)
948.  
949.  
950. def handle_tray_click(reason):
951.    # If the tray is left-clicked, create a new note.
952.    if (
953.        QSystemTrayIcon.ActivationReason(reason)
954.        == QSystemTrayIcon.ActivationReason.Trigger
955.    ):
956.        create_notewindow()
957.  
958.  
959. tray.activated.connect(handle_tray_click)
960.  
961. app.exec()
962.  
963. </code></pre>
964.    </div>
965.    <p>
966.      If you run this now you will be able to right click the note in the tray to show the menu.
967.    </p>
968.    <p>
969.      <img alt="The sticky note icon in the tray showing its context menu" height="143" src="https://www.pythonguis.com/static/examples/qt/desktop-notes/notes-tray-active-windows.png" width="333"> <em>The sticky note icon in the tray showing its context menu</em>
970.    </p>
971.    <p>
972.      Test the <em>Add note</em> and <em>Quit</em> functionality to make sure they're working.
973.    </p>
974.    <p>
975.      So, now we have our note UI implemented, the ability to create and remove notes and a persistent tray icon where we can also create notes & close the application. The last piece of the puzzle is persisting the notes between runs of the application -- if we leave a note on the desktop, we want it to still be there if we come back tomorrow. We'll implement that next.
976.    </p>
977.    <h2 id="setting-up-the-notes-database">
978.      Setting up the Notes database
979.    </h2>
980.    <p>
981.      To be able to store and load notes, we need an underlying data model. For this demo we're using SQLAlchemy as an interface to an SQLite database. This provides an Object-Relational Mapping (ORM) interface, which is a fancy way of saying we can interact with the database through Python objects.
982.    </p>
983.    <p>
984.      We'll define our database in a separate file, to keep the UI file manageable. So start by creating a new file named <code>database.py</code> in your project folder.
985.    </p>
986.    <p>
987.      In that file add the imports for SQLAlchemy, and instantiate the <code>Base</code> class for our models.
988.    </p>
989.    <div class="code-block">
990.      <span class="code-block-language code-block-python">python</span>
991.      <pre><code class="python">from sqlalchemy import Column, Integer, String, create_engine
992. from sqlalchemy.orm import declarative_base, sessionmaker
993.  
994. Base = declarative_base()
995. </code></pre>
996.    </div>
997.    <p>
998.      Next in the same <code>database.py</code> file, define our note database model. This inherits from the <code>Base</code> class we've just created, by calling <code>declarative_base()</code>
999.    </p>
1000.    <div class="code-block">
1001.      <span class="code-block-language code-block-python">python</span>
1002.      <pre><code class="python">class Note(Base):
1003.    __tablename__ = "note"
1004.    id = Column(Integer, primary_key=True)
1005.    text = Column(String(1000), nullable=False)
1006.    x = Column(Integer, nullable=False, default=0)
1007.    y = Column(Integer, nullable=False, default=0)
1008. </code></pre>
1009.    </div>
1010.    <p>
1011.      Each note object has 4 properties:
1012.    </p>
1013.    <ul>
1014.      <li>
1015.        <strong>id</strong> the unique ID for the given note, used to delete from the database
1016.      </li>
1017.      <li>
1018.        <strong>text</strong> the text content of the note
1019.      </li>
1020.      <li>
1021.        <strong>x</strong> the <em>x</em> position on the screen
1022.      </li>
1023.      <li>
1024.        <strong>y</strong> the <em>y</em> position on the screen
1025.      </li>
1026.    </ul>
1027.    <p>
1028.      Next we need to create the <em>engine</em> -- in this case, this is our SQLite file, which we're calling <code>notes.db</code>.We can then create the tables (if they don't already exist). Since our <code>Note</code> class registers itself with the <code>Base</code> we can do that by calling <code>create_all</code> on the <code>Base</code> class.
1029.    </p>
1030.    <div class="code-block">
1031.      <span class="code-block-language code-block-python">python</span>
1032.      <pre><code class="python">engine = create_engine("sqlite:///notes.db")
1033.  
1034. Base.metadata.create_all(engine)
1035. </code></pre>
1036.    </div>
1037.    <p>
1038.      Save the <code>database.py</code> file and run it
1039.    </p>
1040.    <div class="code-block">
1041.      <span class="code-block-language code-block-sh">sh</span>
1042.      <pre><code class="sh">python database.py
1043. </code></pre>
1044.    </div>
1045.    <p>
1046.      After it is complete, if you look in the folder you should see the <code>notes.db</code>. This file contains the table structure for the <code>Note</code> model we defined above.
1047.    </p>
1048.    <p>
1049.      Finally, we need a <em>session</em> to interact with the database from the UI. Since we only need a single session when the app is running, we can go ahead and create it in this file and then import it into the UI code.
1050.    </p>
1051.    <p>
1052.      Add the following to <code>database.py</code>
1053.    </p>
1054.    <div class="code-block">
1055.      <span class="code-block-language code-block-python">python</span>
1056.      <pre><code class="python"># Create a session to handle updates.
1057. Session = sessionmaker(bind=engine)
1058. session = Session()
1059. </code></pre>
1060.    </div>
1061.    <p>
1062.      The final complete code for our database interface is shown below
1063.    </p>
1064.    <div class="code-block">
1065.      <span class="code-block-language code-block-python">python</span>
1066.      <pre><code class="python">from sqlalchemy import Column, Integer, String, create_engine
1067. from sqlalchemy.orm import declarative_base, sessionmaker
1068.  
1069. Base = declarative_base()
1070.  
1071.  
1072. class Note(Base):
1073.    __tablename__ = "note"
1074.    id = Column(Integer, primary_key=True)
1075.    text = Column(String(1000), nullable=False)
1076.    x = Column(Integer, nullable=False, default=0)
1077.    y = Column(Integer, nullable=False, default=0)
1078.  
1079.  
1080. engine = create_engine("sqlite:///notes.db")
1081.  
1082. Base.metadata.create_all(engine)
1083.  
1084. Session = sessionmaker(bind=engine)
1085. session = Session()
1086. </code></pre>
1087.    </div>
1088.    <p>
1089.      Now that our data model is defined, and our database created, we can go ahead and interface our <code>Notes</code> model into the UI. This will allow us to load notes at startup (to show existing notes), save notes when they are updated and delete notes when they are removed.
1090.    </p>
1091.    <h2 id="integrating-the-data-model-into-our-ui">
1092.      Integrating the Data Model into our UI
1093.    </h2>
1094.    <p>
1095.      Our data model holds the text content and x & y positions of the notes. To keep the active notes and model in sync we need a few things.
1096.    </p>
1097.    <ol>
1098.      <li>Each <code>NoteWindow</code> must have it's own associated instance of the <code>Note</code> object.
1099.      </li>
1100.      <li>New <code>Note</code> objects should be created when creating a new <code>NoteWindow</code>.
1101.      </li>
1102.      <li>The <code>NoteWindow</code> should sync it's initial state to a <code>Note</code> if provided.
1103.      </li>
1104.      <li>Moving & editing a <code>NoteWindow</code> should update the data in the <code>Note</code>.
1105.      </li>
1106.      <li>Changes to <code>Note</code> should be synced to the database.
1107.      </li>
1108.    </ol>
1109.    <p>
1110.      We can tackle these one by one.
1111.    </p>
1112.    <p>
1113.      First let's setup our <code>NoteWindow</code> to accept, and store a reference to <code>Note</code> objects if provided, or create a new one if not.
1114.    </p>
1115.    <div class="code-block">
1116.      <span class="code-block-language code-block-python">python</span>
1117.      <pre><code class="python">import sys
1118.  
1119. from database import Note
1120. from PySide6.QtCore import Qt
1121. from PySide6.QtGui import QAction, QIcon
1122. from PySide6.QtWidgets import (
1123.    QApplication,
1124.    QHBoxLayout,
1125.    QMenu,
1126.    QPushButton,
1127.    QSystemTrayIcon,
1128.    QTextEdit,
1129.    QVBoxLayout,
1130.    QWidget,
1131. )
1132.  
1133. app = QApplication(sys.argv)
1134.  
1135. # Store references to the NoteWindow objects in this, keyed by id.
1136. active_notewindows = {}
1137.  
1138.  
1139. class NoteWindow(QWidget):
1140.    def __init__(self, note=None):
1141.        super().__init__()
1142.  
1143.        # ... add to the bottom of the __init__ method
1144.  
1145.        if note is None:
1146.            self.note = Note()
1147.        else:
1148.            self.note = note
1149.  
1150.  
1151. </code></pre>
1152.    </div>
1153.    <p>
1154.      In this code we've imported the <code>Note</code> object from our <code>database.py</code> file. In the <code>__init__</code> of our <code>NoteWindow</code> we've added an optional parameter to receive a <code>Note</code> object. If this is <code>None</code> (or nothing provided) a new <code>Note</code> will be created instead. The passed, or created note, is then stored on the <code>NoteWindow</code> so we can use it later.
1155.    </p>
1156.    <p>
1157.      This <code>Note</code> object is still not being loaded, updated, or persisted to the database. So let's implement that next. We add two methods, <code>load()</code> and <code>save()</code> to our <code>NoteWindow</code> to handle the loading and saving of data.
1158.    </p>
1159.    <div class="code-block">
1160.      <span class="code-block-language code-block-python">python</span>
1161.      <pre><code class="python">from database import Note, session
1162.  
1163. # ... skipped other imports, unchanged.
1164.  
1165. class NoteWindow(QWidget):
1166.    def __init__(self, note=None):
1167.        super().__init__()
1168.  
1169.        # ... modify the close_btn handler to use delete.
1170.        self.close_btn.clicked.connect(self.delete)
1171.  
1172.  
1173.        # ... rest of the code hidden.
1174.  
1175.        # If no note is provided, create one.
1176.        if note is None:
1177.            self.note = Note()
1178.            self.save()
1179.        else:
1180.            self.note = note
1181.            self.load()
1182.  
1183.    # ... add the following to the end of the class definition.
1184.  
1185.    def load(self):
1186.        self.move(self.note.x, self.note.y)
1187.        self.text.setText(self.note.text)
1188.  
1189.    def save(self):
1190.        self.note.x = self.x()
1191.        self.note.y = self.y()
1192.        self.note.text = self.text.toPlainText()
1193.        # Write the data to the database, adding the Note object to the
1194.        # current session and committing the changes.
1195.        session.add(self.note)
1196.        session.commit()
1197.  
1198.    def delete(self):
1199.        session.delete(self.note)
1200.        session.commit()
1201.        del active_notewindows[id(self)]
1202.        self.close()
1203.  
1204. </code></pre>
1205.    </div>
1206.    <p>
1207.      The <code>load()</code> method takes the <code>x</code> and <code>y</code> position from the <code>Note</code> object stored in <code>self.note</code> and updates the <code>NoteWindow</code> position and content to match. The <code>save()</code> method takes the <code>NoteWindow</code> position and content and sets that onto the <code>Note</code> object. It then adds the note to the current database session and commits the changes
1208.    </p>
1209.    <p class="admonition admonition-note">
1210.      Each commit starts a new session. Adding the <code>Note</code> to the session is indicating that we want it's changes persisted.
1211.    </p>
1212.    <p>
1213.      The <code>delete()</code> method handles deletion of the current note. This involves 3 things:
1214.    </p>
1215.    <ol>
1216.      <li>passing the <code>Note</code> object to <code>session.delete</code> to remove it from the database,
1217.      </li>
1218.      <li>deleting the reference to our window from the <code>active_notewindows</code> (so the object will be tidied up)
1219.      </li>
1220.      <li>calling <code>.close()</code> to hide the window immediately.
1221.      </li>
1222.    </ol>
1223.    <p class="admonition admonition-note">
1224.      Usually (2) will cause the object to be cleaned up, and that will close the window indirectly. But that may be delayed, which would mean sometimes the close button doesn't seem to work straight away. We call <code>.close()</code> to make it immediate.
1225.    </p>
1226.    <p>
1227.      We need to modify the <code>close_btn.clicked</code> signal to point to our <code>delete</code> method.
1228.    </p>
1229.    <p>
1230.      Next we've added a <code>load()</code> call to the <code>__init__</code> when a <code>Note</code> object is passed. We also call <code>.save()</code> for newly created notes to persist them immediately, so our delete handler will work before editing.
1231.    </p>
1232.    <p>
1233.      Finally, we need to handle saving the note whenever it changes. We have two ways that the note can change -- when it's moved, or when it's edited. For the first we <em>could</em> do this on each mouse move, but it's a bit redundant. We only care where the note ends up while dragging -- that is, where it is when the mouse is released. We can get this through the <code>mouseReleased</code> method.
1234.    </p>
1235.    <div class="code-block">
1236.      <span class="code-block-language code-block-python">python</span>
1237.      <pre><code class="python">from database import Note, session
1238.  
1239. # ... skipped other imports, unchanged.
1240.  
1241. class NoteWindow(QWidget):
1242.  
1243.    # ... add the mouseReleaseEvent to the events on the NoteWindow.
1244.  
1245.    def mousePressEvent(self, e):
1246.        self.previous_pos = e.globalPosition()
1247.  
1248.    def mouseMoveEvent(self, e):
1249.        delta = e.globalPosition() - self.previous_pos
1250.        self.move(self.x() + delta.x(), self.y() + delta.y())
1251.        self.previous_pos = e.globalPosition()
1252.  
1253.    def mouseReleaseEvent(self, e):
1254.        self.save()
1255.  
1256.    # ... the load and save methods are under here, unchanged.
1257.  
1258. </code></pre>
1259.    </div>
1260.    <p>
1261.      That's all there is to it: when the mouse button is released, we save the current content and position by calling <code>.save()</code>.
1262.    </p>
1263.    <p class="admonition admonition-note">
1264.      You might be wondering why we don't just save the position at this point? Usually it's better to implement a single load & save (persist/restore) handler that can be called for all situations. It avoids needing implementations for each case.
1265.    </p>
1266.    <p>
1267.      There have been a lot of partial code changes in this section, so here is the complete current code.
1268.    </p>
1269.    <div class="code-block">
1270.      <span class="code-block-language code-block-python">python</span>
1271.      <pre><code class="python">import sys
1272.  
1273. from database import Note, session
1274. from PySide6.QtCore import Qt
1275. from PySide6.QtGui import QAction, QIcon
1276. from PySide6.QtWidgets import (
1277.    QApplication,
1278.    QHBoxLayout,
1279.    QMenu,
1280.    QPushButton,
1281.    QSystemTrayIcon,
1282.    QTextEdit,
1283.    QVBoxLayout,
1284.    QWidget,
1285. )
1286.  
1287. app = QApplication(sys.argv)
1288.  
1289. # Store references to the NoteWindow objects in this, keyed by id.
1290. active_notewindows = {}
1291.  
1292.  
1293. class NoteWindow(QWidget):
1294.    def __init__(self, note=None):
1295.        super().__init__()
1296.  
1297.        self.setWindowFlags(
1298.            self.windowFlags()
1299.            | Qt.WindowType.FramelessWindowHint
1300.            | Qt.WindowType.WindowStaysOnTopHint
1301.        )
1302.        self.setStyleSheet(
1303.            "background: #FFFF99; color: #62622f; border: 0; font-size: 16pt;"
1304.        )
1305.        layout = QVBoxLayout()
1306.  
1307.        buttons = QHBoxLayout()
1308.        self.close_btn = QPushButton("×")
1309.        self.close_btn.setStyleSheet(
1310.            "font-weight: bold; font-size: 25px; width: 25px; height: 25px;"
1311.        )
1312.        self.close_btn.clicked.connect(self.delete)
1313.        self.close_btn.setCursor(Qt.CursorShape.PointingHandCursor)
1314.        buttons.addStretch()  # Add stretch on left to push button right.
1315.        buttons.addWidget(self.close_btn)
1316.        layout.addLayout(buttons)
1317.  
1318.        self.text = QTextEdit()
1319.        layout.addWidget(self.text)
1320.        self.setLayout(layout)
1321.  
1322.        self.text.textChanged.connect(self.save)
1323.  
1324.        # Store a reference to this note in the active_notewindows
1325.        active_notewindows[id(self)] = self
1326.  
1327.        # If no note is provided, create one.
1328.        if note is None:
1329.            self.note = Note()
1330.            self.save()
1331.        else:
1332.            self.note = note
1333.            self.load()
1334.  
1335.    def mousePressEvent(self, e):
1336.        self.previous_pos = e.globalPosition()
1337.  
1338.    def mouseMoveEvent(self, e):
1339.        delta = e.globalPosition() - self.previous_pos
1340.        self.move(self.x() + delta.x(), self.y() + delta.y())
1341.        self.previous_pos = e.globalPosition()
1342.  
1343.    def mouseReleaseEvent(self, e):
1344.        self.save()
1345.  
1346.    def load(self):
1347.        self.move(self.note.x, self.note.y)
1348.        self.text.setText(self.note.text)
1349.  
1350.    def save(self):
1351.        self.note.x = self.x()
1352.        self.note.y = self.y()
1353.        self.note.text = self.text.toPlainText()
1354.        # Write the data to the database, adding the Note object to the
1355.        # current session and committing the changes.
1356.        session.add(self.note)
1357.        session.commit()
1358.  
1359.    def delete(self):
1360.        session.delete(self.note)
1361.        session.commit()
1362.        del active_notewindows[id(self)]
1363.        self.close()
1364.  
1365.  
1366. def create_notewindow():
1367.    note = NoteWindow()
1368.    note.show()
1369.  
1370.  
1371. create_notewindow()
1372.  
1373. # Create the icon
1374. icon = QIcon("sticky-note.png")
1375.  
1376. # Create the tray
1377. tray = QSystemTrayIcon()
1378. tray.setIcon(icon)
1379. tray.setVisible(True)
1380.  
1381.  
1382. def handle_tray_click(reason):
1383.    # If the tray is left-clicked, create a new note.
1384.    if (
1385.        QSystemTrayIcon.ActivationReason(reason)
1386.        == QSystemTrayIcon.ActivationReason.Trigger
1387.    ):
1388.        create_notewindow()
1389.  
1390.  
1391. tray.activated.connect(handle_tray_click)
1392.  
1393.  
1394. # Don't automatically close app when the last window is closed.
1395. app.setQuitOnLastWindowClosed(False)
1396.  
1397. # Create the menu
1398. menu = QMenu()
1399. # Add the Add Note option to the menu.
1400. add_note_action = QAction("Add note")
1401. add_note_action.triggered.connect(create_notewindow)
1402. menu.addAction(add_note_action)
1403.  
1404. # Add a Quit option to the menu.
1405. quit_action = QAction("Quit")
1406. quit_action.triggered.connect(app.quit)
1407. menu.addAction(quit_action)
1408. # Add the menu to the tray
1409. tray.setContextMenu(menu)
1410.  
1411.  
1412. app.exec()
1413. </code></pre>
1414.    </div>
1415.    <p>
1416.      If you run the application at this point it will be persisting data to the database as you edit it.
1417.    </p>
1418.    <p class="admonition admonition-tip">
1419.      If you want to look at the contents of the SQLite database I can recommend <a href="https://sqlitebrowser.org/">DB Browser for SQLite</a>. It's open source & free.
1420.    </p>
1421.    <p>
1422.      <img alt="The note data persisted to the SQLite database" height="988" src="https://www.pythonguis.com/static/examples/qt/desktop-notes/notes-sqlite-browser.png" width="1668"> <em>The note data persisted to the SQLite database</em>
1423.    </p>
1424.    <h2 id="starting-up">
1425.      Starting up
1426.    </h2>
1427.    <p>
1428.      So our notes are being created, added to the database, updated and deleted. The last piece of the puzzle is restoring the previous state at start up.
1429.    </p>
1430.    <p>
1431.      We already have all the bits in place for this, we just need to handle the startup itself. To recreate the notes we can query the database to get a list of <code>Note</code> objects and then iterate through this, creating new <code>NoteWindow</code> instances (using our <code>create_notewindow</code> function).
1432.    </p>
1433.    <div class="code-block">
1434.      <span class="code-block-language code-block-python">python</span>
1435.      <pre><code class="python">def create_notewindow(note=None):
1436.    note = NoteWindow(note)
1437.    note.show()
1438.  
1439.  
1440. existing_notes = session.query(Note).all()
1441.  
1442. if existing_notes:
1443.    for note in existing_notes:
1444.        create_notewindow(note)
1445. else:
1446.    create_notewindow()
1447.  
1448. </code></pre>
1449.    </div>
1450.    <p>
1451.      First we've modified the <code>create_notewindow</code> function to accept an (optional) <code>Note</code> object which is passed through to the created <code>NoteWindow</code>.
1452.    </p>
1453.    <p>
1454.      Using the session we query <code>session.query(Note).all()</code> to get all the <code>Note</code> objects. If there any, we iterate them creating them. If not, we create a single note with no associated <code>Note</code> object (this will be created inside the <code>NoteWindow</code>).
1455.    </p>
1456.    <p>
1457.      That's it! The full final code is shown below:
1458.    </p>
1459.    <div class="code-block">
1460.      <span class="code-block-language code-block-python">python</span>
1461.      <pre><code class="python">import sys
1462.  
1463. from database import Note, session
1464. from PySide6.QtCore import Qt
1465. from PySide6.QtGui import QAction, QIcon
1466. from PySide6.QtWidgets import (
1467.    QApplication,
1468.    QHBoxLayout,
1469.    QMenu,
1470.    QPushButton,
1471.    QSystemTrayIcon,
1472.    QTextEdit,
1473.    QVBoxLayout,
1474.    QWidget,
1475. )
1476.  
1477. app = QApplication(sys.argv)
1478.  
1479. # Store references to the NoteWindow objects in this, keyed by id.
1480. active_notewindows = {}
1481.  
1482.  
1483. class NoteWindow(QWidget):
1484.    def __init__(self, note=None):
1485.        super().__init__()
1486.  
1487.        self.setWindowFlags(
1488.            self.windowFlags()
1489.            | Qt.WindowType.FramelessWindowHint
1490.            | Qt.WindowType.WindowStaysOnTopHint
1491.        )
1492.        self.setStyleSheet(
1493.            "background: #FFFF99; color: #62622f; border: 0; font-size: 16pt;"
1494.        )
1495.        layout = QVBoxLayout()
1496.  
1497.        buttons = QHBoxLayout()
1498.        self.close_btn = QPushButton("×")
1499.        self.close_btn.setStyleSheet(
1500.            "font-weight: bold; font-size: 25px; width: 25px; height: 25px;"
1501.        )
1502.        self.close_btn.clicked.connect(self.delete)
1503.        self.close_btn.setCursor(Qt.CursorShape.PointingHandCursor)
1504.        buttons.addStretch()  # Add stretch on left to push button right.
1505.        buttons.addWidget(self.close_btn)
1506.        layout.addLayout(buttons)
1507.  
1508.        self.text = QTextEdit()
1509.        layout.addWidget(self.text)
1510.        self.setLayout(layout)
1511.  
1512.        self.text.textChanged.connect(self.save)
1513.  
1514.        # Store a reference to this note in the active_notewindows
1515.        active_notewindows[id(self)] = self
1516.  
1517.        # If no note is provided, create one.
1518.        if note is None:
1519.            self.note = Note()
1520.            self.save()
1521.        else:
1522.            self.note = note
1523.            self.load()
1524.  
1525.    def mousePressEvent(self, e):
1526.        self.previous_pos = e.globalPosition()
1527.  
1528.    def mouseMoveEvent(self, e):
1529.        delta = e.globalPosition() - self.previous_pos
1530.        self.move(self.x() + delta.x(), self.y() + delta.y())
1531.        self.previous_pos = e.globalPosition()
1532.  
1533.    def mouseReleaseEvent(self, e):
1534.        self.save()
1535.  
1536.    def load(self):
1537.        self.move(self.note.x, self.note.y)
1538.        self.text.setText(self.note.text)
1539.  
1540.    def save(self):
1541.        self.note.x = self.x()
1542.        self.note.y = self.y()
1543.        self.note.text = self.text.toPlainText()
1544.        # Write the data to the database, adding the Note object to the
1545.        # current session and committing the changes.
1546.        session.add(self.note)
1547.        session.commit()
1548.  
1549.    def delete(self):
1550.        session.delete(self.note)
1551.        session.commit()
1552.        del active_notewindows[id(self)]
1553.        self.close()
1554.  
1555.  
1556. def create_notewindow(note=None):
1557.    note = NoteWindow(note)
1558.    note.show()
1559.  
1560.  
1561. existing_notes = session.query(Note).all()
1562.  
1563. if existing_notes:
1564.    for note in existing_notes:
1565.        create_notewindow(note)
1566. else:
1567.    create_notewindow()
1568.  
1569. # Create the icon
1570. icon = QIcon("sticky-note.png")
1571.  
1572. # Create the tray
1573. tray = QSystemTrayIcon()
1574. tray.setIcon(icon)
1575. tray.setVisible(True)
1576.  
1577.  
1578. def handle_tray_click(reason):
1579.    # If the tray is left-clicked, create a new note.
1580.    if (
1581.        QSystemTrayIcon.ActivationReason(reason)
1582.        == QSystemTrayIcon.ActivationReason.Trigger
1583.    ):
1584.        create_notewindow()
1585.  
1586.  
1587. tray.activated.connect(handle_tray_click)
1588.  
1589.  
1590. # Don't automatically close app when the last window is closed.
1591. app.setQuitOnLastWindowClosed(False)
1592.  
1593. # Create the menu
1594. menu = QMenu()
1595. # Add the Add Note option to the menu.
1596. add_note_action = QAction("Add note")
1597. add_note_action.triggered.connect(create_notewindow)
1598. menu.addAction(add_note_action)
1599.  
1600. # Add a Quit option to the menu.
1601. quit_action = QAction("Quit")
1602. quit_action.triggered.connect(app.quit)
1603. menu.addAction(quit_action)
1604. # Add the menu to the tray
1605. tray.setContextMenu(menu)
1606.  
1607.  
1608. app.exec()
1609. </code></pre>
1610.    </div>
1611.    <p>
1612.      If you run the app now, you can create new notes as before, but when you exit (using the Quit option from the tray) and restart, the previous notes will reappear. If you close the notes, they will be deleted. On startup, if there are no notes in the database an initial note will be created for you.
1613.    </p>
1614.    <h2 id="conclusion">
1615.      Conclusion
1616.    </h2>
1617.    <p>
1618.      That's it! We have a fully functional desktop sticky note application, which you can use to keep simple bits of text until you need them again. We've learnt how to build an application up step by step from a basic outline window. We've added basic styles using QSS and used window flags to control the appearance of notes on the desktop. We've also seen how to create a system tray application, adding context menus and default behaviours (via a left mouse click). Finally, we've created a simple data model using SQLAlchemy and hooked that into our UI to persist the UI state between runs of the applications.
1619.    </p>
1620.    <p>
1621.      Try and extend this example further, for example:
1622.    </p>
1623.    <ul>
1624.      <li>Add multicolor notes, using a Python <code>list</code> of hex colors and <code>random.choice</code> to select a new color each time a note is created. Can you persist this in the database too?
1625.      </li>
1626.      <li>Add an option in the tray to show/hide all notes. Remember we have all the <code>NoteWindow</code> objects in <code>active_notewindows</code>. You can show and hide windows in Qt using <code>.show()</code> and <code>.hide()</code>.
1627.      </li>
1628.    </ul>
1629.    <p>
1630.      Think about some additional features you'd like or expect to see in a desktop notes application and see if you can add them yourself!
1631.    &lt;/p&gt;</description>
1632.    </item>
1633.    <item>
1634.      <guid isPermaLink="false">https://www.kdab.com/modelview-drag-and-drop-in-qt-part-3/</guid>
1635.      <title>KDAB on Qt: Model/View Drag and Drop in Qt - Part 3</title>
1636.      <pubDate>Thu, 03 Apr 2025 08:43:00 GMT</pubDate>
1637.      <link>https://www.kdab.com/modelview-drag-and-drop-in-qt-part-3/</link>
1638.      <description>&lt;h1&gt;
1639.      Model/View Drag and Drop in Qt - Part 3
1640.    </h1>
1641.    <div class="rich-text">
1642.      <p>
1643.        In this third blog post of the Model/View Drag and Drop series (<a href="https://www.kdab.com/modelview-drag-and-drop-part-1/">part 1</a> and <a href="https://www.kdab.com/modelview-drag-and-drop-in-qt-part-2/">part 2</a>), the idea is to implement dropping onto items, rather than in between items. QListWidget and QTableWidget have out of the box support for replacing the value of existing items when doing that, but there aren't many use cases for that. What is much more common is to associate a custom semantic to such a drop. For instance, the examples detailed below show email folders and their contents, and dropping an email onto another folder will move (or copy) the email into that folder.
1644.      </p>
1645.    </div>
1646.    <div class="image-variable-size-block">
1647.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
1648.        <div class="image-variable-size-image">
1649.          <img alt="Blog_Drag&Drop_Qt_part3-treeview-step1" class="Blog_Drag&Drop_Qt_part3-treeview-step1" id="Blog_Drag&Drop_Qt_part3-treeview-step1" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/Blog_DragDrop_Qt_part3-treeview-step1.original.png" name="Blog_Drag&Drop_Qt_part3-treeview-step1">
1650.        </div>
1651.        <div class="image-variable-size-caption text-center">
1652.          <div class="rich-text">
1653.            <p>
1654.              Step 1
1655.            </p>
1656.          </div>
1657.        </div>
1658.      </div>
1659.    </div>
1660.    <div class="rich-text">
1661.      <p>
1662.        Initial state, the email is in the inbox
1663.      </p>
1664.    </div>
1665.    <div class="image-variable-size-block">
1666.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
1667.        <div class="image-variable-size-image">
1668.          <img alt="Blog_Drag&Drop_Qt_part3-treeview-step2" class="Blog_Drag&Drop_Qt_part3-treeview-step2" id="Blog_Drag&Drop_Qt_part3-treeview-step2" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/Blog_DragDrop_Qt_part3-treeview-step2.original.png" name="Blog_Drag&Drop_Qt_part3-treeview-step2">
1669.        </div>
1670.        <div class="image-variable-size-caption text-center">
1671.          <div class="rich-text">
1672.            <p>
1673.              Step 2
1674.            </p>
1675.          </div>
1676.        </div>
1677.      </div>
1678.    </div>
1679.    <div class="rich-text">
1680.      <p>
1681.        Dragging the email onto the Customers folder
1682.      </p>
1683.    </div>
1684.    <div class="image-variable-size-block">
1685.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
1686.        <div class="image-variable-size-image">
1687.          <img alt="Blog_Drag&Drop_Qt_part3-treeview-step3" class="Blog_Drag&Drop_Qt_part3-treeview-step3" id="Blog_Drag&Drop_Qt_part3-treeview-step3" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/Blog_DragDrop_Qt_part3-treeview-step3.original.png" name="Blog_Drag&Drop_Qt_part3-treeview-step3">
1688.        </div>
1689.        <div class="image-variable-size-caption text-center">
1690.          <div class="rich-text">
1691.            <p>
1692.              Step 3
1693.            </p>
1694.          </div>
1695.        </div>
1696.      </div>
1697.    </div>
1698.    <div class="rich-text">
1699.      <p>
1700.        Dropping the email
1701.      </p>
1702.    </div>
1703.    <div class="image-variable-size-block">
1704.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
1705.        <div class="image-variable-size-image">
1706.          <img alt="Blog_Drag&Drop_Qt_part3-treeview-step4" class="Blog_Drag&Drop_Qt_part3-treeview-step4" id="Blog_Drag&Drop_Qt_part3-treeview-step4" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/Blog_DragDrop_Qt_part3-treeview-step4.original.png" name="Blog_Drag&Drop_Qt_part3-treeview-step4">
1707.        </div>
1708.        <div class="image-variable-size-caption text-center">
1709.          <div class="rich-text">
1710.            <p>
1711.              Step 4
1712.            </p>
1713.          </div>
1714.        </div>
1715.      </div>
1716.    </div>
1717.    <div class="rich-text">
1718.      <p>
1719.        The email is now in the customers folder
1720.      </p>
1721.      <h2>
1722.        With Model/View separation
1723.      </h2>
1724.      <p>
1725.        Example code can be found <a href="https://github.com/KDABLabs/blogs-qt/blob/main/ItemViews-DragAndDrop/part3-dropping-onto-items/model-view/drop-onto-items-with-model-view.cpp" rel="noopener noreferrer" target="_blank">here</a> for flat models and <a href="https://github.com/KDABLabs/blogs-qt/blob/main/ItemViews-DragAndDrop/part3-dropping-onto-items/treemodel/drop-onto-items-with-treemodel.cpp" rel="noopener noreferrer" target="_blank">here</a> for tree models.
1726.      </p>
1727.      <h3>
1728.        Setting up the view on the drag side
1729.      </h3>
1730.      <p>
1731.        ☑ Call <code>view->setDragDropMode(QAbstractItemView::DragOnly)</code><br>
1732.        unless of course the same view should also support drops. In our example, only emails can be dragged, and only folders allow drops, so the drag and drop sides are distinct.
1733.      </p>
1734.      <p>
1735.        ☑ Call <code>view->setDragDropOverwriteMode(...)</code><br>
1736.        <code>true</code> if moving should clear cells, <code>false</code> if moving should remove rows.<br>
1737.        Note that the default is <code>true</code> for <code>QTableView</code> and <code>false</code> for <code>QListView</code> and <code>QTreeView</code>. In our example, we want to remove emails that have been moved elsewhere, so <code>false</code> is correct.
1738.      </p>
1739.      <p>
1740.        ☑ Call <code>view->setDefaultDropAction(Qt::MoveAction)</code> so that the drag defaults to a move and not a copy, adjust as needed
1741.      </p>
1742.      <h3>
1743.        Setting up the model on the drag side
1744.      </h3>
1745.      <p>
1746.        To implement dragging items out of a model, you need to implement the following -- this is very similar to the section of the same name in the previous blog post, obviously:
1747.      </p>
1748.    </div>
1749.    <div class="formatted-code">
1750.      <pre><code class="language-cpp line-numbers">class EmailsModel : public QAbstractTableModel
1751. {
1752.    ~~~
1753.    Qt::ItemFlags flags(const QModelIndex &index) const override
1754.    {
1755.        if (!index.isValid())
1756.            return {};
1757.        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
1758.    }
1759.  
1760.    // the default is "copy only", change it
1761.    Qt::DropActions supportedDragActions() const override { return Qt::MoveAction | Qt::CopyAction; }
1762.  
1763.    QMimeData *mimeData(const QModelIndexList &indexes) const override;
1764.  
1765.    bool removeRows(int position, int rows, const QModelIndex &parent) override;</code></pre>
1766.    </div>
1767.    <div class="rich-text">
1768.      <p>
1769.        ☑ Reimplement <code>flags()</code> to add <code>Qt::ItemIsDragEnabled</code> in the case of a valid index
1770.      </p>
1771.      <p>
1772.        ☑ Reimplement <code>supportedDragActions()</code> to return <code>Qt::MoveAction | Qt::CopyAction</code> or whichever you want to support (the default is CopyAction only).
1773.      </p>
1774.      <p>
1775.        ☑ Reimplement <code>mimeData()</code> to serialize the complete data for the dragged items. If the views are always in the same process, you can get away with serializing only node pointers (if you have that) and application PID (to refuse dropping onto another process). See the previous part of this blog series for more details.
1776.      </p>
1777.      <p>
1778.        ☑ Reimplement <code>removeRows()</code>, it will be called after a successful drop with <code>MoveAction</code>. An example implementation looks like this:
1779.      </p>
1780.    </div>
1781.    <div class="formatted-code">
1782.      <pre><code class="language-cpp line-numbers">bool EmailsModel::removeRows(int position, int rows, const QModelIndex &parent)
1783. {
1784.    beginRemoveRows(parent, position, position + rows - 1);
1785.    for (int row = 0; row < rows; ++row) {
1786.        m_emailFolder->emails.removeAt(position);
1787.    }
1788.    endRemoveRows();
1789.    return true;
1790. }</code></pre>
1791.    </div>
1792.    <div class="rich-text">
1793.      <h3>
1794.        Setting up the view on the drop side
1795.      </h3>
1796.      <p>
1797.        ☑ Call <code>view->setDragDropMode(QAbstractItemView::DropOnly)</code> unless of course it supports dragging too. In our example, we can drop onto email folders but we cannot reorganize the folders, so <code>DropOnly</code> is correct.
1798.      </p>
1799.      <h3>
1800.        Setting up the model on the drop side
1801.      </h3>
1802.      <p>
1803.        To implement dropping items into a model's existing items, you need to do the following:
1804.      </p>
1805.    </div>
1806.    <div class="formatted-code">
1807.      <pre><code class="language-cpp line-numbers">class FoldersModel : public QAbstractTableModel
1808. {
1809.    ~~~    
1810.    Qt::ItemFlags flags(const QModelIndex &index) const override
1811.    {
1812.        CHECK_flags(index);
1813.        if (!index.isValid())
1814.            return {}; // do not allow dropping between items
1815.        if (index.column() > 0)
1816.            return Qt::ItemIsEnabled | Qt::ItemIsSelectable; // don't drop on other columns
1817.        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDropEnabled;
1818.    }
1819.  
1820.    // the default is "copy only", change it
1821.    Qt::DropActions supportedDropActions() const override { return Qt::MoveAction | Qt::CopyAction; }
1822.  
1823.    QStringList mimeTypes() const override { return {QString::fromLatin1(s_emailsMimeType)}; }
1824.  
1825.    bool dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column, const QModelIndex &parent) override;
1826. };</code></pre>
1827.    </div>
1828.    <div class="rich-text">
1829.      <p>
1830.        ☑ Reimplement <code>flags()</code><br>
1831.        For a valid index (and only in that case), add <code>Qt::ItemIsDropEnabled</code>. As you can see, you can also restrict drops to column 0, which can be more sensible when using <code>QTreeView</code> (the user should drop onto the folder name, not onto the folder size).
1832.      </p>
1833.      <p>
1834.        ☑ Reimplement <code>supportedDropActions()</code> to return <code>Qt::MoveAction | Qt::CopyAction</code> or whichever you want to support (the default is CopyAction only).
1835.      </p>
1836.      <p>
1837.        ☑ Reimplement <code>mimeTypes()</code> - the list should include the MIME type used by the drag model.
1838.      </p>
1839.      <p>
1840.        ☑ Reimplement <code>dropMimeData()</code><br>
1841.        to deserialize the data and handle the drop.<br>
1842.        This could mean calling <code>setData()</code> to replace item contents, or anything else that should happen on a drop: in the email example, this is where we copy or move the email into the destination folder. Once you're done, return true, so that the drag side then deletes the dragged rows by calling <code>removeRows()</code> on its model.
1843.      </p>
1844.    </div>
1845.    <div class="formatted-code">
1846.      <pre><code class="language-cpp line-numbers">bool FoldersModel::dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column, const QModelIndex &parent)
1847. {
1848.    ~~~  // safety checks, see full example code
1849.  
1850.    EmailFolder *destFolder = folderForIndex(parent);
1851.  
1852.    const QByteArray encodedData = mimeData->data(s_emailsMimeType);
1853.    QDataStream stream(encodedData);
1854.    ~~~ // code to detect and reject dropping onto the folder currently holding those emails
1855.  
1856.    while (!stream.atEnd()) {
1857.        QString email;
1858.        stream >> email;
1859.        destFolder->emails.append(email);
1860.    }
1861.    emit dataChanged(parent, parent); // update count
1862.  
1863.    return true; // let the view handle deletion on the source side by calling removeRows there
1864. }</code></pre>
1865.    </div>
1866.    <div class="rich-text">
1867.      <h2>
1868.        Using item widgets
1869.      </h2>
1870.      <p>
1871.        Example code:
1872.      </p>
1873.      <ul>
1874.        <li>
1875.          <a href="https://github.com/KDABLabs/blogs-qt/blob/main/ItemViews-DragAndDrop/part3-dropping-onto-items/qlistwidget/drop-onto-qlistwidgetitems.cpp" rel="noopener noreferrer" target="_blank">QListWidget</a>
1876.        </li>
1877.        <li>
1878.          <a href="https://github.com/KDABLabs/blogs-qt/blob/main/ItemViews-DragAndDrop/part3-dropping-onto-items/qtablewidget/drop-onto-qtablewidgetitems.cpp" rel="noopener noreferrer" target="_blank">QTableWidget</a>
1879.        </li>
1880.        <li>
1881.          <a href="https://github.com/KDABLabs/blogs-qt/blob/main/ItemViews-DragAndDrop/part3-dropping-onto-items/qtreewidget/drop-onto-qtreewidgetitems.cpp" rel="noopener noreferrer" target="_blank">QTreeWidget</a>
1882.        </li>
1883.      </ul>
1884.      <h3>
1885.        On the "drag" side
1886.      </h3>
1887.      <p>
1888.        ☑ Call <code>widget->setDragDropMode(QAbstractItemView::DragOnly)</code> or <code>DragDrop</code> if it should support both
1889.      </p>
1890.      <p>
1891.        ☑ Call <code>widget->setDefaultDropAction(Qt::MoveAction)</code> so that the drag defaults to a move and not a copy, adjust as needed
1892.      </p>
1893.      <p>
1894.        ☑ Reimplement <code>Widget::mimeData()</code> to serialize the complete data for the dragged items. If the views are always in the same process, you can get away with serializing only item pointers and application PID (to refuse dropping onto another process). In our email folders example we also serialize the pointer to the source folder (where the emails come from) so that we can detect dropping onto the same folder (which should do nothing).
1895.      </p>
1896.      <p>
1897.        To serialize pointers in QDataStream, cast them to quintptr, see the <a href="https://github.com/KDABLabs/blogs-qt/blob/main/ItemViews-DragAndDrop/part3-dropping-onto-items/qlistwidget/drop-onto-qlistwidgetitems.cpp#L58" rel="noopener noreferrer" target="_blank">example code</a> for details.
1898.      </p>
1899.      <h3>
1900.        On the "drop" side
1901.      </h3>
1902.      <p>
1903.        ☑ Call <code>widget->setDragDropMode(QAbstractItemView::DropOnly)</code> or <code>DragDrop</code> if it should support both
1904.      </p>
1905.      <p>
1906.        ☑ Call <code>widget->setDragDropOverwriteMode(true)</code> for a minor improvement: no forbidden cursor when moving the drag between folders. Instead Qt only computes drop positions which are onto items, as we want here.
1907.      </p>
1908.      <p>
1909.        ☑ Reimplement <code>Widget::mimeTypes()</code> and return the same name as the one used on the drag side's <code>mimeData</code>
1910.      </p>
1911.      <p>
1912.        ☑ Reimplement <code>Widget::dropMimeData()</code> (note that the signature is different between <code>QListWidget</code>, <code>QTableWidget</code> and <code>QTreeWidget</code>) This is where you deserialize the data and handle the drop. In the email example, this is where we copy or move the email into the destination folder.
1913.      </p>
1914.      <p>
1915.        Make sure to do all of the following:
1916.      </p>
1917.      <ul>
1918.        <li>any necessary behind the scenes work (in our case, moving the actual email)
1919.        </li>
1920.        <li>updating the UI (creating or deleting items as needed)
1921.        </li>
1922.      </ul>
1923.      <p>
1924.        This is a case where proper model/view separation is actually much simpler.
1925.      </p>
1926.      <h2>
1927.        Improvements to Qt
1928.      </h2>
1929.      <p>
1930.        While writing and testing these code examples, I improved the following things in Qt, in addition to those listed in the previous blog posts:
1931.      </p>
1932.      <ul>
1933.        <li>
1934.          <a href="https://bugreports.qt.io/browse/QTBUG-2553" rel="noopener noreferrer" target="_blank">QTBUG-2553</a> QTreeView with setAutoExpandDelay() collapses items while dragging over it, fixed in Qt 6.8.1
1935.        </li>
1936.      </ul>
1937.      <h2>
1938.        Conclusion
1939.      </h2>
1940.      <p>
1941.        I hope you enjoyed this blog post series and learned a few things.
1942.      </p>
1943.    </div>
1944.    <p>
1945.      The post <a href="https://www.kdab.com/modelview-drag-and-drop-in-qt-part-3/">Model/View Drag and Drop in Qt - Part 3</a> appeared first on <a href="https://www.kdab.com">KDAB</a>.
1946.    &lt;/p&gt;</description>
1947.    </item>
1948.    <item>
1949.      <guid isPermaLink="false">https://www.ics.com/4963 at https://www.ics.com</guid>
1950.      <title>ICS Insights: Qt and QML: Still on Qt 5? Time is Running Out!</title>
1951.      <pubDate>Fri, 28 Mar 2025 15:58:37 GMT</pubDate>
1952.      <link>https://www.ics.com/blog/still-qt-5-time-running-out</link>
1953.      <description>&lt;p&gt;
1954.      Standard support for Qt 5 will end in May. Time is running out to port your code!
1955.    &lt;/p&gt;</description>
1956.    </item>
1957.    <item>
1958.      <guid isPermaLink="false">https://scythe-studio.com/en/blog/qt-gui-on-stm32-building-efficient-embedded-applications</guid>
1959.      <title>Scythe Studio Qt Blog: Qt GUI on STM32: Building Efficient Embedded Applications</title>
1960.      <pubDate>Thu, 13 Mar 2025 12:19:25 GMT</pubDate>
1961.      <link>https://scythe-studio.com/en/blog/qt-gui-on-stm32-building-efficient-embedded-applications</link>
1962.      <description>&lt;p&gt;
1963.      Products from the STM32 family have been a popular target for embedded Qt applications for quite a long time. One […]
1964.    &lt;/p&gt;</description>
1965.    </item>
1966.    <item>
1967.      <guid isPermaLink="false">https://www.kdab.com/modelview-drag-and-drop-in-qt-part-2/</guid>
1968.      <title>KDAB on Qt: Model/View Drag and Drop in Qt - Part 2</title>
1969.      <pubDate>Mon, 10 Mar 2025 08:19:00 GMT</pubDate>
1970.      <link>https://www.kdab.com/modelview-drag-and-drop-in-qt-part-2/</link>
1971.      <description>&lt;h1&gt;
1972.      Model/View Drag and Drop in Qt - Part 2
1973.    </h1>
1974.    <div class="rich-text">
1975.      <p>
1976.        In the <a href="https://www.kdab.com/modelview-drag-and-drop-part-1/">previous blog</a>, you learned all about moving items within a single view, to reorder them.
1977.      </p>
1978.      <p>
1979.        In part 2, we are still talking about moving items, and still about inserting them between existing items (never overwriting items) but this time the user can move items from one view to another. A typical use case is a list of available items on the left, and a list of selected items on the right (one concrete example would be to let the user customize which buttons should appear in a toolbar). This also often includes reordering items in the right-side list, the good news being that this comes for free (no extra code needed).
1980.      </p>
1981.    </div>
1982.    <div class="image-variable-size-block">
1983.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
1984.        <div class="image-variable-size-image">
1985.          <img alt="Blog_Drag&Drop_Qt_part2-step1" class="Blog_Drag&Drop_Qt_part2-step1" id="Blog_Drag&Drop_Qt_part2-step1" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/Blog_DragDrop_Qt_part2-step1.original.png" name="Blog_Drag&Drop_Qt_part2-step1">
1986.        </div>
1987.        <div class="image-variable-size-caption text-center">
1988.          <div class="rich-text">
1989.            <p>
1990.              Moving a row between treeviews, step 1
1991.            </p>
1992.          </div>
1993.        </div>
1994.      </div>
1995.    </div>
1996.    <div class="image-variable-size-block">
1997.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
1998.        <div class="image-variable-size-image">
1999.          <img alt="Blog_Drag&Drop_Qt_part2-step2" class="Blog_Drag&Drop_Qt_part2-step2" id="Blog_Drag&Drop_Qt_part2-step2" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/Blog_DragDrop_Qt_part2-step2.original.png" name="Blog_Drag&Drop_Qt_part2-step2">
2000.        </div>
2001.        <div class="image-variable-size-caption text-center">
2002.          <div class="rich-text">
2003.            <p>
2004.              Moving a row between treeviews, step 2
2005.            </p>
2006.          </div>
2007.        </div>
2008.      </div>
2009.    </div>
2010.    <div class="image-variable-size-block">
2011.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
2012.        <div class="image-variable-size-image">
2013.          <img alt="Blog_Drag&Drop_Qt_part2-step3" class="Blog_Drag&Drop_Qt_part2-step3" id="Blog_Drag&Drop_Qt_part2-step3" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/Blog_DragDrop_Qt_part2-step3.original.png" name="Blog_Drag&Drop_Qt_part2-step3">
2014.        </div>
2015.        <div class="image-variable-size-caption text-center">
2016.          <div class="rich-text">
2017.            <p>
2018.              Moving a row between treeviews, step 3
2019.            </p>
2020.          </div>
2021.        </div>
2022.      </div>
2023.    </div>
2024.    <div class="rich-text">
2025.      <h2>
2026.        With Model/View separation
2027.      </h2>
2028.      <p>
2029.        <a href="https://github.com/KDABLabs/blogs-qt/tree/main/ItemViews-DragAndDrop/part2-moving-items-between-views/model-view" rel="noopener noreferrer" target="_blank">Example code</a> for flat models and <a href="https://github.com/KDABLabs/blogs-qt/tree/main/ItemViews-DragAndDrop/part2-moving-items-between-views/treemodel" rel="noopener noreferrer" target="_blank">example code</a> for tree models.
2030.      </p>
2031.      <h3>
2032.        Setting up the view on the drag side
2033.      </h3>
2034.      <p>
2035.        To allow dragging items out of the view, make sure to do the following:
2036.      </p>
2037.      <p>
2038.        ☑ Call <code>view->setDragDropMode(QAbstractItemView::DragOnly)</code> (or <code>DragDrop</code> if it should support both).
2039.      </p>
2040.      <p>
2041.        ☑ Call <code>view->setDragDropOverwriteMode(false)</code> so that <code>QTableView</code> calls removeRows when moving rows, rather than just clearing their cells
2042.      </p>
2043.      <p>
2044.        ☑ Call <code>view->setDefaultDropAction(Qt::MoveAction)</code> so it's a move and not a copy
2045.      </p>
2046.      <h3>
2047.        Setting up the model on the drag side
2048.      </h3>
2049.      <p>
2050.        To implement dragging items out of a model, you need to implement the following:
2051.      </p>
2052.    </div>
2053.    <div class="formatted-code">
2054.      <pre><code class="language-cpp line-numbers">class CountryModel : public QAbstractTableModel
2055. {
2056.    ~~~
2057.    Qt::ItemFlags flags(const QModelIndex &index) const override
2058.    {
2059.        if (!index.isValid())
2060.            return {}; // depending on whether you want drops as well (next section)
2061.        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
2062.    }
2063.  
2064.    // the default is "return supportedDropActions()", let's be explicit
2065.    Qt::DropActions supportedDragActions() const override { return Qt::MoveAction; }
2066.  
2067.    QMimeData *mimeData(const QModelIndexList &indexes) const override; // see below
2068.  
2069.    bool removeRows(int position, int rows, const QModelIndex &parent) override; // see below
2070. };</code></pre>
2071.    </div>
2072.    <div class="rich-text">
2073.      <p>
2074.        More precisely, the check-list is the following:
2075.      </p>
2076.      <p>
2077.        ☑ Reimplement <code>flags()</code> to add <code>Qt::ItemIsDragEnabled</code> in the case of a valid index
2078.      </p>
2079.      <p>
2080.        ☑ Reimplement <code>supportedDragActions()</code> to return <code>Qt::MoveAction</code>
2081.      </p>
2082.      <p>
2083.        ☑ Reimplement <code>mimeData()</code> to serialize the complete data for the dragged items. If the views are always in the same process, you can get away with serializing only node pointers (if you have that, e.g. for tree models) and application PID (to refuse dropping onto another process). Otherwise you can encode the actual data, like this:
2084.      </p>
2085.    </div>
2086.    <div class="formatted-code">
2087.      <pre><code class="language-cpp line-numbers">QMimeData *CountryModel::mimeData(const QModelIndexList &indexes) const
2088. {
2089.    QByteArray encodedData;
2090.    QDataStream stream(&encodedData, QIODevice::WriteOnly);
2091.    for (const QModelIndex &index : indexes) {
2092.        // This calls operator<<(QDataStream &stream, const CountryData &countryData), which you must implement
2093.        stream << m_data.at(index.row());
2094.    }
2095.  
2096.    QMimeData *mimeData = new QMimeData;
2097.    mimeData->setData(s_mimeType, encodedData);
2098.    return mimeData;
2099. }</code></pre>
2100.    </div>
2101.    <div class="rich-text">
2102.      <p>
2103.        <code>s_mimeType</code> is the name of the type of data (make up a name, it usually starts with <code>application/x-</code>)
2104.      </p>
2105.      <p>
2106.        ☑ Reimplement <code>removeRows()</code>, it will be called after a successful drop. For instance, if your data is in a vector called <code>m_data</code>, the implementation would look like this:
2107.      </p>
2108.    </div>
2109.    <div class="formatted-code">
2110.      <pre><code class="language-cpp line-numbers">bool CountryModel::removeRows(int position, int rows, const QModelIndex &parent)
2111. {
2112.    beginRemoveRows(parent, position, position + rows - 1);
2113.    for (int row = 0; row < rows; ++row)
2114.        m_data.removeAt(position);
2115.    endRemoveRows();
2116.    return true;
2117. }</code></pre>
2118.    </div>
2119.    <div class="rich-text">
2120.      <h3>
2121.        Setting up the view on the drop side
2122.      </h3>
2123.      <p>
2124.        ☑ Call <code>view->setDragDropMode(QAbstractItemView::DragDrop)</code> (already done if both views should support dragging and dropping)
2125.      </p>
2126.      <h3>
2127.        Setting up the model on the drop side
2128.      </h3>
2129.      <p>
2130.        To implement dropping items into a model (between existing items), you need to implement the following:
2131.      </p>
2132.    </div>
2133.    <div class="formatted-code">
2134.      <pre><code class="language-cpp line-numbers">class DropModel : public QAbstractTableModel
2135. {
2136.    ~~~
2137.    Qt::ItemFlags flags(const QModelIndex &index) const override
2138.    {
2139.        if (!index.isValid())
2140.            return Qt::ItemIsDropEnabled;
2141.        return Qt::ItemIsEnabled | Qt::ItemIsSelectable; // and optionally Qt::ItemIsDragEnabled (previous section)
2142.    }
2143.  
2144.    // the default is "copy only", change it
2145.    Qt::DropActions supportedDropActions() const override { return Qt::MoveAction; }
2146.  
2147.    QStringList mimeTypes() const override { return {QString::fromLatin1(s_mimeType)}; }
2148.  
2149.    bool dropMimeData(const QMimeData *mimeData, Qt::DropAction action,
2150.                      int row, int column, const QModelIndex &parent) override; // see below
2151. };</code></pre>
2152.    </div>
2153.    <div class="rich-text">
2154.      <p>
2155.        ☑ Reimplement <code>supportedDropActions()</code> to return <code>Qt::MoveAction</code>
2156.      </p>
2157.      <p>
2158.        ☑ Reimplement <code>flags()</code><br>
2159.        For a valid index, make sure <code>Qt::ItemIsDropEnabled</code> is NOT set (except for tree models where we need to drop onto items in order to insert a first child).<br>
2160.        For the invalid index, add <code>Qt::ItemIsDropEnabled</code>, to allow dropping between items.
2161.      </p>
2162.      <p>
2163.        ☑ Reimplement <code>mimeTypes()</code> and return the name of the MIME type used by the <code>mimeData()</code> function on the drag side.
2164.      </p>
2165.      <p>
2166.        ☑ Reimplement <code>dropMimeData()</code><br>
2167.        to deserialize the data and insert new rows.<br>
2168.        In the special case of in-process tree models, clone the dragged nodes.<br>
2169.        In both cases, once you're done, return true, so that the drag side then deletes the dragged rows by calling <code>removeRows()</code> on its model.
2170.      </p>
2171.    </div>
2172.    <div class="formatted-code">
2173.      <pre><code class="language-cpp line-numbers">bool DropModel::dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column, const QModelIndex &parent)
2174. {
2175.    ~~~  // safety checks, see full example code
2176.  
2177.    if (row == -1) // drop into empty area = append
2178.        row = rowCount(parent);
2179.  
2180.    // decode data
2181.    const QByteArray encodedData = mimeData->data(s_mimeType);
2182.    QDataStream stream(encodedData);
2183.    QVector<CountryData> newCountries;
2184.    while (!stream.atEnd()) {
2185.        CountryData countryData;
2186.        stream >> countryData;
2187.        newCountries.append(countryData);
2188.    }
2189.  
2190.    // insert new countries
2191.    beginInsertRows(parent, row, row + newCountries.count() - 1);
2192.    for (const CountryData &countryData : newCountries)
2193.        m_data.insert(row++, countryData);
2194.    endInsertRows();
2195.  
2196.    return true; // let the view handle deletion on the source side by calling removeRows there
2197. }</code></pre>
2198.    </div>
2199.    <div class="rich-text">
2200.      <h2>
2201.        Using item widgets
2202.      </h2>
2203.      <p>
2204.        <a href="https://github.com/KDABLabs/blogs-qt/tree/main/ItemViews-DragAndDrop/part2-moving-items-between-views/itemwidgets" rel="noopener noreferrer" target="_blank">Example code</a> can be found following this link.
2205.      </p>
2206.      <h3>
2207.        For all kinds of widgets
2208.      </h3>
2209.      <p>
2210.        On the "drag" side:
2211.      </p>
2212.      <p>
2213.        ☑ Call <code>widget->setDragDropMode(QAbstractItemView::DragOnly)</code> or <code>DragDrop</code> if it should support both
2214.      </p>
2215.      <p>
2216.        ☑ Call <code>widget->setDefaultDropAction(Qt::MoveAction)</code> so the drag starts as a move right away
2217.      </p>
2218.      <p>
2219.        On the "drop" side:
2220.      </p>
2221.      <p>
2222.        ☑ Call <code>widget->setDragDropMode(QAbstractItemView::DropOnly)</code> or <code>DragDrop</code> if it should support both
2223.      </p>
2224.      <p>
2225.        ☑ Reimplement <code>supportedDropActions()</code> to return only <code>Qt::MoveAction</code>
2226.      </p>
2227.      <h3>
2228.        Additional requirements for QTableWidget
2229.      </h3>
2230.      <p>
2231.        When using <code>QTableWidget</code>, in addition to the common steps above you need to:
2232.      </p>
2233.      <p>
2234.        On the "drag" side:
2235.      </p>
2236.      <p>
2237.        ☑ Call <code>item->setFlags(item->flags() & ~Qt::ItemIsDropEnabled);</code> for each item, to disable dropping onto items.
2238.      </p>
2239.      <p>
2240.        ☑ Call <code>widget->setDragDropOverwriteMode(false)</code> so that after a move the rows are removed rather than cleared
2241.      </p>
2242.      <p>
2243.        On the "drop" side:
2244.      </p>
2245.      <p>
2246.        ☑ Call <code>widget->setDragDropOverwriteMode(false)</code> so that it inserts rows instead of replacing cells (the default is <code>false</code> for the other views anyway)
2247.      </p>
2248.      <p>
2249.        ☑ Another problem is that the items created by a drop will automatically get the <code>Qt::ItemIsDropEnabled</code> flag, which you don't want. To solve this, use <code>widget->setItemPrototype()</code> with an item that has the right flags (see the example).
2250.      </p>
2251.      <h3>
2252.        Additional requirements for QTreeWidget
2253.      </h3>
2254.      <p>
2255.        When using <code>QTreeWidget</code>, you cannot disable dropping onto items (which creates a child of the item).
2256.      </p>
2257.      <p>
2258.        You could call <code>item->setFlags(item->flags() & ~Qt::ItemIsDropEnabled);</code> on your own items, but when <code>QTreeWidget</code> creates new items upon a drop, you cannot prevent them from having the flag <code>Qt::ItemIsDropEnabled</code> set. The prototype solution used above for <code>QTableWidget</code> doesn't exist for <code>QTreeWidget</code>.
2259.      </p>
2260.      <p>
2261.        This means, if you want to let the user build and reorganize an actual tree, you can use <code>QTreeWidget</code>. But if you just want a flat multi-column list, then you should use <code>QTreeView</code> (see previous section on model/view separation).
2262.      </p>
2263.      <h2>
2264.        Addendum: Move/copy items between views
2265.      </h2>
2266.      <p>
2267.        If the user should be able to choose between copying and moving items, follow the previous section and make the following changes.
2268.      </p>
2269.      <h3>
2270.        With Model/View separation
2271.      </h3>
2272.      <p>
2273.        On the "drag" side:
2274.      </p>
2275.      <p>
2276.        ☑ Call <code>view->setDefaultDropAction(...)</code> to choose whether the default should be move or copy. The user can press Shift to force a move, and Ctrl to force a copy.
2277.      </p>
2278.      <p>
2279.        ☑ Reimplement <code>supportedDragActions()</code> in the model to return <code>Qt::MoveAction | Qt::CopyAction</code>
2280.      </p>
2281.      <p>
2282.        On the "drop" side:
2283.      </p>
2284.      <p>
2285.        ☑ Reimplement <code>supportedDropActions()</code> in the model to return <code>Qt::MoveAction | Qt::CopyAction</code>
2286.      </p>
2287.      <p>
2288.        The good news is that there's nothing else to do.
2289.      </p>
2290.      <h3>
2291.        Using item widgets
2292.      </h3>
2293.      <p>
2294.        On the "drag" side:
2295.      </p>
2296.      <p>
2297.        ☑ Call <code>widget->setDefaultDropAction(...)</code> to choose whether the default should be move or copy. The user can press Shift to force a move, and Ctrl to force a copy.
2298.      </p>
2299.      <p>
2300.        Until Qt 6.10 there was no <code>setSupportedDragActions()</code> method in the item widget classes (that was <a href="https://bugreports.qt.io/browse/QTBUG-87465" rel="noopener noreferrer" target="_blank">QTBUG-87465</a>, I implemented it for 6.10). Fortunately the default behavior is to use what <code>supportedDropActions()</code> returns so if you just want move and copy in both, reimplementing <code>supportedDropActions()</code> is enough.
2301.      </p>
2302.      <p>
2303.        On the "drop" side:
2304.      </p>
2305.      <p>
2306.        ☑ Reimplement <code>supportedDropActions()</code> in the item widget class to return <code>Qt::MoveAction | Qt::CopyAction</code>
2307.      </p>
2308.      <p>
2309.        The good news is that there's nothing else to do.
2310.      </p>
2311.      <h3>
2312.        Improvements to Qt
2313.      </h3>
2314.      <p>
2315.        While writing and testing these code examples, I improved the following things in Qt:
2316.      </p>
2317.      <ul>
2318.        <li>
2319.          <a href="https://bugreports.qt.io/browse/QTBUG-1387" rel="noopener noreferrer" target="_blank">QTBUG-1387</a> "Drag and drop multiple columns with item views. Dragging a row and dropping it in a column > 0 creates multiple rows.", fixed in 6.8.1
2320.        </li>
2321.        <li>
2322.          <a href="https://bugreports.qt.io/browse/QTBUG-36831" rel="noopener noreferrer" target="_blank">QTBUG-36831</a> "Drop indicator painted as single pixel when not shown" fixed in 6.8.1
2323.        </li>
2324.        <li>
2325.          <a href="https://bugreports.qt.io/browse/QTBUG-87465" rel="noopener noreferrer" target="_blank">QTBUG-87465</a> ItemWidgets: add supportedDragActions()/setSupportedDragActions(), implemented in 6.10
2326.        </li>
2327.      </ul>
2328.      <h2>
2329.        Conclusion
2330.      </h2>
2331.      <p>
2332.        In the next blog post of this series, you will learn how to move (or copy) onto existing items, rather than between them.
2333.      </p>
2334.    </div>
2335.    <p>
2336.      The post <a href="https://www.kdab.com/modelview-drag-and-drop-in-qt-part-2/">Model/View Drag and Drop in Qt - Part 2</a> appeared first on <a href="https://www.kdab.com">KDAB</a>.
2337.    &lt;/p&gt;</description>
2338.    </item>
2339.    <item>
2340.      <guid isPermaLink="false">https://www.basyskom.de/?p=11713</guid>
2341.      <title>Qt &#x2013; basysKom GmbH: 3D Rendering Solutions in Qt &#x2013; an Overview</title>
2342.      <pubDate>Mon, 03 Mar 2025 13:45:22 GMT</pubDate>
2343.      <link>https://www.basyskom.de/3d-rendering-solutions-in-qt-an-overview/</link>
2344.      <description>&lt;p&gt;
2345.      <a href="https://www.basyskom.de/3d-rendering-solutions-in-qt-an-overview/"><img align="left" alt="3D Rendering Solutions in Qt – an Overview" height="150" src="https://www.basyskom.de/wp-content/uploads/2020/07/Qt_logo_space-01-01-300x150.png" style="margin: 0 20px 20px 0;" width="300"></a>
2346.    </p>
2347.    <p>
2348.      Qt’s 3D offering is changing, so we decided to look at different options for rendering 3D content in Qt.
2349.    </p>
2350.    <p>
2351.      <a href="https://www.basyskom.de/3d-rendering-solutions-in-qt-an-overview/" rel="nofollow">Continue reading 3D Rendering Solutions in Qt – an Overview at basysKom GmbH.</a>
2352.    &lt;/p&gt;</description>
2353.    </item>
2354.    <item>
2355.      <guid isPermaLink="false">https://scythe-studio.com/en/blog/qt-can-bus-example-how-to-start</guid>
2356.      <title>Scythe Studio Qt Blog: Qt CAN Bus Example &#x2013; How to start?</title>
2357.      <pubDate>Mon, 03 Mar 2025 12:08:21 GMT</pubDate>
2358.      <link>https://scythe-studio.com/en/blog/qt-can-bus-example-how-to-start</link>
2359.      <description>&lt;p&gt;
2360.      I welcome you to another blog post. The last one discussed a form of communication between devices using Qt Bluetooth Low […]
2361.    &lt;/p&gt;</description>
2362.    </item>
2363.    <item>
2364.      <guid isPermaLink="false">tag:www.pythonguis.com,2025-02-26:/faq/which-python-gui-library/</guid>
2365.      <title>Python GUIs - qt: Which Python GUI library should you use? &#x2014; Comparing the Python GUI libraries available in 2025</title>
2366.      <pubDate>Wed, 26 Feb 2025 06:00:00 GMT</pubDate>
2367.      <link>https://www.pythonguis.com/faq/which-python-gui-library/</link>
2368.      <description>&lt;p&gt;
2369.      Python is a popular programming used for everything from scripting routine tasks to building websites and performing complex data analysis. While you can accomplish a lot with command line tools, some tasks are better suited to graphical interfaces. You may also find yourself wanting to build a desktop front-end for an existing tool to improve usability for non-technical users. Or maybe you're building some hardware or a mobile app and want an intuitive touchscreen interface.
2370.    </p>
2371.    <p>
2372.      To create <em>graphical user interfaces</em> with Python, you need a GUI library. Unfortunately, at this point things get pretty confusing -- there are many different GUI libraries available for Python, all with different capabilities and licensing. <em>Which Python GUI library should you use for your project?</em>
2373.    </p>
2374.    <p>
2375.      In this article, we will look at a selection of the most popular Python GUI frameworks currently available and why you should consider using them for your own projects. You'll learn about the relative strengths of each library, understand the licensing limitations and see a simple <em>Hello, World!</em> application written in each. By the end of the article you should feel confident choosing the right library for your project.
2376.    </p>
2377.    <p class="admonition admonition-note">
2378.      <strong>tldr</strong> If you're looking to build professional quality software, start with PySide6 or PyQt6. The Qt framework is batteries-included — whatever your project, you'll be able to get it done. We have a complete <a href="https://www.pythonguis.com/pyside6-tutorial/">PySide6 tutorial</a> and <a href="https://www.pythonguis.com/pyqt6-tutorial/">PyQt6 tutorial</a>.
2379.    </p>
2380.    <p>
2381.      There is <em>some</em> bias here -- I have been working with Qt for about 10 years, writing books & developing commercial software. But I chose it and continue to use it because it's the best option for getting things done. That said, the other libraries all have their place & may be a better fit for your own project -- read on to find out!
2382.    </p>
2383.    <p class="admonition admonition-tip">
2384.      If you're looking for more demos to see what you can do with Python, we have a Github respository full of <a href="https://github.com/pythonguis/pythonguis-examples">Python GUI examples</a> to get you started.
2385.    </p>
2386.    <div class="toc">
2387.      <span class="toctitle">Table of Contents</span>
2388.      <ul>
2389.        <li>
2390.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#pyqt-or-pyside">PyQt or PySide</a>
2391.        </li>
2392.        <li>
2393.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#tkinter">Tkinter</a>
2394.        </li>
2395.        <li>
2396.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#kivy">Kivy</a>
2397.        </li>
2398.        <li>
2399.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#beeware-toga">BeeWare Toga</a>
2400.        </li>
2401.        <li>
2402.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#pyqtpyside-with-qml">PyQt/PySide with QML</a>
2403.        </li>
2404.        <li>
2405.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#pysimplegui">PySimpleGUI</a>
2406.        </li>
2407.        <li>
2408.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#wxpython">WxPython</a>
2409.        </li>
2410.        <li>
2411.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#pygobject-gtk">PyGObject (GTK+)</a>
2412.        </li>
2413.        <li>
2414.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#remi">Remi</a>
2415.        </li>
2416.        <li>
2417.          <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#conclusion">Conclusion</a>
2418.        </li>
2419.      </ul>
2420.    </div>
2421.    <h2 id="pyqt-or-pyside">
2422.      PyQt or PySide
2423.    </h2>
2424.    <p>
2425.      <em><strong>Best for</strong> commercial, multimedia, scientific or engineering desktop applications. Best all-rounder with batteries included.</em>
2426.    </p>
2427.    <p>
2428.      PyQt and PySide are wrappers around the Qt framework. They allow you to easily create modern interfaces that look right at home on any platform, including Windows, macOS, Linux and even Android. They also have solid tooling with the most notable being <em>Qt Creator</em>, which includes a WYSIWYG editor for designing GUI interfaces quickly and easily. Being backed by a commercial project means that you will find plenty of support and online learning resources to help you develop your application.
2429.    </p>
2430.    <p>
2431.      Qt (and by extension PyQt & PySide) is not just a GUI library, but a complete application development framework. In addition to standard UI elements, such as widgets and layouts, Qt provides MVC-like data-driven views (spreadsheets, tables), database interfaces & models, graph plotting, vector graphics visualization, multimedia playback, sound effects & playlists and built-in interfaces for hardware such as printing. The Qt signals and slots models allows large applications to be built from re-usable and isolated components.
2432.    </p>
2433.    <p>
2434.      While other toolkits can work great when building small & simple tools, Qt really comes into its own for building real <em>commercial-quality</em> applications where you will benefit from the pre-built components. This comes at the expense of a slight learning curve. However, for smaller projects Qt is not really any more complex than other libraries. Qt Widgets-based applications use platform native widgets to ensure they look and feel at home on Windows, macOS and Qt-based Linux desktops.
2435.    </p>
2436.    <p>
2437.      <strong>Installation</strong> <code>pip install pyqt6</code> or <code>pip install pyside6</code>
2438.    </p>
2439.    <p>
2440.      A simple <em>hello world</em> application in PyQt6, using the Qt Widgets API is shown below.
2441.    </p>
2442.    <div class="tabbed-area multicode">
2443.      <ul class="tabs">
2444.        <li class="tab-link current">PyQt6
2445.        </li>
2446.        <li class="tab-link">PySide6
2447.        </li>
2448.      </ul>
2449.      <div class="tab-content current code-block-outer" id="42fca544c9d4459b9ec3db768c87da19">
2450.        <div class="code-block">
2451.          <span class="code-block-language code-block-python">python</span>
2452.          <pre><code class="python">from PyQt6.QtWidgets import QMainWindow, QApplication, QPushButton
2453.  
2454. import sys
2455.  
2456.  
2457. class MainWindow(QMainWindow):
2458.    def __init__(self):
2459.        super().__init__()
2460.  
2461.        self.setWindowTitle("Hello World")
2462.  
2463.        button = QPushButton("My simple app.")
2464.        button.pressed.connect(self.close)
2465.  
2466.        self.setCentralWidget(button)
2467.        self.show()
2468.  
2469.  
2470. app = QApplication(sys.argv)
2471. w = MainWindow()
2472. app.exec()
2473. </code></pre>
2474.        </div>
2475.      </div>
2476.      <div class="tab-content code-block-outer" id="08f40e151e4b4c2ab296393f768a101c">
2477.        <div class="code-block">
2478.          <span class="code-block-language code-block-python">python</span>
2479.          <pre><code class="python">from PySide6.QtWidgets import QMainWindow, QApplication, QPushButton
2480.  
2481. import sys
2482.  
2483.  
2484. class MainWindow(QMainWindow):
2485.    def __init__(self):
2486.        super().__init__()
2487.  
2488.        self.setWindowTitle("Hello World")
2489.  
2490.        button = QPushButton("My simple app.")
2491.        button.pressed.connect(self.close)
2492.  
2493.        self.setCentralWidget(button)
2494.        self.show()
2495.  
2496.  
2497. app = QApplication(sys.argv)
2498. w = MainWindow()
2499. app.exec()
2500. </code></pre>
2501.        </div>
2502.      </div>
2503.    </div>
2504.    <p class="admonition admonition-tip">
2505.      As you can see, the code is almost identical between PyQt & PySide, so it's not something to be concerned about when you start developing with either: you can always migrate easily if you need to.
2506.    </p>
2507.    <p>
2508.      <img alt="PyQt6 Application Screenshot" height="346" src="https://www.pythonguis.com/static/faq/python-gui-libraries/pyqt6-windows.jpg" width="473"> <em>Hello world application built using PyQt6, running on Windows 11</em>
2509.    </p>
2510.    <p>
2511.      Before the Qt Company (under Nokia) released the officially supported PySide library in 2009, Riverbank Computing had released PyQt in 1998. The main difference between these two libraries is in <em>licensing</em>.
2512.    </p>
2513.    <ul>
2514.      <li>
2515.        <strong>PyQt</strong> The free-to-use version of PyQt is licensed under <strong>GNU General Public License (GPL) v3</strong>. This means that you must also license your applications with the GPL <em>unless</em> you purchase a commercial version
2516.      </li>
2517.      <li>
2518.        <strong>PySide</strong> is licensed under <strong>GNU Lesser General Public License (LGPL)</strong>. This means PySide may be used in your applications without any additional fee.
2519.      </li>
2520.    </ul>
2521.    <p>
2522.      Note that both these libraries are separate from Qt itself which also has a free-to-use, open source version and a paid, commercial version.
2523.    </p>
2524.    <p class="admonition admonition-tip">
2525.      For a more information see our article on <a href="https://www.pythonguis.com/faq/pyqt-vs-pyside/">PyQt vs PySide licensing</a>. <strong>tldr</strong> If you want to develop closed-source software without paying for a license, use PySide6.
2526.    </p>
2527.    <ul>
2528.      <li>
2529.        <p>
2530.          <strong>PySide6</strong>
2531.        </p>
2532.        <ul>
2533.          <li>
2534.            <a href="https://www.pythonguis.com/pyside6-book/">PySide6 Book</a>
2535.          </li>
2536.          <li>
2537.            <a href="https://www.pythonguis.com/pyside6-tutorial/">PySide6 Tutorial</a>
2538.          </li>
2539.          <li>
2540.            <a href="https://www.qt.io/qt-for-python">PySide Website</a>
2541.          </li>
2542.          <li>
2543.            <a href="https://doc.qt.io/qtforpython/">PySide Documentation</a>
2544.          </li>
2545.          <li>
2546.            <a href="https://github.com/PySide">GitHub Repository</a>
2547.          </li>
2548.        </ul>
2549.      </li>
2550.      <li>
2551.        <p>
2552.          <strong>PyQt6</strong>
2553.        </p>
2554.        <ul>
2555.          <li>
2556.            <a href="https://www.pythonguis.com/pyqt6-book/">PyQt6 Book</a>
2557.          </li>
2558.          <li>
2559.            <a href="https://www.pythonguis.com/pyqt6-tutorial/">PyQt6 Tutorial</a>
2560.          </li>
2561.          <li>
2562.            <a href="https://www.martinfitzpatrick.com/pyqt6-crash-course/">PyQt6 Video Course</a>
2563.          </li>
2564.          <li>
2565.            <a href="https://www.riverbankcomputing.com/software/pyqt/intro">PyQt Website</a>
2566.          </li>
2567.          <li>
2568.            <a href="https://www.riverbankcomputing.com/static/Docs/PyQt6/">PyQt6 Documentation</a>
2569.          </li>
2570.        </ul>
2571.      </li>
2572.      <li>
2573.        <p>
2574.          <strong>PyQt5</strong>
2575.        </p>
2576.        <ul>
2577.          <li>
2578.            <a href="https://www.pythonguis.com/pyqt5-book/">PyQt5 Book</a>
2579.          </li>
2580.          <li>
2581.            <a href="https://www.pythonguis.com/pyqt5-tutorial/">PyQt5 Tutorial</a>
2582.          </li>
2583.          <li>
2584.            <a href="https://www.riverbankcomputing.com/static/Docs/PyQt5/">PyQt6 Documentation</a>
2585.          </li>
2586.        </ul>
2587.      </li>
2588.    </ul>
2589.    <h2 id="tkinter">
2590.      Tkinter
2591.    </h2>
2592.    <p>
2593.      <em><strong>Best for</strong> simple portable Python GUIs and applications</em>
2594.    </p>
2595.    <p>
2596.      Tkinter is the defacto GUI framework for Python. It comes bundled with Python on both Windows and macOS. (On Linux, it may require downloading an additional package from your distribution's repo.) Tkinter is a wrapper written around the Tk GUI toolkit. Its name is an amalgamation of the words <em>Tk</em> and <em>Interface</em>.
2597.    </p>
2598.    <p>
2599.      Tkinter is a simple library with support for standard layouts and widgets, as well as more complex widgets such as tabbed views & progressbars. Tkinter is a pure GUI library, not a framework. There is no built-in support for GUIs driven from data sources, databases, or for displaying or manipulating multimedia or hardware. However, if you need to make something simple that doesn't require any additional dependencies, Tkinter may be what you are looking for. Tkinter is cross-platform however the widgets can look outdated, particularly on Windows.
2600.    </p>
2601.    <p>
2602.      <strong>Installation</strong> Already installed with Python on Windows and macOS. Ubuntu/Debian Linux <code>sudo apt install python3-tk</code>
2603.    </p>
2604.    <p>
2605.      A simple <em>hello world</em> application in Tkinter is shown below.
2606.    </p>
2607.    <div class="tabbed-area multicode">
2608.      <ul class="tabs">
2609.        <li class="tab-link current">Standard
2610.        </li>
2611.        <li class="tab-link">Class-based
2612.        </li>
2613.      </ul>
2614.      <div class="tab-content current code-block-outer" id="fbf57b37c3bd47a2888b7256f8d36d14">
2615.        <div class="code-block">
2616.          <span class="code-block-language code-block-python">python</span>
2617.          <pre><code class="python">import tkinter as tk
2618.  
2619. window = tk.Tk()
2620. window.title("Hello World")
2621.  
2622.  
2623. def handle_button_press(event):
2624.    window.destroy()
2625.  
2626.  
2627. button = tk.Button(text="My simple app.")
2628. button.bind("", handle_button_press)
2629. button.pack()
2630.  
2631. # Start the event loop.
2632. window.mainloop()
2633. </code></pre>
2634.        </div>
2635.      </div>
2636.      <div class="tab-content code-block-outer" id="2cc5e90450ee48d0871bbbff559d5f3d">
2637.        <div class="code-block">
2638.          <span class="code-block-language code-block-python">python</span>
2639.          <pre><code class="python">from tkinter import Tk, Button
2640.  
2641.  
2642. class Window(Tk):
2643.    def __init__(self):
2644.        super().__init__()
2645.  
2646.        self.title("Hello World")
2647.  
2648.        self.button = Button(text="My simple app.")
2649.        self.button.bind("", self.handle_button_press)
2650.        self.button.pack()
2651.  
2652.    def handle_button_press(self, event):
2653.        self.destroy()
2654.  
2655.  
2656. # Start the event loop.
2657. window = Window()
2658. window.mainloop()
2659. </code></pre>
2660.        </div>
2661.      </div>
2662.    </div>
2663.    <p>
2664.      <img alt="Tkinter Application Screenshot" height="218" src="https://www.pythonguis.com/static/faq/python-gui-libraries/tkinter-windows.jpg" width="387"> <em>Hello world application built using Tkinter, running on Windows 11</em>
2665.    </p>
2666.    <p>
2667.      Tkinter was originally developed by Steen Lumholt and Guido Van Rossum, who designed Python itself. Both the GUI framework and the language are licensed under the same Python Software Foundation (PSF) License. While the license is compatible with the GPL, it is a 'permissive' license (similar to the MIT License) that allows it to be used for proprietary applications and modifications.
2668.    </p>
2669.    <ul>
2670.      <li>
2671.        <a href="https://www.pythonguis.com/tkinter/">Tkinter tutorial</a>
2672.      </li>
2673.      <li>
2674.        <a href="https://docs.python.org/3/library/tkinter.html">Tkinter Documentation</a>
2675.      </li>
2676.    </ul>
2677.    <h2 id="kivy">
2678.      Kivy
2679.    </h2>
2680.    <p>
2681.      <em><strong>Best for</strong> Python mobile app development</em>
2682.    </p>
2683.    <p>
2684.      While most other GUI frameworks are <em>bindings</em> to toolkits written in other programming languages, Kivy is perhaps the only framework which is primarily written in pure Python. If you want to create touchscreen-oriented interfaces with a focus on mobile platforms such as Android and iOS, this is the way to go. This does run on desktop platforms (Windows, macOS, Linux) as well but note that your application may not look and behave like a <em>native application</em>. However, there is a pretty large community around this framework and you can easily find resources to help you learn it online.
2685.    </p>
2686.    <p>
2687.      The look and feel of Kivy is extremely customizable, allowing it to be used as an alternative to libraries like Pygame (for making games with Python). The developers have also released a number of separate libraries for Kivy. Some provide Kivy with better integration and access to certain platform-specific features, or help package your application for distribution on platforms like Android and iOS. Kivy has it's own design language called Kv, which is similar to QML for Qt. It allows you to easily separate the interface design from your application's logic.
2688.    </p>
2689.    <p class="admonition admonition-tip">
2690.      There is a 3rd party add-on for Kivy named KivyMD that replaces Kivy's widgets with ones that are compliant with Google's Material Design.
2691.    </p>
2692.    <p>
2693.      A simple <em>hello world</em> application in Kivy is shown below.
2694.    </p>
2695.    <p>
2696.      <strong>Installation</strong> <code>pip install kivy</code>
2697.    </p>
2698.    <p>
2699.      A simple <em>hello world</em> application in Kivy is shown below.
2700.    </p>
2701.    <div class="code-block">
2702.      <span class="code-block-language code-block-python">python</span>
2703.      <pre><code class="python">from kivy.app import App
2704. from kivy.uix.boxlayout import BoxLayout
2705. from kivy.uix.button import Button
2706. from kivy.core.window import Window
2707.  
2708. Window.size = (300, 200)
2709.  
2710.  
2711. class MainWindow(BoxLayout):
2712.    def __init__(self):
2713.        super().__init__()
2714.        self.button = Button(text="Hello, World?")
2715.        self.button.bind(on_press=self.handle_button_clicked)
2716.  
2717.        self.add_widget(button)
2718.  
2719.    def handle_button_clicked(self, event):
2720.        self.button.text = "Hello, World!"
2721.  
2722.  
2723. class MyApp(App):
2724.    def build(self):
2725.        self.title = "Hello, World!"
2726.        return MainWindow()
2727.  
2728.  
2729. app = MyApp()
2730. app.run()
2731. </code></pre>
2732.    </div>
2733.    <p>
2734.      <img alt="Kivy Application Screenshot" height="466" src="https://www.pythonguis.com/static/faq/python-gui-libraries/kivy-windows.jpg" width="608"> <em>Hello world application built using Kivy, running on Windows 11</em>
2735.    </p>
2736.    <p>
2737.      An equivalent application built using the Kv declarative language is shown below.
2738.    </p>
2739.    <div class="tabbed-area multicode">
2740.      <ul class="tabs">
2741.        <li class="tab-link current">main.py
2742.        </li>
2743.        <li class="tab-link">controller.kv
2744.        </li>
2745.      </ul>
2746.      <div class="tab-content current code-block-outer" id="1f4204d642f64a669940de30539cc9f7">
2747.        <div class="code-block">
2748.          <span class="code-block-language code-block-python">python</span>
2749.          <pre><code class="python">import kivy
2750. kivy.require('1.0.5')
2751.  
2752. from kivy.uix.floatlayout import FloatLayout
2753. from kivy.app import App
2754. from kivy.properties import ObjectProperty, StringProperty
2755.  
2756.  
2757. class Controller(FloatLayout):
2758.    '''Create a controller that receives a custom widget from the kv lang file.
2759.  
2760.    Add an action to be called from the kv lang file.
2761.    '''
2762.    def button_pressed(self):
2763.        self.button_wid.text = 'Hello, World!'
2764.  
2765.  
2766. class ControllerApp(App):
2767.  
2768.    def build(self):
2769.        return Controller()
2770.  
2771.  
2772. if __name__ == '__main__':
2773.    ControllerApp().run()
2774. </code></pre>
2775.        </div>
2776.      </div>
2777.      <div class="tab-content code-block-outer" id="34fa2478bebd4144b3aef7cabc78d92c">
2778.        <div class="code-block">
2779.          <span class="code-block-language code-block-python">python</span>
2780.          <pre><code class="python">#:kivy 1.0
2781.  
2782. :
2783.    button_wid: custom_button
2784.  
2785.    BoxLayout:
2786.        orientation: 'vertical'
2787.        padding: 20
2788.  
2789.        Button:
2790.            id: custom_button
2791.            text: 'Hello, World?'
2792.            on_press: root.button_pressed()
2793. </code></pre>
2794.        </div>
2795.      </div>
2796.    </div>
2797.    <p class="admonition admonition-note">
2798.      The name of the Kv file <em>must</em> match the name of the class from the main application -- here <code>Controller</code> and <code>controller.kv</code>.
2799.    </p>
2800.    <p>
2801.      <img alt="Kivy Kv Application Screenshot" height="912" src="https://www.pythonguis.com/static/faq/python-gui-libraries/kivykv-windows.jpg" width="1131"> <em>Hello world application built using Kivy + Kv, running on Windows 11</em>
2802.    </p>
2803.    <p>
2804.      In February 2011, Kivy was released as the spiritual successor to a similar framework called <strong>PyMT</strong>. While they shared similar goals and was also led by the current core developers of Kivy, where Kivy differs is in its underlying design and a professional organization which actively develops and maintains it. Kivy is licensed under the MIT license, which is a 'permissive' license that allows you to use it freely in both open source and proprietary applications. As such, you are even allowed to make proprietary modifications to the framework itself.
2805.    </p>
2806.    <ul>
2807.      <li>
2808.        <a href="https://kivy.org">Kivy Website</a>
2809.      </li>
2810.      <li>
2811.        <a href="https://kivy.org/doc/stable/">Kivy Documentation</a>
2812.      </li>
2813.      <li>
2814.        <a href="https://github.com/kivy">GitHub Repository</a>
2815.      </li>
2816.      <li>
2817.        <a href="https://kivymd.readthedocs.io/en/latest/">KivyMD Documentation</a>
2818.      </li>
2819.      <li>
2820.        <a href="https://kivy.org/doc/stable/guide/lang.html">Kv language documentation</a>
2821.      </li>
2822.    </ul>
2823.    <h2 id="beeware-toga">
2824.      BeeWare Toga
2825.    </h2>
2826.    <p>
2827.      <em><strong>Best for</strong> simple cross-platform native GUI development</em>
2828.    </p>
2829.    <p>
2830.      BeeWare is a collection of tools and libraries which work together to help you write cross platform Python applications with <em>native</em> GUIs. That means, the applications you create use the OS-provided widgets and behaviors, appearing just like any other application despite being written in Python.
2831.    </p>
2832.    <p>
2833.      The BeeWare system includes -
2834.    </p>
2835.    <ul>
2836.      <li>
2837.        <strong>Toga</strong> a cross platform widget toolkit, which we'll demo below.
2838.      </li>
2839.      <li>
2840.        <strong>Briefcase</strong> a tool for packaging Python projects as distributable artefacts.
2841.      </li>
2842.      <li>Libraries for accessing platform-native APIs.
2843.      </li>
2844.      <li>Pre-compiled builds of Python for platforms where official Python installers aren't avaiable.
2845.      </li>
2846.    </ul>
2847.    <p>
2848.      <strong>Installation</strong> <code>pip install toga</code>
2849.    </p>
2850.    <p>
2851.      A simple <em>hello world</em> application using BeeWare/Toga is shown below.
2852.    </p>
2853.    <div class="code-block">
2854.      <span class="code-block-language code-block-python">python</span>
2855.      <pre><code class="python">import toga
2856. from toga.style import Pack
2857.  
2858.  
2859. class HelloWorld(toga.App):
2860.    def startup(self):
2861.        layout = toga.Box()
2862.  
2863.        self.button = toga.Button(
2864.            "Say Hello!",
2865.            on_press=self.say_hello,
2866.            style=Pack(margin=5),
2867.        )
2868.        layout.add(self.button)
2869.  
2870.        self.main_window = toga.MainWindow(title="Hello world!")
2871.        self.main_window.content = layout
2872.        self.main_window.show()
2873.  
2874.    def say_hello(self, source_widget):
2875.        # Receives the button that was clicked.
2876.        source_widget.text = "Hello, world!"
2877.  
2878.  
2879. app = HelloWorld(formal_name="Hello, world!", app_id="hello.world")
2880. app.main_loop()
2881.  
2882. </code></pre>
2883.    </div>
2884.    <p>
2885.      <img alt="Toga Application Screenshot" height="382" src="https://www.pythonguis.com/static/faq/python-gui-libraries/toga-windows.jpg" width="705"> <em>Hello world application built using BeeWare Toga, running on Windows 11</em>
2886.    </p>
2887.    <p>
2888.      BeeWare is developed by Russell Keith-Magee. It is licensed under the BSD 3-Clause "New" or "Revised" License. The above example is using a single Python file for simplicity, see the linked tutorial below to see how to set up an application using Briefcase for cross-platform deployment.
2889.    </p>
2890.    <ul>
2891.      <li>
2892.        <a href="https://docs.beeware.org/en/latest/">Toga tutorial</a>
2893.      </li>
2894.      <li>
2895.        <a href="https://beeware.org/">BeeWare Homepage</a>
2896.      </li>
2897.      <li>
2898.        <a href="https://github.com/beeware/toga">Toga Source Code</a>
2899.      </li>
2900.    </ul>
2901.    <h2 id="pyqtpyside-with-qml">
2902.      PyQt/PySide with QML
2903.    </h2>
2904.    <p>
2905.      <em><strong>Best for</strong> Raspberry Pi, microcontrollers, industrial and consumer electronics</em>
2906.    </p>
2907.    <p>
2908.      When using PyQt and PySide you actually have <em>two</em> options for building your GUIs. We've already introduced the Qt Widgets API which is well-suited for building desktop applications. But Qt also provides a <em>declarative</em> API in the form of Qt Quick/QML.
2909.    </p>
2910.    <p>
2911.      Using Qt Quick/QML you have access to the entire Qt framework for building your applications. Your UI consists of two parts: the Python code which handles the business logic and the QML which defines the structure and behavior of the UI itself. You can control the UI from Python, or use embedded Javascript code to handle events and animations.
2912.    </p>
2913.    <p>
2914.      Qt Quick/QML is ideally suited for building modern touchscreen interfaces for microcontrollers or device interfaces -- for example, building interfaces for microcontrollers like the Raspberry Pi. However you can also use it on desktop to build completely customized application experiences, like those you find in media player applications like Spotify, or to desktop games.
2915.    </p>
2916.    <p>
2917.      <strong>Installation</strong> <code>pip install pyqt6</code> or <code>pip install pyside6</code>
2918.    </p>
2919.    <p>
2920.      A simple <em>Hello World</em> app in PyQt6 with QML. Save the QML file in the same folder as the Python file, and run as normally.
2921.    </p>
2922.    <div class="tabbed-area multicode">
2923.      <ul class="tabs">
2924.        <li class="tab-link current">main.py
2925.        </li>
2926.        <li class="tab-link">main.qml
2927.        </li>
2928.      </ul>
2929.      <div class="tab-content current code-block-outer" id="52635e456b264461b2ada2a0e177dcd1">
2930.        <div class="code-block">
2931.          <span class="code-block-language code-block-python">python</span>
2932.          <pre><code class="python">import sys
2933.  
2934. from PyQt6.QtGui import QGuiApplication
2935. from PyQt6.QtQml import QQmlApplicationEngine
2936.  
2937.  
2938. app = QGuiApplication(sys.argv)
2939.  
2940. engine = QQmlApplicationEngine()
2941. engine.quit.connect(app.quit)
2942. engine.load('main.qml')
2943.  
2944. sys.exit(app.exec())
2945. </code></pre>
2946.        </div>
2947.      </div>
2948.      <div class="tab-content code-block-outer" id="41a504134b0e497594bdcf0b57a770ca">
2949.        <div class="code-block">
2950.          <span class="code-block-language code-block-qml">qml</span>
2951.          <pre><code class="qml">import QtQuick 2.15
2952. import QtQuick.Controls 2.15
2953.  
2954. ApplicationWindow {
2955.    visible: true
2956.    width: 600
2957.    height: 500
2958.    title: "HelloApp"
2959.  
2960.    Text {
2961.        anchors.centerIn: parent
2962.        text: "Hello World"
2963.        font.pixelSize: 24
2964.    }
2965.  
2966. }
2967. </code></pre>
2968.        </div>
2969.      </div>
2970.    </div>
2971.    <p>
2972.      Licensing for Qt Quick/QML applications is the same as for other PyQt/PySide apps.
2973.    </p>
2974.    <ul>
2975.      <li>
2976.        <p>
2977.          <strong>PyQt</strong>
2978.        </p>
2979.        <ul>
2980.          <li>
2981.            <a href="https://www.pythonguis.com/tutorials/qml-qtquick-python-application/">QML/PyQt5 Tutorial</a>
2982.          </li>
2983.          <li>
2984.            <a href="https://www.pythonguis.com/tutorials/pyqt6-qml-qtquick-python-application/">QML/PyQt6 Tutorial</a>
2985.          </li>
2986.          <li>
2987.            <a href="https://www.riverbankcomputing.com/software/pyqt/intro">PyQt Website</a>
2988.          </li>
2989.          <li>
2990.            <a href="https://www.riverbankcomputing.com/static/Docs/PyQt6/">PyQt6 Documentation</a>
2991.          </li>
2992.        </ul>
2993.      </li>
2994.      <li>
2995.        <p>
2996.          <strong>PySide</strong>
2997.        </p>
2998.        <ul>
2999.          <li>
3000.            <a href="https://www.pythonguis.com/tutorials/pyside-qml-qtquick-python-application/">QML/PySide2 Tutorial</a>
3001.          </li>
3002.          <li>
3003.            <a href="https://www.pythonguis.com/tutorials/pyside6-qml-qtquick-python-application/">QML/PySide6 Tutorial</a>
3004.          </li>
3005.          <li>
3006.            <a href="https://www.qt.io/qt-for-python">PySide Website</a>
3007.          </li>
3008.          <li>
3009.            <a href="https://doc.qt.io/qtforpython/">PySide Documentation</a>
3010.          </li>
3011.          <li>
3012.            <a href="https://github.com/PySide">GitHub Repository</a>
3013.          </li>
3014.        </ul>
3015.      </li>
3016.    </ul>
3017.    <p>
3018.      <img alt="PyQt6 QML Application Screenshot" height="861" src="https://www.pythonguis.com/static/faq/python-gui-libraries/pyqt6qml-windows.jpg" width="952"> <em>Hello world application built using PyQt6 & QML, running on Windows 11</em>
3019.    </p>
3020.    <h2 id="pysimplegui">
3021.      PySimpleGUI
3022.    </h2>
3023.    <p class="admonition admonition-warning">
3024.      PySimpleGUI is no longer being developed. We do not recommend it if you are starting a new project in 2025. Take a look at <a href="https://www.pythonguis.com/feeds/qt.tag.atom.xml#pyqt-or-pyside">PySide6</a> instead.
3025.    </p>
3026.    <p>
3027.      PySimpleGUI aims to simplify GUI application development for Python. It doesn't reinvent the wheel but provides a wrapper around other existing frameworks such as Tkinter, Qt (PySide 2), WxPython and Remi. By doing so, it lowers the barrier to creating a GUI but also allows you to easily migrate from one GUI framework to another by simply changing the import statement.
3028.    </p>
3029.    <p>
3030.      While there is a separate port of PySimpleGUI for each of these frameworks, the Tkinter version is considered the most feature complete. Wrapping other libraries comes at a cost however &#8212;</description>
3031.    </item>
3032.    <item>
3033.      <guid isPermaLink="false">https://www.basyskom.de/?p=11678</guid>
3034.      <title>Qt &#x2013; basysKom GmbH: PySide6, Qt for Python</title>
3035.      <pubDate>Thu, 13 Feb 2025 09:00:00 GMT</pubDate>
3036.      <link>https://www.basyskom.de/pyside6-qt-for-python/</link>
3037.      <description>&lt;p&gt;
3038.      <a href="https://www.basyskom.de/pyside6-qt-for-python/"><img align="left" alt="PySide6, Qt for Python" height="150" src="https://www.basyskom.de/wp-content/uploads/2020/07/Qt_logo_space-01-01-300x150.png" style="margin: 0 20px 20px 0;" width="300"></a>
3039.    </p>
3040.    <p>
3041.      In this article, we’re going to have a look at Qt for Python, how it integrates with Qt Creator, and why you might want to consider using it, too.
3042.    </p>
3043.    <p>
3044.      <a href="https://www.basyskom.de/pyside6-qt-for-python/" rel="nofollow">Continue reading PySide6, Qt for Python at basysKom GmbH.</a>
3045.    &lt;/p&gt;</description>
3046.    </item>
3047.    <item>
3048.      <guid isPermaLink="false">https://www.kdab.com/modelview-drag-and-drop-part-1/</guid>
3049.      <title>KDAB on Qt: Model/View Drag and Drop in Qt - Part 1</title>
3050.      <pubDate>Thu, 06 Feb 2025 08:07:00 GMT</pubDate>
3051.      <link>https://www.kdab.com/modelview-drag-and-drop-part-1/</link>
3052.      <description>&lt;h1&gt;
3053.      Model/View Drag and Drop in Qt - Part 1
3054.    </h1>
3055.    <div class="rich-text">
3056.      <p>
3057.        This blog series is all about implementing drag-and-drop in the Qt model/view framework. In addition to complete code examples, you'll find checklists that you can go through to make sure that you did not forget anything in your own implementation, when something isn't working as expected.
3058.      </p>
3059.      <p>
3060.        At first, we are going to look at Drag and Drop within a single view, to change the order of the items. The view can be a list, a table or a tree, there are very little differences in what you have to do.
3061.      </p>
3062.    </div>
3063.    <div class="image-variable-size-block">
3064.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3065.        <div class="image-variable-size-image">
3066.          <img alt="part1-table-step1" class="part1-table-step1" id="part1-table-step1" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-table-step1.original.png" name="part1-table-step1">
3067.        </div>
3068.        <div class="image-variable-size-caption text-center">
3069.          <div class="rich-text">
3070.            <p>
3071.              Moving a row in a tableview, step 1
3072.            </p>
3073.          </div>
3074.        </div>
3075.      </div>
3076.    </div>
3077.    <div class="image-variable-size-block">
3078.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3079.        <div class="image-variable-size-image">
3080.          <img alt="part1-table-step2" class="part1-table-step2" id="part1-table-step2" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-table-step2.original.png" name="part1-table-step2">
3081.        </div>
3082.        <div class="image-variable-size-caption text-center">
3083.          <div class="rich-text">
3084.            <p>
3085.              Moving a row in a tableview, step 2
3086.            </p>
3087.          </div>
3088.        </div>
3089.      </div>
3090.    </div>
3091.    <div class="image-variable-size-block">
3092.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3093.        <div class="image-variable-size-image">
3094.          <img alt="part1-table-step3" class="part1-table-step3" id="part1-table-step3" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-table-step3.original.png" name="part1-table-step3">
3095.        </div>
3096.        <div class="image-variable-size-caption text-center">
3097.          <div class="rich-text">
3098.            <p>
3099.              Moving a row in a tableview, step 3
3100.            </p>
3101.          </div>
3102.        </div>
3103.      </div>
3104.    </div>
3105.    <div class="rich-text">
3106.      <p>
3107.        The main question, however, is whether you are using QListView/QTableView/QTreeView on top of a custom item model, or QListWidget/QTableWidget/QTreeWidget with items in them. Let's explore each one in turn.
3108.      </p>
3109.      <h2>
3110.        With Model/View separation
3111.      </h2>
3112.      <p>
3113.        The code being discussed here is extracted from <a href="https://github.com/KDABLabs/blogs-qt/tree/main/ItemViews-DragAndDrop/part1-reordering-elements/model-view" rel="noopener noreferrer" target="_blank">the example</a>. That example features a flat model, while <a href="https://github.com/KDABLabs/blogs-qt/tree/main/ItemViews-DragAndDrop/part1-reordering-elements/treemodel" rel="noopener noreferrer" target="_blank">this example</a> features a tree model. The checklist is the same for these two cases.
3114.      </p>
3115.      <h3>
3116.        Setting up the view
3117.      </h3>
3118.      <p>
3119.        ☑ Call <code>view->setDragDropMode(QAbstractItemView::InternalMove)</code> to enable the mode where only moving within the same view is allowed
3120.      </p>
3121.      <p>
3122.        ☑ When using <code>QTableView</code>, call <code>view->setDragDropOverwriteMode(false)</code> so that it inserts rows instead of replacing cells (the default is <code>false</code> for the other views anyway)
3123.      </p>
3124.      <h3>
3125.        Adding drag-n-drop support to the model
3126.      </h3>
3127.    </div>
3128.    <div class="image-variable-size-block">
3129.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3130.        <div class="image-variable-size-image">
3131.          <img alt="part1-list" class="part1-list" id="part1-list" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-list.original.png" name="part1-list">
3132.        </div>
3133.        <div class="image-variable-size-caption text-center">
3134.          <div class="rich-text">
3135.            <p>
3136.              Reorderable ListView
3137.            </p>
3138.          </div>
3139.        </div>
3140.      </div>
3141.    </div>
3142.    <div class="image-variable-size-block">
3143.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3144.        <div class="image-variable-size-image">
3145.          <img alt="part1-table" class="part1-table" id="part1-table" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-table.original.png" name="part1-table">
3146.        </div>
3147.        <div class="image-variable-size-caption text-center">
3148.          <div class="rich-text">
3149.            <p>
3150.              Reorderable TableView
3151.            </p>
3152.          </div>
3153.        </div>
3154.      </div>
3155.    </div>
3156.    <div class="rich-text">
3157.      <p>
3158.        For a model being used in QListView or QTableView, all you need is something like this:
3159.      </p>
3160.    </div>
3161.    <div class="formatted-code">
3162.      <pre><code class="language-cpp line-numbers">class CountryModel : public QAbstractTableModel
3163. {
3164.    ~~~
3165.    Qt::ItemFlags flags(const QModelIndex &index) const override
3166.    {
3167.        if (!index.isValid())
3168.            return Qt::ItemIsDropEnabled; // allow dropping between items
3169.        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
3170.    }
3171.  
3172.    // the default is "copy only", change it
3173.    Qt::DropActions supportedDropActions() const override { return Qt::MoveAction; }
3174.  
3175.    // the default is "return supportedDropActions()", let's be explicit
3176.    Qt::DropActions supportedDragActions() const override { return Qt::MoveAction; }
3177.  
3178.    QStringList mimeTypes() const override { return {QString::fromLatin1(s_mimeType)}; }
3179.  
3180.    bool moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild) override; // see below
3181. };</code></pre>
3182.    </div>
3183.    <div class="rich-text">
3184.      <p>
3185.        The checklist for the changes you need to make in your model is therefore the following:
3186.      </p>
3187.      <p>
3188.        ☑ Reimplement <code>flags()</code><br>
3189.        For a valid index, add <code>Qt::ItemIsDragEnabled</code> and make sure <code>Qt::ItemIsDropEnabled</code> is NOT set (except for tree models where we need to drop onto items in order to insert a first child). \
3190.      </p>
3191.      <p>
3192.        ☑ Reimplement <code>mimeTypes()</code> and make up a name for the mimetype (usually starting with <code>application/x-</code>)
3193.      </p>
3194.      <p>
3195.        ☑ Reimplement <code>supportedDragActions()</code> to return <code>Qt::MoveAction</code>
3196.      </p>
3197.      <p>
3198.        ☑ Reimplement <code>supportedDropActions()</code> to return <code>Qt::MoveAction</code>
3199.      </p>
3200.      <p>
3201.        ☑ Reimplement <code>moveRows()</code>
3202.      </p>
3203.      <p>
3204.        Note that this approach is only valid when using <code>QListView</code> or, assuming Qt >= 6.8.0, <code>QTableView</code> - see the following sections for details.
3205.      </p>
3206.      <p>
3207.        In a model that encapsulates a <code>QVector</code> called <code>m_data</code>, the implementation of <code>moveRows</code> can look like this:
3208.      </p>
3209.    </div>
3210.    <div class="formatted-code">
3211.      <pre><code class="language-cpp line-numbers">bool CountryModel::moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild)
3212. {
3213.    if (!beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1, destinationParent, destinationChild))
3214.        return false; // invalid move, e.g. no-op (move row 2 to row 2 or to row 3)
3215.  
3216.    for (int i = 0; i < count; ++i) {
3217.        m_data.move(sourceRow + i, destinationChild + (sourceRow > destinationChild ? 0 : -1));
3218.    }
3219.  
3220.    endMoveRows();
3221.    return true;
3222. }</code></pre>
3223.    </div>
3224.    <div class="rich-text">
3225.      <h3>
3226.        QTreeView does not call moveRows
3227.      </h3>
3228.    </div>
3229.    <div class="image-variable-size-block">
3230.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3231.        <div class="image-variable-size-image">
3232.          <img alt="part1-tree" class="part1-tree" id="part1-tree" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-tree.original.png" name="part1-tree">
3233.        </div>
3234.        <div class="image-variable-size-caption text-center">
3235.          <div class="rich-text">
3236.            <p>
3237.              Reorderable treeview
3238.            </p>
3239.          </div>
3240.        </div>
3241.      </div>
3242.    </div>
3243.    <div class="image-variable-size-block">
3244.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3245.        <div class="image-variable-size-image">
3246.          <img alt="part1-treemodel" class="part1-treemodel" id="part1-treemodel" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-treemodel.original.png" name="part1-treemodel">
3247.        </div>
3248.        <div class="image-variable-size-caption text-center">
3249.          <div class="rich-text">
3250.            <p>
3251.              Reorderable treeview with a tree model
3252.            </p>
3253.          </div>
3254.        </div>
3255.      </div>
3256.    </div>
3257.    <div class="rich-text">
3258.      <p>
3259.        QTreeView does not (yet?) call <code>moveRows</code> in the model, so you need to:
3260.      </p>
3261.      <p>
3262.        ☑ Reimplement <code>mimeData()</code> to encode row numbers for flat models, and node pointers for tree models
3263.      </p>
3264.      <p>
3265.        ☑ Reimplement <code>dropMimeData()</code> to implement the move and return false (meaning: all done)
3266.      </p>
3267.      <p>
3268.        Note that this means a move is in fact an insertion and a deletion, so the selection isn't automatically updated to point to the moved row(s).
3269.      </p>
3270.      <h3>
3271.        QTableView in Qt < 6.8.0
3272.      </h3>
3273.      <p>
3274.        I implemented moving of rows in <code>QTableView</code> itself for Qt 6.8.0, so that moving rows in a table view is simpler to implement (one method instead of two), more efficient, and so that selection is updated. If you're not yet using Qt >= 6.8.0 then you'll have to reimplement <code>mimeData()</code> and <code>dropMimeData()</code> in your model, as per the previous section.
3275.      </p>
3276.      <p>
3277.        This concludes the section on how to implement a reorderable view using a separate model class.
3278.      </p>
3279.      <h2>
3280.        Using item widgets
3281.      </h2>
3282.      <p>
3283.        The alternative to model/view separation is the use of the item widgets (<code>QListWidget</code>, <code>QTableWidget</code> or <code>QTreeWidget</code>) which you populate directly by creating items.
3284.      </p>
3285.    </div>
3286.    <div class="image-variable-size-block">
3287.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3288.        <div class="image-variable-size-image">
3289.          <img alt="part1-listwidget" class="part1-listwidget" id="part1-listwidget" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-listwidget.original.png" name="part1-listwidget">
3290.        </div>
3291.        <div class="image-variable-size-caption text-center">
3292.          <div class="rich-text">
3293.            <p>
3294.              Reorderable QListWidget
3295.            </p>
3296.          </div>
3297.        </div>
3298.      </div>
3299.    </div>
3300.    <div class="image-variable-size-block">
3301.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3302.        <div class="image-variable-size-image">
3303.          <img alt="part1-tablewidget" class="part1-tablewidget" id="part1-tablewidget" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-tablewidget.original.png" name="part1-tablewidget">
3304.        </div>
3305.        <div class="image-variable-size-caption text-center">
3306.          <div class="rich-text">
3307.            <p>
3308.              Reorderable QTableWidget
3309.            </p>
3310.          </div>
3311.        </div>
3312.      </div>
3313.    </div>
3314.    <div class="image-variable-size-block">
3315.      <div class="image-variable-positioning-block right-margin-auto left-margin-auto width-100">
3316.        <div class="image-variable-size-image">
3317.          <img alt="part1-treewidget" class="part1-treewidget" id="part1-treewidget" src="https://eu-central-1.linodeobjects.com/wagtail-production/images/part1-treewidget.original.png" name="part1-treewidget">
3318.        </div>
3319.        <div class="image-variable-size-caption text-center">
3320.          <div class="rich-text">
3321.            <p>
3322.              Reorderable QTreeWidget
3323.            </p>
3324.          </div>
3325.        </div>
3326.      </div>
3327.    </div>
3328.    <div class="rich-text">
3329.      <p>
3330.        Here's what you need to do to allow users to reorder those items.
3331.      </p>
3332.      <p>
3333.        <a href="https://github.com/KDABLabs/blogs-qt/tree/main/ItemViews-DragAndDrop/part1-reordering-elements/itemwidgets" rel="noopener noreferrer" target="_blank">Example code</a> can be found following this link.
3334.      </p>
3335.      <h3>
3336.        Reorderable QListWidget
3337.      </h3>
3338.      <p>
3339.        ☑ Call <code>listWidget->setDragDropMode(QAbstractItemView::InternalMove)</code> to enable the mode where only moving within the same view is allowed
3340.      </p>
3341.      <p>
3342.        For a <code>QListWidget</code>, this is all you need. That was easy!
3343.      </p>
3344.      <h3>
3345.        Reorderable QTableWidget
3346.      </h3>
3347.      <p>
3348.        When using <code>QTableWidget</code>:
3349.      </p>
3350.      <p>
3351.        ☑ Call <code>tableWidget->setDragDropMode(QAbstractItemView::InternalMove)</code>
3352.      </p>
3353.      <p>
3354.        ☑ Call <code>tableWidget->setDragDropOverwriteMode(false)</code> so that it inserts rows instead of replacing cells
3355.      </p>
3356.      <p>
3357.        ☑ Call <code>item->setFlags(item->flags() & ~Qt::ItemIsDropEnabled);</code> on each item, to disable dropping onto items
3358.      </p>
3359.      <p>
3360.        Note: Before Qt 6.8.0, <code>QTableWidget</code> did not really support moving rows. It would instead move data into cells (like Excel). The example code shows a workaround, but since it calls code that inserts a row and deletes the old one, header data is lost in the process. My changes in Qt 6.8.0 implement support for moving rows in <code>QTableWidget</code>'s internal model, so it's all fixed there. If you really need this feature in older versions of Qt, consider switching to <code>QTableView</code>.
3361.      </p>
3362.      <h3>
3363.        Reorderable QTreeWidget
3364.      </h3>
3365.      <p>
3366.        When using <code>QTreeWidget</code>:
3367.      </p>
3368.      <p>
3369.        ☑ Call <code>tableWidget->setDragDropMode(QAbstractItemView::InternalMove)</code>
3370.      </p>
3371.      <p>
3372.        ☑ Call <code>item->setFlags(item->flags() & ~Qt::ItemIsDropEnabled);</code> on each item, to disable dropping onto items
3373.      </p>
3374.      <h3>
3375.        Conclusion about reorderable item widgets
3376.      </h3>
3377.      <p>
3378.        Of course, you'll also need to iterate over the items at the end to grab the new order, like the example code does. As usual, item widgets lead to less code to write, but the runtime performance is worse than when using model/view separation. So, only use item widgets when the number of items is small (and you don't need proxy models).
3379.      </p>
3380.      <h2>
3381.        Improvements to Qt
3382.      </h2>
3383.      <p>
3384.        While writing and testing these code examples, I improved the following things in Qt 6.8:
3385.      </p>
3386.      <ul>
3387.        <li>
3388.          <a href="https://bugreports.qt.io/browse/QTBUG-13873" rel="noopener noreferrer" target="_blank">QTBUG-13873</a> / <a href="https://bugreports.qt.io/browse/QTBUG-101475" rel="noopener noreferrer" target="_blank">QTBUG-101475</a> - QTableView: implement moving rows by drag-n-drop
3389.        </li>
3390.        <li>
3391.          <a href="https://bugreports.qt.io/browse/QTBUG-69807" rel="noopener noreferrer" target="_blank">QTBUG-69807</a> - Implement QTableModel::moveRows
3392.        </li>
3393.        <li>
3394.          <a href="https://bugreports.qt.io/browse/QTBUG-130045" rel="noopener noreferrer" target="_blank">QTBUG-130045</a> - QTableView: fix dropping between items when precisely on the cell border
3395.        </li>
3396.        <li>
3397.          <a href="https://bugreports.qt.io/browse/QTBUG-1656" rel="noopener noreferrer" target="_blank">QTBUG-1656</a> - Implement full-row drop indicator when the selection behavior is SelectRows
3398.        </li>
3399.      </ul>
3400.      <h2>
3401.        Conclusion
3402.      </h2>
3403.      <p>
3404.        I hope this checklist will be useful when you have to implement your own reordering of items in a model or an item-widget. Please post a comment if anything appears to be incorrect or missing.
3405.      </p>
3406.      <p>
3407.        In the next blog post of this series, you will learn how to move (or even copy) items from one view to another.
3408.      </p>
3409.    </div>
3410.    <p>
3411.      The post <a href="https://www.kdab.com/modelview-drag-and-drop-part-1/">Model/View Drag and Drop in Qt - Part 1</a> appeared first on <a href="https://www.kdab.com">KDAB</a>.
3412.    &lt;/p&gt;</description>
3413.    </item>
3414.  </channel>
3415. </rss>
3416.