use std::collections::HashMap;
use std::iter::FromIterator;
use std::ops::Index;
use cpp::cpp;
use super::*;
pub trait QAbstractListModel: QObject {
fn get_object_description() -> &'static QObjectDescriptor
where
Self: Sized,
{
unsafe {
&*cpp!([]-> *const QObjectDescriptor as "RustQObjectDescriptor const*" {
return RustQObjectDescriptor::instance<Rust_QAbstractListModel>();
})
}
}
fn row_count(&self) -> i32;
fn data(&self, index: QModelIndex, role: i32) -> QVariant;
fn set_data(&mut self, _index: QModelIndex, _value: &QVariant, _role: i32) -> bool {
false
}
fn role_names(&self) -> HashMap<i32, QByteArray> {
HashMap::new()
}
fn begin_insert_rows(&mut self, first: i32, last: i32) {
let p = QModelIndex::default();
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*", p as "QModelIndex", first as "int", last as "int"]{
if(obj) obj->beginInsertRows(p, first, last);
})
}
}
fn end_insert_rows(&mut self) {
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*"]{
if(obj) obj->endInsertRows();
})
}
}
fn begin_remove_rows(&mut self, first: i32, last: i32) {
let p = QModelIndex::default();
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*", p as "QModelIndex", first as "int", last as "int"]{
if(obj) obj->beginRemoveRows(p, first, last);
})
}
}
fn end_remove_rows(&mut self) {
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*"]{
if(obj) obj->endRemoveRows();
})
}
}
fn begin_reset_model(&mut self) {
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*"]{
if(obj) obj->beginResetModel();
})
}
}
fn end_reset_model(&mut self) {
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*"]{
if(obj) obj->endResetModel();
})
}
}
fn begin_move_rows(
&mut self,
source_parent: QModelIndex,
source_first: i32,
source_last: i32,
destination_parent: QModelIndex,
destination_child: i32,
) {
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*", source_parent as "QModelIndex", source_first as "int", source_last as "int", destination_parent as "QModelIndex", destination_child as "int"]{
if(obj) obj->beginMoveRows(source_parent, source_first, source_last, destination_parent, destination_child);
})
}
}
fn end_move_rows(&mut self) {
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*"]{
if(obj) obj->endMoveRows();
})
}
}
fn data_changed(&mut self, top_left: QModelIndex, bottom_right: QModelIndex) {
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*", top_left as "QModelIndex", bottom_right as "QModelIndex"]{
if(obj) obj->dataChanged(top_left, bottom_right);
})
}
}
fn row_index(&self, i: i32) -> QModelIndex {
let obj = self.get_cpp_object();
unsafe {
cpp!([obj as "Rust_QAbstractListModel*", i as "int"] -> QModelIndex as "QModelIndex" {
return obj ? obj->index(i) : QModelIndex();
})
}
}
}
cpp! {{
#include <qmetaobject_rust.hpp>
#include <QtCore/QAbstractListModel>
struct Rust_QAbstractListModel : RustObject<QAbstractListModel> {
using QAbstractListModel::beginInsertRows;
using QAbstractListModel::endInsertRows;
using QAbstractListModel::beginRemoveRows;
using QAbstractListModel::endRemoveRows;
using QAbstractListModel::beginResetModel;
using QAbstractListModel::endResetModel;
using QAbstractListModel::beginMoveRows;
using QAbstractListModel::endMoveRows;
int rowCount(const QModelIndex & = QModelIndex()) const override {
return rust!(Rust_QAbstractListModel_rowCount[rust_object : QObjectPinned<dyn QAbstractListModel> as "TraitObject"]
-> i32 as "int" {
rust_object.borrow().row_count()
});
}
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override {
return rust!(Rust_QAbstractListModel_data[rust_object : QObjectPinned<dyn QAbstractListModel> as "TraitObject",
index : QModelIndex as "QModelIndex", role : i32 as "int"] -> QVariant as "QVariant" {
rust_object.borrow().data(index, role)
});
}
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override {
return rust!(Rust_QAbstractListModel_setData[rust_object : QObjectPinned<dyn QAbstractListModel> as "TraitObject",
index : QModelIndex as "QModelIndex", value : QVariant as "QVariant", role : i32 as "int"]
-> bool as "bool" {
rust_object.borrow_mut().set_data(index, &value, role)
});
}
QHash<int, QByteArray> roleNames() const override {
QHash<int, QByteArray> base = QAbstractListModel::roleNames();
rust!(Rust_QAbstractListModel_roleNames[rust_object : QObjectPinned<dyn QAbstractListModel> as "TraitObject",
base: *mut c_void as "QHash<int, QByteArray>&"] {
for (key, val) in rust_object.borrow().role_names().iter() {
add_to_hash(base, *key, val.clone());
}
});
return base;
}
};
}}
pub trait SimpleListItem {
fn get(&self, role: i32) -> QVariant;
fn names() -> Vec<QByteArray>;
}
#[derive(QObject, Default)]
#[QMetaObjectCrate = "super"]
pub struct SimpleListModel<T: SimpleListItem + 'static> {
#[qt_base_class = "QAbstractListModel"]
base: QObjectCppWrapper,
values: Vec<T>,
}
impl<T> QAbstractListModel for SimpleListModel<T>
where
T: SimpleListItem,
{
fn row_count(&self) -> i32 {
self.values.len() as i32
}
fn data(&self, index: QModelIndex, role: i32) -> QVariant {
let idx = index.row();
if idx >= 0 && (idx as usize) < self.values.len() {
self.values[idx as usize].get(role - USER_ROLE).clone()
} else {
QVariant::default()
}
}
fn role_names(&self) -> HashMap<i32, QByteArray> {
T::names().iter().enumerate().map(|(i, x)| (i as i32 + USER_ROLE, x.clone())).collect()
}
}
impl<T: SimpleListItem> SimpleListModel<T> {
pub fn insert(&mut self, index: usize, element: T) {
(self as &mut dyn QAbstractListModel).begin_insert_rows(index as i32, index as i32);
self.values.insert(index, element);
(self as &mut dyn QAbstractListModel).end_insert_rows();
}
pub fn push(&mut self, value: T) {
let idx = self.values.len();
self.insert(idx, value);
}
pub fn remove(&mut self, index: usize) {
(self as &mut dyn QAbstractListModel).begin_remove_rows(index as i32, index as i32);
self.values.remove(index);
(self as &mut dyn QAbstractListModel).end_remove_rows();
}
pub fn change_line(&mut self, index: usize, value: T) {
self.values[index] = value;
let idx = (self as &mut dyn QAbstractListModel).row_index(index as i32);
(self as &mut dyn QAbstractListModel).data_changed(idx, idx);
}
pub fn reset_data(&mut self, data: Vec<T>) {
(self as &mut dyn QAbstractListModel).begin_reset_model();
self.values = data;
(self as &mut dyn QAbstractListModel).end_reset_model();
}
pub fn iter(&self) -> impl Iterator<Item = &T> {
self.values.iter()
}
}
impl<T> FromIterator<T> for SimpleListModel<T>
where
T: SimpleListItem + Default,
{
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> SimpleListModel<T> {
let mut m = SimpleListModel::default();
m.values = Vec::from_iter(iter.into_iter());
m
}
}
impl<'a, T> FromIterator<&'a T> for SimpleListModel<T>
where
T: SimpleListItem + Default + Clone,
{
fn from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> SimpleListModel<T> {
let mut m = SimpleListModel::<T>::default();
m.values = Vec::from_iter(iter.into_iter().cloned());
m
}
}
impl<T> Index<usize> for SimpleListModel<T>
where
T: SimpleListItem,
{
type Output = T;
fn index(&self, index: usize) -> &T {
&self.values[index]
}
}