Fix pin size on Windows for scaled screen (#4907)

Pinning a capture on a display with 150% scaling produces a pin window
half again as large as the region that was selected. #4614 fixed the
position of that window for v14.0.0; this is the size.

A capture started from the tray icon is fine, because the tray lives in
the daemon and createPin() hands the pixmap straight to attachPin().
Any invocation that runs in its own process instead -- `flameshot gui`
from a shell, a desktop or AutoHotkey shortcut, D-Bus -- finds
FlameshotDaemon::instance() null and serializes the capture to the
daemon. QDataStream writes a QPixmap as a plain image, which carries no
device pixel ratio, so the daemon reconstructs a pixmap that claims a
ratio of 1. PinWidget then lays out device pixels as if they were
logical ones and the window comes out too large by the scale factor.
The built-in PrintScreen hook is not affected; it runs inside the daemon
and takes the in-process path.

Send the ratio next to the pixmap so the serialized path ends up with
the same pixmap the in-process path already gets. Both transports share
the reading half, since the D-Bus adapter and the KDSingleApplication
handler each deserialize the message themselves. A message from an older
flameshot has no ratio appended; the read runs past the end, the stream
reports it, and the pixmap keeps the ratio it already had.

Checked on Windows 11, 1024x768 screen, QT_SCALE_FACTOR=1.5, pinning a
400x300 region. The pin window measured 621x471 before and 422x321
after. The capture is 400x300 device pixels either way, so the pin
should be that plus the 7pt margin on each side, and the patched size
matches the 414x314 measured on an unscaled screen to within the scaled
margin. Unscaled displays measured 414x314 both before and after.

Author: 4RH1T3CT0R7

data/dbus/org.flameshot.Flameshot.xml

@@ -11,7 +11,8 @@
 
     <!--
         attachPin:
-        @data: Byte array containing the screenshot and geometry information.
+        @data: Byte array containing the screenshot, geometry information and
+        the screenshot's device pixel ratio.
 
         Attach a pinned screenshot widget to the daemon.
     -->

src/core/flameshotdaemon.cpp

@@ -39,6 +39,26 @@
 #include "core/globalshortcutfilter.h"
 #endif
 
+namespace {
+/**
+ * @brief Read a pin message written by FlameshotDaemon::createPin.
+ *
+ * A QPixmap loses its device pixel ratio when it goes through a QDataStream,
+ * so it travels next to the pixmap and is restored here. Without it the pin is
+ * laid out in device pixels and comes out too big on a scaled screen. Messages
+ * from an older flameshot don't carry it, in which case the pixmap keeps the
+ * ratio it was created with.
+ */
+void readPin(QDataStream& stream, QPixmap& pixmap, QRect& geometry)
+{
+    qreal devicePixelRatio = 0;
+    stream >> pixmap >> geometry >> devicePixelRatio;
+    if (stream.status() == QDataStream::Ok && devicePixelRatio > 0) {
+        pixmap.setDevicePixelRatio(devicePixelRatio);
+    }
+}
+}
+
 /**
  * @brief A way of accessing the flameshot daemon both from the daemon itself,
  * and from subcommands.
@@ -121,13 +141,15 @@ void FlameshotDaemon::createPin(const QPixmap& capture, QRect geometry)
     QByteArray data;
     QDataStream stream(&data, QIODevice::WriteOnly);
 
+    // A QPixmap loses its device pixel ratio when streamed, so send it along.
 #if defined(USE_KDSINGLEAPPLICATION) &&                                        \
   (defined(Q_OS_MACOS) || defined(Q_OS_WIN))
     auto kdsa = KDSingleApplication(QStringLiteral("org.flameshot.Flameshot"));
-    stream << QStringLiteral("attachPin") << capture << geometry;
+    stream << QStringLiteral("attachPin") << capture << geometry
+           << capture.devicePixelRatio();
     kdsa.sendMessage(data);
 #else
-    stream << capture << geometry;
+    stream << capture << geometry << capture.devicePixelRatio();
     QDBusMessage m = createMethodCall(QStringLiteral("attachPin"));
     m << data;
     call(m);
@@ -330,8 +352,7 @@ void FlameshotDaemon::attachPin(const QByteArray& data)
     QPixmap pixmap;
     QRect geometry;
 
-    stream >> pixmap;
-    stream >> geometry;
+    readPin(stream, pixmap, geometry);
 
     attachPin(pixmap, geometry);
 }
@@ -474,7 +495,7 @@ void FlameshotDaemon::messageReceivedFromSecondaryInstance(
     if (methodCall == QStringLiteral("attachPin")) {
         QPixmap capture;
         QRect geometry;
-        stream >> capture >> geometry;
+        readPin(stream, capture, geometry);
         // qDebug() << "Pixmap:" << capture;
         // qDebug() << "Geometry:" << geometry;
         if (!capture.isNull()) {