Merge lp:~mzanetti/ubuntu-clock-app/add-timezonemodel into lp:~nik90/ubuntu-clock-app/10-world-clocks

[Michael Zanetti]

Add a TimeZoneModel

[lp:~mzanetti/ubuntu-clock-app/add-timezonemodel]

26. By Michael Zanetti on 2014-07-14

add missing endResetModel

[Nekhelesh Ramananthan (nik90)]

Merged into lp:~nik90/ubuntu-clock-app/10-world-clocks

=== modified file 'app/worldclock/WorldCityList.qml'
--- app/worldclock/WorldCityList.qml	2014-07-13 11:25:46 +0000
+++ app/worldclock/WorldCityList.qml	2014-07-14 09:09:10 +0000
@@ -10,33 +10,24 @@
     title: i18n.tr("Select a city")
     visible: false
 
-    XmlListModel {
-        id: worldCityModel;
-
+    TimeZoneModel {
+        id: timeZoneModel
         source: Qt.resolvedUrl("world-city-list.xml")
-        query: "/Cities/City"
-
-        XmlRole { name: "city"; query: "cityName/string()"; isKey: true }
-        XmlRole { name: "country"; query: "countryName/string()"; isKey: true }
-        XmlRole { name: "timezoneID"; query: "timezoneID/string()"; isKey: true }
-    }
-
-    Zone {
-        id: cityTimezone
+        updateInterval: 1000
     }
 
     ListView {
         id: cityList
 
         anchors.fill: parent
-        model: worldCityModel
+        model: timeZoneModel
 
         delegate: ListItem.Subtitled {
             text: city + "," + country
-            subText: timezoneID
+            subText: timezoneID + "(" + localTime + ")"
 
             onClicked: {
-                console.log(cityTimezone.getLocalTime(timezoneID))
+                print(model.timezoneID, model.localTime)
             }
         }
     }

=== modified file 'backend/CMakeLists.txt'
--- backend/CMakeLists.txt	2014-07-13 11:18:31 +0000
+++ backend/CMakeLists.txt	2014-07-14 09:09:10 +0000
@@ -6,6 +6,7 @@
     ubuntu-clock-appbackend_SRCS
     modules/Timezone/backend.cpp
     modules/Timezone/zone.cpp
+    modules/Timezone/timezonemodel.cpp
 )
 
 add_library(ubuntu-clock-appbackend MODULE

=== modified file 'backend/modules/Timezone/backend.cpp'
--- backend/modules/Timezone/backend.cpp	2014-06-06 19:43:43 +0000
+++ backend/modules/Timezone/backend.cpp	2014-07-14 09:09:10 +0000
@@ -2,6 +2,7 @@
 #include <QtQml/QQmlContext>
 #include "backend.h"
 #include "zone.h"
+#include "timezonemodel.h"
 
 
 void BackendPlugin::registerTypes(const char *uri)
@@ -9,6 +10,7 @@
     Q_ASSERT(uri == QLatin1String("Timezone"));
 
     qmlRegisterType<Zone>(uri, 1, 0, "Zone");
+    qmlRegisterType<TimeZoneModel>(uri, 1, 0, "TimeZoneModel");
 }
 
 void BackendPlugin::initializeEngine(QQmlEngine *engine, const char *uri)

=== added file 'backend/modules/Timezone/timezonemodel.cpp'
--- backend/modules/Timezone/timezonemodel.cpp	1970-01-01 00:00:00 +0000
+++ backend/modules/Timezone/timezonemodel.cpp	2014-07-14 09:09:10 +0000
@@ -0,0 +1,214 @@
+
+#include "timezonemodel.h"
+
+#include <QTimeZone>
+#include <QFile>
+#include <QXmlStreamReader>
+#include <QTimeZone>
+#include <QDebug>
+
+TimeZoneModel::TimeZoneModel(QObject *parent):
+    QAbstractListModel(parent)
+{
+    m_updateTimer.setInterval(0);
+    connect(&m_updateTimer, &QTimer::timeout, this, &TimeZoneModel::update);
+}
+
+// In order for Qt/QML to know how many entries our model has, we
+// need to implement rowCount() and return the amount of rows.
+int TimeZoneModel::rowCount(const QModelIndex &parent) const
+{
+    // Qt's models can also handle tables and tree views, so the index
+    // is not just a integer, but consists of a parent, a row and acolumn.
+    // We're just using the siple list mode, so let's ignore the parent.
+    // Using Q_UNUSED(parent) gets rid of the compile warning about the
+    // unused variable.
+    Q_UNUSED(parent)
+
+    return m_timeZones.count();
+}
+
+// This is the main function to get the data out of the model.
+// We need to return our stuff here.
+QVariant TimeZoneModel::data(const QModelIndex &index, int role) const
+{
+    // Again, ignore everything from the index except row. Were' not into tables and trees.
+    int row = index.row();
+
+    // Now, each cell can have multiple values, e.g. a text value, a color value,
+    // an icon value and what not. Those things are selected by using "roles".
+    // We have defined Roles in our .h file. Lets use them here.
+
+    switch (role) {
+    case RoleCityName:
+        return m_timeZones.at(row).cityName;
+    case RoleCountyName:
+        return m_timeZones.at(row).country;
+    case RoleTimeZoneId:
+        return m_timeZones.at(row).timeZoneId;
+    case RoleTimeString:
+        QTimeZone zone(m_timeZones.at(row).timeZoneId.toLatin1());
+        // TODO: pass formatting options as parameter to toString().
+        // see: http://qt-project.org/doc/qt-5/qdate.html#toString
+        return QDateTime::currentDateTime().toTimeZone(zone).toString();
+    }
+
+    // In case the method was called with an invalid index or role, let's
+    // return an empty QVariant
+    return QVariant();
+}
+
+QHash<int, QByteArray> TimeZoneModel::roleNames() const
+{
+    QHash<int, QByteArray> roles;
+    roles.insert(RoleCityName, "city");
+    roles.insert(RoleCountyName, "country");
+    roles.insert(RoleTimeZoneId, "timezoneID");
+    roles.insert(RoleTimeString, "localTime");
+    return roles;
+}
+
+QUrl TimeZoneModel::source() const
+{
+    return m_source;
+}
+
+void TimeZoneModel::setSource(const QUrl &source)
+{
+    if (m_source == source) {
+        // Don't parse the file again if the source is the same already
+        return;
+    }
+
+    // Change the property and let people know by emitting the changed signal
+    m_source = source;
+    emit sourceChanged();
+
+    // Ultimately load the file
+    loadTimeZonesFromXml();
+}
+
+int TimeZoneModel::updateInterval() const
+{
+    return m_updateTimer.interval();
+}
+
+void TimeZoneModel::setUpdateInterval(int updateInterval)
+{
+    if (m_updateTimer.interval() != updateInterval) {
+        m_updateTimer.setInterval(updateInterval);
+        emit updateIntervalChanged();
+
+        if (m_updateTimer.interval() > 0) {
+            m_updateTimer.start();
+        } else {
+            m_updateTimer.stop();
+        }
+    }
+}
+
+void TimeZoneModel::loadTimeZonesFromXml()
+{
+    // Let qml know that the model will be cleared and rebuilt
+    beginResetModel();
+
+    m_timeZones.clear();
+
+    QFile file(m_source.path());
+    if (!file.open(QFile::ReadOnly)) {
+        qWarning() << "Can't open" << m_source << ". Model will be empty.";
+        endResetModel();
+        return;
+    }
+    QXmlStreamReader reader(&file);
+    bool haveCities = false;
+    bool isCityName = false;
+    bool isCountryName = false;
+    bool isTzId = false;
+
+    TimeZone tz;
+    while (!reader.atEnd() && !reader.hasError()) {
+        QXmlStreamReader::TokenType token = reader.readNext();
+
+        // Skip any header
+        if(token == QXmlStreamReader::StartDocument) {
+            continue;
+        }
+
+        if (token == QXmlStreamReader::StartElement) {
+
+            // skip anything outside the Cities tag
+            if (!haveCities) {
+                if (reader.name() == "Cities") {
+                    haveCities = true;
+                }
+                continue;
+            }
+
+            if (reader.name() == "City") {
+                // A new time zone begins. clear tz
+                tz = TimeZone();
+            }
+            if (reader.name() == "cityName") {
+                isCityName = true;
+            }
+            if (reader.name() == "countryName") {
+                isCountryName = true;
+            }
+            if (reader.name() == "timezoneID") {
+                isTzId = true;
+            }
+        }
+
+        if (token == QXmlStreamReader::Characters) {
+
+            if (isCityName) {
+                tz.cityName = reader.text().toString();
+            }
+            if (isCountryName) {
+                tz.country = reader.text().toString();
+            }
+            if (isTzId) {
+                tz.timeZoneId = reader.text().toString();
+            }
+        }
+
+        if (token == QXmlStreamReader::EndElement) {
+            if (reader.name() == "Cities") {
+                haveCities = false;
+            }
+            if (reader.name() == "City") {
+                // A time zone has ended. insert it into list
+                m_timeZones.append(tz);
+                qDebug() << "appended tz:" << tz.cityName << tz.country << tz.timeZoneId;
+            }
+            if (reader.name() == "cityName") {
+                isCityName = false;
+            }
+            if (reader.name() == "countryName") {
+                isCountryName = false;
+            }
+            if (reader.name() == "timezoneID") {
+                isTzId = false;
+            }
+        }
+    }
+
+    // Let QML know that the model is usable again.
+    endResetModel();
+}
+
+void TimeZoneModel::update()
+{
+    // All we have to do is to emit notifications for the view's to re-request
+    // the data for role timezoneID because the time will be calculated on the
+    // fly anyways
+    // For that we emit dataChanged with a startIndex of 0, an endIndex for the
+    // last item and the RoleTimeString as the changed roles.
+
+    QModelIndex startIndex = index(0);
+    QModelIndex endIndex = index(m_timeZones.count() - 1);
+    QVector<int> roles;
+    roles << RoleTimeString;
+    emit dataChanged(startIndex, endIndex, roles);
+}

=== added file 'backend/modules/Timezone/timezonemodel.h'
--- backend/modules/Timezone/timezonemodel.h	1970-01-01 00:00:00 +0000
+++ backend/modules/Timezone/timezonemodel.h	2014-07-14 09:09:10 +0000
@@ -0,0 +1,84 @@
+#ifndef TIMEZONEMODEL_H
+#define TIMEZONEMODEL_H
+
+#include <QAbstractListModel>
+#include <QDateTime>
+#include <QUrl>
+#include <QTimer>
+
+// Create a simple container class to hold our information
+class TimeZone
+{
+public:
+    QString cityName;
+    QString country;
+    QString timeZoneId;
+};
+
+
+
+// We're going to use QAbstractListModel as the base class
+// That makes it compatible to QML's ListView.
+class TimeZoneModel: public QAbstractListModel
+{
+    Q_OBJECT
+
+    // Let's have a source property for the xml file, just like the XmlListModel
+    Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
+
+    // A this property determines the interval for updating time. The default, 0, doesn't update at all
+    Q_PROPERTY(int updateInterval READ updateInterval WRITE setUpdateInterval NOTIFY updateIntervalChanged)
+
+public:
+    enum Roles {
+        RoleCityName,
+        RoleCountyName,
+        RoleTimeZoneId,
+        RoleTimeString
+    };
+
+    // A simple constructor. Add the standard QObject *parent parameter.
+    // That helps Qt with "garbage collection"
+    TimeZoneModel(QObject *parent = 0);
+
+    // Let's override the pure virtual functions (the ones marked as
+    // "virtual" and have "= 0" in the end.
+    int rowCount(const QModelIndex &parent) const override;
+    QVariant data(const QModelIndex &index, int role) const override;
+
+    // As QML can't really deal with the Roles enum above, we need a mapping
+    // between the enum and strings
+    QHash<int, QByteArray> roleNames() const override;
+
+    // We need to implement the READ and WRITE methods of the properties
+    QUrl source() const;
+    void setSource(const QUrl &source);
+
+    int updateInterval() const;
+    void setUpdateInterval(int updateInterval);
+
+signals:
+    // and we need a signal for the NOTIFY when the properties change
+    void sourceChanged();
+    void updateIntervalChanged();
+
+private:
+    // Lets do the xml parsing in a separate function for less messy code
+    void loadTimeZonesFromXml();
+
+private slots:
+    // A private slot that gets called by the updateTimer
+    void update();
+
+private:
+    // Keep a list of TimeZone objects, holding all our timeZones.
+    QList<TimeZone> m_timeZones;
+
+    // And keel a store of the source property
+    QUrl m_source;
+
+    // Have a timer to update stuff
+    QTimer m_updateTimer;
+};
+
+#endif

=== modified file 'backend/modules/Timezone/zone.cpp'
--- backend/modules/Timezone/zone.cpp	2014-07-13 11:25:46 +0000
+++ backend/modules/Timezone/zone.cpp	2014-07-14 09:09:10 +0000
@@ -1,8 +1,12 @@
 #include "zone.h"
 
+// This is the constructor
+// It will only be called once, when a new "Zone" object is created.
+// If you read currentDateTime in here, it'll stick to the time when the
+// Object is created and not reflect the current time when getLocalTime is called.
 Zone::Zone(QObject *parent) :
     QObject(parent),
-    m_time(QDateTime::currentDateTime())
+    m_time(QDateTime::currentDateTime()) // delete this
 {
 
 }
@@ -11,14 +15,28 @@
 
 }
 
-QDateTime Zone::getLocalTime(QByteArray *timezoneID) {
-    // Create a QTimeZone object and initiate it with the timezone ID provided
-    QTimeZone zone = QTimeZone(*timezoneID);
-
-    // Convert the QDateTime object to the timezone provided
-    m_time.toTimeZone(zone);
-
-    qDebug() << m_time;
-
-    return m_time;
+//QDateTime Zone::getLocalTime(QByteArray *timezoneID) {
+//    // Create a QTimeZone object and initiate it with the timezone ID provided
+//    QTimeZone zone = QTimeZone(*timezoneID);
+
+//    // Convert the QDateTime object to the timezone provided
+//    m_time.toTimeZone(zone);
+
+//    qDebug() << m_time;
+
+//    return m_time;
+//}
+
+// In my opinion this should work but it doesn't will ask some other people
+// and report a bug if m suspicion turns out to be true.
+QDateTime Zone::getLocalTime(const QByteArray &timeZoneId) const
+{
+    QTimeZone zone(timeZoneId);
+    return QDateTime::currentDateTime().toTimeZone(zone);
+}
+
+// So. let's use this instead:
+QString Zone::getCurrentTimeString(const QByteArray &timeZoneId) const
+{
+    return getLocalTime(timeZoneId).toString();
 }

=== modified file 'backend/modules/Timezone/zone.h'
--- backend/modules/Timezone/zone.h	2014-07-13 11:25:46 +0000
+++ backend/modules/Timezone/zone.h	2014-07-14 09:09:10 +0000
@@ -22,10 +22,35 @@
      * Public function to receive a Olson Timezone ID as argument and
      * output that timezone's QDateTime object.
     */
-    QDateTime getLocalTime(QByteArray *timezoneID);
+//    QDateTime getLocalTime(QByteArray *timezoneID);
+
+
+// You shouldn't use slots with return values... Instead, make a public
+// function and mark it as Q_INVOKABLE
+public:
+    // You shouldn't use a pointer (*) to QByteArray. There's only very few cases
+    // where that is desirable. Until you understand the difference, better
+    // stick to references (&) like this:
+    Q_INVOKABLE QDateTime getLocalTime(const QByteArray &timeZoneId) const;
+
+    // Marking the parameter and the method "const" is good practice and helps
+    // with keeping the code easier to maintain, but it's not required. Don't
+    // get hung up on those if you're not understanding those yet.
+
+    // You could also just use this:
+    // QDateTime getLocalTime(QByteArray timeZoneId);
+    // That, however, makes the code slower, because it creates a copy of
+    // timeZoneId before passing it into the function. Using & doesn't
+    // do that and refers to the original value. We're using const to make
+    // sure to not accidentally change the original value.
+
+
+    // Workaround for QDateTime losing timezone information
+    Q_INVOKABLE QString getCurrentTimeString(const QByteArray &timeZoneId) const;
+
 
 private:
-    QDateTime m_time;
+    QDateTime m_time; // delete this
 };
 
 #endif // ZONE_H

=== modified file 'ubuntu-clock-app.json'
--- ubuntu-clock-app.json	2014-07-11 03:01:10 +0000
+++ ubuntu-clock-app.json	2014-07-14 09:09:10 +0000
@@ -5,4 +5,4 @@
         "networking"
     ],
     "policy_version": 1.2
-}
+}
\ No newline at end of file