Merge lp:~bfiller/history-service/rtm-14.09-sim-presence into lp:history-service/rtm-14.09

[Bill Filler]

sim presence and call grouping merge from trunk

sim presence and call grouping merge from trunk

=== modified file 'Ubuntu/History/CMakeLists.txt'
--- Ubuntu/History/CMakeLists.txt	2014-07-14 23:05:23 +0000
+++ Ubuntu/History/CMakeLists.txt	2014-08-22 15:31:10 +0000
@@ -2,6 +2,7 @@
 
 set(plugin_SRCS
     historyeventmodel.cpp
+    historygroupedeventsmodel.cpp
     historythreadgroupingproxymodel.cpp
     historyqmltexteventattachment.cpp
     historyqmlfilter.cpp
@@ -15,6 +16,7 @@
 
 set(plugin_HDRS
     historyeventmodel.h
+    historygroupedeventsmodel.h
     historythreadgroupingproxymodel.h
     historyqmltexteventattachment.h
     historyqmlfilter.h

=== modified file 'Ubuntu/History/historyeventmodel.cpp'
--- Ubuntu/History/historyeventmodel.cpp	2014-08-07 19:22:31 +0000
+++ Ubuntu/History/historyeventmodel.cpp	2014-08-22 15:31:10 +0000
@@ -37,7 +37,8 @@
 
 HistoryEventModel::HistoryEventModel(QObject *parent) :
     QAbstractListModel(parent), mCanFetchMore(true), mFilter(0),
-    mSort(0), mType(HistoryThreadModel::EventTypeText), mEventWritingTimer(0), mFetchTimer(0)
+    mSort(new HistoryQmlSort(this)), mType(HistoryThreadModel::EventTypeText),
+    mEventWritingTimer(0), mUpdateTimer(0)
 {
     connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SIGNAL(countChanged()));
     connect(this, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SIGNAL(countChanged()));
@@ -63,7 +64,7 @@
     mRoles[CallDurationRole] = "callDuration";
 
     // create the view and get some objects
-    updateQuery();
+    triggerQueryUpdate();
 }
 
 int HistoryEventModel::rowCount(const QModelIndex &parent) const
@@ -81,7 +82,11 @@
         return QVariant();
     }
 
-    History::Event event = mEvents[index.row()];
+    return eventData(mEvents[index.row()], role);
+}
+
+QVariant HistoryEventModel::eventData(const History::Event &event, int role) const
+{
     History::TextEvent textEvent;
     History::VoiceEvent voiceEvent;
     History::Thread thread;
@@ -194,7 +199,7 @@
         return;
     }
 
-    History::Events events = mView->nextPage();
+    History::Events events = fetchNextPage();
 
     qDebug() << "Got events:" << events.count();
     if (events.isEmpty()) {
@@ -227,11 +232,11 @@
     if (mFilter) {
         connect(mFilter,
                 SIGNAL(filterChanged()),
-                SLOT(updateQuery()));
+                SLOT(triggerQueryUpdate()));
     }
 
     Q_EMIT filterChanged();
-    updateQuery();
+    triggerQueryUpdate();
 }
 
 HistoryQmlSort *HistoryEventModel::sort() const
@@ -250,11 +255,11 @@
     if (mSort) {
         connect(mSort,
                 SIGNAL(sortChanged()),
-                SLOT(updateQuery()));
+                SLOT(triggerQueryUpdate()));
     }
 
     Q_EMIT sortChanged();
-    updateQuery();
+    triggerQueryUpdate();
 }
 
 HistoryThreadModel::EventType HistoryEventModel::type() const
@@ -266,7 +271,7 @@
 {
     mType = value;
     Q_EMIT typeChanged();
-    updateQuery();
+    triggerQueryUpdate();
 }
 
 QString HistoryEventModel::threadIdForParticipants(const QString &accountId, int eventType, const QStringList &participants, int matchFlags, bool create)
@@ -378,7 +383,7 @@
             SLOT(onEventsRemoved(History::Events)));
     connect(mView.data(),
             SIGNAL(invalidated()),
-            SLOT(updateQuery()));
+            SLOT(triggerQueryUpdate()));
 
     mCanFetchMore = true;
     Q_EMIT canFetchMoreChanged();
@@ -391,12 +396,7 @@
     }
     mAttachmentCache.clear();
 
-    if (mFetchTimer) {
-        killTimer(mFetchTimer);
-    }
-
-    // delay the loading of the model data until the settings settle down
-    mFetchTimer = startTimer(100);
+    fetchMore(QModelIndex());
 }
 
 void HistoryEventModel::onEventsAdded(const History::Events &events)
@@ -474,13 +474,18 @@
             qDebug() << "... succeeded!";
             mEventWritingQueue.clear();
         }
-    } else if (event->timerId() == mFetchTimer) {
-        killTimer(mFetchTimer);
-        mFetchTimer = 0;
-        fetchMore(QModelIndex());
+    } else if (event->timerId() == mUpdateTimer) {
+        killTimer(mUpdateTimer);
+        mUpdateTimer = 0;
+        updateQuery();
     }
 }
 
+History::Events HistoryEventModel::fetchNextPage()
+{
+    return mView->nextPage();
+}
+
 QVariant HistoryEventModel::get(int row) const
 {
     if (row >= this->rowCount() || row < 0) {
@@ -489,3 +494,12 @@
 
     return QVariant(mEvents[row].properties());
 }
+
+void HistoryEventModel::triggerQueryUpdate()
+{
+    if (mUpdateTimer) {
+        killTimer(mUpdateTimer);
+    }
+    // delay the loading of the model data until the settings settle down
+    mUpdateTimer = startTimer(100);
+}

=== modified file 'Ubuntu/History/historyeventmodel.h'
--- Ubuntu/History/historyeventmodel.h	2014-08-07 19:22:31 +0000
+++ Ubuntu/History/historyeventmodel.h	2014-08-22 15:31:10 +0000
@@ -53,18 +53,20 @@
         TextReadSubjectRole,
         TextMessageAttachmentsRole,
         CallMissedRole,
-        CallDurationRole
+        CallDurationRole,
+        LastRole
     };
 
     explicit HistoryEventModel(QObject *parent = 0);
 
-    int rowCount(const QModelIndex &parent = QModelIndex()) const;
-    QVariant data(const QModelIndex &index, int role) const;
-
-    Q_INVOKABLE bool canFetchMore(const QModelIndex &parent = QModelIndex()) const;
-    Q_INVOKABLE void fetchMore(const QModelIndex &parent = QModelIndex());
-
-    QHash<int, QByteArray> roleNames() const;
+    virtual int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    virtual QVariant data(const QModelIndex &index, int role) const;
+    QVariant eventData(const History::Event &event, int role) const;
+
+    Q_INVOKABLE virtual bool canFetchMore(const QModelIndex &parent = QModelIndex()) const;
+    Q_INVOKABLE virtual void fetchMore(const QModelIndex &parent = QModelIndex());
+
+    virtual QHash<int, QByteArray> roleNames() const;
 
     HistoryQmlFilter *filter() const;
     void setFilter(HistoryQmlFilter *value);
@@ -85,7 +87,7 @@
     Q_INVOKABLE bool markEventAsRead(const QString &accountId, const QString &threadId, const QString &eventId, int eventType);
 
     Q_INVOKABLE bool removeEventAttachment(const QString &accountId, const QString &threadId, const QString &eventId, int eventType, const QString &attachmentId);
-    Q_INVOKABLE QVariant get(int row) const;
+    Q_INVOKABLE virtual QVariant get(int row) const;
 
 Q_SIGNALS:
     void countChanged();
@@ -95,13 +97,15 @@
     void canFetchMoreChanged();
 
 protected Q_SLOTS:
-    void updateQuery();
-    void onEventsAdded(const History::Events &events);
-    void onEventsModified(const History::Events &events);
-    void onEventsRemoved(const History::Events &events);
+    void triggerQueryUpdate();
+    virtual void updateQuery();
+    virtual void onEventsAdded(const History::Events &events);
+    virtual void onEventsModified(const History::Events &events);
+    virtual void onEventsRemoved(const History::Events &events);
 
 protected:
     void timerEvent(QTimerEvent *event);
+    History::Events fetchNextPage();
 
 private:
     History::EventViewPtr mView;
@@ -114,7 +118,7 @@
     mutable QMap<History::TextEvent, QList<QVariant> > mAttachmentCache;
     History::Events mEventWritingQueue;
     int mEventWritingTimer;
-    int mFetchTimer;
+    int mUpdateTimer;
 };
 
 #endif // HISTORYEVENTMODEL_H

=== added file 'Ubuntu/History/historygroupedeventsmodel.cpp'
--- Ubuntu/History/historygroupedeventsmodel.cpp	1970-01-01 00:00:00 +0000
+++ Ubuntu/History/historygroupedeventsmodel.cpp	2014-08-22 15:31:10 +0000
@@ -0,0 +1,346 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of history-service.
+ *
+ * history-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * history-service 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "historygroupedeventsmodel.h"
+#include "phoneutils_p.h"
+#include "sort.h"
+#include "historyqmlsort.h"
+
+HistoryGroupedEventsModel::HistoryGroupedEventsModel(QObject *parent) :
+    HistoryEventModel(parent)
+{
+}
+
+int HistoryGroupedEventsModel::rowCount(const QModelIndex &parent) const
+{
+    if (parent.isValid()) {
+        return 0;
+    }
+
+    return mEventGroups.count();
+}
+
+QVariant HistoryGroupedEventsModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() < 0 || index.row() >= mEventGroups.count()) {
+        return QVariant();
+    }
+
+    HistoryEventGroup group = mEventGroups[index.row()];
+    QVariant result;
+    QVariantList events;
+
+    switch (role) {
+    case EventsRole:
+        Q_FOREACH(const History::Event &event, group.events) {
+            events << event.properties();
+        }
+        result = events;
+        break;
+    case EventCountRole:
+        result = group.events.count();
+        break;
+    default:
+        result = eventData(group.displayedEvent, role);
+        break;
+    }
+
+    return result;
+}
+
+void HistoryGroupedEventsModel::fetchMore(const QModelIndex &parent)
+{
+    if (!canFetchMore(parent)) {
+        return;
+    }
+
+    History::Events events = fetchNextPage();
+
+    // History already deliver us the events in the right order
+    // but we might have added new entries in the added, removed, modified events.
+    // still, it is less expensive to do a sequential search starting from the bottom
+    // than to do a binary search for each event, as it is very likely that the entries
+    // belong to the bottom part of the model.
+    Q_FOREACH(const History::Event event, events) {
+        bool found = false;
+        int pos = mEventGroups.count() -1;
+        for (; pos >= 0; pos--) {
+            HistoryEventGroup &group = mEventGroups[pos];
+            if (areOfSameGroup(event, group.displayedEvent)) {
+                found = true;
+                addEventToGroup(event, group, pos);
+                break;
+            } else if (isAscending() ? lessThan(group.displayedEvent, event) : lessThan(event, group.displayedEvent)) {
+                break;
+            }
+        }
+
+        if (!found) {
+            // the item goes into a new group right after the position found above
+            pos++;
+            HistoryEventGroup group;
+            group.displayedEvent = event;
+            group.events << event;
+            beginInsertRows(QModelIndex(), pos, pos);
+            mEventGroups.insert(pos, group);
+            endInsertRows();
+        }
+    }
+}
+
+QHash<int, QByteArray> HistoryGroupedEventsModel::roleNames() const
+{
+    QHash<int, QByteArray> roles = HistoryEventModel::roleNames();
+    roles[EventsRole] = "events";
+    roles[EventCountRole] = "eventCount";
+    return roles;
+}
+
+void HistoryGroupedEventsModel::updateQuery()
+{
+    // remove all event groups from the model
+    if (!mEventGroups.isEmpty()) {
+        beginRemoveRows(QModelIndex(), 0, mEventGroups.count() - 1);
+        mEventGroups.clear();
+        endRemoveRows();
+    }
+
+    // and ask HistoryEventModel to update the query and fetch items again
+    HistoryEventModel::updateQuery();
+}
+
+void HistoryGroupedEventsModel::onEventsAdded(const History::Events &events)
+{
+    if (!events.count()) {
+        return;
+    }
+
+    Q_FOREACH(const History::Event &event, events) {
+        int pos = positionForEvent(event);
+
+        // check if the event belongs to the group at the position
+        if (pos >= 0 && pos < mEventGroups.count()) {
+            HistoryEventGroup &group = mEventGroups[pos];
+            if (areOfSameGroup(event, group.displayedEvent)) {
+                addEventToGroup(event, group, pos);
+                continue;
+            }
+        }
+
+        // else, we just create a new group
+        beginInsertRows(QModelIndex(), pos, pos);
+        HistoryEventGroup group;
+        group.displayedEvent = event;
+        group.events << event;
+        mEventGroups.insert(pos, group);
+        endInsertRows();
+
+    }
+}
+
+void HistoryGroupedEventsModel::onEventsModified(const History::Events &events)
+{
+    // FIXME: we are not yet handling events changing the property used for sorting
+    // so for now the behavior is to find the item and check if it needs inserting or
+    // updating in the group, which is exactly what onEventsAdded() does, so:
+    onEventsAdded(events);
+}
+
+void HistoryGroupedEventsModel::onEventsRemoved(const History::Events &events)
+{
+    Q_FOREACH(const History::Event &event, events) {
+        int pos = positionForEvent(event);
+        if (pos < 0 || pos >= rowCount()) {
+            continue;
+        }
+        HistoryEventGroup &group = mEventGroups[pos];
+        if (!group.events.contains(event)) {
+            continue;
+        }
+        removeEventFromGroup(event, group, pos);
+    }
+}
+
+bool HistoryGroupedEventsModel::compareParticipants(const QStringList &list1, const QStringList &list2)
+{
+    if (list1.count() != list2.count()) {
+        return false;
+    }
+
+    int found = 0;
+    Q_FOREACH(const QString &participant, list1) {
+        Q_FOREACH(const QString &item, list2) {
+            if (PhoneUtils::comparePhoneNumbers(participant, item)) {
+                found++;
+                break;
+            }
+        }
+    }
+
+    return found == list1.count();
+}
+
+bool HistoryGroupedEventsModel::areOfSameGroup(const History::Event &event1, const History::Event &event2)
+{
+    QVariantMap props1 = event1.properties();
+    QVariantMap props2 = event2.properties();
+
+    Q_FOREACH(const QString &property, mGroupingProperties) {
+        // first check if the property exists in the maps
+        if (!props1.contains(property) || !props2.contains(property)) {
+            return false;
+        }
+
+        // now check if the values are the same
+        if (property == History::FieldParticipants) {
+            if (!compareParticipants(props1[property].toStringList(),
+                                     props2[property].toStringList())) {
+                return false;
+            }
+        } else if (props1[property] != props2[property]) {
+            return false;
+        }
+    }
+
+    // if it didn't fail before, the events are indeed of the same group
+    return true;
+}
+
+void HistoryGroupedEventsModel::addEventToGroup(const History::Event &event, HistoryEventGroup &group, int row)
+{
+    if (!group.events.contains(event)) {
+        // insert the event in the correct position according to the sort criteria
+        bool append = true;
+        for (int i = 0; i < group.events.count(); ++i) {
+            History::Event &otherEvent = group.events[i];
+            if (isAscending() ? lessThan(event, otherEvent) : lessThan(otherEvent, event)) {
+                group.events.insert(i, event);
+                append = false;
+                break;
+            }
+        }
+
+        // if it is not above any item, just append it
+        if (append) {
+            group.events.append(event);
+        }
+    }
+
+    // now check if the displayed event should be updated
+    History::Event &firstEvent = group.events.first();
+    if (group.displayedEvent != firstEvent) {
+        group.displayedEvent = firstEvent;
+        QModelIndex idx(index(row));
+        Q_EMIT dataChanged(idx, idx);
+    }
+}
+
+void HistoryGroupedEventsModel::removeEventFromGroup(const History::Event &event, HistoryEventGroup &group, int row)
+{
+    if (group.events.contains(event)) {
+        group.events.removeOne(event);
+    }
+
+    if (group.events.isEmpty()) {
+        beginRemoveRows(QModelIndex(), row, row);
+        mEventGroups.removeAt(row);
+        endRemoveRows();
+        return;
+    }
+
+    if (group.displayedEvent == event) {
+        // check what is the event that should be displayed
+       group.displayedEvent =  group.events.first();
+        Q_FOREACH(const History::Event &other, group.events) {
+            if (isAscending() ? lessThan(other, group.displayedEvent) : lessThan(group.displayedEvent, other)) {
+                group.displayedEvent = other;
+            }
+        }
+    }
+    QModelIndex idx = index(row);
+    Q_EMIT dataChanged(idx, idx);
+}
+
+bool HistoryGroupedEventsModel::lessThan(const History::Event &left, const History::Event &right) const
+{
+
+    QVariant leftValue = left.properties()[sort()->sortField()];
+    QVariant rightValue = right.properties()[sort()->sortField()];
+    return leftValue < rightValue;
+}
+
+int HistoryGroupedEventsModel::positionForEvent(const History::Event &event) const
+{
+    // do a binary search for the item position on the list
+    int lowerBound = 0;
+    int upperBound = mEventGroups.count() - 1;
+    if (upperBound < 0) {
+        return 0;
+    }
+
+    while (true) {
+        int pos = (upperBound + lowerBound) / 2;
+        const History::Event &posEvent = mEventGroups[pos].displayedEvent;
+        if (lowerBound == pos) {
+            if (isAscending() ? lessThan(event, posEvent) : lessThan(posEvent, event)) {
+                return pos;
+            }
+        }
+        if (isAscending() ? lessThan(posEvent, event) : lessThan(event, posEvent)) {
+            lowerBound = pos + 1;          // its in the upper
+            if (lowerBound > upperBound) {
+                return pos += 1;
+            }
+        } else if (lowerBound > upperBound) {
+            return pos;
+        } else {
+            upperBound = pos - 1;          // its in the lower
+        }
+    }
+
+}
+
+QVariant HistoryGroupedEventsModel::get(int row) const
+{
+    if (row >= rowCount() || row < 0) {
+        return QVariant();
+    }
+
+    return data(index(row), EventsRole);
+}
+
+
+QStringList HistoryGroupedEventsModel::groupingProperties() const
+{
+    return mGroupingProperties;
+}
+
+void HistoryGroupedEventsModel::setGroupingProperties(const QStringList &properties)
+{
+    mGroupingProperties = properties;
+    Q_EMIT groupingPropertiesChanged();
+    triggerQueryUpdate();
+}
+
+bool HistoryGroupedEventsModel::isAscending() const
+{
+    return sort() && sort()->sort().sortOrder() == Qt::AscendingOrder;
+}

=== added file 'Ubuntu/History/historygroupedeventsmodel.h'
--- Ubuntu/History/historygroupedeventsmodel.h	1970-01-01 00:00:00 +0000
+++ Ubuntu/History/historygroupedeventsmodel.h	2014-08-22 15:31:10 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2014 Canonical, Ltd.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ *
+ * This file is part of history-service.
+ *
+ * history-service is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * history-service 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HISTORYGROUPEDEVENTSMODEL_H
+#define HISTORYGROUPEDEVENTSMODEL_H
+
+#include "historyeventmodel.h"
+
+typedef struct {
+    History::Events events;
+    History::Event displayedEvent;
+} HistoryEventGroup;
+
+class HistoryGroupedEventsModel : public HistoryEventModel
+{
+    Q_OBJECT
+    Q_PROPERTY(QStringList groupingProperties
+               READ groupingProperties
+               WRITE setGroupingProperties
+               NOTIFY groupingPropertiesChanged)
+    Q_ENUMS(GroupedRole)
+public:
+    enum GroupedRole {
+        EventsRole = HistoryEventModel::LastRole,
+        EventCountRole
+    };
+
+    explicit HistoryGroupedEventsModel(QObject *parent = 0);
+
+    // reimplemented from HistoryEventModel
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    QVariant data(const QModelIndex &index, int role) const;
+    Q_INVOKABLE void fetchMore(const QModelIndex &parent = QModelIndex());
+    QHash<int, QByteArray> roleNames() const;
+    Q_INVOKABLE QVariant get(int row) const;
+
+    QStringList groupingProperties() const;
+    void setGroupingProperties(const QStringList &properties);
+
+    bool isAscending() const;
+
+Q_SIGNALS:
+    void groupingPropertiesChanged();
+
+protected Q_SLOTS:
+    void updateQuery();
+    void onEventsAdded(const History::Events &events);
+    void onEventsModified(const History::Events &events);
+    void onEventsRemoved(const History::Events &events);
+
+protected:
+    bool compareParticipants(const QStringList &list1, const QStringList &list2);
+    bool areOfSameGroup(const History::Event &event1, const History::Event &event2);
+    void addEventToGroup(const History::Event &event, HistoryEventGroup &group, int row);
+    void removeEventFromGroup(const History::Event &event, HistoryEventGroup &group, int row);
+    bool lessThan(const History::Event &left, const History::Event &right) const;
+    int positionForEvent(const History::Event &event) const;
+
+private:
+    QStringList mGroupingProperties;
+    QList<HistoryEventGroup> mEventGroups;
+};
+
+#endif // HISTORYGROUPEDEVENTSMODEL_H

=== modified file 'Ubuntu/History/historyqmlplugin.cpp'
--- Ubuntu/History/historyqmlplugin.cpp	2014-07-14 23:05:23 +0000
+++ Ubuntu/History/historyqmlplugin.cpp	2014-08-22 15:31:10 +0000
@@ -27,6 +27,7 @@
 #include "historythreadmodel.h"
 #include "historythreadgroupingproxymodel.h"
 #include "historyeventmodel.h"
+#include "historygroupedeventsmodel.h"
 #include "historyqmltexteventattachment.h"
 #include "sortproxymodel.h"
 #include <QQmlEngine>
@@ -43,6 +44,7 @@
 {
     // @uri History
     qmlRegisterType<HistoryEventModel>(uri, 0, 1, "HistoryEventModel");
+    qmlRegisterType<HistoryGroupedEventsModel>(uri, 0, 1, "HistoryGroupedEventsModel");
     qmlRegisterType<HistoryThreadModel>(uri, 0, 1, "HistoryThreadModel");
     qmlRegisterType<HistoryQmlFilter>(uri, 0, 1, "HistoryFilter");
     qmlRegisterType<HistoryQmlIntersectionFilter>(uri, 0, 1, "HistoryIntersectionFilter");

=== modified file 'Ubuntu/History/historythreadmodel.cpp'
--- Ubuntu/History/historythreadmodel.cpp	2014-08-07 19:22:31 +0000
+++ Ubuntu/History/historythreadmodel.cpp	2014-08-22 15:31:10 +0000
@@ -35,7 +35,8 @@
 Q_DECLARE_METATYPE(History::TextEventAttachments)
 
 HistoryThreadModel::HistoryThreadModel(QObject *parent) :
-    QAbstractListModel(parent), mCanFetchMore(true), mFilter(0), mSort(0), mType(EventTypeText), mFetchTimer(0)
+    QAbstractListModel(parent), mCanFetchMore(true), mFilter(0), mSort(0),
+    mType(EventTypeText), mUpdateTimer(0)
 {
     // configure the roles
     mRoles[AccountIdRole] = "accountId";
@@ -66,7 +67,7 @@
     connect(this, SIGNAL(modelReset()), SIGNAL(countChanged()));
 
     // create the results view
-    updateQuery();
+    triggerQueryUpdate();
 }
 
 int HistoryThreadModel::rowCount(const QModelIndex &parent) const
@@ -213,7 +214,7 @@
 
 void HistoryThreadModel::fetchMore(const QModelIndex &parent)
 {
-    if (parent.isValid()) {
+    if (parent.isValid() || mThreadView.isNull()) {
         return;
     }
 
@@ -249,11 +250,11 @@
     if (mFilter) {
         connect(mFilter,
                 SIGNAL(filterChanged()),
-                SLOT(updateQuery()));
+                SLOT(triggerQueryUpdate()));
     }
 
     Q_EMIT filterChanged();
-    updateQuery();
+    triggerQueryUpdate();
 }
 
 HistoryQmlSort *HistoryThreadModel::sort() const
@@ -272,11 +273,11 @@
     if (mSort) {
         connect(mSort,
                 SIGNAL(sortChanged()),
-                SLOT(updateQuery()));
+                SLOT(triggerQueryUpdate()));
     }
 
     Q_EMIT sortChanged();
-    updateQuery();
+    triggerQueryUpdate();
 }
 
 HistoryThreadModel::EventType HistoryThreadModel::type() const
@@ -288,7 +289,7 @@
 {
     mType = value;
     Q_EMIT typeChanged();
-    updateQuery();
+    triggerQueryUpdate();
 }
 
 QString HistoryThreadModel::threadIdForParticipants(const QString &accountId, int eventType, const QStringList &participants, int matchFlags, bool create)
@@ -324,6 +325,14 @@
     return mThreads[row].properties();
 }
 
+void HistoryThreadModel::triggerQueryUpdate()
+{
+    if (mUpdateTimer) {
+        killTimer(mUpdateTimer);
+    }
+    mUpdateTimer = startTimer(100);
+}
+
 void HistoryThreadModel::updateQuery()
 {
     // remove all events from the model
@@ -363,7 +372,7 @@
             SLOT(onThreadsRemoved(History::Threads)));
     connect(mThreadView.data(),
             SIGNAL(invalidated()),
-            SLOT(updateQuery()));
+            SLOT(triggerQueryUpdate()));
 
     Q_FOREACH(const QVariant &attachment, mAttachmentCache) {
         HistoryQmlTextEventAttachment *qmlAttachment = attachment.value<HistoryQmlTextEventAttachment *>();
@@ -373,16 +382,10 @@
     }
     mAttachmentCache.clear();
 
-    if (mFetchTimer) {
-        killTimer(mFetchTimer);
-    }
-
     // and fetch again
     mCanFetchMore = true;
     Q_EMIT canFetchMoreChanged();
-
-    // delay the loading just to give the settings some time to settle down
-    mFetchTimer = startTimer(100);
+    fetchMore(QModelIndex());
 }
 
 void HistoryThreadModel::onThreadsAdded(const History::Threads &threads)
@@ -430,10 +433,9 @@
 
 void HistoryThreadModel::timerEvent(QTimerEvent *event)
 {
-    if (event->timerId() == mFetchTimer) {
-        killTimer(mFetchTimer);
-        mFetchTimer = 0;
-
-        fetchMore(QModelIndex());
+    if (event->timerId() == mUpdateTimer) {
+        killTimer(mUpdateTimer);
+        mUpdateTimer = 0;
+        updateQuery();
     }
 }

=== modified file 'Ubuntu/History/historythreadmodel.h'
--- Ubuntu/History/historythreadmodel.h	2014-08-07 19:22:31 +0000
+++ Ubuntu/History/historythreadmodel.h	2014-08-22 15:31:10 +0000
@@ -125,6 +125,7 @@
     void canFetchMoreChanged();
 
 protected Q_SLOTS:
+    void triggerQueryUpdate();
     void updateQuery();
     void onThreadsAdded(const History::Threads &threads);
     void onThreadsModified(const History::Threads &threads);
@@ -142,7 +143,7 @@
     EventType mType;
     QHash<int, QByteArray> mRoles;
     mutable QMap<History::TextEvent, QList<QVariant> > mAttachmentCache;
-    int mFetchTimer;
+    int mUpdateTimer;
 };
 
 #endif // HISTORYTHREADMODEL_H

=== modified file 'src/event.cpp'
--- src/event.cpp	2013-09-26 21:06:50 +0000
+++ src/event.cpp	2014-08-22 15:31:10 +0000
@@ -55,6 +55,7 @@
     map[FieldEventId] = eventId;
     map[FieldSenderId] = senderId;
     map[FieldTimestamp] = timestamp.toString(Qt::ISODate);
+    map[FieldDate] = timestamp.date().toString(Qt::ISODate);
     map[FieldNewEvent] = newEvent;
     map[FieldType] = type();
     map[FieldParticipants] = participants;
@@ -243,6 +244,11 @@
     return true;
 }
 
+bool Event::operator!=(const Event &other) const
+{
+    return !(*this == other);
+}
+
 bool Event::operator<(const Event &other) const
 {
     QString selfData = accountId() + threadId() + eventId();

=== modified file 'src/event.h'
--- src/event.h	2013-09-26 21:06:50 +0000
+++ src/event.h	2014-08-22 15:31:10 +0000
@@ -56,6 +56,7 @@
     QVariantMap properties() const;
     bool isNull() const;
     bool operator==(const Event &other) const;
+    bool operator!=(const Event &other) const;
     bool operator<(const Event &other) const;
 
 protected:

=== modified file 'src/types.h'
--- src/types.h	2014-06-25 11:45:09 +0000
+++ src/types.h	2014-08-22 15:31:10 +0000
@@ -106,6 +106,7 @@
 static const char* FieldUnreadCount = "unreadCount";
 static const char* FieldSenderId = "senderId";
 static const char* FieldTimestamp = "timestamp";
+static const char* FieldDate = "date";
 static const char* FieldNewEvent = "newEvent";
 
 // text event fields