Merge branch 'main' into improve_qimage_support

Author: Montel

.clangd

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <[email protected]>
+# SPDX-FileContributor: Leon Matthes <[email protected]>
+#
+# SPDX-License-Identifier: MIT OR Apache-2.0
+CompileFlags:
+  Add: [-DCXX_QT_GUI_FEATURE=1]

.gitignore

@@ -20,3 +20,5 @@ compile_commands.json
 # cmps (https://github.com/leonmatthes/cmps)
 .cmps/
 
+# clangd cache
+.cache/

README.md

@@ -41,7 +41,8 @@ CXX-Qt is tested on CI on Linux, Windows, and macOS (all on x86_64). It should w
 Rust both support, however, these are not tested regularly.
 
 CXX-Qt is in early development and the API changes frequently. For the latest documentation between releases, [install mdBook](https://rust-lang.github.io/mdBook/guide/installation.html)
-and run `mdbook serve` in the [book folder](./book).
+and run `mdbook serve --open` in the [book folder](./book). It will open your own browser.
+If you need to open it in another browser goto url [http://localhost:3000](http://localhost:3000).
 
 ## Comparison to other Rust Qt bindings
 
@@ -130,7 +131,7 @@ ctest --test-dir build
 
 ## Licensing
 
-CXX-Qt is Copyright (C) 2022, Klarälvdalens Datakonsult AB, and is available under
+CXX-Qt is Copyright (C) Klarälvdalens Datakonsult AB, and is available under
 the terms of the [MIT](https://github.com/KDAB/cxx-qt/blob/main/LICENSES/MIT.txt)
 or the [Apache-2.0](https://github.com/KDAB/cxx-qt/blob/main/LICENSES/Apache-2.0.txt)
 licenses.

crates/cxx-qt-lib-headers/include/core/qline.h

@@ -0,0 +1,9 @@
+// clang-format off
+// SPDX-FileCopyrightText: 2023 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 <QtCore/QLine>

crates/cxx-qt-lib-headers/include/core/qlinef.h

@@ -0,0 +1,9 @@
+// clang-format off
+// SPDX-FileCopyrightText: 2023 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 <QtCore/QLineF>

crates/cxx-qt-lib-headers/src/lib.rs

@@ -25,6 +25,8 @@ pub fn write_headers(directory: impl AsRef<Path>) {
         (include_str!("../include/core/qdate.h"), "qdate.h"),
         (include_str!("../include/core/qdatetime.h"), "qdatetime.h"),
         (include_str!("../include/core/qhash.h"), "qhash.h"),
+        (include_str!("../include/core/qline.h"), "qline.h"),
+        (include_str!("../include/core/qlinef.h"), "qlinef.h"),
         (include_str!("../include/core/qlist.h"), "qlist.h"),
         (
             include_str!("../include/core/qlist_qvector.h"),

crates/cxx-qt-lib/build.rs

@@ -37,6 +37,8 @@ fn main() {
         "core/qdate",
         "core/qhash/qhash_i32_qbytearray",
         "core/qhash/qhash_qstring_qvariant",
+        "core/qline",
+        "core/qlinef",
         "core/qlist/qlist_bool",
         "core/qlist/qlist_f32",
         "core/qlist/qlist_f64",
@@ -200,6 +202,8 @@ fn main() {
         "core/qcoreapplication",
         "core/qdate",
         "core/qhash/qhash",
+        "core/qline",
+        "core/qlinef",
         "core/qlist/qlist",
         "core/qmap/qmap",
         "core/qmargins",

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

@@ -20,6 +20,12 @@ pub use qdatetime::QDateTime;
 mod qhash;
 pub use qhash::{QHash, QHashPair, QHashPair_QString_QVariant, QHashPair_i32_QByteArray};
 
+mod qline;
+pub use qline::QLine;
+
+mod qlinef;
+pub use qlinef::QLineF;
+
 mod qlist;
 pub use qlist::{QList, QListElement};
 

crates/cxx-qt-lib/src/core/qline.cpp

@@ -0,0 +1,22 @@
+// clang-format off
+// SPDX-FileCopyrightText: 2023 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
+#include "cxx-qt-lib/qline.h"
+
+#include "../assertion_utils.h"
+
+#include <cstdint>
+
+// QLine has "QPoint" members - pt1, pt2
+// Rust represents these as 32-bit integer types.
+// https://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/tools/qline.h?h=v5.15.6-lts-lgpl#n90
+//
+// https://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/tools/qline.h?h=v6.2.4#n90
+assert_alignment_and_size(QLine,
+                          alignof(::std::int32_t),
+                          sizeof(::std::int32_t[4]));
+
+static_assert(::std::is_trivially_copyable<QLine>::value);

crates/cxx-qt-lib/src/core/qline.rs

@@ -0,0 +1,113 @@
+// SPDX-FileCopyrightText: 2023 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 crate::QPoint;
+use cxx::{type_id, ExternType};
+
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        include!("cxx-qt-lib/qline.h");
+        type QLine = super::QLine;
+        include!("cxx-qt-lib/qpoint.h");
+        type QPoint = crate::QPoint;
+
+        /// Returns the line's start point.
+        fn p1(self: &QLine) -> QPoint;
+
+        /// Returns the line's end point.
+        fn p2(self: &QLine) -> QPoint;
+
+        /// Returns the x-coordinate of the line's start point.
+        fn x1(self: &QLine) -> i32;
+
+        /// Returns the x-coordinate of the line's end point.
+        fn x2(self: &QLine) -> i32;
+
+        /// Returns the y-coordinate of the line's start point.
+        fn y1(self: &QLine) -> i32;
+
+        /// Returns the y-coordinate of the line's end point.
+        fn y2(self: &QLine) -> i32;
+
+        /// Returns the center point of this line. This is equivalent to (p1() + p2()) / 2, except it will never overflow.
+        fn center(self: &QLine) -> QPoint;
+
+        /// Returns the horizontal component of the line's vector.
+        fn dx(self: &QLine) -> i32;
+
+        /// Returns the vertical component of the line's vector.
+        fn dy(self: &QLine) -> i32;
+
+        /// Returns true if the line does not have distinct start and end points; otherwise returns false.
+        #[rust_name = "is_null"]
+        fn isNull(self: &QLine) -> bool;
+
+        /// Sets the starting point of this line to p1.
+        #[rust_name = "set_p1"]
+        fn setP1(self: &mut QLine, p1: &QPoint);
+
+        /// Sets the end point of this line to p2.
+        #[rust_name = "set_p2"]
+        fn setP2(self: &mut QLine, p1: &QPoint);
+
+        /// Sets this line to the start in x1, y1 and end in x2, y2.
+        #[rust_name = "set_line"]
+        fn setLine(self: &mut QLine, x1: i32, y1: i32, x2: i32, y2: i32);
+
+        /// Sets the start point of this line to p1 and the end point of this line to p2.
+        #[rust_name = "set_points"]
+        fn setPoints(self: &mut QLine, p1: &QPoint, p2: &QPoint);
+
+        /// Translates this line by the given offset.
+        fn translate(self: &mut QLine, offset: &QPoint);
+
+        /// Returns this line translated by the given offset.
+        fn translated(self: &QLine, offset: &QPoint) -> QLine;
+    }
+
+    #[namespace = "rust::cxxqtlib1"]
+    unsafe extern "C++" {
+        include!("cxx-qt-lib/common.h");
+
+        #[doc(hidden)]
+        #[rust_name = "qline_default"]
+        fn construct() -> QLine;
+
+        #[doc(hidden)]
+        #[rust_name = "qline_new"]
+        fn construct(pt1: QPoint, pt2: QPoint) -> QLine;
+    }
+}
+
+/// The QLine class provides a two-dimensional vector using integer precision
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[repr(C)]
+pub struct QLine {
+    pt1: QPoint,
+    pt2: QPoint,
+}
+
+impl QLine {
+    /// Constructs a line object that represents the line between p1 and p2.
+    pub fn new(pt1: QPoint, pt2: QPoint) -> Self {
+        ffi::qline_new(pt1, pt2)
+    }
+}
+
+impl Default for QLine {
+    /// Constructs a null line.
+    fn default() -> Self {
+        ffi::qline_default()
+    }
+}
+
+// Safety:
+//
+// Static checks on the C++ side ensure that QLine is trivial.
+unsafe impl ExternType for QLine {
+    type Id = type_id!("QLine");
+    type Kind = cxx::kind::Trivial;
+}

crates/cxx-qt-lib/src/core/qlinef.cpp

@@ -0,0 +1,20 @@
+// clang-format off
+// SPDX-FileCopyrightText: 2023 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
+#include "cxx-qt-lib/qlinef.h"
+
+#include "../assertion_utils.h"
+
+#include <cstdint>
+
+// QLineF has "QPointF" members - pt1, pt2
+// Rust represents these as double types.
+// https://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/tools/qline.h?h=v5.15.6-lts-lgpl#n281
+//
+// https://code.qt.io/cgit/qt/qtbase.git/tree/src/corelib/tools/qline.h?h=v6.2.4#n295
+assert_alignment_and_size(QLineF, alignof(double), sizeof(double[4]));
+
+static_assert(::std::is_trivially_copyable<QLineF>::value);

crates/cxx-qt-lib/src/core/qlinef.rs

@@ -0,0 +1,126 @@
+// SPDX-FileCopyrightText: 2023 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 crate::QLine;
+use crate::QPointF;
+use cxx::{type_id, ExternType};
+
+#[cxx::bridge]
+mod ffi {
+    unsafe extern "C++" {
+        include!("cxx-qt-lib/qlinef.h");
+        type QLineF = super::QLineF;
+        include!("cxx-qt-lib/qline.h");
+        type QLine = crate::QLine;
+        include!("cxx-qt-lib/qpointf.h");
+        type QPointF = crate::QPointF;
+
+        /// Returns the line's start point.
+        fn p1(self: &QLineF) -> QPointF;
+
+        /// Returns the line's end point.
+        fn p2(self: &QLineF) -> QPointF;
+
+        /// Returns the x-coordinate of the line's start point.
+        fn x1(self: &QLineF) -> f64;
+
+        /// Returns the x-coordinate of the line's end point.
+        fn x2(self: &QLineF) -> f64;
+
+        /// Returns the y-coordinate of the line's start point.
+        fn y1(self: &QLineF) -> f64;
+
+        /// Returns the y-coordinate of the line's end point.
+        fn y2(self: &QLineF) -> f64;
+
+        /// Returns the center point of this line. This is equivalent to (p1() + p2()) / 2, except it will never overflow.
+        fn center(self: &QLineF) -> QPointF;
+
+        /// Returns the horizontal component of the line's vector.
+        fn dx(self: &QLineF) -> f64;
+
+        /// Returns the vertical component of the line's vector.
+        fn dy(self: &QLineF) -> f64;
+
+        /// Returns true if the line does not have distinct start and end points; otherwise returns false.
+        #[rust_name = "is_null"]
+        fn isNull(self: &QLineF) -> bool;
+
+        /// Sets the starting point of this line to p1.
+        #[rust_name = "set_p1"]
+        fn setP1(self: &mut QLineF, p1: &QPointF);
+
+        /// Sets the end point of this line to p2.
+        #[rust_name = "set_p2"]
+        fn setP2(self: &mut QLineF, p1: &QPointF);
+
+        /// Sets this line to the start in x1, y1 and end in x2, y2.
+        #[rust_name = "set_line"]
+        fn setLine(self: &mut QLineF, x1: f64, y1: f64, x2: f64, y2: f64);
+
+        /// Sets the start point of this line to p1 and the end point of this line to p2.
+        #[rust_name = "set_points"]
+        fn setPoints(self: &mut QLineF, p1: &QPointF, p2: &QPointF);
+
+        /// Translates this line by the given offset.
+        fn translate(self: &mut QLineF, offset: &QPointF);
+
+        /// Returns this line translated by the given offset.
+        fn translated(self: &QLineF, offset: &QPointF) -> QLineF;
+    }
+
+    #[namespace = "rust::cxxqtlib1"]
+    unsafe extern "C++" {
+        include!("cxx-qt-lib/common.h");
+
+        #[doc(hidden)]
+        #[rust_name = "qlinef_default"]
+        fn construct() -> QLineF;
+
+        #[doc(hidden)]
+        #[rust_name = "qlinef_new"]
+        fn construct(pt1: QPointF, pt2: QPointF) -> QLineF;
+        #[doc(hidden)]
+        #[rust_name = "qlinef_from_qline"]
+        fn construct(line: &QLine) -> QLineF;
+    }
+}
+
+/// The QLineF class provides a two-dimensional vector using floating point precision.
+#[derive(Debug, Clone, PartialEq)]
+#[repr(C)]
+pub struct QLineF {
+    pt1: QPointF,
+    pt2: QPointF,
+}
+
+impl QLineF {
+    /// Constructs a line object that represents the line between pt1 and pt2.
+    pub fn new(pt1: QPointF, pt2: QPointF) -> Self {
+        ffi::qlinef_new(pt1, pt2)
+    }
+}
+
+impl Default for QLineF {
+    /// Constructs a default qlinef
+    fn default() -> Self {
+        ffi::qlinef_default()
+    }
+}
+
+impl From<&ffi::QLine> for QLineF {
+    /// Construct a QLineF object from the given integer-based line.
+    fn from(line: &QLine) -> Self {
+        ffi::qlinef_from_qline(line)
+    }
+}
+
+// Safety:
+//
+// Static checks on the C++ side ensure that QLineF is trivial.
+unsafe impl ExternType for QLineF {
+    type Id = type_id!("QLineF");
+    type Kind = cxx::kind::Trivial;
+}

crates/cxx-qt-lib/src/core/qpersistentmodelindex.rs

@@ -31,6 +31,9 @@ mod ffi {
         fn row(self: &QPersistentModelIndex) -> i32;
         /// Returns the sibling at row and column or an invalid QModelIndex if there is no sibling at this position.
         fn sibling(self: &QPersistentModelIndex, row: i32, column: i32) -> QModelIndex;
+
+        /// Swaps this persistent modelindex with other. This function is very fast and never fails.
+        fn swap(self: &mut QPersistentModelIndex, other: &mut QPersistentModelIndex);
     }
 
     #[namespace = "rust::cxxqtlib1"]

crates/cxx-qt-lib/src/core/qstring.rs

@@ -81,6 +81,10 @@ mod ffi {
         /// Returns true if the string starts with s; otherwise returns false.
         #[rust_name = "starts_with"]
         fn startsWith(self: &QString, s: &QString, cs: CaseSensitivity) -> bool;
+
+        /// Converts a plain text string to an HTML string with HTML metacharacters <, >, &, and " replaced by HTML entities.
+        #[rust_name = "to_html_escaped"]
+        fn toHtmlEscaped(self: &QString) -> QString;
     }
 
     #[namespace = "rust::cxxqtlib1"]