#![cfg_attr(no_qt, allow(unused))]
use std::collections::HashMap;
use std::convert::From;
use std::fmt;
use std::hash::Hash;
use std::iter::FromIterator;
use std::ops::{Index, IndexMut};
#[cfg(feature = "chrono")]
use chrono::prelude::*;
#[cfg(no_qt)]
pub(crate) mod no_qt {
pub fn panic<T>() -> T {
panic!("Qt was not found during build")
}
}
pub(crate) mod internal_prelude {
#[cfg(not(no_qt))]
pub(crate) use cpp::{cpp, cpp_class};
#[cfg(no_qt)]
macro_rules! cpp {
{{ $($t:tt)* }} => {};
{$(unsafe)? [$($a:tt)*] -> $ret:ty as $b:tt { $($t:tt)* } } => {
crate::no_qt::panic::<$ret>()
};
{ $($t:tt)* } => {
crate::no_qt::panic::<()>()
};
}
#[cfg(no_qt)]
macro_rules! cpp_class {
($(#[$($attrs:tt)*])* $vis:vis unsafe struct $name:ident as $type:expr) => {
#[derive(Default, Ord, Eq, PartialEq, PartialOrd, Clone, Copy)]
#[repr(C)]
$vis struct $name;
};
}
#[cfg(no_qt)]
pub(crate) use cpp;
#[cfg(no_qt)]
pub(crate) use cpp_class;
}
use internal_prelude::*;
mod qtcore;
pub use crate::qtcore::{
qreal, NormalizationForm, QByteArray, QListIterator, QSettings, QString, QStringList, QUrl,
QVariant, QVariantList, UnicodeVersion,
};
mod qtgui;
pub use crate::qtgui::{QColor, QColorNameFormat, QColorSpec, QRgb, QRgba64};
cpp! {{
#include <QtCore/QByteArray>
#include <QtCore/QDateTime>
#include <QtCore/QModelIndex>
#include <QtCore/QString>
#include <QtCore/QUrl>
#include <QtCore/QVariant>
#include <QtGui/QImage>
#include <QtGui/QPixmap>
#include <QtGui/QPainter>
#include <QtGui/QPen>
#include <QtGui/QBrush>
}}
cpp_class!(
#[derive(PartialEq, PartialOrd, Eq, Ord)]
pub unsafe struct QDate as "QDate"
);
impl QDate {
pub fn from_y_m_d(y: i32, m: i32, d: i32) -> Self {
cpp!(unsafe [y as "int", m as "int", d as "int"] -> QDate as "QDate" {
return QDate(y, m, d);
})
}
pub fn get_y_m_d(&self) -> (i32, i32, i32) {
let mut res = (0, 0, 0);
let (ref mut y, ref mut m, ref mut d) = res;
cpp!(unsafe [self as "QDate*", y as "int*", m as "int*", d as "int*"] {
return self->getDate(y, m, d);
});
res
}
pub fn is_valid(&self) -> bool {
cpp!(unsafe [self as "const QDate*"] -> bool as "bool" {
return self->isValid();
})
}
}
#[cfg(feature = "chrono")]
impl From<NaiveDate> for QDate {
fn from(a: NaiveDate) -> QDate {
QDate::from_y_m_d(a.year() as i32, a.month() as i32, a.day() as i32)
}
}
#[cfg(feature = "chrono")]
impl Into<NaiveDate> for QDate {
fn into(self) -> NaiveDate {
let (y, m, d) = self.get_y_m_d();
NaiveDate::from_ymd(y, m as u32, d as u32)
}
}
#[test]
fn test_qdate() {
let date = QDate::from_y_m_d(2019, 10, 22);
assert_eq!((2019, 10, 22), date.get_y_m_d());
}
#[test]
fn test_qdate_is_valid() {
let valid_qdate = QDate::from_y_m_d(2019, 10, 26);
assert!(valid_qdate.is_valid());
let invalid_qdate = QDate::from_y_m_d(-1, -1, -1);
assert!(!invalid_qdate.is_valid());
}
#[cfg(feature = "chrono")]
#[test]
fn test_qdate_chrono() {
let chrono_date = NaiveDate::from_ymd(2019, 10, 22);
let qdate: QDate = chrono_date.into();
let actual_chrono_date: NaiveDate = qdate.into();
assert_eq!((2019, 10, 22), qdate.get_y_m_d());
assert_eq!(chrono_date, actual_chrono_date);
}
cpp_class!(
#[derive(PartialEq, PartialOrd, Eq, Ord)]
pub unsafe struct QTime as "QTime"
);
impl QTime {
pub fn from_h_m_s_ms(h: i32, m: i32, s: Option<i32>, ms: Option<i32>) -> Self {
let s = s.unwrap_or(0);
let ms = ms.unwrap_or(0);
cpp!(unsafe [h as "int", m as "int", s as "int", ms as "int"] -> QTime as "QTime" {
return QTime(h, m, s, ms);
})
}
pub fn get_hour(&self) -> i32 {
cpp!(unsafe [self as "const QTime*"] -> i32 as "int" {
return self->hour();
})
}
pub fn get_minute(&self) -> i32 {
cpp!(unsafe [self as "const QTime*"] -> i32 as "int" {
return self->minute();
})
}
pub fn get_second(&self) -> i32 {
cpp!(unsafe [self as "const QTime*"] -> i32 as "int" {
return self->second();
})
}
pub fn get_msec(&self) -> i32 {
cpp!(unsafe [self as "const QTime*"] -> i32 as "int" {
return self->msec();
})
}
pub fn get_h_m_s_ms(&self) -> (i32, i32, i32, i32) {
(self.get_hour(), self.get_minute(), self.get_second(), self.get_msec())
}
pub fn is_valid(&self) -> bool {
cpp!(unsafe [self as "const QTime*"] -> bool as "bool" {
return self->isValid();
})
}
}
#[cfg(feature = "chrono")]
impl From<NaiveTime> for QTime {
fn from(a: NaiveTime) -> QTime {
QTime::from_h_m_s_ms(
a.hour() as i32,
a.minute() as i32,
Some(a.second() as i32),
Some(a.nanosecond() as i32 / 1_000_000),
)
}
}
#[cfg(feature = "chrono")]
impl Into<NaiveTime> for QTime {
fn into(self) -> NaiveTime {
let (h, m, s, ms) = self.get_h_m_s_ms();
NaiveTime::from_hms_milli(h as u32, m as u32, s as u32, ms as u32)
}
}
#[test]
fn test_qtime() {
let qtime = QTime::from_h_m_s_ms(10, 30, Some(40), Some(300));
assert_eq!((10, 30, 40, 300), qtime.get_h_m_s_ms());
}
#[cfg(feature = "chrono")]
#[test]
fn test_qtime_chrono() {
let chrono_time = NaiveTime::from_hms(10, 30, 50);
let qtime: QTime = chrono_time.into();
let actual_chrono_time: NaiveTime = qtime.into();
assert_eq!((10, 30, 50, 0), qtime.get_h_m_s_ms());
assert_eq!(chrono_time, actual_chrono_time);
}
#[test]
fn test_qtime_is_valid() {
let valid_qtime = QTime::from_h_m_s_ms(10, 30, Some(40), Some(300));
assert!(valid_qtime.is_valid());
let invalid_qtime = QTime::from_h_m_s_ms(10, 30, Some(40), Some(9999));
assert!(!invalid_qtime.is_valid());
}
cpp_class!(
#[derive(PartialEq, PartialOrd, Eq, Ord)]
pub unsafe struct QDateTime as "QDateTime"
);
impl QDateTime {
pub fn from_date(date: QDate) -> Self {
cpp!(unsafe [date as "QDate"] -> QDateTime as "QDateTime" {
#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
return date.startOfDay();
#else
return QDateTime(date);
#endif
})
}
pub fn from_date_time_local_timezone(date: QDate, time: QTime) -> Self {
cpp!(unsafe [date as "QDate", time as "QTime"] -> QDateTime as "QDateTime" {
return QDateTime(date, time);
})
}
pub fn get_date(&self) -> QDate {
cpp!(unsafe [self as "const QDateTime*"] -> QDate as "QDate" {
return self->date();
})
}
pub fn get_time(&self) -> QTime {
cpp!(unsafe [self as "const QDateTime*"] -> QTime as "QTime" {
return self->time();
})
}
pub fn get_date_time(&self) -> (QDate, QTime) {
(self.get_date(), self.get_time())
}
pub fn is_valid(&self) -> bool {
cpp!(unsafe [self as "const QDateTime*"] -> bool as "bool" {
return self->isValid();
})
}
}
#[test]
fn test_qdatetime_from_date() {
let qdate = QDate::from_y_m_d(2019, 10, 22);
let qdatetime = QDateTime::from_date(qdate);
let actual_qdate = qdatetime.get_date();
assert_eq!((2019, 10, 22), actual_qdate.get_y_m_d());
}
#[test]
fn test_qdatetime_from_date_time_local_timezone() {
let qdate = QDate::from_y_m_d(2019, 10, 22);
let qtime = QTime::from_h_m_s_ms(10, 30, Some(40), Some(300));
let qdatetime = QDateTime::from_date_time_local_timezone(qdate, qtime);
let (actual_qdate, actual_qtime) = qdatetime.get_date_time();
assert_eq!((2019, 10, 22), actual_qdate.get_y_m_d());
assert_eq!((10, 30, 40, 300), actual_qtime.get_h_m_s_ms());
assert_eq!(10, actual_qtime.get_hour());
assert_eq!(30, actual_qtime.get_minute());
assert_eq!(40, actual_qtime.get_second());
assert_eq!(300, actual_qtime.get_msec());
}
#[test]
fn test_qdatetime_is_valid() {
let valid_qdate = QDate::from_y_m_d(2019, 10, 26);
let invalid_qdate = QDate::from_y_m_d(-1, -1, -1);
let valid_qtime = QTime::from_h_m_s_ms(10, 30, Some(40), Some(300));
let invalid_qtime = QTime::from_h_m_s_ms(10, 30, Some(40), Some(9999));
let valid_qdatetime_from_date = QDateTime::from_date(valid_qdate);
assert!(valid_qdatetime_from_date.is_valid());
let valid_qdatetime_from_valid_date_valid_time =
QDateTime::from_date_time_local_timezone(valid_qdate, valid_qtime);
assert!(valid_qdatetime_from_valid_date_valid_time.is_valid());
let valid_qdatetime_from_valid_date_invalid_time =
QDateTime::from_date_time_local_timezone(valid_qdate, invalid_qtime);
assert!(valid_qdatetime_from_valid_date_invalid_time.is_valid());
let invalid_qdatetime_from_invalid_date_valid_time =
QDateTime::from_date_time_local_timezone(invalid_qdate, valid_qtime);
assert!(!invalid_qdatetime_from_invalid_date_valid_time.is_valid());
let invalid_qdatetime_from_invalid_date_invalid_time =
QDateTime::from_date_time_local_timezone(invalid_qdate, invalid_qtime);
assert!(!invalid_qdatetime_from_invalid_date_invalid_time.is_valid());
}
cpp_class!(
#[derive(Default, PartialEq, Eq)]
pub unsafe struct QVariantMap as "QVariantMap"
);
impl QVariantMap {
pub fn insert(&mut self, key: QString, element: QVariant) {
cpp!(unsafe [self as "QVariantMap*", key as "QString", element as "QVariant"] {
self->insert(key, std::move(element));
})
}
pub fn remove(&mut self, key: QString) -> usize {
cpp!(unsafe [self as "QVariantMap*", key as "QString"] -> usize as "size_t" {
return self->remove(key);
})
}
pub fn take(&mut self, key: QString) -> QVariant {
cpp!(unsafe [self as "QVariantMap*", key as "QString"] -> QVariant as "QVariant" {
return self->take(key);
})
}
pub fn len(&self) -> usize {
cpp!(unsafe [self as "const QVariantMap*"] -> usize as "size_t" {
return self->size();
})
}
pub fn is_empty(&self) -> bool {
cpp!(unsafe [self as "const QVariantMap*"] -> bool as "bool" {
return self->isEmpty();
})
}
pub fn contains(&self, key: QString) -> bool {
cpp!(unsafe [self as "const QVariantMap*", key as "QString"] -> bool as "bool" {
return self->contains(key);
})
}
pub fn clear(&mut self) {
cpp!(unsafe [self as "QVariantMap*"] {
self->clear();
})
}
pub fn value(&self, key: QString, default_value: QVariant) -> QVariant {
cpp!(unsafe [self as "const QVariantMap*", key as "QString", default_value as "QVariant"] -> QVariant as "QVariant" {
return self->value(key, default_value);
})
}
pub fn key(&self, value: QVariant, default_key: QString) -> QString {
cpp!(unsafe [self as "const QVariantMap*", default_key as "QString", value as "QVariant"] -> QString as "QString" {
return self->key(value, default_key);
})
}
}
impl Index<QString> for QVariantMap {
type Output = QVariant;
#[track_caller]
fn index(&self, key: QString) -> &Self::Output {
cpp!(unsafe [self as "const QVariantMap*", key as "QString"] -> Option<&QVariant> as "const QVariant*" {
auto x = self->constFind(key);
if (x == self->constEnd()) {
return NULL;
} else {
return &x.value();
}
}).expect("key not in the QVariant")
}
}
impl IndexMut<QString> for QVariantMap {
fn index_mut(&mut self, key: QString) -> &mut Self::Output {
unsafe {
&mut *cpp!([self as "QVariantMap*", key as "QString"] -> *mut QVariant as "QVariant*" {
return &(*self)[key];
})
}
}
}
impl fmt::Debug for QVariantMap {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_map().entries(self.into_iter()).finish()
}
}
cpp_class!(unsafe struct QVariantMapIteratorInternal as "QVariantMap::iterator");
pub struct QVariantMapIterator<'a> {
map: &'a QVariantMap,
iterator: QVariantMapIteratorInternal,
}
impl<'a> QVariantMapIterator<'a> {
fn key(&self) -> Option<&'a QString> {
let iterator = &self.iterator;
cpp!(unsafe [iterator as "const QVariantMap::iterator*"] -> Option<&QString> as "const QString*" {
return &iterator->key();
})
}
fn value(&self) -> Option<&'a QVariant> {
let iterator = &self.iterator;
cpp!(unsafe [iterator as "const QVariantMap::iterator*"] -> Option<&QVariant> as "QVariant*" {
return &iterator->value();
})
}
fn check_end(&self) -> bool {
let map = self.map;
let iterator = &self.iterator;
cpp!(unsafe [iterator as "const QVariantMap::iterator*", map as "const QVariantMap*"] -> bool as "bool" {
return (*iterator == map->end());
})
}
fn increment(&mut self) {
let iterator = &self.iterator;
cpp!(unsafe [iterator as "QVariantMap::iterator*"] {
++(*iterator);
})
}
}
impl<'a> Iterator for QVariantMapIterator<'a> {
type Item = (&'a QString, &'a QVariant);
fn next(&mut self) -> Option<Self::Item> {
if self.check_end() {
return None;
}
let key = self.key();
let value = self.value();
self.increment();
match (key, value) {
(Some(k), Some(v)) => Some((k, v)),
_ => None,
}
}
}
impl<'a> IntoIterator for &'a QVariantMap {
type Item = (&'a QString, &'a QVariant);
type IntoIter = QVariantMapIterator<'a>;
fn into_iter(self) -> Self::IntoIter {
let iter = cpp!(unsafe [self as "QVariantMap*"] -> QVariantMapIteratorInternal as "QVariantMap::iterator" {
return self->begin();
});
Self::IntoIter { map: self, iterator: iter }
}
}
impl<K, V> FromIterator<(K, V)> for QVariantMap
where
K: Into<QString>,
V: Into<QVariant>,
{
fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
let mut m = QVariantMap::default();
for i in iter {
let (k, v) = i;
m.insert(k.into(), v.into());
}
m
}
}
impl<K, V> From<HashMap<K, V>> for QVariantMap
where
K: Into<QString>,
V: Into<QVariant>,
{
fn from(m: HashMap<K, V>) -> Self {
m.into_iter().collect()
}
}
impl<K, V, const N: usize> From<[(K, V); N]> for QVariantMap
where
K: Into<QString>,
V: Into<QVariant>,
{
fn from(m: [(K, V); N]) -> Self {
let mut temp = QVariantMap::default();
for (key, val) in m {
temp.insert(key.into(), val.into());
}
temp
}
}
impl<K, V> From<QVariantMap> for HashMap<K, V>
where
K: Hash + Eq,
V: Eq,
QString: Into<K>,
QVariant: Into<V>,
{
fn from(m: QVariantMap) -> Self {
m.into_iter().map(|(k, v)| (k.clone().into(), v.clone().into())).collect()
}
}
#[cfg(test)]
mod qvariantmap_tests {
use super::*;
#[test]
fn test_qvariantmap() {
let mut map = QVariantMap::default();
let key1 = QString::from("a");
let val1 = QString::from("abc");
assert!(map.is_empty());
map.insert(key1.clone(), val1.clone().into());
assert_eq!(map.len(), 1);
assert_eq!(map[key1.clone()].to_qbytearray().to_string(), val1.to_string());
assert_eq!(map.take(key1.clone()).to_qbytearray().to_string(), val1.to_string());
assert!(map.is_empty());
map[key1.clone()] = val1.clone().into();
let default_value = QVariant::from(10);
assert_eq!(map[key1.clone()].to_qbytearray().to_string(), val1.to_string());
assert_eq!(map.value(key1.clone(), default_value.clone()), val1.clone().into());
assert_eq!(map.value(val1.clone(), default_value.clone()), default_value.clone());
assert_eq!(map.key(val1.clone().into(), val1.clone()), key1.clone());
assert_eq!(map.key(key1.clone().into(), val1.clone()), val1.clone());
}
#[test]
#[should_panic(expected = "key not in the QVariant")]
fn test_index_panic() {
let map = QVariantMap::default();
map[QString::from("t")].to_qbytearray().to_string();
}
#[test]
fn test_iter() {
let hashmap =
HashMap::from([("Mercury", 0.4), ("Venus", 0.7), ("Earth", 1.0), ("Mars", 1.5)]);
let map: QVariantMap = hashmap.clone().into();
assert_eq!(map.len(), hashmap.len());
for (k, v) in map.into_iter() {
assert_eq!(hashmap[k.to_string().as_str()].to_string(), v.to_qbytearray().to_string());
}
}
#[test]
fn test_from() {
let hashmap1 = HashMap::from([
("A".to_string(), QVariant::from(QString::from("abc"))),
("B".to_string(), QVariant::from(QString::from("def"))),
]);
let qvariantmap1: QVariantMap = hashmap1.clone().into();
let hashmap2 = qvariantmap1.clone().into();
assert_eq!(hashmap1, hashmap2);
let qvariantmap2 = QVariantMap::from([
("A".to_string(), QVariant::from(QString::from("abc"))),
("B".to_string(), QVariant::from(QString::from("def"))),
]);
assert_eq!(qvariantmap1, qvariantmap2);
}
}
cpp_class!(
#[derive(PartialEq, Eq)]
pub unsafe struct QModelIndex as "QModelIndex"
);
impl QModelIndex {
pub fn id(&self) -> usize {
cpp!(unsafe [self as "const QModelIndex*"] -> usize as "uintptr_t" { return self->internalId(); })
}
pub fn column(&self) -> i32 {
cpp!(unsafe [self as "const QModelIndex*"] -> i32 as "int" { return self->column(); })
}
pub fn row(&self) -> i32 {
cpp!(unsafe [self as "const QModelIndex*"] -> i32 as "int" { return self->row(); })
}
pub fn is_valid(&self) -> bool {
cpp!(unsafe [self as "const QModelIndex*"] -> bool as "bool" { return self->isValid(); })
}
}
#[repr(C)]
#[derive(Default, Clone, Copy, PartialEq, Debug)]
pub struct QRectF {
pub x: qreal,
pub y: qreal,
pub width: qreal,
pub height: qreal,
}
impl QRectF {
pub fn contains(&self, pos: QPointF) -> bool {
cpp!(unsafe [self as "const QRectF*", pos as "QPointF"] -> bool as "bool" {
return self->contains(pos);
})
}
pub fn top_left(&self) -> QPointF {
QPointF { x: self.x, y: self.y }
}
pub fn is_valid(&self) -> bool {
self.width > 0. && self.height > 0.
}
}
#[repr(C)]
#[derive(Default, Clone, Copy, PartialEq, Debug)]
pub struct QPointF {
pub x: qreal,
pub y: qreal,
}
impl std::ops::Add for QPointF {
type Output = QPointF;
fn add(self, other: QPointF) -> QPointF {
QPointF { x: self.x + other.x, y: self.y + other.y }
}
}
impl std::ops::AddAssign for QPointF {
fn add_assign(&mut self, other: QPointF) {
*self = QPointF { x: self.x + other.x, y: self.y + other.y };
}
}
#[repr(C)]
#[derive(Default, Clone, Copy, PartialEq, Debug)]
pub struct QSizeF {
pub width: qreal,
pub height: qreal,
}
#[test]
fn test_qpointf_qrectf() {
let rect = QRectF { x: 200., y: 150., width: 60., height: 75. };
let pt = QPointF { x: 12., y: 5.5 };
assert!(!rect.contains(pt));
assert!(rect.contains(pt + rect.top_left()));
}
#[repr(C)]
#[derive(Default, Clone, Copy, PartialEq, Debug)]
pub struct QSize {
pub width: u32,
pub height: u32,
}
#[repr(C)]
#[derive(Default, Clone, Copy, PartialEq, Debug)]
pub struct QPoint {
pub x: i32,
pub y: i32,
}
#[repr(C)]
#[derive(Default, Clone, Copy, PartialEq, Debug)]
pub struct QMargins {
pub left: i32,
pub top: i32,
pub right: i32,
pub bottom: i32,
}
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Debug)]
#[allow(non_camel_case_types)]
pub enum ImageFormat {
Invalid = 0,
Mono = 1,
MonoLSB = 2,
Indexed8 = 3,
RGB32 = 4,
ARGB32 = 5,
ARGB32_Premultiplied = 6,
RGB16 = 7,
ARGB8565_Premultiplied = 8,
RGB666 = 9,
ARGB6666_Premultiplied = 10,
RGB555 = 11,
ARGB8555_Premultiplied = 12,
RGB888 = 13,
RGB444 = 14,
ARGB4444_Premultiplied = 15,
RGBX8888 = 16,
RGBA8888 = 17,
RGBA8888_Premultiplied = 18,
BGR30 = 19,
A2BGR30_Premultiplied = 20,
RGB30 = 21,
A2RGB30_Premultiplied = 22,
Alpha8 = 23,
Grayscale8 = 24,
Grayscale16 = 28,
RGBX64 = 25,
RGBA64 = 26,
RGBA64_Premultiplied = 27,
BGR888 = 29,
}
cpp_class!(
#[derive(Default, Clone, PartialEq)]
pub unsafe struct QImage as "QImage"
);
impl QImage {
pub fn load_from_file(filename: QString) -> Self {
cpp!(unsafe [filename as "QString"] -> QImage as "QImage" {
return QImage(filename);
})
}
pub fn new(size: QSize, format: ImageFormat) -> Self {
cpp!(unsafe [size as "QSize", format as "QImage::Format" ] -> QImage as "QImage" {
return QImage(size, format);
})
}
pub fn size(&self) -> QSize {
cpp!(unsafe [self as "const QImage*"] -> QSize as "QSize" { return self->size(); })
}
pub fn format(&self) -> ImageFormat {
cpp!(unsafe [self as "const QImage*"] -> ImageFormat as "QImage::Format" { return self->format(); })
}
pub fn fill(&mut self, color: QColor) {
cpp!(unsafe [self as "QImage*", color as "QColor"] { self->fill(color); })
}
pub fn set_pixel_color(&mut self, x: u32, y: u32, color: QColor) {
cpp!(unsafe [self as "QImage*", x as "int", y as "int", color as "QColor"] {
self->setPixelColor(x, y, color);
})
}
pub fn get_pixel_color(&self, x: u32, y: u32) -> QColor {
cpp!(unsafe [self as "const QImage*", x as "int", y as "int"] -> QColor as "QColor" {
return self->pixelColor(x, y);
})
}
}
cpp_class!(
pub unsafe struct QPixmap as "QPixmap"
);
impl QPixmap {
pub fn size(&self) -> QSize {
cpp!(unsafe [self as "const QPixmap*"] -> QSize as "QSize" { return self->size(); })
}
}
impl From<QPixmap> for QImage {
fn from(pixmap: QPixmap) -> Self {
cpp!(unsafe [pixmap as "QPixmap"] -> QImage as "QImage" { return pixmap.toImage(); })
}
}
impl From<QImage> for QPixmap {
fn from(image: QImage) -> Self {
cpp!(unsafe [image as "QImage"] -> QPixmap as "QPixmap" { return QPixmap::fromImage(image); })
}
}
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Debug)]
#[allow(non_camel_case_types)]
pub enum PenStyle {
NoPen = 0,
SolidLine = 1,
DashLine = 2,
DotLine = 3,
DashDotLine = 4,
DashDotDotLine = 5,
CustomDashLine = 6,
}
cpp_class!(
#[derive(Default)]
pub unsafe struct QPen as "QPen"
);
impl QPen {
pub fn from_color(color: QColor) -> Self {
cpp!(unsafe [color as "QColor"] -> QPen as "QPen" { return QPen(color); })
}
pub fn from_style(style: PenStyle) -> Self {
cpp!(unsafe [style as "Qt::PenStyle"] -> QPen as "QPen" { return QPen(style); })
}
pub fn set_color(&mut self, color: QColor) {
cpp!(unsafe [self as "QPen*", color as "QColor"] { return self->setColor(color); });
}
pub fn set_style(&mut self, style: PenStyle) {
cpp!(unsafe [self as "QPen*", style as "Qt::PenStyle"] { return self->setStyle(style); });
}
pub fn set_width(&mut self, width: i32) {
cpp!(unsafe [self as "QPen*", width as "int"] { return self->setWidth(width); });
}
pub fn set_width_f(&mut self, width: qreal) {
cpp!(unsafe [self as "QPen*", width as "qreal"] { return self->setWidthF(width); });
}
}
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Debug)]
#[allow(non_camel_case_types)]
pub enum QStandardPathLocation {
DesktopLocation = 0,
DocumentsLocation = 1,
FontsLocation = 2,
ApplicationsLocation = 3,
MusicLocation = 4,
MoviesLocation = 5,
PicturesLocation = 6,
TempLocation = 7,
HomeLocation = 8,
AppLocalDataLocation = 9,
CacheLocation = 10,
GenericDataLocation = 11,
RuntimeLocation = 12,
ConfigLocation = 13,
DownloadLocation = 14,
GenericCacheLocation = 15,
GenericConfigLocation = 16,
AppDataLocation = 17,
AppConfigLocation = 18,
}
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Debug)]
#[allow(non_camel_case_types)]
pub enum BrushStyle {
NoBrush = 0,
SolidPattern = 1,
Dense1Pattern = 2,
Dense2Pattern = 3,
Dense3Pattern = 4,
Dense4Pattern = 5,
Dense5Pattern = 6,
Dense6Pattern = 7,
Dense7Pattern = 8,
HorPattern = 9,
VerPattern = 10,
CrossPattern = 11,
BDiagPattern = 12,
FDiagPattern = 13,
DiagCrossPattern = 14,
LinearGradientPattern = 15,
ConicalGradientPattern = 17,
RadialGradientPattern = 16,
TexturePattern = 24,
}
cpp_class!(
#[derive(Default)]
pub unsafe struct QBrush as "QBrush "
);
impl QBrush {
pub fn from_color(color: QColor) -> Self {
cpp!(unsafe [color as "QColor"] -> QBrush as "QBrush" { return QBrush(color); })
}
pub fn from_style(style: BrushStyle) -> Self {
cpp!(unsafe [style as "Qt::BrushStyle"] -> QBrush as "QBrush" { return QBrush(style); })
}
pub fn set_color(&mut self, color: QColor) {
cpp!(unsafe [self as "QBrush*", color as "QColor"] { return self->setColor(color); });
}
pub fn set_style(&mut self, style: BrushStyle) {
cpp!(unsafe [self as "QBrush*", style as "Qt::BrushStyle"] { return self->setStyle(style); });
}
}
#[repr(C)]
#[derive(Default, Clone, Copy, PartialEq, Debug)]
pub struct QLineF {
pub pt1: QPointF,
pub pt2: QPointF,
}
cpp_class!(
pub unsafe struct QPainter as "QPainter "
);
impl QPainter {
pub fn draw_arc(&mut self, rectangle: QRectF, start_angle: i32, span_angle: i32) {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF", start_angle as "int", span_angle as "int"] {
self->drawArc(rectangle, start_angle, span_angle);
});
}
pub fn draw_chord(&mut self, rectangle: QRectF, start_angle: i32, span_angle: i32) {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF", start_angle as "int", span_angle as "int"] {
self->drawChord(rectangle, start_angle, span_angle);
});
}
pub fn draw_convex_polygon(&mut self, points: &[QPointF]) {
let points_ptr = points.as_ptr();
let points_count = points.len() as u64;
cpp!(unsafe [self as "QPainter *", points_ptr as "QPointF*", points_count as "uint64_t"] {
self->drawConvexPolygon(points_ptr, points_count);
});
}
pub fn draw_ellipse(&mut self, rectangle: QRectF) {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF"] {
self->drawEllipse(rectangle);
});
}
pub fn draw_ellipse_with_center(&mut self, center: QPointF, rx: qreal, ry: qreal) {
cpp!(unsafe [self as "QPainter *", center as "QPointF", rx as "qreal", ry as "qreal"] {
self->drawEllipse(center, rx, ry);
});
}
pub fn draw_image_fit_rect(&mut self, rectangle: QRectF, image: QImage) {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF", image as "QImage"] {
self->drawImage(rectangle, image);
});
}
pub fn draw_image_at_point(&mut self, point: QPointF, image: QImage) {
cpp!(unsafe [self as "QPainter *", point as "QPointF", image as "QImage"] {
self->drawImage(point, image);
});
}
pub fn draw_image_fit_rect_with_source(
&mut self,
rectangle: QRectF,
image: QImage,
source_rect: QRectF,
) {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF", image as "QImage", source_rect as "QRectF"] {
self->drawImage(rectangle, image, source_rect);
});
}
pub fn draw_image_at_point_with_source(
&mut self,
point: QPointF,
image: QImage,
source_rect: QRectF,
) {
cpp!(unsafe [self as "QPainter *", point as "QPointF", image as "QImage", source_rect as "QRectF"] {
self->drawImage(point, image, source_rect);
});
}
pub fn draw_line(&mut self, line: QLineF) {
cpp!(unsafe [self as "QPainter *", line as "QLineF"] {
self->drawLine(line);
});
}
pub fn draw_lines(&mut self, lines: &[QLineF]) {
let lines_ptr = lines.as_ptr();
let lines_count = lines.len() as u64;
cpp!(unsafe [self as "QPainter *", lines_ptr as "QLineF*", lines_count as "uint64_t"] {
self->drawLines(lines_ptr, lines_count);
});
}
pub fn draw_lines_from_points(&mut self, point_pairs: &[QPointF]) {
let point_pairs_ptr = point_pairs.as_ptr();
let point_pairs_count = point_pairs.len() as u64;
cpp!(unsafe [self as "QPainter *", point_pairs_ptr as "QLineF*", point_pairs_count as "uint64_t"] {
self->drawLines(point_pairs_ptr, point_pairs_count);
});
}
pub fn draw_pie(&mut self, rectangle: QRectF, start_angle: i32, span_angle: i32) {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF", start_angle as "int", span_angle as "int"] {
self->drawPie(rectangle, start_angle, span_angle);
});
}
pub fn draw_point(&mut self, point: QPointF) {
cpp!(unsafe [self as "QPainter *", point as "QPointF"] {
self->drawPoint(point);
});
}
pub fn draw_points(&mut self, points: &[QPointF]) {
let points_ptr = points.as_ptr();
let points_count = points.len() as u64;
cpp!(unsafe [self as "QPainter *", points_ptr as "QPointF*", points_count as "uint64_t"] {
self->drawPoints(points_ptr, points_count);
});
}
pub fn draw_polygon(&mut self, points: &[QPointF]) {
let points_ptr = points.as_ptr();
let points_count = points.len() as u64;
cpp!(unsafe [self as "QPainter *", points_ptr as "QPointF*", points_count as "uint64_t"] {
self->drawPolygon(points_ptr, points_count);
});
}
pub fn draw_polyline(&mut self, points: &[QPointF]) {
let points_ptr = points.as_ptr();
let points_count = points.len() as u64;
cpp!(unsafe [self as "QPainter *", points_ptr as "QPointF*", points_count as "uint64_t"] {
self->drawPolyline(points_ptr, points_count);
});
}
pub fn draw_rect(&mut self, rectangle: QRectF) {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF"] {
self->drawRect(rectangle);
});
}
pub fn draw_rects(&mut self, rects: &[QRectF]) {
let rects_ptr = rects.as_ptr();
let rects_count = rects.len() as u64;
cpp!(unsafe [self as "QPainter *", rects_ptr as "QRectF*", rects_count as "uint64_t"] {
self->drawRects(rects_ptr, rects_count);
});
}
pub fn draw_rounded_rect(&mut self, rect: QRectF, x_radius: qreal, y_radius: qreal) {
cpp!(unsafe [self as "QPainter *", rect as "QRectF", x_radius as "qreal", y_radius as "qreal"] {
self->drawRoundedRect(rect, x_radius, y_radius);
});
}
pub fn draw_text(&mut self, position: QPointF, text: QString) {
cpp!(unsafe [self as "QPainter *", position as "QPointF", text as "QString"] {
self->drawText(position, text);
});
}
pub fn draw_text_in_rect(&mut self, rectangle: QRectF, flags: u32, text: QString) -> QRectF {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF", flags as "uint32_t", text as "QString"] -> QRectF as "QRectF" {
QRectF boundingRect;
self->drawText(rectangle, flags, text, &boundingRect);
return boundingRect;
})
}
pub fn erase_rect(&mut self, rectangle: QRectF) {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF"] {
self->eraseRect(rectangle);
});
}
pub fn fill_rect(&mut self, rectangle: QRectF, brush: QBrush) {
cpp!(unsafe [self as "QPainter *", rectangle as "QRectF", brush as "QBrush"] {
self->fillRect(rectangle, brush);
});
}
pub fn reset_transform(&mut self) {
cpp!(unsafe [self as "QPainter *"] {
self->resetTransform();
});
}
pub fn restore(&mut self) {
cpp!(unsafe [self as "QPainter *"] {
self->restore();
});
}
pub fn rotate(&mut self, angle: qreal) {
cpp!(unsafe [self as "QPainter *", angle as "qreal"] {
self->rotate(angle);
});
}
pub fn save(&mut self) {
cpp!(unsafe [self as "QPainter *"] {
self->save();
});
}
pub fn scale(&mut self, sx: qreal, sy: qreal) {
cpp!(unsafe [self as "QPainter *", sx as "qreal", sy as "qreal"] {
self->scale(sx, sy);
});
}
pub fn set_background(&mut self, brush: QBrush) {
cpp!(unsafe [self as "QPainter *", brush as "QBrush"] {
self->setBackground(brush);
});
}
pub fn set_brush(&mut self, brush: QBrush) {
cpp!(unsafe [self as "QPainter *", brush as "QBrush"] {
self->setBrush(brush);
});
}
pub fn set_opacity(&mut self, opacity: qreal) {
cpp!(unsafe [self as "QPainter *", opacity as "qreal"] {
self->setOpacity(opacity);
});
}
pub fn set_pen(&mut self, pen: QPen) {
cpp!(unsafe [self as "QPainter *", pen as "QPen"] {
self->setPen(pen);
});
}
pub fn translate(&mut self, offset: QPointF) {
cpp!(unsafe [self as "QPainter *", offset as "QPointF"] {
self->translate(offset);
});
}
pub fn set_render_hint(&mut self, hint: QPainterRenderHint, on: bool) {
cpp!(unsafe [self as "QPainter *", hint as "QPainter::RenderHint", on as "bool"] {
self->setRenderHint(hint, on);
});
}
}
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Debug)]
#[allow(non_camel_case_types)]
pub enum QPainterRenderHint {
Antialiasing = 0x01,
TextAntialiasing = 0x02,
SmoothPixmapTransform = 0x04,
HighQualityAntialiasing = 0x08,
NonCosmeticDefaultPen = 0x10,
Qt4CompatiblePainting = 0x20,
LosslessImageRendering = 0x40,
}
cpp! {{
#include <QtCore/QJsonDocument>
#include <QtCore/QJsonValue>
#include <QtCore/QJsonObject>
#include <QtCore/QJsonArray>
}}
cpp_class!(
#[derive(Default, PartialEq, Eq, Clone)]
pub unsafe struct QJsonValue as "QJsonValue"
);
impl Into<QVariant> for QJsonValue {
fn into(self) -> QVariant {
cpp!(unsafe [self as "QJsonValue"] -> QVariant as "QVariant" { return self.toVariant(); })
}
}
impl From<QVariant> for QJsonValue {
fn from(v: QVariant) -> QJsonValue {
cpp!(unsafe [v as "QVariant"] -> QJsonValue as "QJsonValue" { return QJsonValue::fromVariant(v); })
}
}
impl Into<QJsonObject> for QJsonValue {
fn into(self) -> QJsonObject {
cpp!(unsafe [self as "QJsonValue"] -> QJsonObject as "QJsonObject" { return self.toObject(); })
}
}
impl From<QJsonObject> for QJsonValue {
fn from(v: QJsonObject) -> QJsonValue {
cpp!(unsafe [v as "QJsonObject"] -> QJsonValue as "QJsonValue" { return QJsonValue(v); })
}
}
impl Into<QJsonArray> for QJsonValue {
fn into(self) -> QJsonArray {
cpp!(unsafe [self as "QJsonValue"] -> QJsonArray as "QJsonArray" { return self.toArray(); })
}
}
impl From<QJsonArray> for QJsonValue {
fn from(v: QJsonArray) -> QJsonValue {
cpp!(unsafe [v as "QJsonArray"] -> QJsonValue as "QJsonValue" { return QJsonValue(v); })
}
}
impl Into<QString> for QJsonValue {
fn into(self) -> QString {
cpp!(unsafe [self as "QJsonValue"] -> QString as "QString" { return self.toString(); })
}
}
impl From<QString> for QJsonValue {
fn from(v: QString) -> QJsonValue {
cpp!(unsafe [v as "QString"] -> QJsonValue as "QJsonValue" { return QJsonValue(v); })
}
}
impl Into<bool> for QJsonValue {
fn into(self) -> bool {
cpp!(unsafe [self as "QJsonValue"] -> bool as "bool" { return self.toBool(); })
}
}
impl From<bool> for QJsonValue {
fn from(v: bool) -> QJsonValue {
cpp!(unsafe [v as "bool"] -> QJsonValue as "QJsonValue" { return QJsonValue(v); })
}
}
impl Into<f64> for QJsonValue {
fn into(self) -> f64 {
cpp!(unsafe [self as "QJsonValue"] -> f64 as "double" { return self.toDouble(); })
}
}
impl From<f64> for QJsonValue {
fn from(v: f64) -> QJsonValue {
cpp!(unsafe [v as "double"] -> QJsonValue as "QJsonValue" { return QJsonValue(v); })
}
}
#[test]
fn test_qjsonvalue() {
let test_str = QJsonValue::from(QVariant::from(QString::from("test")));
let test_str2 = QJsonValue::from(QString::from("test"));
assert!(test_str == test_str2);
assert_eq!(<QJsonValue as Into<QString>>::into(test_str), QString::from("test"));
let test_bool = QJsonValue::from(true);
let test_bool_variant: QVariant = QJsonValue::from(true).into();
let test_bool_variant2 = QVariant::from(true);
assert!(test_bool_variant == test_bool_variant2);
assert_eq!(<QJsonValue as Into<bool>>::into(test_bool), true);
let test_f64 = QJsonValue::from(1.2345);
let test_f64_variant: QVariant = QJsonValue::from(1.2345).into();
let test_f64_variant2 = QVariant::from(1.2345);
assert!(test_f64_variant == test_f64_variant2);
assert_eq!(<QJsonValue as Into<f64>>::into(test_f64), 1.2345);
let values = QJsonArray::from(vec![
QJsonValue::from(QString::from("test")),
QJsonValue::from(true),
QJsonValue::from(false),
QJsonValue::from(1.2345),
QJsonValue::from(456.0),
]);
assert_eq!(values.to_json().to_string(), "[\"test\",true,false,1.2345,456]");
}
cpp_class!(
#[derive(Default, PartialEq, Eq, Clone)]
pub unsafe struct QJsonObject as "QJsonObject"
);
impl QJsonObject {
pub fn to_json(&self) -> QByteArray {
cpp!(unsafe [self as "QJsonObject*"] -> QByteArray as "QByteArray" { return QJsonDocument(*self).toJson(QJsonDocument::Compact); })
}
pub fn to_json_pretty(&self) -> QByteArray {
cpp!(unsafe [self as "QJsonObject*"] -> QByteArray as "QByteArray" { return QJsonDocument(*self).toJson(QJsonDocument::Indented); })
}
pub fn insert(&mut self, key: &str, value: QJsonValue) {
let len = key.len();
let ptr = key.as_ptr();
cpp!(unsafe [self as "QJsonObject*", len as "size_t", ptr as "char*", value as "QJsonValue"] { self->insert(QString::fromUtf8(ptr, len), std::move(value)); })
}
pub fn value(&self, key: &str) -> QJsonValue {
let len = key.len();
let ptr = key.as_ptr();
cpp!(unsafe [self as "QJsonObject*", len as "size_t", ptr as "char*"] -> QJsonValue as "QJsonValue" { return self->value(QString::fromUtf8(ptr, len)); })
}
pub fn take(&mut self, key: &str) -> QJsonValue {
let len = key.len();
let ptr = key.as_ptr();
cpp!(unsafe [self as "QJsonObject*", len as "size_t", ptr as "char*"] -> QJsonValue as "QJsonValue" { return self->take(QString::fromUtf8(ptr, len)); })
}
pub fn remove(&mut self, key: &str) {
let len = key.len();
let ptr = key.as_ptr();
cpp!(unsafe [self as "QJsonObject*", len as "size_t", ptr as "char*"] { return self->remove(QString::fromUtf8(ptr, len)); })
}
pub fn len(&self) -> usize {
cpp!(unsafe [self as "QJsonObject*"] -> usize as "size_t" { return self->size(); })
}
pub fn is_empty(&self) -> bool {
cpp!(unsafe [self as "QJsonObject*"] -> bool as "bool" { return self->isEmpty(); })
}
pub fn contains(&self, key: &str) -> bool {
let len = key.len();
let ptr = key.as_ptr();
cpp!(unsafe [self as "QJsonObject*", len as "size_t", ptr as "char*"] -> bool as "bool" { return self->contains(QString::fromUtf8(ptr, len)); })
}
pub fn keys(&self) -> Vec<String> {
let len = self.len();
let mut vec = Vec::with_capacity(len);
let keys = cpp!(unsafe [self as "QJsonObject*"] -> QStringList as "QStringList" { return self->keys(); });
for i in 0..len {
vec.push(keys[i].to_string());
}
vec
}
}
impl From<HashMap<String, String>> for QJsonObject {
fn from(v: HashMap<String, String>) -> QJsonObject {
let keys: Vec<QString> = v.keys().cloned().map(QString::from).collect();
let values: Vec<QString> = v.values().cloned().map(QString::from).collect();
let keys_ptr = keys.as_ptr();
let values_ptr = values.as_ptr();
let len = keys.len();
cpp!(unsafe [keys_ptr as "const QString*", values_ptr as "const QString*", len as "size_t"] -> QJsonObject as "QJsonObject" {
QJsonObject obj;
for (size_t i = 0; i < len; ++i) {
obj.insert(keys_ptr[i], values_ptr[i]);
}
return obj;
})
}
}
impl From<HashMap<String, QJsonValue>> for QJsonObject {
fn from(v: HashMap<String, QJsonValue>) -> QJsonObject {
let keys: Vec<QString> = v.keys().cloned().map(QString::from).collect();
let values: Vec<QJsonValue> = v.values().cloned().collect();
let keys_ptr = keys.as_ptr();
let values_ptr = values.as_ptr();
let len = keys.len();
cpp!(unsafe [keys_ptr as "const QString*", values_ptr as "const QJsonValue*", len as "size_t"] -> QJsonObject as "QJsonObject" {
QJsonObject obj;
for (size_t i = 0; i < len; ++i) {
obj.insert(keys_ptr[i], values_ptr[i]);
}
return obj;
})
}
}
cpp! {{ #include <QtCore/QDebug> }}
#[test]
fn test_qjsonobject() {
let mut hashmap = HashMap::new();
hashmap.insert("key".to_owned(), "value".to_owned());
hashmap.insert("test".to_owned(), "hello".to_owned());
let object = QJsonObject::from(hashmap);
assert_eq!(object.to_json().to_string(), "{\"key\":\"value\",\"test\":\"hello\"}");
let array = QJsonArray::from(vec![
QJsonValue::from(QString::from("test")),
QJsonValue::from(true),
QJsonValue::from(false),
QJsonValue::from(1.2345),
QJsonValue::from(456.0),
]);
let mut valuemap = HashMap::new();
valuemap.insert("1_string".to_owned(), QJsonValue::from(QString::from("test")));
valuemap.insert("2_bool".to_owned(), QJsonValue::from(true));
valuemap.insert("3_f64".to_owned(), QJsonValue::from(1.2345));
valuemap.insert("4_int".to_owned(), QJsonValue::from(456.0));
valuemap.insert("5_array".to_owned(), QJsonValue::from(array));
valuemap.insert("6_object".to_owned(), QJsonValue::from(object));
let object = QJsonObject::from(valuemap);
assert_eq!(object.to_json().to_string(), "{\"1_string\":\"test\",\"2_bool\":true,\"3_f64\":1.2345,\"4_int\":456,\"5_array\":[\"test\",true,false,1.2345,456],\"6_object\":{\"key\":\"value\",\"test\":\"hello\"}}");
let at_f64: f64 = object.value("3_f64").into();
assert_eq!(at_f64, 1.2345);
let at_string = object.value("1_string");
assert_eq!(<QJsonValue as Into<QString>>::into(at_string).to_string(), "test");
let mut object = QJsonObject::default();
object.insert("key", QJsonValue::from(QString::from("value")));
object.insert("test", QJsonValue::from(QString::from("hello")));
assert_eq!(object.to_json().to_string(), "{\"key\":\"value\",\"test\":\"hello\"}");
assert_eq!(object.keys(), vec!["key".to_owned(), "test".to_owned()]);
}
#[test]
fn test_qjsonobject_utf8() {
let emoji = String::from("🦀");
let expected = String::from("{\"🦀\":1}");
let mut qmap: QJsonObject = QJsonObject::default();
qmap.insert(&emoji, QVariant::from(1).into());
let actual = qmap.to_json();
let actual = actual.to_str().unwrap();
assert_eq!(actual, expected);
}
cpp_class!(
#[derive(Default, PartialEq, Eq, Clone)]
pub unsafe struct QJsonArray as "QJsonArray"
);
impl QJsonArray {
pub fn to_json(&self) -> QByteArray {
cpp!(unsafe [self as "QJsonArray*"] -> QByteArray as "QByteArray" { return QJsonDocument(*self).toJson(QJsonDocument::Compact); })
}
pub fn to_json_pretty(&self) -> QByteArray {
cpp!(unsafe [self as "QJsonArray*"] -> QByteArray as "QByteArray" { return QJsonDocument(*self).toJson(QJsonDocument::Indented); })
}
pub fn push(&mut self, value: QJsonValue) {
cpp!(unsafe [self as "QJsonArray*", value as "QJsonValue"] { self->append(std::move(value)); })
}
pub fn insert(&mut self, index: usize, element: QJsonValue) {
cpp!(unsafe [self as "QJsonArray*", index as "size_t", element as "QJsonValue"] { self->insert(index, std::move(element)); })
}
pub fn at(&self, index: usize) -> QJsonValue {
cpp!(unsafe [self as "QJsonArray*", index as "size_t"] -> QJsonValue as "QJsonValue" { return self->at(index); })
}
pub fn take_at(&mut self, index: usize) -> QJsonValue {
cpp!(unsafe [self as "QJsonArray*", index as "size_t"] -> QJsonValue as "QJsonValue" { return self->takeAt(index); })
}
pub fn remove_at(&mut self, index: usize) {
cpp!(unsafe [self as "QJsonArray*", index as "size_t"] { return self->removeAt(index); })
}
pub fn len(&self) -> usize {
cpp!(unsafe [self as "QJsonArray*"] -> usize as "size_t" { return self->size(); })
}
pub fn is_empty(&self) -> bool {
cpp!(unsafe [self as "QJsonArray*"] -> bool as "bool" { return self->isEmpty(); })
}
}
impl From<Vec<QJsonValue>> for QJsonArray {
fn from(v: Vec<QJsonValue>) -> QJsonArray {
let ptr = v.as_ptr();
let len = v.len();
cpp!(unsafe [ptr as "const QJsonValue*", len as "size_t"] -> QJsonArray as "QJsonArray" {
QJsonArray arr;
for (size_t i = 0; i < len; ++i) {
arr.append(ptr[i]);
}
return arr;
})
}
}
#[test]
fn test_qjsonarray() {
let mut array = QJsonArray::default();
array.push(QJsonValue::from(QString::from("test")));
array.push(QJsonValue::from(true));
array.push(QJsonValue::from(false));
array.push(QJsonValue::from(1.2345));
assert_eq!(array.to_json().to_string(), "[\"test\",true,false,1.2345]");
let mut vec = Vec::new();
vec.push(QJsonValue::from(QString::from("test")));
vec.push(QJsonValue::from(true));
vec.push(QJsonValue::from(false));
vec.push(QJsonValue::from(1.2345));
assert!(QJsonArray::from(vec) == array);
assert_eq!(array.len(), 4);
assert_eq!(<QJsonValue as Into<QString>>::into(array.at(0)).to_string(), "test");
assert!(array.at(3) == QJsonValue::from(1.2345));
}