diff --git a/framework/src/domain/todomodel.cpp b/framework/src/domain/todomodel.cpp
index b86cb42f..e80c4930 100644
--- a/framework/src/domain/todomodel.cpp
+++ b/framework/src/domain/todomodel.cpp
@@ -1,289 +1,295 @@
 /*
     Copyright (c) 2018 Christian Mollekopf <mollekopf@kolabsys.com>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "todomodel.h"
 
 #include <sink/log.h>
 #include <sink/query.h>
 #include <sink/store.h>
 #include <sink/applicationdomaintype.h>
 
 #include <QMetaEnum>
 
 #include <KCalCore/ICalFormat>
 
 #include <entitycache.h>
 
 using namespace Sink;
 
 TodoSourceModel::TodoSourceModel(QObject *parent)
     : QAbstractItemModel(parent),
     mCalendarCache{EntityCache<ApplicationDomain::Calendar, ApplicationDomain::Calendar::Color>::Ptr::create()}
 {
     mRefreshTimer.setSingleShot(true);
     QObject::connect(&mRefreshTimer, &QTimer::timeout, this, &TodoSourceModel::updateFromSource);
 }
 
 void TodoSourceModel::setCalendarFilter(const QSet<QByteArray> &calendarFilter)
 {
     mCalendarFilter = calendarFilter;
     updateQuery();
 }
 
 void TodoSourceModel::setFilter(const QVariantMap &filter)
 {
     mFilter = filter;
     updateQuery();
 }
 
 void TodoSourceModel::updateQuery()
 {
     using namespace Sink::ApplicationDomain;
     if (mCalendarFilter.isEmpty()) {
         refreshView();
         return;
     }
 
     Sink::Query query;
     // query.resourceFilter<SinkResource::Account>(mAccount);
     query.setFlags(Sink::Query::LiveQuery);
     query.request<Todo::Summary>();
     query.request<Todo::Description>();
     query.request<Todo::StartDate>();
     query.request<Todo::DueDate>();
     query.request<Todo::CompletedDate>();
     query.request<Todo::Status>();
     query.request<Todo::Calendar>();
     query.request<Todo::Ical>();
     query.request<Todo::Priority>();
 
     mSourceModel = Store::loadModel<ApplicationDomain::Todo>(query);
 
     QObject::connect(mSourceModel.data(), &QAbstractItemModel::dataChanged, this, &TodoSourceModel::refreshView);
     QObject::connect(mSourceModel.data(), &QAbstractItemModel::layoutChanged, this, &TodoSourceModel::refreshView);
     QObject::connect(mSourceModel.data(), &QAbstractItemModel::modelReset, this, &TodoSourceModel::refreshView);
     QObject::connect(mSourceModel.data(), &QAbstractItemModel::rowsInserted, this, &TodoSourceModel::refreshView);
     QObject::connect(mSourceModel.data(), &QAbstractItemModel::rowsMoved, this, &TodoSourceModel::refreshView);
     QObject::connect(mSourceModel.data(), &QAbstractItemModel::rowsRemoved, this, &TodoSourceModel::refreshView);
 
     refreshView();
 }
 
 void TodoSourceModel::refreshView()
 {
     if (!mRefreshTimer.isActive()) {
         //Instant update, but then only refresh every 50ms max.
         updateFromSource();
         mRefreshTimer.start(50);
     }
 }
 
 void TodoSourceModel::updateFromSource()
 {
     beginResetModel();
 
     mTodos.clear();
 
     if (mSourceModel) {
         for (int i = 0; i < mSourceModel->rowCount(); ++i) {
             auto todo = mSourceModel->index(i, 0).data(Sink::Store::DomainObjectRole).value<ApplicationDomain::Todo::Ptr>();
             const bool skip = [&] {
                 if (!mCalendarFilter.contains(todo->getCalendar())) {
                     return true;
                 }
-                for (auto it = mFilter.constBegin(); it!= mFilter.constEnd(); it++) {
+                for (auto it = mFilter.constBegin(); it != mFilter.constEnd(); it++) {
                     if (todo->getProperty(it.key().toLatin1()) != it.value()) {
                         return true;
                     }
                 }
                 return false;
             }();
             if (skip) {
                 continue;
             }
 
             //Parse the todo
             if(auto icalTodo = KCalCore::ICalFormat().readIncidence(todo->getIcal()).dynamicCast<KCalCore::Todo>()) {
                 mTodos.append({icalTodo->dtStart(), icalTodo->dtDue(), icalTodo->completed(), icalTodo, getColor(todo->getCalendar()), todo->getStatus(), todo, todo->getPriority()});
             } else {
                 SinkWarning() << "Invalid ICal to process, ignoring...";
             }
         }
     }
 
     endResetModel();
 }
 
 QModelIndex TodoSourceModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!hasIndex(row, column, parent)) {
         return {};
     }
 
     if (!parent.isValid()) {
         return createIndex(row, column);
     }
     return {};
 }
 
 QModelIndex TodoSourceModel::parent(const QModelIndex &) const
 {
     return {};
 }
 
 int TodoSourceModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return mTodos.size();
     }
     return 0;
 }
 
 int TodoSourceModel::columnCount(const QModelIndex &) const
 {
     return 1;
 }
 
 QByteArray TodoSourceModel::getColor(const QByteArray &calendar) const
 {
     const auto color = mCalendarCache->getProperty(calendar, "color").toByteArray();
     if (color.isEmpty()) {
         qWarning() << "Failed to get color for calendar " << calendar;
     }
     return color;
 }
 
 QVariant TodoSourceModel::data(const QModelIndex &idx, int role) const
 {
     if (!hasIndex(idx.row(), idx.column())) {
         return {};
     }
     auto todo = mTodos.at(idx.row());
     auto icalTodo = todo.incidence;
     switch (role) {
         case Summary:
             return icalTodo->summary();
         case Description:
             return icalTodo->description();
         case StartDate:
             return todo.start;
         case DueDate:
             return todo.due;
         case Date:
             if (todo.status == "COMPLETED") {
                 return todo.completed;
             }
             if (todo.due.isValid()) {
                 return todo.due;
             }
             return todo.start;
         case CompletedDate:
             return todo.completed;
         case Color:
             return todo.color;
         case Status:
             return todo.status;
         case Complete:
             return todo.status == "COMPLETED";
         case Doing:
             return todo.status == "INPROCESS";
         case Important:
             return todo.priority == 1;
         case Relevance: {
             int score = 100;
             if (todo.status == "COMPLETED") {
                 score -= 100;
             } else {
                 //TODO add if due date is soon
                 //TODO add more if overdue
                 if (todo.priority == 1) {
                     score += 50;
                 }
                 if (todo.status == "INPROCESS") {
                     score += 100;
                 }
             }
             return score;
         }
         case Todo:
             return QVariant::fromValue(todo.domainObject);
         default:
             SinkWarning() << "Unknown role for todo:" << QMetaEnum::fromType<Roles>().valueToKey(role) << role;
             return {};
     }
 }
 
 QHash<int, QByteArray> TodoSourceModel::roleNames() const
 {
     return {
         {Summary, "summary"},
         {Description, "description"},
         {StartDate, "startDate"},
         {DueDate, "dueDate"},
         {CompletedDate, "completedDate"},
         {Date, "date"},
         {Color, "color"},
         {Status, "status"},
         {Complete, "complete"},
         {Doing, "doing"},
         {Important, "important"},
         {Todo, "domainObject"}
     };
 }
 
 
 
 TodoModel::TodoModel(QObject *parent)
     : QSortFilterProxyModel(parent)
 {
     setDynamicSortFilter(true);
     sort(0, Qt::DescendingOrder);
     setFilterCaseSensitivity(Qt::CaseInsensitive);
     setSourceModel(new TodoSourceModel(this));
 }
 
 QHash<int, QByteArray> TodoModel::roleNames() const
 {
     return sourceModel()->roleNames();
 }
 
 void TodoModel::setCalendarFilter(const QSet<QByteArray> &filter)
 {
     static_cast<TodoSourceModel*>(sourceModel())->setCalendarFilter(filter);
 }
 
-void TodoModel::setFilter(const QVariantMap &filter)
+void TodoModel::setFilter(const QVariantMap &f)
 {
+    auto filter = f;
+    if (filter.contains("doing")) {
+        if (filter.take("doing").toBool()) {
+            filter.insert("status", "INPROCESS");
+        }
+    }
     static_cast<TodoSourceModel*>(sourceModel())->setFilter(filter);
 }
 
 bool TodoModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
 {
     const auto leftScore = left.data(TodoSourceModel::Relevance).toInt();
     const auto rightScore = right.data(TodoSourceModel::Relevance).toInt();
     if (leftScore == rightScore) {
         return left.data(TodoSourceModel::Summary) < right.data(TodoSourceModel::Summary);
     }
     return leftScore < rightScore;
 }
 
 bool TodoModel::filterAcceptsRow(int /*sourceRow*/, const QModelIndex &/*sourceParent*/) const
 {
     return true;
 }
diff --git a/views/todo/qml/View.qml b/views/todo/qml/View.qml
index 49a64339..ba03c0f6 100644
--- a/views/todo/qml/View.qml
+++ b/views/todo/qml/View.qml
@@ -1,345 +1,391 @@
 /*
  *  Copyright (C) 2017 Michael Bohlender, <michael.bohlender@kdemail.net>
  *  Copyright (C) 2017 Christian Mollekopf, <mollekopf@kolabsys.com>
  *
  *  This program 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; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License along
  *  with this program; if not, write to the Free Software Foundation, Inc.,
  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 
 import QtQuick 2.9
 import QtQuick.Controls 1.3 as Controls1
 import QtQuick.Controls 2
 import QtQuick.Layouts 1.1
 
 import org.kube.framework 1.0 as Kube
 
 Kube.View {
     id: root
     property alias currentAccount: accountSwitcher.currentAccount
     // property variant currentFolder: null
 
     //We have to hardcode because all the mapToItem/mapFromItem functions are garbage
     // searchArea: Qt.rect(ApplicationWindow.window.sidebarWidth + mailListView.parent.x, 0, (mailView.x + mailView.width) - mailListView.parent.x, (mailView.y + mailView.height) - mailListView.y)
 
     onFilterChanged: {
         Kube.Fabric.postMessage(Kube.Messages.searchString, {"searchString": filter})
     }
 
     onRefresh: {
         // if (!!root.currentFolder) {
         //     Kube.Fabric.postMessage(Kube.Messages.synchronize, {"folder": root.currentFolder});
         //     Kube.Fabric.postMessage(Kube.Messages.synchronize, {"accountId": root.currentAccount, "type": "folder"})
         // } else {
             Kube.Fabric.postMessage(Kube.Messages.synchronize, {"accountId": root.currentAccount})
         // }
     }
 
     Kube.Listener {
         filter: Kube.Messages.search
         onMessageReceived: root.triggerSearch()
     }
 
     helpViewComponent: Kube.HelpPopup {
         ListModel {
             ListElement { description: qsTr("Jump to next thread:"); shortcut: "j" }
             ListElement { description: qsTr("Jump to previous thread:"); shortcut: "k" }
             ListElement { description: qsTr("Jump to next message:"); shortcut: "n" }
             ListElement { description: qsTr("Jump to previous message:"); shortcut: "p" }
             ListElement { description: qsTr("Jump to next folder:"); shortcut: "f,n" }
             ListElement { description: qsTr("Jump to previous previous folder:"); shortcut: "f,p" }
             ListElement { description: qsTr("Compose new message:"); shortcut: "c" }
             ListElement { description: qsTr("Reply to the currently focused message:"); shortcut: "r" }
             ListElement { description: qsTr("Delete the currently focused message:"); shortcut: "d" }
             ListElement { description: qsTr("Mark the currently focused message as important:"); shortcut: "i" }
             ListElement { description: qsTr("Mark the currently focused message as unread:"); shortcut: "u" }
             ListElement { description: qsTr("Show this help text:"); shortcut: "?" }
         }
     }
 
     Shortcut {
         sequences: ['j']
         onActivated: Kube.Fabric.postMessage(Kube.Messages.selectNextConversation, {})
     }
     Shortcut {
         sequences: ['k']
         onActivated: Kube.Fabric.postMessage(Kube.Messages.selectPreviousConversation, {})
     }
     Shortcut {
         sequences: ['f,n']
         onActivated: Kube.Fabric.postMessage(Kube.Messages.selectNextFolder, {})
     }
     Shortcut {
         sequences: ['f,p']
         onActivated: Kube.Fabric.postMessage(Kube.Messages.selectPreviousFolder, {})
     }
     Shortcut {
         sequences: ['c']
         onActivated: Kube.Fabric.postMessage(Kube.Messages.compose, {})
     }
     Shortcut {
         sequence: "?"
         onActivated: root.showHelp()
     }
 
+    ButtonGroup { id: viewButtonGroup }
 
     Controls1.SplitView {
         Layout.fillWidth: true
         Layout.fillHeight: true
         Rectangle {
             width: Kube.Units.gridUnit * 10
             Layout.fillHeight: parent.height
             color: Kube.Colors.darkBackgroundColor
 
-            Kube.PositiveButton {
-                id: newMailButton
-                objectName: "newMailButton"
-
+            Column {
+                id: topLayout
                 anchors {
                     top: parent.top
                     left: parent.left
                     right: parent.right
                     margins: Kube.Units.largeSpacing
                 }
-                focus: true
-                text: qsTr("New Todo")
-                onClicked: editorPopup.createObject(root, {}).open()
+
+                Kube.PositiveButton {
+                    id: newMailButton
+                    objectName: "newMailButton"
+
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                    }
+                    focus: true
+                    text: qsTr("New Todo")
+                    onClicked: editorPopup.createObject(root, {}).open()
+                }
+
+                Item {
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                    }
+                    height: Kube.Units.gridUnit
+                }
+
+                Kube.TextButton {
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                    }
+                    text: qsTr("Today")
+                    textColor: Kube.Colors.highlightedTextColor
+                    checkable: true
+                    checked: true
+                    horizontalAlignment: Text.AlignHLeft
+                    ButtonGroup.group: viewButtonGroup
+                    onClicked: todoModel.filter = {"doing": true}
+                }
+                Kube.TextButton {
+                    id: allViewButton
+                    anchors {
+                        left: parent.left
+                        right: parent.right
+                    }
+                    text: qsTr("All")
+                    textColor: Kube.Colors.highlightedTextColor
+                    checkable: true
+                    horizontalAlignment: Text.AlignHLeft
+                    ButtonGroup.group: viewButtonGroup
+                    onClicked: todoModel.filter = {}
+                }
             }
 
             Kube.CalendarSelector {
                 id: accountSwitcher
                 activeFocusOnTab: true
                 anchors {
-                    top: newMailButton.bottom
+                    top: topLayout.bottom
                     topMargin: Kube.Units.largeSpacing
                     bottom: statusBarContainer.top
-                    left: newMailButton.left
+                    left: topLayout.left
                     right: parent.right
                 }
             }
 
             Item {
                 id: statusBarContainer
                 anchors {
                     topMargin: Kube.Units.smallSpacing
                     bottom: parent.bottom
                     left: parent.left
                     right: parent.right
                 }
                 height: childrenRect.height
 
                 Rectangle {
                     id: border
                     visible: statusBar.visible
                     anchors {
                         right: parent.right
                         left: parent.left
                         margins: Kube.Units.smallSpacing
                     }
                     height: 1
                     color: Kube.Colors.viewBackgroundColor
                     opacity: 0.3
                 }
                 Kube.StatusBar {
                     id: statusBar
                     accountId: root.currentAccount
                     height: Kube.Units.gridUnit * 2
                     anchors {
                         top: border.bottom
                         left: statusBarContainer.left
                         right: statusBarContainer.right
                     }
                 }
             }
         }
 
         Rectangle {
             width: Kube.Units.gridUnit * 18
             Layout.fillHeight: parent.height
 
             color: "transparent"
             border.width: 1
             border.color: Kube.Colors.buttonColor
 
             Kube.ListView {
                 id: todoView
                 anchors.fill: parent
                 Layout.minimumWidth: Kube.Units.gridUnit * 10
 
                 onCurrentItemChanged: {
                     if (currentItem) {
                         var currentData = currentItem.currentData;
                         todoDetails.controller = controllerComponent.createObject(parent, {"todo": currentData.domainObject})
                     }
                 }
 
                 model: Kube.TodoModel {
+                    id: todoModel
                     calendarFilter: accountSwitcher.enabledCalendars
+                    filter: {}
                 }
                 delegate: Kube.ListDelegate {
                     id: delegateRoot
                     //Required for D&D
                     // property var mail: model.mail
                     property bool buttonsVisible: delegateRoot.hovered
 
                     width: todoView.availableWidth
                     height: Kube.Units.gridUnit * 3
 
                     color: Kube.Colors.viewBackgroundColor
                     border.color: Kube.Colors.backgroundColor
                     border.width: 1
 
                     Item {
                         id: content
 
                         anchors {
                             fill: parent
                             margins: Kube.Units.smallSpacing
                         }
 
                         Column {
                             anchors {
                                 verticalCenter: parent.verticalCenter
                                 left: parent.left
                                 leftMargin:  Kube.Units.largeSpacing
                             }
 
                             Kube.Label{
                                 id: subject
                                 width: content.width - Kube.Units.gridUnit * 3
                                 text: model.summary
                                 color: delegateRoot.textColor
                                 font.strikeout: model.complete
-                                font.bold: model.doing
+                                font.bold: model.doing && allViewButton.checked
                                 maximumLineCount: 2
                                 wrapMode: Text.WordWrap
                                 elide: Text.ElideRight
                             }
                         }
 
                         Kube.Label {
                             id: date
                             anchors {
                                 right: parent.right
                                 bottom: parent.bottom
                             }
                             visible: model.date && !delegateRoot.buttonsVisible
                             text: Qt.formatDateTime(model.date, "dd MMM yyyy")
                             font.italic: true
                             color: delegateRoot.disabledTextColor
                             font.pointSize: Kube.Units.tinyFontSize
                         }
                     }
 
                     Kube.Icon {
                         anchors {
                             right: parent.right
                             verticalCenter: parent.verticalCenter
                             margins: Kube.Units.smallSpacing
                         }
 
                         visible:  model.important && !delegateRoot.buttonsVisible
                         iconName: Kube.Icons.isImportant
                     }
 
                     Column {
                         id: buttons
 
                         anchors {
                             right: parent.right
                             margins: Kube.Units.smallSpacing
                             verticalCenter: parent.verticalCenter
                         }
 
                         visible: delegateRoot.buttonsVisible
                         opacity: 0.7
 
                         Kube.IconButton {
                             iconName: model.doing ? Kube.Icons.listRemove : Kube.Icons.addNew
                             activeFocusOnTab: false
                             tooltip: model.doing ? qsTr("Unpick") : qsTr("Pick")
                             onClicked: {
                                 var controller = controllerComponent.createObject(parent, {"todo": model.domainObject});
                                 if (controller.complete) {
                                     controller.complete = false
                                 }
                                 controller.doing = !controller.doing;
                                 controller.saveAction.execute();
                             }
                         }
 
                         Kube.IconButton {
                             iconName: Kube.Icons.checkbox
                             checked: model.complete
                             activeFocusOnTab: false
                             tooltip: qsTr("Done!")
                             onClicked: {
                                 var controller = controllerComponent.createObject(parent, {"todo": model.domainObject});
                                 controller.complete = !controller.complete;
                                 controller.saveAction.execute();
                             }
                         }
 
                     }
                 }
             }
         }
         Rectangle {
             Layout.fillHeight: parent.height
             Layout.fillWidth: true
 
             color: "transparent"
             border.width: 1
             border.color: Kube.Colors.buttonColor
 
             TodoView {
                 id: todoDetails
                 anchors.fill: parent
                 // onDone: popup.close()
             }
         }
         Component {
             id: controllerComponent
             Kube.TodoController {
             }
         }
 
     }
 
     Kube.Listener {
         filter: Kube.Messages.eventEditor
         onMessageReceived: eventPopup.createObject(root, message).open()
     }
 
     Component {
         id: editorPopup
         Kube.Popup {
             id: popup
 
             x: root.width * 0.15
             y: root.height * 0.15
 
             width: root.width * 0.7
             height: root.height * 0.7
             padding: 0
             TodoEditor {
                 id: editor
                 anchors.fill: parent
                 accountId: root.currentAccount
                 onDone: popup.close()
             }
         }
     }
 
 }