calculator_qalculate

- Add option: Units in global query
- Add option: Functions in global query

Author: ManuelSchneid3r

calculator_qalculate/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.16)
 find_package(Albert REQUIRED)
 
-project(calculator_qalculate VERSION 5.3)
+project(calculator_qalculate VERSION 6.0)
 
 find_package(PkgConfig REQUIRED)
 pkg_check_modules(LIBQALCULATE REQUIRED libqalculate)

calculator_qalculate/i18n/calculator_qalculate.ts

@@ -63,6 +63,14 @@ The global handler evaluates basic math expressions. Use the trigger handler to
         <source>Precision for approximate calculations.</source>
         <translation></translation>
     </message>
+    <message>
+        <source>Functions in global query</source>
+        <translation></translation>
+    </message>
+    <message>
+        <source>Units in global query</source>
+        <translation></translation>
+    </message>
 </context>
 <context>
     <name>Plugin</name>

calculator_qalculate/i18n/calculator_qalculate_de.ts

@@ -67,6 +67,14 @@ Der globale Handler wertet grundlegende mathematische Ausdrücke aus. Verwenden
         <source>Precision for approximate calculations.</source>
         <translation>Präzision für ungefähre Berechnungen.</translation>
     </message>
+    <message>
+        <source>Functions in global query</source>
+        <translation>Funktionen in globaler Abfrage</translation>
+    </message>
+    <message>
+        <source>Units in global query</source>
+        <translation>Einheiten in globaler Abfrage</translation>
+    </message>
 </context>
 <context>
     <name>Plugin</name>

calculator_qalculate/src/configwidget.ui

@@ -137,6 +137,26 @@ The global handler evaluates basic math expressions. Use the trigger handler to
        </property>
       </widget>
      </item>
+     <item row="3" column="0">
+      <widget class="QLabel" name="functionsInGlobalQueryLabel">
+       <property name="text">
+        <string>Functions in global query</string>
+       </property>
+      </widget>
+     </item>
+     <item row="3" column="1">
+      <widget class="QCheckBox" name="functionsInGlobalQueryCheckBox"/>
+     </item>
+     <item row="4" column="0">
+      <widget class="QLabel" name="unitsInGlobalQueryLabel">
+       <property name="text">
+        <string>Units in global query</string>
+       </property>
+      </widget>
+     </item>
+     <item row="4" column="1">
+      <widget class="QCheckBox" name="unitsInGlobalQueryCheckBox"/>
+     </item>
     </layout>
    </item>
    <item>

calculator_qalculate/src/plugin.cpp

@@ -19,6 +19,11 @@ const char* CFG_PARSINGMODE = "parsing_mode";
 const uint  DEF_PARSINGMODE = (int)PARSING_MODE_CONVENTIONAL;
 const char* CFG_PRECISION = "precision";
 const uint  DEF_PRECISION = 16;
+const char* CFG_UNITS = "units_in_global_query";
+const bool  DEF_UNITS = false;
+const char* CFG_FUNCS = "functions_in_global_query";
+const bool  DEF_FUNCS = false;
+
 }
 
 const QStringList Plugin::icon_urls = {"xdg:calc", ":qalculate"};
@@ -41,10 +46,10 @@ Plugin::Plugin()
 
     // parse options
     eo.parse_options.angle_unit = static_cast<AngleUnit>(s->value(CFG_ANGLEUNIT, DEF_ANGLEUNIT).toInt());
-    eo.parse_options.functions_enabled = false;
+    eo.parse_options.functions_enabled = s->value(CFG_FUNCS, DEF_FUNCS).toBool();
     eo.parse_options.limit_implicit_multiplication = true;
     eo.parse_options.parsing_mode = static_cast<ParsingMode>(s->value(CFG_PARSINGMODE, DEF_PARSINGMODE).toInt());
-    eo.parse_options.units_enabled = false;
+    eo.parse_options.units_enabled = s->value(CFG_UNITS, DEF_UNITS).toBool();
     eo.parse_options.unknowns_enabled = false;
 
     // print options
@@ -101,6 +106,24 @@ QWidget *Plugin::buildConfigWidget()
         qalc->setPrecision(value);
     });
 
+    // Units in global query
+    ui.unitsInGlobalQueryCheckBox->setChecked(eo.parse_options.units_enabled);
+    connect(ui.unitsInGlobalQueryCheckBox, &QCheckBox::toggled, this, [this](bool checked)
+    {
+        settings()->setValue(CFG_UNITS, checked);
+        lock_guard locker(qalculate_mutex);
+        eo.parse_options.units_enabled = checked;
+    });
+
+    // Functions in global query
+    ui.functionsInGlobalQueryCheckBox->setChecked(eo.parse_options.functions_enabled);
+    connect(ui.functionsInGlobalQueryCheckBox, &QCheckBox::toggled, this, [this](bool checked)
+    {
+        settings()->setValue(CFG_FUNCS, checked);
+        lock_guard locker(qalculate_mutex);
+        eo.parse_options.functions_enabled = checked;
+    });
+
     return widget;
 }
 
@@ -125,38 +148,62 @@ shared_ptr<Item> Plugin::buildItem(const QString &query, const MathStructure &ms
     );
 }
 
-vector<RankItem> Plugin::handleGlobalQuery(const Query *query)
+std::variant<QStringList, MathStructure>
+Plugin::runQalculateLocked(const albert::Query *query, const EvaluationOptions &eo_)
 {
-    vector<RankItem> results;
-
-    auto trimmed = query->string().trimmed();
-    if (trimmed.isEmpty())
-        return results;
-
-    lock_guard locker(qalculate_mutex);
-
     auto expression = qalc->unlocalizeExpression(query->string().toStdString(), eo.parse_options);
 
     qalc->startControl();
     MathStructure mstruct;
-    qalc->calculate(&mstruct, expression, 0, eo);
+    qalc->calculate(&mstruct, expression, 0, eo_);
     for (; qalc->busy(); QThread::msleep(10))
         if (!query->isValid())
             qalc->abort();
     qalc->stopControl();
 
     if (!query->isValid())
-        return results;
+        return QStringList();
 
-    if (qalc->message()){
-        for (auto msg = qalc->message(); msg; msg = qalc->nextMessage())
-            DEBG << QString::fromUtf8(qalc->message()->c_message());
-        return results;
+    QStringList errors;
+    for (auto msg = qalc->message(); msg; msg = qalc->nextMessage())
+        errors << QString::fromUtf8(qalc->message()->c_message());
+
+    if (errors.empty())
+    {
+        mstruct.format(po);
+        return mstruct;
     }
+    else
+        return errors;
+}
+
+vector<RankItem> Plugin::handleGlobalQuery(const Query *query)
+{
+    vector<RankItem> results;
 
-    mstruct.format(po);
+    auto trimmed = query->string().trimmed();
+    if (trimmed.isEmpty())
+        return results;
 
-    results.emplace_back(buildItem(trimmed, mstruct), 1.0f);
+    lock_guard locker(qalculate_mutex);
+
+    auto ret = runQalculateLocked(query, eo);
+
+    if (!query->isValid())
+        return results;
+
+    try {
+        auto mstruct = std::get<MathStructure>(ret);
+        results.emplace_back(buildItem(trimmed, mstruct), 1.0f);
+    } catch (const std::bad_variant_access &) {
+        try {
+            auto errors = std::get<QStringList>(ret);
+            for (const auto & e : errors)
+                DEBG << e;
+        } catch (const std::bad_variant_access &) {
+            CRIT << "Unhandled bad_variant_access";
+        }
+    }
 
     return results;
 }
@@ -167,47 +214,37 @@ void Plugin::handleTriggerQuery(Query *query)
     if (trimmed.isEmpty())
         return;
 
-    lock_guard locker(qalculate_mutex);
-
     auto eo_ = eo;
     eo_.parse_options.functions_enabled = true;
     eo_.parse_options.units_enabled = true;
     eo_.parse_options.unknowns_enabled = true;
 
-    auto expression = qalc->unlocalizeExpression(query->string().toStdString(), eo_.parse_options);
+    lock_guard locker(qalculate_mutex);
 
-    qalc->startControl();
-    MathStructure mstruct;
-    qalc->calculate(&mstruct, expression, 0, eo_);
-    for (; qalc->busy(); QThread::msleep(10))
-        if (!query->isValid())
-            qalc->abort();
-    qalc->stopControl();
+    auto ret = runQalculateLocked(query, eo_);
 
     if (!query->isValid())
         return;
 
-    QStringList errors;
-    for (auto msg = qalc->message(); msg; msg = qalc->nextMessage())
-        errors << QString::fromUtf8(qalc->message()->c_message());
-
-    if (errors.empty())
-    {
-        mstruct.format(po);
+    try {
+        auto mstruct = std::get<MathStructure>(ret);
         query->add(buildItem(trimmed, mstruct));
-    }
-    else
-    {
-        static const auto tr_e = tr("Evaluation error.");
-        static const auto tr_d = tr("Visit documentation");
-        query->add(
-            StandardItem::make(
-                "qalc-err",
-                tr_e,
-                errors.join(" "),
-                icon_urls,
-                {{"manual", tr_d, [=](){ openUrl(URL_MANUAL); }}}
-            )
-        );
+    } catch (const std::bad_variant_access &) {
+        try {
+            auto errors = std::get<QStringList>(ret);
+            static const auto tr_e = tr("Evaluation error.");
+            static const auto tr_d = tr("Visit documentation");
+            query->add(
+                StandardItem::make(
+                    "qalc-err",
+                    tr_e,
+                    errors.join(", "),
+                    icon_urls,
+                    {{"manual", tr_d, [=](){ openUrl(URL_MANUAL); }}}
+                )
+            );
+        } catch (const std::bad_variant_access &) {
+            CRIT << "Unhandled bad_variant_access";
+        }
     }
 }

calculator_qalculate/src/plugin.h

@@ -11,7 +11,9 @@ class Plugin : public albert::ExtensionPlugin,
                public albert::GlobalQueryHandler
 {
     ALBERT_PLUGIN
+
 public:
+
     Plugin();
 
     QString defaultTrigger() const override;
@@ -21,6 +23,10 @@ class Plugin : public albert::ExtensionPlugin,
     QWidget* buildConfigWidget() override;
 
 private:
+
+    std::variant<QStringList, MathStructure>
+    runQalculateLocked(const albert::Query *query, const EvaluationOptions &eo) ;
+
     std::shared_ptr<albert::Item> buildItem(const QString &query, const MathStructure &mstruct) const;
 
     QString iconPath;
@@ -29,4 +35,5 @@ class Plugin : public albert::ExtensionPlugin,
     PrintOptions po;
     std::mutex qalculate_mutex;
     static const QStringList icon_urls;
+
 };