GUI frontend completed

Author: BC100Dev

Sources/AppGUI/Resources/example_applist.json

@@ -0,0 +1,125 @@
+#include "Shared.hpp"
+
+#include <QFileInfo>
+#include <QStandardPaths>
+#include <QJsonDocument>
+#include <QJsonArray>
+#include <QJsonObject>
+
+#include <fstream>
+#include <iostream>
+#include <filesystem>
+#include <vector>
+
+namespace fs = std::filesystem;
+
+namespace SharedCode {
+
+    QIcon FindIcon(const QString &name) {
+        QIcon icon = QIcon::fromTheme(name);
+        if (!icon.isNull())
+            return icon;
+
+        QStringList iconPaths = {
+                "/usr/share/icons/hicolor/48x48/apps/" + name + ".png",
+                "/usr/share/icons/hicolor/128x128/apps/" + name + ".png",
+                "/usr/share/icons/hicolor/scalable/apps/" + name + ".svg",
+                "/usr/share/pixmaps/" + name + ".png"
+        };
+
+        for (const QString &iconPath: iconPaths) {
+            if (QFileInfo::exists(iconPath))
+                return QIcon(iconPath);
+        }
+
+        return QIcon::fromTheme("application-x-executable");
+    }
+
+    std::vector<Application> GetAppList() {
+        std::vector<Application> appList;
+
+        QString configPath = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/RunAsGPU/apps.json";
+        QFile file(configPath);
+
+        if (!file.exists()) {
+            std::ofstream _file(configPath.toStdString());
+            if (_file.is_open() && _file.good()) {
+                _file << "[]" << std::endl;
+                _file.close();
+            }
+            return appList;
+        }
+
+        if (!file.open(QIODevice::ReadOnly)) {
+            qDebug() << "Failed to open apps.json: " << file.errorString();
+            return appList;
+        }
+
+        QByteArray jsonData = file.readAll();
+        file.close();
+
+        QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonData);
+        if (!jsonDoc.isArray()) {
+            qDebug() << "Invalid JSON format!";
+            return appList;
+        }
+
+        QJsonArray jsonArray = jsonDoc.array();
+        for (const QJsonValue &value: jsonArray) {
+            if (!value.isObject()) continue;
+
+            QJsonObject jsonObj = value.toObject();
+            Application app{jsonObj["name"].toString(), jsonObj["desc"].toString(), jsonObj["execPath"].toString(),
+                            jsonObj["icon"].toString()};
+
+            appList.push_back(app);
+        }
+
+        return appList;
+    }
+
+    void SaveAppList(const std::vector<Application> &appList) {
+        const char *home = getenv("HOME");
+        if (!home) {
+            std::cerr << "Failed to get home directory, exiting..." << std::endl;
+            std::abort();
+        }
+
+        std::string appListPath = std::string(home) + "/.config/RunAsGPU/apps.json";
+        if (!fs::exists(fs::path(appListPath).parent_path()))
+            fs::create_directory(fs::path(appListPath).parent_path());
+
+        QJsonArray jsonArr;
+        for (const auto &app: appList) {
+            QJsonObject obj;
+            QString executor = app.execPath.split(' ')[0];
+            if (executor.isEmpty()) continue;
+
+            if (executor.startsWith('\"'))
+                executor = executor.mid(1, executor.length());
+
+            if (executor.endsWith('\"'))
+                executor = executor.left(executor.length() - 1);
+
+            obj["name"] = app.name;
+            obj["description"] = app.description;
+            obj["execPath"] = executor;
+            obj["icon"] = app.iconStr.isEmpty() ? QJsonValue(QJsonValue::Null) : app.iconStr;
+
+            jsonArr.append(obj);
+        }
+
+        QJsonDocument doc(jsonArr);
+        QString configPath = QStandardPaths::writableLocation(QStandardPaths::ConfigLocation) + "/RunAsGPU/apps.json";
+        QFile file(configPath);
+
+        if (!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
+            qDebug() << "Failed to save apps.json:" << file.errorString();
+            return;
+        }
+
+        file.write(doc.toJson(QJsonDocument::Indented));
+        file.close();
+    }
+
+}

Sources/AppGUI/Shared.cpp

@@ -0,0 +1,19 @@
+#ifndef RUNASGPU_SHARED_HPP
+#define RUNASGPU_SHARED_HPP
+
+#include <QIcon>
+#include <QString>
+
+#include "../UI/Model/AppListModel.hpp"
+
+namespace SharedCode {
+
+    QIcon FindIcon(const QString &iconName);
+
+    std::vector<Application> GetAppList();
+
+    void SaveAppList(const std::vector<Application> &appList);
+
+}
+
+#endif //RUNASGPU_SHARED_HPP

Sources/AppGUI/SharedData/IconFinder.hpp

@@ -0,0 +1,111 @@
+#include "AppRemoval.hpp"
+#include "Model/AppListDelegate.hpp"
+
+#include <Shared.hpp>
+#include <iostream>
+
+std::vector<Application> Ui::appsForRemoval;
+
+AppListModel *modelAppList0;
+AppListDelegate *delegateAppList0;
+
+std::vector<QString> rSelectedApps;
+std::vector<Application> rFilteredApps, rApps;
+
+void Ui_AppRemovalDialog::performLogic() const {
+    self->setFixedSize(self->size());
+
+    modelAppList0 = new AppListModel(appListView);
+    delegateAppList0 = new AppListDelegate(appListView);
+
+    self->setFixedSize(self->size());
+
+    appListView->setModel(modelAppList0);
+    appListView->setItemDelegate(delegateAppList0);
+    appListView->setViewMode(QListView::ListMode);
+    appListView->setUniformItemSizes(true);
+    appListView->setSpacing(5);
+    appListView->setSelectionMode(QAbstractItemView::MultiSelection);
+    appListView->setEditTriggers(QAbstractItemView::NoEditTriggers);
+    appListView->setFocusPolicy(Qt::StrongFocus);
+
+    rApps = SharedCode::GetAppList();
+    for (const auto &app: rApps)
+        modelAppList0->addItem(app);
+
+    QObject::connect(filterBox, &QLineEdit::textChanged, self, [&](const QString &text) {
+        QItemSelectionModel *selectionModel = appListView->selectionModel();
+
+        rFilteredApps.clear();
+        for (const auto &app: rApps) {
+            if (app.name.contains(text, Qt::CaseInsensitive))
+                rFilteredApps.push_back(app);
+        }
+
+        modelAppList0->clear();
+        for (const auto &app: rFilteredApps)
+            modelAppList0->addItem(app);
+
+        // restore selections
+        for (int i = 0; i < modelAppList0->rowCount(); i++) {
+            QModelIndex index = modelAppList0->index(i, 0);
+            QString appName = modelAppList0->data(index, Qt::DisplayRole).toString();
+            if (std::find(rSelectedApps.begin(), rSelectedApps.end(), appName) != rSelectedApps.end())
+                selectionModel->select(index, QItemSelectionModel::Select);
+        }
+    });
+
+    QObject::connect(appListView->selectionModel(), &QItemSelectionModel::selectionChanged, self,
+                     [&](const QItemSelection &selected, const QItemSelection &deselected) {
+                         for (const QModelIndex &index: selected.indexes()) {
+                             QString selectedName = modelAppList0->data(index, Qt::DisplayRole).toString();
+
+                             auto it = std::find_if(rSelectedApps.begin(), rSelectedApps.end(),
+                                                    [&](const QString &appName) {
+                                                        return appName == selectedName;
+                                                    });
+
+                             if (it == rSelectedApps.end()) {
+                                 auto appIt = std::find_if(rApps.begin(), rApps.end(), [&](const Application &app) {
+                                     return app.name == selectedName;
+                                 });
+
+                                 if (appIt != rApps.end())
+                                     rSelectedApps.push_back(selectedName);
+                             }
+                         }
+
+                         for (const QModelIndex &index: deselected.indexes()) {
+                             QString deselectedName = modelAppList0->data(index, Qt::DisplayRole).toString();
+
+                             rSelectedApps.erase(std::remove_if(rSelectedApps.begin(), rSelectedApps.end(),
+                                                                [&](const QString &appName) {
+                                                                    return appName == deselectedName;
+                                                                }), rSelectedApps.end());
+                         }
+                     });
+
+    QObject::connect(buttonBox, &QDialogButtonBox::clicked, self, [&](QAbstractButton *button) {
+        if (buttonBox->standardButton(button) != QDialogButtonBox::Apply)
+            return;
+
+        Ui::appsForRemoval.clear();
+
+        for (const QString &index: rSelectedApps) {
+            auto it = std::find_if(rApps.begin(), rApps.end(), [&](const Application &app) {
+                return app.name == index;
+            });
+
+            if (it != rApps.end()) {
+                Ui::appsForRemoval.push_back(*it);
+            }
+        }
+
+        appListView->selectionModel()->clearSelection();
+        self->accept();
+    });
+
+    QObject::connect(buttonBox, &QDialogButtonBox::rejected, self, [&]() {
+        self->reject();
+    });
+}

Sources/AppGUI/SharedData/Shared.hpp

@@ -0,0 +1,72 @@
+#ifndef AppRemoval_HPP
+#define AppRemoval_HPP
+
+#include "Model/AppListModel.hpp"
+
+#include <QtCore/QVariant>
+#include <QtWidgets/QAbstractButton>
+#include <QtWidgets/QApplication>
+#include <QtWidgets/QDialog>
+#include <QtWidgets/QDialogButtonBox>
+#include <QtWidgets/QLabel>
+#include <QtWidgets/QLineEdit>
+#include <QtWidgets/QListView>
+
+QT_BEGIN_NAMESPACE
+
+class Ui_AppRemovalDialog {
+public:
+    QDialog *self;
+    QDialogButtonBox *buttonBox;
+    QLabel *labelFilter;
+    QLineEdit *filterBox;
+    QListView *appListView;
+
+    void setupUi(QDialog *AppRemovalDialog) {
+        if (AppRemovalDialog->objectName().isEmpty())
+            AppRemovalDialog->setObjectName("AppRemovalDialog");
+        AppRemovalDialog->resize(491, 377);
+        self = AppRemovalDialog;
+        buttonBox = new QDialogButtonBox(AppRemovalDialog);
+        buttonBox->setObjectName("buttonBox");
+        buttonBox->setGeometry(QRect(140, 330, 341, 32));
+        buttonBox->setOrientation(Qt::Orientation::Horizontal);
+        buttonBox->setStandardButtons(
+                QDialogButtonBox::StandardButton::Apply | QDialogButtonBox::StandardButton::Close);
+        labelFilter = new QLabel(AppRemovalDialog);
+        labelFilter->setObjectName("labelFilter");
+        labelFilter->setGeometry(QRect(10, 285, 41, 18));
+        filterBox = new QLineEdit(AppRemovalDialog);
+        filterBox->setObjectName("filterBox");
+        filterBox->setGeometry(QRect(60, 280, 421, 32));
+        appListView = new QListView(AppRemovalDialog);
+        appListView->setObjectName("appListView");
+        appListView->setGeometry(QRect(10, 10, 471, 261));
+
+        retranslateUi(AppRemovalDialog);
+
+        QMetaObject::connectSlotsByName(AppRemovalDialog);
+        performLogic();
+    } // setupUi
+
+    void retranslateUi(QDialog *AppRemovalDialog) {
+        AppRemovalDialog->setWindowTitle(QCoreApplication::translate("AppRemovalDialog", "Remove Apps", nullptr));
+        labelFilter->setText(QCoreApplication::translate("AppRemovalDialog", "Filter:", nullptr));
+        filterBox->setPlaceholderText(QCoreApplication::translate("AppRemovalDialog", "Application Name", nullptr));
+    } // retranslateUi
+
+    void performLogic() const;
+
+};
+
+namespace Ui {
+
+    extern std::vector<Application> appsForRemoval;
+
+    class AppRemovalDialog : public Ui_AppRemovalDialog {
+    };
+} // namespace Ui
+
+QT_END_NAMESPACE
+
+#endif // AppRemoval_HPP