fix: qmlfmt

IListView: animation

3 files changed, 92 insertions, 185 deletions

diff --git a/qml_plugin/src/launcher/duckduckgo.rs b/qml_plugin/src/launcher/duckduckgo.rs
index 16c9102..0375cdf 100644
--- a/qml_plugin/src/launcher/duckduckgo.rs
+++ b/qml_plugin/src/launcher/duckduckgo.rs
@@ -16,19 +16,10 @@ mod qobject {
         #[qobject]
         #[qml_element]
         #[qml_singleton]
-        #[qproperty(
-            bool, ok
-        )]
-        #[qproperty(
-            QString, title
-        )]
-        #[qproperty(
-            QString,
-            description_html
-        )]
-        #[qproperty(
-            QString, image
-        )]
+        #[qproperty(bool, ok)]
+        #[qproperty(QString, title)]
+        #[qproperty(QString, description_html)]
+        #[qproperty(QString, image)]
         type DuckDuckGo = super::DuckDuckGoRs;
 
         #[qinvokable]
@@ -61,60 +52,37 @@ pub struct DuckDuckGoRs {
 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();
-                },
-            );
+        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());
+        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
index d29239e..601dc3b 100644
--- a/qml_plugin/src/launcher/mathcalc.rs
+++ b/qml_plugin/src/launcher/mathcalc.rs
@@ -22,9 +22,7 @@ mod qobject {
         #[qobject]
         #[qml_element]
         #[qml_singleton]
-        #[qproperty(
-            QVariant, result
-        )]
+        #[qproperty(QVariant, result)]
         type MathCalc = super::MathCalcRs;
 
         #[qinvokable]
@@ -63,61 +61,34 @@ impl Default for MathCalcRs {
 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,
-        );
+        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();
-                },
-            );
+        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.as_mut().reset_result();
         self.reset_ctx();
     }
 
@@ -126,13 +97,10 @@ impl qobject::MathCalc {
     }
 
     fn reset_ctx(mut self: Pin<&mut Self>) {
-        self.as_mut()
-            .rust_mut()
-            .ctx = Arc::new(Mutex::new(Self::new_ctx()))
+        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())
+        self.as_mut().set_result(QVariant::default())
     }
 }
diff --git a/qml_plugin/src/launcher/smartcalc.rs b/qml_plugin/src/launcher/smartcalc.rs
index c23ecfa..9b5f05a 100644
--- a/qml_plugin/src/launcher/smartcalc.rs
+++ b/qml_plugin/src/launcher/smartcalc.rs
@@ -18,17 +18,9 @@ mod qobject {
         #[qobject]
         #[qml_element]
         #[qml_singleton]
-        #[qproperty(
-            QVariant, result
-        )]
-        #[qproperty(
-            ResultType,
-            result_type
-        )]
-        #[qproperty(
-            QVariant,
-            cached_query
-        )]
+        #[qproperty(QVariant, result)]
+        #[qproperty(ResultType, result_type)]
+        #[qproperty(QVariant, cached_query)]
         type SmartCalc = super::SmartCalcRs;
 
         #[qinvokable]
@@ -89,64 +81,43 @@ impl qobject::SmartCalc {
         if self.cached_query == (&input).into() {
             return;
         }
-        self.as_mut()
-            .set_cached_query((&input.clone()).into());
+        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,
+        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(),
+                        },
                     )
-                    .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();
-                },
-            );
+                })
+                .unwrap_print();
+        });
     }
 
     fn reset(mut self: Pin<&mut Self>) {
-        self.as_mut()
-            .set_cached_query(QVariant::default());
+        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);
+        self.as_mut().set_result(QVariant::default());
+        self.as_mut().set_result_type(qobject::ResultType::Unset);
     }
 }