qtbridge-runtime 0.3.0

Qt Bridge: bridging code to be run in applications.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

// Copyright (C) 2026 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only

use qtbridge_type_lib::QVariant;

use crate::QMetaTypeCompatible;

/// A type that cross to and from QML by value.
///
/// This is the bound for values stored in a model role (see
/// [`QModelItem`](crate::QModelItem)) and for value-typed properties and
/// method arguments. Implemented for:
/// - Primitive numeric types and `bool`
/// - [`String`]
/// - [`Vec<T>`] where `T` is one of the above
///
/// `QObject` handles (`Rc<RefCell<T>>`) are deliberately not
/// `QVariantConvertible` as they cross as a pointer.
pub trait QVariantConvertible: Sized {
    /// Convert to QVariant. Intended for use with references only.
    fn to_qvariant(&self) -> QVariant;
    /// Fallible conversion from QVariant to a value type.
    fn try_from_qvariant(value: &QVariant) -> Result<Self, ()>;

}

/// Implement `QVariantConvertible` traits using `QMetaTypeCompatible`.
macro_rules! impl_to_qvariant_and_try_from_qvariant {
    ($($t:ty),*) => {
        $(
            impl QVariantConvertible for $t {
                // Conversion from referenced value to QVariant.
                fn to_qvariant(&self) -> QVariant {
                    let compat = QMetaTypeCompatible::to_compatible(self);
                    (&compat).into()
                }
                // Conversion from a QVariant to value.
                fn try_from_qvariant(value: &QVariant) -> Result<Self, ()> {
                    let compat: <$t as QMetaTypeCompatible>::CompatibleType = value.value()
                        .ok_or(())?;
                    Ok(<Self as QMetaTypeCompatible>::from_compatible(&compat))
                }
            }
        )*
    }
}

impl_to_qvariant_and_try_from_qvariant!(
    bool, i8, u8, i16, u16, i32, u32, i64, u64, isize, usize, f32, f64, String,
    Vec<bool>, Vec<i8>, Vec<u8>, Vec<i16>, Vec<u16>, Vec<i32>, Vec<u32>, Vec<i64>, Vec<u64>,
    Vec<isize>, Vec<usize>, Vec<f32>, Vec<f64>, Vec<String>
);

impl QVariantConvertible for () {
    fn to_qvariant(&self) -> QVariant {
        QVariant::default()
    }
    fn try_from_qvariant(value: &QVariant) -> Result<Self, ()> {
        match value.is_valid() {
            true => Err(()),
            false => Ok(()),
        }
    }
}

#[cfg(feature = "serde_json")]
impl QVariantConvertible for serde_json::Value {
    fn to_qvariant(&self) -> QVariant {
        let jv = crate::serde_tools::serde_to_qjsonvalue(self);
        (&jv).into()
    }
    fn try_from_qvariant(value: &QVariant) -> Result<Self, ()> {
        crate::serde_tools::qvariant_to_serde(value)
    }
}

#[cfg(feature = "serde_json")]
impl QVariantConvertible for Vec<serde_json::Value> {
    fn to_qvariant(&self) -> QVariant {
        let ja = crate::serde_tools::serde_to_qjsonarray(self);
        (&ja).into()
    }
    fn try_from_qvariant(value: &QVariant) -> Result<Self, ()> {
        match crate::serde_tools::qvariant_to_serde(value)? {
            serde_json::Value::Array(arr) => Ok(arr),
            _ => Err(()),
        }
    }
}