Merge branch 'main' into add_valgrind_info

Author: Montel

crates/cxx-qt-lib-headers/include/gui/qpainter.h

@@ -10,3 +10,10 @@
 #include <memory>
 
 #include <QtGui/QPainter>
+
+namespace rust {
+namespace cxxqtlib1 {
+using QPainterRenderHint = QPainter::RenderHint;
+
+} // namespace cxxqtlib1
+} // namespace rust

crates/cxx-qt-lib/src/gui/mod.rs

@@ -37,4 +37,4 @@ mod qpainterpath;
 pub use qpainterpath::QPainterPath;
 
 mod qpainter;
-pub use qpainter::QPainter;
+pub use qpainter::{QPainter, QPainterRenderHint};

crates/cxx-qt-lib/src/gui/qfont.rs

@@ -262,6 +262,10 @@ mod ffi {
         #[doc(hidden)]
         #[rust_name = "qfont_clone"]
         fn construct(font: &QFont) -> QFont;
+
+        #[doc(hidden)]
+        #[rust_name = "qfont_eq"]
+        fn operatorEq(a: &QFont, b: &QFont) -> bool;
     }
 }
 
@@ -291,6 +295,14 @@ impl Clone for QFont {
     }
 }
 
+impl PartialEq for QFont {
+    fn eq(&self, other: &Self) -> bool {
+        ffi::qfont_eq(self, other)
+    }
+}
+
+impl Eq for QFont {}
+
 impl QFont {
     /// Returns the bounding rectangle of the current clip if there is a clip;
     /// otherwise returns `None`. Note that the clip region is given in logical coordinates.

crates/cxx-qt-lib/src/gui/qimage.rs

@@ -237,6 +237,10 @@ mod ffi {
         #[doc(hidden)]
         #[rust_name = "qimage_cache_key"]
         fn qimageCacheKey(image: &QImage) -> i64;
+
+        #[doc(hidden)]
+        #[rust_name = "qimage_eq"]
+        fn operatorEq(a: &QImage, b: &QImage) -> bool;
     }
 }
 
@@ -270,6 +274,14 @@ impl Default for QImage {
     }
 }
 
+impl PartialEq for QImage {
+    fn eq(&self, other: &Self) -> bool {
+        ffi::qimage_eq(self, other)
+    }
+}
+
+impl Eq for QImage {}
+
 // Safety:
 //
 // Static checks on the C++ side to ensure the size & alignment is the same.

crates/cxx-qt-lib/src/gui/qpainter.rs

@@ -15,6 +15,27 @@ mod ffi {
         type SizeMode = crate::SizeMode;
     }
 
+    /// Renderhints are used to specify flags to QPainter that may or may not be respected by any given engine.
+    #[repr(i32)]
+    #[namespace = "rust::cxxqtlib1"]
+    #[derive(Debug)]
+    enum QPainterRenderHint {
+        /// Indicates that the engine should antialias edges of primitives if possible.
+        Antialiasing = 0x01,
+        /// Indicates that the engine should antialias text if possible.
+        /// To forcibly disable antialiasing for text, do not use this hint.
+        /// Instead, set QFont::NoAntialias on your font's style strategy.
+        TextAntialiasing = 0x02,
+        /// Indicates that the engine should use a smooth pixmap transformation algorithm
+        /// (such as bilinear) rather than nearest neighbor.
+        SmoothPixmapTransform = 0x04,
+        /// Use a lossless image rendering, whenever possible. Currently, this hint is only
+        /// used when QPainter is employed to output a PDF file through QPrinter or QPdfWriter,
+        /// where drawImage()/drawPixmap() calls will encode images using a lossless compression
+        /// algorithm instead of lossy JPEG compression. This value was added in Qt 5.13.
+        LosslessImageRendering = 0x40,
+    }
+
     unsafe extern "C++" {
         include!("cxx-qt-lib/qpainter.h");
         type QPainter;
@@ -197,15 +218,19 @@ mod ffi {
         #[rust_name = "set_layout_direction"]
         fn setLayoutDirection(self: Pin<&mut QPainter>, direction: LayoutDirection);
 
-        /// Sets the painter's pen to be the given pen.
-        #[rust_name = "set_pen"]
-        fn setPen(self: Pin<&mut QPainter>, pen: &QPen);
-
         /// Sets the opacity of the painter to opacity. The value should be in the range 0.0 to 1.0,
         /// where 0.0 is fully transparent and 1.0 is fully opaque.
         #[rust_name = "set_opacity"]
         fn setOpacity(self: Pin<&mut QPainter>, opacity: f64);
 
+        /// Sets the painter's pen to be the given pen.
+        #[rust_name = "set_pen"]
+        fn setPen(self: Pin<&mut QPainter>, pen: &QPen);
+
+        /// Sets the given render hint on the painter if on is true; otherwise clears the render hint.
+        #[rust_name = "set_render_hint"]
+        fn setRenderHint(self: Pin<&mut QPainter>, hint: QPainterRenderHint, on: bool);
+
         /// Sets the painter's viewport rectangle to the given rectangle, and enables view transformations.
         #[rust_name = "set_viewport"]
         fn setViewport(self: Pin<&mut QPainter>, rectangle: &QRect);
@@ -218,6 +243,10 @@ mod ffi {
         #[rust_name = "stroke_path"]
         fn strokePath(self: Pin<&mut QPainter>, path: &QPainterPath, pen: &QPen);
 
+        /// Returns true if hint is set; otherwise returns false.
+        #[rust_name = "test_render_hint"]
+        fn testRenderHint(self: &QPainter, hint: QPainterRenderHint) -> bool;
+
         /// Restores the current painter state (pops a saved state off the stack).
         fn restore(self: Pin<&mut QPainter>);
 
@@ -239,13 +268,15 @@ mod ffi {
     unsafe extern "C++" {
         include!("cxx-qt-lib/common.h");
 
+        type QPainterRenderHint;
+
         #[doc(hidden)]
         #[rust_name = "qpainter_init_default"]
         fn make_unique() -> UniquePtr<QPainter>;
     }
 }
 
-pub use ffi::QPainter;
+pub use ffi::{QPainter, QPainterRenderHint};
 
 impl QPainter {
     /// Create a QPainter

crates/cxx-qt-lib/src/gui/qpainterpath.rs

@@ -188,6 +188,10 @@ mod ffi {
         #[doc(hidden)]
         #[rust_name = "qpainterpath_drop"]
         fn drop(painterPath: &mut QPainterPath);
+
+        #[doc(hidden)]
+        #[rust_name = "qpainterpath_eq"]
+        fn operatorEq(a: &QPainterPath, b: &QPainterPath) -> bool;
     }
 }
 
@@ -222,6 +226,14 @@ impl From<&QPointF> for QPainterPath {
     }
 }
 
+impl PartialEq for QPainterPath {
+    fn eq(&self, other: &Self) -> bool {
+        ffi::qpainterpath_eq(self, other)
+    }
+}
+
+impl Eq for QPainterPath {}
+
 // Safety:
 //
 // Static checks on the C++ side to ensure the size is the same.

crates/cxx-qt-lib/src/gui/qpen.rs

@@ -113,6 +113,10 @@ mod ffi {
         #[doc(hidden)]
         #[rust_name = "qpen_clone"]
         fn construct(pen: &QPen) -> QPen;
+
+        #[doc(hidden)]
+        #[rust_name = "qpen_eq"]
+        fn operatorEq(a: &QPen, b: &QPen) -> bool;
     }
 }
 
@@ -143,6 +147,14 @@ impl Clone for QPen {
     }
 }
 
+impl PartialEq for QPen {
+    fn eq(&self, other: &Self) -> bool {
+        ffi::qpen_eq(self, other)
+    }
+}
+
+impl Eq for QPen {}
+
 impl From<&ffi::QColor> for QPen {
     fn from(color: &ffi::QColor) -> Self {
         ffi::qpen_init_from_qcolor(color)

crates/cxx-qt-lib/src/gui/qpolygon.rs

@@ -2,6 +2,7 @@
 // SPDX-FileContributor: Laurent Montel <[email protected]>
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
+use crate::QRect;
 use core::mem::MaybeUninit;
 use cxx::{type_id, ExternType};
 
@@ -65,13 +66,21 @@ mod ffi {
         #[rust_name = "qpolygon_init_default"]
         fn construct() -> QPolygon;
 
+        #[doc(hidden)]
+        #[rust_name = "qpolygon_init_qrect"]
+        fn construct(rect: &QRect, closed: bool) -> QPolygon;
+
         #[doc(hidden)]
         #[rust_name = "qpolygon_drop"]
         fn drop(pen: &mut QPolygon);
 
         #[doc(hidden)]
         #[rust_name = "qpolygon_clone"]
         fn construct(p: &QPolygon) -> QPolygon;
+
+        #[doc(hidden)]
+        #[rust_name = "qpolygon_eq"]
+        fn operatorEq(a: &QPolygon, b: &QPolygon) -> bool;
     }
 }
 
@@ -107,6 +116,23 @@ impl Clone for QPolygon {
     }
 }
 
+impl QPolygon {
+    /// Constructs a polygon from the given rectangle. If closed is false, the polygon
+    /// just contains the four points of the rectangle ordered clockwise, otherwise the
+    /// polygon's fifth point is set to rectangle.topLeft().
+    pub fn new(rect: &QRect, closed: bool) -> Self {
+        ffi::qpolygon_init_qrect(rect, closed)
+    }
+}
+
+impl PartialEq for QPolygon {
+    fn eq(&self, other: &Self) -> bool {
+        ffi::qpolygon_eq(self, other)
+    }
+}
+
+impl Eq for QPolygon {}
+
 // Safety:
 //
 // Static checks on the C++ side to ensure the size is the same.

crates/cxx-qt-lib/src/gui/qpolygonf.rs

@@ -75,6 +75,10 @@ mod ffi {
         #[doc(hidden)]
         #[rust_name = "qpolygonf_clone"]
         fn construct(p: &QPolygonF) -> QPolygonF;
+
+        #[doc(hidden)]
+        #[rust_name = "qpolygonf_eq"]
+        fn operatorEq(a: &QPolygonF, b: &QPolygonF) -> bool;
     }
 }
 
@@ -110,6 +114,14 @@ impl Clone for QPolygonF {
     }
 }
 
+impl PartialEq for QPolygonF {
+    fn eq(&self, other: &Self) -> bool {
+        ffi::qpolygonf_eq(self, other)
+    }
+}
+
+impl Eq for QPolygonF {}
+
 // Safety:
 //
 // Static checks on the C++ side to ensure the size is the same.

tests/qt_types_standalone/CMakeLists.txt

@@ -66,6 +66,7 @@ add_executable(${APP_NAME}
     cpp/qpersistentmodelindex.h
     cpp/qpoint.h
     cpp/qpointf.h
+    cpp/qpolygon.h
     cpp/qqmlapplicationengine.h
     cpp/qqmlengine.h
     cpp/qrect.h

tests/qt_types_standalone/cpp/main.cpp

@@ -25,6 +25,7 @@
 #include "qpersistentmodelindex.h"
 #include "qpoint.h"
 #include "qpointf.h"
+#include "qpolygon.h"
 #include "qqmlapplicationengine.h"
 #include "qqmlengine.h"
 #include "qrect.h"
@@ -90,6 +91,7 @@ main(int argc, char* argv[])
   runTest(QScopedPointer<QObject>(new QVector2DTest));
   runTest(QScopedPointer<QObject>(new QVector3DTest));
   runTest(QScopedPointer<QObject>(new QVector4DTest));
+  runTest(QScopedPointer<QObject>(new QPolygonTest));
 
   return status;
 }

tests/qt_types_standalone/cpp/qpolygon.h

@@ -0,0 +1,35 @@
+// clang-format off
+// SPDX-FileCopyrightText: 2024 Klarälvdalens Datakonsult AB, a KDAB Group company <[email protected]>
+// clang-format on
+// SPDX-FileContributor: Laurent Montel <[email protected]>
+//
+// SPDX-License-Identifier: MIT OR Apache-2.0
+#pragma once
+
+#include <QtGui/QPolygon>
+#include <QtTest/QTest>
+
+#include "cxx-qt-gen/qpolygon.cxx.h"
+
+class QPolygonTest : public QObject
+{
+  Q_OBJECT
+
+private Q_SLOTS:
+  void construct()
+  {
+    const auto m = construct_qpolygon();
+    QVERIFY(m.isEmpty());
+  }
+  void clone()
+  {
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
+    const auto m = QPolygon(QList<QPoint>() << QPoint(1, 2) << QPoint(3, 4));
+#else
+    const auto m = QPolygon(QVector<QPoint>() << QPoint(1, 2) << QPoint(3, 4));
+#endif
+    const auto c = clone_qpolygon(m);
+    QCOMPARE(c.point(0), QPoint(1, 2));
+    QCOMPARE(c.point(1), QPoint(3, 4));
+  }
+};

tests/qt_types_standalone/rust/build.rs

@@ -25,6 +25,7 @@ fn main() {
         .file("src/qpersistentmodelindex.rs")
         .file("src/qpoint.rs")
         .file("src/qpointf.rs")
+        .file("src/qpolygon.rs")
         .file("src/qqmlapplicationengine.rs")
         .file("src/qqmlengine.rs")
         .file("src/qrect.rs")

tests/qt_types_standalone/rust/src/lib.rs

@@ -22,6 +22,7 @@ mod qmodelindex;
 mod qpersistentmodelindex;
 mod qpoint;
 mod qpointf;
+mod qpolygon;
 mod qqmlapplicationengine;
 mod qqmlengine;
 mod qrect;

tests/qt_types_standalone/rust/src/qpolygon.rs

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: 2024 Klarälvdalens Datakonsult AB, a KDAB Group company <[email protected]>
+// SPDX-FileContributor: Laurent Montel <[email protected]>
+//
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+use cxx_qt_lib::QPolygon;
+
+#[cxx::bridge]
+mod qpolygon_cxx {
+    unsafe extern "C++" {
+        include!("cxx-qt-lib/qpolygon.h");
+
+        type QPolygon = cxx_qt_lib::QPolygon;
+    }
+
+    extern "Rust" {
+        fn clone_qpolygon(p: &QPolygon) -> QPolygon;
+        fn construct_qpolygon() -> QPolygon;
+    }
+}
+
+fn construct_qpolygon() -> QPolygon {
+    QPolygon::default()
+}
+
+fn clone_qpolygon(p: &QPolygon) -> QPolygon {
+    p.clone()
+}