Add initial browser application

applications/applications.pro

@@ -16,6 +16,7 @@ SUBDIRS = \
     system-service \
     task-switcher \
     update-desktop-database \
+    web-browser \
     xdg-desktop-icon \
     xdg-desktop-menu \
     xdg-icon-resource \
@@ -40,6 +41,7 @@ xdg-settings.depends = system-service
 xdg-icon-resource.depends = system-service
 desktop-file-edit.depends =
 desktop-file-install.depends =
+web-browser.depends = system-service
 inject_evdev.depends =
 
 INSTALLS += $$SUBDIRS

applications/screenshot-viewer/controller.h

@@ -11,7 +11,7 @@
 using namespace codes::eeems::oxide1;
 using namespace Oxide::Sentry;
 
-#define CORRUPT_SETTINGS_VERSION 1
+#define ANXIETY_SETTINGS_VERSION 1
 
 enum State { Normal, PowerSaving };
 enum BatteryState { BatteryUnknown, BatteryCharging, BatteryDischarging, BatteryNotPresent };
@@ -55,7 +55,7 @@ class Controller : public QObject {
 
         settings.sync();
         auto version = settings.value("version", 0).toInt();
-        if(version < CORRUPT_SETTINGS_VERSION){
+        if(version < ANXIETY_SETTINGS_VERSION){
             migrate(&settings, version);
         }
     }
@@ -133,7 +133,7 @@ private slots:
             throw "Unknown settings version";
         }
         // In the future migrate changes to settings between versions
-        settings->setValue("version", CORRUPT_SETTINGS_VERSION);
+        settings->setValue("version", ANXIETY_SETTINGS_VERSION);
         settings->sync();
     }
 };

applications/web-browser/.gitignore

@@ -0,0 +1,73 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+

applications/web-browser/controller.h

@@ -0,0 +1,83 @@
+#ifndef CONTROLLER_H
+#define CONTROLLER_H
+
+#include <QObject>
+#include <QImage>
+#include <QQuickItem>
+#include <QSettings>
+#include <QTimer>
+
+#include <epframebuffer.h>
+#include <liboxide.h>
+
+#include <QKeyEvent>
+#include <QMouseEvent>
+
+#define MOLD_SETTINGS_VERSION 1
+
+enum State { Normal, PowerSaving };
+enum BatteryState { BatteryUnknown, BatteryCharging, BatteryDischarging, BatteryNotPresent };
+enum ChargerState { ChargerUnknown, ChargerConnected, ChargerNotConnected, ChargerNotPresent };
+enum WifiState { WifiUnknown, WifiOff, WifiDisconnected, WifiOffline, WifiOnline};
+
+class Controller : public QObject {
+    Q_OBJECT
+public:
+    Controller(QObject* parent)
+    : QObject(parent), settings(this), applications() {
+        settings.sync();
+        auto version = settings.value("version", 0).toInt();
+        if(version < MOLD_SETTINGS_VERSION){
+            migrate(&settings, version);
+        }
+    }
+    ~Controller(){}
+
+    Q_INVOKABLE void startup(){
+        qDebug() << "Running controller startup";
+        QTimer::singleShot(10, [this]{
+            setState("loaded");
+        });
+    }
+    QString state() {
+        if(!getStateControllerUI()){
+            return "loading";
+        }
+        return stateControllerUI->property("state").toString();
+    }
+    void setState(QString state){
+        if(!getStateControllerUI()){
+            throw "Unable to find state controller";
+        }
+        stateControllerUI->setProperty("state", state);
+    }
+
+    void setRoot(QObject* root){ this->root = root; }
+signals:
+    void aboutToQuit();
+    void keyEvent(QKeyEvent* ke);
+    void mouseEvent(QMouseEvent* me);
+    void touchEvent(QTouchEvent* te);
+    void tabletEvent(QTabletEvent* te);
+
+private:
+    QSettings settings;
+    QObject* root = nullptr;
+    QObject* stateControllerUI = nullptr;
+    QList<QObject*> applications;
+
+    QObject* getStateControllerUI(){
+        stateControllerUI = root->findChild<QObject*>("stateController");
+        return stateControllerUI;
+    }
+    static void migrate(QSettings* settings, int fromVersion){
+        if(fromVersion != 0){
+            throw "Unknown settings version";
+        }
+        // In the future migrate changes to settings between versions
+        settings->setValue("version", MOLD_SETTINGS_VERSION);
+        settings->sync();
+    }
+};
+
+#endif // CONTROLLER_H

applications/web-browser/keyboardhandler.h

@@ -0,0 +1,90 @@
+#ifndef KEYBOARD_H
+#define KEYBOARD_H
+#include <Qt>
+#include <QQmlApplicationEngine>
+#include <QChar>
+#include <QKeyEvent>
+#include <QCoreApplication>
+#include <QDebug>
+#include <QQuickItem>
+
+class KeyboardHandler : public QObject {
+    Q_OBJECT
+public:
+    explicit KeyboardHandler(QObject *parent = 0) : QObject(parent) {}
+   QQuickItem* root;
+    Q_INVOKABLE void charPress(const QChar &character, const Qt::KeyboardModifiers &modifier){
+        if(character != '\x0'){
+            int key = character.unicode();
+            auto targets = focusObjects();
+            if(targets.empty()){
+                qDebug() << "No target";
+                return;
+            }
+            qDebug() << targets;
+            for(auto target : targets){
+                QKeyEvent* event = new QKeyEvent(QEvent::KeyPress, key, modifier, QString(character));
+                QCoreApplication::postEvent(target, event);
+            }
+            qDebug() << "Char pressed: " << QKeySequence(key + modifier).toString();
+        }else{
+            qDebug() << "Invalid char";
+            keyPress(Qt::Key_unknown, modifier, QString());
+        }
+    }
+    Q_INVOKABLE void keyPress(const Qt::Key &key, const Qt::KeyboardModifiers &modifier, const QString &text){
+        auto targets = focusObjects();
+        if(targets.empty()){
+            qDebug() << "No target";
+            return;
+        }
+        qDebug() << targets;
+        for(auto target : targets){
+            QKeyEvent* event = new QKeyEvent(QEvent::KeyPress, key, modifier, text);
+            QCoreApplication::postEvent(target, event);
+        }
+        QKeySequence sequence;
+        switch(key){
+            case Qt::Key_Shift:
+            case Qt::Key_Alt:
+            case Qt::Key_AltGr:
+            case Qt::Key_Control:
+            case Qt::Key_Meta:
+                sequence = QKeySequence(modifier);
+                break;
+            default:
+                sequence = QKeySequence(key + modifier);
+                break;
+        }
+        qDebug() << "Key pressed: " << sequence.toString() << " text: " << text;
+    }
+    Q_INVOKABLE void stringPress(const QString &text, const Qt::KeyboardModifiers &modifier){
+        auto targets = focusObjects();
+        if(targets.empty()){
+            qDebug() << "No target";
+            return;
+        }
+        qDebug() << targets;
+        for(auto target : targets){
+            QKeyEvent* event = new QKeyEvent(QEvent::KeyPress, Qt::Key_unknown, modifier, text);
+            QCoreApplication::postEvent(target, event);
+            QVariant readOnly = target->property("readOnly");
+            QVariant length = target->property("length");
+            if(target->property("text").isValid() && length.isValid() && readOnly.isValid() && !readOnly.toBool()){
+                QMetaObject::invokeMethod(target, "insert", Q_ARG(int, length.toInt()), Q_ARG(QString, text));
+            }
+        }
+        qDebug() << "String pressed: " << QKeySequence(text + modifier).toString();
+    }
+    QList<QQuickItem*> focusObjects(){
+        QList<QQuickItem*> focusItems;
+        for(auto widget : root->findChildren<QQuickItem*>()){
+            if(widget->hasActiveFocus()){
+                focusItems.append(widget);
+            }
+        }
+        return focusItems;
+    }
+};
+
+#endif // KEYBOARD_H

applications/web-browser/main.cpp

@@ -0,0 +1,76 @@
+#include <QGuiApplication>
+#include <QQmlApplicationEngine>
+#include <QtPlugin>
+#include <QtQuick>
+
+#include <cstdlib>
+#include <signal.h>
+#include <liboxide.h>
+#include <liboxide/eventfilter.h>
+
+#include "controller.h"
+#include "keyboardhandler.h"
+
+#ifdef __arm__
+Q_IMPORT_PLUGIN(QsgEpaperPlugin)
+#endif
+
+#include "dbusservice_interface.h"
+
+using namespace std;
+using namespace Oxide;
+
+const char* qt_version = qVersion();
+
+void sigHandler(int signal){
+    ::signal(signal, SIG_DFL);
+    qApp->quit();
+}
+
+int main(int argc, char *argv[]){
+    if (strcmp(qt_version, QT_VERSION_STR) != 0){
+        qDebug() << "Version mismatch, Runtime: " << qt_version << ", Build: " << QT_VERSION_STR;
+    }
+#ifdef __arm__
+    // Setup epaper
+    qputenv("QMLSCENE_DEVICE", "epaper");
+    qputenv("QT_QPA_PLATFORM", "epaper:enable_fonts");
+    qputenv("QT_QPA_EVDEV_TOUCHSCREEN_PARAMETERS", deviceSettings.getTouchEnvSetting());
+    qputenv("QT_QPA_GENERIC_PLUGINS", "evdevtablet");
+//    qputenv("QT_DEBUG_BACKINGSTORE", "1");
+#endif
+    qmlRegisterType<KeyboardHandler>("KeyboardHandler", 1, 0, "KeyboardHandler");
+    QGuiApplication app(argc, argv);
+    auto filter = new EventFilter(&app);
+    app.installEventFilter(filter);
+    app.setOrganizationName("Eeems");
+    app.setOrganizationDomain(OXIDE_SERVICE);
+    app.setApplicationName("mold");
+    app.setApplicationDisplayName("Web Browser");
+    app.setApplicationVersion(OXIDE_INTERFACE_VERSION);
+    Controller controller(&app);
+    QQmlApplicationEngine engine;
+    QQmlContext* context = engine.rootContext();
+    context->setContextProperty("screenGeometry", app.primaryScreen()->geometry());
+    context->setContextProperty("controller", &controller);
+    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
+    if (engine.rootObjects().isEmpty()){
+        qDebug() << "Nothing to display";
+        return -1;
+    }
+    auto root = engine.rootObjects().first();
+    filter->root = (QQuickItem*)root;
+    controller.setRoot(root);
+    KeyboardHandler* keyboard = root->findChild<KeyboardHandler*>("keyboard");
+    if(!keyboard){
+        qDebug() << "No keyboard handler";
+        return 1;
+    }
+    keyboard->root = (QQuickItem*)root;
+
+    signal(SIGINT, sigHandler);
+    signal(SIGSEGV, sigHandler);
+    signal(SIGTERM, sigHandler);
+
+    return app.exec();
+}