diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..8680b5e --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "shared-libraries"] + path = shared-libraries + url = https://git.itsblue.de/ScStw/shared-libraries.git diff --git a/CHANGELOG b/CHANGELOG deleted file mode 100644 index ee02e0b..0000000 --- a/CHANGELOG +++ /dev/null @@ -1,52 +0,0 @@ -# Changelog -All notable changes to this project will be documented in this file. - -The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) -and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). - -## [1.1] -### Added -- connecting to and controlling a ScStw Basestation is now possible -- creating profiles and saving times is now possible (only when connected to a ScStw Basestation) -- dark mode -### Changed -- new, more modern style -- new start tone which is compliant with the IFSC norm -- new and improved codebase - - -## [0.04] - 2018-08-11 -### Added -- buzzer icon in the upper left corner indicating that the buzzer is connected -### Fixed -- start seqnece continues in a buggy way when cancel is being pressed while 'at your marks' or 'ready' -- bug that made the start sequence freeze if a delay of zero or lower or a non valid number was set as delay -### Changed -- increased the size of the back buttons in settings / profiles dialog - -## [0.03 - BETA] - 2018-07-29 -### Added -- cancel button during start sequence -- new screen in landscape mode -- buttons for settings and profiles -- the screen stays on now -- the volume csontrols control the media volume directly -- settings dialog -- capabilitie to connect to a Buzzer via Wifi -- it is now possible to setup an automatic start sequence that spells the command -'at your marks' and 'ready' with a customizable delay before them -### Fixed -- bug that made a Button freeze when it was pressed and the screen rotated at the same time - -## [0.02] - 2018-07-18 -### Fixed -- negative time when the stopping starts -- removed delay between the end of the startton an the begin of the stopping -### Changed -- slowed down animations -### Added -- animation for the text "click start to start" between STOPPED and IDLE to - prevent it from getting out of the screen - -## [0.01] -### Initial Release diff --git a/ScStwApp.pro b/ScStwApp.pro index ad328a6..1800b0d 100644 --- a/ScStwApp.pro +++ b/ScStwApp.pro @@ -18,26 +18,20 @@ DEFINES += QT_DEPRECATED_WARNINGS # You can also select to disable deprecated APIs only up to a certain version of Qt. #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 -TARGET = speedclimbing_stw +TARGET = ScStwApp + +# include submodules +CONFIG += ScStwLibraries_QML ScStwLibraries_Styling ScStwLibraries_ClientLibs +include($$PWD/shared-libraries/ScStwLibraries/ScStwLibraries.pri) SOURCES += \ + sources/scstwappbackend.cpp \ sources/main.cpp \ - sources/sqlstoragemodel.cpp \ - sources/sqlprofilemodel.cpp \ - sources/appsettings.cpp \ - sources/baseconn.cpp \ - sources/speedtimer.cpp \ - sources/climbingrace.cpp \ - sources/apptheme.cpp + sources/scstwappsettings.cpp HEADERS += \ - headers/sqlstoragemodel.h \ - headers/sqlprofilemodel.h \ - headers/appsettings.h \ - headers/baseconn.h \ - headers/speedtimer.h \ - headers/climbingrace.h \ - headers/apptheme.h + headers/scstwappbackend.h \ + headers/scstwappsettings.h RESOURCES += \ resources/shared/shared.qrc \ @@ -59,10 +53,18 @@ else: unix:!android: target.path = /home/pi/$${TARGET}/bin !isEmpty(target.path): INSTALLS += target DISTFILES += \ - android-sources/AndroidManifest.xml \ CHANGELOG \ - android-sources/src/MainActivity.java + android/AndroidManifest.xml \ + android/build.gradle \ + android/gradle.properties \ + android/gradle/wrapper/gradle-wrapper.jar \ + android/gradle/wrapper/gradle-wrapper.properties \ + android/gradlew \ + android/gradlew.bat \ + android/res/values/libs.xml \ + android/src/de/itsblue/scstw/MainActivity.java android { - ANDROID_PACKAGE_SOURCE_DIR = $$PWD/android-sources + ANDROID_PACKAGE_SOURCE_DIR = $$PWD/android + ANDROID_ABIS = armeabi-v7a arm64-v8a } diff --git a/android-sources/AndroidManifest_old.xml b/android/AndroidManifest.xml similarity index 66% rename from android-sources/AndroidManifest_old.xml rename to android/AndroidManifest.xml index c9d943e..31a7da9 100644 --- a/android-sources/AndroidManifest_old.xml +++ b/android/AndroidManifest.xml @@ -1,44 +1,54 @@ - - - + + + + + + + + + + - - - + - - - + - + - - - + + + + - + + + - - - - + - - - - + + - - - - - - - - - - - - - - - - - + diff --git a/android-sources/AndroidManifest.xml b/android/AndroidManifest.xml.old similarity index 98% rename from android-sources/AndroidManifest.xml rename to android/AndroidManifest.xml.old index d8e5b8a..e065954 100644 --- a/android-sources/AndroidManifest.xml +++ b/android/AndroidManifest.xml.old @@ -22,11 +22,9 @@ - - @@ -49,12 +47,10 @@ - - - - - - - - - + + - + + + + + + + + + + + + + + + diff --git a/android-sources/src/MainActivity.java b/android/src/de/itsblue/scstw/MainActivity.java similarity index 88% rename from android-sources/src/MainActivity.java rename to android/src/de/itsblue/scstw/MainActivity.java index 79815bf..be8a921 100644 --- a/android-sources/src/MainActivity.java +++ b/android/src/de/itsblue/scstw/MainActivity.java @@ -15,12 +15,13 @@ along with this program. If not, see . */ -package com.itsblue.speedclimbing_stopwatch; +package de.itsblue.scstw; + public class MainActivity extends org.qtproject.qt5.android.bindings.QtActivity { @Override public void onCreate(android.os.Bundle savedInstanceState){ super.onCreate(savedInstanceState); this.getWindow().addFlags(android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON); - //this.getWindow().setVolumeControlStream(android.view.AudioManager.STREAM_MUSIC); + this.setVolumeControlStream(android.media.AudioManager.STREAM_MUSIC); } } diff --git a/headers/appsettings.h b/headers/appsettings.h deleted file mode 100644 index 8e315ae..0000000 --- a/headers/appsettings.h +++ /dev/null @@ -1,28 +0,0 @@ -#ifndef APPSETTINGS_H -#define APPSETTINGS_H - -#include -#include -#include - -class AppSettings : public QObject -{ - Q_OBJECT -public: - explicit AppSettings(QObject *parent = nullptr); - ~AppSettings(); - - Q_INVOKABLE QString loadSetting(const QString &key); - Q_INVOKABLE void writeSetting(const QString &key, const QVariant &variant); - Q_INVOKABLE void setDefaultSetting(const QString &key, const QVariant &defaultVariant); - - QSettings *settingsManager; - -signals: - -public slots: - -}; -extern AppSettings * pGlobalAppSettings; - -#endif // APPSETTINGS_H diff --git a/headers/apptheme.h b/headers/apptheme.h deleted file mode 100644 index e2e683b..0000000 --- a/headers/apptheme.h +++ /dev/null @@ -1,31 +0,0 @@ -#ifndef APPTHEME_H -#define APPTHEME_H - -#include -#include -#include "appsettings.h" - -class AppTheme : public QObject -{ - Q_OBJECT - Q_PROPERTY(QVariant style READ getStyle NOTIFY styleChanged) -public: - explicit AppTheme(QObject *parent = nullptr); - -private: - QVariant lightTheme; - QVariant darkTheme; - - QVariant * currentTheme; - - -signals: - void styleChanged(); - -public slots: - QVariant getStyle(); - Q_INVOKABLE void changeTheme(); - Q_INVOKABLE void refreshTheme(); -}; - -#endif // APPTHEME_H diff --git a/headers/baseconn.h b/headers/baseconn.h deleted file mode 100644 index 5639bce..0000000 --- a/headers/baseconn.h +++ /dev/null @@ -1,153 +0,0 @@ -#ifndef BASECONN_H -#define BASECONN_H - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "headers/appsettings.h" -#include "headers/speedtimer.h" - -class BaseConn : public QObject -{ - Q_OBJECT - -public: - explicit BaseConn(QObject *parent = nullptr); - - // values for the socket connection - int connection_progress; - QString ip; - ushort port = 3563; - int errors; - int errors_until_disconnect = 4; - - QVariant connections; - - QString latestReadReply; - - //---general status values---// - - // some meta data of the base - QString firmwareVersion; - bool firmwareUpToDate; - double timeOffset; - - - // the current state - QString state; - // can be: - // - 'disconnected' - // - 'connecting' - // - 'connected' - - -private: - QDateTime *date; - //to get the current time - - QTcpSocket *socket; - //socket for communication with the extention - - QTimer *timeoutTimer; - - QString readBuffer; - - int nextConnectionId; - - struct waitingRequest { - int id; - QEventLoop * loop; - QJsonObject reply; - }; - - QList waitingRequests; - -signals: - void stateChanged(); - //is emitted, when the connection state changes - - void progressChanged(); - //is emmited during the connection process when the progress changes - - void gotUnexpectedReply(QString reply); - - void gotUpdate(QVariant data); - - void connectionsChanged(); - - void connectionSlotReleased(); - - void nextRemoteActionChanged(); - - void nextRemoteActionDelayProgChanged(); - - void gotError(QString error); - - void propertiesChanged(); - -public slots: - - void connectToHost(); - //function to connect to the base station - - void connectionTimeout(); - - bool init(); - void deInit(); - - void closeConnection(); - - void gotError(QAbstractSocket::SocketError err); - - // --- socket communication handling --- - - QVariantMap sendCommand(int header, QJsonValue data = "", bool useTerminationKeys = true, int timeout = 3000); - - // --- updater functions --- - - bool updateTime(); - bool updateFirmware(); - bool isFirmwareUpToDate(); - - // --- helper functions --- - - int writeRemoteSetting(QString key, QString value); - - bool refreshConnections(); - - void setConnections(QVariantList connections); - - - // functions for the qml adapter - QString getIP() const; - void setIP(const QString &ipAdress); - - QString getState() const; - void setState(QString newState); - - int getProgress() const; - - QVariant getConnections(); - -private slots: - void readyRead(); - - void processSocketMessage(QString message); - - void socketReplyRecieved(QString reply); - - void socketStateChanged(QAbstractSocket::SocketState socketState); -}; -extern BaseConn * pGlobalBaseConn; - -#endif // BASECONN_H diff --git a/headers/buzzerconn.h b/headers/buzzerconn.h deleted file mode 100644 index 8255edb..0000000 --- a/headers/buzzerconn.h +++ /dev/null @@ -1,79 +0,0 @@ -#ifndef BUZZERCONN_H -#define BUZZERCONN_H - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -typedef struct strReturnData{ - int status_code; - QString text; -}ReturnData_t; - -class BuzzerConn : public QObject -{ - Q_OBJECT -public: - explicit BuzzerConn(QObject *parent = nullptr, QString ip = "http://192.168.4.1", int port = 80); - double offset; - QList latest_offsets; - double latest_button_pressed; - double starttime; - bool connected; - int connection_progress; - QString ip; - int port; - int errors; - int errors_until_disconnect = 4; - - - -private: - QNetworkAccessManager *networkManager; - QNetworkAccessManager *reloadNetworkManager; - QDateTime *date; - QTcpSocket *socket; - QStringList pending_commands; - //QSemaphore dataPipe(1); -signals: - -public slots: - ReturnData_t senddata(QNetworkAccessManager * NetMan, QUrl serviceUrl, int timeout); - //function to communicate with the buzzer - Q_INVOKABLE signed long sendCommand(QString command, int timeout); - //function to send commands to the sensor - //Can be: - //command - return - //GET_TIMESTAMP - timestamp of the sensor - //GET_LASTPRESSED - timestamp of the sensor when it was triggered the last time - // - //error codes: - //(-1) : timeout - //(-2) : invalid data was recieved - Q_INVOKABLE QList gettimes(int timeout); - //function to get the times from the buzzer as a list with the normal network manager - Q_INVOKABLE bool connect(); - //function to connect to buzzer - Q_INVOKABLE bool calcoffset(QList times); - //function that calculates the average time offset between the buzzer and the device - Q_INVOKABLE bool buzzer_triggered(); - //function that checks ih the buzzer has been pushed since the last call of this function - Q_INVOKABLE bool start(); - //syncs the buzzer and the base to make a start possible - Q_INVOKABLE double get(QString key); - //can return some things (offset, lastpressed, currtime, connection_progress, connected) - Q_INVOKABLE QString test(); - Q_INVOKABLE bool refresh(); - //refreshed the connection to the buzzer - Q_INVOKABLE void appendCommand(QString command); - - -}; - -#endif // BUZZERCONN_H diff --git a/headers/climbingrace.h b/headers/climbingrace.h deleted file mode 100644 index ada6797..0000000 --- a/headers/climbingrace.h +++ /dev/null @@ -1,120 +0,0 @@ -#ifndef CLIMBINGRACE_H -#define CLIMBINGRACE_H - -#include -#include -#include -#include -#include "headers/baseconn.h" -#include "headers/appsettings.h" -#include "headers/speedtimer.h" - -class ClimbingRace : public QObject -{ - Q_OBJECT - - Q_PROPERTY(int state READ getState NOTIFY stateChanged) - Q_PROPERTY(int mode READ getMode NOTIFY modeChanged) - Q_PROPERTY(QVariant timers READ getTimerTextList NOTIFY timerTextChanged) - Q_PROPERTY(QString baseStationState READ getBaseStationState NOTIFY baseStationStateChanged) - Q_PROPERTY(QVariant baseStationConnections READ getBaseStationConnections NOTIFY baseStationConnectionsChanged) - Q_PROPERTY(double nextStartActionDelayProgress READ getNextStartActionDelayProgress NOTIFY nextStartActionDelayProgressChanged) - Q_PROPERTY(int nextStartAction READ getNextStartAction NOTIFY nextStartActionChanged) - Q_PROPERTY(QVariantMap baseStationProperties READ getBaseStationProperties NOTIFY baseStationPropertiesChanged) - -public: - explicit ClimbingRace(QObject *parent = nullptr); - - enum raceState { IDLE, STARTING, WAITING, RUNNING, STOPPED }; - raceState state; - - enum raceMode { LOCAL, REMOTE }; - raceMode mode; - - enum NextStartAction { AtYourMarks, Ready, Start, None }; - -private: - AppSettings * appSettings; - BaseConn * baseConn; - - QMediaPlayer * player; - - QTimer * timerTextRefreshTimer; - QTimer * nextStartActionTimer; - - QDateTime *date; - - QList speedTimers; - - NextStartAction nextStartAction; - - double nextStartActionDelayProgress; - // only used in remote mode: - double nextStartActionDelayStartedAt; - double nextStartActionTotalDelay; - - // helper vars - QVariantList qmlTimers; - const QStringList remoteSettings = {"ready_en", "ready_delay", "at_marks_en", "at_marks_delay"}; - const QStringList remoteOnlySettings = {"soundVolume"}; - -private slots: - // helper functions - void playSoundsAndStartRace(); - bool playSound(QString path); - void setState(raceState newState); - void refreshMode(); - void refreshTimerText(); - - bool refreshRemoteTimers(QVariantList timers); - -signals: - void nextStartActionChanged(); - void nextStartActionDelayProgressChanged(); - - void stateChanged(int state); - void modeChanged(); - void timerTextChanged(); - void baseStationStateChanged(); - void baseStationConnectionsChanged(); - void baseStationPropertiesChanged(); - -public slots: - Q_INVOKABLE int startRace(); - Q_INVOKABLE int stopRace(int type); - Q_INVOKABLE int resetRace(); - - // base station sync - void handleBaseStationUpdate(QVariant data); - Q_INVOKABLE bool pairConnectedUsbExtensions(); - - // functions for qml - Q_INVOKABLE int getState(); - Q_INVOKABLE int getMode(); - Q_INVOKABLE QVariant getTimerTextList(); - Q_INVOKABLE double getNextStartActionDelayProgress(); - Q_INVOKABLE int getNextStartAction(); - - Q_INVOKABLE void writeSetting(QString key, QVariant value); - Q_INVOKABLE QString readSetting(QString key); - - Q_INVOKABLE void connectBaseStation(); - Q_INVOKABLE void disconnectBaseStation(); - Q_INVOKABLE QString getBaseStationState(); - Q_INVOKABLE QVariant getBaseStationConnections(); - Q_INVOKABLE QVariantMap getBaseStationProperties(); - - Q_INVOKABLE bool updateBasestationFirmware(); - Q_INVOKABLE bool updateBasestationTime(); - - // athlete management - Q_INVOKABLE QVariant getAthletes(); - Q_INVOKABLE bool createAthlete( QString userName, QString fullName ); - Q_INVOKABLE bool deleteAthlete( QString userName ); - Q_INVOKABLE bool selectAthlete( QString userName, int timerId ); - Q_INVOKABLE QVariant getResults( QString userName ); - - Q_INVOKABLE bool reloadBaseStationIpAdress(); -}; - -#endif // CLIMBINGRACE_H diff --git a/headers/scstwappbackend.h b/headers/scstwappbackend.h new file mode 100644 index 0000000..783906d --- /dev/null +++ b/headers/scstwappbackend.h @@ -0,0 +1,42 @@ +#ifndef SCSTWAPPBACKEND_H +#define SCSTWAPPBACKEND_H + +#include + +#include +#include +#include +#include + +#include "headers/scstwappsettings.h" + + +class ScStwAppBackend : public QObject +{ + Q_OBJECT + + Q_PROPERTY(ScStwClient *scStwClient READ getScStwClient WRITE setScStwClient NOTIFY scStwClientChanged) + +public: + explicit ScStwAppBackend(QObject *parent = nullptr); + +private: + ScStwClient * scStwClient; + +public slots: + // functions for qml + Q_INVOKABLE ScStwClient *getScStwClient(); + Q_INVOKABLE void setScStwClient(ScStwClient *client); + + // athlete management + Q_INVOKABLE QVariant getAthletes(); + Q_INVOKABLE bool createAthlete( QString userName, QString fullName ); + Q_INVOKABLE bool deleteAthlete( QString userName ); + Q_INVOKABLE bool selectAthlete( QString userName, int timerId ); + Q_INVOKABLE QVariant getResults( QString userName ); + +signals: + void scStwClientChanged(); +}; + +#endif // SCSTWAPPBACKEND_H diff --git a/headers/scstwappsettings.h b/headers/scstwappsettings.h new file mode 100644 index 0000000..c42fa1d --- /dev/null +++ b/headers/scstwappsettings.h @@ -0,0 +1,58 @@ +#ifndef APPSETTINGS_H +#define APPSETTINGS_H + +#include +#include +#include +#include "scstwremotesettings.h" + +class ScStwAppSettings : public ScStwRemoteSettings +{ + Q_OBJECT +public: + explicit ScStwAppSettings(QObject *parent = nullptr); + explicit ScStwAppSettings(ScStwClient * scStwClient, QObject *parent = nullptr); + + enum AppInternalSetting { + InvalidSetting = -1, + AppThemeSetting, + BaseStationIpSetting + }; + Q_ENUM(AppInternalSetting) + + enum KeyLevelEnum { + KeyLevel = 1 + }; + Q_ENUM(KeyLevelEnum) + + using ScStwSettings::readSetting; + Q_INVOKABLE QVariant readSetting(AppInternalSetting key); + using ScStwSettings::writeSetting; + Q_INVOKABLE bool writeSetting(AppInternalSetting key, QVariant value); + using ScStwSettings::setDefaultSetting; + Q_INVOKABLE bool setDefaultSetting(AppInternalSetting key, QVariant defaultValue); + + static QString keyToString(int key) { + return QMetaEnum::fromType().valueToKey(key); + } + + static QVariant::Type keyToType(int key) { + QMap types = { + {AppThemeSetting, QVariant::String}, + {BaseStationIpSetting, QVariant::String} + }; + + if(types.contains(AppInternalSetting(key))) + return types[AppInternalSetting(key)]; + + return QVariant::Invalid; + } + +signals: + +public slots: + +}; +extern ScStwAppSettings * pGlobalAppSettings; + +#endif // APPSETTINGS_H diff --git a/headers/speedtimer.h b/headers/speedtimer.h deleted file mode 100644 index 1beca26..0000000 --- a/headers/speedtimer.h +++ /dev/null @@ -1,48 +0,0 @@ -#ifndef SPEEDTIMER_H -#define SPEEDTIMER_H - -#include -#include -#include -#include -#include - -class SpeedTimer : public QObject -{ - Q_OBJECT -public: - explicit SpeedTimer(QObject *parent = nullptr); - - enum timerState { IDLE, STARTING, WAITING, RUNNING, WON, LOST, FAILED, CANCELLED, DISABLED }; - timerState state; - - // variables for capturing the time - double startTime; - double stopTime; - double stoppedTime; - double reactionTime; - -signals: - void stateChanged(timerState newState); - void startCanceled(bool falseStart); - -public slots: - bool start(bool force = false); - bool stop(int type, bool force = false); - bool reset(bool force = false); - - void setState(timerState newState); - QString getState(); - double getCurrTime(); - QString getText(); - - //helper functions - - void delay(int mSecs); - - timerState stateFromString(QString state); -private: - QDateTime *date; -}; - -#endif // SPEEDTIMER_H diff --git a/headers/sqlprofilemodel.h b/headers/sqlprofilemodel.h deleted file mode 100644 index 253b7ef..0000000 --- a/headers/sqlprofilemodel.h +++ /dev/null @@ -1,29 +0,0 @@ -#ifndef SQLPROFILEMODEL_H -#define SQLPROFILEMODEL_H - -#include -#include -#include -#include -#include -#include -#include - -class SqlProfileModel : public QSqlTableModel -{ - Q_OBJECT -public: - explicit SqlProfileModel(QObject *parent = nullptr); - - QVariant data(const QModelIndex &index, int role) const Q_DECL_OVERRIDE; - QHash roleNames() const Q_DECL_OVERRIDE; - - - Q_INVOKABLE bool append(QString name); - Q_INVOKABLE void remove(int row); -signals: - -public slots: -}; - -#endif // SQLPROFILEMODEL_H diff --git a/headers/sqlstoragemodel.h b/headers/sqlstoragemodel.h deleted file mode 100644 index 51289f3..0000000 --- a/headers/sqlstoragemodel.h +++ /dev/null @@ -1,26 +0,0 @@ -#ifndef SQLSTORAGEMODEL_H -#define SQLSTORAGEMODEL_H - -#include -#include -#include -#include -#include -#include -#include - -class SqlStorageModel : public QSqlTableModel -{ - Q_OBJECT - -public: - explicit SqlStorageModel(QObject *parent = nullptr); - - QVariant data(const QModelIndex &index, int role) const Q_DECL_OVERRIDE; - QHash roleNames() const Q_DECL_OVERRIDE; -signals: - -public slots: -}; - -#endif // SQLSTORAGEMODEL_H diff --git a/resources/qml/MainPage/BottomToolBar.qml b/resources/qml/MainPage/BottomToolBar.qml new file mode 100644 index 0000000..ef7ee3b --- /dev/null +++ b/resources/qml/MainPage/BottomToolBar.qml @@ -0,0 +1,99 @@ +import QtQuick 2.0 +import QtQuick.Controls 2.0 +import QtQuick.Layouts 1.0 + +import "../components" +import "../components/layout" + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 + +ToolBar { + id: control + + property bool connectedToBase: speedBackend.scStwClient.state === ScStwClient.CONNECTED + + GridLayout { + id: bottomContentLayout + + anchors { + left: parent.left + leftMargin: app.landscape() ? 0:parent.width * 0.1 + right: parent.right + rightMargin: app.landscape() ? 0:parent.width * 0.1 + top: parent.top + topMargin: app.landscape() ? parent.height * 0.1:0 + bottom: parent.bottom + bottomMargin: app.landscape() ? parent.height * 0.1:0 + } + + columns: app.landscape() ? 1:2 + rows: app.landscape() ? 2:1 + + FancyButton { + id: settingsButt + + Layout.alignment: Layout.Center + Layout.preferredHeight: app.landscape() ? width:control.height * 0.8 + Layout.preferredWidth: app.landscape() ? control.width * 0.8:height + + onClicked: { + settingsDialog.open() + } + + image: appTheme.theme.images.settIcon + + backgroundColor: parent.pressed ? appTheme.theme.colors.buttonPressed:appTheme.theme.colors.button + + } + + FancyButton { + id: profilesButt + + property double size + + state: control.connectedToBase ? "visible":"hidden" + visible: size > 0 + + Layout.alignment: Layout.Center + Layout.preferredWidth: app.landscape() ? control.width * size:control.height * size + Layout.preferredHeight: width + + image: appTheme.theme.images.profilesIcon + + backgroundColor: parent.pressed ? appTheme.theme.colors.buttonPressed:appTheme.theme.colors.button + + onClicked: { + profilesDialog.open() + } + + states: [ + State { + name: "hidden" + PropertyChanges { + target: profilesButt + size: 0 + } + }, + State { + name: "visible" + PropertyChanges { + target: profilesButt + size: 0.8 + } + } + ] + + transitions: [ + Transition { + NumberAnimation { + duration: 200 + properties: "size" + } + } + ] + } + } +} + diff --git a/resources/qml/MainPage/CenterContent.qml b/resources/qml/MainPage/CenterContent.qml new file mode 100644 index 0000000..82b5b67 --- /dev/null +++ b/resources/qml/MainPage/CenterContent.qml @@ -0,0 +1,395 @@ +import QtQuick 2.0 +import QtQuick.Controls 2.0 +import QtGraphicalEffects 1.0 +import QtQuick.Layouts 1.0 + +import "../components" +import "../components/layout" + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 + +Item { + id: control + + GridLayout { + id: centerLayout + + //anchors.centerIn: parent + + anchors { + right: parent.right + bottom: parent.bottom + } + + width: parent.width + height: parent.height + + columns: app.landscape() ? 3:1 + rows: app.landscape() ? 1:3 + + Item { + id: centerExtraContentTop + + property double size + + Layout.preferredHeight: app.landscape() ? centerLayout.height * 0.6:Math.min(centerLayout.width * size, centerLayout.height * size) + Layout.preferredWidth: app.landscape() ? Math.min(centerLayout.width * size, centerLayout.height * size):centerLayout.width * 0.8 + Layout.alignment: Layout.Center + + + Behavior on size { + NumberAnimation { + duration: 800 + easing.type: Easing.InOutQuart + } + } + + StackView { + id: centerExtraContentTopStack + + anchors.fill: parent + anchors.margins: 1 + + property QtObject newItem: emptyComp + + onNewItemChanged: { + centerExtraContentTopStack.replace(newItem) + } + + replaceEnter: Transition { + SequentialAnimation { + PauseAnimation { + duration: 400 + } + + NumberAnimation { + property: "opacity" + from: 0 + to: 1 + duration: 400 + easing.type: Easing.InOutQuart + } + } + } + + replaceExit: Transition { + NumberAnimation { + property: "opacity" + from: 1 + to: 0 + duration: 400 + easing.type: Easing.InOutQuart + } + } + + + Component { + id: waitingDetailsComp + + Column { + + opacity: 0 + + Row { + id: stateIndicatorRow + + property int delegateWidth: width / stateIndicatorRepeater.model - (spacing * (stateIndicatorRepeater.model - 1) / stateIndicatorRepeater.model) + property int delegateHeight: height + + width: parent.width + height: parent.height * 0.9 + + spacing: width * 0.1 + + Repeater { + id: stateIndicatorRepeater + + model: scStwRemoteRace.timers.length + + delegate: ColumnLayout { + id: timerStatusColumn + + property var thisTimer: scStwRemoteRace.timers[index] + + width: parent.delegateWidth + height: parent.delegateHeight + + Label { + Layout.preferredWidth: parent.width + Layout.preferredHeight: parent.height * 0.1 + + font.pixelSize: height * 0.8 + fontSizeMode: Text.Fit + minimumPointSize: 1 + horizontalAlignment: Text.AlignHCenter + verticalAlignment: Text.AlignVCenter + + color: appTheme.theme.colors.text + + text: "Lane " + timerStatusColumn.thisTimer["letter"] + } + + StateIndicator { + + Layout.fillWidth: true + Layout.fillHeight: true + + backgroundColor: appTheme.theme.colors.background + successColor: appTheme.theme.colors.success + warningColor: appTheme.theme.colors.warning + + state: timerStatusColumn.thisTimer["readyState"] === ScStwTimer.IsReady ? + "success":timerStatusColumn.thisTimer["readyState"] === ScStwTimer.IsDisabled ? + "unknown":"warn" + + indicatorSize: 0.8 + + MouseArea { + anchors.fill: parent + + onClicked: { + var disabled = timerStatusColumn.thisTimer["state"] !== ScStwTimer.DISABLED + console.log("setting timer to disabled: " + disabled) + scStwRemoteRace.setTimerDisabled(timerStatusColumn.thisTimer["id"], disabled) + } + } + } + } + } + } + + Label { + width: parent.width + height: parent.height * 0.1 + + font.pixelSize: height * 0.6 + fontSizeMode: Text.Fit + minimumPointSize: 1 + horizontalAlignment: Text.AlignHCenter + verticalAlignment: Text.AlignVCenter + + color: appTheme.theme.colors.text + + text: "Tap on a lane to disable it" + } + + } + } + + Component { + id: incidentDetailsComp + + ExtensionOverview { + opacity: 0 + backgroundColor: appTheme.theme.colors.background + delegateHeight: centerExtraContentTopStack.height / 5 + } + } + + Component { + id: emptyComp + Item {} + } + + } + } + + MainActionButton { + id: mainActionButton + + property double size + startProgress: scStwRemoteRace.currentStartDelay["progress"] + + Layout.alignment: Layout.Center + + Layout.preferredHeight: app.landscape() ? width:Math.min(centerLayout.width * size, centerLayout.height * size) + Layout.preferredWidth: app.landscape() ? Math.min(centerLayout.width * size, centerLayout.height * size):height + + onClicked: { + if(progressControlActivated && progress < 1.0) + return + + var ret; + + switch(scStwRemoteRace.state) { + case ScStwRace.IDLE: + ret = scStwRemoteRace.start() + break; + case ScStwRace.WAITING: + if(!scStwRemoteRace.readySoundEnabled && scStwRemoteRace.isReadyForNextState) + ret = scStwRemoteRace.start() + else + ret = scStwRemoteRace.cancel() + break; + case ScStwRace.PREPAIRING: + case ScStwRace.STARTING: + ret = scStwRemoteRace.cancel() + break; + case ScStwRace.RUNNING: + ret = scStwRemoteRace.stop() + break; + case ScStwRace.STOPPED: + case ScStwRace.INCIDENT: + ret = scStwRemoteRace.reset() + break; + } + + if(ret !== 200) + console.log("Error executing main button action: " + ret) + + progress = 0 + } + + Behavior on size { + NumberAnimation { + duration: 800 + easing.type: Easing.InOutQuart + } + } + } + + Item { + id: centerExtraContentBottom + + property double size + + Layout.preferredHeight: app.landscape() ? centerLayout.height:Math.min(centerLayout.width * size, centerLayout.height * size) + Layout.preferredWidth: app.landscape() ? Math.min(centerLayout.width * size, centerLayout.height * size):centerLayout.width + + Behavior on size { + NumberAnimation { + duration: 400 + easing.type: Easing.InOutQuart + } + } + } + + } + + states: [ + State { + name: ScStwRace.IDLE + PropertyChanges { + target: mainActionButton + size: 0.9 + text: "start" + } + + PropertyChanges { + target: centerLayout + + height: app.landscape() ? control.height : Math.max(control.height, app.height * 0.4) + width: app.landscape() ? Math.max(control.width, app.width * 0.4) : control.width + } + }, + + State { + name: ScStwRace.PREPAIRING + PropertyChanges { + target: mainActionButton + size: 0.9 + text: "cancel" + } + }, + + State { + name: ScStwRace.WAITING + + PropertyChanges { + target: mainActionButton + size: scStwRemoteRace.competitionMode ? 0.3:0.9 + text: scStwRemoteRace.readySoundEnabled ? "cancel": scStwRemoteRace.isReadyForNextState ? "ready":"cancel" + progressControlActivated: scStwRemoteRace.competitionMode && !scStwRemoteRace.readySoundEnabled && !scStwRemoteRace.isReadyForNextState + } + + PropertyChanges { + target: centerExtraContentTop + + size: scStwRemoteRace.competitionMode ? 0.7:0 + } + + PropertyChanges { + target: centerExtraContentBottom + + size: scStwRemoteRace.competitionMode ? 0.05:0 + } + + PropertyChanges { + target: centerExtraContentTopStack + + newItem: scStwRemoteRace.competitionMode ? waitingDetailsComp:emptyComp + } + }, + + State { + name: ScStwRace.STARTING + PropertyChanges { + target: mainActionButton + size: 0.9 + text: "cancel" + } + }, + + State { + name: ScStwRace.RUNNING + PropertyChanges { + target: mainActionButton + size: 0.9 + text: scStwRemoteRace.competitionMode ? "cancel":"stop" + progressControlActivated: scStwRemoteRace.competitionMode + } + }, + + State { + name: ScStwRace.STOPPED + + PropertyChanges { + target: mainActionButton + + size: 0.5 + + text: "reset" + } + + PropertyChanges { + target: centerLayout + + height: app.landscape() ? control.height : Math.max(control.height, app.height * 0.4) + width: app.landscape() ? Math.max(control.width, app.width * 0.4) : control.width + } + }, + + State { + name: ScStwRace.INCIDENT + + PropertyChanges { + target: mainActionButton + + size: 0.5 + + text: "reset" + } + + PropertyChanges { + target: centerExtraContentTop + + size: scStwRemoteRace.competitionMode ? 0.7:0 + } + + PropertyChanges { + target: centerExtraContentBottom + + size: scStwRemoteRace.competitionMode ? 0.05:0 + } + + PropertyChanges { + target: centerExtraContentTopStack + + newItem: scStwRemoteRace.competitionMode ? incidentDetailsComp:emptyComp + } + } + + ] +} diff --git a/resources/qml/MainPage/TopToolBar.qml b/resources/qml/MainPage/TopToolBar.qml new file mode 100644 index 0000000..58f95c2 --- /dev/null +++ b/resources/qml/MainPage/TopToolBar.qml @@ -0,0 +1,307 @@ +import QtQuick 2.9 +import QtQuick.Controls 2.9 + +import "../components" +import "../components/layout" + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 + +ToolBar { + id: control + + property string statusText + + Loader { + id: topContentLoader + + anchors.fill: parent + + Behavior on state { + FadeAnimation { + target: topContentLoader + fadeDuration: 300 + } + } + + Component { + id: raceStatusLabelComponent + Text { + id: raceStatusLabel + + padding: app.landscape() ? width * 0.2 : height * 0.25 + + text: control.statusText + + color: appTheme.theme.colors.text + + fontSizeMode: Text.Fit + + verticalAlignment: Text.AlignVCenter + horizontalAlignment: Text.AlignHCenter + + font.pixelSize: height + + minimumPixelSize: 1 + + Behavior on text { + FadeAnimation { + target: raceStatusLabel + fadeDuration: 100 + } + } + } + } + + Component { + id: timerColumnComponent + TimerColumn { + id: timerColumn + + anchors.fill: parent + anchors.topMargin: app.landscape() ? 0:parent.height * 0.1 + anchors.bottomMargin: app.landscape() ? 0:parent.height * 0.1 + + timers: scStwRemoteRace.timers + colors: appTheme.theme.colors + fontName: appTheme.theme.fonts.timers + showTimerLetter: true + + + // make text smaller for much better performance + textScale: app.landscape() ? 0.7 : 0.5 + + Behavior on opacity { + NumberAnimation { + duration: 200 + } + } + } + } + } + + + Item { + id: connectionIconContainer + + anchors { + top: parent.top + left: parent.left + right: parent.right + bottom: parent.bottom + bottomMargin: app.landscape() ? parent.height * 0.8:0 + rightMargin: app.landscape() ? 0:parent.width * 0.8 + } + + opacity: scStwRemoteRace.state === ScStwRace.IDLE ? 1:0 + + ConnectionIcon { + id: baseConnConnIcon + + function clientStateToString(state) { + switch(state) { + case ScStwClient.DISCONNECTED: + return "disconnected" + case ScStwClient.CONNECTING: + return "connecting" + case ScStwClient.INITIALISING: + return "connecting" + case ScStwClient.CONNECTED: + return "connected" + } + } + + status: clientStateToString(speedBackend.scStwClient.state) + + source: appTheme.theme.images.baseStationIcon + + anchors { + top: parent.top + topMargin: 10 + left: parent.left + leftMargin: 10 + } + + height: !app.landscape()? parent.height*0.4:parent.width*0.4 + } + + Row { + id: extensionStatusRow + + anchors { + top: parent.top + topMargin: 10 + left: baseConnConnIcon.right + leftMargin: 1 + } + + height: baseConnConnIcon.height * 0.4 + spacing: 5 + + Repeater { + id: extensionStatusRep + + model: Object.keys(speedBackend.scStwClient.extensions) + delegate: Rectangle { + id: statusRect + + property string thisLetter: modelData + property var thisExtensions: speedBackend.scStwClient.extensions[modelData] + property int thisLaneState: getLaneState(thisExtensions) + + width: height + height: parent.height + + radius: width * 0.1 + + color: appTheme.theme.colors.background + border.color: [appTheme.theme.colors.success, appTheme.theme.colors.warning, appTheme.theme.colors.error][thisLaneState] + border.width: width * 0.08 + + onThisExtensionsChanged: { + thisLaneState = getLaneState(thisExtensions) + } + + function getLaneState(extensions) { + var batteryWarning = false; + for(var i = 0; i < extensions.length; i++) { + if(extensions[i]["state"] !== ScStw.ExtensionConnected || extensions[i]["batteryState"] === ScStw.BatteryCritical) + return 2 + if(extensions[i]["batteryState"] === ScStw.BatteryWarning) + batteryWarning = true + } + + return batteryWarning ? 1:0 + } + + Behavior on border.color { + ColorAnimation { + duration: 200 + } + } + + Behavior on color { + ColorAnimation { + duration: 200 + } + } + + Text { + anchors.fill: parent + + text: parent.thisLetter + + fontSizeMode: Text.Fit + font.pixelSize: height * 0.7 + font.bold: true + + color: statusRect.border.color + + verticalAlignment: Text.AlignVCenter + horizontalAlignment: Text.AlignHCenter + } + + } + } + } + + Behavior on opacity { + NumberAnimation { + duration: 200 + } + } + } + + states: [ + State { + name: ScStwRace.IDLE + + PropertyChanges { + target: control + statusText: app.landscape() ? "Press\nstart":"Press start" + } + + PropertyChanges { + target: topContentLoader + sourceComponent: raceStatusLabelComponent + } + }, + + State { + name: ScStwRace.PREPAIRING + + PropertyChanges { + target: control + statusText: "At your\nmarks" + } + + PropertyChanges { + target: topContentLoader + sourceComponent: raceStatusLabelComponent + } + }, + + State { + name: ScStwRace.WAITING + + PropertyChanges { + target: control + statusText: "Ready" + } + + PropertyChanges { + target: topContentLoader + sourceComponent: raceStatusLabelComponent + } + }, + + State { + name: ScStwRace.STARTING + + PropertyChanges { + target: control + statusText: "Starting" + } + + PropertyChanges { + target: topContentLoader + sourceComponent: raceStatusLabelComponent + } + }, + + State { + name: ScStwRace.RUNNING + + PropertyChanges { + target: topContentLoader + sourceComponent: timerColumnComponent + } + }, + + State { + name: ScStwRace.STOPPED + + PropertyChanges { + target: topContentLoader + sourceComponent: timerColumnComponent + } + }, + + State { + name: ScStwRace.INCIDENT + + PropertyChanges { + target: control + statusText: app.landscape() ? "Technical\nincident!":"Technical incident!" + } + + PropertyChanges { + target: topContentLoader + sourceComponent: raceStatusLabelComponent + } + } + + ] + +} diff --git a/resources/qml/ProfilesDialog/AddProfilePage.qml b/resources/qml/ProfilesDialog/AddProfilePage.qml index 0617d96..72de7d4 100644 --- a/resources/qml/ProfilesDialog/AddProfilePage.qml +++ b/resources/qml/ProfilesDialog/AddProfilePage.qml @@ -21,7 +21,11 @@ import QtQuick.Window 2.2 import QtQuick.Controls 2.4 import QtQuick.Layouts 1.3 import QtGraphicalEffects 1.0 -import com.itsblue.speedclimbingstopwatch 1.0 + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 import "../components" diff --git a/resources/qml/ProfilesDialog/ProfileListPage.qml b/resources/qml/ProfilesDialog/ProfileListPage.qml index 8dd109a..5d2a044 100644 --- a/resources/qml/ProfilesDialog/ProfileListPage.qml +++ b/resources/qml/ProfilesDialog/ProfileListPage.qml @@ -21,7 +21,11 @@ import QtQuick.Window 2.2 import QtQuick.Controls 2.4 import QtQuick.Layouts 1.3 import QtGraphicalEffects 1.0 -import com.itsblue.speedclimbingstopwatch 1.0 + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 import "../components" @@ -91,7 +95,7 @@ RemoteDataListView { } text: swipeDelegate.text - color: appTheme.style.textColor + color: appTheme.theme.colors.text verticalAlignment: Text.AlignVCenter horizontalAlignment: Text.AlignLeft @@ -104,7 +108,7 @@ RemoteDataListView { } background: Rectangle { - color: pressed ? appTheme.style.delegatePressedColor : appTheme.style.delegateBackgroundColor + color: pressed ? appTheme.theme.colors.delegatePressed : appTheme.theme.colors.delegateBackground Behavior on color { @@ -128,22 +132,22 @@ RemoteDataListView { Repeater { id: athleteSelectBoxRep - model: speedBackend.timers.length + model: scStwRemoteRace.timers.length delegate: CheckBox { id: control - property bool active: speedBackend.timers[index]["id"] === profileList.listData[swipeDelegate.thisIndex]["active"] + property bool active: scStwRemoteRace.timers[index]["id"] === profileList.listData[swipeDelegate.thisIndex]["active"] anchors.verticalCenter: parent.verticalCenter height: parent.height * 0.6 - enabled: speedBackend.timers[index]["state"] !== "DISABLED" + enabled: scStwRemoteRace.timers[index]["state"] !== ScStwTimer.DISABLED checked: control.active onCheckedChanged: { - if(checked && !control.active && speedBackend.selectAthlete(profileList.listData[swipeDelegate.thisIndex]["userName"], speedBackend.timers[index]["id"])){ + if(checked && !control.active && speedBackend.selectAthlete(profileList.listData[swipeDelegate.thisIndex]["userName"], scStwRemoteRace.timers[index]["id"])){ profileList.loadData() } } @@ -160,7 +164,7 @@ RemoteDataListView { radius: width * 0.2 border.color: control.enabled ? control.down ? "#17a81a" : "#21be2b" : "grey" - color: control.down ? appTheme.style.delegatePressedColor : appTheme.style.delegateBackgroundColor + color: control.down ? appTheme.theme.colors.delegatePressed : appTheme.theme.colors.delegateBackground Rectangle { width: parent.width * 0.65 @@ -233,7 +237,7 @@ RemoteDataListView { Label { id: deleteLabel text: qsTr("Delete") - color: appTheme.style.textColor + color: appTheme.theme.colors.text verticalAlignment: Label.AlignVCenter padding: 12 height: parent.height diff --git a/resources/qml/ProfilesDialog/ProfilesDialog.qml b/resources/qml/ProfilesDialog/ProfilesDialog.qml index 3885185..772c934 100644 --- a/resources/qml/ProfilesDialog/ProfilesDialog.qml +++ b/resources/qml/ProfilesDialog/ProfilesDialog.qml @@ -21,7 +21,12 @@ import QtQuick.Window 2.2 import QtQuick.Controls 2.4 import QtQuick.Layouts 1.3 import QtGraphicalEffects 1.0 -import com.itsblue.speedclimbingstopwatch 1.0 + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 + import "../components" @@ -59,7 +64,7 @@ Popup { id: backgroundRect anchors.fill: parent radius: width * 0.1 - color: appTheme.style.viewColor + color: appTheme.theme.colors.view } } @@ -87,7 +92,7 @@ Popup { Connections { target: root - onOpened: { + function onOpened() { profilesStack.init() } } @@ -132,7 +137,7 @@ Popup { anchors.fill: parent - property color color: appTheme.style.viewColor + property color color: appTheme.theme.colors.view onPaint: { var ctx = getContext("2d"); @@ -173,7 +178,7 @@ Popup { verticalAlignment: Text.AlignVCenter horizontalAlignment: Text.AlignHCenter - color: appTheme.style.textColor + color: appTheme.theme.colors.text text: profilesStack.currentItem.title @@ -196,9 +201,9 @@ Popup { glowOpacity: Math.pow( root.opacity, 100 ) - backgroundColor: appTheme.style.buttonColor + backgroundColor: appTheme.theme.colors.button - image: appTheme.style.backIcon + image: appTheme.theme.images.backIcon onClicked: profilesStack.depth > 1 ? profilesStack.pop():root.close() @@ -221,9 +226,9 @@ Popup { glowOpacity: opacity < 1 ? Math.pow( opacity, 100 ) : Math.pow( opacity, 100 ) - backgroundColor: appTheme.style.buttonColor + backgroundColor: appTheme.theme.colors.button - image: appTheme.style.confirmIcon + image: appTheme.theme.images.confirmIcon imageScale: profilesStack.currentItem.secondButt === "ok" ? 1:0 Label { @@ -235,7 +240,7 @@ Popup { } opacity: profilesStack.currentItem.secondButt === "add" ? 1:0 - color: appTheme.style.textColor + color: appTheme.theme.colors.text text: "+" font.pixelSize: parent.height * 0.8 diff --git a/resources/qml/ProfilesDialog/ProfilesStack.qml b/resources/qml/ProfilesDialog/ProfilesStack.qml index 59fb0a4..c424384 100644 --- a/resources/qml/ProfilesDialog/ProfilesStack.qml +++ b/resources/qml/ProfilesDialog/ProfilesStack.qml @@ -21,7 +21,11 @@ import QtQuick.Window 2.2 import QtQuick.Controls 2.4 import QtQuick.Layouts 1.3 import QtGraphicalEffects 1.0 -import com.itsblue.speedclimbingstopwatch 1.0 + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 import "../components" diff --git a/resources/qml/ProfilesDialog/ResultListPage.qml b/resources/qml/ProfilesDialog/ResultListPage.qml index 30f5fbd..4a337c9 100644 --- a/resources/qml/ProfilesDialog/ResultListPage.qml +++ b/resources/qml/ProfilesDialog/ResultListPage.qml @@ -21,7 +21,12 @@ import QtQuick.Window 2.2 import QtQuick.Controls 2.4 import QtQuick.Layouts 1.3 import QtGraphicalEffects 1.0 -import com.itsblue.speedclimbingstopwatch 1.0 + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 + import "../components" RemoteDataListView { @@ -83,7 +88,7 @@ RemoteDataListView { font.pixelSize: height * 0.8 fontSizeMode: Text.Fit - color: appTheme.style.textColor + color: appTheme.theme.colors.text text: resultDel.getDateText() } @@ -96,7 +101,7 @@ RemoteDataListView { font.pixelSize: height * 0.8 fontSizeMode: Text.Fit - color: appTheme.style.textColor + color: appTheme.theme.colors.text text: qsTr("result: ") + (listData[index]["result"] / 1000).toFixed(3) + " s" } @@ -109,7 +114,7 @@ RemoteDataListView { font.pixelSize: height * 0.8 fontSizeMode: Text.Fit - color: appTheme.style.textColor + color: appTheme.theme.colors.text text: qsTr("reaction time: ") + listData[index]["reactionTime"].toFixed(0) + " ms" } diff --git a/resources/qml/SettingsDialog/SettingsBaseStationConnectionsPage.qml b/resources/qml/SettingsDialog/SettingsBaseStationConnectionsPage.qml deleted file mode 100644 index 919e9a8..0000000 --- a/resources/qml/SettingsDialog/SettingsBaseStationConnectionsPage.qml +++ /dev/null @@ -1,30 +0,0 @@ -import QtQuick 2.9 -import QtMultimedia 5.8 -import QtQuick.Window 2.2 -import QtQuick.Controls 2.2 -import QtQuick.Layouts 1.3 -import QtGraphicalEffects 1.0 -import QtQuick.Controls.Styles 1.4 -import "../components" - -ListView { - id: control - - property string title: qsTr("connections") - property var parentObj - - spacing: parentObj.rowSpacing - boundsBehavior: Flickable.StopAtBounds - - model: speedBackend.baseStationConnections.length - delegate: ConnectionDelegate { - - opacity: 1 - - width: parent.width - height: parentObj.delegateHeight - - text: speedBackend.baseStationConnections[index]["name"] - status: {'status': speedBackend.baseStationConnections[index]["state"], 'progress': speedBackend.baseStationConnections[index]["progress"]} - } -} diff --git a/resources/qml/SettingsDialog/SettingsBaseStationPage.qml b/resources/qml/SettingsDialog/SettingsBaseStationPage.qml index f29d474..85912d1 100644 --- a/resources/qml/SettingsDialog/SettingsBaseStationPage.qml +++ b/resources/qml/SettingsDialog/SettingsBaseStationPage.qml @@ -1,4 +1,4 @@ -import QtQuick 2.9 +import QtQuick 2.12 import QtMultimedia 5.8 import QtQuick.Window 2.2 import QtQuick.Controls 2.12 @@ -6,6 +6,13 @@ import QtQuick.Layouts 1.3 import QtGraphicalEffects 1.0 import QtQuick.Controls.Styles 1.4 import QtQuick.Templates 2.12 as T + + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 + import "../components" Column { @@ -13,105 +20,108 @@ Column { property string title: qsTr("base station") - property bool baseConnected: speedBackend.baseStationState === "connected" + property bool baseConnected: speedBackend.scStwClient.state === ScStwClient.CONNECTED property var parentObj opacity: 0 - function doFirmwareUpdate() { - doFirmwareUpdateTimer.start() - } - - Timer { - id: doFirmwareUpdateTimer - - interval: 10 - repeat: false - running: false - - onTriggered: { - busyDl.open() - var ret = speedBackend.updateBasestationFirmware() - busyDl.displayMessageAndClose(ret ? "OK":"error", ret ? "#6bd43b":"#e03b2f" ) - } - } - ConnectionDelegate { id: connectToBaseDel + + function clientStateToString(state) { + switch(state) { + case ScStwClient.DISCONNECTED: + return "disconnected" + case ScStwClient.CONNECTING: + return "connecting" + case ScStwClient.INITIALISING: + return "connecting" + case ScStwClient.CONNECTED: + return "connected" + } + } + text: status.status === "connected" ? qsTr("disconnect"): status.status === "disconnected" ? qsTr("connect"):qsTr("connecting...") - status: { "status": speedBackend.baseStationState, "progress": 100 } - connect: speedBackend.connectBaseStation - disconnect: speedBackend.disconnectBaseStation + status: { "status": clientStateToString(speedBackend.scStwClient.state), "progress": 100 } + connect: speedBackend.scStwClient.connectToHost + disconnect: speedBackend.scStwClient.closeConnection type: "baseStation" width: parent.width height: parentObj.delegateHeight } - Loader { + Item { + width: parent.width + height: parent.height * 0.05 + + Rectangle { + anchors { + top: parent.top + left: parent.left + right: parent.right + } + + height: 2 + color: appTheme.theme.colors.line + } + } + + StackView { id: baseStationOptionsLd - property alias parentComp: control - property alias baseConnected: control.baseConnected + width: parent.width + height: parent.height - onBaseConnectedChanged: { - disappearAnim.start() + property alias parentComp: control + property Component sourceComponent: control.baseConnected ? baseStationConnectedOptionsComp : baseStationDisconnectedOptionsComp + + onSourceComponentChanged: { + baseStationOptionsLd.replace(sourceComponent) } Component.onCompleted: { - baseStationOptionsLd.sourceComponent = control.baseConnected ? baseStationConnectedOptionsComp : baseStationDisconnectedOptionsComp - item.opacity = 1 - item.scale = 1 + baseStationOptionsLd.replace(sourceComponent) } - sourceComponent: null + replaceExit: Transition { + ParallelAnimation { + id: disappearAnim - ParallelAnimation { - id: disappearAnim + NumberAnimation { + property: "opacity" + to: 0 + duration: 100 + } - NumberAnimation { - property: "opacity" - to: 0 - duration: 100 - target: baseStationOptionsLd.item - } - - NumberAnimation { - property: "scale" - to: 0.95 - duration: 100 - target: baseStationOptionsLd.item - } - - onRunningChanged: { - if(!running) { - baseStationOptionsLd.sourceComponent = control.baseConnected ? baseStationConnectedOptionsComp : baseStationDisconnectedOptionsComp - appearAnim.start() + NumberAnimation { + property: "scale" + to: 0.95 + duration: 100 } } } - ParallelAnimation { - id: appearAnim + replaceEnter: Transition { + ParallelAnimation { + id: appearAnim - NumberAnimation { - property: "opacity" - from: 0 - to: 1 - duration: 100 - target: baseStationOptionsLd.item - } + NumberAnimation { + property: "opacity" + from: 0 + to: 1 + duration: 100 + } - NumberAnimation { - property: "scale" - from: 0.95 - to: 1 - duration: 100 - target: baseStationOptionsLd.item + NumberAnimation { + property: "scale" + from: 0.95 + to: 1 + duration: 100 + } } } - } Component { @@ -120,8 +130,6 @@ Column { Column { id: baseStationDisconnectedOptions - width: parentComp.width - opacity: 0 // opacity and scale are adjusted by baseStationOptionsLd scale: 0.95 @@ -131,12 +139,11 @@ Column { text: qsTr("IP") inputHint: "IP" - inputText: speedBackend.readSetting("baseStationIpAdress") + inputText: scStwAppSettings.readSetting(ScStwAppSettings.BaseStationIpSetting) inputTextFieldWidth: width * 0.7 onInputTextChanged: { - speedBackend.writeSetting("baseStationIpAdress", inputText) - speedBackend.reloadBaseStationIpAdress() + scStwAppSettings.writeSetting(ScStwAppSettings.BaseStationIpSetting, inputText) } width: parent.width @@ -172,258 +179,77 @@ Column { Component { id: baseStationConnectedOptionsComp - ScrollView{ - id: flickable - contentHeight: baseStationConnectedOptions.childrenRect.height - contentWidth: -1 + Column { + id: baseStationConnectedOptions + width: parentComp.width - height: control.height - baseStationOptionsLd.y - - clip: true - - opacity: 0 // opacity and scale are adjusted by baseStationOptionsLd - scale: 0.95 - - ScrollBar.horizontal.policy: ScrollBar.AlwaysOff - ScrollBar.vertical: ScrollBar { - parent: flickable.parent - anchors.top: flickable.top - anchors.left: flickable.right - anchors.bottom: flickable.bottom - policy: ScrollBar.AlwaysOn - interactive: false - } - - Column { - id: baseStationConnectedOptions - - width: parentComp.width - - SmoothSliderDelegate { - id: baseStationVolumeDel - text: qsTr("volume") - - width: parent.width - height: parentObj.delegateHeight - - sliderValue: 0 - - onSliderFinished: { - enabled = false - speedBackend.writeSetting("soundVolume", sliderValue) - enabled = true - } - - Component.onCompleted: { - var val = speedBackend.readSetting("soundVolume") - if(val !== "false"){ - sliderValue = parseFloat(val) - } - } - } - - NextPageDelegate { - id: baseStationConnectionsDel - text: qsTr("connected extensions") - - width: parent.width - height: parentObj.delegateHeight - - visible: height > 5 - - onClicked: { - parentObj.push(baseStationConnections) - } - } - - SmoothItemDelegate { - id: connectUsbExtensionsDel - - width: parent.width - height: parentObj.delegateHeight - - text: "pair extensions" - - onClicked: { - busyDl.open() - var ret = speedBackend.pairConnectedUsbExtensions() - busyDl.displayMessageAndClose(ret ? "OK":"error", ret ? "#6bd43b":"#e03b2f" ) - } - } - - SmoothItemDelegate { - id: baseStationUpdateDel - - // 0: hidden 1: update firmware 2: sync time - property int mode: speedBackend.baseStationProperties["firmware"]["upToDate"] ? - (Math.abs(parseInt(speedBackend.baseStationProperties["timeOffset"])) > 10000 ? 2:0) - :1 - - width: parent.width - height: mode > 0 ? parentObj.delegateHeight:0 - - visible: height > 5 - - text: mode === 2 ? qsTr("sync time"):qsTr("update firmware") - - onClicked: { - if(mode === 1) { - control.doFirmwareUpdate() - } - else if(mode === 2){ - busyDl.open() - var ret = speedBackend.updateBasestationTime() - busyDl.displayMessageAndClose(ret ? "OK":"error", ret ? "#6bd43b":"#e03b2f" ) - } - - } - } - - Rectangle { - anchors.left: parent.left - width: parent.width - height: 1 - color: appTheme.style.lineColor - } - - Item { - anchors.left: parent.left - width: parent.width - height: parentObj.delegateHeight * 0.5 - - - Label { - - anchors { - top: parent.top - left: parent.left - } - - width: parent.width * 0.5 - height: parent.height * 0.5 - - - verticalAlignment: Text.AlignTop - horizontalAlignment: Text.AlignLeft - - fontSizeMode: Text.Fit - font.pixelSize: height - - minimumPixelSize: 1 - - color: appTheme.style.lineColor - text: "version: " + speedBackend.baseStationProperties["firmware"]["version"] - } - - Label { - - property var date: new Date(new Date().getTime() + parseInt(speedBackend.baseStationProperties["timeOffset"])) - - anchors { - top: parent.top - right: parent.right - } - - width: parent.width * 0.5 - height: parent.height - - verticalAlignment: Text.AlignTop - horizontalAlignment: Text.AlignRight - - fontSizeMode: Text.Fit - - minimumPixelSize: 1 - font.pixelSize: height - - color: appTheme.style.lineColor - text: date.toLocaleDateString() + "\n" + date.toLocaleTimeString() - } - } - - } - - } - - - } - - Popup { - id: busyDl - - property string message: "" - property color messageColor: "transparent" - - x: Math.round((parent.width - width) / 2) - y: Math.round((parent.height - height) / 2) - - width: app.width - height: app.height - - modal: true - dim: true - - closePolicy: Dialog.NoAutoClose - - function displayMessageAndClose(message, messageColor) { - busyDl.message = message - busyDl.messageColor = messageColor - - closeDelayTimer.start() - } - - Timer { - id: closeDelayTimer - - interval: 1000 - repeat: false - running: false - - onTriggered: { - busyDl.close() - busyDl.message = "" - busyDl.messageColor = "transparent" - } - } - - background: Item { - FancyBusyIndicator { - anchors.centerIn: parent - opacity: busyDl.message === "" ? 1:0 - - lineColor: "white" - - Behavior on opacity { NumberAnimation { duration: 150 } } - } Label { - anchors.centerIn: parent + id: headerLabel - width: parent.width * 0.5 - height: parent.height * 0.5 + width: parent.width + height: parentObj.delegateHeight - opacity: busyDl.message === "" ? 0:1 - - color: busyDl.messageColor - text: busyDl.message - - fontSizeMode: Text.Fit - font.pixelSize: height - minimumPixelSize: 1 - - font.bold: true + visible: true verticalAlignment: Text.AlignVCenter horizontalAlignment: Text.AlignHCenter - Behavior on opacity { NumberAnimation { duration: 150 } } - } - } + fontSizeMode: Text.Fit + font.pixelSize: height - T.Overlay.modal: Rectangle { - id: modalRect - color: "#80404040" - Behavior on opacity { NumberAnimation { duration: 150 } } + minimumPixelSize: 1 + + color: appTheme.theme.colors.text + + text: "ScStwBaseStation" + } + + Label { + id: firmwareVersionLabel + + width: parent.width + height: parentObj.delegateHeight * 0.3 + + + verticalAlignment: Text.AlignTop + horizontalAlignment: Text.AlignHCenter + + fontSizeMode: Text.Fit + font.pixelSize: height + + minimumPixelSize: 1 + + color: appTheme.theme.colors.line + + text: "Firmware: " + speedBackend.scStwClient.getFirmwareVersion() + " API: " + speedBackend.scStwClient.getApiVersion() + } + + NextPageDelegate { + text: qsTr("settings") + + width: parent.width + height: parentObj.delegateHeight * 0.8 + + font.pixelSize: height * 0.5 + + onClicked: { + parentObj.push(baseStationSettings) + } + } + + NextPageDelegate { + text: qsTr("extensions") + + width: parent.width + height: parentObj.delegateHeight * 0.8 + + font.pixelSize: height * 0.5 + + onClicked: { + parentObj.push(extensions) + } + } } } } - diff --git a/resources/qml/SettingsDialog/SettingsBaseStationSettingsPage.qml b/resources/qml/SettingsDialog/SettingsBaseStationSettingsPage.qml new file mode 100644 index 0000000..6d72167 --- /dev/null +++ b/resources/qml/SettingsDialog/SettingsBaseStationSettingsPage.qml @@ -0,0 +1,62 @@ +import QtQuick 2.12 +import QtMultimedia 5.8 +import QtQuick.Window 2.2 +import QtQuick.Controls 2.12 +import QtQuick.Layouts 1.3 +import QtGraphicalEffects 1.0 +import QtQuick.Controls.Styles 1.4 + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 + +import "../components" + + +Column { + id: baseStationSettings + + property var parentObj + property string title: "Bs settings" + + width: parentObj.width + + SmoothSliderDelegate { + id: baseStationVolumeDel + + property ScStwSetting setting: scStwAppSettings.getSetting(ScStwSettings.SoundVolumeSetting, ScStwSettings.KeyLevel) + + text: qsTr("volume") + + width: parent.width + height: parentObj.delegateHeight + + font.pixelSize: height * 0.5 + + sliderValue: setting.readonlyValue + + onSliderFinished: { + enabled = false + setting.value = sliderValue + enabled = true + } + } + + SmoothSwitchDelegate { + property ScStwSetting setting: scStwAppSettings.getSetting(ScStwSettings.CompetitionModeSetting, ScStwSettings.KeyLevel) + + width: parent.width + height: parentObj.delegateHeight + + checked: setting.readonlyValue + + onClicked: { + enabled = false + setting.value = checked + enabled = true + } + + text: qsTr("competition mode") + } +} diff --git a/resources/qml/SettingsDialog/SettingsDialog.qml b/resources/qml/SettingsDialog/SettingsDialog.qml index fdd4419..0c17892 100644 --- a/resources/qml/SettingsDialog/SettingsDialog.qml +++ b/resources/qml/SettingsDialog/SettingsDialog.qml @@ -42,8 +42,8 @@ Popup { background: Rectangle { radius: width * 0.5 - color: appTheme.style.viewColor - border.color: appTheme.style.lineColor + color: appTheme.theme.colors.view + border.color: appTheme.theme.colors.line border.width: 0 Behavior on color { @@ -76,7 +76,7 @@ Popup { height: header.height width: header.width - property color color: appTheme.style.viewColor + property color color: appTheme.theme.colors.view Behavior on color { ColorAnimation { @@ -130,7 +130,7 @@ Popup { text: options_stack.currentItem.title font.pixelSize: headlineUnderline.width * 0.1 - color: enabled ? appTheme.style.textColor:appTheme.style.disabledTextColor + color: enabled ? appTheme.theme.colors.text:appTheme.theme.colors.disabledText } } @@ -138,7 +138,7 @@ Popup { id: headlineUnderline height: 1 width: parent.width - color: appTheme.style.lineColor + color: appTheme.theme.colors.line visible: false anchors { top: parent.top @@ -166,7 +166,7 @@ Popup { glowOpacity: Math.pow( root.opacity, 100 ) - image: appTheme.style.backIcon + image: appTheme.theme.images.backIcon onClicked: { options_stack.depth > 1 ? options_stack.pop():root.close() diff --git a/resources/qml/SettingsDialog/SettingsStack.qml b/resources/qml/SettingsDialog/SettingsStack.qml index 0941b94..b68aebd 100644 --- a/resources/qml/SettingsDialog/SettingsStack.qml +++ b/resources/qml/SettingsDialog/SettingsStack.qml @@ -47,14 +47,22 @@ StackView { } - /*-----Page to view devices that core connected to the pase startion-----*/ - Component{ - id: baseStationConnections + Component { + id: extensions - SettingsBaseStationConnectionsPage { + ExtensionOverview { + property string title: qsTr("extensions") + delegateHeight: control.delegateHeight + backgroundColor: appTheme.theme.colors.view + } + } + + Component { + id: baseStationSettings + + SettingsBaseStationSettingsPage { parentObj: control } - } /*-----Custom animations-----*/ diff --git a/resources/qml/SettingsDialog/SettingsStartSequencePage.qml b/resources/qml/SettingsDialog/SettingsStartSequencePage.qml index 8322d7e..f6da2b6 100644 --- a/resources/qml/SettingsDialog/SettingsStartSequencePage.qml +++ b/resources/qml/SettingsDialog/SettingsStartSequencePage.qml @@ -5,6 +5,12 @@ import QtQuick.Controls 2.2 import QtQuick.Layouts 1.3 import QtGraphicalEffects 1.0 import QtQuick.Controls.Styles 1.4 + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 + import "../components" Column { @@ -17,37 +23,38 @@ Column { function updateSetting(key, val, del){ del.busy = true - speedBackend.writeSetting(key, val) + scStwAppSettings.writeSetting(key, val, ScStwSettings.KeyLevel) del.busy = false } function loadSetting(key, del){ - return speedBackend.readSetting(key) + return scStwAppSettings.readSetting(key, ScStwSettings.KeyLevel) } SmoothSwitchDelegate { id: ready_del - property bool busy: false + property ScStwSetting setting: scStwAppSettings.getSetting(ScStwSettings.ReadySoundEnableSetting, ScStwSettings.KeyLevel) width: parent.width height: parentObj.delegateHeight - enabled: !busy - - text: qsTr("say 'ready'") - - checked: parent.loadSetting("ready_en", ready_del) === "true" + checked: setting.value onCheckedChanged: { - parent.updateSetting("ready_en", checked, ready_del) + enabled = false + setting.value = checked + enabled = true } + + text: qsTr("say 'ready'") } InputDelegate { id: ready_delay_del property bool busy: false + property ScStwSetting setting: scStwAppSettings.getSetting(ScStwSettings.ReadySoundDelaySetting, ScStwSettings.KeyLevel) width: parent.width height: parentObj.delegateHeight @@ -58,29 +65,32 @@ Column { inputHint: qsTr("time") inputMethodHints: Qt.ImhFormattedNumbersOnly - inputText: control.loadSetting("ready_delay", ready_delay_del) + inputText: setting.value onInputFinished: { - control.updateSetting("ready_delay", inputText, ready_delay_del) + console.log("input finished") + busy = true + setting.value = inputText + busy = false } } SmoothSwitchDelegate { id: at_marks_del - property bool busy: false + property ScStwSetting setting: scStwAppSettings.getSetting(ScStwSettings.AtYourMarksSoundEnableSetting, ScStwSettings.KeyLevel) width: parent.width height: parentObj.delegateHeight - enabled: !busy - text: qsTr("say 'at your marks'") - checked: control.loadSetting("at_marks_en", ready_del) === "true" + checked: setting.value onCheckedChanged: { - parent.updateSetting("at_marks_en",at_marks_del.checked, at_marks_del) + enabled = false + setting.value = checked + enabled = true } } @@ -88,6 +98,7 @@ Column { id: at_marks_delay_del property bool busy: false + property ScStwSetting setting: scStwAppSettings.getSetting(ScStwSettings.AtYourMarksSoundDelaySetting, ScStwSettings.KeyLevel) width: parent.width height: parentObj.delegateHeight @@ -96,12 +107,14 @@ Column { inputHint: qsTr("time") inputMethodHints: Qt.ImhFormattedNumbersOnly - enabled: !busy && at_marks_del.checked + enabled: !busy && at_marks_del.checked - inputText: control.loadSetting("at_marks_delay", at_marks_delay_del) + inputText: setting.value onInputFinished: { - control.updateSetting("at_marks_delay", inputText, at_marks_delay_del) + busy = true + setting.setValue(inputText) + busy = false } } } diff --git a/resources/qml/SettingsDialog/StartPage.qml b/resources/qml/SettingsDialog/StartPage.qml index 8208e72..b5a3808 100644 --- a/resources/qml/SettingsDialog/StartPage.qml +++ b/resources/qml/SettingsDialog/StartPage.qml @@ -5,6 +5,12 @@ import QtQuick.Controls 2.2 import QtQuick.Layouts 1.3 import QtGraphicalEffects 1.0 import QtQuick.Controls.Styles 1.4 + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 + import "../components" Column { @@ -49,11 +55,10 @@ Column { width: parent.width height: parentObj.delegateHeight - checked: speedBackend.readSetting("theme") === "Dark" + checked: appTheme.setting.value === "Dark" onCheckedChanged: { - speedBackend.writeSetting("theme", checked ? "Dark":"Light") - appTheme.refreshTheme() + appTheme.setting.setValue(checked ? "Dark":"Light") } } } diff --git a/resources/qml/components/BatteryIndicator.qml b/resources/qml/components/BatteryIndicator.qml new file mode 100644 index 0000000..2814e2e --- /dev/null +++ b/resources/qml/components/BatteryIndicator.qml @@ -0,0 +1,250 @@ +import QtQuick 2.0 + +Rectangle { + id: control + + property color chargingColor: "green" + property color fineColor: "green" + property color warningColor: "orange" + property color criticalColor: "red" + property color unknownColor: "grey" + property color notChargingColor: "red" + property color backgroundColor: "white" + property double indicatorSize: 1 + + height: app.height * 0.9 + width: height * 0.8 + + color: backgroundColor + + border.width: Math.min(width * 0.1, height * 0.1) * control.indicatorSize + border.color: "green" + radius: border.width + + state: "charging" + + Rectangle { + id: outerRect + + anchors { + right: parent.left + rightMargin: parent.border.width * 0.25 + verticalCenter: parent.verticalCenter + } + + width: parent.border.width + height: parent.height * 0.5 + radius: width * 0.5 + + color: parent.border.color + } + + Rectangle { + id: innerRect + + property double amountFilled: 1 + + anchors { + top: parent.top + bottom: parent.bottom + right: parent.right + + margins: parent.border.width * 1.5 + } + + width: (parent.width - parent.border.width * 3) * amountFilled + + radius: control.radius * 0.5 + + border.width: 0 + + color: control.border.color + + Rectangle { + id: chargingRect + + property double amountFilled: 0 + + anchors { + top: parent.top + bottom: parent.bottom + right: parent.right + } + + width: parent.width * amountFilled + + radius: innerRect.radius + + color: Qt.darker(innerRect.color, 1.5) + } + } + + Text { + id: questionMarkText + visible: false + anchors.centerIn: parent + + height: parent.height * 0.7 + width: parent.width * 0.7 + + color: outerRect.color + + verticalAlignment: Text.AlignVCenter + horizontalAlignment: Text.AlignHCenter + + font.bold: true + font.pixelSize: height + + text: "?" + + } + + ParallelAnimation { + id: chargingAnimation + + running: false + + loops: Animation.Infinite + alwaysRunToEnd: true + + NumberAnimation { + target: chargingRect + + properties: "amountFilled" + + from: 0 + to: 1 + + duration: 3000 + + easing.type: Easing.OutQuad + } + + NumberAnimation { + target: chargingRect + + properties: "opacity" + + from: 1 + to: 0 + + duration: 3000 + + easing.type: Easing.Linear + } + } + + states: [ + State { + name: "charging" + PropertyChanges { + target: control + border.color: control.chargingColor + } + + PropertyChanges { + target: innerRect + amountFilled: 1 + } + + PropertyChanges { + target: chargingAnimation + running: true + } + }, + + State { + name: "notCharging" + PropertyChanges { + target: control + border.color: control.notChargingColor + } + + PropertyChanges { + target: innerRect + amountFilled: 0 + } + + PropertyChanges { + target: questionMarkText + visible: true + } + }, + + State { + name: "fine" + PropertyChanges { + target: control + border.color: control.fineColor + } + + PropertyChanges { + target: innerRect + amountFilled: 1 + } + }, + + State { + name: "warning" + PropertyChanges { + target: control + border.color: control.warningColor + } + + PropertyChanges { + target: innerRect + amountFilled: 0.3 + } + }, + + State { + name: "critical" + PropertyChanges { + target: control + border.color: control.criticalColor + } + + PropertyChanges { + target: innerRect + amountFilled: 0.1 + } + }, + + State { + name: "unknown" + PropertyChanges { + target: control + border.color: control.unknownColor + } + + PropertyChanges { + target: innerRect + amountFilled: 0 + } + + PropertyChanges { + target: questionMarkText + visible: true + } + } + + ] + + transitions: [ + Transition { + NumberAnimation { + properties: "amountFilled" + duration: 400 + easing.type: Easing.InOutQuad + } + + + ColorAnimation { + properties: "color,border.color" + duration: 400 + easing.type: Easing.InOutQuad + } + } + ] + +} diff --git a/resources/qml/components/ConnectionDelegate.qml b/resources/qml/components/ConnectionDelegate.qml index 90f9021..3edeb8d 100644 --- a/resources/qml/components/ConnectionDelegate.qml +++ b/resources/qml/components/ConnectionDelegate.qml @@ -6,27 +6,31 @@ SmoothItemDelegate { property var status property string oldState: "" - property var connect + property var connect: null property var disconnect + property string batteryState: "unknown" property string type + text: qsTr(type) enabled: (status.status === "disconnected" && control.connect !== undefined) || ( status.status === "connected" && control.disconnect !== undefined ) onClicked: { - if(status.status === "disconnected"){ + if(connect == null) + return; + + if(status.status === "disconnected") connect() - } - else { + else disconnect() - } + } onStatusChanged: { if(oldState !== status.status) { if(status.status === "disconnected" && oldState === "connecting") { - statusIndicator.color_override = appTheme.style.errorColor + statusIndicator.color_override = "error" shortDelay.start() } oldState = status.status @@ -43,57 +47,59 @@ SmoothItemDelegate { } } - Item { - id: statusItem + Row { anchors { right: parent.right rightMargin: ( height / control.height / 2 ) * height verticalCenter: parent.verticalCenter } - height: control.height * 0.4 - width: height - Rectangle { + spacing: height * 0.4 + + BatteryIndicator { + id: batteryIndicator + + height: control.height * 0.4 + width: height + + opacity: control.batteryState === "unknown" ? 0:1 + + backgroundColor: "transparent" + chargingColor: fineColor + fineColor: appTheme.theme.colors.success + warningColor: appTheme.theme.colors.warning + criticalColor: appTheme.theme.colors.error + notChargingColor: warningColor + + state: control.batteryState + + indicatorSize: 0.8 + + Behavior on opacity { + NumberAnimation { + duration: 200 + } + } + } + + StateIndicator { id: statusIndicator property string color_override: "" - anchors.fill: parent - color: color_override === "" ? status.status === "connected" ? appTheme.style.successColor:"transparent":color_override - opacity: status.status === "connecting" ? 0:1 - radius: height * 0.5 - border.color: appTheme.style.lineColor - border.width: 1 - Behavior on color { - ColorAnimation { - duration: 200 - } - } + height: control.height * 0.4 + width: height - Behavior on opacity { - NumberAnimation { - duration: 800 + state: color_override === "" ? status.status === "connected" ? "success": status.status === "connecting" ? "working":"unknown":color_override - } - } - } + indicatorSize: 0.8 - ProgressCircle { - id: prog - anchors.fill: parent - opacity: status.status === "connecting" ? 1:0 - lineWidth: 1 + radius: border.width * 2 - arcBegin: 0 - arcEnd: 360 * ( status.progress / 100 ) - colorCircle: appTheme.style.lineColor - onColorCircleChanged: prog.repaint() - onArcEndChanged: prog.repaint() - - Behavior on opacity { - NumberAnimation { - duration: 200 - } - } + backgroundColor: appTheme.theme.colors.background + successColor: appTheme.theme.colors.success + errorColor: appTheme.theme.colors.error } } + + } diff --git a/resources/qml/components/ExtensionOverview.qml b/resources/qml/components/ExtensionOverview.qml new file mode 100644 index 0000000..c1f272a --- /dev/null +++ b/resources/qml/components/ExtensionOverview.qml @@ -0,0 +1,110 @@ +import QtQuick 2.9 +import QtMultimedia 5.8 +import QtQuick.Window 2.2 +import QtQuick.Controls 2.2 +import QtQuick.Layouts 1.3 +import QtGraphicalEffects 1.0 +import QtQuick.Controls.Styles 1.4 +import "../components" + +ListView { + id: control + + property int delegateHeight: 40 + property color backgroundColor: "transparent" + + spacing: control.delegateHeight * 0.3 + boundsBehavior: Flickable.StopAtBounds + + clip: true + + model: Object.keys(speedBackend.scStwClient.extensions) + + header: Rectangle { + // for top spacing + width: parent.width + height: control.spacing + color: control.backgroundColor + } + + delegate: Rectangle { + id: laneContainerRect + + property string thisLane: modelData + + anchors.horizontalCenter: parent.horizontalCenter + + width: parent.width * 0.98 + height: control.delegateHeight * extensionsList.model + + radius: width * 0.05 + + border.width: 1 + border.color: appTheme.theme.colors.line + + color: control.backgroundColor + + Rectangle { + id: laneLabelRect + + anchors { + left: parent.left + leftMargin: parent.radius * 1 + verticalCenter: parent.top + } + + height: control.delegateHeight * 0.5 + width: laneLabel.font.pixelSize * 4 + + color: control.backgroundColor + + Label { + id: laneLabel + + height: parent.height + width: parent.width + + leftPadding: laneContainerRect.width * 0.02 + rightPadding: laneContainerRect.width * 0.02 + + horizontalAlignment: Text.AlignHCenter + verticalAlignment: Text.AlignVCenter + + fontSizeMode: Text.Fit + font.pixelSize: height * 0.5 + + color: appTheme.theme.colors.text + + text: "Lane " + laneContainerRect.thisLane + } + + } + + ListView { + id: extensionsList + + anchors.fill: parent + anchors.margins: width * 0.04 + + interactive: false + + model: speedBackend.scStwClient.extensions[parent.thisLane].length + + delegate: ConnectionDelegate { + property var thisExtension: speedBackend.scStwClient.extensions[laneContainerRect.thisLane][index] + property var stateTranslations: ["disconnected", "connecting", "connecting", "connected"] + property var batteryStateStrings: ["critical", "warning", "fine", "charging", "notCharging"] + color: control.backgroundColor + + batteryState: thisExtension["batteryState"] === -1 ? "unknown":batteryStateStrings[thisExtension["batteryState"]] + + height: extensionsList.height / extensionsList.model + + enabled: true + + text: thisExtension["type"] === 0 ? "StartPad":"TopPad" // TODO: make dynamic with ScStw::extensionTypeToString() + status: {'status': stateTranslations[thisExtension["state"]]} + } + } + } +} diff --git a/resources/qml/components/FadeAnimation.qml b/resources/qml/components/FadeAnimation.qml deleted file mode 100644 index 40343b7..0000000 --- a/resources/qml/components/FadeAnimation.qml +++ /dev/null @@ -1,70 +0,0 @@ -/* - Speed Climbing Stopwatch - Simple Stopwatch for Climbers - Copyright (C) 2018 Itsblue Development - Dorian Zeder - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published - by the Free Software Foundation, version 3 of the License. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see . -*/ - -import QtQuick 2.0 - -SequentialAnimation { - id: root - property QtObject target - property string fadeProperty: "scale" - property int fadeDuration: 150 - property int fadeDuration_in: fadeDuration - property int fadeDuration_out: fadeDuration - property alias outValue: outAnimation.to - property alias inValue: inAnimation.to - property alias outEasingType: outAnimation.easing.type - property alias inEasingType: inAnimation.easing.type - property string easingType: "Quad" - ParallelAnimation { - NumberAnimation { // in the default case, fade scale to 0 - id: outAnimation - target: root.target - property: "scale" - duration: root.fadeDuration_in - to: 0.9 - easing.type: Easing["In"+root.easingType] - } - NumberAnimation { // in the default case, fade scale to 0 - id: outAnimation2 - target: root.target - property: "opacity" - duration: root.fadeDuration_in - to: 0 - easing.type: Easing["In"+root.easingType] - } - } - PropertyAction { } // actually change the property targeted by the Behavior between the 2 other animations - ParallelAnimation { - NumberAnimation { // in the default case, fade scale back to 1 - id: inAnimation - target: root.target - property: root.fadeProperty - duration: root.fadeDuration_out - to: 1 - easing.type: Easing["Out"+root.easingType] - } - NumberAnimation { // in the default case, fade scale to 0 - id: inAnimation2 - target: root.target - property: "opacity" - duration: root.fadeDuration_in - to: 1 - easing.type: Easing["In"+root.easingType] - } - } - -} diff --git a/resources/qml/components/FancyBusyIndicator.qml b/resources/qml/components/FancyBusyIndicator.qml deleted file mode 100644 index ba6631f..0000000 --- a/resources/qml/components/FancyBusyIndicator.qml +++ /dev/null @@ -1,65 +0,0 @@ -import QtQuick 2.3 -import QtQuick.Controls 2.4 -import QtQuick.Controls.Styles 1.2 - -BusyIndicator { - id: control - - property double animationSpeed: 1000 - property double formFactor: 4.5 - - property color lineColor: "#21be2b" - - contentItem: Item { - implicitWidth: 64 - implicitHeight: 64 - - Item { - id: item - - anchors.fill: parent - - property int currentHeight: 0 - - SequentialAnimation { - running: control.running - loops: Animation.Infinite - - NumberAnimation { - target: item - property: "currentHeight" - from: 0 - to: 800 - duration: control.animationSpeed - } - } - - Row { - - anchors.fill: parent - - spacing: item.width / 9 - - Repeater { - id: repeater - model: 5 - - Rectangle { - - property double heightMultiplier: Math.abs( Math.sin( ( ((item.currentHeight/100) + (index*(control.formFactor/repeater.model)))) * (Math.PI/8) ) ) - - anchors.verticalCenter: parent.verticalCenter - - width: item.width / 9 - height: ( heightMultiplier ) * ( item.height - 1 ) + 1 - - radius: width * 0.5 - - color: control.lineColor - - } - } - } - } - } -} diff --git a/resources/qml/components/FancyButton.qml b/resources/qml/components/FancyButton.qml index 28dd8a3..b24d6da 100644 --- a/resources/qml/components/FancyButton.qml +++ b/resources/qml/components/FancyButton.qml @@ -1,12 +1,15 @@ import QtQuick 2.9 -import QtQuick.Controls 2.4 +import QtQuick.Controls 2.2 import QtGraphicalEffects 1.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 + Button { id: control property string image - property color backgroundColor: appTheme.style.buttonColor + property color backgroundColor: appTheme.theme.colors.button property real imageScale: 1 property double glowRadius: 0.001 property double glowSpread: 0.2 @@ -14,16 +17,16 @@ Button { property double glowScale: 0.75 property double glowOpacity: Math.pow( control.opacity, 100 ) - - - //scale: control.pressed ? 0.8:1 - - Behavior on scale { - PropertyAnimation { - duration: 100 + Behavior on text { + //animate a text change + enabled: true + FadeAnimation { + target: text } } + contentItem: Item {} + background: Item { id: controlBackgroundContainer @@ -56,6 +59,26 @@ Button { } } + Text { + id: text + + anchors.centerIn: parent + anchors.verticalCenterOffset: -height * 0.05 + height: parent.height * 0.6 + width: parent.width * 0.6 + + fontSizeMode: Text.Fit + font.pixelSize: Math.max(parent.height * 0.16, parent.width * 0.16) + font.family: "Helvetica" + + verticalAlignment: Text.AlignVCenter + horizontalAlignment: Text.AlignHCenter + + text: control.text + + color: enabled ? appTheme.theme.colors.text:appTheme.theme.colors.disabledText + } + Image { id: buttonIcon source: control.image diff --git a/resources/qml/components/InputDelegate.qml b/resources/qml/components/InputDelegate.qml index 306321b..c11231e 100644 --- a/resources/qml/components/InputDelegate.qml +++ b/resources/qml/components/InputDelegate.qml @@ -1,5 +1,5 @@ import QtQuick 2.0 -import QtQuick.Controls 2.3 +import QtQuick.Controls 2.2 SmoothItemDelegate { id: control @@ -37,7 +37,7 @@ SmoothItemDelegate { inputMethodHints: control.inputMethodHints - palette.text: appTheme.style.textColor + palette.text: appTheme.theme.colors.text onTextChanged: { control.inputText = text diff --git a/resources/qml/components/MainActionButton.qml b/resources/qml/components/MainActionButton.qml new file mode 100644 index 0000000..b82a21a --- /dev/null +++ b/resources/qml/components/MainActionButton.qml @@ -0,0 +1,129 @@ +import QtQuick 2.0 +import QtQuick.Controls 2.9 +import QtGraphicalEffects 1.0 + +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 + +DelayButton { + id : control + + text: "start" + property color backgroundColor: appTheme.theme.colors.button + property bool progressControlActivated: false + property double startProgress + property double oldStartProgress: -1 + + delay: progressControlActivated ? 2000:0 + + onStartProgressChanged: { + if(startProgress > oldStartProgress) + oldStartProgress = startProgress + else { + startProgressAnimation.from = oldStartProgress + startProgressAnimation.to = startProgress + startProgressAnimation.start() + } + } + + Text { + id: labelText + text: control.text + anchors.centerIn: parent + font.pixelSize: parent.height * 0.16 + font.family: "Helvetica" + color: enabled ? appTheme.theme.colors.text:appTheme.theme.colors.disabledText + } + + NumberAnimation { + id: startProgressAnimation + + to: 0 + target: control + properties: "oldStartProgress" + duration: 200 + } + + Behavior on text { + //animate a text change + enabled: true + FadeAnimation { + target: labelText + } + } + + contentItem: Text { + } + + background: Item { + RectangularGlow { + glowRadius: 0.001 + spread: 0.2 + color: "black" + + visible: true + + cornerRadius: background.radius + anchors.fill: background + scale: 0.75 + opacity: Math.pow( control.opacity, 100 ) + } + + Rectangle { + id: background + implicitWidth: 100 + implicitHeight: 100 + color: control.down ? Qt.darker(control.backgroundColor, 1.2) : control.backgroundColor + radius: size / 2 + + readonly property real size: Math.min(control.width, control.height) + width: size + height: size + anchors.fill: parent + + Behavior on color { + ColorAnimation { + duration: 200 + } + } + + Canvas { + id: canvas + anchors.fill: parent + + Connections { + target: control + function onProgressChanged() { + canvas.requestPaint() + } + + function onOldStartProgressChanged() { + canvas.requestPaint() + } + } + + onPaint: { + var progress + var showHoldProgress = ((control.oldStartProgress <= 0 || control.oldStartProgress === 1) && control.progressControlActivated) + + if(showHoldProgress) + progress = control.progress + else + progress = control.oldStartProgress < 0 ? 0:1-control.oldStartProgress + + + var ctx = getContext("2d") + ctx.clearRect(0, 0, width, height) + ctx.strokeStyle = showHoldProgress ? appTheme.theme.colors.error:"grey" + ctx.lineWidth = parent.width * 0.02 + ctx.beginPath() + var startAngle = Math.PI * 1.5 + var endAngle = startAngle + progress * Math.PI * 2 + ctx.arc(width / 2, height / 2, width / 2 - ctx.lineWidth / 2 - 2, startAngle, endAngle) + ctx.stroke() + } + } + } + } +} diff --git a/resources/qml/components/NextPageDelegate.qml b/resources/qml/components/NextPageDelegate.qml index 6c16109..f57734d 100644 --- a/resources/qml/components/NextPageDelegate.qml +++ b/resources/qml/components/NextPageDelegate.qml @@ -9,7 +9,7 @@ SmoothItemDelegate { Image { id: forwardImage - source: appTheme.style.backIcon + source: appTheme.theme.images.backIcon rotation: 180 height: control.height * 0.4 width: height diff --git a/resources/qml/components/RemoteDataListView.qml b/resources/qml/components/RemoteDataListView.qml index 4e825b1..6fb0a46 100644 --- a/resources/qml/components/RemoteDataListView.qml +++ b/resources/qml/components/RemoteDataListView.qml @@ -1,6 +1,8 @@ import QtQuick 2.10 import QtQuick.Controls 2.4 +import de.itsblue.ScStw.Styling.Components 1.0 + Item { id: control @@ -73,8 +75,12 @@ Item { } - FancyBusyIndicator { + BusyIndicator { anchors.centerIn: parent + + width: app.landscape() ? parent.height * 0.1:parent.width * 0.1 + height: width + opacity: !(status === 200 || status === 902) ? 1:0 Behavior on opacity { diff --git a/resources/qml/components/SmoothItemDelegate.qml b/resources/qml/components/SmoothItemDelegate.qml index 2caf73a..18ca7f5 100644 --- a/resources/qml/components/SmoothItemDelegate.qml +++ b/resources/qml/components/SmoothItemDelegate.qml @@ -4,8 +4,9 @@ import QtQuick.Controls 2.2 ItemDelegate { id: control text: "" - property color textColor: appTheme.style.textColor + property color textColor: appTheme.theme.colors.text property alias backgroundRect: backgroundRect + property color color: appTheme.theme.colors.delegateBackground font.pixelSize: height * 0.4 @@ -26,7 +27,7 @@ ItemDelegate { } text: control.text - color: appTheme.style.textColor + color: appTheme.theme.colors.text verticalAlignment: Text.AlignVCenter horizontalAlignment: Text.AlignLeft @@ -42,7 +43,7 @@ ItemDelegate { background: Rectangle { id: backgroundRect - color: control.down ? appTheme.style.delegatePressedColor : appTheme.style.delegateBackgroundColor + color: control.down ? appTheme.theme.colors.delegatePressed : appTheme.theme.colors.delegateBackground radius: height * 0.3 diff --git a/resources/qml/components/SmoothSwitchDelegate.qml b/resources/qml/components/SmoothSwitchDelegate.qml index 0942bf7..08022c7 100644 --- a/resources/qml/components/SmoothSwitchDelegate.qml +++ b/resources/qml/components/SmoothSwitchDelegate.qml @@ -1,5 +1,5 @@ import QtQuick 2.9 -import QtQuick.Controls 2.3 +import QtQuick.Controls 2.2 SwitchDelegate { id: control @@ -24,7 +24,7 @@ SwitchDelegate { } text: control.text - color: appTheme.style.textColor + color: appTheme.theme.colors.text fontSizeMode: Text.Fit @@ -60,7 +60,7 @@ SwitchDelegate { width: parent.height height: parent.height radius: height * 0.5 - color: parent.down ? appTheme.style.buttonPressedColor:appTheme.style.backgroundColor + color: parent.down ? appTheme.theme.colors.buttonPressed:appTheme.theme.colors.background border.color: parent.checked ? (parent.down ? "#17a81a" : "#21be2b") : "#999999" Behavior on x{ NumberAnimation { @@ -74,7 +74,7 @@ SwitchDelegate { background: Rectangle { opacity: enabled ? 1 : 0.3 - color: control.down ? appTheme.style.delegatePressedColor : appTheme.style.delegateBackgroundColor + color: control.down ? appTheme.theme.colors.delegatePressed : appTheme.theme.colors.delegateBackground radius: height * 0.3 diff --git a/resources/qml/components/StateIndicator.qml b/resources/qml/components/StateIndicator.qml new file mode 100644 index 0000000..e4485ee --- /dev/null +++ b/resources/qml/components/StateIndicator.qml @@ -0,0 +1,316 @@ +import QtQuick 2.0 + +Rectangle { + id: control + + property color successColor: "green" + property color warningColor: "orange" + property color errorColor: "red" + property color unknownColor: "grey" + property color backgroundColor: "white" + property color workingColor: "grey" + property double indicatorSize: 1 + + height: app.height * 0.9 + width: height * 0.8 + + color: backgroundColor + + border.width: Math.min(width * 0.1, height * 0.1) * control.indicatorSize + border.color: "green" + radius: border.width * 0.5 + + state: "success" + + clip: true + + Rectangle { + id: higherRect + + property int totalWidth: Math.abs(Math.sin(rotation * Math.PI / 180) * (height)) + property int totalHeight: Math.abs(Math.cos(rotation * Math.PI / 180) * (height)) + + radius: width * 0.5 + border.width: 0 + border.color: control.workingColor + + color: "green" + + } + + Rectangle { + id: lowerRect + + property int totalWidth: Math.abs(Math.sin(rotation * Math.PI / 180) * (height)) + property int totalHeight: Math.abs(Math.cos(rotation * Math.PI / 180) * (height)) + + radius: width * 0.5 + border.width: 0 + border.color: control.workingColor + + color: "green" + } + + ParallelAnimation { + id: workingAnimation + + property int from: lowerRect.height + property int to: Math.max(control.width * 1.1, control.height * 1.1) + + property bool shouldBeRunning: false + + running: false + + loops: Animation.Infinite + + onShouldBeRunningChanged: { + pauseAnimation.start() + } + + NumberAnimation { + target: higherRect + + properties: "height" + + from: workingAnimation.from + to: workingAnimation.to + + duration: 1000 + + easing.type: Easing.InQuad + } + + NumberAnimation { + target: higherRect + + properties: "opacity" + + from: 1 + to: 0.3 + + duration: 1000 + + easing.type: Easing.InQuad + } + } + + PauseAnimation { + id: pauseAnimation + duration: 400 + onStopped: { + workingAnimation.running = workingAnimation.shouldBeRunning + higherRect.opacity = 1 + } + } + + states: [ + State { + name: "working" + PropertyChanges { + target: control + border.color: control.workingColor + } + + PropertyChanges { + target: higherRect + + x: (parent.width - width) / 2 + y: (parent.height - height) / 2 + + width: height + height: Math.min(parent.width * 0.1, parent.height * 0.1) * control.indicatorSize + + color: "transparent" + + border.color: control.workingColor + border.width: control.border.width + } + + PropertyChanges { + target: lowerRect + + x: (parent.width - width) / 2 + y: (parent.height - height) / 2 + + width: height + height: Math.min(parent.width * 0.2, parent.height * 0.2) * control.indicatorSize + + color: control.workingColor + } + + PropertyChanges { + target: workingAnimation + + shouldBeRunning: true + } + }, + + State { + name: "unknown" + PropertyChanges { + target: control + border.color: control.unknownColor + } + + PropertyChanges { + target: higherRect + + x: (parent.width - width) / 2 + y: (parent.height - height) / 2 + + width: control.border.width + height: Math.min(parent.width * 0.7, parent.height * 0.7) * control.indicatorSize + + color: control.unknownColor + + rotation: 90 + } + + PropertyChanges { + target: lowerRect + + x: (parent.width - width) / 2 + y: (parent.height - height) / 2 + + width: control.border.width + height: Math.min(parent.width * 0.7, parent.height * 0.7) * control.indicatorSize + + color: control.unknownColor + + rotation: -90 + } + }, + + State { + id: errorState + name: "error" + + property int distance: control.height * 0.1 + + PropertyChanges { + target: control + border.color: control.errorColor + } + + PropertyChanges { + target: higherRect + + x: (parent.width - width) / 2 + y: control.border.width + parent.height * 0.15 + + width: control.border.width + height: parent.height * 0.4 * control.indicatorSize + + color: control.errorColor + } + + PropertyChanges { + target: lowerRect + + x: (parent.width - width) / 2 + y: higherRect.y + higherRect.height + errorState.distance + + width: control.border.width * 1.3 + height: width + + color: control.errorColor + } + }, + + State { + name: "warn" + PropertyChanges { + target: control + border.color: control.warningColor + } + + PropertyChanges { + target: higherRect + + x: (parent.width - width) / 2 + y: (parent.height - height) / 2 + + width: control.border.width + height: Math.min(parent.width * 0.7, parent.height * 0.7) * control.indicatorSize + + color: control.warningColor + + rotation: 45 + } + + PropertyChanges { + target: lowerRect + + x: (parent.width - width) / 2 + y: (parent.height - height) / 2 + + width: control.border.width + height: Math.min(parent.width * 0.7, parent.height * 0.7) * control.indicatorSize + + color: control.warningColor + + rotation: -45 + } + }, + + State { + id: tickState + + property int bottomX: ((control.width) / 2 - (higherRect.totalWidth - (lowerRect.totalWidth + higherRect.totalWidth) / 2 )) * 1.055 + property int bottomY: ((control.height + higherRect.totalHeight) / 2 - lowerRect.radius) * 1.05 + + name: "success" + + PropertyChanges { + target: control + border.color: control.successColor + } + + PropertyChanges { + target: higherRect + + x: tickState.bottomX - width / 2 + (Math.sin(rotation * Math.PI / 180) * (height / 2 - radius)) + y: tickState.bottomY - height / 2 - (Math.cos(rotation * Math.PI / 180) * (height / 2 - radius)) + + width: control.border.width + height: Math.min(parent.width * 0.6, parent.height * 0.6) * control.indicatorSize + + rotation: 40 + + color: control.successColor + } + + PropertyChanges { + target: lowerRect + + x: tickState.bottomX - width / 2 + (Math.sin(rotation * Math.PI / 180) * (height / 2 - radius)) + y: tickState.bottomY - height / 2 - (Math.cos(rotation * Math.PI / 180) *(height / 2 - radius)) + + width: control.border.width + height: Math.min(parent.width * 0.3, parent.height * 0.3) * control.indicatorSize + + rotation: -40 + + color: control.successColor + } + } + ] + + transitions: [ + Transition { + NumberAnimation { + properties: "height,width,rotation,x,y" + duration: 400 + easing.type: Easing.InOutQuad + } + + + ColorAnimation { + properties: "color,border.color" + duration: 400 + easing.type: Easing.InOutQuad + } + } + ] + +} diff --git a/resources/qml/components/layout/ToolBar.qml b/resources/qml/components/layout/ToolBar.qml new file mode 100644 index 0000000..95471bf --- /dev/null +++ b/resources/qml/components/layout/ToolBar.qml @@ -0,0 +1,48 @@ +import QtQuick 2.0 +import QtQuick.Controls 2.0 +import QtGraphicalEffects 1.0 +import QtQuick.Layouts 1.0 + +Rectangle { + id: control + + property double size: sizes[sizeMode] + property string sizeMode: "small" + property var sizes: { + "tiny": 0, + "small": 0.15, + "medium": 0.25, + "large": 0.8 + } + + Layout.preferredHeight: app.landscape() ? app.height : app.height * size + Layout.preferredWidth: app.landscape() ? app.width * size : app.width + + Behavior on size { + NumberAnimation { + duration: 700 + easing.type: Easing.InOutQuad + } + } + + RectangularGlow { + glowRadius: 7 + spread: 0.02 + color: "black" + opacity: 0.18 + anchors.fill: headerBackgroundRectangle + scale: 1 + } + + Rectangle { + id: headerBackgroundRectangle + anchors.fill: parent + color: appTheme.theme.colors.menu + + Behavior on color { + ColorAnimation { + duration: 200 + } + } + } +} diff --git a/resources/qml/main.qml b/resources/qml/main.qml index 687abc8..08b3b72 100644 --- a/resources/qml/main.qml +++ b/resources/qml/main.qml @@ -17,36 +17,40 @@ import QtQuick 2.9 import QtMultimedia 5.8 -import QtQuick.Window 2.2 -import QtQuick.Controls 2.2 +import QtQuick.Controls 2.12 import QtGraphicalEffects 1.0 +import QtQuick.Layouts 1.0 + import "." import "./components" import "./ProfilesDialog" import "./SettingsDialog" +import "./components/layout" +import "./MainPage" //import QtQuick.Layouts 1.11 -import com.itsblue.speedclimbingstopwatch 2.0 +import de.itsblue.ScStw 2.0 +import de.itsblue.ScStw.Styling 2.0 +import de.itsblue.ScStw.Styling.Components 1.0 +import de.itsblue.ScStwApp 2.0 -Window { +ApplicationWindow { visible: true width: 540 height: 960 - title: "Speedclimbing stw" - property date currentTime: new Date() - property int millis: 0 + + title: "ScStwApp" Page { - id:app + id: app anchors.fill: parent - //set default state to IDLE - state: "IDLE" + state: scStwRemoteRace.state Rectangle { id: backgroundRect anchors.fill: parent - color: appTheme.style.backgroundColor + color: appTheme.theme.colors.background Behavior on color { ColorAnimation { @@ -55,488 +59,195 @@ Window { } } - SpeedBackend { - id: speedBackend + ScStw { + id: scStw + } + + ScStwClient { + id: scStwClient + + property ScStwSetting ipSetting: scStwAppSettings.getSetting(ScStwAppSettings.BaseStationIpSetting, ScStwAppSettings.KeyLevel) + ipAddress: ipSetting.value + } + + ScStwAppSettings { + id: scStwAppSettings + + scStwClient: scStwClient + } + + ScStwTimer { + id: defaultTimer + } + + ScStwRemoteRace { + id: scStwRemoteRace + + autoRefreshTimerText: true + settings: scStwAppSettings + scStwClient: scStwClient + + Component.onCompleted: { + scStwRemoteRace.addTimer(defaultTimer) + } onStateChanged: { - var stateString - console.log("race state changed to: " + state) - switch (state){ - case 0: - stateString = "IDLE" - break; - case 1: - stateString = "STARTING" - settingsDialog.close() - profilesDialog.close() - break; - case 2: - stateString = "WAITING" - settingsDialog.close() - profilesDialog.close() - break; - case 3: - stateString = "RUNNING" - settingsDialog.close() - profilesDialog.close() - break; - case 4: - stateString = "STOPPED" + if(scStwRemoteRace.state !== ScStwRace.IDLE) { settingsDialog.close() profilesDialog.close() } - app.state = stateString } } - AppTheme { + SpeedBackend { + id: speedBackend + scStwClient: scStwClient + } + + ScStwAppThemeManager { id: appTheme + property ScStwSetting setting: scStwAppSettings.getSetting(ScStwAppSettings.AppThemeSetting, ScStwAppSettings.KeyLevel) + themeName: setting.value } - /*------------------------ - Timer text an upper line - ------------------------*/ - RectangularGlow { - id: effect_2 - glowRadius: 7 - spread: 0.02 - color: "black" - opacity: 0.18 - anchors.fill: topContainerItm - scale: 1 + // --------------- + // - Main layout - + // --------------- + + GridLayout { + id: mainLayout + + anchors.fill: parent + + columns: app.landscape() ? 3:1 + rows: app.landscape() ? 1:3 + + TopToolBar { + id: topToolBar + + state: app.state + + sizeMode: "large" + } + + + CenterContent { + id: centerContent + + state: app.state + + Layout.fillWidth: true + Layout.fillHeight: true + } + + BottomToolBar { + id: bottomToolBar + + sizeMode: "tiny" + } + } - Item { - id: topContainerItm + states: [ + State { + name: ScStwRace.IDLE - anchors { - top: parent.top - left: parent.left - right: app.landscape() ? startButt.left:parent.right - bottom: app.landscape() ? parent.bottom:startButt.top - bottomMargin: app.landscape() ? undefined:parent.height * 0.1 - rightMargin: app.landscape() ? parent.width * 0.05:0 - } - - Rectangle { - anchors.fill: parent - color: appTheme.style.menuColor - - Behavior on color { - ColorAnimation { - duration: 200 - } - } - } - - Text { - id: topLa - - property string implicitText: "" - - anchors.centerIn: parent - - opacity: ( speedBackend.state < 3 ) ? 1:0 - - width: parent.width * 0.7 - height: parent.height * 0.7 - - text: implicitText === "NEXT_START_ACTION" ? ["at your \nmarks", "ready", "starting...", ""][speedBackend.nextStartAction]:implicitText - - color: appTheme.style.textColor - - fontSizeMode: Text.Fit - - verticalAlignment: Text.AlignVCenter - horizontalAlignment: Text.AlignHCenter - - font.pixelSize: app.landscape() ? parent.width * 0.15 : parent.height * 0.4 - - minimumPixelSize: 1 - - Behavior on text { - FadeAnimation{ - target: topLa - fadeDuration: 100 - } - } - } - - Column { - id: timerCol - - anchors.fill: parent - anchors.bottomMargin: app.landscape() ? 0:parent.height * 0.1 - - opacity: ( speedBackend.state < 3 ) ? 0:1 - - spacing: height * 0.05 - - Repeater { - id: timerRep - - model: speedBackend.timers.length - - delegate: Item { - id: timerDel - - width: parent.width - height: timerRep.model > 1 ? ( timerCol.height * 0.9 ) / timerRep.model:timerCol.height - - Label { - id: timerTextLa - - anchors.centerIn: parent - - width: ( parent.width * 0.8 ) - height: parent.height - - elide: "ElideRight" - color: ["WON"].includes(speedBackend.timers[index]["state"]) ? appTheme.style.successColor : - ["LOST", "FAILED"].includes(speedBackend.timers[index]["state"]) ? appTheme.style.errorColor: - appTheme.style.textColor - - enabled: speedBackend.timers[index]["state"] !== "DISABLED" - - text: speedBackend.timers[index]["text"] - - fontSizeMode: Text.Fit - - verticalAlignment: Text.AlignVCenter - horizontalAlignment: Text.AlignHCenter - - font.pixelSize: app.landscape() ? parent.width * 0.15 : parent.height * 0.4 - - minimumPixelSize: 1 - - /*Behavior on text { - enabled: !["RUNNING", "STOPPED", "WON", "LOST", "FAILED", "CANCELLED"].includes(app.state) - FadeAnimation { - target: timerTextLa - } - }*/ - } - - Label { - id: react_time - - property int rtime: speedBackend.timers[index]["reacttime"] - - anchors { - centerIn: parent - verticalCenterOffset: timerTextLa.font.pixelSize * 0.5 + react_time.font.pixelSize * 0.5 - } - - width: ( parent.width * 0.6 ) - height: parent.height - - fontSizeMode: Text.Fit - - verticalAlignment: Text.AlignVCenter - horizontalAlignment: Text.AlignHCenter - - text: "reaction time (ms): " + Math.round(rtime) - - opacity: (app.state === "RUNNING" || app.state === "STOPPED") && rtime !== 0 ? 1:0 - - color: appTheme.style.textColor - - font.pixelSize: timerTextLa.font.pixelSize * 0.5 - } - } + PropertyChanges { + target: topToolBar + sizeMode: "small" } - Behavior on opacity { - NumberAnimation { - duration: 200 - } + PropertyChanges { + target: bottomToolBar + sizeMode: "small" } - } + }, - Behavior on opacity { - NumberAnimation { - duration: 200 - } - } - } + State { + name: ScStwRace.PREPAIRING - Item { - id: connectionIconContainer - - anchors { - top: parent.top - left: parent.left - right: parent.right - bottom: parent.bottom - bottomMargin: app.landscape() ? 0:parent.height * 0.8 - rightMargin: app.landscape() ? parent.width * 0.8:0 - } - - ConnectionIcon { - id: baseConnConnIcon - status: speedBackend.baseStationState - - source: appTheme.style.baseStationIcon - anchors { - top: parent.top - topMargin: 10 - left: parent.left - leftMargin: 10 - } - scale: 1.3 - height: !app.landscape()? parent.height*0.3:parent.width*0.3 - } - - Row { - id: connectedExtensionsRow - - anchors { - top: parent.top - topMargin: 10 - left: baseConnConnIcon.right - leftMargin: 1 + PropertyChanges { + target: topToolBar + sizeMode: "medium" } - height: parent.height - width: parent.width - - Repeater { - id: connectedExtensionsRep - anchors.fill: parent - model: speedBackend.baseStationConnections.length - delegate: ConnectionIcon { - id: buzzerConnIcon - status: speedBackend.baseStationConnections[index]["state"] - - source: { - var source - switch(speedBackend.baseStationConnections[index]["type"]){ - case "STARTPAD": - source = appTheme.style.startpadIcon - break - case "TOPPAD": - source = appTheme.style.buzzerIcon - break - } - } - - scale: 0 - - height: !app.landscape()? parent.height*0.17:parent.width*0.17 - width: status === "disconnected" ? 0:height - - Component.onCompleted: { - scale = 1 - } - - Behavior on scale { - NumberAnimation { - duration: 200 - } - } - - Behavior on width { - NumberAnimation { - duration: 200 - } - } - } + PropertyChanges { + target: bottomToolBar + sizeMode: "tiny" } - } - } + }, - Rectangle { - id: upper_line - width: app.landscape() ? 1:parent.width - height: app.landscape() ? parent.height:1 - color: appTheme.style.lineColor - anchors.left: app.landscape() ? topContainerItm.right:parent.left - anchors.top: app.landscape() ? parent.top:topContainerItm.bottom - anchors.bottom: app.landscape() ? parent.bottom:undefined - visible: false - } + State { + name: ScStwRace.WAITING - // ---------------------------------- - // -- Start / Stop / Reset button --- - // ---------------------------------- - DelayButton { - id : startButt - - text: "start" - property int size: app.landscape() ? parent.width * 0.5:parent.height * 0.5 - property color backgroundColor: appTheme.style.buttonColor - property bool progressControlActivated: speedBackend.baseStationState === "connected" && app.state === "RUNNING" - delay: progressControlActivated ? 2000:0 - - anchors { - bottom: parent.bottom - bottomMargin: app.height * 0.5 - height * 0.5 - right: parent.right - rightMargin: app.width * 0.5 - width * 0.5 - } - - height: app.landscape() ? (size > parent.height * 0.9 ? parent.height * 0.9:size) : (size > parent.width * 0.9 ? parent.width * 0.9:size) - width: height - - Label { - id: startButt_text - text: startButt.text - anchors.centerIn: parent - font.pixelSize: parent.height * 0.16 - font.family: "Helvetica" - color: enabled ? appTheme.style.textColor:appTheme.style.disabledTextColor - } - - Behavior on text { - //animate a text change - enabled: true - FadeAnimation { - target: startButt_text - } - } - - onClicked: { - if(startButt.progressControlActivated && progress < 1.0) - return - startButt.progress = 0 - switch(app.state) { - case "IDLE": - app.start() - break - case "RUNNING": - app.stop(0) - break - case "STOPPED": - app.reset() - break - } - } - - contentItem: Text { - } - - background: Item { - RectangularGlow { - glowRadius: 0.001 - spread: 0.2 - color: "black" - - visible: true - - cornerRadius: startButtBackground.radius - anchors.fill: startButtBackground - scale: 0.75 - opacity: Math.pow( startButt.opacity, 100 ) + PropertyChanges { + target: topToolBar + sizeMode: "medium" } - Rectangle { - id: startButtBackground - implicitWidth: 100 - implicitHeight: 100 - color: startButt.down ? Qt.darker(startButt.backgroundColor, 1.2) : startButt.backgroundColor - radius: size / 2 - - readonly property real size: Math.min(startButt.width, startButt.height) - width: size - height: size - anchors.fill: parent - - Behavior on color { - ColorAnimation { - duration: 200 - } - } - - Canvas { - id: canvas - anchors.fill: parent - - visible: startButt.progressControlActivated - - Connections { - target: startButt - onProgressChanged: canvas.requestPaint() - } - - onPaint: { - var ctx = getContext("2d") - ctx.clearRect(0, 0, width, height) - ctx.strokeStyle = "grey" - ctx.lineWidth = parent.width * 0.02 - ctx.beginPath() - var startAngle = Math.PI * 0.5 - var endAngle = startAngle + startButt.progress * Math.PI * 2 - ctx.arc(width / 2, height / 2, width / 2 - ctx.lineWidth / 2 - 2, startAngle, endAngle) - ctx.stroke() - } - } + PropertyChanges { + target: bottomToolBar + sizeMode: "tiny" } - }} + }, - ProgressCircle { - id: prog - anchors.fill: startButt - opacity: app.state === "STARTING" ? 1:0 + State { + name: ScStwRace.STARTING - scale: startButt.scale + PropertyChanges { + target: topToolBar + sizeMode: "medium" + } - lineWidth: prog.width * 0.02 + PropertyChanges { + target: bottomToolBar + sizeMode: "tiny" + } + }, - arcBegin: 0 - arcEnd: 360 * speedBackend.nextStartActionDelayProgress + State { + name: ScStwRace.RUNNING - colorCircle: "grey" + PropertyChanges { + target: topToolBar + sizeMode: "medium" + } - Behavior on opacity { - NumberAnimation { - duration: 200 + PropertyChanges { + target: bottomToolBar + sizeMode: "tiny" + } + }, + + State { + name: ScStwRace.STOPPED + + PropertyChanges { + target: topToolBar + sizeMode: "large" + } + + PropertyChanges { + target: bottomToolBar + sizeMode: "tiny" + } + }, + + State { + name: ScStwRace.INCIDENT + + PropertyChanges { + target: topToolBar + sizeMode: "small" + } + + PropertyChanges { + target: bottomToolBar + sizeMode: "tiny" } } + ] - animationDuration: 0 - } - - /*---------------------- - Cancel button - ----------------------*/ - FancyButton { - id: cancelButt - - text: "cancel" - anchors { - right: startButt.right - bottom: startButt.bottom - } - contentItem: Text { - //make text disappear - } - height: startButt.height * 0.3 - scale: 0 - width: height - - enabled: app.state === "STARTING" - - onClicked: { - app.stop(1) - } - - Behavior on scale { - PropertyAnimation { - duration: 200 - } - } - - Label { - id: cancelButt_text - text: cancelButt.text - anchors.centerIn: parent - font.pixelSize: parent.height * 0.16 - font.family: "Helvetica" - color: appTheme.style.textColor - } - - backgroundColor: appTheme.style.buttonColor - } /*------ Popups @@ -544,10 +255,11 @@ Window { SettingsDialog{ id: settingsDialog - x: startButt.x - y: startButt.y - width: startButt.width - height: startButt.height + x: centerContent.x + (centerContent.width - width) * 0.5 + y: centerContent.y + (centerContent.height - height) * 0.5 + + width: Math.min(centerContent.width * 0.9, centerContent.height * 0.9) + height: width } ProfilesDialog { @@ -555,310 +267,14 @@ Window { property int margin: app.landscape() ? app.height * 0.05:app.width * 0.05 - x: app.landscape() ? topContainerItm.width + margin:topContainerItm.x + margin - y: !app.landscape() ? topContainerItm.height + margin:topContainerItm.x + margin - width: app.landscape() ? app.width - topContainerItm.width - menu_container.width - margin * 2 : app.width - margin * 2 - height: !app.landscape() ? app.height - topContainerItm.height - menu_container.height - margin * 2 : app.height - margin * 2 + x: centerContent.x + margin + y: centerContent.y + margin + width: centerContent.width - margin * 2 + height: centerContent.height - margin * 2 } - /*------------------- - lower line and menu - -------------------*/ - - Rectangle { - id: lowerLine - width: app.landscape() ? 1:parent.width - height: app.landscape() ? parent.height:1 - color: appTheme.style.lineColor - anchors.right: app.landscape() ? menu_container.left:parent.right - anchors.bottom: app.landscape() ? parent.bottom:menu_container.top - anchors.top: app.landscape() ? parent.top:undefined - visible: false - } - - RectangularGlow { - id: effect - glowRadius: 7 - spread: 0.02 - color: "black" - opacity: 0.18 - anchors.fill: menu_container - scale: 1 - } - - Item { - id: menu_container - - anchors { - bottom: parent.bottom - right: parent.right - left: app.landscape() ? startButt.right:parent.left - top: app.landscape() ? parent.top:startButt.bottom - topMargin: app.landscape() ? undefined:parent.height * 0.1 - leftMargin: app.landscape() ? parent.width * 0.05:0 - } - - Rectangle { - id: lowerMenuBackground - anchors.fill: parent - color: appTheme.style.menuColor - - Behavior on color { - ColorAnimation { - duration: 200 - } - } - } - - Grid { - id: loweMenuGrd - - property int spacingMultiplier: 200 * (getActiveChildren() - 1) - property int activeChildren: getActiveChildren() - - function getActiveChildren() { - var childrenCount = 0 - for (var i = 0; i < children.length; i++) - { - if(children[i].enabled){ - childrenCount ++ - } - } - - return childrenCount - } - - anchors.centerIn: parent - - height: childrenRect.height - width: childrenRect.width - - rows: app.landscape() ? activeChildren:1 - columns: app.landscape() ? 1:activeChildren - - spacing: 0// app.landscape() ? parent.height * spacingMultiplier * 0.001:parent.width * spacingMultiplier * 0.001 - - Behavior on spacingMultiplier { - NumberAnimation { - duration: 200 - } - } - - FancyButton { - id: settingsButt - - height: app.landscape() ? menu_container.width * 0.7:menu_container.height * 0.7 - width: height - - onClicked: { - settingsDialog.open() - } - - image: appTheme.style.settIcon - - backgroundColor: parent.pressed ? appTheme.style.buttonPressedColor:appTheme.style.buttonColor - - } - - Item { - height: profilesButt.height - width: profilesButt.height - } - - FancyButton { - id: profilesButt - - enabled: height > 0 - - state: speedBackend.baseStationState === "connected" ? "visible":"hidden" - width: height - - onClicked: { - profilesDialog.open() - } - - image: appTheme.style.profilesIcon - - backgroundColor: parent.pressed ? appTheme.style.buttonPressedColor:appTheme.style.buttonColor - - states: [ - State { - name: "hidden" - PropertyChanges { - target: profilesButt - height: 0 - } - }, - State { - name: "visible" - PropertyChanges { - target: profilesButt - height: app.landscape() ? menu_container.width * 0.7:menu_container.height * 0.7 - } - } - ] - - transitions: [ - Transition { - NumberAnimation { - properties: "height" - } - } - ] - } - } - } - - /*---------------------- - Timer states - ----------------------*/ - states: [ - State { - name: "IDLE" - //state for the start page - PropertyChanges { - target: topContainerItm; - anchors.bottomMargin: app.landscape() ? undefined:parent.height * 0.1; - anchors.rightMargin: app.landscape() ? parent.height * 0.05:0 - } - PropertyChanges { - target: startButt; - enabled: true; text: "start"; - size: app.landscape() ? parent.width * 0.5:parent.height * 0.5 - anchors.bottomMargin: parent.height * 0.5 - startButt.height * 0.5 - anchors.rightMargin: parent.width * 0.5 - startButt.width * 0.5 - } - PropertyChanges { - target: topLa - implicitText: "click start to start" - } - - }, - State { - name: "WAITING" - //state when a false start occured and waiting for time calculation - PropertyChanges { - target: startButt; enabled: false; text: "waiting..."; - anchors.rightMargin: app.landscape() ? parent.width * 0.05:parent.width * 0.5 - startButt.width * 0.5 //put the button more to the right to hide the menu (only in landscape mode) - anchors.bottomMargin: app.landscape() ? parent.height * 0.5 - startButt.height * 0.5:parent.height * 0.1 //put the button lower to hide the menu (only in portrait mode) - } - PropertyChanges { target: cancelButt; scale: 0; enabled: false} - PropertyChanges { target: menu_container; } - PropertyChanges { - target: topLa - implicitText: "please wait..." - } - }, - State { - name: "STARTING" - //state for the start sequence - PropertyChanges { target: startButt; enabled: false; text: "starting..."; - anchors.rightMargin: app.landscape() ? parent.width * 0.05:parent.width * 0.5 - startButt.width * 0.5 //put the button more to the right to hide the menu (only in landscape mode) - anchors.bottomMargin: app.landscape() ? parent.height * 0.5 - startButt.height * 0.5:parent.height * 0.1 //put the button lower to hide the menu (only in portrait mode) - } - PropertyChanges { target: cancelButt; scale: 1} - PropertyChanges { target: menu_container; } - PropertyChanges { - target: topLa - implicitText: "NEXT_START_ACTION" - } - - }, - State { - name: "RUNNING" - //state when the timer is running - PropertyChanges { target: startButt; enabled: true; - text: speedBackend.baseStationState === "connected" ? "cancel":"stop" - anchors.rightMargin: app.landscape() ? parent.width * 0.05:parent.width * 0.5 - startButt.width * 0.5 //put the button more to the right to hide the menu (only in landscape mode) - anchors.bottomMargin: app.landscape() ? parent.height * 0.5 - startButt.height * 0.5:parent.height * 0.1 //put the button lower to hide the menu (only in portrait mode) - } - PropertyChanges { - target: topLa - implicitText: "" - } - }, - - State { - name: "STOPPED" - //state when the meassuring is over - PropertyChanges { - target: startButt; - enabled: true; text: "reset"; - size: app.landscape() ? parent.height * 0.35:parent.height * 0.2; - anchors.bottomMargin: app.landscape() ? parent.height * 0.5 - startButt.height * 0.5:parent.height * 0.2 - startButt.height * 0.5 - anchors.rightMargin: app.landscape() ? parent.height * 0.2 - startButt.height * 0.5:parent.width * 0.5 - startButt.width * 0.5 - } - PropertyChanges { - target: topContainerItm; - anchors.rightMargin: app.landscape() ? 0-startButt.width/2:undefined - anchors.bottomMargin: app.landscape() ? undefined:0-startButt.height/2 - } - PropertyChanges { - target: topLa - text: "" - } - } - ] - - /*---------------------- - Timer animations - ----------------------*/ - transitions: [ - Transition { - NumberAnimation { properties: "size,rightMargin,height,width,bottomMargin,font.pixelSize,pixelSize"; easing.type: Easing.InOutQuad; duration: 700 } - }, - Transition { - to: "STOPPED" - NumberAnimation { properties: "size,rightMargin,height,width,bottomMargin,font.pixelSize,pixelSize"; easing.type: Easing.InOutQuad; duration: 700 } - }, - Transition { - to: "IDLE" - NumberAnimation { properties: "size,rightMargin,height,width,bottomMargin,font.pixelSize,pixelSize"; easing.type: Easing.InOutQuad; duration: 700 } - }, - - Transition { - from: "STARTING" - to: "RUNNING" - //disable transitions for the RUNNING state - }, - Transition { - from: "RUNNING" - to: "WAITING" - //disable transitions for the RUNNING state - } - ] - - /*---------------------- - Timer functions - ----------------------*/ function landscape(){ return(app.height < app.width) } - - /*----Functions to control the stopwatch----*/ - function start(){ - var ret = speedBackend.startRace() - if(ret !== 200){ - console.log("+ --- error starting race: "+ret) - } - } - - function stop(type){ - - var ret = speedBackend.stopRace(type) - - if(ret !== 200){ - console.log("+ --- error stopping race: "+ret) - } - } - - function reset(){ - - var ret = speedBackend.resetRace() - - if(ret !== 200){ - console.log("+ --- error resetting race: "+ret) - } - } } } diff --git a/resources/qml/qml.qrc b/resources/qml/qml.qrc index f69312d..18988d9 100644 --- a/resources/qml/qml.qrc +++ b/resources/qml/qml.qrc @@ -3,7 +3,6 @@ main.qml components/ProgressCircle.qml components/ConnectionDelegate.qml - components/FadeAnimation.qml components/ConnectionIcon.qml components/NextPageDelegate.qml components/FancyButton.qml @@ -12,7 +11,6 @@ components/InputDelegate.qml components/SmoothSliderDelegate.qml components/RemoteDataListView.qml - components/FancyBusyIndicator.qml ProfilesDialog/ProfilesDialog.qml ProfilesDialog/ProfilesStack.qml ProfilesDialog/ProfileListPage.qml @@ -23,6 +21,14 @@ SettingsDialog/StartPage.qml SettingsDialog/SettingsStartSequencePage.qml SettingsDialog/SettingsBaseStationPage.qml - SettingsDialog/SettingsBaseStationConnectionsPage.qml + components/layout/ToolBar.qml + MainPage/TopToolBar.qml + MainPage/CenterContent.qml + MainPage/BottomToolBar.qml + components/MainActionButton.qml + components/StateIndicator.qml + components/BatteryIndicator.qml + components/ExtensionOverview.qml + SettingsDialog/SettingsBaseStationSettingsPage.qml diff --git a/resources/shared/ScStwBasestation.sb64 b/resources/shared/ScStwBasestation.sb64 deleted file mode 100644 index 47a2919..0000000 --- a/resources/shared/ScStwBasestation.sb64 +++ /dev/null @@ -1 +0,0 @@ -0.8.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 \ No newline at end of file diff --git a/resources/shared/graphics/Banner.png b/resources/shared/graphics/Banner.png deleted file mode 100644 index 7fc4651..0000000 Binary files a/resources/shared/graphics/Banner.png and /dev/null differ diff --git a/resources/shared/graphics/Banner.xcf b/resources/shared/graphics/Banner.xcf deleted file mode 100644 index b166863..0000000 Binary files a/resources/shared/graphics/Banner.xcf and /dev/null differ diff --git a/resources/shared/graphics/BaseStation.xcf b/resources/shared/graphics/BaseStation.xcf deleted file mode 100644 index a4d75f3..0000000 Binary files a/resources/shared/graphics/BaseStation.xcf and /dev/null differ diff --git a/resources/shared/graphics/Buzzer.xcf b/resources/shared/graphics/Buzzer.xcf deleted file mode 100644 index 2cac802..0000000 Binary files a/resources/shared/graphics/Buzzer.xcf and /dev/null differ diff --git a/resources/shared/graphics/favicon.xcf b/resources/shared/graphics/favicon.xcf deleted file mode 100644 index a901dd4..0000000 Binary files a/resources/shared/graphics/favicon.xcf and /dev/null differ diff --git a/resources/shared/graphics/poster.png b/resources/shared/graphics/poster.png deleted file mode 100644 index b920b99..0000000 Binary files a/resources/shared/graphics/poster.png and /dev/null differ diff --git a/resources/shared/graphics/poster.xcf b/resources/shared/graphics/poster.xcf deleted file mode 100644 index 13d95a3..0000000 Binary files a/resources/shared/graphics/poster.xcf and /dev/null differ diff --git a/resources/shared/graphics/startpad.xcf b/resources/shared/graphics/startpad.xcf deleted file mode 100644 index 518add8..0000000 Binary files a/resources/shared/graphics/startpad.xcf and /dev/null differ diff --git a/resources/shared/shared.qrc b/resources/shared/shared.qrc index d49ee55..d977fbf 100644 --- a/resources/shared/shared.qrc +++ b/resources/shared/shared.qrc @@ -25,6 +25,5 @@ graphics/icons/user_black.png graphics/icons/ok.png sounds/IFSC_STARTSIGNAL_SINE.wav - ScStwBasestation.sb64 diff --git a/resources/shared/speedclimbing_stopwatch.png b/resources/shared/speedclimbing_stopwatch.png deleted file mode 100644 index ec4b891..0000000 Binary files a/resources/shared/speedclimbing_stopwatch.png and /dev/null differ diff --git a/shared-libraries b/shared-libraries new file mode 160000 index 0000000..37bea91 --- /dev/null +++ b/shared-libraries @@ -0,0 +1 @@ +Subproject commit 37bea9105f1c7e0c8f1a209da3d5043c61abfb44 diff --git a/sources/appsettings.cpp b/sources/appsettings.cpp deleted file mode 100644 index 9bff130..0000000 --- a/sources/appsettings.cpp +++ /dev/null @@ -1,69 +0,0 @@ -/* - Speed Climbing Stopwatch - Simple Stopwatch for Climbers - Copyright (C) 2018 Itsblue Development - Dorian Zeder - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published - by the Free Software Foundation, version 3 of the License. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see . -*/ - -#include "headers/appsettings.h" - -AppSettings * pGlobalAppSettings = nullptr; - -AppSettings::AppSettings(QObject* parent) - :QObject(parent) -{ - QString path = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation); - - this->settingsManager = new QSettings(path+"/settings.ini", QSettings::IniFormat, this); - - this->setDefaultSetting("ready_en", "false"); - this->setDefaultSetting("ready_delay", 0); - this->setDefaultSetting("at_marks_en", "false"); - this->setDefaultSetting("at_marks_delay", 0); - - this->setDefaultSetting("theme", "Light"); - - this->setDefaultSetting("baseStationIpAdress", "192.168.4.1"); - - pGlobalAppSettings = this; -} - -QString AppSettings::loadSetting(const QString &key) -{ - this->settingsManager->beginGroup("AppSettings"); - QString value = this->settingsManager->value(key , false).toString(); - this->settingsManager->endGroup(); - return(value); -} - -void AppSettings::writeSetting(const QString &key, const QVariant &variant) -{ - this->settingsManager->beginGroup("AppSettings"); - this->settingsManager->setValue(key , variant); - this->settingsManager->endGroup(); -} - -void AppSettings::setDefaultSetting(const QString &key, const QVariant &defaultVariant) -{ - QString value = this->loadSetting(key); - if(value == "false"){ - this->writeSetting(key, defaultVariant); - } - -} - -AppSettings::~AppSettings() -{ - delete settingsManager; -} - diff --git a/sources/apptheme.cpp b/sources/apptheme.cpp deleted file mode 100644 index dd6fd19..0000000 --- a/sources/apptheme.cpp +++ /dev/null @@ -1,132 +0,0 @@ -#include "headers/apptheme.h" - -AppTheme::AppTheme(QObject *parent) : QObject(parent) -{ - - QVariantMap tmpDarkTheme = { - {"backgroundColor", "#2d3037"}, - - {"buttonColor", "#202227"}, - {"buttonPressedColor", "#41454f"}, - {"buttonBorderColor", "grey"}, - {"disabledButtonColor", "#555555"}, - - {"viewColor", "#202227"}, - {"menuColor", "#292b32"}, - - {"delegate1Color", "#202227"}, - {"delegate2Color", "#202227"}, - {"delegateBackgroundColor", "#202227"}, - {"delegatePressedColor", "#41454f"}, - - {"textColor", "#ffffff"}, - {"textDarkColor", "#232323"}, - {"disabledTextColor", "#777777"}, - - {"sliderColor", "#6ccaf2"}, - - {"successColor", "#6bd43b"}, - {"errorColor", "#e03b2f"}, - - {"lineColor", "grey"}, - - {"backIcon", "qrc:/graphics/icons/back.png"}, - {"settIcon", "qrc:/graphics/icons/settings.png"}, - {"buzzerIcon", "qrc:/graphics/icons/buzzer.png"}, - {"startpadIcon", "qrc:/graphics/icons/startpad.png"}, - {"baseStationIcon", "qrc:/graphics/icons/BaseStation.png"}, - {"profilesIcon", "qrc:/graphics/icons/user.png"}, - {"confirmIcon", "qrc:/graphics/icons/ok.png"} - - }; - this->darkTheme = tmpDarkTheme; - - QVariantMap tmpLightTheme = { - {"backgroundColor", "white"}, - - {"buttonColor", "white"}, - {"buttonPressedColor", "lightgrey"}, - {"buttonBorderColor", "grey"}, - {"disabledButtonColor", "#d5d5d5"}, - - {"viewColor", "white"}, - {"menuColor", "#f8f8f8"}, - - {"delegate1Color", "#202227"}, - {"delegate2Color", "#202227"}, - {"delegateBackgroundColor", "white"}, - {"delegatePressedColor", "#dddedf"}, - - {"textColor", "black"}, - {"textDarkColor", "#232323"}, - {"disabledTextColor", "grey"}, - - {"sliderColor", "#6ccaf2"}, - - {"successColor", "#60de26"}, - {"errorColor", "#ff0000"}, - - {"lineColor", "grey"}, - - {"backIcon", "qrc:/graphics/icons/back_black.png"}, - {"settIcon", "qrc:/graphics/icons/settings_black.png"}, - {"buzzerIcon", "qrc:/graphics/icons/buzzer_black.png"}, - {"startpadIcon", "qrc:/graphics/icons/startpad_black.png"}, - {"baseStationIcon", "qrc:/graphics/icons/BaseStation_black.png"}, - {"profilesIcon", "qrc:/graphics/icons/user_black.png"}, - {"confirmIcon", "qrc:/graphics/icons/ok_black.png"} - - }; - this->lightTheme = tmpLightTheme; - - QString currentThemeString = pGlobalAppSettings->loadSetting("theme"); - - if(currentThemeString == "Light"){ - this->currentTheme = &this->lightTheme; - } - else if (currentThemeString == "Dark") { - this->currentTheme = &this->darkTheme; - } - else { - this->currentTheme = &this->lightTheme; - } -} - -QVariant AppTheme::getStyle() { - return *this->currentTheme; -} - -void AppTheme::changeTheme() { - QString currentThemeString = pGlobalAppSettings->loadSetting("theme"); - QString newThemeString = "Light"; - - if(currentThemeString == "Light"){ - this->currentTheme = &this->darkTheme; - newThemeString = "Dark"; - - } - else if (currentThemeString == "Dark") { - this->currentTheme = &this->lightTheme; - newThemeString = "Light"; - } - else { - this->currentTheme = &this->lightTheme; - } - - pGlobalAppSettings->writeSetting("theme", newThemeString); - - emit this->styleChanged(); -} - -void AppTheme::refreshTheme() { - QString currentThemeString = pGlobalAppSettings->loadSetting("theme"); - - if(currentThemeString == "Light"){ - this->currentTheme = &this->lightTheme; - } - else if (currentThemeString == "Dark") { - this->currentTheme = &this->darkTheme; - } - - emit this->styleChanged(); -} diff --git a/sources/baseconn.cpp b/sources/baseconn.cpp deleted file mode 100644 index bda8539..0000000 --- a/sources/baseconn.cpp +++ /dev/null @@ -1,460 +0,0 @@ -#include "headers/baseconn.h" - -BaseConn * pGlobalBaseConn = nullptr; - -BaseConn::BaseConn(QObject *parent) : QObject(parent) -{ - pGlobalBaseConn = this; - - socket = new QTcpSocket(this); - - this->timeoutTimer = new QTimer(this); - this->timeoutTimer->setSingleShot(true); - - this->state = "disconnected"; - - connect(this->socket, SIGNAL(error(QAbstractSocket::SocketError)), - this, SLOT(gotError(QAbstractSocket::SocketError))); - - connect(this->socket, &QAbstractSocket::stateChanged, this, &BaseConn::socketStateChanged); - - this->nextConnectionId = 1; - this->connections = QVariantList({}); -} - -void BaseConn::connectToHost() { - qDebug() << "connecting"; - setState("connecting"); - this->connection_progress = 0; - - connect(this->timeoutTimer, SIGNAL(timeout()), this, SLOT(connectionTimeout())); - - //connect - this->socket->connectToHost(this->ip, this->port); - - timeoutTimer->start(3000); -} - -void BaseConn::connectionTimeout() { - this->socket->abort(); - disconnect(this->timeoutTimer, SIGNAL(timeout()), this, SLOT(connectionTimeout())); -} - -bool BaseConn::init() { - disconnect(this->timeoutTimer, SIGNAL(timeout()), this, SLOT(connectionTimeout())); - this->timeoutTimer->stop(); - - connect(this->socket, &QTcpSocket::readyRead, this, &BaseConn::readyRead); - this->connection_progress = 50; - - this->setState("connected"); - - // init remote session - QJsonArray updateSubs = {"onRaceStateChanged", "onTimersChanged", "onExtensionConnectionsChanged", "onNextStartActionChanged"}; - QJsonObject sessionParams = {{"updateSubs", updateSubs}, {"init", true}, {"usingTerminationKeys", true}}; - - QVariantMap initResponse = this->sendCommand(1, sessionParams, false); - - if(initResponse["status"] != 200) { - return false; - } - - this->firmwareVersion = initResponse["data"].toMap()["version"].toString(); - this->timeOffset = initResponse["data"].toMap()["time"].toDouble() - this->date->currentMSecsSinceEpoch(); - this->firmwareUpToDate = this->isFirmwareUpToDate(); - - emit this->propertiesChanged(); - - qDebug() << "[INFO][BaseStation] Init done! firmware: version: " << this->firmwareVersion << " up-to-date: " << this->firmwareUpToDate << " time offset: " << this->timeOffset; - - return true; -} - -void BaseConn::deInit() { - this->connections.clear(); - emit this->connectionsChanged(); - this->setState("disconnected"); -} - -void BaseConn::closeConnection() -{ - this->connections = QVariantList({}); - emit this->connectionsChanged(); - - qDebug() << "closing connection"; - switch (socket->state()) - { - case 0: - socket->disconnectFromHost(); - break; - case 2: - socket->abort(); - break; - default: - socket->abort(); - } - - setState("disconnected"); -} - -void BaseConn::gotError(QAbstractSocket::SocketError err) -{ - //qDebug() << "got error"; - QString strError = "unknown"; - switch (err) - { - case 0: - strError = "Connection was refused"; - break; - case 1: - strError = "Remote host closed the connection"; - this->closeConnection(); - break; - case 2: - strError = "Host address was not found"; - break; - case 5: - strError = "Connection timed out"; - break; - default: - strError = "Unknown error"; - } - - emit gotError(strError); - qDebug() << "got socket error: " << strError; -} - -// ------------------------------------- -// --- socket communication handling --- -// ------------------------------------- - -void BaseConn::socketStateChanged(QAbstractSocket::SocketState socketState) { - switch (socketState) { - case QAbstractSocket::UnconnectedState: - { - this->deInit(); - break; - } - case QAbstractSocket::ConnectedState: - { - if(!this->init()) { - this->closeConnection(); - } - - break; - } - default: - { - //qDebug() << "+ --- UNKNOWN SOCKET STATE: " << socketState; - break; - } - } -} - -QVariantMap BaseConn::sendCommand(int header, QJsonValue data, bool useTerminationKeys, int timeout) { - if(this->state != "connected"){ - return {{"status", 910}, {"data", "not connected"}}; - } - - // generate id and witing requests entry - int thisId = nextConnectionId; - //qDebug() << "sending command: " << header << " with data: " << data << " and id: " << thisId; - nextConnectionId ++; - - QEventLoop *loop = new QEventLoop(this); - QTimer *timer = new QTimer(this); - QJsonObject reply; - - this->waitingRequests.append({thisId, loop, reply}); - - QJsonObject requestObj; - requestObj.insert("id", thisId); - requestObj.insert("header", header); - requestObj.insert("data", data); - - QString jsonRequest = QJsonDocument(requestObj).toJson(); - - timer->setSingleShot(true); - // quit the loop when the timer times out - loop->connect(timer, SIGNAL(timeout()), loop, SLOT(quit())); - // quit the loop when the connection was established - // loop.connect(this, &BaseConn::gotReply, &loop, &QEventLoop::quit); - // start the timer before starting to connect - timer->start(timeout); - - //write data - if(useTerminationKeys) { - socket->write("" + jsonRequest.toLatin1() + ""); - } - else { - socket->write(jsonRequest.toLatin1()); - } - - //wait for an answer to finish (programm gets stuck in here) - loop->exec(); - - bool replyFound = false; - - // find reply and delete the request from waiting list - for(int i = 0; iwaitingRequests.length(); i++){ - if(this->waitingRequests[i].id == thisId){ - // request was found - replyFound = true; - // delete event loop - if(this->waitingRequests[i].loop != nullptr) { - delete this->waitingRequests[i].loop; - } - // store reply - reply = this->waitingRequests[i].reply; - // remove reply from waiting list - this->waitingRequests.removeAt(i); - } - } - - if(!replyFound) { - // some internal error occured - return {{"status", 900}, {"data", ""}}; - } - - if(timer->remainingTime() == -1){ - //the time has been triggered -> timeout - return {{"status", 911}, {"data", ""}}; - } - - delete timer; - return {{"status", reply.value("header").toInt()}, {"data", reply.value("data").toVariant()}}; - -} - -void BaseConn::readyRead() { - - //qDebug() << "ready to ready " << socket->bytesAvailable() << " bytes" ; - QString reply = socket->readAll(); - - //qWarning() << "socket read: " << reply; - - processSocketMessage(reply); -} - -void BaseConn::processSocketMessage(QString message) { - QString startKey = ""; - QString endKey = ""; - - //qWarning() << "... processing message now ... : " << message; - - if(message == ""){ - return; - } - - if((message.startsWith(startKey) && message.endsWith(endKey)) && (message.count(startKey) == 1 && message.count(endKey) == 1)){ - // non-split message ( e.g.: 123456789 - } - else if(!message.contains(endKey) && (!this->readBuffer.isEmpty() || message.startsWith(startKey))){ - // begin of a split message ( e.g.: 123 ) - // or middle of a split message ( e.g.: 456 ) - //qWarning() << "this is a begin or middle of split a message"; - this->readBuffer += message; - return; - } - else if(!message.contains(startKey) && message.endsWith(endKey)) { - // end of a split message ( e.g.: 789 ) - - if(!this->readBuffer.isEmpty()){ - message = readBuffer + message; - readBuffer.clear(); - } - } - else if((message.count(startKey) > 1 || message.count(endKey) > 1) || (message.contains(endKey) && !message.endsWith(endKey) && message.contains(startKey) && !message.startsWith(startKey))) { - // multiple messages in one packet ( e.g.: 123456789987654321 ) - // or multiple message fragments in one message ( e.g.: 56789987654321 or 5678998765 ) - //qDebug() << "detected multiple messages"; - - int startOfSecondMessage = message.lastIndexOf(startKey); - // process first part of message - QString firstMessage = message.left(startOfSecondMessage); - this->processSocketMessage(firstMessage); - // process second part of message - QString secondMessage = message.right(message.length() - startOfSecondMessage); - this->processSocketMessage(secondMessage); - - return; - } - else { - // invalid message - return; - } - - //qWarning() << "... done processing, message: " << message; - this->socketReplyRecieved(message); -} - -void BaseConn::socketReplyRecieved(QString reply) { - reply.replace("", ""); - reply.replace("", ""); - - int id = 0; - - QJsonDocument jsonReply = QJsonDocument::fromJson(reply.toUtf8()); - QJsonObject replyObj = jsonReply.object(); - - if(!replyObj.isEmpty()){ - id = replyObj.value("id").toInt(); - - if(id == -1) { - // this message is an update!! - emit this->gotUpdate(replyObj.toVariantMap()); - return; - } - - // this message is the reply to a command! - for(int i = 0; i < this->waitingRequests.length(); i++){ - if(this->waitingRequests[i].id == id){ - this->waitingRequests[i].reply = replyObj; - if(this->waitingRequests[i].loop != nullptr){ - this->waitingRequests[i].loop->quit(); - } - return; - } - } - } - - latestReadReply = reply; - emit gotUnexpectedReply(reply); -} - -// ------------------------- -// --- updater functions --- -// ------------------------- - -bool BaseConn::updateTime() { - if(abs(this->timeOffset) < 10000) { - // the time is already up-to-date - return true; - } - - QVariantMap ret = this->sendCommand(5001, this->date->currentSecsSinceEpoch()); - qDebug() << ret; - - return ret["status"].toInt() == 200; -} - -bool BaseConn::updateFirmware() { - QString file = ":/ScStwBasestation.sb64"; - QFile f(file); - if (!f.open(QFile::ReadOnly)) return false; - QString fileContents = f.readAll(); - - if(this->firmwareUpToDate) { - return true; - } - - QVariantMap ret = this->sendCommand(5000, fileContents, true, 15000); - - return ret["status"].toInt() == 200; -} - -bool BaseConn::isFirmwareUpToDate() { - QString file = ":/ScStwBasestation.sb64"; - QFile f(file); - if (!f.open(QFile::ReadOnly)) return false; - QString fileContents = f.readAll(); - - QString newFirmwareVersion = fileContents.split("")[1].split("")[0]; - int newFirmwareVersionMajor = newFirmwareVersion.split(".")[0].toInt(); - int newFirmwareVersionMinor = newFirmwareVersion.split(".")[1].toInt(); - int newFirmwareVersionPatch = newFirmwareVersion.split(".")[2].toInt(); - - QString currentFirmwareVersion = this->firmwareVersion; - int currentFirmwareVersionMajor = currentFirmwareVersion.split(".")[0].toInt(); - int currentFirmwareVersionMinor = currentFirmwareVersion.split(".")[1].toInt(); - int currentFirmwareVersionPatch = currentFirmwareVersion.split(".")[2].toInt(); - - return newFirmwareVersionMajor < currentFirmwareVersionMajor || newFirmwareVersionMinor < currentFirmwareVersionMinor || newFirmwareVersionPatch <= currentFirmwareVersionPatch; -} - -// ------------------------ -// --- helper functions --- -// ------------------------ - -int BaseConn::writeRemoteSetting(QString key, QString value) { - QJsonArray requestData; - requestData.append(key); - requestData.append(value); - return this->sendCommand(3000, requestData)["status"].toInt(); -} - -void BaseConn::setIP(const QString &ipAdress){ - this->ip = ipAdress; -} - -QString BaseConn::getIP() const -{ - return(this->ip); -} - -QString BaseConn::getState() const -{ - return(this->state); -} - -void BaseConn::setState(QString newState){ - if(this->state != newState) { - qDebug() << "+--- BaseConn state changed: " << newState; - this->state = newState; - emit stateChanged(); - if(this->state == "disconnected") { - this->deInit(); - } - } -} - -int BaseConn::getProgress() const -{ - return(connection_progress); -} - -bool BaseConn::refreshConnections() { - QVariantMap reply = this->sendCommand(2006); - - if(reply["status"] != 200){ - //handle Error!! - if(reply["status"] == 910){ - this->connections = QVariantList({}); - return true; - } - qDebug() << "+ --- error refreshing connections: " << reply["status"]; - return false; - } - - QVariantList tmpConnections = reply["data"].toList(); - - if(this->connections != reply["data"].toList()){ - this->connections = reply["data"].toList(); - emit this->connectionsChanged(); - } - - return true; - -} - -QVariant BaseConn::getConnections() { - return(connections); - /* - "id": "id of the extention (int)", - "type": "type of the extention (can be: 'STARTPAD', 'TOPPAD')", - "name": "name of the extention", - "ip": "ip-adress of he extention (string)", - "state": "state of the extention (can be: 'disconnected', 'connecting', 'connected')" - */ - //QVariantMap conn = {{"id",0}, {"type","STARTPAD"}, {"name", "startpad1"}, {"ip", "192.168.4.11"}, {"state", "connected"}}; - //QVariantMap conn1 = {{"id",0}, {"type","TOPPAD"}, {"name", "buzzer1"}, {"ip", "192.168.4.10"}, {"state", "connected"}}; - //QVariantList conns = {conn, conn1}; - //return conns; -} - -void BaseConn::setConnections(QVariantList connections) { - if(this->connections != connections){ - this->connections = connections; - emit this->connectionsChanged(); - } -} diff --git a/sources/buzzerconn.cpp b/sources/buzzerconn.cpp deleted file mode 100644 index b3c30aa..0000000 --- a/sources/buzzerconn.cpp +++ /dev/null @@ -1,367 +0,0 @@ -/* - Speed Climbing Stopwatch - Simple Stopwatch for Climbers - Copyright (C) 2018 Itsblue Development - Dorian Zeder - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published - by the Free Software Foundation, version 3 of the License. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see . -*/ - -#include "headers/buzzerconn.h" - -BuzzerConn::BuzzerConn(QObject *parent, QString ip, int port) : QObject(parent) -{ - this->networkManager = new QNetworkAccessManager(); - this->reloadNetworkManager = new QNetworkAccessManager(); - - this->socket = new QTcpSocket(); - - this->date = new QDateTime; - this->latest_button_pressed = 0; - this->connected = false; - - this->ip = ip; - this->port = port; - // "http://192.168.4.1" -} - -bool BuzzerConn::connect() -{ - qDebug() << "connecting..."; - - //wait until the request has finished - QEventLoop loop; - QTimer timer; - - timer.setSingleShot(true); - loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit())); - loop.connect(this->socket, SIGNAL(connected()), &loop, SLOT(quit())); - - timer.start(3000); - this->socket->connectToHost(this->ip, this->port); - loop.exec(); - timer.stop(); - - if(timer.remainingTime() == 0){ - //the time has been triggered -> timeout - return(false); - } - - - QList times = gettimes(2000); - qDebug() << times[0]; - if(times[0] == 200.0){ - this->latest_button_pressed = times[2]; - for(int i=0;i<=100;i++){ - this->connection_progress = i; - if(!calcoffset(this->gettimes(1000))){ - this->connection_progress = 100; - this->connected = false; - return(false); - } - } - this->connected = true; - return(true); - } - else{ - this->connected = false; - return(false); - } -} - -bool BuzzerConn::calcoffset(QList times) -{ - if(times.length() != 3){ - return(false); - } - if(times[0] == 200.0){ - this->latest_button_pressed = times[2]; - double offset = date->currentMSecsSinceEpoch() - times[1]; - if(this->latest_offsets.length()>=100){ - this->latest_offsets.removeFirst(); - } - this->latest_offsets.append(offset); - - double mem = 0; - for(int i=0;ioffset = mem / double(latest_offsets.length()); - qDebug("%20f", this->offset); - return(true); - } - else { - //this->connected = false; - return(false); - } -} - -QList BuzzerConn::gettimes(int timeout) -{ - // QList times; - // ReturnData_t ret = senddata(this->networkManager, QUrl(this->ip), timeout); - // times.append(double(ret.status_code)); - - // if(ret.status_code == 200){ - // ret.text.replace("\n",""); - // ret.text.replace("\r",""); - // QStringList times_cache = ret.text.split("
"); - // times.append(times_cache[0].toDouble()); - // times.append(times_cache[1].toDouble()); - - // return(times); - // } - // else{ - // return(times); - // } - - QList times; - signed long ret; - ret = this->sendCommand("GET_TIMESTAMP", timeout); - if(ret >= 0){ - times.append(double(200)); - times.append(double(ret)); - ret = this->sendCommand("GET_LASTPRESSED", timeout); - if(ret >= 0){ - times.append(double(ret)); - return(times); - } - else { - times[0] = ret; - } - - } - else { - times.append(ret); - } - return(times); - -} - -bool BuzzerConn::buzzer_triggered() -{ - - if(!this->connected){ - return(false); - } - - if(pending_commands.length() > 0){ - QString command = this->pending_commands.first(); - - signed long retval = this->sendCommand(command, 800); - if(retval > 0){ - this->pending_commands.removeFirst(); - } - } - - QList times = this->gettimes(1000); - if(times[0] == 200.0){ - if(times[2] > this->latest_button_pressed){ - this->latest_button_pressed = times[2]; - - return(true); - } - else { - return(false); - } - } - else{ - //this->connected = false; - return(false); - } -} - -bool BuzzerConn::start() -{ - if(!this->connected){ - return(false); - } - QList times = this->gettimes(1000); - if(times[0] == 200.0 && this->connected){ - this->latest_button_pressed = times[2]; - return(true); - } - else{ - this->connected = false; - return(false); - } -} - -double BuzzerConn::get(QString key) -{ - if(key == "offset"){ - return(this->offset); - } - else if (key == "lastpressed") { - return(this->latest_button_pressed); - } - else if( key == "currtime") { - return(this->date->currentMSecsSinceEpoch()); - } - else if( key == "connection_progress") { - return(this->connection_progress); - } - else if( key == "connected") { - if(this->connected){ - return(1); - } - return(0); - } -} - -QString BuzzerConn::test() -{ - ReturnData_t ret = this->senddata(this->networkManager, QUrl("http://www.google.de"), 500); - return(ret.text); -} - -bool BuzzerConn::refresh() -{ - if(!this->connected){ - return(false); - } -// QList times; -// ReturnData_t ret = senddata(this->reloadNetworkManager, QUrl(this->ip), 1000); -// times.append(double(ret.status_code)); - -// if(ret.status_code == 200){ -// ret.text.replace("\n",""); -// ret.text.replace("\r",""); -// QStringList times_cache = ret.text.split("
"); -// times.append(times_cache[0].toDouble()); -// times.append(times_cache[1].toDouble()); -// calcoffset(times); -// return(true); -// } -// else{ -// //this->connected = false; -// return(false); -// } - - if(pending_commands.length() > 0){ - QString command = this->pending_commands.first(); - - signed long retval = this->sendCommand(command, 800); - if(retval > 0){ - this->pending_commands.removeFirst(); - } - } - - //refresh the times - QList ret = this->gettimes(800); - if(ret[0] >= 0){ - this->errors = 0; - return(this->calcoffset(ret)); - } - else { - this->errors ++; - if(this->errors > errors_until_disconnect){ - this->socket->disconnectFromHost(); - this->connected = false; - } - return(false); - } - -} - -ReturnData_t BuzzerConn::senddata(QNetworkAccessManager * NetMan, QUrl serviceUrl, int timeout) -{ - - ReturnData_t ret; //this is a custom type to store the returned data - // Call the webservice - - QNetworkRequest request(serviceUrl); - request.setHeader(QNetworkRequest::ContentTypeHeader, - "application/x-www-form-urlencoded"); - - //send a POST request with the given url and data to the server - QUrlQuery pdata; - QNetworkReply* reply; - - //wait until the request has finished - QEventLoop loop; - QTimer timer; - - timer.setSingleShot(true); - loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit())); - loop.connect(NetMan, SIGNAL(finished(QNetworkReply*)), SLOT(quit())); - - timer.start(timeout); - reply = NetMan->post(request, pdata.toString(QUrl::FullyEncoded).toUtf8()); - loop.exec(); - timer.stop(); - - //get the status code - QVariant status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute); - - ret.status_code = status_code.toInt(); - if(ret.status_code == 0){ //if the statuscode is zero, the connecion to the server was not possible - ret.status_code = 444; - } - //get the full text response - ret.text = QString::fromUtf8(reply->readAll()); - - //return the data - return(ret); -} - -signed long BuzzerConn::sendCommand(QString command, int timeout){ - - //if there is any data in the storage, clear it - if(this->socket->bytesAvailable() > 0){ - this->socket->readAll(); - } - - //send request to the socket server - QByteArray arrBlock; - QDataStream out(&arrBlock, QIODevice::WriteOnly); - //out.setVersion(QDataStream::Qt_5_10); - out << quint16(0) << command; - - out.device()->seek(0); - out << quint16(arrBlock.size() - sizeof(quint16)); - - this->socket->write(arrBlock); - - //now wait for the server of the sensor to answer - QEventLoop loop; - QTimer timer; - - timer.setSingleShot(true); - loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit())); - loop.connect(socket, SIGNAL(readyRead()), &loop, SLOT(quit())); - timer.start(timeout); - loop.exec(); - - //loop finished - timer.stop(); - if(timer.remainingTime() == 0){ - //the time has been triggered -> timeout - return(-1); - } - - //if the data is not 4 bites long if is invalid -> clear and terminate - if(this->socket->bytesAvailable() != 4){ - this->socket->readAll(); - return(-2); - } - long data = 0; - this->socket->read((char*)&data,4); - - qDebug() << data; - qDebug() << this->socket->bytesAvailable(); - - return data; -} - -void BuzzerConn::appendCommand(QString command){ - this->pending_commands.append(command); -} diff --git a/sources/climbingrace.cpp b/sources/climbingrace.cpp deleted file mode 100644 index f8773b3..0000000 --- a/sources/climbingrace.cpp +++ /dev/null @@ -1,649 +0,0 @@ -#include "headers/climbingrace.h" - -/* - * manages: - * - global state - * - timers - * - sounds - * - next start action - * - next start action delay progress - * - settings (remote and local) - */ - -ClimbingRace::ClimbingRace(QObject *parent) : QObject(parent) -{ - this->state = IDLE; - this->mode = LOCAL; - - this->appSettings = new AppSettings(this); - this->baseConn = new BaseConn(this); - - this->baseConn->setIP(pGlobalAppSettings->loadSetting("baseStationIpAdress")); - connect(this->baseConn, &BaseConn::stateChanged, this, &ClimbingRace::baseStationStateChanged); - connect(this->baseConn, &BaseConn::stateChanged, this, &ClimbingRace::refreshMode); - connect(this->baseConn, &BaseConn::connectionsChanged, this, &ClimbingRace::baseStationConnectionsChanged); - connect(this->baseConn, &BaseConn::gotUpdate, this, &ClimbingRace::handleBaseStationUpdate); - connect(this->baseConn, &BaseConn::propertiesChanged, this, &ClimbingRace::baseStationPropertiesChanged); - - this->speedTimers.append( new SpeedTimer(this) ); - - this->player = new QMediaPlayer; - this->date = new QDateTime; - - this->nextStartActionTimer = new QTimer(this); - nextStartActionTimer->setSingleShot(true); - - this->timerTextRefreshTimer = new QTimer(this); - this->timerTextRefreshTimer->setInterval(1); - this->timerTextRefreshTimer->setSingleShot(true); - this->timerTextRefreshTimer->connect(this->timerTextRefreshTimer, &QTimer::timeout, this, &ClimbingRace::refreshTimerText); - this->refreshTimerText(); -} - -// -------------------------- -// --- Main Functionality --- -// -------------------------- - -int ClimbingRace::startRace() { - - if(this->state != IDLE) { - return 904; - } - - qDebug() << "+ --- starting race"; - - int returnCode = 900; - - switch (this->mode) { - case LOCAL: - { - - this->setState(STARTING); - - this->nextStartAction = None; - this->playSoundsAndStartRace(); - - returnCode = 200; - - break; - } - case REMOTE: - { - QVariantMap reply = this->baseConn->sendCommand(1000); - - if(reply["status"] != 200){ - //handle Error!! - returnCode = reply["status"].toInt(); - } - else { - - returnCode = 200; - - } - - break; - } - } - - return returnCode; -} - -int ClimbingRace::stopRace(int type) { - - if(this->state != RUNNING && this->state != STARTING) { - return 904; - } - - // type can be: - // 0: stopp - // 1: cancel - // 2: fail (fase start) - - qDebug() << "+ --- stopping race"; - - int returnCode = 900; - - switch (this->mode) { - case LOCAL: - { - - if(type == 1){ - this->nextStartActionTimer->stop(); - this->player->stop(); - this->nextStartAction = None; - } - - returnCode = this->speedTimers[0]->stop(type) ? 200:904; - - if(returnCode == 200) { - this->setState(STOPPED); - } - - break; - } - case REMOTE: - { - QVariantMap reply = this->baseConn->sendCommand(1001); - - if(reply["status"] != 200){ - returnCode = reply["status"].toInt(); - } - else { - returnCode = 200; - } - - break; - } - } - - return returnCode; -} - -int ClimbingRace::resetRace() { - - if(this->state != STOPPED) { - return 904; - } - - qDebug() << "+ --- resetting race"; - - int returnCode = 900; - - - switch (this->mode) { - case LOCAL: - { - returnCode = this->speedTimers[0]->reset() ? 200:904; - - if(returnCode == 200){ - this->setState(IDLE); - } - - break; - } - case REMOTE: - { - - QVariantMap reply = this->baseConn->sendCommand(1002); - - if(reply["status"] != 200){ - //handle Error!! - returnCode = reply["status"].toInt(); - } - else { - returnCode = 200; - } - - break; - } - } - - return returnCode; -} - -// ------------------------- -// --- Base Station sync --- -// ------------------------- - -/** - * @brief ClimbingRace::handleBaseStationUpdate - * - * Function to handle a update, sent by the base station, which indicates - * that some remote value (like a state) has changed - * - * @param data - */ -void ClimbingRace::handleBaseStationUpdate(QVariant data) { - //qDebug() << "got update: " << data; - int header = data.toMap()["header"].toInt(); - switch (header) { - case 9000: - { - // the remote race state has changed - this->setState( raceState( data.toMap()["data"].toInt() ) ); - break; - } - case 9001: - { - // the remote timers have changed - this->refreshRemoteTimers(data.toMap()["data"].toList()); - break; - } - case 9002: - { - // the extension connections have changed - this->baseConn->setConnections(data.toMap()["data"].toList()); - break; - } - case 9003: - { - // the next start action has changed - this->nextStartActionTotalDelay = data.toMap()["data"].toMap()["nextActionDelay"].toDouble(); - this->nextStartActionDelayStartedAt = this->date->currentMSecsSinceEpoch() - (this->nextStartActionTotalDelay * data.toMap()["data"].toMap()["nextActionDelayProg"].toDouble()); - this->nextStartAction = NextStartAction( data.toMap()["data"].toMap()["nextAction"].toInt() ); - - emit this->nextStartActionChanged(); - } - - } -} - -bool ClimbingRace::refreshRemoteTimers(QVariantList timers) { - - if(timers.length() != speedTimers.length()){ - // local timers are out of sync - - // delete all current timers - foreach(SpeedTimer * locTimer, this->speedTimers){ - delete locTimer; - } - - speedTimers.clear(); - - foreach(QVariant remTimer, timers){ - // create a local timer for each remote timer - this->speedTimers.append(new SpeedTimer(this)); - } - } - - foreach(QVariant remTimer, timers){ - int currId = remTimer.toMap()["id"].toInt(); - speedTimers[currId]->startTime = this->date->currentMSecsSinceEpoch() - remTimer.toMap()["currTime"].toDouble(); - speedTimers[currId]->stoppedTime = remTimer.toMap()["currTime"].toDouble(); - speedTimers[currId]->reactionTime = remTimer.toMap()["reactTime"].toDouble(); - - speedTimers[currId]->setState(SpeedTimer::timerState(remTimer.toMap()["state"].toInt())); - } - - return true; - -} - -// ------------------------ -// --- helper functions --- -// ------------------------ - -void ClimbingRace::playSoundsAndStartRace() { - qDebug() << "next Action: " << nextStartAction; - - nextStartActionTimer->disconnect(nextStartActionTimer, SIGNAL(timeout()), this, SLOT(playSoundsAndStartRace())); - - switch (this->nextStartAction) { - case AtYourMarks: - { - if(!playSound("qrc:/sounds/at_marks_1.wav")){ - return; - } - if(appSettings->loadSetting("ready_en") == "true"){ - nextStartAction = Ready; - nextStartActionTimer->setInterval(appSettings->loadSetting("ready_delay").toInt() <= 0 ? 1:appSettings->loadSetting("ready_delay").toInt()); - } - else{ - nextStartAction = Start; - nextStartActionTimer->setInterval(1); - } - - break; - } - case Ready: - { - if(!playSound("qrc:/sounds/ready_1.wav")){ - return; - } - nextStartAction = Start; - nextStartActionTimer->setInterval(1); - - break; - } - case Start: - { - if(!playSound("qrc:/sounds/IFSC_STARTSIGNAL_SINE.wav")){ - return; - } - nextStartAction = None; - nextStartActionTimer->disconnect(nextStartActionTimer, SIGNAL(timeout()), this, SLOT(playSoundsAndStartRace())); - - this->setState(RUNNING); - speedTimers[0]->start(); - - emit this->nextStartActionChanged(); - - return; - } - case None: - { - this->speedTimers[0]->setState(SpeedTimer::STARTING); - if(appSettings->loadSetting("at_marks_en") == "true"){ - nextStartAction = AtYourMarks; - nextStartActionTimer->setInterval(appSettings->loadSetting("at_marks_delay").toInt() <= 0 ? 1:appSettings->loadSetting("at_marks_delay").toInt()); - } - else if(appSettings->loadSetting("ready_en") == "true"){ - nextStartAction = Ready; - nextStartActionTimer->setInterval(appSettings->loadSetting("ready_delay").toInt() <= 0 ? 1:appSettings->loadSetting("ready_delay").toInt()); - } - else{ - nextStartAction = Start; - nextStartActionTimer->setInterval(1); - } - - break; - } - } - - emit this->nextStartActionChanged(); - - nextStartActionTimer->connect(nextStartActionTimer, SIGNAL(timeout()), this, SLOT(playSoundsAndStartRace())); - nextStartActionTimer->start(); -} - -bool ClimbingRace::playSound(QString path) { - - player->setMedia(QUrl(path)); - player->setVolume(50); - player->play(); - - QTimer timer; - timer.setInterval(1); - timer.setSingleShot(true); - - QEventLoop loop; - loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit())); - - while (player->mediaStatus() == QMediaPlayer::LoadingMedia || player->mediaStatus() == QMediaPlayer::BufferingMedia || player->mediaStatus() == QMediaPlayer::BufferedMedia) { - timer.start(); - loop.exec(); - } - - if(player->mediaStatus() == QMediaPlayer::EndOfMedia){ - return true; - } - else { - return false; - } -} - -void ClimbingRace::setState(raceState newState) { - - if(newState != this->state) { - this->state = newState; - this->stateChanged(newState); - } -} - -void ClimbingRace::refreshMode() { - raceMode newMode; - if(this->baseConn->state == "connected"){ - newMode = REMOTE; - } - else { - newMode = LOCAL; - } - - if(this->mode != newMode){ - - if(newMode == LOCAL){ - // if the new mode is local -> connection to base station has been lost - - // reset race - // reset state - this->setState(IDLE); - - // reset timers - // go back to one timer - for (int i = 0;ispeedTimers.length();i++) { - delete this->speedTimers[i]; - } - - this->speedTimers.clear(); - - this->speedTimers.append(new SpeedTimer); - - // reset base conn - // clear extensions - this->baseConn->connections.clear(); - } - - this->mode = newMode; - emit this->modeChanged(); - } - -} - -void ClimbingRace::refreshTimerText() { - - // --- refresh timer text --- - - QVariantList newTimerTextList; - - foreach(SpeedTimer * timer, this->speedTimers){ - QVariantMap timerMap = {{"text",timer->getText()}, {"reacttime", timer->reactionTime}, {"state", timer->getState()}, {"id", this->speedTimers.indexOf(timer)}}; - newTimerTextList.append(timerMap); - } - - if(newTimerTextList != this->qmlTimers){ - this->qmlTimers = newTimerTextList; - emit timerTextChanged(); - } - - // --- refresh next start action delay progress --- - double nextStartActionRemainingDelay = 0; - - switch (this->mode) { - case LOCAL: { - - // get remaining and total next start action delay time - if(nextStartAction == 0){ - this->nextStartActionTotalDelay = appSettings->loadSetting("at_marks_delay").toDouble(); - } - else if (nextStartAction == 1) { - this->nextStartActionTotalDelay = appSettings->loadSetting("ready_delay").toDouble(); - } - - nextStartActionRemainingDelay = this->nextStartActionTimer->remainingTime(); - - break; - } - case REMOTE: { - - // calculate remaining next start action delay time - nextStartActionRemainingDelay = this->nextStartActionTotalDelay - ( this->date->currentMSecsSinceEpoch() - this->nextStartActionDelayStartedAt ); - break; - } - } - - // calculate next start action delay progress - if(nextStartActionRemainingDelay > 0){ - this->nextStartActionDelayProgress = nextStartActionRemainingDelay / this->nextStartActionTotalDelay; - emit this->nextStartActionDelayProgressChanged(); - } - else { - this->nextStartActionDelayProgress = 0; - emit this->nextStartActionDelayProgressChanged(); - } - - - /*if (this->mode == REMOTE && this->state == IDLE) { - this->nextStartActionDelayProgress = 0; - emit this->nextStartActionDelayProgressChanged(); - }*/ - - this->timerTextRefreshTimer->start(); -} - -bool ClimbingRace::pairConnectedUsbExtensions() { - QVariantMap ret = this->baseConn->sendCommand(5002, "", 10000); - qDebug() << ret; - return ret["status"] == 200; -} - -// - athlete management - - -QVariant ClimbingRace::getAthletes() { - QVariantMap reply = this->baseConn->sendCommand(4003); - - if(reply["status"] != 200){ - //handle Error!! - qDebug() << "+ --- error getting athletes: " << reply["status"]; - return false; - } - - QVariantMap tmpAthletes = reply["data"].toMap(); - - //qDebug() << tmpAthletes; - - return tmpAthletes; -} - -bool ClimbingRace::createAthlete(QString userName, QString fullName) { - - QVariant requestData = QVariantMap({{"fullName", fullName}, {"userName", userName}}); - - QVariantMap reply = this->baseConn->sendCommand(4001, requestData.toJsonValue()); - - if(reply["status"] != 200){ - //handle Error!! - qDebug() << "+ --- error creating athlete: " << reply["status"]; - return false; - } - - return true; -} - -bool ClimbingRace::deleteAthlete( QString userName ){ - - QVariant requestData = QVariantMap({{"userName", userName}}); - - QVariantMap reply = this->baseConn->sendCommand(4002, requestData.toJsonValue()); - - if(reply["status"] != 200){ - //handle Error!! - qDebug() << "+ --- error deleting athlete: " << reply["status"]; - return false; - } - - return true; - -} - -bool ClimbingRace::selectAthlete( QString userName, int timerId ){ - - QVariant requestData = QVariantMap({{"userName", userName}, {"timerId", timerId}}); - - QVariantMap reply = this->baseConn->sendCommand(4000, requestData.toJsonValue()); - - if(reply["status"] != 200){ - //handle Error!! - qDebug() << "+ --- error selecting athlete: " << reply["status"]; - return false; - } - - return true; - -} - -QVariant ClimbingRace::getResults( QString userName ){ - QVariantMap reply = this->baseConn->sendCommand(4004, userName); - - if(reply["status"] != 200){ - //handle Error!! - qDebug() << "+ --- error getting results: " << reply["status"]; - return false; - } - - QVariantList tmpAthletes = reply["data"].toList(); - - //qDebug() << tmpAthletes; - - return tmpAthletes; -} - -// ------------------------- -// --- functions for qml --- -// ------------------------- - -int ClimbingRace::getState() { - return this->state; -} - -int ClimbingRace::getMode() { - return this->mode; -} - -QVariant ClimbingRace::getTimerTextList() { - return this->qmlTimers; -} - -double ClimbingRace::getNextStartActionDelayProgress() { - return this->nextStartActionDelayProgress; -} - -int ClimbingRace::getNextStartAction() { - return this->nextStartAction; -} - -void ClimbingRace::writeSetting(QString key, QVariant value) { - this->refreshMode(); - - if(this->mode == REMOTE && ( this->remoteSettings.contains(key) || this->remoteOnlySettings.contains(key) ) ){ - this->baseConn->writeRemoteSetting(key, value.toString()); - } - else if(!this->remoteOnlySettings.contains(key)){ - this->appSettings->writeSetting(key, value); - } -} - -QString ClimbingRace::readSetting(QString key) { - this->refreshMode(); - - if(this->mode == REMOTE && ( this->remoteSettings.contains(key) || this->remoteOnlySettings.contains(key) )){ - QVariantMap reply = this->baseConn->sendCommand(3001, key); - if(reply["status"] != 200){ - return "false"; - } - return reply["data"].toString(); - } - else if(!this->remoteOnlySettings.contains(key)){ - return this->appSettings->loadSetting(key); - } - else { - return "false"; - } -} - -void ClimbingRace::connectBaseStation() { - this->reloadBaseStationIpAdress(); - this->baseConn->connectToHost(); -} - -void ClimbingRace::disconnectBaseStation() { - this->baseConn->closeConnection(); -} - -QString ClimbingRace::getBaseStationState() { - return this->baseConn->getState(); -} - -QVariant ClimbingRace::getBaseStationConnections() { - return baseConn->getConnections(); -} - -QVariantMap ClimbingRace::getBaseStationProperties() { - QVariantMap firmware = {{"version", this->baseConn->firmwareVersion}, {"upToDate", this->baseConn->firmwareUpToDate}}; - return {{"firmware", firmware}, {"timeOffset", this->baseConn->timeOffset}}; -} - -bool ClimbingRace::updateBasestationFirmware() { - return this->baseConn->updateFirmware(); -} - -bool ClimbingRace::updateBasestationTime() { - return this->baseConn->updateTime(); -} - -bool ClimbingRace::reloadBaseStationIpAdress() { - if(this->baseConn->state == "disconnected"){ - this->baseConn->setIP(pGlobalAppSettings->loadSetting("baseStationIpAdress")); - return true; - } - return false; -} diff --git a/sources/main.cpp b/sources/main.cpp index 9244717..a4efc7b 100644 --- a/sources/main.cpp +++ b/sources/main.cpp @@ -17,6 +17,7 @@ #include #include + #include #include #include #include @@ -35,6 +36,8 @@ #include #include #include +#include +#include #include #include @@ -44,94 +47,38 @@ #include #include #include -//#include -#ifdef Q_OS_ANDROID -#include -#endif -#include "headers/sqlstoragemodel.h" -#include "headers/sqlprofilemodel.h" -#include "headers/appsettings.h" -#include "headers/baseconn.h" -#include "headers/speedtimer.h" -#include "headers/climbingrace.h" -#include "headers/apptheme.h" + +#include "headers/scstwappsettings.h" +//#include "headers/speedtimer.h" +//#include "headers/climbingrace.h" +#include "headers/scstwappbackend.h" +#include #include -static void connectToDatabase() -{ - QSqlDatabase database = QSqlDatabase::database(); - if (!database.isValid()) { - database = QSqlDatabase::addDatabase("QSQLITE"); - if (!database.isValid()) - qFatal("Cannot add database: %s", qPrintable(database.lastError().text())); - } - - const QDir writeDir = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation); - - if (!writeDir.mkpath(".")) - qFatal("Failed to create writable directory at %s", qPrintable(writeDir.absolutePath())); - - // Ensure that we have a writable location on all devices. - const QString fileName = writeDir.absolutePath() + "/chat-database.sqlite3"; - //QFile::remove(fileName); - // When using the SQLite driver, open() will create the SQLite database if it doesn't exist. - database.setDatabaseName(fileName); - if (!database.open()) { - QFile::remove(fileName); - qFatal("Cannot open database: %s", qPrintable(database.lastError().text())); - - } -} - int main(int argc, char *argv[]) { QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling); QGuiApplication app(argc, argv); -#ifdef Q_OS_ANDROID - //set the standard volume to media - QAndroidJniObject jactivity=QtAndroid::androidActivity(); - if(jactivity.isValid()) - jactivity.callMethod("setVolumeControlStream","(I)V",3); + // setup speed backend + qmlRegisterType("de.itsblue.ScStwApp", 2, 0, "SpeedBackend"); + qmlRegisterType("de.itsblue.ScStwApp", 2, 0, "ScStwAppSettings"); - //set statusbar color - QtAndroid::runOnAndroidThread([=]() - { - QAndroidJniObject window = QtAndroid::androidActivity().callObjectMethod("getWindow", "()Landroid/view/Window;"); - window.callMethod("addFlags", "(I)V", 0x80000000); - window.callMethod("clearFlags", "(I)V", 0x04000000); - //window.callMethod("setStatusBarColor", "(I)V", 0x202227); // Desired statusbar color - //QAndroidJniObject decorView = window.callObjectMethod("getDecorView", "()Landroid/view/View;"); - //decorView.callMethod("setSystemUiVisibility", "(I)V", 0x00002000); - }); -#endif - - connectToDatabase(); - - AppSettings * pAppSettings = new AppSettings(); - - //setup the sql storage model as a qml model - qmlRegisterType("com.itsblue.speedclimbingstopwatch", 1, 0, "SqlProfileModel"); - qmlRegisterType("com.itsblue.speedclimbingstopwatch", 1, 0, "SqlStorageModel"); - - // setup speed backend and App themes - qmlRegisterType("com.itsblue.speedclimbingstopwatch", 2, 0, "SpeedBackend"); - qmlRegisterType("com.itsblue.speedclimbingstopwatch", 2, 0, "AppTheme"); + qRegisterMetaType("ScStwAppSettings::BaseStationSetting"); QQmlApplicationEngine engine; - engine.load(QUrl(QStringLiteral("qrc:/main.qml"))); - QQmlContext *context = engine.rootContext(); + ScStwLibraries::init(); + ScStwLibraries::initStyling(&engine); - // stup app settings - context->setContextProperty("_cppAppSettings", pAppSettings); + const QUrl url(QStringLiteral("qrc:/main.qml")); + QObject::connect(&engine, &QQmlApplicationEngine::objectCreated, + &app, [url](QObject *obj, const QUrl &objUrl) { + if (!obj && url == objUrl) + QCoreApplication::exit(-1); + }, Qt::QueuedConnection); + engine.load(url); - if (engine.rootObjects().isEmpty()) - return -1; - - int iRet = 0; - iRet = app.exec(); - - return iRet; + return app.exec(); } diff --git a/sources/scstwappbackend.cpp b/sources/scstwappbackend.cpp new file mode 100644 index 0000000..e196798 --- /dev/null +++ b/sources/scstwappbackend.cpp @@ -0,0 +1,106 @@ +#include "../headers/scstwappbackend.h" + +ScStwAppBackend::ScStwAppBackend(QObject *parent) : QObject(parent) +{ +} + +// ------------------------ +// --- helper functions --- +// ------------------------ + +void ScStwAppBackend::setScStwClient(ScStwClient *client) { + if(client != this->scStwClient) { + this->scStwClient = client; + emit this->scStwClientChanged(); + } +} + +// - athlete management - + +// TODO: move to client +QVariant ScStwAppBackend::getAthletes() { + QVariantMap reply = this->scStwClient->sendCommand(4003); + + if(reply["status"] != 200){ + //handle Error!! + qDebug() << "+ --- error getting athletes: " << reply["status"]; + return false; + } + + QVariantMap tmpAthletes = reply["data"].toMap(); + + //qDebug() << tmpAthletes; + + return tmpAthletes; +} + +bool ScStwAppBackend::createAthlete(QString userName, QString fullName) { + + QVariant requestData = QVariantMap({{"fullName", fullName}, {"userName", userName}}); + + QVariantMap reply = this->scStwClient->sendCommand(4001, requestData.toJsonValue()); + + if(reply["status"] != 200){ + //handle Error!! + qDebug() << "+ --- error creating athlete: " << reply["status"]; + return false; + } + + return true; +} + +bool ScStwAppBackend::deleteAthlete( QString userName ){ + + QVariant requestData = QVariantMap({{"userName", userName}}); + + QVariantMap reply = this->scStwClient->sendCommand(4002, requestData.toJsonValue()); + + if(reply["status"] != 200){ + //handle Error!! + qDebug() << "+ --- error deleting athlete: " << reply["status"]; + return false; + } + + return true; + +} + +bool ScStwAppBackend::selectAthlete( QString userName, int timerId ){ + + QVariant requestData = QVariantMap({{"userName", userName}, {"timerId", timerId}}); + + QVariantMap reply = this->scStwClient->sendCommand(4000, requestData.toJsonValue()); + + if(reply["status"] != 200){ + //handle Error!! + qDebug() << "+ --- error selecting athlete: " << reply["status"]; + return false; + } + + return true; + +} + +QVariant ScStwAppBackend::getResults( QString userName ){ + QVariantMap reply = this->scStwClient->sendCommand(4004, userName); + + if(reply["status"] != 200){ + //handle Error!! + qDebug() << "+ --- error getting results: " << reply["status"]; + return false; + } + + QVariantList tmpAthletes = reply["data"].toList(); + + //qDebug() << tmpAthletes; + + return tmpAthletes; +} + +// ------------------------- +// --- functions for qml --- +// ------------------------- + +ScStwClient* ScStwAppBackend::getScStwClient() { + return this->scStwClient; +} diff --git a/sources/scstwappsettings.cpp b/sources/scstwappsettings.cpp new file mode 100644 index 0000000..abacf85 --- /dev/null +++ b/sources/scstwappsettings.cpp @@ -0,0 +1,46 @@ +/* + Speed Climbing Stopwatch - Simple Stopwatch for Climbers + Copyright (C) 2018 Itsblue Development - Dorian Zeder + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published + by the Free Software Foundation, version 3 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . +*/ + +#include "headers/scstwappsettings.h" + +ScStwAppSettings * pGlobalAppSettings = nullptr; + +ScStwAppSettings::ScStwAppSettings(QObject *parent) : ScStwAppSettings (nullptr, parent) +{ +} + +ScStwAppSettings::ScStwAppSettings(ScStwClient * client, QObject* parent) + :ScStwRemoteSettings(client, parent) +{ + this->registerKeyLevelConverters(ScStwAppSettings::KeyLevel, &ScStwAppSettings::keyToString, &ScStwAppSettings::keyToType); + + this->setDefaultSetting(ScStwAppSettings::AppThemeSetting, "Light"); + this->setDefaultSetting(ScStwAppSettings::BaseStationIpSetting, "192.168.4.1"); +} + +QVariant ScStwAppSettings::readSetting(AppInternalSetting key) { + return this->readSetting(key, 1); +} + +bool ScStwAppSettings::writeSetting(AppInternalSetting key, QVariant value) { + return this->writeSetting(key, 1, value); +} + +bool ScStwAppSettings::setDefaultSetting(AppInternalSetting key, QVariant defaultValue) { + return this->setDefaultSetting(key, 1, defaultValue); +} + diff --git a/sources/speedtimer.cpp b/sources/speedtimer.cpp deleted file mode 100644 index 40c9392..0000000 --- a/sources/speedtimer.cpp +++ /dev/null @@ -1,211 +0,0 @@ -#include "headers/speedtimer.h" - -SpeedTimer::SpeedTimer(QObject *parent) : QObject(parent) -{ - - this->date = new QDateTime; - - this->startTime = 0; - this->stopTime = 0; - this->stoppedTime = 0; - this->reactionTime = 0; - this->state = IDLE; -} - -bool SpeedTimer::start(bool force) { - if(this->state != STARTING && !force){ - return false; - } - qDebug() << "starting timer"; - if(!force){ - this->stopTime = 0; - this->stoppedTime = 0; - this->reactionTime = 0; - this->startTime = this->date->currentMSecsSinceEpoch(); - } - - this->setState(RUNNING); - - return true; -} - -bool SpeedTimer::stop(int type, bool force) { - - // type can be: - // 0: stopped - // 1: cancelled - // 2: failed (fase start) - - if( ( this->state != SpeedTimer::STARTING && this->state != SpeedTimer::RUNNING && this->state ) && !force ){ - return false; - } - - //qDebug() << "Stopping: " << "start Time: " << startTime << " stopTime: " << stopTime << " stoppedTime: " << stoppedTime << " reactionTime: " << reactionTime; - - switch (type) { - case 0: - { - this->stopTime = this->date->currentMSecsSinceEpoch(); - this->stoppedTime = this->stopTime - this->startTime; - this->setState(WON); - break; - } - case 1: - { - this->stoppedTime = 0; - this->setState(CANCELLED); - break; - } - case 2: - { - this->stoppedTime = this->reactionTime; - this->setState(FAILED); - break; - } - } - - qDebug() << "Stopped: " << "start Time: " << startTime << " stopTime: " << stopTime << " stoppedTime: " << stoppedTime << " reactionTime: " << reactionTime; - - return true; - //this->startPad->appendCommand("SET_LED_STARTING"); -} - -bool SpeedTimer::reset(bool force){ - if( ( this->state < WON ) && !force){ - return false; - } - - this->startTime = 0; - this->stopTime = 0; - this->stoppedTime = 0; - this->reactionTime = 0; - this->setState(IDLE); - - return true; - //this->startPad->appendCommand("SET_LED_STARTING"); -} - -void SpeedTimer::setState(timerState newState){ - if(this->state != newState){ - this->state = newState; - qDebug() << "+--- timer state changed: " << newState; - emit this->stateChanged(newState); - } -} - -QString SpeedTimer::getState(){ - switch(state){ - case IDLE: - return "IDLE"; - case STARTING: - return "STARTING"; - case WAITING: - return "WAITING"; - case RUNNING: - return "RUNNING"; - case WON: - return "WON"; - case LOST: - return "LOST"; - case FAILED: - return "FAILED"; - case CANCELLED: - return "CANCELLED"; - case DISABLED: - return "DISABLED"; - } - return "ERROR"; -} - -double SpeedTimer::getCurrTime() { - double currTime; - if(this->state == RUNNING && this->startTime > 0){ - currTime = this->date->currentMSecsSinceEpoch() - this->startTime; - } - else { - currTime = this->stoppedTime; - } - - return(currTime); -} - -QString SpeedTimer::getText() { - //qDebug() << this->getState(); - QString newText; - switch (this->state) { - case SpeedTimer::IDLE: - newText = "0.000 sec"; - break; - case SpeedTimer::STARTING: - newText = "0.000 sec"; - break; - case SpeedTimer::WAITING: - newText = "please wait..."; - break; - case SpeedTimer::RUNNING: - newText = QString::number( this->getCurrTime() / 1000.0, 'f', 3 ) + " sec"; - break; - case SpeedTimer::WON: - newText = QString::number( this->stoppedTime / 1000.0, 'f', 3 ) + " sec"; - break; - case SpeedTimer::LOST: - newText = QString::number( this->stoppedTime / 1000.0, 'f', 3 ) + " sec"; - break; - case SpeedTimer::FAILED: - newText = "false start"; - break; - case SpeedTimer::CANCELLED: - newText = "cancelled"; - break; - case SpeedTimer::DISABLED: - newText = "---"; - break; - } - - return newText; -} - -void SpeedTimer::delay(int mSecs){ - QEventLoop loop; - QTimer timer; - - timer.setSingleShot(true); - // quit the loop when the timer times out - loop.connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit())); - //quit the loop when the connection was established - // start the timer before starting to connect - timer.start(mSecs); - //connect - - //wait for the connection to finish (programm gets stuck in here) - loop.exec(); -} - -SpeedTimer::timerState SpeedTimer::stateFromString(QString state){ - - if(state == "IDLE"){ - return IDLE; - } - else if (state == "STARTING") { - return STARTING; - } - else if (state == "RUNNING") { - return RUNNING; - } - else if (state == "WON") { - return WON; - } - else if (state == "LOST") { - return LOST; - } - else if (state == "FAILED") { - return FAILED; - } - else if(state == "DISABLED") { - return DISABLED; - } - else { - return CANCELLED; - } -} - diff --git a/sources/sqlprofilemodel.cpp b/sources/sqlprofilemodel.cpp deleted file mode 100644 index 1bd98d6..0000000 --- a/sources/sqlprofilemodel.cpp +++ /dev/null @@ -1,96 +0,0 @@ -/* - Speed Climbing Stopwatch - Simple Stopwatch for Climbers - Copyright (C) 2018 Itsblue Development - Dorian Zeder - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published - by the Free Software Foundation, version 3 of the License. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see . -*/ - -#include "headers/sqlprofilemodel.h" - -static void createTable() -{ - if (QSqlDatabase::database().tables().contains(QStringLiteral("Contacts"))) { - // The table already exists; we don't need to do anything. - return; - } - - QSqlQuery query; - - //creat eth etable to store the profiles - if (!query.exec( - "CREATE TABLE IF NOT EXISTS `profiles` ( " - " `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE," - " `name` TEXT NOT NULL " - " );")) { - qFatal("Failed to query database: %s", qPrintable(query.lastError().text())); - } - - //create the table to store the times - if (!query.exec( - "CREATE TABLE IF NOT EXISTS `times` (" - " `id` INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT UNIQUE," - " `profileid` INTEGER NOT NULL," - " `time` INTEGER NOT NULL, " - " `timestamp` INTEGER NOT NULL" - " );")) { - qFatal("Failed to query database: %s", qPrintable(query.lastError().text())); - } -} - -SqlProfileModel::SqlProfileModel(QObject *parent) : QSqlTableModel(parent) -{ - qDebug("ProfileModel constructor"); - createTable(); - setTable("profiles"); - setEditStrategy(QSqlTableModel::OnManualSubmit); - select(); -} - -QVariant SqlProfileModel::data(const QModelIndex &index, int role) const -{ - if (role < Qt::UserRole) - return QSqlTableModel::data(index, role); - - const QSqlRecord sqlRecord = record(index.row()); - return sqlRecord.value(role - Qt::UserRole); -} - -QHash SqlProfileModel::roleNames() const -{ - QHash names; - names[Qt::UserRole + 0] = "id"; - names[Qt::UserRole + 1] = "name"; - - return names; -} - -bool SqlProfileModel::append(QString name) -{ - qDebug() << name; - QSqlRecord newRecord = record(); - newRecord.setValue("name", name); - - if (!insertRecord(rowCount(), newRecord)) { - qWarning() << "Failed to add profile:" << lastError().text(); - return(false); - } - - submitAll(); - return(true); -} - -void SqlProfileModel::remove(int row) -{ - removeRows(row, 1); - submitAll(); -} diff --git a/sources/sqlstoragemodel.cpp b/sources/sqlstoragemodel.cpp deleted file mode 100644 index d5906c8..0000000 --- a/sources/sqlstoragemodel.cpp +++ /dev/null @@ -1,43 +0,0 @@ -/* - Speed Climbing Stopwatch - Simple Stopwatch for Climbers - Copyright (C) 2018 Itsblue Development - Dorian Zeder - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published - by the Free Software Foundation, version 3 of the License. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see . -*/ - -#include "headers/sqlstoragemodel.h" - -SqlStorageModel::SqlStorageModel(QObject *parent) : QSqlTableModel(parent) -{ - qDebug("ProfileModel constructor"); - setTable("times"); - select(); -} - -QVariant SqlStorageModel::data(const QModelIndex &index, int role) const -{ - if (role < Qt::UserRole) - return QSqlTableModel::data(index, role); - - const QSqlRecord sqlRecord = record(index.row()); - return sqlRecord.value(role - Qt::UserRole); -} - -QHash SqlStorageModel::roleNames() const -{ - QHash names; - names[Qt::UserRole + 0] = "id"; - names[Qt::UserRole + 1] = "name"; - - return names; -}