diff --git a/src/contactview/mainpage.cpp b/src/contactview/mainpage.cpp
index 11d673b0..58c0c530 100644
--- a/src/contactview/mainpage.cpp
+++ b/src/contactview/mainpage.cpp
@@ -1,382 +1,382 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Bluesystems                                     *
  *   Author : Emmanuel Lepage Vallee <elv1313@gmail.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 3 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, see <http://www.gnu.org/licenses/>. *
  **************************************************************************/
 #include "mainpage.h"
 
 #include <QQmlApplicationEngine>
 #include <QQuickPaintedItem>
 #include <QQuickWindow>
 #include <QQmlEngine>
 #include <QtGui/QPixmap>
 #include <QtGui/QPainter>
 #include <QtGui/QIcon>
 #include <QtCore/QMimeData>
 #include <QtCore/QTimer>
 #include <QtCore/QSortFilterProxyModel>
 #include <QQmlContext>
 
 #include <../ringapplication.h>
 #include "peerstimelinemodel.h"
 #include "phonedirectorymodel.h"
 #include <contactmethod.h>
 #include <libcard/eventaggregate.h>
 #include <individual.h>
 #include <person.h>
 #include <call.h>
 #include <callmodel.h>
 #include <session.h>
 
 // Remove inactive calls from the CallModel
 class ActiveCallProxy2 : public QSortFilterProxyModel
 {
     Q_OBJECT
 
 public:
     explicit ActiveCallProxy2(QObject* parent) : QSortFilterProxyModel(parent) {}
 
 protected:
     virtual bool filterAcceptsRow(int row, const QModelIndex & srcParent ) const override;
 };
 
 class MainPagePrivate final : public QObject {
     Q_OBJECT
 public:
     QSharedPointer<QAbstractItemModel> m_CallsModel;
     Individual* m_Invididual {nullptr};
     QSharedPointer<QAbstractItemModel> m_TimelineModel;
     QQuickItem* m_pItem   {nullptr};
     QQuickItem* m_pHeader {nullptr};
 
     QList< QTimer* > m_lTimers;
 
     MainPage* q_ptr;
 
 public Q_SLOTS:
     void slotWindowChanged();
 };
 
 MainPage::MainPage(QQuickItem* parent) :
     QQuickItem(parent), d_ptr(new MainPagePrivate)
 {
     d_ptr->q_ptr = this;
     auto cp = new ActiveCallProxy2(Session::instance()->callModel());
     cp->setSourceModel(Session::instance()->callModel());
 
     QFile file(QStringLiteral(":/assets/welcome.html"));
     if (file.open(QIODevice::ReadOnly))
         RingApplication::engine()->rootContext()->setContextProperty(QStringLiteral("welcomeMessage"), file.readAll());
 
     RingApplication::engine()->rootContext()->setContextProperty(QStringLiteral("ActiveCallProxyModel"), cp);
 
     connect(this, &QQuickItem::windowChanged, d_ptr, &MainPagePrivate::slotWindowChanged);
     connect(Session::instance()->callModel(), &CallModel::callAttentionRequest, this, &MainPage::showVideo);
 
     installEventFilter(this);
 
     // Wait a bit, the timeline will change while it is loading, so before
     // picking something at random, give it a chance to load some things.
     QTimer::singleShot(500, [this]() {
         if (d_ptr->m_Invididual)
             return;
 
-        auto i = PeersTimelineModel::instance().mostRecentIndividual();
+        auto i = Session::instance()->peersTimelineModel()->mostRecentIndividual();
 
         // Select whatever is first (if any)
-        if ((!i) && PeersTimelineModel::instance().rowCount())
+        if ((!i) && Session::instance()->peersTimelineModel()->rowCount())
             if (auto rawI = qvariant_cast<Individual*>(
-                PeersTimelineModel::instance().index(0,0).data((int)Ring::Role::Object)
+                Session::instance()->peersTimelineModel()->index(0,0).data((int)Ring::Role::Object)
             ))
                 i = rawI;
 
         // There is nothing yet, wait
         if (!i) {
             QMetaObject::Connection c;
 
-            c = connect(&PeersTimelineModel::instance(), &QAbstractItemModel::rowsInserted, this, [c, this]() {
+            c = connect(Session::instance()->peersTimelineModel(), &QAbstractItemModel::rowsInserted, this, [c, this]() {
                 if (d_ptr->m_Invididual) {
                     disconnect(c);
                     return;
                 }
 
-                if (auto i = PeersTimelineModel::instance().mostRecentIndividual()) {
+                if (auto i = Session::instance()->peersTimelineModel()->mostRecentIndividual()) {
                     disconnect(c);
                     setIndividual(i);
-                    const auto idx = PeersTimelineModel::instance().individualIndex(i);
+                    const auto idx = Session::instance()->peersTimelineModel()->individualIndex(i);
                     emit suggestSelection(i, idx);
                 }
             });
 
             return;
         }
 
         setIndividual(i);
 
         if (i) {
-            const auto idx = PeersTimelineModel::instance().individualIndex(i);
+            const auto idx = Session::instance()->peersTimelineModel()->individualIndex(i);
             emit suggestSelection(i, idx);
         }
     });
 }
 
 MainPage::~MainPage()
 {
     d_ptr->m_TimelineModel.clear();
     d_ptr->m_Invididual = nullptr;
     d_ptr->m_CallsModel.clear();
 
     // Release the shared pointer reference from the timer.
     for (auto t : qAsConst(d_ptr->m_lTimers)) {
         disconnect(t);
         delete t;
     }
 
     delete d_ptr;
 }
 
 bool MainPage::eventFilter(QObject *obj, QEvent *event)
 {
     Q_UNUSED(obj)
     Q_UNUSED(event)
     //TODO the context menu
     return false;
 }
 
 void MainPage::setIndividual(Individual* ind)
 {
     if (!ind)
         return;
 
     if (d_ptr->m_TimelineModel) {
         disconnect(d_ptr->m_TimelineModel.data(), &QAbstractItemModel::rowsInserted,
             this, &MainPage::contextInserted);
     }
 
     d_ptr->m_Invididual = ind;
     d_ptr->m_TimelineModel = ind->timelineModel();
     d_ptr->m_CallsModel = ind->eventAggregate()->unsortedListView();
     Q_ASSERT(d_ptr->m_CallsModel);
 
     d_ptr->m_pItem->setProperty( "currentContactMethod", QVariant::fromValue(
         static_cast<ContactMethod*>(nullptr)
     ));
 
     d_ptr->m_pItem->setProperty( "currentIndividual", QVariant::fromValue(
         ind
     ));
 
     d_ptr->m_pItem->setProperty( "timelineModel", QVariant::fromValue(d_ptr->m_TimelineModel));
     d_ptr->m_pItem->setProperty( "unsortedListView", QVariant::fromValue(d_ptr->m_CallsModel));
 
     if (d_ptr->m_TimelineModel) {
         connect(d_ptr->m_TimelineModel.data(), &QAbstractItemModel::rowsInserted,
             this, &MainPage::contextInserted);
     }
 }
 
 void MainPage::setContactMethod(ContactMethod* cm)
 {
     if ((!cm) || (!d_ptr->m_pItem))
         return;
 
 
     cm = PhoneDirectoryModel::instance().fromTemporary(cm);
 
     // Keep a reference for 5 minutes to avoid double free from QML
     for (auto ptr : {d_ptr->m_CallsModel, d_ptr->m_TimelineModel})
         if (ptr) {
             auto t = new QTimer(this);
             t->setInterval(5 * 60 * 1000);
             t->setSingleShot(true);
             connect(t, &QTimer::timeout, this, [t, this, ptr]() {
                 this->d_ptr->m_lTimers.removeAll(t);
             });
             t->start();
             d_ptr->m_lTimers << t;
         }
 
     if (d_ptr->m_TimelineModel) {
         disconnect(d_ptr->m_TimelineModel.data(), &QAbstractItemModel::rowsInserted,
             this, &MainPage::contextInserted);
     }
 
     // Keep a strong reference because QML won't
     d_ptr->m_Invididual = cm->individual();
     d_ptr->m_CallsModel = cm->individual()->eventAggregate()->unsortedListView();
     Q_ASSERT(d_ptr->m_CallsModel);
 
     d_ptr->m_TimelineModel = cm->individual()->timelineModel();
 
     d_ptr->m_pItem->setProperty( "currentContactMethod", QVariant::fromValue(cm));
     d_ptr->m_pItem->setProperty( "currentIndividual", QVariant::fromValue(
         cm->individual()
     ));
     d_ptr->m_pItem->setProperty( "timelineModel", QVariant::fromValue(d_ptr->m_TimelineModel));
     d_ptr->m_pItem->setProperty( "unsortedListView", QVariant::fromValue(d_ptr->m_CallsModel));
 
     if (d_ptr->m_TimelineModel) {
         connect(d_ptr->m_TimelineModel.data(), &QAbstractItemModel::rowsInserted,
             this, &MainPage::contextInserted);
     }
 }
 
 void MainPage::setPerson(Person* p)
 {
     if (d_ptr->m_TimelineModel) {
         disconnect(d_ptr->m_TimelineModel.data(), &QAbstractItemModel::rowsInserted,
             this, &MainPage::contextInserted);
     }
 
     auto ind = p->individual();
     d_ptr->m_Invididual = ind;
 
     d_ptr->m_pItem->setProperty( "currentPerson", QVariant::fromValue(p));
     d_ptr->m_pItem->setProperty( "currentIndividual", QVariant::fromValue(
         ind
     ));
 
     d_ptr->m_CallsModel = ind->eventAggregate()->unsortedListView();
     Q_ASSERT(d_ptr->m_CallsModel);
 
     d_ptr->m_pItem->setProperty( "unsortedListView", QVariant::fromValue(d_ptr->m_CallsModel));
 
     if (d_ptr->m_TimelineModel) {
         connect(d_ptr->m_TimelineModel.data(), &QAbstractItemModel::rowsInserted,
             this, &MainPage::contextInserted);
     }
 }
 
 void MainPage::setCurrentPage(MainPage::Pages page)
 {
     QString name;
     switch (page) {
         case MainPage::Pages::INFORMATION:
             name = QStringLiteral("INFORMATION");
             break;
         case MainPage::Pages::TIMELINE:
             name = QStringLiteral("TIMELINE");
             break;
         case MainPage::Pages::CALL_HISTORY:
             name = QStringLiteral("CALL_HISTORY");
             break;
         case MainPage::Pages::RECORDINGS:
             name = QStringLiteral("RECORDINGS");
             break;
         case MainPage::Pages::SEARCH:
             name = QStringLiteral("SEARCH");
             break;
         case MainPage::Pages::MEDIA:
             name = QStringLiteral("MEDIA");
             break;
     }
 
     d_ptr->m_pItem->setProperty( "currentPage", name);
 }
 
 bool ActiveCallProxy2::filterAcceptsRow(int row, const QModelIndex& srcParent ) const
 {
     // Conferences are always active
     if (srcParent.isValid())
         return true;
 
     return sourceModel()->index(row, 0)
         .data((int)Call::Role::LifeCycleState) == QVariant::fromValue(Call::LifeCycleState::PROGRESS);
 }
 
 void MainPagePrivate::slotWindowChanged()
 {
     auto ctx = QQmlEngine::contextForObject(q_ptr);
     Q_ASSERT(ctx);
 
     QQmlComponent comp(ctx->engine(), QStringLiteral("qrc:/ViewContact.qml"), q_ptr);
 
     m_pItem = qobject_cast<QQuickItem*>(comp.create(ctx));
 
     if (!m_pItem) {
         qDebug() << "Previous error" << comp.errorString();
     }
 
     Q_ASSERT(m_pItem);
     m_pItem->setParentItem(q_ptr);
 
 
     auto anchors = qvariant_cast<QObject*>(m_pItem->property("anchors"));
     anchors->setProperty("fill", QVariant::fromValue(q_ptr));
     m_pItem->setProperty( "unsortedListView", QVariant::fromValue(nullptr));
 }
 
 void MainPage::showVideo(Call* c)
 {
     // Ignore clicks on dialing calls
     if ((!c) || c->state() == Call::State::NEW || c->state() == Call::State::DIALING)
         return;
 
     setContactMethod(c->peerContactMethod());
     QMetaObject::invokeMethod(d_ptr->m_pItem, "showVideo");
 }
 
 QQuickItem* MainPage::page() const
 {
     return d_ptr->m_pItem;
 }
 
 
 QQuickItem* MainPage::header() const
 {
     return d_ptr->m_pHeader;
 }
 
 void MainPage::setHeader(QQuickItem* item)
 {
     d_ptr->m_pItem->setProperty("contactHeader", QVariant::fromValue(item));
     d_ptr->m_pHeader = item;
 }
 
 bool MainPage::isMobile() const
 {
     return d_ptr->m_pItem->property("mobile").toBool();
 }
 
 void MainPage::setMobile(bool v)
 {
     d_ptr->m_pItem->setProperty("mobile", v);
 }
 
 Individual* MainPage::individual() const
 {
     if (d_ptr->m_Invididual)
         return qobject_cast<Individual*>(d_ptr->m_Invididual);
 
     return nullptr;
 }
 
 QModelIndex MainPage::suggestedTimelineIndex() const
 {
     if (d_ptr->m_Invididual)
-        return PeersTimelineModel::instance().individualIndex(
+        return Session::instance()->peersTimelineModel()->individualIndex(
             qobject_cast<Individual*>(d_ptr->m_Invididual)
         );
 
     return {};
 }
 
 void MainPage::contextInserted()
 {
     QMetaObject::invokeMethod(d_ptr->m_pItem, "showNewContent");
 }
 
 #include <mainpage.moc>
 // kate: space-indent on; indent-width 4; replace-tabs on;
diff --git a/src/desktopview/qml/dockbar.qml b/src/desktopview/qml/dockbar.qml
index c4361434..d0796026 100644
--- a/src/desktopview/qml/dockbar.qml
+++ b/src/desktopview/qml/dockbar.qml
@@ -1,290 +1,291 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Bluesystems                                     *
  *   Author : Emmanuel Lepage Vallee <elv1313@gmail.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 3 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, see <http://www.gnu.org/licenses/>. *
  **************************************************************************/
 import QtQuick 2.7
 import Ring 1.0
 import QtQuick.Layouts 1.0
 import QtQuick.Controls 2.0 as Controls
 import org.kde.kirigami 2.2 as Kirigami
 import QtQuick.Window 2.2
+import net.lvindustries.ringqtquick 1.0 as RingQtQuick
 import ContactView 1.0
 
 import DesktopView 1.0
 
 Item {
     id: topLevel
 
     width: Math.min(335, root.width-48) + dockBar.width
 
     property var newHolder: null
 
     function setCurrentIndex(index) {
         if (dockLoader.sourceComponent != timelineViewComponent)
             return
 
         dockLoader.item.setCurrentIndex(index)
     }
 
     signal timelineSelected()
 
     RowLayout {
         id: dockLayout
         spacing: 0
         anchors.fill: parent
 
         Image {
             id: dockBar
 
             property string selectedItem: "timeline"
 
             source: "gui/icons/assets/toolbar_bg.png"
             fillMode: Image.Tile
             width: 48
             height: parent.height
 
             Layout.fillHeight: true
             Layout.maximumWidth: width
 
             onSelectedItemChanged: {
                 switch(selectedItem) {
                     case "timeline":
                         dockLoader.sourceComponent = timelineViewComponent
                         break
                     case "call"    :
                         dockLoader.sourceComponent = dialViewComponent
                         break
                     case "contact" :
                         dockLoader.sourceComponent = contactViewComponent
                         break
                     case "bookmark":
                         dockLoader.sourceComponent = bookmarkViewComponent
                         break
                     case "history" :
                         dockLoader.sourceComponent = historyViewComponent
                         break
                 }
             }
 
             Behavior on width {
                 NumberAnimation {duration: 200;  easing.type: Easing.OutQuad }
             }
 
             DockModel {
                 id: icons
             }
 
             FontMetrics {
                 id: fontMetrics
             }
 
             Column {
                 Item {
                     width: dockBar.width
                     height: Math.max(
                         dockBar.width * 1.33,
                         availableAccounts.count*(dockBar.width+5) + 6
                     )
 
                     ListView {
                         y: 5
                         id: availableAccounts
                         model: ProfileModel.availableProfileModel
                         height: 200
                         spacing: 5
                         interactive: false
                         delegate: MouseArea {
                             width: dockBar.width
                             height: dockBar.width
                             ContactPhoto {
                                 anchors.centerIn: parent
                                 width: dockBar.width - 3
                                 height: dockBar.width - 3
                                 individual: object
                                 defaultColor: "#f2f2f2ff" //same as the SVG
                             }
                             onClicked: {
                                 var component = Qt.createComponent("PresenceSelector.qml")
                                 if (component.status == Component.Ready) {
                                     var window = component.createObject(applicationWindow().contentItem)
                                     window.individual = object
                                     window.open()
                                 }
                                 else
                                     console.log("ERROR", component.status, component.errorString())
                             }
                         }
                     }
 
                     Loader {
                         active: availableAccounts.count == 0 || !ProfileModel.hasAvailableProfiles
                         anchors.centerIn: parent
                         sourceComponent: Rectangle {
                             height: 48
                             width: 48
                             border.width: 2
                             border.color: Kirigami.Theme.negativeTextColor
                             color: "transparent"
                             radius: 99
 
                             Image {
                                 anchors.fill: parent
                                 sourceSize.width: 48
                                 sourceSize.height: 48
                                 anchors.verticalCenter: parent.verticalCenter
                                 source: "image://SymbolicColorizer/:/sharedassets/outline/warning.svg"
                             }
                         }
                     }
 
                     Rectangle {
                         height: 1
                         width: parent.width
                         color: "#939393"
                         anchors.bottom: parent.bottom
                     }
                 }
 
                 Repeater {
                     model: icons
                     Rectangle {
                         id: actionIcon
                         color: dockBar.selectedItem == identifier ? "#111111" : "transparent"
                         height: dockBar.width + 10
                         width: dockBar.width
 
                         Image {
                             anchors.verticalCenter: parent.verticalCenter
                             source: decoration
                             width: 48
                             height: 48
                             sourceSize.width: 48
                             sourceSize.height: 48
                             fillMode: Image.PreserveAspectFit
                         }
 
                         MouseArea {
                             anchors.fill: parent
                             onClicked: {
                                 dockBar.selectedItem = identifier
                             }
                         }
 
                         Rectangle {
                             color: "red"
                             radius: 99
                             x: 2
                             y: 2
                             width: fontMetrics.height + 4
                             height: fontMetrics.height + 4
                             visible: activeCount > 0
                             Text {
                                 color: "white"
                                 anchors.centerIn: parent
                                 font.bold: true
                                 text: activeCount
                             }
                         }
                     }
                 }
             }
         }
 
         Component {
             id: timelineViewComponent
             PeersTimeline {
                 anchors.fill: parent
                 state: ""
                 onIndividualSelected: {
                     mainPage.setIndividual(ind)
                 }
             }
         }
         Component {
             id: dialViewComponent
             DialView {
                 anchors.fill: parent
                 onSelectCall: {
                     mainPage.showVideo(call)
                 }
             }
         }
         Component {
             id: contactViewComponent
             ContactList {
                 anchors.fill: parent
                 onIndividualSelected: {
                     mainPage.setIndividual(ind)
                 }
             }
         }
         Component {
             id: bookmarkViewComponent
             BookmarkList {
                 anchors.fill: parent
                 onContactMethodSelected: {
                     mainPage.setContactMethod(cm)
                 }
             }
         }
         Component {
             id: historyViewComponent
             HistoryTimeline {
                 anchors.fill: parent
                 onContactMethodSelected: {
                     mainPage.setContactMethod(cm)
                 }
             }
         }
 
         ColumnLayout {
             id: dockHolder
             width: Math.min(335, root.width-48)
             Layout.fillHeight: true
             visible: true
 
             // This is a placeholder for the searchbox
             Item {
                 Layout.fillWidth: true
                 Layout.minimumHeight: 32
                 Layout.maximumHeight: 32
             }
 
             Loader {
                 id: dockLoader
 
                 sourceComponent: timelineViewComponent
                 Layout.fillWidth: true
                 Layout.fillHeight: true
 
                 onItemChanged: {
                     if (item && sourceComponent == timelineViewComponent)
                         timelineSelected()
                 }
             }
         }
     }
 
     SearchOverlay {
         id: searchView
         source: parent
         anchors.fill: parent
         onContactMethodSelected: {
             mainPage.setContactMethod(cm)
-            setCurrentIndex(PeersTimelineModel.individualIndex(cm.individual))
+            setCurrentIndex(RingSession.peersTimelineModel.individualIndex(cm.individual))
         }
     }
 }
diff --git a/src/ringapplication.cpp b/src/ringapplication.cpp
index 678ecc51..91d3c8f7 100644
--- a/src/ringapplication.cpp
+++ b/src/ringapplication.cpp
@@ -1,625 +1,623 @@
 /***************************************************************************
  *   Copyright (C) 2009-2015 by Savoir-Faire Linux                         *
  *   Author : Emmanuel Lepage Valle <emmanuel.lepage@savoirfairelinux.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 3 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, see <http://www.gnu.org/licenses/>. *
  **************************************************************************/
 
 //Parent
 #include "ringapplication.h"
 
 //Qt
 #include <QtCore/QDir>
 #include <QtCore/QTimer>
 #include <QtCore/QCommandLineParser>
 #include <QtCore/QDebug>
 #include <QtCore/QStandardPaths>
 #include <QtCore/QItemSelectionModel>
 #include <QtWidgets/QAction>
 #include <QQmlApplicationEngine>
 #include <QQmlContext>
 #include <QQuickItem>
 #include <QQuickWindow>
 #include <QQmlExtensionPlugin>
 #include <QQmlComponent>
 
 //KDE
 #include <KIconLoader>
 #include <KActionCollection>
 #include <kmessagebox.h>
 #include <KDeclarative/KDeclarative>
 
 //LRC
 #include <itemdataroles.h>
 #include <session.h>
 #include <callmodel.h>
 #include <eventmodel.h>
 #include <accountmodel.h>
 #include <account.h>
 #include <individual.h>
 #include <contactmethod.h>
 #include <phonedirectorymodel.h>
 #include <categorizedhistorymodel.h>
 #include <categorizedcontactmodel.h>
 #include <ringdevicemodel.h>
 #include <namedirectory.h>
 #include <categorizedbookmarkmodel.h>
 #include <numbercompletionmodel.h>
 #include <useractionmodel.h>
 #include <protocolmodel.h>
 #include <pendingcontactrequestmodel.h>
 #include <video/configurationproxy.h>
 #include <video/sourcemodel.h>
 #include <contactmethod.h>
 #include <media/recordingmodel.h>
 #include <peerstimelinemodel.h>
 #include <individualtimelinemodel.h>
 #include <ringtonemodel.h>
 #include <video/previewmanager.h>
 #include <media/recording.h>
 #include <media/avrecording.h>
 #include <media/textrecording.h>
 #include <media/availabilitytracker.h>
 #include <media/media.h>
 #include <video/renderer.h>
 #include <libcard/historyimporter.h>
 #include <troubleshoot/dispatcher.h>
 
 //Ring
 #include "klib/kcfg_settings.h"
 #include "cmd.h"
 #include "errormessage.h"
 #include "implementation.h"
 #include "wizard/welcome.h"
 #include "callview/videowidget.h"
 #include "notification.h"
 #include "actioncollection.h"
 
 //Models
 #include <profilemodel.h>
 #include <certificatemodel.h>
 #include <availableaccountmodel.h>
 #include <numbercategorymodel.h>
 #include <codecmodel.h>
 #include <credentialmodel.h>
 #include <presencestatusmodel.h>
 #include <personmodel.h>
 #include <infotemplatemanager.h>
 
 //Collections
 #include <foldercertificatecollection.h>
 #include <fallbackpersoncollection.h>
 #include <peerprofilecollection2.h>
 #include <localhistorycollection.h>
 #include <localbookmarkcollection.h>
 #include <localrecordingcollection.h>
 #include <localprofilecollection.h>
 #include <localtextrecordingcollection.h>
 #include <globalinstances.h>
 
 //Configurators
 #include "configurator/localhistoryconfigurator.h"
 #include "configurator/audiorecordingconfigurator.h"
 #include "configurator/fallbackpersonconfigurator.h"
 #include "configurator/peerprofileconfigurator.h"
 #include "configurator/bookmarkconfigurator.h"
 
 //Delegates
 #include <delegates/kdepixmapmanipulation.h>
 #include <interfaces/itemmodelstateserializeri.h>
 #include "klib/itemmodelserialization.h"
 #include "extensions/presencecollectionextension.h"
 
 //QML
 #include <KQuickItemViews/plugin.h>
 #include "qmlwidgets/plugin.h"
 #include "qmlwidgets/recentfilemodel.h"
 #include "qmlwidgets/symboliccolorizer.h"
 #include "photoselector/photoplugin.h"
 #include "canvasindicators/canvasindicator.h"
 #include "canvasindicators/ringingimageprovider.h"
 #include "desktopview/desktopviewplugin.h"
 #include "contactview/contactviewplugin.h"
 #include "accountview/accountviewplugin.h"
 #include "dialview/dialviewplugin.h"
 #include "timeline/timelineplugin.h"
 
 //Widgets
 #include "widgets/systray.h"
 
 //Other
 #include <unistd.h>
 
 KDeclarative::KDeclarative* RingApplication::m_pDeclarative {nullptr};
 RingQmlWidgets* RingApplication::m_pQmlWidget {nullptr};
 PhotoSelectorPlugin* RingApplication::m_pPhotoSelector {nullptr};
 DesktopView* RingApplication::m_pDesktopView {nullptr};
 ContactView* RingApplication::m_pContactView {nullptr};
 AccountView* RingApplication::m_pAccountView {nullptr};
 DialView* RingApplication::m_pDialView {nullptr};
 TimelinePlugin* RingApplication::m_pTimeline {nullptr};
 CanvasIndicator* RingApplication::m_pCanvasIndicator {nullptr};
 RingApplication* RingApplication::m_spInstance {nullptr};
 
 //This code detect if the window is active, innactive or minimzed
 class PhoneWindowEvent final : public QObject {
    Q_OBJECT
 public:
    PhoneWindowEvent(RingApplication* ev) : QObject(ev),m_pParent(ev) {
       QTimer::singleShot(0, [this]() {
          m_pParent->desktopWindow()->installEventFilter(this);
       });
    }
 protected:
    virtual bool eventFilter(QObject *obj, QEvent *event)  override {
       Q_UNUSED(obj)
       if (event->type() == QEvent::WindowDeactivate) {
          m_pParent->m_HasFocus = false;
       }
       else if (event->type() == QEvent::WindowActivate) {
          m_pParent->m_HasFocus = true;
       }
       return false;
    }
 
 private:
    RingApplication* m_pParent;
 
 Q_SIGNALS:
    void minimized(bool);
 };
 
 /**
  * The application constructor
  */
 RingApplication::RingApplication(int & argc, char ** argv) : QApplication(argc,argv),m_StartIconified(false)
 {
    Q_ASSERT(argc != -1);
 #ifdef ENABLE_VIDEO
    //Necessary to draw OpenGL from a separated thread
    setAttribute(Qt::AA_X11InitThreads,true);
 #endif
    setAttribute(Qt::AA_EnableHighDpiScaling);
 
    m_pEventFilter = new PhoneWindowEvent(this);
 
    m_spInstance = this;
 }
 
 void RingApplication::init()
 {
    if ((!Session::instance()->callModel()->isConnected()) || (!Session::instance()->callModel()->isValid())) {
       QTimer::singleShot(5000,this,&RingApplication::daemonTimeout);
    }
 
    initCollections();
 }
 
 /**
  * Destructor
  */
 RingApplication::~RingApplication()
 {
    delete m_pDeclarative;
    delete engine();
    delete m_pCanvasIndicator;
    delete m_pPhotoSelector;
    delete m_pQmlWidget;
 
-   delete &PeersTimelineModel::instance();
+   delete Session::instance()->peersTimelineModel();
    delete &Media::RecordingModel::instance();
    delete &PersonModel::instance();
    delete Session::instance()->callModel();
    delete &ProfileModel::instance();
    delete Session::instance()->accountModel();
    delete &PhoneDirectoryModel::instance();
    delete &NumberCategoryModel::instance();
    m_spInstance = nullptr;
 }
 
 RingApplication* RingApplication::instance()
 {
    Q_ASSERT(m_spInstance);
    return m_spInstance;
 }
 
 static void loadNumberCategories()
 {
    auto& model = NumberCategoryModel::instance();
    static const QString pathTemplate = QStringLiteral(":/mini/icons/miniicons/%1.png");
 #define ICN(name) QPixmap(QString(pathTemplate).arg(QStringLiteral(name)))
    model.addCategory(i18n("Home")     ,ICN("home")     , 1 /*KABC::PhoneNumber::Home */);
    model.addCategory(i18n("Work")     ,ICN("work")     , 2 /*KABC::PhoneNumber::Work */);
    model.addCategory(i18n("Msg")      ,ICN("mail")     , 3 /*KABC::PhoneNumber::Msg  */);
    model.addCategory(i18n("Pref")     ,ICN("call")     , 4 /*KABC::PhoneNumber::Pref */);
    model.addCategory(i18n("Voice")    ,ICN("video")    , 5 /*KABC::PhoneNumber::Voice*/);
    model.addCategory(i18n("Fax")      ,ICN("call")     , 6 /*KABC::PhoneNumber::Fax  */);
    model.addCategory(i18n("Cell")     ,ICN("mobile")   , 7 /*KABC::PhoneNumber::Cell */);
    model.addCategory(i18n("Video")    ,ICN("call")     , 8 /*KABC::PhoneNumber::Video*/);
    model.addCategory(i18n("Bbs")      ,ICN("call")     , 9 /*KABC::PhoneNumber::Bbs  */);
    model.addCategory(i18n("Modem")    ,ICN("call")     , 10/*KABC::PhoneNumber::Modem*/);
    model.addCategory(i18n("Car")      ,ICN("car")      , 11/*KABC::PhoneNumber::Car  */);
    model.addCategory(i18n("Isdn")     ,ICN("call")     , 12/*KABC::PhoneNumber::Isdn */);
    model.addCategory(i18n("Pcs")      ,ICN("call")     , 13/*KABC::PhoneNumber::Pcs  */);
    model.addCategory(i18n("Pager")    ,ICN("pager")    , 14/*KABC::PhoneNumber::Pager*/);
    model.addCategory(i18n("Preferred"),ICN("preferred"), 10000                         );
 #undef ICN
 #undef IS_ENABLED
 }
 
 void RingApplication::initCollections()
 {
    GlobalInstances::setInterface<KDEActionExtender>();
 
    GlobalInstances::setInterface<ColorDelegate>();
 
    GlobalInstances::setInterface<KDEPixmapManipulation>();
 
    loadNumberCategories();
 
    Session::instance()->callModel()->setAudoCleanDelay(5000);
 
    InfoTemplateManager::instance();
 
    /*******************************************
       *           Set the configurator          *
       ******************************************/
 
    PersonModel::instance()             .registerConfigarator<PeerProfileCollection2  >    (new PeerProfileConfigurator   (this));
    PersonModel::instance()             .registerConfigarator<FallbackPersonCollection>    (new FallbackPersonConfigurator(this));
    Session::instance()->historyModel()->registerConfigarator<LocalHistoryCollection  >    (new LocalHistoryConfigurator  (this));
    Session::instance()->bookmarkModel()->registerConfigarator<LocalBookmarkCollection >    (new BookmarkConfigurator      (this));
    Media::RecordingModel::instance()   .registerConfigarator<LocalRecordingCollection>    (new AudioRecordingConfigurator(this,
       AudioRecordingConfigurator::Mode::AUDIO
    ));
    Media::RecordingModel::instance()   .registerConfigarator<LocalTextRecordingCollection>(new AudioRecordingConfigurator(this,
       AudioRecordingConfigurator::Mode::TEXT
    ));
 
    /*******************************************
       *           Load the collections          *
       ******************************************/
 
    // Load the old phone call history and port it to the newer calendar events format.
    if (QFile::exists(QStandardPaths::writableLocation(QStandardPaths::DataLocation) + QLatin1Char('/') +"history.ini")) {
       auto histo = Session::instance()->historyModel()->addCollection<LocalHistoryCollection>(LoadOptions::FORCE_ENABLED);
       HistoryImporter::importHistory(histo);
       histo->clear();
    }
 
    //HACK load the Calendar now to speedup everything else
    const int accountCount = Session::instance()->accountModel()->size();
    for (int i=0; i < accountCount; i++)
       (*Session::instance()->accountModel())[i]->calendar();
 
    ProfileModel::instance().addCollection<LocalProfileCollection>(LoadOptions::FORCE_ENABLED);
 
 #ifdef Q_OS_LINUX
    CertificateModel::instance().addCollection<FolderCertificateCollection,QString, FlagPack<FolderCertificateCollection::Options>,QString>(
       QStringLiteral("/usr/share/ca-certificates/"),
       FolderCertificateCollection::Options::ROOT
          | FolderCertificateCollection::Options::RECURSIVE
          | FolderCertificateCollection::Options::READ_ONLY,
       i18n("System root certificates"),
       LoadOptions::FORCE_ENABLED
    );
 #endif
 
    Session::instance()->bookmarkModel()->addCollection<LocalBookmarkCollection>();
    Session::instance()->bookmarkModel()->setDisplayPopular(
       ConfigurationSkeleton::displayPopularAsBookmark()
    );
 
    PersonModel::instance().addCollection<FallbackPersonCollection>(LoadOptions::FORCE_ENABLED);
    auto ppc = PersonModel::instance().addCollection<PeerProfileCollection2>(LoadOptions::FORCE_ENABLED);
 
    const auto m = static_cast<PeerProfileCollection2::DefaultMode>(ConfigurationSkeleton::defaultPeerProfileMode());
    ppc->setDefaultMode(m);
 
    GlobalInstances::setInterface<ItemModelStateSerialization>();
    GlobalInstances::itemModelStateSerializer().load();
 
 #ifdef ENABLE_AKONADI
    AkonadiBackend::initCollections();
 #endif
 
 //       PresenceCollectionModelExtension* ext = new PresenceCollectionModelExtension(this);
 //       PersonModel::instance().backendModel()->addExtension(ext); //FIXME
 
    ProfileModel::instance();
 
    Notification::instance();
 }
 
 ///Parse command line arguments
 int RingApplication::newInstance()
 {
    static bool displayWizard  = ConfigurationSkeleton::enableWizard() || ConfigurationSkeleton::showSplash();
    const  bool displayOnStart = ConfigurationSkeleton::displayOnStart() && !startIconified();
 
    static bool init = true;
    //Only call on the first instance
    if (init) {
       init = false;
 
       ActionCollection::instance()->setupAction();
       desktopWindow();
       new SysTray(QIcon(QStringLiteral(":appicon/icons/64-apps-ring-kde.png")));
    }
 
    // The first run wizard
    if (displayOnStart && displayWizard) {
       // Also add this object
       engine()->rootContext()->setContextProperty(
          QStringLiteral("RingApplication"), this
       );
 
       engine()->rootContext()->setContextProperty(
          QStringLiteral("wizardWelcomeOnly"), QVariant(!ConfigurationSkeleton::enableWizard())
       );
 
       if (!Session::instance()->accountModel()->size())
          showWizard();
 
       ConfigurationSkeleton::setEnableWizard(false);
       displayWizard = false;
       return 0;
    }
 
    return 0;
 }
 
 bool RingApplication::startIconified() const
 {
    return m_StartIconified;
 }
 
 void RingApplication::setIconify(bool iconify)
 {
    m_StartIconified = iconify;
 }
 
 void RingApplication::setStartTimeline(bool value)
 {
    m_StartTimeLine = value;
 }
 
 void RingApplication::setStartPhone(bool value)
 {
    m_StartPhone = value;
 }
 
 #define QML_TYPE(name) qmlRegisterUncreatableType<name>(AppName, 1,0, #name, #name "cannot be instantiated");
 #define QML_NS(name) qmlRegisterUncreatableMetaObject( name :: staticMetaObject, #name, 1, 0, #name, "Namespaces cannot be instantiated" );
 #define QML_CRTYPE(name) qmlRegisterType<name>(AppName, 1,0, #name);
 #define QML_SINGLETON(name) RingApplication::engine()->rootContext()->setContextProperty(QStringLiteral(#name), &name::instance());
 #define QML_SINGLETON2(name) RingApplication::engine()->rootContext()->setContextProperty(QStringLiteral(#name), name::instance());
 #define QML_ADD_OBJECT(name, obj) RingApplication::engine()->rootContext()->setContextProperty(QStringLiteral(#name), obj);
 
 constexpr static const char AppName[]= "Ring";
 
 /// Create a QML engine for various canvas widgets
 QQmlApplicationEngine* RingApplication::engine()
 {
    static QQmlApplicationEngine* e = nullptr;
    static std::atomic_flag engineInit = ATOMIC_FLAG_INIT;
 
    if (!engineInit.test_and_set()) {
       m_pQmlWidget = new RingQmlWidgets;
       m_pQmlWidget->registerTypes("RingQmlWidgets");
 
       m_pPhotoSelector = new PhotoSelectorPlugin;
       m_pPhotoSelector->registerTypes("PhotoSelectorPlugin");
 
       m_pDesktopView = new DesktopView;
       m_pDesktopView->registerTypes("DesktopView");
 
       m_pContactView = new ContactView;
       m_pContactView->registerTypes("ContactView");
 
       m_pAccountView = new AccountView;
       m_pAccountView->registerTypes("AccountView");
 
       m_pDialView = new DialView;
       m_pDialView->registerTypes("DialView");
 
       m_pTimeline = new TimelinePlugin;
       m_pTimeline->registerTypes("TimeLine");
 
       m_pCanvasIndicator = new CanvasIndicator;
       m_pCanvasIndicator->registerTypes("CanvasIndicator");
 
       QML_TYPE( QAction)
 
       QML_CRTYPE( QItemSelectionModel )
 
       QML_NS(Ring)
 
       e = new QQmlApplicationEngine(QGuiApplication::instance());
 
       // Setup the icon theme provider and ki18n
       m_pDeclarative = new KDeclarative::KDeclarative;
       m_pDeclarative->setDeclarativeEngine(e);
       m_pDeclarative->setupBindings();
 
       try {
-         QML_SINGLETON( NameDirectory            );
-         QML_SINGLETON( PeersTimelineModel       );
          QML_SINGLETON( NumberCategoryModel      );
          QML_SINGLETON( PhoneDirectoryModel      );
          QML_SINGLETON( RecentFileModel          );
          QML_SINGLETON( ProfileModel             );
          QML_SINGLETON( PresenceStatusModel      );
          QML_SINGLETON( EventModel               );
          QML_SINGLETON( RingtoneModel            );
 
          QML_SINGLETON2( ActionCollection        );
 
          QML_ADD_OBJECT(VideoRateSelectionModel      , &Video::ConfigurationProxy::rateSelectionModel      ());
          QML_ADD_OBJECT(VideoResolutionSelectionModel, &Video::ConfigurationProxy::resolutionSelectionModel());
          QML_ADD_OBJECT(VideoChannelSelectionModel   , &Video::ConfigurationProxy::channelSelectionModel   ());
          QML_ADD_OBJECT(VideoDeviceSelectionModel    , &Video::ConfigurationProxy::deviceSelectionModel    ());
          { using namespace Media;
             QML_SINGLETON( RecordingModel        );
          }
 
          { using namespace Video;
             QML_SINGLETON( PreviewManager        );
          }
 
          qmlRegisterUncreatableType<::Media::Media>(
             AppName, 1,0, "Media", QStringLiteral("cannot be instantiated")
          );
 
          RingApplication::engine()->rootContext()->setContextProperty(
             QStringLiteral("SortedContactModel"),
             CategorizedContactModel::SortedProxy::instance().model()
          );
 
          RingApplication::engine()->rootContext()->setContextProperty(
             QStringLiteral("ContactCategoryModel"),
             CategorizedContactModel::SortedProxy::instance().categoryModel()
          );
 
          RingApplication::engine()->rootContext()->setContextProperty(
             QStringLiteral("ContactCategorySelectionModel"),
             CategorizedContactModel::SortedProxy::instance().categorySelectionModel()
          );
 
          auto completionModel = new NumberCompletionModel();
 
          RingApplication::engine()->rootContext()->setContextProperty(
             QStringLiteral("CompletionModel"), completionModel
          );
          auto im = new RingingImageProvider();
          e->addImageProvider( QStringLiteral("RingingImageProvider"), im );
          e->addImportPath(QStringLiteral("qrc:/"));
 
          auto im2 = new SymbolicColorizer();
          e->addImageProvider( QStringLiteral("SymbolicColorizer"), im2 );
 
          VideoWidget3::initProvider();
       }
       catch(char const* e) {
          qDebug() << "Failed to connect to the daemon" << e;
          sync();
          ::exit(1);
       }
       catch(...) {
          qDebug() << "Failed to connect to the daemon with an unknown problem";
          ::exit(2);
       }
    }
    return e;
 }
 
 #undef QML_TYPE
 #undef QML_SINGLETON
 #undef QML_ADD_OBJECT
 #undef QML_CRTYPE
 
 QQuickWindow* RingApplication::desktopWindow() const
 {
    static QQuickWindow* dw = nullptr;
    if (!dw) {
       QQmlComponent component(engine());
       component.loadUrl(QUrl(QStringLiteral("qrc:/DesktopWindow.qml")));
       if ( component.isReady() ) {
          qDebug() << "Previous error" << component.errorString();
 
          auto obj2 = component.create();
 
          // I have *no* clue why this is needed... A race somewhere
          while (component.errorString().isEmpty() && !obj2)
             obj2 = component.create();
 
          if (!(dw = qobject_cast<QQuickWindow*>(obj2)))
             qWarning() << "Failed to load:" << component.errorString();
       }
       else
          qWarning() << component.errorString();
    }
 
    Q_ASSERT(dw);
 
    return dw;
 }
 
 ///The daemon is not found
 void RingApplication::daemonTimeout()
 {
    if ((!Session::instance()->callModel()->isConnected()) || (!Session::instance()->callModel()->isValid())) {
       KMessageBox::error(nullptr, ErrorMessage::NO_DAEMON_ERROR);
       exit(1);
    }
 }
 
 void RingApplication::showWizard()
 {
    RingApplication::engine()->rootContext()->setContextProperty(
       QStringLiteral("wizardWelcomeOnly"), QVariant(false)
    );
 
    auto wiz = new WelcomeDialog();
    wiz->show();
 }
 
 void RingApplication::configureAccounts()
 {
    desktopWindow()->setProperty(
       "accountMode", true
    );
 }
 
 ///Exit gracefully
 bool RingApplication::notify (QObject* receiver, QEvent* e)
 {
    try {
       return QApplication::notify(receiver,e);
    }
    catch (const Call::State& state) {
       qDebug() << ErrorMessage::GENERIC_ERROR << "CallState" << state;
       QTimer::singleShot(2500, this, &RingApplication::daemonTimeout);
    }
    catch (const Call::Action& state) {
       qDebug() << ErrorMessage::GENERIC_ERROR << "Call Action" << state;
       QTimer::singleShot(2500, this, &RingApplication::daemonTimeout);
    }
    catch (const QString& errorMessage) {
       KMessageBox::error(nullptr,errorMessage);
       QTimer::singleShot(2500, this, &RingApplication::daemonTimeout);
    }
    catch (const std::exception& e) {
       qDebug() << ErrorMessage::GENERIC_ERROR << e.what();
       KMessageBox::error(nullptr,ErrorMessage::GENERIC_ERROR);
       QTimer::singleShot(2500, this, &RingApplication::daemonTimeout);
 
    }
    catch (...) {
       Q_ASSERT(false);
       qDebug() << ErrorMessage::GENERIC_ERROR;
       KMessageBox::error(nullptr, ErrorMessage::GENERIC_ERROR);
       QTimer::singleShot(2500, this, &RingApplication::daemonTimeout);
    }
    return false;
 }
 
 bool RingApplication::mayHaveFocus()
 {
    return m_HasFocus;
 }
 
 #include <ringapplication.moc>
 
 // kate: space-indent on; indent-width 3; replace-tabs on;
diff --git a/src/timeline/qml/peerstimeline.qml b/src/timeline/qml/peerstimeline.qml
index 520b5db9..3b266438 100644
--- a/src/timeline/qml/peerstimeline.qml
+++ b/src/timeline/qml/peerstimeline.qml
@@ -1,309 +1,309 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Bluesystems                                     *
  *   Author : Emmanuel Lepage Vallee <elv1313@gmail.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 3 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, see <http://www.gnu.org/licenses/>. *
  **************************************************************************/
 import QtQuick 2.7
 import QtQuick.Controls 2.2
 import Ring 1.0
 import QtQuick.Layouts 1.0
 import QtGraphicalEffects 1.0
 import org.kde.kirigami 2.2 as Kirigami
 import org.kde.playground.kquickitemviews 1.0 as KQuickItemViews
 import net.lvindustries.ringqtquick 1.0 as RingQtQuick
 
 import RingQmlWidgets 1.0
 
 Rectangle {
     SystemPalette {
         id: activePalette
         colorGroup: SystemPalette.Active
     }
 
     SystemPalette {
         id: inactivePalette
         colorGroup: SystemPalette.Disabled
     }
 
     color: activePalette.base
     id: recentDock
     visible: true
 
     property alias overlayVisible: scrollBar.overlayVisible
     signal contactMethodSelected(var cm)
     signal individualSelected(var ind)
     signal contextMenuRequested(var cm, int index)
 
     function setCurrentIndex(index) {
         recentView.setCurrentIndex(index)
     }
 
     FontMetrics {
         id: fontMetrics
     }
 
     Component {
         id: contactDelegate
         ContactMethodDelegate {}
     }
 
     Component {
         id: sectionDelegate
         PeersTimelineCategories {}
     }
 
     Component {
         id: noRegisteredAccounts
         AccountError {
             Component.onCompleted: {
                 implicitHeight = height + 20
                 accountError.height = height + 20
             }
         }
     }
 
     Component {
         id: noEnabledAccounts
         AccountDisabled {
             Component.onCompleted: {
                 implicitHeight = height
                 accountError.height = height
             }
         }
     }
 
     Component {
         id: noAccounts
         NoAccount {
             Component.onCompleted: {
                 implicitHeight = height
                 accountError.height = height
             }
         }
     }
 
     Component {
         id: pendingContactRequests
         ViewContactRequests {
             Component.onCompleted: {
                 implicitHeight = height
                 accountError.height = height
             }
         }
     }
 
     property bool displayNoAccount: RingSession.accountModel.size == 0
     property bool displayDisabled: !RingSession.accountModel.hasEnabledAccounts
     property bool displayNoRegAccounts: !RingSession.accountModel.hasAvailableAccounts
     property bool displayContactRequests: RingSession.accountModel.incomingContactRequestModel.size > 0
     property bool displayActionHeader: displayNoAccount || displayNoRegAccounts || displayDisabled || displayContactRequests
 
     Item {
         anchors.fill: parent
 
         Text {
             visible: recentView.empty
             anchors.centerIn: parent
             width: parent.width
             anchors.margins: 10
             wrapMode: Text.WordWrap
             color: activePalette.text
             text: i18n("To begin using Ring-KDE, enter an username in the box above and press enter")
         }
 
         Loader {
             id: accountError
             active: displayActionHeader
 
             width: parent.width -20 - scrollBar.width
             x: 10
             y: 10
             height: item ? item.implicitHeight : 0
 
             sourceComponent: displayNoAccount ? noAccounts : (
                 displayDisabled ? noEnabledAccounts : (
                     displayNoRegAccounts ? noRegisteredAccounts :
                         pendingContactRequests
             ))
         }
 
         KQuickItemViews.ListView {
             id: recentView
             clip: true
             anchors.fill: parent
             anchors.topMargin: (!accountError.active) ? 0 : accountError.height + 20
             delegate: contactDelegate
             section.delegate: sectionDelegate
             section.property: "formattedLastUsed" // indexedLastUsed
-            section.model: PeersTimelineModel.timelineSummaryModel
+            section.model: RingSession.peersTimelineModel.timelineSummaryModel
 
             highlight: Item {
 
                 anchors.topMargin: 5
                 anchors.bottomMargin: 5
                 anchors.leftMargin: 30
                 anchors.rightMargin: 40
                 Rectangle {
                     anchors.fill: parent
                     anchors.topMargin: 5
                     anchors.bottomMargin: 5
                     anchors.leftMargin: 30
                     anchors.rightMargin: 40
                     radius: 10
                     color: activePalette.highlight
                 }
             }
 
             model: KQuickItemViews.SizeHintProxyModel {
                 id: proxyModel
 
                 /*invalidationRoles: [
                     "object",
                     "unreadTextMessageCount",
                     "isRecording",
                     "hasActiveVideo",
                 ]*/
 
                 constants: ({
                     fmh: fontMetrics.height,
                     fmh2: fontMetrics.height,
                 })
 
                 function getRowCount(obj) {
                     var activeCM = obj ? obj.activeContactMethod : null
 
                     return 2 + ((obj != null) && (obj.hasActiveCall
                         || obj.unreadTextMessageCount > 0
                         || (activeCM && activeCM.isRecording)
                         || (activeCM && activeCM.hasActiveVideo)
                     ) ? 1 : 0)
                 }
 
                 widthHint: recentView.width
                 heightHint: (proxyModel.getRowCount(object)*2+1)*fmh + 13
 
-                sourceModel: PeersTimelineModel
+                sourceModel: RingSession.peersTimelineModel
             }
         }
 
         TimelineScrollbar {
             id: scrollBar
             height: parent.height
             anchors.top: parent.top
             anchors.right: parent.right
             width: 10
-            model: PeersTimelineModel.timelineSummaryModel
+            model: RingSession.peersTimelineModel.timelineSummaryModel
             z: 100
             display: recentView.moving || recentDock.state == ""
             view: recentView
 
             onWidthChanged: {
                 burryOverlay.width = scrollBar.fullWidth + 15
             }
         }
 
         // Add a blurry background
         ShaderEffectSource {
             id: effectSource
             visible: false
 
             sourceItem: recentView
             anchors.right: recentView.right
             anchors.top: recentView.top
             width: scrollBar.fullWidth + 15
             height: recentView.height
 
             sourceRect: Qt.rect(
                 parent.width - scrollBar.fullWidth - 15,
                 0,
                 scrollBar.fullWidth + 15,
                 recentView.height
             )
         }
 
         Item {
             id: burryOverlay
             visible: false
             opacity: 0
             anchors.right: recentView.right
             anchors.top: recentView.top
             width: scrollBar.fullWidth + 15
             height: recentView.height
             clip: true
 
             Repeater {
                 anchors.fill: parent
                 model: 5
                 FastBlur {
                     anchors.fill: parent
                     source: effectSource
                     radius: 30
 
                 }
             }
 
             Rectangle {
                 anchors.fill: parent
                 color: inactivePalette.highlight
                 opacity: 0.75
             }
         }
     }
 
     // Timeline scrollbar
     StateGroup {
         states: [
             State {
                 name: "overlay"
                 when: scrollBar.overlayVisible
                 PropertyChanges {
                     target:  burryOverlay
                     visible: true
                 }
                 PropertyChanges {
                     target:  burryOverlay
                     opacity: 1
                 }
                 PropertyChanges {
                     target:  effectSource
                     visible: true
                 }
             }
         ]
 
         transitions: [
             Transition {
                 to: "overlay"
                 NumberAnimation {
                     properties: "opacity"
                     easing.type: Easing.InQuad
                     duration: 400
                     loops: 1
                 }
             }
         ]
     }
 
     states: [
         State {
             name: ""
         },
         State {
             name: "mobile"
 
         }
     ]
 
 }
diff --git a/src/timeline/qml/searchoverlay.qml b/src/timeline/qml/searchoverlay.qml
index c6969072..6afae151 100644
--- a/src/timeline/qml/searchoverlay.qml
+++ b/src/timeline/qml/searchoverlay.qml
@@ -1,427 +1,427 @@
 /***************************************************************************
  *   Copyright (C) 2018 by Bluesystems                                     *
  *   Author : Emmanuel Lepage Vallee <elv1313@gmail.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 3 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, see <http://www.gnu.org/licenses/>. *
  **************************************************************************/
 import QtQuick 2.7
 import QtQuick.Controls 2.0
 import QtQuick.Layouts 1.0
 import QtGraphicalEffects 1.0
 import Ring 1.0
 import RingQmlWidgets 1.0
 import org.kde.kirigami 2.0 as Kirigami
-
+import net.lvindustries.ringqtquick 1.0 as RingQtQuick
 import Ring 1.0
 
 Item {
     id: seachOverlay
     property var source: null
     property bool active: searchBox.searchFocus
     property alias currentIndex: searchView.currentIndex
     property bool delayed: false
 
     signal contactMethodSelected(var cm)
     signal displayNotFoundMessage()
 
     function hide() {
         searchBox.hide()
     }
 
     // Add a blurry background
     ShaderEffectSource {
         id: effectSource
         visible: false
 
         sourceItem: seachOverlay.source
         anchors.fill: seachOverlay
 
         sourceRect: Qt.rect(
             0,
             0,
             parent.width,
             parent.height
         )
     }
 
     Timer {
         id: buggyTimer
         repeat: false
         running: true
         interval: 0
         onTriggered: {
             delayed = true
         }
     }
 
     Item {
         id: burryOverlay
         visible: false
         opacity: 0
         anchors.fill: parent
         clip: true
 
         Repeater {
             anchors.fill: parent
             model: 5
             FastBlur {
                 anchors.fill: parent
                 source: effectSource
                 radius: 30
 
             }
         }
 
         Rectangle {
             anchors.fill: parent
             color: inactivePalette.highlight
             opacity: 0.75
         }
     }
 
     FirstRun {
         id: firstRun
         visible: active
         active: searchStateGroup.state == "firstSearch"
         anchors.left: parent.left
         anchors.right: parent.right
         height: parent.height* 0.4
     }
 
     SearchBox {
         id: searchBox
         searchView: searchView
         width: topLevel.width
         xPadding: dockBar.width
     }
 
     // The close and QR CODE buttons
 
     Loader {
         height: 30
         width: parent.width - searchBox.labelWidth
         anchors.right: parent.right
         clip: true
         active: seachOverlay.active && searchStateGroup.state != "firstSearch"
         sourceComponent: RowLayout {
 
             Behavior on x {
                 NumberAnimation {duration: 350; easing.type: Easing.OutQuad}
             }
 
             Item {
                 Layout.fillWidth: true
             }
 
             OutlineButton {
                 label: "  "+i18n("Scan a QR Code")
                 visible: false //Not implemented
                 height: 24
                 alignment: Qt.AlignRight
                 Layout.maximumWidth: width
                 icon: "image://SymbolicColorizer/:/sharedassets/outline/qrcode.svg"
             }
 
             OutlineButton {
                 label: "  "+i18n("Close")
                 height: 24
                 alignment: Qt.AlignRight
                 icon: "image://SymbolicColorizer/:/sharedassets/outline/close.svg"
                 onClicked: {
                     hide()
                 }
             }
 
             Component.onCompleted: x = 0
         }
     }
 
     ListModel {
         id: searchCategoryModel
 
         ListElement {
             name: "Web"
             elemColor: "#2c53bd"
             src: "image://SymbolicColorizer/?color=#2c53bd;:/sharedassets/outline/web.svg"
         }
         ListElement {
             name: "Bookmarks"
             elemColor: "#cfa02a"
             src: "image://SymbolicColorizer/?color=#cfa02a;:/toolbar/bookmark.svg"
         }
         ListElement {
             name: "Contacts"
             elemColor: "#14883b"
             src: "image://SymbolicColorizer/?color=#14883b;:/toolbar/contact.svg"
         }
         ListElement {
             name: "History"
             elemColor: "#be3411"
             src: "image://SymbolicColorizer/?color=#be3411;:/toolbar/history.svg"
         }
     }
 
     Loader {
         id: filterList
         active: searchView.count > 0 && searchStateGroup.state == "searchActive"
         opacity: searchView.count > 0 ? 1 : 0
         height: 30 + Kirigami.Units.fontMetrics.height*1.5
         y: searchBox.y+searchBox.height+5
         width: parent.width
 
         Behavior on opacity {
             NumberAnimation {duration: 150;  easing.type: Easing.InQuad}
         }
 
         sourceComponent: Row {
             anchors.fill: parent
             Repeater {
                 model: searchCategoryModel
                 Item {
                     width: parent.width / 4
                     height: sourceName.implicitHeight + 34
                     Rectangle {
                         anchors.horizontalCenter: parent.horizontalCenter
                         width: 30
                         height: 30
                         radius: 99
                         border.width: 2
                         border.color: elemColor
                         color: "transparent"
                         Image {
                             width: parent.width*0.8
                             height: width
                             anchors.centerIn:parent
                             sourceSize.width: width
                             sourceSize.height: width
                             source: src
                         }
                     }
                     Text {
                         id: sourceName
                         anchors.bottom: parent.bottom
                         anchors.topMargin: 4
                         anchors.horizontalCenter: parent.horizontalCenter
                         color: activePalette.text
                         text: name
                     }
                 }
             }
         }
     }
 
     // Display some tips and help to new users
     SearchTip {
         active: seachOverlay.active
             && (!filterList.active)
             && searchStateGroup.state != "firstSearch"
             && displayTips.showSearchTip
         anchors.top: searchBox.bottom
         anchors.topMargin: 15
         width: parent.width
     }
 
     FindPeers {
         id: searchView
         visible: false
         anchors.fill: parent
         anchors.topMargin: filterList.y + filterList.height
         z: 99999999
     }
 
     Rectangle {
         id: notFoundMessage
         z: 999999999
         visible: false
         anchors.bottom: parent.bottom
         anchors.horizontalCenter: parent.horizontalCenter
         anchors.bottomMargin: 20
         radius: 5
         width: parent.width * 0.80
         height: errorLabel.implicitHeight + 20
         color: inactivePalette.text
         opacity: 0
 
         Behavior on opacity {
             NumberAnimation {duration: 150; easing.type: Easing.OutQuad}
         }
 
         Timer {
             id: errorMessageTimer
             running: false
             interval: 3000
             repeat: false
 
             onTriggered: {
                 notFoundMessage.visible = false
                 notFoundMessage.opacity = 0
             }
         }
 
         Text {
             id: errorLabel
             width: parent.width
             y: 10
             wrapMode: Text.WordWrap
             horizontalAlignment: Text.AlignHCenter
             color: inactivePalette.base
             text: i18n("Cannot select this person because it was not found")
         }
     }
 
     onDisplayNotFoundMessage: {
         errorMessageTimer.running = true
         notFoundMessage.visible = true
         notFoundMessage.opacity = 1
     }
 
     CheckBox {
         z: 199999999
         anchors.bottom: parent.bottom
         anchors.right: parent.right
         anchors.margins: 10
         text: i18n("Hide and do not show again")
         checked: false
         checkable: true
         visible: displayTips.showFirstTip && searchStateGroup.state == "firstSearch"
         onCheckStateChanged: {
             searchBox.searchFocus    = false
             displayTips.showFirstTip = false
         }
     }
 
     // Search
     StateGroup {
         id: searchStateGroup
 
         states: [
             State {
                 name: ""
                 when: ((!wizardVisible) && (!seachOverlay.active) && (
-                    (!PeersTimelineModel.empty) || (!displayTips.showFirstTip)
+                    (!RingSession.peersTimelineModel.empty) || (!displayTips.showFirstTip)
                 )) || (!delayed)
 
                 ParentChange {
                     target: seachOverlay
                     parent: topLevel
                 }
 
                 PropertyChanges {
                     target:  seachOverlay
                     anchors.fill: parent
                 }
 
                 PropertyChanges {
                     target:  searchView
                     visible: false
                 }
 
                 PropertyChanges {
                     target:  burryOverlay
                     visible: false
                     opacity: 0
                 }
 
                 PropertyChanges {
                     target: desktopOverlay
                     visible: false
                 }
             },
             State {
                 name: "searchActive"
                 when: delayed && (!wizardVisible) && seachOverlay.active
                     && (
                         (!PeersTimelineModel.empty) || (!displayTips.showFirstTip)
                     )
 
                 PropertyChanges {
                     target:  seachOverlay
                     anchors.fill: parent
                     width: undefined
                     height: undefined
                 }
 
                 PropertyChanges {
                     target:  searchView
                     visible: true
                 }
 
                 PropertyChanges {
                     target:  burryOverlay
                     visible: true
                     opacity: 1
                 }
 
                 PropertyChanges {
                     target:  effectSource
                     sourceRect: Qt.rect(0, 0, parent.width, parent.height)
                 }
 
                 PropertyChanges {
                     target: desktopOverlay
                     visible: false
                 }
             },
             State {
                 name: "firstSearch"
                 extend: "searchActive"
                 when: delayed && (!wizardVisible) && (
                     PeersTimelineModel.empty || !searchBox.empty
                 ) && displayTips.showFirstTip
                 PropertyChanges {
                     target:  seachOverlay
                     anchors.fill: undefined
                     width: applicationWindow().contentItem.width
                     height: applicationWindow().contentItem.height
                 }
 
                 ParentChange {
                     target: seachOverlay
                     parent: desktopOverlay
                 }
 
                 PropertyChanges {
                     target: searchBox
                     y: firstRun.height + 10
                     width: seachOverlay.width*0.9
                     x: seachOverlay.width*0.05
                     searchFocus: true
                 }
 
                 PropertyChanges {
                     target: desktopOverlay
                     visible: true
                 }
             }
         ]
 
         transitions: [
             Transition {
                 to: "searchActive"
                 NumberAnimation {
                     properties: "opacity"
                     easing.type: Easing.InQuad
                     duration: 200
                     loops: 1
                 }
                 NumberAnimation {
                     properties: "width,height"
                     easing.type: Easing.InQuad
                     duration: 0
                     loops: 1
                 }
             }
         ]
     }
 }
diff --git a/src/wizard/qml/CreateRing.qml b/src/wizard/qml/CreateRing.qml
index 26219429..942a126e 100644
--- a/src/wizard/qml/CreateRing.qml
+++ b/src/wizard/qml/CreateRing.qml
@@ -1,458 +1,458 @@
 /***************************************************************************
  *   Copyright (C) 2017 by Bluesystems                                     *
  *   Author : Emmanuel Lepage Vallee <elv1313@gmail.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 3 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, see <http://www.gnu.org/licenses/>. *
  **************************************************************************/
 import QtQuick 2.0
 import QtQuick.Controls 2.0
 import QtQuick.Layouts 1.0
 import Ring 1.0
 import net.lvindustries.ringqtquick 1.0 as RingQtQuick
 
 Item {
     id: createRing
     property alias registerUserName: registerUserName
 
     property bool nextAvailable: false
     property bool busy: false
     property var lookupState: 2
 
     property var account: null
 
     signal registrationCompleted(QtObject account)
 
     width: Math.min(createForm.implicitWidth, parent.width - 20)
     height: createForm.implicitHeight
 
     function isNextAvailable() {
         nextAvailable = (userName.text.length > 2 || !registerUserName.checked)
             && (password.text.length > 0)
             && (password.text == repeatPassword.text)
             && (lookupState == 2 || !registerUserName.checked)
     }
 
     function performLookup() {
         if (userName.text != "" && userName.text.length > 2 && registerUserName.checked) {
             registerFoundLabel.text = i18n("Please enter an username")
             registerFoundLabel.color = "white"
             createRing.lookupState = 2
             NameDirectory.lookupName(undefined, "", userName.text)
         }
         else
             createRing.lookupState = 2
     }
 
     function createAccount() {
         if (!nextAvailable) {
             console.log("Account creation failed: missing fields")
             return;
         }
 
         // Prevent trigger happy people from DDOSing the daemon with entropy
         // starvation
         nextAvailable = false
         busy = true
 
         // Display the progress popup
         state = "registrationResult"
         registrationTimeout.running = true
 
         // The alias is not selected by the profile (if necessary)
         var name = userName.text
 
         // Make sure they are unique
         name = name + RingSession.accountModel.getSimilarAliasIndex(name)
 
         account = RingSession.accountModel.add(name, RingQtQuick.Account.RING);
         account.displayName     = name
         account.archivePassword = password.text
         account.upnpEnabled     = true;
 
         account.performAction(RingQtQuick.Account.SAVE)
         account.performAction(RingQtQuick.Account.RELOAD)
         console.log("Account creation in progress")
     }
 
     ColumnLayout {
         id: createForm
         anchors.fill: parent
 
         Switch {
             id: registerUserName
             height: 40
             text: i18n("Register public username*")
             checked: true
             opacity: 1
             Layout.fillWidth: true
             onCheckedChanged: {
                 performLookup()
                 isNextAvailable()
             }
         }
 
         Label {
             id: label2
             clip: true
             x: -7
             y: 170
             height: 14
             text: i18n("Enter an username")
             color: "white"
             anchors.leftMargin: 8
             Layout.fillWidth: true
 
             /*Behavior on Layout.maximumHeight {
                 NumberAnimation {
                     easing.type: Easing.OutQuad
                     duration: 500
                 }
             }*/
         }
 
         TextField {
             id: userName
             clip: true
             x: 8
             y: 74
             height: 40
             Layout.fillWidth: true
 
             onTextChanged: {
                 performLookup()
 
                 busyIndicator.visible = userName.text != ""
                 isNextAvailable()
             }
         }
 
         RowLayout {
             id: rowLayout
             clip: true
             Layout.fillHeight: false
             Layout.maximumHeight: 37
             Layout.fillWidth: true
             visible: registerUserName.checked
             spacing: 6
 
             Item {
                 width: 37
                 height: 37
                 Layout.fillHeight: true
                 Layout.preferredWidth: 37
 
                 BusyIndicator {
                     id: busyIndicator
                     anchors.fill: parent
                     visible: false
                 }
 
                 Image {
                     id: image
                     anchors.fill: parent
                 }
             }
 
             Label {
                 id: registerFoundLabel
                 text: i18n("Please enter an username")
                 verticalAlignment: Text.AlignVCenter
                 color: "white"
                 Layout.fillHeight: true
                 Layout.fillWidth: true
             }
 
             /*Behavior on Layout.maximumHeight {
                 NumberAnimation {
                     easing.type: Easing.OutQuad
                     duration: 500
                 }
             }*/
         }
 
         Label {
             id: label1
             text: i18n("Enter an archive password")
             color: "white"
             Layout.fillWidth: true
             anchors.leftMargin: 8
         }
 
         TextField {
             id: password
             echoMode: "Password"
             Layout.fillWidth: true
             onTextChanged: isNextAvailable()
         }
 
         Label {
             id: label
             color: "white"
             text: i18n("Repeat the new password")
             Layout.fillWidth: true
             anchors.leftMargin: 8
         }
 
         TextField {
             id: repeatPassword
             echoMode: "Password"
             Layout.fillWidth: true
             onTextChanged: isNextAvailable()
         }
 
         Label {
             id: label4
             color: "red"
             text: i18n("Passwords don't match")
             verticalAlignment: Text.AlignVCenter
             Layout.fillHeight: true
             Layout.fillWidth: true
             opacity: 0
 
             // Only show when the passwords mismatch
             states: [
                 State
                 {
                     name: "invisible"
                     when: repeatPassword.text != password.text
                     PropertyChanges {
                         target: label4
                         opacity: 1
                     }
                 }
             ]
 
             Behavior on opacity {
                 NumberAnimation {
                     easing.type: Easing.OutQuad
                     duration: 200
                 }
             }
         }
 
         Item {
             height: 10
             Layout.fillWidth: true
         }
 
         Label {
             id: labelInfo
             color: "white"
             text: i18n("(*) registered usernames can be reached by their username-string instead of their generated ring-id number only.")
             Layout.fillWidth: true
             wrapMode: Text.WordWrap
         }
 
         Rectangle {
             Layout.fillHeight: true
         }
     }
 
     Rectangle {
         id: registrationPopup
         width: popupLayout.implicitWidth + 50
         height: popupLayout.implicitHeight + 10
         color: "#eeeeee"
         visible: false
         z: 200
         anchors.centerIn: createRing
 
         RowLayout {
             id: popupLayout
             anchors.verticalCenter: parent.verticalCenter
 
             BusyIndicator {
                 id: registrationIndicator
                 Layout.fillHeight: false
             }
 
             Label {
                 id: registrationStatus
                 text: i18n("Creating account")
                 Layout.fillHeight: false
                 Layout.fillWidth: true
                 color: "black"
             }
         }
     }
 
     // Hide the error message after a second
     Timer {
         id: hidePopup
         repeat: false
         running: false
         interval: 1000
         onTriggered: {
             registrationPopup.visible = false
         }
     }
 
     // Remove the popup after 30 seconds if it didn't finish by then
     Timer {
         id: registrationTimeout
         repeat: false
         interval: 30000
         running: false
         onTriggered: {
             registrationPopup.color = "red"
             registerFoundLabel.text = i18n("Timeout")
             hidePopup.running       = true
             nextAvailable = true
             busy = false
         }
     }
 
     states: [
         State {
             name: "noRegister"
             when: !registerUserName.checked
 
             PropertyChanges {
                 target: label2
                 Layout.maximumHeight: 0
                 opacity: 0
             }
 
             PropertyChanges {
                 target: label
                 padding: 0
             }
         },
         State {
             name: "registrationResult"
 
             PropertyChanges {
                 target: registrationPopup
                 visible: true
             }
         }
     ]
 
     /*transitions: Transition {
         NumberAnimation {
             properties: "opacity"
             easing.type: Easing.OutQuad
             duration: 500
             onStopped: {
                 label2.visible = false
                 userName.visible = false
                 rowLayout.visible = false
             }
         }
     }*/
 
     // After each username field change, check availability
     Connections {
-        target: NameDirectory
+        target: RingSession.nameDirectory
         onRegisteredNameFound: {
             //  Race conditions
             if (userName.text != name)
                 return;
 
             createRing.lookupState = status
 
             busyIndicator.visible = false
             if (status == 2) { //NameDirectory.NOT_FOUND
                 registerFoundLabel.text = i18n("The username is available")
                 registerFoundLabel.color = "green"
             }
             else if (status == 1 || name == "") {
                 registerFoundLabel.text = i18n("Please enter an username (3 characters minimum)")
                 registerFoundLabel.color = "white"
                 nextAvailable = false
             }
             else if (status == 3) {
                 registerFoundLabel.text = i18n("The registered name lookup failed, ignoring")
                 nextAvailable = true
             }
             else {
                 registerFoundLabel.text = i18n("The username is not available")
                 registerFoundLabel.color = "red"
                 nextAvailable = false
             }
             isNextAvailable()
         }
     }
 
     Connections {
         target: NameDirectory
         onNameRegistrationEnded: {
             registrationTimeout.stop()
 
             if (status == 0)
                 registrationPopup.color = "green"
             else {
                 registrationPopup.color = "red"
                 hidePopup.running = true
             }
 
             registrationIndicator.visible = false
 
             switch(status) {
                 case 0: //SUCCESS
                     registrationStatus.text = i18n("Success")
                     busy = false
                     createRing.registrationCompleted(account)
                     break
                 case 1: //WRONG_PASSWORD
                     registrationStatus.text = i18n("Password mismatch")
                     break
                 case 2: //INVALID_NAME
                     registrationStatus.text = i18n("Invalid name")
                     break
                 case 3: //ALREADY_TAKEN
                     registrationStatus.text = i18n("Already taken")
                     break
                 case 4: //NETWORK_ERROR
                     registrationStatus.text = i18n("Network error")
                     break
             }
         }
     }
 
     Connections {
         target: account
         onStateChanged: {
             // Assume UNREGISTERED accounts are ok, otherwise it will have
             // false negatives
             if (state == RingQtQuick.Account.READY || state == RingQtQuick.Account.UNREGISTERED) {
                 if (registerUserName.checked) {
                     if (account.registerName(password.text, account.displayName)) {
                         registrationStatus.text = i18n("Registration")
                         registrationTimeout.stop()
                     }
                     else {
                         registrationPopup.color = "red"
                         registrationStatus.text = i18n("Can't register")
                         registrationTimeout.stop()
                     }
                 }
                 else {
                     registrationTimeout.stop()
                     registrationIndicator.visible = false
                     busy = false
                     createRing.registrationCompleted(account)
                 }
                 account = null
             }
             else if (state == RingQtQuick.Account.ERROR) {
                 console.log("The account creation failed with an invalid state:",
                     account.lastErrorMessage)
             }
             else {
                 console.log("The wizard account creation has state:", state)
             }
         }
     }
 }