refactor: qml_pluginmain

1 files changed, 0 insertions, 123 deletions

diff --git a/qml_plugin/src/launcher/smartcalc.rs b/qml_plugin/src/launcher/smartcalc.rs
deleted file mode 100644
index 9b5f05a..0000000
--- a/qml_plugin/src/launcher/smartcalc.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use cxx_qt::{CxxQtType, Threading};
-use cxx_qt_lib::{QString, QVariant};
-use std::pin::Pin;
-use unwrap_print::PrintableResult;
-
-use crate::ExclusiveExecutor;
-
-#[cxx_qt::bridge]
-mod qobject {
-    extern "C++" {
-        include!("cxx-qt-lib/qstring.h");
-        include!("cxx-qt-lib/qvariant.h");
-        type QString = cxx_qt_lib::QString;
-        type QVariant = cxx_qt_lib::QVariant;
-    }
-
-    extern "RustQt" {
-        #[qobject]
-        #[qml_element]
-        #[qml_singleton]
-        #[qproperty(QVariant, result)]
-        #[qproperty(ResultType, result_type)]
-        #[qproperty(QVariant, cached_query)]
-        type SmartCalc = super::SmartCalcRs;
-
-        #[qinvokable]
-        fn query(self: Pin<&mut SmartCalc>, input: QString);
-
-        #[qinvokable]
-        fn reset(self: Pin<&mut SmartCalc>);
-
-        #[qinvokable]
-        fn reset_result(self: Pin<&mut SmartCalc>);
-    }
-
-    impl cxx_qt::Threading for SmartCalc {}
-
-    #[qenum(SmartCalc)]
-    pub enum ResultType {
-        Math,
-        Unit,
-        Currency,
-        Crypto,
-        Time,
-        Date,
-        Unset,
-    }
-}
-
-impl Default for qobject::ResultType {
-    fn default() -> Self {
-        qobject::ResultType::Unset
-    }
-}
-
-impl From<&smart_calculator::types::ResultType> for qobject::ResultType {
-    fn from(value: &smart_calculator::types::ResultType) -> Self {
-        match value {
-            smart_calculator::types::ResultType::Math => qobject::ResultType::Math,
-            smart_calculator::types::ResultType::Unit => qobject::ResultType::Unit,
-            smart_calculator::types::ResultType::Currency => qobject::ResultType::Currency,
-            smart_calculator::types::ResultType::Crypto => qobject::ResultType::Crypto,
-            smart_calculator::types::ResultType::Time => qobject::ResultType::Time,
-            smart_calculator::types::ResultType::Date => qobject::ResultType::Date,
-        }
-    }
-}
-
-#[derive(Default)]
-pub struct SmartCalcRs {
-    result: QVariant,
-    result_type: qobject::ResultType,
-
-    cached_query: QVariant,
-
-    executor: ExclusiveExecutor,
-}
-
-impl qobject::SmartCalc {
-    fn query(mut self: Pin<&mut Self>, input: QString) {
-        if self.cached_query == (&input).into() {
-            return;
-        }
-        self.as_mut().set_cached_query((&input.clone()).into());
-        let qt_thread = self.qt_thread();
-        self.as_mut().rust_mut().executor.spawn(async move {
-            let result = smart_calculator::calculate(&input.to_string(), None).await;
-            _ = qt_thread
-                .queue(|mut qo| {
-                    qo.as_mut().set_result_type(match &result {
-                        Ok(value) => (&value.res_type).into(),
-                        Err(_) => qobject::ResultType::Unset,
-                    });
-                    qo.as_mut().set_result(
-                        // TODO: do the calc outside of ts main qt ui render
-                        // thread.(all *.rs)
-                        match result {
-                            Ok(value) => {
-                                if value.formatted == value.input {
-                                    QVariant::default()
-                                } else {
-                                    let result: QString = value.formatted.into();
-                                    QVariant::from(&result)
-                                }
-                            }
-                            Err(_) => QVariant::default(),
-                        },
-                    )
-                })
-                .unwrap_print();
-        });
-    }
-
-    fn reset(mut self: Pin<&mut Self>) {
-        self.as_mut().set_cached_query(QVariant::default());
-        self.reset_result();
-    }
-
-    fn reset_result(mut self: Pin<&mut Self>) {
-        self.as_mut().set_result(QVariant::default());
-        self.as_mut().set_result_type(qobject::ResultType::Unset);
-    }
-}