diff --git a/Desktop.qml b/Desktop.qml
index 78b6263e..cd1f2409 100644
--- a/Desktop.qml
+++ b/Desktop.qml
@@ -1,285 +1,307 @@
 
 // Skeleton from https://github.com/achipa/outqross_blog.git
 // Almost everything has been re-adapted
 
 import QtQuick 2.7
 import QtQuick.Controls 1.4
 import QtQuick.Controls.Styles 1.2
 import QtQuick.Window 2.2
 import QtQuick.Dialogs 1.2
 import QtQuick.Layouts 1.1
 import Qt.labs.settings 1.0
 import QtGraphicalEffects 1.0
 
 import KDE.Ruqola.UserData 1.0
 import KDE.Ruqola.DDPClient 1.0
 
 // import "Log.js" as Log
 // import "Data.js" as Data
 
 ApplicationWindow {
     property int margin: 11
     property string statusText
     
     property string lightGreen: "#6ab141";
     property string darkGreen: "#00613a";
     
     property string selectedRoomID: "";
     
     id: appid
     title: qsTr("Ruqola")
     width: 800
     height: 600
     visible: true
     
     Shortcut {
         sequence: StandardKey.Quit
         context: Qt.ApplicationShortcut
         onActivated: Qt.quit()
     }
     
     Login {
         id: loginTab
         visible: (UserData.loginStatus == DDPClient.LoginFailed || UserData.loginStatus == DDPClient.LoggedOut)
         
         anchors.fill:parent
         z: 10
         serverURL: UserData.serverURL
         username: UserData.userName
         onAccepted: {
             UserData.password = loginTab.password;
             UserData.userName = loginTab.username;
             UserData.serverURL = loginTab.serverURL;
             UserData.tryLogin();
         }        
     }
     
     BusyIndicator {
         id: busy
         anchors.centerIn: parent
         visible: UserData.loginStatus == DDPClient.LoggingIn
     }
 
     Item {
         id: mainWidget
         anchors.fill: parent
         visible: !loginTab.visible
 
         Rectangle {
             id: userBox
             anchors.top: parent.top
             width: parent.width
             anchors.left: parent.left
             anchors.right: roomsList.right
             height: 40
             color: darkGreen
             Text {
                 verticalAlignment: Text.AlignVCenter
                 horizontalAlignment: Text.AlignRight
                 anchors.rightMargin: 10
                 anchors.fill: parent
                 font.pointSize: 12
                 color: "white"
                 text: "Hello, " + UserData.userName
             }
             
         }
             
         RoomsView {
             anchors.top: userBox.bottom
             anchors.left: parent.left
             anchors.bottom: parent.bottom
             anchors.margins: 0            
             width: 200
             height: appid.height
 
             id: roomsList
             
             model: UserData.roomModel()
 
             visible: parent.visible
             
             selectedRoomID: appid.selectedRoomID;
             
             onRoomSelected: {
                 if (roomID == selectedRoomID) {
                     return;
                 }
                 console.log("Choosing room", roomID);
                 appid.selectedRoomID = roomID;
                 activeChat.model = UserData.getModelForRoom(roomID)
                 topicWidget.selectedRoom = UserData.getRoom(roomID)
             }
             
             onCountChanged: {
 //                 console.log("We have", roomsList.count, "rooms")
             }
             
             LinearGradient {
                 id: greenGradient
                 anchors.fill: parent
                 start: Qt.point(0, 0)
                 end: Qt.point(roomsList.width, 0)
                 gradient: Gradient {
                     GradientStop { position: 0.0; color: "#6ab141" }
                     GradientStop { position: 1.0; color: "#00613a" }
                 }
                 z: -1;
                 
             }
         }
         
         
         Item {
             anchors.right: parent.right
             anchors.left: roomsList.right
             anchors.top: parent.top
             anchors.bottom: messageLine.top
             
 //             Item {
 //                 anchors.fill: parent
 //                 id: greeter
 //                 visible: false
 // //                 visible: selectedRoomID.empty
 //                 Text {
 //                     text: "Welcome to Ruqola!";
 //                 }
 //             }
             Rectangle {
                 id: topicWidget
                 color: "#fff"
                 anchors.top: parent.top
                 
                 property var selectedRoom;
                 
                 Text {
-                    anchors.fill: parent
+                    id: nameLabel
                     text: "#" + parent.selectedRoom.name
                     font.pointSize: 18
                     verticalAlignment: Text.AlignVCenter
                     anchors.leftMargin: 20
+                    height: 40
+                
+                    anchors.top: parent.top
+                    anchors.left: parent.left
+                    anchors.right: parent.right
+                    
                 }
+                
+                Text {
+                    id: topicLabel
+                    text: topicWidget.selectedRoom.topic
+                    
+                    anchors.top: nameLabel.bottom
+                    anchors.bottom: parent.bottom
+                    anchors.left: parent.left
+                    anchors.right: parent.right
+                    
+                    horizontalAlignment: Text.AlignHCenter
+                    
+                    height: font.pixelSize + 10
+                }                    
+//                 */
                 anchors.right: parent.right
                 anchors.left: parent.left
-                height: 40
+                height: nameLabel.height + topicLabel.height 
+                
             }
             
             ScrollView {
                 
                 anchors.right: parent.right
                 anchors.left: parent.left
                 anchors.top: topicWidget.bottom
                 anchors.bottom: parent.bottom
                 
                 verticalScrollBarPolicy: Qt.ScrollBarAlwaysOn
 //                 visible: parent.visible && (UserData.loginStatus != DDPClient.LoggingIn)
                 visible: !greeter.visible
 
          
                 ListView {
                     id: activeChat
 //                     model: UserData.getModelForRoom(selectedRoomID)
 
                     onCountChanged: {
     //                     console.log("changed")
     //                     var newIndex = count - 1 // last index
     //                     positionViewAtEnd()
                         positionViewAtIndex(count - 1, ListView.Beginning)
 
     //                     currentIndex = newIndex
                     }
     //                 Component.onCompleted: positionViewAtEnd()
                     Component.onCompleted: positionViewAtIndex(count - 1, ListView.Beginning)
 
 
     //                 onSelectedRoomIDChanged: { console.log("CHANGED"); activeChat.positionViewAtEnd(); }
 
     //                 model: myModel
                     anchors.fill:parent
                     visible : count > 0
                     
                     
                     z: -1
                     
         //             ScrollBar.vertical: ScrollBar { }
                     
                     delegate: Message {
                                 i_messageText: messageText
                                 i_username: username
                                 i_systemMessage: systemMessage
                                 i_systemMessageType: type
                                 width: parent.width
                             }
                 }
             }
         }
         TextField {
             id: messageLine
             anchors.right: parent.right
             anchors.left: roomsList.right
             anchors.bottom: parent.bottom
             placeholderText: qsTr("Enter message")
             height: 2.7*font.pixelSize
 //             font.pointSize: 12
             
             onAccepted: {
                 if (text != "") {
                     UserData.sendMessage(selectedRoomID, text);
                     text = "";
                 }
             }
         }
     }
     
     Rectangle {
         z: -10
         anchors.fill: parent
         color: "white"
     }
     
     onClosing: {
         console.log("Minimizing to systray...");
         hide();
     }
     
     function toggleShow(reason) {
 //         console.log ("Showing");
         
         if (visible) {
             hide();
         } else {
             show();
             raise();
             requestActivate();
         }
     }
     Component.onCompleted: {
         systrayIcon.activated.connect(toggleShow);
 //         roomsList.model = UserData.roomModel();
 //         systrayIcon.showMessage("Connected", "We are CONNECTED!");
     
         timer.start();
         timer.fire();
     }
 
 /*    
     Timer {
         id: timer
         interval: 1000
         onTriggered: {
 //             console.log("FIRE");
             switch (UserData.loginStatus) {
                 case UserData.NotConnected:
                     statusText = qsTr("Not connected.");
                     break;
                 case UserData.LoggedIn:
                         statusText = qsTr("Connected to " + UserData.serverURL);
                         break;
                     
             }
         }
         repeat: true
     }*/
 
     onStatusTextChanged: timer.restart();
 }
diff --git a/src/ddpclient.cpp b/src/ddpclient.cpp
index 0743352d..73f070ff 100644
--- a/src/ddpclient.cpp
+++ b/src/ddpclient.cpp
@@ -1,296 +1,297 @@
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright 2016  Riccardo Iaconelli <riccardo@kde.org>
  *
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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 "ddpclient.h"
 
 #include <QtCore/QJsonDocument>
 #include <QtCore/QJsonObject>
 
 #include <iostream>
 #include "userdata.h"
 
 void process_test(QJsonDocument doc)
 {
     qDebug() << "Callback test:" << doc;
     qDebug() << "End callback";
 }
 
 void login_callback(QJsonDocument doc)
 {
     qDebug() << "LOGIN:" << doc;
     UserData::self()->setAuthToken(doc.object().value("token").toString());
     qDebug() << "End callback";
 }
 
 void DDPClient::resume_login_callback(QJsonDocument doc)
 {
     qDebug() << "LOGIN:" << doc;
     UserData::self()->setAuthToken(doc.object().value("token").toString());
     qDebug() << "End callback";
 }
 
 
 void empty_callback(QJsonDocument doc)
 {
     Q_UNUSED(doc);
 }
 
 DDPClient::DDPClient(const QString& url, QObject* parent)
  : QObject(parent),
   m_url(url),
   m_uid(1),
   m_loginJob(0),
   m_loginStatus(NotConnected),
   m_connected(false),
   m_attemptedPasswordLogin(false),
   m_attemptedTokenLogin(false)
 {
     m_webSocket.ignoreSslErrors();
     connect(&m_webSocket, &QWebSocket::connected, this, &DDPClient::onWSConnected);
     connect(&m_webSocket, &QWebSocket::textMessageReceived, this, &DDPClient::onTextMessageReceived);
     connect(&m_webSocket, &QWebSocket::disconnected, this, &DDPClient::WSclosed);
     connect(UserData::self(), &UserData::serverURLChanged, this, &DDPClient::onServerURLChange);    
     
     if (!url.isEmpty()) {
         m_webSocket.open(QUrl("wss://"+url+"/websocket"));
     }
     qDebug() << "Trying to connect to URL" << url;
     
 }
 
 DDPClient::~DDPClient()
 {
     m_webSocket.close();
 }
 
 void DDPClient::onServerURLChange()
 {
     if (UserData::self()->serverURL() != m_url || !m_webSocket.isValid()) {
         if (m_webSocket.isValid()) {
             m_webSocket.flush();
             m_webSocket.close();
         }
         m_url = UserData::self()->serverURL();
         m_webSocket.open(QUrl("wss://"+m_url+"/websocket"));
         connect(&m_webSocket, &QWebSocket::connected, this, &DDPClient::onWSConnected);
         qDebug() << "Reconnecting" << m_url; //<< m_webSocket.st;
     }
 }
 
 DDPClient::LoginStatus DDPClient::loginStatus() const
 {
     return m_loginStatus;
 }
 
 bool DDPClient::isConnected() const
 {
     return m_connected;
 }
 
 bool DDPClient::isLoggedIn() const
 {
     return m_loginStatus == LoggedIn;
 }
 
 unsigned int DDPClient::method(const QString& m, const QJsonDocument& params)
 {
     return method(m, params, empty_callback);
 }
 
 unsigned int DDPClient::method(const QString& method, const QJsonDocument& params, std::function<void (QJsonDocument)> callback)
 {
     QString json;
     if (params.isArray()){
         json = "{\"msg\":\"method\", \"method\": \"%1\", \"id\": \"%2\", \"params\": %3}";
     } else {
         json = "{\"msg\":\"method\", \"method\": \"%1\", \"id\": \"%2\", \"params\": [%3]}";
     }
     
     json = json.arg(method).arg(m_uid).arg(QString(params.toJson(QJsonDocument::Compact)));
     
     qint64 bytes = m_webSocket.sendTextMessage(json.toUtf8()); // FIXME : text? maybe binary will be better - check if it keeps working
     if (bytes < json.length()) {
         qDebug() << "ERROR! I couldn't send all of my message. This is a bug! (try again)";
         qDebug() << m_webSocket.isValid() << m_webSocket.error() << m_webSocket.requestUrl();
     } else {
         qDebug() << "Successfully sent " << json;
     }
 
     //callback(QJsonDocument::fromJson(json.toUtf8()));
     m_callbackHash[m_uid] = callback;
 
     m_uid++;
     return m_uid - 1 ;
 }
 
 void DDPClient::subscribe(const QString& collection, const QJsonDocument& params)
 {
     QString json("{\"msg\":\"sub\",\"id\": \"%1\",\"name\":\"%2\", \"params\": %3}");
     json = json.arg(m_uid).arg(collection).arg(QString(params.toJson(QJsonDocument::Compact)));
     qint64 bytes = m_webSocket.sendBinaryMessage(json.toUtf8()); // FIXME : text? maybe binary will be better - check if it keeps working
     if (bytes < json.length()) {
         qDebug() << "ERROR! I couldn't send all of my message. This is a bug! (try again)";
     } else {
         qDebug() << "Successfully sent " << json;
     }
     
     m_uid++;
     
 }
 
 void DDPClient::onTextMessageReceived(QString message)
 {
     QJsonDocument response = QJsonDocument::fromJson(message.toUtf8());
     
     if (!response.isNull() && response.isObject()) {
         
         QJsonObject root = response.object();
         QString messageType = root.value("msg").toString();
         
         if (messageType == "updated") {
         
             
         } else if (messageType == "result") {
             
 //             qDebug() << "got a result" << root;
             unsigned id = root.value("id").toString().toInt();
             
             if (m_callbackHash.contains(id)) {
                 std::function<void (QJsonDocument)> callback = m_callbackHash.take(id);
                 callback( QJsonDocument(root.value("result").toObject()) );
             }
             emit result(id, QJsonDocument(root.value("result").toObject()));
             
             if (id == m_loginJob) {
                 if (root.value("error").toObject().value("error").toInt() == 403) {
                     qDebug() << "Wrong password or token expired";
                     
 //                     // Kill wrong credentials, so we don't try to use them again
 //                     if (!UserData::instance()->authToken().isEmpty()) {
 //                         UserData::instance()->setAuthToken(QString());
 //                     } else if (!UserData::instance()->password().isEmpty()) {
 //                         UserData::instance()->setPassword(QString());
 //                     }
 //                     setLoginStatus(DDPClient::LoginFailed);
                     
                     
                     login(); // Let's keep trying to log in
                 } else {
                     UserData::self()->setAuthToken(root.value("result").toObject().value("token").toString());
 
                     setLoginStatus(DDPClient::LoggedIn);
                 }
 //                 emit loggedInChanged();
             }
             
         } else if (messageType == "connected") {
             qDebug() << "Connected";
             m_connected = true;
             emit connectedChanged();
             setLoginStatus(DDPClient::LoggingIn);
             login(); // Try to resume auth token login
             
             
         } else if (messageType == "error") {
             qDebug() << "ERROR!!" << message;
         } else if (messageType == "ping") {
             qDebug() << "Ping - Pong";
             m_webSocket.sendBinaryMessage("{\"msg\":\"pong\"}");
         } else if (messageType == "added"){
+            qDebug() << "ADDING" <<root;
             emit added(root);
         } else if (messageType == "changed") {
             emit changed(root);
         } else if (messageType == "ready") {
             // do nothing
         }else {
             qDebug() << "received something unhandled:" << message;
         }
     }
     
 }
 
 void DDPClient::setLoginStatus(DDPClient::LoginStatus l)
 {
     qDebug() << "Setting login status to" << l;
     m_loginStatus = l;
     emit loginStatusChanged();
     
     // reset flags
     if (l == LoginFailed) {
         m_attemptedPasswordLogin = false;
         m_attemptedTokenLogin = false;
     }
 }
 
 void DDPClient::login()
 {
     if (!UserData::self()->password().isEmpty()) {
  
         // If we have a password and we couldn't log in, let's stop here
         if (m_attemptedPasswordLogin) {
             setLoginStatus(LoginFailed);
             return;
         }
         
         m_attemptedPasswordLogin = true;
         QString json = "{\"password\":\"%1\", \"user\": {\"username\":\"%2\"}}";
         json = json.arg(UserData::self()->password()).arg(UserData::self()->userName());
         m_loginJob = method("login", QJsonDocument::fromJson(json.toUtf8()));
         
     } else if (!UserData::self()->authToken().isEmpty() && !m_attemptedTokenLogin) {
         m_attemptedPasswordLogin = true;
         QString json = "{\"resume\":\"%1\"}";
         json = json.arg(UserData::self()->authToken());
         m_loginJob = method("login", QJsonDocument::fromJson(json.toUtf8()));
     } else {
         setLoginStatus(LoginFailed);
     }
 }
 
 void DDPClient::logOut()
 {
 //     setLoginStatus(NotConnected);
     m_webSocket.close();
 }
 
 void DDPClient::onWSConnected()
 {
     qDebug() << "Websocket connected at URL" << m_url;
     
     QString json("{\"msg\":\"connect\", \"version\": \"1\", \"support\": [\"1\"]}");
     
     qint64 bytes = m_webSocket.sendTextMessage(json.toUtf8());
     if (bytes < json.length()) {
         qDebug() << "ERROR! I couldn't send all of my message. This is a bug! (try again)";
     } else {
         qDebug() << "Successfully sent " << json;
     }
 }
 
 void DDPClient::WSclosed()
 {
     qDebug() << "WebSocket CLOSED" << m_webSocket.closeReason() << m_webSocket.error() << m_webSocket.closeCode();
     setLoginStatus(NotConnected);
 //     m_connected = false;
 }
 
 
diff --git a/src/rocketchatbackend.cpp b/src/rocketchatbackend.cpp
index 449c163e..23f99789 100644
--- a/src/rocketchatbackend.cpp
+++ b/src/rocketchatbackend.cpp
@@ -1,177 +1,234 @@
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright 2016  Riccardo Iaconelli <riccardo@kde.org>
  *
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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 "rocketchatbackend.h"
 #include <QtCore>
 #include <QJsonObject>
 #include <QDebug>
 #include "userdata.h"
 #include "ddpclient.h"
 
 void debug_callback(QJsonDocument doc)
 {
     qDebug() << "DEBUG:" << doc;
 }
 
 void process_backlog(QJsonDocument messages)
 {
     qDebug() << messages.object().value("messages").toArray().size();
     RocketChatBackend::processIncomingMessages(messages.object().value("messages").toArray());
 }
 
 void rooms_callback(QJsonDocument doc)
 {
 //     qDebug() << doc;
     RoomModel *model = UserData::self()->roomModel();
 //     qDebug() << model;
 //     model->reset();
     
     QJsonArray removed = doc.object().value("remove").toArray();
     QJsonArray updated = doc.object().value("update").toArray();
     
     for (int i = 0; i < updated.size(); i++) {
         QJsonObject room = updated.at(i).toObject();
     
-        if (room.value("t").toString() == "c") {
+        if (room.value("t").toString() != "d") {
+
+            QString roomID = room.value("_id").toString();
+//             qDebug() << "Adding" << roomID<< room.value("name").toString() <<  room;
+            MessageModel *roomModel = UserData::self()->getModelForRoom(roomID);
+            
+            // let's be extra safe around crashes
+            if (UserData::self()->loginStatus() == DDPClient::LoggedIn) {
+                Room r;
+                r.id = roomID;
+                r.name = room["name"].toString();
+                r.topic = room["topic"].toString();
+                
+                
+                qDebug() << "Adding room" << r.name << r.id << r.topic;
+                
+                model->addRoom(r);
+            }
+            
+            QString params = QString("[\"%1\"]").arg(roomID);
+            UserData::self()->ddp()->subscribe("stream-room-messages", QJsonDocument::fromJson(params.toLatin1()));
+        
+            // Load history
+            QByteArray json = "[\""+roomID.toLatin1() +
+                            "\", null, 50, {\"$date\": "+
+                            QString::number(roomModel->lastTimestamp()).toLatin1()+
+                            "}]";
+            qDebug() << json;
+            UserData::self()->ddp()->method("loadHistory", QJsonDocument::fromJson(json), process_backlog);
+            
+        }
+    } 
+    qDebug() << "DEBUG:" << doc;
+}
+
+void subs_callback(QJsonDocument doc)
+{
+//     qDebug() << doc;
+    RoomModel *model = UserData::self()->roomModel();
+//     qDebug() << model;
+//     model->reset();
+    
+    QJsonArray removed = doc.object().value("remove").toArray();
+    QJsonArray updated = doc.object().value("update").toArray();
+    
+    for (int i = 0; i < updated.size(); i++) {
+        QJsonObject room = updated.at(i).toObject();
+    
+        if (room.value("t").toString() != "d") {
 
             QString roomID = room.value("rid").toString();
-            qDebug() << "Adding" << roomID<< room.value("name").toString();
+//             qDebug() << "Adding" << roomID<< room.value("name").toString() <<  room;
             MessageModel *roomModel = UserData::self()->getModelForRoom(roomID);
             
             // let's be extra safe around crashes
             if (UserData::self()->loginStatus() == DDPClient::LoggedIn) {
-                model->addRoom(roomID, room.value("name").toString());
+                Room r;
+                r.id = roomID;
+                r.name = room["name"].toString();
+                r.topic = room["topic"].toString();
+                
+                
+                qDebug() << "Adding room" << r.name << r.id << r.topic;
+                
+                model->addRoom(r);
             }
             
             QString params = QString("[\"%1\"]").arg(roomID);
             UserData::self()->ddp()->subscribe("stream-room-messages", QJsonDocument::fromJson(params.toLatin1()));
         
             // Load history
             QByteArray json = "[\""+roomID.toLatin1() +
                             "\", null, 50, {\"$date\": "+
                             QString::number(roomModel->lastTimestamp()).toLatin1()+
                             "}]";
             qDebug() << json;
             UserData::self()->ddp()->method("loadHistory", QJsonDocument::fromJson(json), process_backlog);
             
         }
     } 
-//     qDebug() << "DEBUG:" << doc;
+    qDebug() << "DEBUG:" << doc;
 }
 
 void RocketChatBackend::processIncomingMessages(QJsonArray messages)
 {
     foreach (const QJsonValue v, messages) {
         QJsonObject o = v.toObject();
         
         Message m;
         QString roomId = o.value("rid").toString();
         QString type = o.value("t").toString();
         m.username = o.value("u").toObject().value("username").toString();
         m.userID = o.value("u").toObject().value("_id").toString();
         m.message = o.value("msg").toString();
         m.messageID = o.value("_id").toString();
         m.roomID = roomId;    
         m.timestamp = (qint64)o.value("ts").toObject().value("$date").toDouble();
         
         if (!type.isEmpty()) {
             m.systemMessage = true;
             m.systemMessageType = type;
         } else {
             m.systemMessage = false;
         }
         
         UserData::self()->getModelForRoom(roomId)->addMessage(m);
         
     }
 }
 
 RocketChatBackend::RocketChatBackend(QObject* parent)
  : QObject(parent)
 {
 //     UserData::self()->ddp() = new DDPClient(, this);
     connect(UserData::self(), &UserData::loginStatusChanged, this, &RocketChatBackend::onLoginStatusChanged);
     
+        connect(UserData::self()->ddp(), &DDPClient::changed, this, &RocketChatBackend::onChanged);
+        connect(UserData::self()->ddp(), &DDPClient::added, this, &RocketChatBackend::onAdded);
 }
 
 RocketChatBackend::~RocketChatBackend()
 {
-//     delete m_rooms;
-//     delete UserData::self()->ddp();
 }
 
 void RocketChatBackend::onLoginStatusChanged()
 {
     if (UserData::self()->loginStatus() == DDPClient::LoggedIn) {
-        connect(UserData::self()->ddp(), &DDPClient::changed, this, &RocketChatBackend::onChanged);
-        connect(UserData::self()->ddp(), &DDPClient::added, this, &RocketChatBackend::onAdded);
         
         qDebug() << "GETTING LIST OF ROOMS";
-        UserData::self()->ddp()->method("subscriptions/get", QJsonDocument::fromJson("{\"$date\": 0}"), rooms_callback);
+//         UserData::self()->ddp()->method("subscriptions/get", QJsonDocument::fromJson("{\"$date\": 0}"), rooms_callback);
+        UserData::self()->ddp()->method("rooms/get", QJsonDocument::fromJson("{\"$date\": 0}"), rooms_callback);
+        
+//         UserData::self()->ddp()->subscribe("stream-room-messages", QJsonDocument::fromJson(params.toLatin1()));
+
     }
 }
 
 void RocketChatBackend::onLoggedIn()
 {
 //     if (UserData::self()->loginStatus() != DDPClient::LoggedIn) {
 //         qDebug() << "not yet logged in:" << UserData::self()->loginStatus();
 //         return;
 //     }
 
 //     // get list of rooms
 //     UserData::self()->ddp()->method("rooms/get", QJsonDocument::fromJson("{\"$date\": 0}"), rooms_callback);
 }
 
 void RocketChatBackend::onAdded(QJsonObject object)
 {
     QString collection = object.value("collection").toString();
     
     qDebug() << "ROCKET BACK" << object << collection;
-    if (collection == "stream-room-messages") {
     
+    if (collection == "stream-room-messages") {
         
     } else if (collection == "users") {
         qDebug() << "NEW USER";
         
     } else if (collection == "rooms") {
     }
 }
-// {"_id":"RhiggypZiepy9M4qL","_updatedAt":{"$date":1482704143952},"alert":false,"ls":{"$date":1482704143952},"name":"tech","open":true,"rid":"tKHaLfB35vo4qAnBp","t":"c","ts":{"$date":1479497659929},"u":{"_id":"po2bcKwPMdtnDCXhX","username":"ruphy"},"unread":0}
 
 void RocketChatBackend::onChanged(QJsonObject object)
 {
-    QString collection = object.value("collection").toString();
+    QString collection = object["collection"].toString();
     
     qDebug() << "ROCKET BACK" << object << collection;
     if (collection == "stream-room-messages") {
         QJsonObject fields = object.value("fields").toObject();
         QString roomId = fields.value("eventName").toString();
         QJsonArray contents = fields.value("args").toArray();
         RocketChatBackend::processIncomingMessages(contents);
         
     } else if (collection == "users") {
         qDebug() << "NEW USER";
         
     } else if (collection == "rooms") {
     }
 }
 
diff --git a/src/roommodel.cpp b/src/roommodel.cpp
index ca0c2ffe..c786e955 100644
--- a/src/roommodel.cpp
+++ b/src/roommodel.cpp
@@ -1,238 +1,238 @@
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright 2016  Riccardo Iaconelli <riccardo@kde.org>
  *
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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 "roommodel.h"
 
 #include <QtCore/QAbstractItemModel>
 #include <QtCore>
 
 #include "userdata.h"
 
 Room RoomModel::fromJSon(const QJsonObject& o)
 {
     Room r;
     
     r.name = o["name"].toString();
     r.id = o["id"].toString();
     r.unread = o["unread"].toInt(0);
     
     return r;
 }
 
 QByteArray RoomModel::serialize(const Room& r)
 {
     QJsonDocument d;
     QJsonObject o;
     o["name"] = r.name;
     o["id"] = r.id;
     o["unread"] = r.unread;
     d.setObject(o);
     return d.toBinaryData();
 }
 
 RoomWrapper::RoomWrapper(QObject *parent)
  : QObject(parent)
 {}
 
 RoomWrapper::RoomWrapper(const Room &r, QObject *parent)
  : QObject(parent)
 {
     m_name = r.name;
     m_topic = r.topic;
     m_unread = r.unread;
     m_id = r.id;
     m_selected = r.selected;
 }
 
 RoomModel::RoomModel(QObject* parent)
     : QAbstractListModel(parent)
 {
 //     connect(UserData::self(), &UserData::loginStatusChanged, this, &RoomModel::onLoginStatusChanged);
 }
 
 RoomModel::~RoomModel()
 {
     QDir cacheDir(UserData::self()->cacheBasePath());
     if (!cacheDir.exists(cacheDir.path())) {
         cacheDir.mkpath(cacheDir.path());
     }
     
     QFile f(cacheDir.absoluteFilePath("rooms"));
 
     if (f.open(QIODevice::WriteOnly)) {
         QDataStream out(&f);
         foreach (const Room m, m_roomsList) {            
             QByteArray ms = RoomModel::serialize(m);
             out.writeBytes(ms, ms.size());
         }
     }
 }
 
 void RoomModel::clear()
 {
     if (m_roomsList.size()) {
         beginRemoveRows(QModelIndex(), 0, rowCount()-1);
         m_roomsList.clear();
         QAbstractItemModel::endRemoveRows();
     }
 }
 
 RoomWrapper* RoomModel::findRoom(const QString& roomID) const
 {
     foreach (const Room r, m_roomsList) {
         if (r.id == roomID) {
             return new RoomWrapper(r);
         }
     }
     Room r;
 //     RoomWrapper w;
     return new RoomWrapper(r);
 }
 
 // Clear data and refill it it with data in the cache, if there is
 void RoomModel::reset()
 {
     if (UserData::self()->cacheBasePath().isEmpty()) {
         return;
     }
     
     clear();
     
     QDir cacheDir(UserData::self()->cacheBasePath());
     // load cache
     if (cacheDir.exists(cacheDir.path())) {
         QFile f(cacheDir.absoluteFilePath("rooms"));
         if (f.open(QIODevice::ReadOnly)) {
             QDataStream in(&f);
             while (!f.atEnd()) {
                 char * byteArray; quint32 length;
                 in.readBytes(byteArray, length);
                 QByteArray arr = QByteArray::fromRawData(byteArray, length);
                 Room m = RoomModel::fromJSon(QJsonDocument::fromBinaryData(arr).object());
                 addRoom(m.id, m.name, m.selected);
             }
         }
     }
     qDebug() << "Cache Loaded";
 }
 
 QHash<int, QByteArray> RoomModel::roleNames() const
 {
     QHash<int, QByteArray> roles;
     roles[RoomName] = "name";
     roles[RoomID] = "room_id";
     roles[RoomSelected] = "selected";
     roles[RoomUnread] = "unread";
     return roles;
 }
 
 int RoomModel::rowCount(const QModelIndex & parent) const
 {
 //     if (m_roomsHash.size() > 4) {return 4;}
 //     qDebug() << m_roomsList.size() << "ROOMS";
     return m_roomsList.size();
 }
 
 QVariant RoomModel::data(const QModelIndex & index, int role) const
 {
 //     qDebug() << "GOT ASKED FOR " << index.row();
     Room r = m_roomsList.at(index.row());
     
      if (role == RoomModel::RoomName) {
         return  r.name;
     } else if (role == RoomModel::RoomID) {
         return r.id;
     } else if (role == RoomModel::RoomSelected) {
         return r.selected;
     } else {
         return QVariant("0");
     }
 }
 
 // void RoomModel::setActiveRoom(const QString& activeRoom)
 // {
 //     foreach (const QString &id, m_roomsHash.keys()) {
 //         qDebug() << id;
 //         m_roomsHash[id].selected = (id == activeRoom);
 //     }
 // //     emit dataChanged(createIndex(1, 1), createIndex(rowCount(), 1));
 // }
 
 void RoomModel::addRoom(const QString& roomID, const QString& roomName, bool selected)
 {
     if (roomID.isEmpty() || roomName.isEmpty()) {
         return;
     }
     qDebug() << "Adding room" << roomID << roomName;
     
     
     Room r;
     r.id = roomID;
     r.name = roomName;
     r.selected = selected;
     addRoom(r);
 }
 
 void RoomModel::addRoom(const Room &room)
 {
     auto existingRoom = qFind(m_roomsList.begin(), m_roomsList.end(), room);
     bool present = (existingRoom != m_roomsList.end());
     
 //     qDebug() << "Present? "<< present;
     
     auto i = qUpperBound(m_roomsList.begin(), m_roomsList.end(),
                                                room);
     int pos = i-m_roomsList.begin();
     bool roomChanged = false;
     qDebug() << pos;
      
 //     if (qFind(m_roomsList.begin(), m_roomsList.end(), room) != m_roomsList.end() && pos > 0) {
     if (present) {
 //         qDebug() << (qFind(m_roomsList.begin(), m_roomsList.end(), room) - m_roomsList.begin());
 //     if (pos != m_roomsList.size()) { // we're at the end
-//         qDebug() << "Room changed!";
+        qDebug() << "Room changed!";
         roomChanged = true;
         //Figure out a better way to update just the really changed message
     } else {
         beginInsertRows(QModelIndex(), pos, pos);
     }
     
     if (roomChanged) {
         m_roomsList.replace(pos-1, room);
     } else {
         qDebug() << "Inserting room at position" <<pos;
         m_roomsList.insert(i, room);
     }
     
     if (roomChanged) {
         emit dataChanged(createIndex(1, 1), createIndex(pos, 1));
         
     } else {
         endInsertRows();
     }
     
     
     UserData::self()->getModelForRoom(room.id);
 }
 
 
 // #include "roommodel.moc"
diff --git a/src/roommodel.h b/src/roommodel.h
index 102f38e3..6c2930e6 100644
--- a/src/roommodel.h
+++ b/src/roommodel.h
@@ -1,126 +1,134 @@
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright 2016  Riccardo Iaconelli <riccardo@kde.org>
  *
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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/>.
  *
  */
 
 #ifndef ROOMMODEL_H
 #define ROOMMODEL_H
 
 #include <QAbstractListModel>
 #include <QObject>
 
 
 class Room {
 public:   
 //     Room(const Room &room)
 //     {
 // //         this->parent = room.parent();
 //     }
     
     // To be used in ID find: message ID
     inline bool operator==(const Room &other) const
     {
         return other.id == id;
     };
     // To be used in sorted insert: timestamp
     inline bool operator<(const Room &other) const
     {
         return name < other.name;
     };
     
     QString getName() const {return name;};
     QString getTopic() const {return topic;};
     
-private:
-    friend class RoomModel;
-    friend class RoomWrapper;
+// private:
+//     friend class RoomModel;
+//     friend class RoomWrapper;
+    
+    
 //  When you add a field, please remember to also add relevant code
 //  to the enum declaration, roleNames, fromJSon and serialize
     QString name;
     QString topic;
     int unread;
     
     bool selected = false;
     QString id;
 };
 
 class RoomWrapper : public QObject
 {
-    Q_PROPERTY(QString name READ getName)
-    Q_PROPERTY(QString topic READ getTopic)
+    Q_PROPERTY(QString name READ getName NOTIFY nameChanged)
+    Q_PROPERTY(QString topic READ getTopic NOTIFY topicChanged)
     Q_OBJECT
     
 public:
     RoomWrapper(QObject *parent = 0);
     RoomWrapper(const Room &r, QObject *parent = 0);
      
     QString getName() {return m_name;};
     QString getTopic() {return m_topic;};
+    
+    
+signals:
+    void nameChanged();
+    void topicChanged();
+    
 private:
     QString m_name, m_topic, m_id;
     int m_unread;
     bool m_selected;
 };
     
 
 class RoomModel : public QAbstractListModel
 {
     Q_OBJECT
 public:
 
     enum RoomRoles {
         RoomName = Qt::UserRole + 1,
         RoomSelected,
         RoomID,
         RoomUnread
     };
     
     RoomModel (QObject *parent = 0);
     virtual ~RoomModel();
     
     virtual int rowCount(const QModelIndex & parent = QModelIndex()) const;
     virtual QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
 
 //     void setCurrentRoom(const QString &newRoom);
 //     QString getCurrentRoom() const;
     
     Q_INVOKABLE void addRoom(const QString& roomID, const QString& roomName, bool selected = false);
     
     void addRoom(const Room& room);
     RoomWrapper* findRoom(const QString &roomID) const;
     
     
     static Room fromJSon(const QJsonObject &source);
     static QByteArray serialize(const Room &r);
     
 //     void setActiveRoom(const QString &activeRoom);
     
     void reset();
     void clear();
 protected:
     virtual QHash<int, QByteArray> roleNames() const;
     
 private:
     
     QVector<Room> m_roomsList;
 //     QHash< QString, Room > m_roomsHash;
 };
 
 #endif // ROOMMODEL_H
diff --git a/src/userdata.cpp b/src/userdata.cpp
index a7bdd822..f634c39d 100644
--- a/src/userdata.cpp
+++ b/src/userdata.cpp
@@ -1,217 +1,215 @@
 /*
  * <one line to give the program's name and a brief idea of what it does.>
  * Copyright 2016  Riccardo Iaconelli <riccardo@kde.org>
  *
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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 "userdata.h"
 #include "roommodel.h"
 #include "ddpclient.h"
 
 UserData *UserData::m_self = 0;
 
 QString UserData::authToken() const
 {
     return m_authToken;
 }
 
 QString UserData::userName() const
 {
     return m_userName;
 }
 
 QString UserData::password() const
 {
     return m_password;
 }
 
 void UserData::setAuthToken(const QString& token)
 {
     qDebug() << "Setting token to" << token;
     QSettings s;
     m_authToken = token;
     s.setValue("authToken", token);
 }
 
 void UserData::setPassword(const QString& password)
 {
     m_password = password;
 }
 
 void UserData::setUserName(const QString& username)
 {
     m_userName = username;
     QSettings s;
     s.setValue("username", username);
     emit userNameChanged();
 }
 
 RoomModel * UserData::roomModel()
 {
     if (!m_roomModel) {
         qDebug() << "creating new RoomModel";
         m_roomModel = new RoomModel(this);
         qDebug() << m_roomModel;
 //         m_roomModel->reset();
     }
     return m_roomModel;
 }
 
 DDPClient * UserData::ddp()
 {
     if (!m_ddp) {
         m_ddp = new DDPClient(serverURL());
         connect(m_ddp, &DDPClient::loginStatusChanged, this, &UserData::loginStatusChanged);
 //         connect(m_ddp, &DDPClient::loginStatusChanged, this, [=](){qDebug() << "Signal received";});
     }
     return m_ddp;
 }
 
 void UserData::sendMessage(const QString &roomID, const QString &message)
 {
     QString json = "{\"rid\": \"%1\", \"msg\": \"%2\"}";
     json = json.arg(roomID, message);
     ddp()->method("sendMessage", QJsonDocument::fromJson(json.toUtf8()));
 }
 
 MessageModel * UserData::getModelForRoom(const QString& roomID)
 {
     if (m_messageModels.contains(roomID)) {
 //         qDebug() << "Returning old model for " << roomID;
         return m_messageModels.value(roomID);
     } else {
 //         qDebug() << "Creating a new model";
         m_messageModels[roomID] = new MessageModel(roomID, this);
         
         return m_messageModels[roomID];        
     }
 }
 
 QString UserData::serverURL() const
 {
     return m_serverURL;
 }
 
 void UserData::setServerURL(const QString& serverURL)
 {
     if (m_serverURL == serverURL) {
         return;
     }
     
     QSettings s;
     s.setValue("serverURL", serverURL);
     m_serverURL = serverURL;
 //     m_roomModel->reset();
     emit serverURLChanged();
 }
 
 DDPClient::LoginStatus UserData::loginStatus()
 {
     if (m_ddp) {
         return ddp()->loginStatus();
     } else {
         return DDPClient::LoggedOut;
     }
 }
 
 void UserData::tryLogin()
 {
     qDebug() << "Attempting login" << userName() << "on" << serverURL();
 
     // Reset model views
     foreach (const QString key, m_messageModels.keys()) {
         MessageModel *m = m_messageModels.take(key);
         delete m;
     }
     delete m_ddp;
     m_ddp = 0;
     
     // In the meantime, load cache...
     m_roomModel->reset();
     
     // This creates a new ddp() object.
     // DDP will automatically try to connect and login.
     ddp();
 }
 
 void UserData::logOut()
 {
     setAuthToken(QString());
     setPassword(QString());
 //     m_ddp->logOut();
     foreach (const QString key, m_messageModels.keys()) {
         MessageModel *m = m_messageModels.take(key);
         delete m;
     }
     delete m_ddp;
     m_ddp = 0;
     emit loginStatusChanged();
     
     m_roomModel->clear();
-//     m_roomModel->reset();
-    // RoomModel -> reset();
 }
 
 QString UserData::cacheBasePath() const
 {
     if (m_serverURL.isEmpty()) {
         return QString();
     }
     return QStandardPaths::writableLocation(QStandardPaths::CacheLocation)+'/'+m_serverURL;
 }
 
 // QString UserData::activeRoom() const
 // {
 //     return m_activeRoom;
 // }
 // void UserData::setActiveRoom(const QString& activeRoom)
 // {
 //     m_activeRoom = activeRoom;
 // //     roomModel()->setActiveRoom(activeRoom);
 //     emit activeRoomChanged();
 // }
 RoomWrapper * UserData::getRoom(const QString& roomID)
 {
     return roomModel()->findRoom(roomID);
 }
 
 
 UserData::UserData(QObject* parent)
  : QObject(parent),
  m_ddp(0),
  m_roomModel(0)
 {
     QSettings s;
     m_serverURL = s.value("serverURL", "demo.rocket.chat").toString();
     m_userName = s.value("username").toString();
     m_authToken = s.value("authToken").toString();
 //     roomModel()->reset();
 }
 
 UserData * UserData::self() 
 {
     if (!m_self) {
         m_self = new UserData;
         m_self->ddp(); // Create DDP object so we try to connect at startup
         m_self->roomModel()->reset();
 //         m_self->getModelForRoom("GENERAL");
     }
     return m_self;
 }