summaryrefslogtreecommitdiff
path: root/qml_plugin/src/launcher
diff options
context:
space:
mode:
Diffstat (limited to 'qml_plugin/src/launcher')
-rw-r--r--qml_plugin/src/launcher/duckduckgo.rs88
-rw-r--r--qml_plugin/src/launcher/mathcalc.rs106
-rw-r--r--qml_plugin/src/launcher/smartcalc.rs123
3 files changed, 0 insertions, 317 deletions
diff --git a/qml_plugin/src/launcher/duckduckgo.rs b/qml_plugin/src/launcher/duckduckgo.rs
deleted file mode 100644
index 0375cdf..0000000
--- a/qml_plugin/src/launcher/duckduckgo.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-use cxx_qt::{CxxQtType, Threading};
-use cxx_qt_lib::QString;
-use std::pin::Pin;
-use unwrap_print::PrintableResult;
-
-use crate::{ExclusiveExecutor, web::duckduckgo};
-
-#[cxx_qt::bridge]
-mod qobject {
- extern "C++" {
- include!("cxx-qt-lib/qstring.h");
- type QString = cxx_qt_lib::QString;
- }
-
- extern "RustQt" {
- #[qobject]
- #[qml_element]
- #[qml_singleton]
- #[qproperty(bool, ok)]
- #[qproperty(QString, title)]
- #[qproperty(QString, description_html)]
- #[qproperty(QString, image)]
- type DuckDuckGo = super::DuckDuckGoRs;
-
- #[qinvokable]
- fn query(self: Pin<&mut DuckDuckGo>, input: QString);
-
- #[qinvokable]
- fn reset(self: Pin<&mut DuckDuckGo>);
- }
-
- impl cxx_qt::Threading for DuckDuckGo {}
-}
-
-#[derive(Default)]
-pub struct QmlDuckDuckGo {
- pub title: QString,
- pub description_html: QString,
- pub image: QString,
-}
-
-#[derive(Default)]
-pub struct DuckDuckGoRs {
- ok: bool,
- title: QString,
- description_html: QString,
- image: QString,
-
- executor: ExclusiveExecutor,
-}
-
-impl qobject::DuckDuckGo {
- fn query(self: Pin<&mut Self>, input: QString) {
- let qt_thread = self.qt_thread();
- self.rust_mut().executor.spawn(async move {
- let qinput = input.to_string();
- let result: Result<QmlDuckDuckGo, _> =
- duckduckgo::query(&qinput).await.map(|r| r.into());
- // consider just unwrapping since this is in a separate thread and
- // is already end of life anw
- _ = qt_thread
- .queue(move |mut qo| match result {
- Ok(r) => {
- if (r.title.to_lower() == input.to_lower() || r.title.is_empty())
- && r.description_html.is_empty()
- && r.image.is_empty()
- {
- qo.as_mut().set_ok(false);
- } else {
- qo.as_mut().set_ok(true);
- qo.as_mut().set_title(r.title);
- qo.as_mut().set_description_html(r.description_html);
- qo.as_mut().set_image(r.image);
- }
- }
- Err(_) => qo.set_ok(false),
- })
- .unwrap_print();
- });
- }
-
- fn reset(mut self: Pin<&mut Self>) {
- self.as_mut().set_ok(false);
- self.as_mut().set_title("".into());
- self.as_mut().set_description_html("".into());
- self.as_mut().set_image("".into());
- }
-}
diff --git a/qml_plugin/src/launcher/mathcalc.rs b/qml_plugin/src/launcher/mathcalc.rs
deleted file mode 100644
index 601dc3b..0000000
--- a/qml_plugin/src/launcher/mathcalc.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-use cxx_qt::{CxxQtType, Threading};
-use cxx_qt_lib::{QString, QVariant};
-use kalk::parser;
-use std::{pin::Pin, sync::Arc};
-use tokio::sync::Mutex;
-use unwrap_print::PrintableResult;
-
-use crate::ExclusiveExecutor;
-
-const DEFAULT_ANGLE_UNIT: &str = "deg";
-
-#[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)]
- type MathCalc = super::MathCalcRs;
-
- #[qinvokable]
- fn query(self: Pin<&mut MathCalc>, input: QString);
-
- #[qinvokable]
- fn reset(self: Pin<&mut MathCalc>);
-
- #[qinvokable]
- fn reset_ctx(self: Pin<&mut MathCalc>);
-
- #[qinvokable]
- fn reset_result(self: Pin<&mut MathCalc>);
- }
-
- impl cxx_qt::Threading for MathCalc {}
-}
-
-pub struct MathCalcRs {
- result: QVariant,
- ctx: Arc<Mutex<parser::Context>>,
-
- executor: ExclusiveExecutor,
-}
-
-impl Default for MathCalcRs {
- fn default() -> Self {
- Self {
- result: QVariant::default(),
- ctx: Arc::new(Mutex::new(qobject::MathCalc::new_ctx())),
- executor: ExclusiveExecutor::default(),
- }
- }
-}
-
-impl qobject::MathCalc {
- fn query(mut self: Pin<&mut Self>, input: QString) {
- let qt_thread = self.qt_thread();
- let ctx = Arc::clone(&self.as_mut().rust_mut().ctx);
- // TODO: consider moving to spawn_blocking
- self.rust_mut().executor.spawn(async move {
- let input = input.to_string();
- let result = parser::eval(
- &mut *ctx.lock().await,
- &input,
- // TODO: move to const/config
- 53,
- )
- .map_or_default(|r| {
- r.map_or_default(|r| {
- let r: QString = r
- // to display scientific notation properly
- // other ones show both version without e or shows *10^_
- // and have a = prefix
- // to_string_big will result in 1/2=5.0000000000000000e − 1
- .to_string()
- .into();
- if r != input.into() { QVariant::from(&r) } else { QVariant::default() }
- })
- });
- _ = qt_thread.queue(|mut qo| qo.as_mut().set_result(result)).unwrap_print();
- });
- }
-
- fn reset(mut self: Pin<&mut Self>) {
- self.as_mut().reset_result();
- self.reset_ctx();
- }
-
- fn new_ctx() -> parser::Context {
- parser::Context::default().set_angle_unit(DEFAULT_ANGLE_UNIT)
- }
-
- fn reset_ctx(mut self: Pin<&mut Self>) {
- self.as_mut().rust_mut().ctx = Arc::new(Mutex::new(Self::new_ctx()))
- }
-
- fn reset_result(mut self: Pin<&mut Self>) {
- self.as_mut().set_result(QVariant::default())
- }
-}
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);
- }
-}
generated by cgit v1.2.3 (git 2.25.1) at 2026-11-01 21:37:59 +0000