initial commit to split repos

CMakeLists.txt

@@ -0,0 +1,81 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(WeatherRoutes VERSION 0.1 LANGUAGES CXX)
+
+# Define versioning information
+set(VERSION_CODE 1)  # Change this to your desired version code
+set(VERSION_NAME "0.1")  # Your version name
+
+# Include this in the Android section
+set(ANDROID_PACKAGE_NAME "com.example.weatherroutes")
+set(ANDROID_VERSION_CODE ${VERSION_CODE})
+set(ANDROID_VERSION_NAME ${VERSION_NAME})
+
+set(CMAKE_ANDROID_MANIFEST "${CMAKE_CURRENT_SOURCE_DIR}/android/AndroidManifest.xml")
+
+
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(RESOURCE_FILES resources.qrc)
+
+find_package(Qt6 REQUIRED COMPONENTS Quick)
+find_package(Qt6 REQUIRED COMPONENTS Core)
+find_package(Qt6 REQUIRED COMPONENTS Location)
+find_package(Qt6 REQUIRED COMPONENTS Positioning)
+find_package(Qt6 REQUIRED COMPONENTS Network)
+
+qt_add_resources(RESOURCES_RCC "${RESOURCE_FILES}")
+
+qt_add_executable(appWeatherRoutes
+    main.cpp
+    ${RESOURCES_RCC}
+)
+
+qt6_add_qml_module(appWeatherRoutes
+    URI WeatherRoutes
+    VERSION 1.0
+    QML_FILES
+        Main.qml
+        SOURCES
+        QML_FILES
+        QML_FILES qml/WaypointData.qml
+        QML_FILES qml/WeatherDetailsView.qml
+        QML_FILES qml/CustomInputField.qml
+        QML_FILES qml/MapView.qml
+        QML_FILES
+        QML_FILES qml/HomeScreen.qml
+        SOURCES mvc/data/waypoint.h mvc/data/waypoint.cpp
+        SOURCES mvc/data/mapdata.cpp mvc/data/mapdata.h
+        SOURCES mvc/model/mapdatamodel.h mvc/model/mapdatamodel.cpp
+        SOURCES mvc/data/weatherdetailsdata.h mvc/data/weatherdetailsdata.cpp
+        SOURCES mvc/enums/weatherstatus.h
+        SOURCES mvc/data/weatherdata.h mvc/data/weatherdata.cpp
+        SOURCES mvc/controller/weathercontroller.h mvc/controller/weathercontroller.cpp
+        SOURCES mvc/controller/networkmanager.h mvc/controller/networkmanager.cpp
+        SOURCES mvc/controller/stylecontroller.h mvc/controller/stylecontroller.cpp
+)
+
+target_include_directories(appWeatherRoutes
+    PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/mvc
+)
+
+# Qt for iOS sets MACOSX_BUNDLE_GUI_IDENTIFIER automatically since Qt 6.1.
+# If you are developing for iOS or macOS you should consider setting an
+# explicit, fixed bundle identifier manually though.
+set_target_properties(appWeatherRoutes PROPERTIES
+#    MACOSX_BUNDLE_GUI_IDENTIFIER com.example.appWeatherRoutes
+    MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
+    MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
+    MACOSX_BUNDLE TRUE
+    WIN32_EXECUTABLE TRUE
+)
+target_link_libraries(appWeatherRoutes PRIVATE Qt6::Quick Qt6::Location Qt6::Positioning)
+set(CMAKE_AUTORCC ON)
+
+include(GNUInstallDirs)
+install(TARGETS appWeatherRoutes
+    BUNDLE DESTINATION .
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)

Main.qml

@@ -0,0 +1,17 @@
+import QtQuick
+import QtQuick.Controls
+import QtLocation
+import QtPositioning
+
+ApplicationWindow {
+    visible: true
+
+    width: Qt.platform.os == "android" ? Screen.width : 360
+    height: Qt.platform.os == "android" ? Screen.height : 640
+    title: "Weather Routes"
+    HomeScreen
+    {
+        id: homeScreen
+        anchors.fill: parent
+    }
+}

android/AndroidManifest.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.weatherroutes" android:versionCode="" android:versionName="">
+
+    <application android:label="WeatherRoutes">
+        <activity
+            android:name="org.qtproject.qt5.android.bindings.QtActivity"
+            android:label="@string/appWeatherRoutes"
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|direction|density|uiMode">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+    <!-- Permissions -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
+</manifest>

generate.py

@@ -0,0 +1,14 @@
+import os
+
+resource_file = "resources.qrc"
+image_folder = "images"
+
+with open(resource_file, "w") as f:
+    f.write('<!DOCTYPE RCC><RCC version="1.0">\n<qresource prefix="">\n')
+    for root, _, files in os.walk(image_folder):
+        for file in files:
+            if file.endswith('.png'):
+                f.write(f'    <file>{os.path.join(image_folder, file)}</file>\n')
+    f.write('</qresource>\n</RCC>\n')
+
+print(f"{resource_file} has been generated.")

images/currentLocationOfWaypoint.svg

@@ -0,0 +1,11 @@
+<svg width="306" height="400" xmlns="http://www.w3.org/2000/svg" xml:space="preserve" version="1.1">
+
+ <g>
+  <title>Layer 1</title>
+  <g id="_x31_57_x2C__Twitter_x2C__Location_x2C__Map">
+   <g id="svg_4">
+    <path id="svg_3" fill="#FF7979" d="m153.31529,-0.17747c84.87,0 153.81,68.94 153.81,153.96c0,77.059 -87.02,195.03 -153.2,246.04c-85.33,-69.24 -154.58,-167.75 -154.58,-246.04c0,-85.021 68.94,-153.96 153.97,-153.96zm74.79,150.799c0,-41.34 -33.521,-74.86 -74.87,-74.86c-41.35,0 -74.86,33.52 -74.86,74.86c0,41.35 33.51,74.87 74.86,74.87c41.35,0 74.87,-33.52 74.87,-74.87z"/>
+   </g>
+  </g>
+ </g>
+</svg>

images/start_location.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="24px" viewBox="0 -960 960 960" width="24px" fill="#e8eaed"><path d="M480-80q-83 0-156-31.5T197-197q-54-54-85.5-127T80-480q0-83 31.5-156T197-763q54-54 127-85.5T480-880q83 0 156 31.5T763-763q54 54 85.5 127T880-480q0 83-31.5 156T763-197q-54 54-127 85.5T480-80Zm0-80q134 0 227-93t93-227q0-134-93-227t-227-93q-134 0-227 93t-93 227q0 134 93 227t227 93Zm0-320Z"/></svg>

main.cpp

@@ -0,0 +1,65 @@
+#include "controller/networkmanager.h"
+#include "controller/weathercontroller.h"
+#include "data/mapdata.h"
+#include "data/weatherdetailsdata.h"
+#include "controller/weathercontroller.h"
+#include "controller/networkmanager.h"
+#include "enums/weatherstatus.h"
+#include <QGuiApplication>
+#include <QLocationPermission>
+#include <QQmlApplicationEngine>
+#include <QQmlContext>
+
+int main(int argc, char *argv[]) {
+#if defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID)
+  qputenv("QT_IM_MODULE", QByteArray("qtvirtualkeyboard"));
+#endif
+
+  QGuiApplication app(argc, argv);
+
+  QLocationPermission permission;
+  permission.setAccuracy(QLocationPermission::Precise);
+  permission.setAvailability(QLocationPermission::WhenInUse);
+  switch (qApp->checkPermission(permission)) {
+  case Qt::PermissionStatus::Undetermined:
+    qApp->requestPermission(permission, [](const QPermission &permission) {
+      if (permission.status() == Qt::PermissionStatus::Granted) {
+        qDebug() << "Permission granted !!";
+      }
+    });
+  case Qt::PermissionStatus::Granted:
+  case Qt::PermissionStatus::Denied:
+    break;
+  }
+
+  QQmlApplicationEngine engine;
+
+  MapData mapData;
+  mapData.setDefaultZoomLevel(15);
+  mapData.setZoomLevel(mapData.defaultZoomLevel());
+  mapData.setGpsUpdateInterval(1000);
+  engine.rootContext()->setContextProperty("mapData", &mapData);
+
+  WeatherController ctrl;
+  std::shared_ptr<WeatherController> weatherCntrl =
+      std::make_shared<WeatherController>();
+  ctrl.parseJSONData();
+
+  WeatherDetailsData weatherDetailsData(weatherCntrl);
+  engine.rootContext()->setContextProperty("weatherDetailsData",
+                                           &weatherDetailsData);
+  engine.rootContext()->setContextProperty("networkManager",
+                                           NetworkManager::Instance());
+
+  const QUrl url(QStringLiteral("qrc:/WeatherRoutes/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);
+
+  return app.exec();
+}

mvc/controller/networkmanager.cpp

@@ -0,0 +1,42 @@
+#include "networkmanager.h"
+#include "QStandardPaths"
+#include <QFile>
+#include <QGuiApplication>
+#include <QJsonDocument>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+
+NetworkManager *NetworkManager::m_instance;
+
+NetworkManager::NetworkManager(QObject *parent) : QObject{parent} {}
+
+NetworkManager *NetworkManager::Instance() {
+  if (m_instance != nullptr) {
+    return m_instance;
+  }
+  m_instance = new NetworkManager();
+  return m_instance;
+}
+
+void NetworkManager::fetchJSONfromAPI(QUrl url, QJsonDocument &doc)
+{
+    qDebug() << "Fetch URL::" << url.toDisplayString();
+    QNetworkAccessManager m_manager;
+    QNetworkRequest request(url);
+    QNetworkReply *reply = m_manager.get(request);
+    QEventLoop loop;
+    connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
+    loop.exec();
+    if (reply->error() == QNetworkReply::NoError)
+    {
+        QByteArray response = reply->readAll();
+        doc = QJsonDocument::fromJson(response);
+    }
+    else
+    {
+        qDebug() << "Invalid JSON response:: " << reply->errorString();
+    }
+
+    reply->deleteLater();
+}
+

mvc/controller/networkmanager.h

@@ -0,0 +1,22 @@
+#ifndef NETWORKMANAGER_H
+#define NETWORKMANAGER_H
+
+#include <QObject>
+
+class NetworkManager : public QObject {
+  Q_OBJECT
+public:
+  void fetchJSONfromAPI(QUrl url, QJsonDocument &doc);
+  static NetworkManager *m_instance;
+  static NetworkManager *Instance();
+
+    NetworkManager(const NetworkManager&) = delete;
+    NetworkManager& operator=(const NetworkManager&) = delete;
+
+signals:
+
+private:
+  explicit NetworkManager(QObject *parent = nullptr);
+};
+
+#endif // NETWORKMANAGER_H

mvc/controller/stylecontroller.cpp

@@ -0,0 +1,30 @@
+#include "stylecontroller.h"
+
+StyleController* StyleController::m_instance;
+
+StyleController *StyleController::Instance()
+{
+    if(m_instance != nullptr)
+    {
+        return m_instance;
+    }
+    m_instance = new StyleController();
+    return m_instance;
+}
+
+StyleController::StyleController(QObject *parent)
+    : QObject{parent}
+{}
+
+int StyleController::colorMode() const
+{
+    return m_colorMode;
+}
+
+void StyleController::setColorMode(int newColorMode)
+{
+    if (m_colorMode == newColorMode)
+        return;
+    m_colorMode = newColorMode;
+    emit colorModeChanged();
+}

mvc/controller/stylecontroller.h

@@ -0,0 +1,59 @@
+#ifndef STYLECONTROLLER_H
+#define STYLECONTROLLER_H
+
+#include <QObject>
+#include <QColor>
+
+class StyleController : public QObject
+{
+    Q_OBJECT
+public:
+    static StyleController* m_instance;
+    StyleController(const StyleController&) = delete;
+    StyleController& operator=(const StyleController&) = delete;
+    StyleController* Instance();
+
+    enum COLOR_MODE
+    {
+        DARK = 0,
+        LIGHT,
+        SYSTEM
+    }
+    Q_ENUMS(COLOR_MODE);
+
+
+    Q_PROPERTY(int colorMode READ colorMode WRITE setColorMode NOTIFY colorModeChanged FINAL)
+
+    //Dark Mode
+    Q_PROPERTY(QColor textPrimary READ textPrimary NOTIFY colorChanged FINAL)
+    QColor textPrimary() const {return QColor(255,255,255);}
+
+    Q_PROPERTY(QColor textSecondary READ textSecondary NOTIFY colorChanged FINAL)
+    QColor textSecondary() const {return QColor(255,255,255,179);}
+
+    Q_PROPERTY(QColor textDisabled READ textDisabled NOTIFY colorChanged FINAL)
+    QColor textDisabled() const {return QColor(255,255,255,125);}
+
+    Q_PROPERTY(QColor buttonActive READ buttonActive NOTIFY colorChanged FINAL)
+    QColor buttonActive() const {return QColor(255,255,255);}
+
+    Q_PROPERTY(QColor buttonDisabled READ buttonDisabled NOTIFY colorChanged FINAL)
+    QColor buttonDisabled() const {return QColor(255,255,255, 77);}
+
+    Q_PROPERTY(QColor buttonSelected READ buttonSelected NOTIFY colorChanged FINAL)
+    QColor buttonSelected() const {return QColor(255,255,255, 40);}
+
+    int colorMode() const;
+    void setColorMode(int newColorMode);
+
+
+signals:
+    void colorChanged();
+    void colorModeChanged();
+
+private:
+    explicit StyleController(QObject *parent = nullptr);
+    int m_colorMode = COLOR_MODE::DARK;
+};
+
+#endif // STYLECONTROLLER_H

mvc/controller/weathercontroller.cpp

@@ -0,0 +1,224 @@
+#include "weathercontroller.h"
+#include "QDir"
+#include "QFile"
+#include "QGuiApplication"
+#include "QStandardPaths"
+#include "networkmanager.h"
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <qdebug.h>
+
+const QString WeatherController::FILENAME = "static.json";
+
+WeatherController::WeatherController(QObject *parent) : QObject{parent} {}
+
+bool WeatherController::parseJSONData() {
+  QJsonDocument doc;
+  if (this->checkToDownload(doc)) {
+    QJsonObject jsonObject = doc.object();
+    QJsonArray dataArray = jsonObject["data"].toArray();
+    for (QJsonArray::const_iterator iter = dataArray.constBegin();
+         iter != dataArray.constEnd(); ++iter) {
+      QJsonObject weatherObject = (*iter).toObject();
+
+      // Extract values from the JSON object
+      long tijd = weatherObject["tijd"].toString().toLong();
+      QString tijd_nl = weatherObject["tijd_nl"].toString();
+      int offset = weatherObject["offset"].toInt();
+      float temp = weatherObject["temp"].toString().toFloat();
+      int wind_ms = weatherObject["windb"].toInt();
+      int wind_bf = weatherObject["winds"].toInt();
+      int wind_knp = weatherObject["windknp"].toInt();
+      int wind_kmh = weatherObject["windkmh"].toString().toFloat();
+      int wind_r = weatherObject["windr"].toInt();
+      QString wind_ltr = weatherObject["windrltr"].toString();
+      int visibility = weatherObject["vis"].toInt();
+      int neersl = weatherObject["neersl"].toString().toFloat() *
+                   10; // Converted from 0.1 to 1 decimal scale
+      float luchtd_bar = weatherObject["luchtd"].toString().toFloat();
+      float luchtdmmhg = weatherObject["luchtdmmhg"].toString().toFloat();
+      float luchtdinHg = weatherObject["luchtdinhg"].toString().toFloat();
+      int hw = weatherObject["hw"].toInt();
+      int mw = weatherObject["mw"].toInt();
+      int lw = weatherObject["lw"].toInt();
+      int tw = weatherObject["tw"].toInt();
+      int rv = weatherObject["rv"].toInt();
+      int gr = weatherObject["gr"].toInt();
+      int gr_w = weatherObject["gr_w"].toInt();
+      QString cape = weatherObject["cape"].toString();
+      int snd = weatherObject["snd"].toInt();
+      int snv = weatherObject["snv"].toInt();
+      int cond = weatherObject["cond"].toInt();
+      int iconCode = weatherObject["ico"].toInt();
+      QString sameenv = weatherObject["samenv"].toString();
+      QString icoon = weatherObject["icoon"].toString();
+
+      // Create WeatherData object and add it to the list using initializer list
+      // constructor
+      mData.append(WeatherData(tijd, tijd_nl, offset, temp, wind_ms, wind_bf,
+                               wind_knp, wind_kmh, wind_r, wind_ltr, visibility,
+                               neersl, luchtd_bar, luchtdmmhg, luchtdinHg, hw,
+                               mw, lw, tw, rv, gr, gr_w, cape, snd, snv, cond,
+                               iconCode, sameenv, icoon));
+    }
+  }
+    else
+        return false;
+
+    return true;
+}
+
+QJsonObject WeatherController::fetchCurrentWeatherData(const QGeoCoordinate &coord)
+{
+    QJsonDocument doc;
+    readWeatherData(doc, "liveweer");
+    QJsonArray liveweerArray = doc.array();
+    QJsonObject firstEntry = liveweerArray.at(0).toObject();
+
+    //Will fetch live data when the time difference is more than 10 mins from last fetch
+    if (qAbs(QDateTime::currentSecsSinceEpoch() - firstEntry["timestamp"].toString().toUInt()) > 600)
+    {
+        // NetworkManager::Instance()->fetchJSONfromAPI(prepareURL(coord), doc);
+        // if(!doc.isNull() && doc.isObject())
+        // {
+        //     updateWeatherData(doc);
+        // }
+    }
+    return doc.object();
+}
+
+bool WeatherController::readWeatherData(QJsonDocument &doc, QString objName)
+{
+    QString cacheDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
+    QString fileName = cacheDir + "/" + WeatherController::FILENAME;
+
+    QFile file(fileName);
+    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        QTextStream in(&file);
+        QJsonParseError error;
+        doc  = QJsonDocument::fromJson(in.readAll().toStdString().c_str(), &error);
+        file.close();
+        if(doc.isNull())
+        {
+            qWarning() << "Error:: " << error.errorString();
+            return false;
+        }
+
+        if (!doc.isObject()) {
+            qWarning() << "Invalid JSON format";
+            return false;
+        }
+        if(!objName.isNull())
+        {
+            QJsonArray ary = doc.object()[objName].toArray();
+            QJsonDocument temp_doc(ary);
+            doc = temp_doc;
+        }
+    }
+    return true;
+}
+
+bool WeatherController::saveWeatherData(QJsonDocument &doc)
+{
+    QString cacheDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
+    // Ensure the directory exists
+    QDir dir(cacheDir);
+    if (!dir.exists()) {
+        dir.mkpath(cacheDir);
+    }
+
+    QString fileName = cacheDir + "/" + WeatherController::FILENAME;
+
+    QFile file(fileName);
+    if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        QTextStream out(&file);
+        out << doc.toJson();
+        file.close();
+        qDebug() << "Data saved to hidden cache file.";
+        return true;
+    } else {
+        qDebug() << "Failed to open file for writing";
+        return false;
+    }
+}
+
+bool WeatherController::fetchWeatherData(QUrl url, QJsonDocument &doc)
+{
+    NetworkManager::Instance()->fetchJSONfromAPI(url, doc);
+    if (doc.isObject() && !doc.isNull()) {
+        QJsonObject jsonObject = doc.object();
+
+        QString todayDate = QDate::currentDate().toString("dd-MM-yyyy");
+
+        jsonObject["downloaddatum"] = todayDate;
+
+        QString timeOfDownload = QDateTime::currentDateTime().toString("hh:mm:ss");
+
+        jsonObject["downloadtime"] = timeOfDownload;
+
+        QJsonDocument updatedDoc(jsonObject);
+        saveWeatherData(updatedDoc);
+    }
+    return true;
+}
+
+void WeatherController::updateWeatherData(QJsonDocument &inputDoc)
+{
+    QJsonDocument doc;
+    readWeatherData(doc);
+    QJsonObject rootObj = doc.object();
+    QJsonObject inputObj = inputDoc.object();
+    QJsonArray liveweerArray = inputObj["liveweer"].toArray();
+    rootObj["liveweer"] = liveweerArray;
+
+    QJsonDocument updatedDoc(rootObj);
+    saveWeatherData(updatedDoc);
+}
+
+QUrl WeatherController::prepareURL(const QString &plaats)
+{
+    return QUrl(QString("http://data.meteoserver.nl/api/uurverwachting.php?locatie=%1&key=785f0630f0").arg(plaats));
+}
+
+QUrl WeatherController::prepareURL(const QGeoCoordinate &coord)
+{
+    return QUrl(QString("http://data.meteoserver.nl/api/liveweer_synop.php?lat=%1&long=%2&key=785f0630f0&select=1").arg(coord.latitude()).arg(coord.longitude()));
+}
+
+bool WeatherController::checkToDownload(QJsonDocument &doc)
+{
+    bool toDownloadData = false;
+    readWeatherData(doc);
+
+    if (doc.isObject() && !doc.isNull()) {
+
+        // Get the root object
+        QJsonObject jsonObject = doc.object();
+
+        // Extract the 'downloaddatum' value
+        QString downloaddatum = jsonObject.value("downloaddatum").toString();
+        if(downloaddatum != QDate::currentDate().toString("dd-MM-yyyy"))
+            toDownloadData = true;
+
+        QJsonArray plaatsnaamArray = jsonObject.value("plaatsnaam").toArray();
+
+        if (!plaatsnaamArray.isEmpty()) {
+            QJsonObject plaatsObject = plaatsnaamArray.at(0).toObject();
+            QString plaats = plaatsObject.value("plaats").toString();
+            if(plaats != "Raalte")
+                toDownloadData = true;
+        } else {
+            qWarning() << "plaatsnaam array is empty";
+            return false;
+        }
+
+    } else {
+        qWarning() << "Failed to open file for reading";
+        return false;
+    }
+    if(toDownloadData)
+        return fetchWeatherData(prepareURL("Raalte"), doc);
+    return false;
+}
+

mvc/controller/weathercontroller.h

@@ -0,0 +1,30 @@
+#ifndef WEATHERCONTROLLER_H
+#define WEATHERCONTROLLER_H
+
+#include "../data/weatherdata.h"
+#include <QGeoCoordinate>
+#include <QObject>
+
+class WeatherController : public QObject {
+  Q_OBJECT
+public:
+  explicit WeatherController(QObject *parent = nullptr);
+
+  static const QString FILENAME;
+  bool parseJSONData();
+  QJsonObject fetchCurrentWeatherData(const QGeoCoordinate &coord);
+
+signals:
+
+private:
+    bool readWeatherData(QJsonDocument &doc, QString objName = NULL);
+    bool checkToDownload(QJsonDocument &doc);
+    bool saveWeatherData(QJsonDocument &doc);
+    bool fetchWeatherData(QUrl url, QJsonDocument &doc);
+    void updateWeatherData(QJsonDocument &inputDoc);
+    QUrl prepareURL(const QString &plaats);
+    QUrl prepareURL(const QGeoCoordinate &coord);
+    QList<WeatherData> mData;
+};
+
+#endif // WEATHERCONTROLLER_H

mvc/data/mapdata.cpp

@@ -0,0 +1,42 @@
+#include "mapdata.h"
+
+MapData::MapData(QObject *parent) : QObject{parent} {}
+
+QList<std::unique_ptr<Waypoint>> MapData::waypoints() const {
+  return m_waypoints;
+}
+
+void MapData::setWaypoints(
+    const QList<std::unique_ptr<Waypoint>> &newWaypoints) {
+  if (m_waypoints == newWaypoints)
+    return;
+  m_waypoints = newWaypoints;
+  emit waypointsChanged();
+}
+
+int MapData::zoomLevel() const { return m_zoomLevel; }
+
+void MapData::setZoomLevel(int newZoomLevel) {
+  if (m_zoomLevel == newZoomLevel)
+    return;
+  m_zoomLevel = newZoomLevel;
+  emit zoomLevelChanged();
+}
+
+int MapData::gpsUpdateInterval() const { return m_gpsUpdateInterval; }
+
+void MapData::setGpsUpdateInterval(int newGpsUpdateInterval) {
+  if (m_gpsUpdateInterval == newGpsUpdateInterval)
+    return;
+  m_gpsUpdateInterval = newGpsUpdateInterval;
+  emit gpsUpdateIntervalChanged();
+}
+
+int MapData::defaultZoomLevel() const { return m_defaultZoomLevel; }
+
+void MapData::setDefaultZoomLevel(int newDefaultZoomLevel) {
+  if (m_defaultZoomLevel == newDefaultZoomLevel)
+    return;
+  m_defaultZoomLevel = newDefaultZoomLevel;
+  emit defaultZoomLevelChanged();
+}

mvc/data/mapdata.h

@@ -0,0 +1,46 @@
+#ifndef MAPDATA_H
+#define MAPDATA_H
+
+#include "waypoint.h"
+#include <QObject>
+
+class MapData : public QObject {
+  Q_OBJECT
+public:
+  explicit MapData(QObject *parent = nullptr);
+
+  Q_PROPERTY(QList<std::unique_ptr<Waypoint>> waypoints READ waypoints WRITE
+                 setWaypoints NOTIFY waypointsChanged FINAL)
+  Q_PROPERTY(int zoomLevel READ zoomLevel WRITE setZoomLevel NOTIFY
+                 zoomLevelChanged FINAL)
+  Q_PROPERTY(int gpsUpdateInterval READ gpsUpdateInterval WRITE
+                 setGpsUpdateInterval NOTIFY gpsUpdateIntervalChanged FINAL)
+  Q_PROPERTY(int defaultZoomLevel READ defaultZoomLevel NOTIFY
+                 defaultZoomLevelChanged FINAL)
+
+  QList<std::unique_ptr<Waypoint>> waypoints() const;
+  void setWaypoints(const QList<std::unique_ptr<Waypoint>> &newWaypoints);
+
+  int zoomLevel() const;
+  void setZoomLevel(int newZoomLevel);
+
+  int gpsUpdateInterval() const;
+  void setGpsUpdateInterval(int newGpsUpdateInterval);
+
+  int defaultZoomLevel() const;
+  void setDefaultZoomLevel(int newDefaultZoomLevel);
+
+signals:
+  void waypointsChanged();
+  void zoomLevelChanged();
+  void gpsUpdateIntervalChanged();
+  void defaultZoomLevelChanged();
+
+private:
+  QList<std::unique_ptr<Waypoint>> m_waypoints;
+  int m_zoomLevel;
+  int m_gpsUpdateInterval;
+  int m_defaultZoomLevel;
+};
+
+#endif // MAPDATA_H

mvc/data/waypoint.cpp

@@ -0,0 +1,16 @@
+#include "waypoint.h"
+
+Waypoint::Waypoint(QObject *parent) : QObject{parent} {}
+
+Waypoint::Waypoint(const double latitude, const double longitude)
+    : m_latitude(latitude), m_longitude(longitude), m_altitude(0) {}
+
+Waypoint::Waypoint(const double latitude, const double longitude,
+                   WeatherData &data)
+    : m_latitude(latitude), m_longitude(longitude), m_altitude(0),
+      m_data(data) {}
+
+Waypoint::Waypoint(const double latitude, const double longitude,
+                   const double altitude, WeatherData &data)
+    : m_latitude(latitude), m_longitude(longitude), m_altitude(altitude),
+      m_data(data) {}

mvc/data/waypoint.h

@@ -0,0 +1,23 @@
+#ifndef WAYPOINT_H
+#define WAYPOINT_H
+
+#include "weatherdata.h"
+#include <QObject>
+
+class Waypoint : public QObject {
+  Q_OBJECT
+public:
+  explicit Waypoint(QObject *parent = nullptr);
+  Waypoint(const double latitude, const double longitude);
+  Waypoint(const double latitude, const double longitude, WeatherData &data);
+  Waypoint(const double latitude, const double longitude, const double altitude,
+           WeatherData &data);
+
+private:
+  double m_latitude;
+  double m_longitude;
+  double m_altitude;
+  WeatherData m_data;
+};
+
+#endif // WAYPOINT_H

mvc/data/weatherdata.cpp

@@ -0,0 +1,331 @@
+#include "weatherdata.h"
+
+WeatherData::WeatherData(QObject *parent) : QObject{parent} {}
+
+WeatherData::WeatherData(long tijd, const QString &tijd_nl, int offset,
+                         float temp, int wind_ms, int wind_bf, int wind_knp,
+                         int wind_kmh, int wind_r, const QString &wind_ltr,
+                         int visibility, int neersl, float luchtd_bar,
+                         float luchtdmmhg, float luchtdinHg, int hw, int mw,
+                         int lw, int tw, int rv, int gr, int gr_w,
+                         const QString &cape, int snd, int snv, int cond,
+                         int iconCode, const QString &sameenv,
+                         const QString &icoon)
+    : m_tijd(tijd), m_tijd_nl(tijd_nl), m_offset(offset), m_temp(temp),
+      m_wind_ms(wind_ms), m_wind_bf(wind_bf), m_wind_knp(wind_knp),
+      m_wind_kmh(wind_kmh), m_wind_r(wind_r), m_wind_ltr(wind_ltr),
+      m_visibility(visibility), m_neersl(neersl), m_luchtd_bar(luchtd_bar),
+      m_luchtdmmhg(luchtdmmhg), m_luchtdinHg(luchtdinHg), m_hw(hw), m_mw(mw),
+      m_lw(lw), m_tw(tw), m_rv(rv), m_gr(gr), m_gr_w(gr_w), m_cape(cape),
+      m_snd(snd), m_snv(snv), m_cond(cond), m_iconCode(iconCode),
+      m_sameenv(sameenv), m_icoon(icoon) {}
+
+WeatherData::WeatherData(const WeatherData &other)
+    : m_tijd(other.m_tijd), m_tijd_nl(other.m_tijd_nl),
+      m_offset(other.m_offset), m_temp(other.m_temp),
+      m_wind_ms(other.m_wind_ms), m_wind_bf(other.m_wind_bf),
+      m_wind_knp(other.m_wind_knp), m_wind_kmh(other.m_wind_kmh),
+      m_wind_r(other.m_wind_r), m_wind_ltr(other.m_wind_ltr),
+      m_visibility(other.m_visibility), m_neersl(other.m_neersl),
+      m_luchtd_bar(other.m_luchtd_bar), m_luchtdmmhg(other.m_luchtdmmhg),
+      m_luchtdinHg(other.m_luchtdinHg), m_hw(other.m_hw), m_mw(other.m_mw),
+      m_lw(other.m_lw), m_tw(other.m_tw), m_rv(other.m_rv), m_gr(other.m_gr),
+      m_gr_w(other.m_gr_w), m_cape(other.m_cape), m_snd(other.m_snd),
+      m_snv(other.m_snv), m_cond(other.m_cond), m_iconCode(other.m_iconCode),
+      m_sameenv(other.m_sameenv), m_icoon(other.m_icoon) {}
+
+WeatherData WeatherData::operator=(const WeatherData &other) {
+  m_tijd = (other.m_tijd);
+  m_tijd_nl = (other.m_tijd_nl);
+  m_offset = (other.m_offset);
+  m_temp = (other.m_temp);
+  m_wind_ms = (other.m_wind_ms);
+  m_wind_bf = (other.m_wind_bf);
+  m_wind_knp = (other.m_wind_knp);
+  m_wind_kmh = (other.m_wind_kmh);
+  m_wind_r = (other.m_wind_r);
+  m_wind_ltr = (other.m_wind_ltr);
+  m_visibility = (other.m_visibility);
+  m_neersl = (other.m_neersl);
+  m_luchtd_bar = (other.m_luchtd_bar);
+  m_luchtdmmhg = (other.m_luchtdmmhg);
+  m_luchtdinHg = (other.m_luchtdinHg);
+  m_hw = (other.m_hw);
+  m_mw = (other.m_mw);
+  m_lw = (other.m_lw);
+  m_tw = (other.m_tw);
+  m_rv = (other.m_rv);
+  m_gr = (other.m_gr);
+  m_gr_w = (other.m_gr_w);
+  m_cape = (other.m_cape);
+  m_snd = (other.m_snd);
+  m_snv = (other.m_snv);
+  m_cond = (other.m_cond);
+  m_iconCode = (other.m_iconCode);
+  m_sameenv = (other.m_sameenv);
+  m_icoon = (other.m_icoon);
+  return *this;
+}
+
+long WeatherData::tijd() const { return m_tijd; }
+
+void WeatherData::setTijd(long newTijd) {
+  if (m_tijd == newTijd)
+    return;
+  m_tijd = newTijd;
+  emit tijdChanged();
+}
+
+QString WeatherData::tijd_nl() const { return m_tijd_nl; }
+
+void WeatherData::setTijd_nl(const QString &newTijd_nl) {
+  if (m_tijd_nl == newTijd_nl)
+    return;
+  m_tijd_nl = newTijd_nl;
+  emit tijd_nlChanged();
+}
+
+int WeatherData::offset() const { return m_offset; }
+
+void WeatherData::setOffset(int newOffset) {
+  if (m_offset == newOffset)
+    return;
+  m_offset = newOffset;
+  emit offsetChanged();
+}
+
+float WeatherData::temp() const { return m_temp; }
+
+void WeatherData::setTemp(float newTemp) {
+  if (qFuzzyCompare(m_temp, newTemp))
+    return;
+  m_temp = newTemp;
+  emit tempChanged();
+}
+
+int WeatherData::wind_ms() const { return m_wind_ms; }
+
+void WeatherData::setWind_ms(int newWind_ms) {
+  if (m_wind_ms == newWind_ms)
+    return;
+  m_wind_ms = newWind_ms;
+  emit wind_msChanged();
+}
+
+int WeatherData::wind_bf() const { return m_wind_bf; }
+
+void WeatherData::setWind_bf(int newWind_bf) {
+  if (m_wind_bf == newWind_bf)
+    return;
+  m_wind_bf = newWind_bf;
+  emit wind_bfChanged();
+}
+
+int WeatherData::wind_knp() const { return m_wind_knp; }
+
+void WeatherData::setWind_knp(int newWind_knp) {
+  if (m_wind_knp == newWind_knp)
+    return;
+  m_wind_knp = newWind_knp;
+  emit wind_knpChanged();
+}
+
+int WeatherData::wind_kmh() const { return m_wind_kmh; }
+
+void WeatherData::setWind_kmh(int newWind_kmh) {
+  if (m_wind_kmh == newWind_kmh)
+    return;
+  m_wind_kmh = newWind_kmh;
+  emit wind_kmhChanged();
+}
+
+int WeatherData::wind_r() const { return m_wind_r; }
+
+void WeatherData::setWind_r(int newWind_r) {
+  if (m_wind_r == newWind_r)
+    return;
+  m_wind_r = newWind_r;
+  emit wind_rChanged();
+}
+
+QString WeatherData::wind_ltr() const { return m_wind_ltr; }
+
+void WeatherData::setWind_ltr(const QString &newWind_ltr) {
+  if (m_wind_ltr == newWind_ltr)
+    return;
+  m_wind_ltr = newWind_ltr;
+  emit wind_ltrChanged();
+}
+
+int WeatherData::visibility() const { return m_visibility; }
+
+void WeatherData::setVisibility(int newVisibility) {
+  if (m_visibility == newVisibility)
+    return;
+  m_visibility = newVisibility;
+  emit visibilityChanged();
+}
+
+int WeatherData::neersl() const { return m_neersl; }
+
+void WeatherData::setNeersl(int newNeersl) {
+  if (m_neersl == newNeersl)
+    return;
+  m_neersl = newNeersl;
+  emit neerslChanged();
+}
+
+float WeatherData::luchtd_bar() const { return m_luchtd_bar; }
+
+void WeatherData::setLuchtd_bar(float newLuchtd_bar) {
+  if (qFuzzyCompare(m_luchtd_bar, newLuchtd_bar))
+    return;
+  m_luchtd_bar = newLuchtd_bar;
+  emit luchtd_barChanged();
+}
+
+float WeatherData::luchtdmmhg() const { return m_luchtdmmhg; }
+
+void WeatherData::setLuchtdmmhg(float newLuchtdmmhg) {
+  if (qFuzzyCompare(m_luchtdmmhg, newLuchtdmmhg))
+    return;
+  m_luchtdmmhg = newLuchtdmmhg;
+  emit luchtdmmhgChanged();
+}
+
+float WeatherData::luchtdinHg() const { return m_luchtdinHg; }
+
+void WeatherData::setLuchtdinHg(float newLuchtdinHg) {
+  if (qFuzzyCompare(m_luchtdinHg, newLuchtdinHg))
+    return;
+  m_luchtdinHg = newLuchtdinHg;
+  emit luchtdinHgChanged();
+}
+
+int WeatherData::hw() const { return m_hw; }
+
+void WeatherData::setHw(int newHw) {
+  if (m_hw == newHw)
+    return;
+  m_hw = newHw;
+  emit hwChanged();
+}
+
+int WeatherData::mw() const { return m_mw; }
+
+void WeatherData::setMw(int newMw) {
+  if (m_mw == newMw)
+    return;
+  m_mw = newMw;
+  emit mwChanged();
+}
+
+int WeatherData::lw() const { return m_lw; }
+
+void WeatherData::setLw(int newLw) {
+  if (m_lw == newLw)
+    return;
+  m_lw = newLw;
+  emit lwChanged();
+}
+
+int WeatherData::tw() const { return m_tw; }
+
+void WeatherData::setTw(int newTw) {
+  if (m_tw == newTw)
+    return;
+  m_tw = newTw;
+  emit twChanged();
+}
+
+int WeatherData::rv() const { return m_rv; }
+
+void WeatherData::setRv(int newRv) {
+  if (m_rv == newRv)
+    return;
+  m_rv = newRv;
+  emit rvChanged();
+}
+
+int WeatherData::gr() const { return m_gr; }
+
+void WeatherData::setGr(int newGr) {
+  if (m_gr == newGr)
+    return;
+  m_gr = newGr;
+  emit grChanged();
+}
+
+int WeatherData::gr_w() const { return m_gr_w; }
+
+void WeatherData::setGr_w(int newGr_w) {
+  if (m_gr_w == newGr_w)
+    return;
+  m_gr_w = newGr_w;
+  emit gr_wChanged();
+}
+
+QString WeatherData::cape() const { return m_cape; }
+
+void WeatherData::setCape(const QString &newCape) {
+  if (m_cape == newCape)
+    return;
+  m_cape = newCape;
+  emit capeChanged();
+}
+
+int WeatherData::snd() const { return m_snd; }
+
+void WeatherData::setSnd(int newSnd) {
+  if (m_snd == newSnd)
+    return;
+  m_snd = newSnd;
+  emit sndChanged();
+}
+
+int WeatherData::snv() const { return m_snv; }
+
+void WeatherData::setSnv(int newSnv) {
+  if (m_snv == newSnv)
+    return;
+  m_snv = newSnv;
+  emit snvChanged();
+}
+
+int WeatherData::cond() const { return m_cond; }
+
+void WeatherData::setCond(int newCond) {
+  if (m_cond == newCond)
+    return;
+  m_cond = newCond;
+  emit condChanged();
+}
+
+int WeatherData::iconCode() const { return m_iconCode; }
+
+void WeatherData::setIconCode(int newIconCode) {
+  if (m_iconCode == newIconCode)
+    return;
+  m_iconCode = newIconCode;
+  emit iconCodeChanged();
+}
+
+QString WeatherData::sameenv() const { return m_sameenv; }
+
+void WeatherData::setSameenv(const QString &newSameenv) {
+  if (m_sameenv == newSameenv)
+    return;
+  m_sameenv = newSameenv;
+  emit sameenvChanged();
+}
+
+QString WeatherData::icoon() const { return m_icoon; }
+
+void WeatherData::setIcoon(const QString &newIcoon) {
+  if (m_icoon == newIcoon)
+    return;
+  m_icoon = newIcoon;
+  emit icoonChanged();
+}
+
+void WeatherData::print() {}

mvc/data/weatherdata.h

@@ -0,0 +1,306 @@
+#ifndef WEATHERDATA_H
+#define WEATHERDATA_H
+
+#include <QObject>
+
+class WeatherData : public QObject {
+  Q_OBJECT
+
+public:
+  enum ICON_NAME {
+    regen,
+    bewolkt,
+    halfbewolkt,
+    lichtbewolkt,
+    nachtbewolkt,
+    wolkennacht,
+    zonnig,
+    helderenacht
+  };
+  Q_ENUM(ICON_NAME)
+
+  enum WEATHER_COND {
+    Regen,
+    Bewolkt,
+    Halfbewolkt,
+    Lichtbewolkt,
+    Zonnig,
+    Helder
+  };
+  Q_ENUM(WEATHER_COND)
+
+  enum WIND_DIR {
+    Noord,
+    NNO,
+    NO,
+    ONO,
+    Oost,
+    OZO,
+    ZO,
+    ZZO,
+    Zuid,
+    ZZW,
+    ZW,
+    WZW,
+    West,
+    WNW,
+    NW,
+    NNW
+  };
+  Q_ENUM(WIND_DIR)
+
+  explicit WeatherData(QObject *parent = nullptr);
+
+  WeatherData(long tijd, const QString &tijd_nl, int offset, float temp,
+              int wind_ms, int wind_bf, int wind_knp, int wind_kmh, int wind_r,
+              const QString &wind_ltr, int visibility, int neersl,
+              float luchtd_bar, float luchtdmmhg, float luchtdinHg, int hw,
+              int mw, int lw, int tw, int rv, int gr, int gr_w,
+              const QString &cape, int snd, int snv, int cond, int iconCode,
+              const QString &sameenv, const QString &icoon);
+
+  WeatherData(const WeatherData &other);
+  WeatherData operator=(WeatherData const &other);
+
+  Q_PROPERTY(long tijd READ tijd WRITE setTijd NOTIFY tijdChanged
+                 FINAL) // DateTime in Timestamp
+  Q_PROPERTY(QString tijd_nl READ tijd_nl WRITE setTijd_nl NOTIFY tijd_nlChanged
+                 FINAL) // DateTime is Human readable format
+  Q_PROPERTY(int offset READ offset WRITE setOffset NOTIFY offsetChanged
+                 FINAL) // Offset is the last reference hour point of the
+                        // model's predicted weather data
+  Q_PROPERTY(float temp READ temp WRITE setTemp NOTIFY tempChanged
+                 FINAL) // temp in Celsius
+  Q_PROPERTY(int wind_ms READ wind_ms WRITE setWind_ms NOTIFY wind_msChanged
+                 FINAL) // Wind avg speed in m/s
+  Q_PROPERTY(int wind_bf READ wind_bf WRITE setWind_bf NOTIFY wind_bfChanged
+                 FINAL) // Wind avg speed in Beaufort
+  Q_PROPERTY(int wind_knp READ wind_knp WRITE setWind_knp NOTIFY wind_knpChanged
+                 FINAL) // Wind avg speed in knots
+  Q_PROPERTY(int wind_kmh READ wind_kmh WRITE setWind_kmh NOTIFY wind_kmhChanged
+                 FINAL) // Wind avg speed in k/h
+  Q_PROPERTY(int wind_r READ wind_r WRITE setWind_r NOTIFY wind_rChanged
+                 FINAL) // Wind direction in degrees
+  Q_PROPERTY(
+      QString wind_ltr READ wind_ltr WRITE setWind_ltr NOTIFY wind_ltrChanged
+          FINAL) // Wind directions in Letters like N,S,E,W
+  Q_PROPERTY(int visibility READ visibility WRITE setVisibility NOTIFY
+                 visibilityChanged FINAL) // Visibility in meters
+  Q_PROPERTY(int neersl READ neersl WRITE setNeersl NOTIFY neerslChanged
+                 FINAL) // Precipitation in nml
+  Q_PROPERTY(float luchtd_bar READ luchtd_bar WRITE setLuchtd_bar NOTIFY
+                 luchtd_barChanged FINAL) // Air pressure in mbar
+  Q_PROPERTY(float luchtdmmhg READ luchtdmmhg WRITE setLuchtdmmhg NOTIFY
+                 luchtdmmhgChanged FINAL) // Air pressure in mmHg
+  Q_PROPERTY(float luchtdinHg READ luchtdinHg WRITE setLuchtdinHg NOTIFY
+                 luchtdinHgChanged FINAL) // Air pressure in inHg
+  Q_PROPERTY(int hw READ hw WRITE setHw NOTIFY hwChanged
+                 FINAL) //% of Higher Cloud desnsity
+  Q_PROPERTY(int mw READ mw WRITE setMw NOTIFY mwChanged
+                 FINAL) // % of medium cloud density
+  Q_PROPERTY(int lw READ lw WRITE setLw NOTIFY lwChanged
+                 FINAL) // % of low cloud density
+  Q_PROPERTY(int tw READ tw WRITE setTw NOTIFY twChanged
+                 FINAL) // % avg of all cloud density
+  Q_PROPERTY(
+      int rv READ rv WRITE setRv NOTIFY rvChanged FINAL) // Reletive Humidity
+  Q_PROPERTY(int gr READ gr WRITE setGr NOTIFY grChanged
+                 FINAL) // Expected Sun radiation J/cm2
+  Q_PROPERTY(int gr_w READ gr_w WRITE setGr_w NOTIFY gr_wChanged
+                 FINAL) // Expected Sun radiation watts/m2
+  Q_PROPERTY(QString cape READ cape WRITE setCape NOTIFY capeChanged
+                 FINAL) // Not gonna use it
+  Q_PROPERTY(int snd READ snd WRITE setSnd NOTIFY sndChanged
+                 FINAL) // Available snow deck in mm
+  Q_PROPERTY(int snv READ snv WRITE setSnv NOTIFY snvChanged
+                 FINAL) // Actual snowfall in mm
+  Q_PROPERTY(int cond READ cond WRITE setCond NOTIFY condChanged
+                 FINAL) // Cond is condition code is weather type like sunny,
+                        // rainy, etc
+  Q_PROPERTY(int iconCode READ iconCode WRITE setIconCode NOTIFY iconCodeChanged
+                 FINAL) // Icon code of the weather
+  Q_PROPERTY(QString sameenv READ sameenv WRITE setSameenv NOTIFY sameenvChanged
+                 FINAL) // Name of the current weather type
+  Q_PROPERTY(QString icoon READ icoon WRITE setIcoon NOTIFY icoonChanged
+                 FINAL) // Icon name of the current weather
+
+  long tijd() const;
+  void setTijd(long newTijd);
+
+  QString tijd_nl() const;
+  void setTijd_nl(const QString &newTijd_nl);
+
+  int offset() const;
+  void setOffset(int newOffset);
+
+  float temp() const;
+  void setTemp(float newTemp);
+
+  int wind_ms() const;
+  void setWind_ms(int newWind_ms);
+
+  int wind_bf() const;
+  void setWind_bf(int newWind_bf);
+
+  int wind_knp() const;
+  void setWind_knp(int newWind_knp);
+
+  int wind_kmh() const;
+  void setWind_kmh(int newWind_kmh);
+
+  int wind_r() const;
+  void setWind_r(int newWind_r);
+
+  QString wind_ltr() const;
+  void setWind_ltr(const QString &newWind_ltr);
+
+  int visibility() const;
+  void setVisibility(int newVisibility);
+
+  int neersl() const;
+  void setNeersl(int newNeersl);
+
+  float luchtd_bar() const;
+  void setLuchtd_bar(float newLuchtd_bar);
+
+  float luchtdmmhg() const;
+  void setLuchtdmmhg(float newLuchtdmmhg);
+
+  float luchtdinHg() const;
+  void setLuchtdinHg(float newLuchtdinHg);
+
+  int hw() const;
+  void setHw(int newHw);
+
+  int mw() const;
+  void setMw(int newMw);
+
+  int lw() const;
+  void setLw(int newLw);
+
+  int tw() const;
+  void setTw(int newTw);
+
+  int rv() const;
+  void setRv(int newRv);
+
+  int gr() const;
+  void setGr(int newGr);
+
+  int gr_w() const;
+  void setGr_w(int newGr_w);
+
+  QString cape() const;
+  void setCape(const QString &newCape);
+
+  int snd() const;
+  void setSnd(int newSnd);
+
+  int snv() const;
+  void setSnv(int newSnv);
+
+  int cond() const;
+  void setCond(int newCond);
+
+  int iconCode() const;
+  void setIconCode(int newIconCode);
+
+  QString sameenv() const;
+  void setSameenv(const QString &newSameenv);
+
+  QString icoon() const;
+  void setIcoon(const QString &newIcoon);
+
+  void print();
+
+signals:
+  void tijdChanged();
+  void tijd_nlChanged();
+
+  void offsetChanged();
+
+  void tempChanged();
+
+  void wind_msChanged();
+
+  void wind_bfChanged();
+
+  void wind_knpChanged();
+
+  void wind_kmhChanged();
+
+  void wind_rChanged();
+
+  void wind_ltrChanged();
+
+  void visibilityChanged();
+
+  void neerslChanged();
+
+  void luchtd_barChanged();
+
+  void luchtdmmhgChanged();
+
+  void luchtdinHgChanged();
+
+  void hwChanged();
+
+  void mwChanged();
+
+  void lwChanged();
+
+  void twChanged();
+
+  void rvChanged();
+
+  void grChanged();
+
+  void gr_wChanged();
+
+  void capeChanged();
+
+  void sndChanged();
+
+  void snvChanged();
+
+  void condChanged();
+
+  void iconCodeChanged();
+
+  void sameenvChanged();
+
+  void icoonChanged();
+
+private:
+  long m_tijd;
+  QString m_tijd_nl;
+  int m_offset;
+  float m_temp;
+  int m_wind_ms;
+  int m_wind_bf;
+  int m_wind_knp;
+  int m_wind_kmh;
+  int m_wind_r;
+  QString m_wind_ltr;
+  int m_visibility;
+  int m_neersl;
+  float m_luchtd_bar;
+  float m_luchtdmmhg;
+  float m_luchtdinHg;
+  int m_hw;
+  int m_mw;
+  int m_lw;
+  int m_tw;
+  int m_rv;
+  int m_gr;
+  int m_gr_w;
+  QString m_cape;
+  int m_snd;
+  int m_snv;
+  int m_cond;
+  int m_iconCode;
+  QString m_sameenv;
+  QString m_icoon;
+};
+
+#endif // WEATHERDATA_H

mvc/data/weatherdetailsdata.cpp

@@ -0,0 +1,84 @@
+#include "weatherdetailsdata.h"
+#include <QJsonArray>
+#include <qjsonobject.h>
+
+WeatherDetailsData::WeatherDetailsData(QObject *parent) : QObject{parent} {}
+
+WeatherDetailsData::WeatherDetailsData(std::shared_ptr<WeatherController> &ctrl)
+    : m_localWeatherCtrl(ctrl) {}
+
+QString WeatherDetailsData::weatherStatus() const { return m_weatherStatus; }
+
+void WeatherDetailsData::setWeatherStatus(QString newWeatherStatus) {
+  if (m_weatherStatus == newWeatherStatus)
+    return;
+  m_weatherStatus = newWeatherStatus;
+  emit weatherStatusChanged();
+}
+
+double WeatherDetailsData::temperature() const { return m_temperature; }
+
+void WeatherDetailsData::setTemperature(double newTemperature) {
+  if (qFuzzyCompare(m_temperature, newTemperature))
+    return;
+  m_temperature = newTemperature;
+  emit temperatureChanged();
+}
+
+double WeatherDetailsData::humidity() const { return m_humidity; }
+
+void WeatherDetailsData::setHumidity(double newHumidity) {
+  if (qFuzzyCompare(m_humidity, newHumidity))
+    return;
+  m_humidity = newHumidity;
+  emit humidityChanged();
+}
+
+double WeatherDetailsData::windSpeed() const { return m_windSpeed; }
+
+void WeatherDetailsData::setWindSpeed(double newWindSpeed) {
+  if (qFuzzyCompare(m_windSpeed, newWindSpeed))
+    return;
+  m_windSpeed = newWindSpeed;
+  emit windSpeedChanged();
+}
+
+double WeatherDetailsData::precipitation() const { return m_precipitation; }
+
+void WeatherDetailsData::setPrecipitation(double newPrecipitation) {
+  if (qFuzzyCompare(m_precipitation, newPrecipitation))
+    return;
+  m_precipitation = newPrecipitation;
+  emit precipitationChanged();
+}
+
+void WeatherDetailsData::populate(double temperature, double humidity,
+                                  double windSpeed, double precipitation,
+                                  QString weatherStatus) {
+  setTemperature(temperature);
+  setHumidity(humidity);
+  setWindSpeed(windSpeed);
+  setPrecipitation(precipitation);
+  setWeatherStatus(weatherStatus);
+}
+
+void WeatherDetailsData::populate(QGeoCoordinate coord) {
+  QJsonObject obj = m_localWeatherCtrl->fetchCurrentWeatherData(coord);
+  QJsonArray liveweerArray = obj["liveweer"].toArray();
+  QJsonObject firstEntry = liveweerArray.at(0).toObject();
+  QString temp = verifyForDash(firstEntry["temp"].toString());
+  QString humidity = verifyForDash(firstEntry["lv"].toString());
+  QString windSpeed = verifyForDash(firstEntry["windkmh"].toString());
+  QString precipitation = verifyForDash(firstEntry["neerslagints"].toString());
+  QString weatherStatus = verifyForDash(firstEntry["image"].toString());
+  populate(temp.toDouble(), humidity.toDouble(), windSpeed.toDouble(),
+           precipitation.toDouble(), weatherStatus);
+}
+
+QString WeatherDetailsData::getImgSrc(QString status) {
+  return QString("qrc:/images/live_icons/%1.png").arg(status);
+}
+
+QString WeatherDetailsData::verifyForDash(QString data) {
+  return data == "-" ? "0" : data;
+}

mvc/data/weatherdetailsdata.h

@@ -0,0 +1,81 @@
+#ifndef WEATHERDETAILSDATA_H
+#define WEATHERDETAILSDATA_H
+
+#include <QObject>
+#include "../controller/weathercontroller.h"
+#include "enums/weatherstatus.h"
+#include <QObject>
+
+class WeatherDetailsData : public QObject {
+  Q_OBJECT
+public:
+  enum LIVE_ICON_NAME {
+    zonnig,
+    bliksem,
+    regen,
+    buien,
+    hagel,
+    mist,
+    sneeuw,
+    bewolkt,
+    halfbewolkt,
+    zwaarbewolkt,
+    lichtbewolkt,
+    nachtmist,
+    helderenacht,
+    wolkennacht
+  };
+  Q_ENUM(LIVE_ICON_NAME)
+
+  explicit WeatherDetailsData(QObject *parent = nullptr);
+  WeatherDetailsData(std::shared_ptr<WeatherController> &ctrl);
+
+  Q_PROPERTY(double temperature READ temperature WRITE setTemperature NOTIFY
+                 temperatureChanged FINAL)
+  Q_PROPERTY(double humidity READ humidity WRITE setHumidity NOTIFY
+                 humidityChanged FINAL)
+  Q_PROPERTY(double windSpeed READ windSpeed WRITE setWindSpeed NOTIFY
+                 windSpeedChanged FINAL)
+  Q_PROPERTY(double precipitation READ precipitation WRITE setPrecipitation
+                 NOTIFY precipitationChanged FINAL)
+  Q_PROPERTY(QString weatherStatus READ weatherStatus WRITE setWeatherStatus
+                 NOTIFY weatherStatusChanged FINAL)
+
+  QString weatherStatus() const;
+  void setWeatherStatus(QString newWeatherStatus);
+
+  double temperature() const;
+  void setTemperature(double newTemperature);
+
+  double humidity() const;
+  void setHumidity(double newHumidity);
+
+  double windSpeed() const;
+  void setWindSpeed(double newWindSpeed);
+
+  double precipitation() const;
+  void setPrecipitation(double newPrecipitation);
+
+  void populate(double temperature, double humidity, double windSpeed,
+                double precipitation, QString weatherStatus);
+  Q_INVOKABLE void populate(QGeoCoordinate coord);
+  Q_INVOKABLE QString getImgSrc(QString status);
+
+signals:
+  void weatherStatusChanged();
+  void temperatureChanged();
+  void humidityChanged();
+  void windSpeedChanged();
+  void precipitationChanged();
+
+private:
+    QString m_weatherStatus = "regen";
+    double m_temperature = 0.0;
+    double m_humidity = 0.0;
+    double m_windSpeed = 0.0;
+    double m_precipitation = 0.0;
+    std::shared_ptr<WeatherController> m_localWeatherCtrl;
+    QString verifyForDash(QString data);
+};
+
+#endif // WEATHERDETAILSDATA_H

mvc/enums/weatherstatus.h

@@ -0,0 +1,20 @@
+#ifndef WEATHERSTATUS_H
+#define WEATHERSTATUS_H
+
+#include <stdint.h>
+
+enum WeatherStatus : uint8_t {
+  UNKNOWN = 0,
+  SUNNY,
+  PARTLY_CLOUDY,
+  CLOUDY,
+  RAINY,
+  SNOWING,
+  HAILSTORM,
+  FROZED_TO_DEAD,
+  THUNDERSTORM,
+  TSUNAMI
+
+};
+
+#endif // WEATHERSTATUS_H

mvc/model/mapdatamodel.cpp

@@ -0,0 +1,34 @@
+// #include "mapdatamodel.h"
+
+// MapDataModel::MapDataModel(QObject *parent) {}
+
+// int MapDataModel::rowCount(const QModelIndex &parent) const
+// {
+//     return mDatas.size();
+// }
+
+// int MapDataModel::columnCount(const QModelIndex &parent) const
+// {
+
+// }
+
+// QVariant MapDataModel::data(const QModelIndex &index, int role) const
+// {
+//     if (!index.isValid())
+//         return QVariant();
+//     if ( role == Qt::DisplayRole)
+//     {
+//         if ( index.column() == 0)
+//             return mDatas[index.row()].waypoints();
+//         if ( index.column() == 1)
+//             return mDatas[index.row()].longitude();
+//         if ( index.column() == 2)
+//             return mDatas[index.row()].altitude();
+//     }
+//     return QVariant();
+// }
+
+// void MapDataModel::populate()
+// {
+
+// }

mvc/model/mapdatamodel.h

@@ -0,0 +1,22 @@
+// #ifndef MAPDATAMODEL_H
+// #define MAPDATAMODEL_H
+
+// #include <QAbstractItemModel >
+// #include <QObject>
+// #include "../data/mapdata.h"
+
+// class MapDataModel : public QAbstractItemModel
+// {
+//     Q_OBJECT
+// public:
+//     MapDataModel(QObject * parent = 0);
+//     int rowCount(const QModelIndex& parent = QModelIndex()) const;
+//     int columnCount(const QModelIndex& parent = QModelIndex()) const;
+//     QVariant data(const QModelIndex &index, int role) const;
+//     void populate();
+
+// private:
+//     QList<MapData> mDatas;
+// };
+
+// #endif // MAPDATAMODEL_H

qml/CustomInputField.qml

@@ -0,0 +1,50 @@
+import QtQuick
+import QtQuick.Controls
+
+Rectangle {
+    property alias logoSrc: logoImage.source
+    property alias placeHolderText: textInput.placeholderText
+    property alias text: textInput.text
+
+    Rectangle
+    {
+        id: logoRect
+        width: parent.width * 0.1
+        height: parent.height
+        anchors.left: parent.left
+        anchors.top: parent.top
+        anchors.verticalCenter: parent.verticalCenter
+        color: "transparent"
+        Image
+        {
+            id: logoImage
+            anchors.fill: parent
+            fillMode: Image.PreserveAspectFit
+            anchors.verticalCenter: parent.verticalCenter
+            z: parent.z + 1
+        }
+    }
+
+    Rectangle
+    {
+        id: inputRect
+        width: parent.width * 0.9
+        height: parent.height
+        anchors.left: logoRect.right
+        anchors.top: parent.top
+        anchors.verticalCenter: parent.verticalCenter
+        color: "transparent"
+        radius: parent.radius
+        TextField
+        {
+            id: textInput
+            anchors.fill: parent
+            onPressed: textInput.forceActiveFocus()
+            background: Rectangle{
+                width: inputRect.width
+                height:inputRect.height
+                radius: inputRect.radius
+            }
+        }
+    }
+}

qml/HomeScreen.qml

@@ -0,0 +1,97 @@
+import QtQuick
+import QtQuick.Controls
+
+Rectangle {
+    id: root
+    anchors.fill: parent
+    border.color: "black"
+    border.width: 2
+    color: "transparent"
+    readonly property int radius:  width * 0.025
+
+    Component.onCompleted:
+    {
+        mapView.positionSource.start()
+        weatherDetailsData.populate(mapView.positionSource.position.coordinate)
+    }
+
+    CustomInputField
+    {
+        id: inputFrom
+        width: parent.width - (2 * anchors.margins)
+        height: parent.height * 0.05
+        anchors.horizontalCenter: parent.horizontalCenter
+        anchors.top: parent.top
+        anchors.margins: parent.width * 0.01
+        anchors.topMargin: parent.width * 0.02
+        logoSrc: "qrc:/images/start_location.svg"
+        placeHolderText: "Start"
+        z: mapView.z + 1
+        radius: root.radius
+    }
+
+    CustomInputField
+    {
+        id: inputTo
+        width: parent.width - (2 * anchors.margins)
+        height: parent.height * 0.05
+        anchors.horizontalCenter: parent.horizontalCenter
+        anchors.top: inputFrom.bottom
+        anchors.margins: parent.width * 0.01
+        logoSrc: "qrc:/images/Destination_location.png"
+        placeHolderText: "Destination"
+        z: mapView.z + 1
+        radius: root.radius
+    }
+
+    MapView
+    {
+        id: mapView
+        anchors.fill: parent
+        radius: root.radius
+    }
+
+    Button
+    {
+        id: myLocationButton
+        width: parent.width * 0.1
+        height: width
+        anchors.right: parent.right
+        anchors.bottom: weatherDetails.top
+        anchors.margins: parent.width * 0.01
+        background: Rectangle
+        {
+            anchors.fill: parent
+            color:"darkgray"
+            radius: width/2
+            Image
+            {
+                source: "qrc:/images/centerToGPS.png"
+                fillMode: Image.PreserveAspectFit
+                anchors.horizontalCenter: parent.horizontalCenter
+                anchors.verticalCenter: parent.verticalCenter
+            }
+        }
+        onClicked:
+        {
+            mapView.resetZoomLevel()
+        }
+        z: mapView.z + 1
+    }
+
+    WeatherDetailsView
+    {
+        id: weatherDetails
+        width: parent.width
+        height: parent.height * 0.1
+        anchors.horizontalCenter: parent.horizontalCenter
+        anchors.bottom: parent.bottom
+        z: mapView.z + 1
+        radius: root.radius
+        imgSrc: weatherDetailsData.getImgSrc(weatherDetailsData.weatherStatus)
+        temperature: weatherDetailsData.temperature
+        precipitation: weatherDetailsData.precipitation
+        windSpeed: weatherDetailsData.windSpeed
+        humidity: weatherDetailsData.humidity
+    }
+}

qml/MapView.qml

@@ -0,0 +1,107 @@
+import QtQuick
+import QtLocation
+import QtPositioning
+
+Rectangle  {
+    property alias positionSource: positionSource
+    property variant waypoints: mapData.waypoints
+
+    function resetZoomLevel()
+    {
+        map.zoomLevel = mapData.defaultZoomLevel
+        map.bearing = 0;
+        positionSource.start()
+    }
+
+    Plugin {
+        id: mapPlugin
+        name: "osm"
+        PluginParameter {
+            name: "osm.mapping.providersrepository.disabled"
+            value: "true"
+        }
+        PluginParameter {
+            name: "osm.mapping.providersrepository.address"
+            value: "http://maps-redirect.qt.io/osm/5.6/"
+        }
+    }
+
+    PositionSource
+    {
+        id: positionSource
+        updateInterval: mapData.gpsUpdateInterval
+        active: true
+        onPositionChanged: {
+            var coord = positionSource.position.coordinate;
+            map.visible = true;
+            map.center = positionSource.position.coordinate;
+        }
+    }
+
+    MapQuickItem {
+        id: marker
+        zoomLevel: map.zoomLevel
+        anchorPoint.x: image.width/2
+        anchorPoint.y: image.height
+        coordinate: positionSource.position.coordinate
+
+        sourceItem: Image {
+            id: image
+            height: 40
+            width: height*2/3
+            source: "qrc:/images/currentLocationOfWaypoint.svg"
+            transform: Rotation { origin.x: marker.anchorPoint.x; origin.y: marker.anchorPoint.y; angle: map.bearing}
+        }
+        Component.onCompleted: map.addMapItem(marker)
+    }
+
+    Map {
+        id: map
+        anchors.fill: parent
+        plugin: mapPlugin
+        center: QtPositioning.coordinate(59.91, 10.75) // Oslo
+        zoomLevel: mapData.zoomLevel
+        property geoCoordinate startCentroid
+
+        PinchHandler {
+            id: pinch
+            target: null
+            onActiveChanged: if (active) {
+                map.startCentroid = map.toCoordinate(pinch.centroid.position, false)
+            }
+            onScaleChanged: (delta) => {
+                map.zoomLevel += Math.log2(delta)
+                map.alignCoordinateToPoint(map.startCentroid, pinch.centroid.position)
+            }
+            onRotationChanged: (delta) => {
+                map.bearing -= delta
+                map.alignCoordinateToPoint(map.startCentroid, pinch.centroid.position)
+            }
+            grabPermissions: PointerHandler.TakeOverForbidden
+        }
+        WheelHandler {
+            id: wheel
+            acceptedDevices: Qt.platform.pluginName === "cocoa" || Qt.platform.pluginName === "wayland"
+                             ? PointerDevice.Mouse | PointerDevice.TouchPad
+                             : PointerDevice.Mouse
+            rotationScale: 1/120
+            property: "zoomLevel"
+        }
+        DragHandler {
+            id: drag
+            target: null
+            onTranslationChanged: (delta) => map.pan(-delta.x, -delta.y)
+            // onGrabChanged: positionSource.active = false
+        }
+        Shortcut {
+            enabled: map.zoomLevel < map.maximumZoomLevel
+            sequence: StandardKey.ZoomIn
+            onActivated: map.zoomLevel = Math.round(map.zoomLevel + 1)
+        }
+        Shortcut {
+            enabled: map.zoomLevel > map.minimumZoomLevel
+            sequence: StandardKey.ZoomOut
+            onActivated: map.zoomLevel = Math.round(map.zoomLevel - 1)
+        }
+    }
+}

qml/WaypointData.qml

@@ -0,0 +1,5 @@
+import QtQuick 2.15
+
+Item {
+
+}

qml/WeatherDetailsView.qml

@@ -0,0 +1,119 @@
+import QtQuick
+
+Rectangle {
+    id: root
+    property alias imgSrc: image.source
+    property alias temperature: tempValue.text
+    property alias humidity: humidityValue.text
+    property alias precipitation: precipValue.text
+    property alias windSpeed: windValue.text
+
+    property double rightMargin: root.width * 0.05
+
+    Rectangle
+    {
+        id: imageRect
+        width: parent.width * 0.2
+        height: parent.height
+        anchors.left: parent.left
+        anchors.top: parent.top
+        radius: 15
+        color: "black"
+        Image
+        {
+            id: image
+            fillMode: Image.PreserveAspectFit
+            anchors.horizontalCenter: parent.horizontalCenter
+            anchors.verticalCenter: parent.verticalCenter
+        }
+    }
+    Rectangle
+    {
+        id: tempRect
+        width: parent.width * 0.4
+        height: parent.height * 0.5
+        anchors.left: imageRect.right
+        anchors.top: parent.top
+        Text
+        {
+            id: tempLabel
+            text: "Temp (C):"
+            anchors.left: parent.left
+            anchors.verticalCenter: parent.verticalCenter
+        }
+        Text
+        {
+            id: tempValue
+            anchors.right: parent.right
+            anchors.verticalCenter: parent.verticalCenter
+            anchors.rightMargin: root.rightMargin
+        }
+    }
+    Rectangle
+    {
+        id: humidityRect
+        width: parent.width * 0.4
+        height: parent.height * 0.5
+        anchors.left: tempRect.right
+        anchors.top: parent.top
+        Text
+        {
+            id: humidityLabel
+            text: "Humidity (%):"
+            anchors.left: parent.left
+            anchors.verticalCenter: parent.verticalCenter
+        }
+        Text
+        {
+            id: humidityValue
+            anchors.right: parent.right
+            anchors.rightMargin: root.rightMargin
+            anchors.verticalCenter: parent.verticalCenter
+        }
+    }
+    Rectangle
+    {
+        id: precipRect
+        width: parent.width * 0.4
+        height: parent.height * 0.5
+        anchors.left: imageRect.right
+        anchors.top: tempRect.bottom
+        Text
+        {
+            id: precipLabel
+            text: "Precipitation (mm)"
+            anchors.left: parent.left
+            anchors.verticalCenter: parent.verticalCenter
+
+        }
+        Text
+        {
+            id: precipValue
+            anchors.right: parent.right
+            anchors.verticalCenter: parent.verticalCenter
+            anchors.rightMargin: root.rightMargin
+        }
+    }
+    Rectangle
+    {
+        id: windRect
+        width: parent.width * 0.4
+        height: parent.height * 0.5
+        anchors.left: tempRect.right
+        anchors.top: humidityRect.bottom
+        Text
+        {
+            id: windLabel
+            text: "Wind (km/h):"
+            anchors.left: parent.left
+            anchors.verticalCenter: parent.verticalCenter
+        }
+        Text
+        {
+            id: windValue
+            anchors.right: parent.right
+            anchors.verticalCenter: parent.verticalCenter
+            anchors.rightMargin: root.rightMargin
+        }
+    }
+}

resources.qrc

@@ -0,0 +1,28 @@
+<RCC>
+    <qresource prefix="/">
+        <file>images/Destination_location.png</file>
+        <file>images/start_location.png</file>
+        <file>images/weather_partly_cloudy_day.png</file>
+        <file>images/weather_rainy.png</file>
+        <file>images/weather_sunny.png</file>
+        <file>images/weather_thunderstorm.png</file>
+        <file>images/weather_tsunami.png</file>
+        <file>images/start_location.svg</file>
+        <file>images/centerToGPS.png</file>
+        <file>images/currentLocationOfWaypoint.svg</file>
+        <file>images/live_icons/bewolkt.png</file>
+        <file>images/live_icons/bliksem.png</file>
+        <file>images/live_icons/buien.png</file>
+        <file>images/live_icons/hagel.png</file>
+        <file>images/live_icons/halfbewolkt.png</file>
+        <file>images/live_icons/helderenacht.png</file>
+        <file>images/live_icons/lichtbewolkt.png</file>
+        <file>images/live_icons/mist.png</file>
+        <file>images/live_icons/nachtmist.png</file>
+        <file>images/live_icons/regen.png</file>
+        <file>images/live_icons/sneeuw.png</file>
+        <file>images/live_icons/wolkennacht.png</file>
+        <file>images/live_icons/zonnig.png</file>
+        <file>images/live_icons/zwaarbewolkt.png</file>
+    </qresource>
+</RCC>