diff --git a/microblogs/pumpio/pumpiomicroblog.cpp b/microblogs/pumpio/pumpiomicroblog.cpp
index ab755e18..53ba5b75 100644
--- a/microblogs/pumpio/pumpiomicroblog.cpp
+++ b/microblogs/pumpio/pumpiomicroblog.cpp
@@ -1,905 +1,973 @@
 /*
     This file is part of Choqok, the KDE micro-blogging client
 
     Copyright (C) 2013  Andrea Scarpino <scarpino@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 "pumpiomicroblog.h"
 
 #include <QTextDocument>
 
 #include <qjson/parser.h>
 #include <qjson/serializer.h>
 
 #include <KGenericFactory>
 #include <KIO/Job>
 #include <KIO/StoredTransferJob>
 
 #include "accountmanager.h"
 #include "application.h"
 #include "choqokbehaviorsettings.h"
 #include "notifymanager.h"
 
 #include "pumpioaccount.h"
 #include "pumpioeditaccountwidget.h"
 #include "pumpiopost.h"
 #include "pumpiopostwidget.h"
 
 class PumpIOMicroBlog::Private
 {
 public:
     Private():countOfTimelinesToSave(0)
     {}
     int countOfTimelinesToSave;
 };
 
 K_PLUGIN_FACTORY( MyPluginFactory, registerPlugin < PumpIOMicroBlog > (); )
 K_EXPORT_PLUGIN( MyPluginFactory( "choqok_pumpio" ) )
 
 const QString PumpIOMicroBlog::inboxActivity("/api/user/%1/inbox");
 const QString PumpIOMicroBlog::outboxActivity("/api/user/%1/feed");
 
 PumpIOMicroBlog::PumpIOMicroBlog(QObject* parent, const QVariantList& args):
     MicroBlog(MyPluginFactory::componentData(), parent), d(new Private)
 {
     Q_UNUSED(args)
     setServiceName("Pump.io");
     setServiceHomepageUrl("http://pump.io");
     QStringList timelineNames;
     timelineNames << "Activity" << "Favorites" << "Inbox" << "Outbox";
     setTimelineNames(timelineNames);
     setTimelinesInfo();
 }
 
 PumpIOMicroBlog::~PumpIOMicroBlog()
 {
 }
 
 void PumpIOMicroBlog::abortAllJobs(Choqok::Account* theAccount)
 {
     Q_FOREACH (KJob *job, m_accountJobs.keys(theAccount)) {
         job->kill(KJob::EmitResult);
     }
 }
 
 void PumpIOMicroBlog::abortCreatePost(Choqok::Account* theAccount, Choqok::Post* post)
 {
     if (m_createPostJobs.isEmpty()) {
         return;
     }
     if (post) {
         m_createPostJobs.key(post)->kill(KJob::EmitResult);
         return;
     }
 
     Q_FOREACH (KJob *job, m_createPostJobs.keys()){
         if( m_accountJobs[job] == theAccount) {
             job->kill(KJob::EmitResult);
         }
     }
 }
 
 void PumpIOMicroBlog::aboutToUnload()
 {
     Q_FOREACH (Choqok::Account* acc, Choqok::AccountManager::self()->accounts()) {
         if (acc->microblog() == this){
             d->countOfTimelinesToSave += acc->timelineNames().count();
         }
     }
     emit saveTimelines();
 }
 
 ChoqokEditAccountWidget* PumpIOMicroBlog::createEditAccountWidget(Choqok::Account* account,
                                                                   QWidget* parent)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount* >(account);
     if (acc || !account) {
         return new PumpIOEditAccountWidget(this, acc, parent);
     } else {
         kDebug() << "Account passed here was not a valid PumpIOAccount!";
         return 0;
     }
 }
 
 Choqok::Account* PumpIOMicroBlog::createNewAccount(const QString& alias)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(
         Choqok::AccountManager::self()->findAccount(alias) );
     if (!acc) {
         return new PumpIOAccount(this, alias);
     } else {
         kDebug() << "Cannot create a new PumpIOAccount!";
         return 0;
     }
 }
 
 void PumpIOMicroBlog::createPost(Choqok::Account* theAccount, Choqok::Post* post)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
     if (acc) {
         QVariantMap object;
         object.insert("objectType", "note");
         object.insert("content", QUrl::toPercentEncoding(post->content));
 
         QVariantList to;
         QVariantMap thePublic;
         thePublic.insert("objectType", "collection");
         thePublic.insert("id", "http://activityschema.org/collection/public");
         to.prepend(thePublic);
 
         QVariantMap item;
         item.insert("verb", "post");
         item.insert("object", object);
         item.insert("to", to);
 
         QJson::Serializer serializer;
         const QByteArray data = serializer.serialize(item);
 
         KUrl url(acc->host());
         url.addPath(outboxActivity.arg(acc->username()));
         KIO::StoredTransferJob *job = KIO::storedHttpPost(data, url, KIO::HideProgressInfo);
         job->addMetaData("content-type", "Content-Type: application/json");
         job->addMetaData("customHTTPHeader", authorizationMetaData(acc, url, QOAuth::POST));
         if (!job) {
             kDebug() << "Cannot create an http POST request!";
             return;
         }
         m_accountJobs[job] = acc;
         m_createPostJobs[job] = post;
         connect(job, SIGNAL(result(KJob*)), this, SLOT(slotCreatePost(KJob*)));
         job->start();
     } else {
         kDebug() << "theAccount is not a PumpIOAccount!";
     }
 }
 
 Choqok::UI::PostWidget* PumpIOMicroBlog::createPostWidget(Choqok::Account* account,
                                                           Choqok::Post* post,
                                                           QWidget* parent)
 {
     return new PumpIOPostWidget(account, post, parent);
 }
 
 void PumpIOMicroBlog::fetchPost(Choqok::Account* theAccount, Choqok::Post* post)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
     if (acc) {
+        if (!post->postId.startsWith(acc->host())) {
+            kDebug() << "You can only fetch posts from your host!";
+            return;
+        }
         KUrl url(post->postId);
 
         KIO::StoredTransferJob *job = KIO::storedGet(url, KIO::Reload, KIO::HideProgressInfo);
         if (!job) {
             kDebug() << "Cannot create an http GET request!";
             return;
         }
         job->addMetaData("customHTTPHeader", authorizationMetaData(acc, url, QOAuth::GET));
         m_accountJobs[job] = acc;
-        m_fetchPostJobs[job] = post->postId;
         connect(job, SIGNAL(result(KJob*)), this, SLOT(slotFetchPost(KJob*)));
         job->start();
     } else {
         kDebug() << "theAccount is not a PumpIOAccount!";
     }
 }
 
 void PumpIOMicroBlog::removePost(Choqok::Account* theAccount, Choqok::Post* post)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
     if (acc) {
         QVariantMap object;
         object.insert("id", post->postId.toString());
         object.insert("objectType", post->type);
 
         QVariantMap item;
         item.insert("verb", "delete");
         item.insert("object", object);
 
         QJson::Serializer serializer;
         const QByteArray data = serializer.serialize(item);
 
         KUrl url(acc->host());
         url.addPath(outboxActivity.arg(acc->username()));
         KIO::StoredTransferJob *job = KIO::storedHttpPost(data, url, KIO::HideProgressInfo);
         job->addMetaData("content-type", "Content-Type: application/json");
         job->addMetaData("customHTTPHeader", authorizationMetaData(acc, url, QOAuth::POST));
         if (!job) {
             kDebug() << "Cannot create an http POST request!";
             return;
         }
         m_accountJobs[job] = acc;
         m_removePostJobs[job] = post;
         connect(job, SIGNAL(result(KJob*)), this, SLOT(slotRemovePost(KJob*)));
         job->start();
     } else {
         kDebug() << "theAccount is not a PumpIOAccount!";
     }
 }
 
 QList< Choqok::Post* > PumpIOMicroBlog::loadTimeline(Choqok::Account* account,
                                                      const QString& timelineName)
 {
     QList< Choqok::Post* > list;
     const QString fileName = Choqok::AccountManager::generatePostBackupFileName(account->alias(),
                                                                                 timelineName);
     const KConfig postsBackup( "choqok/" + fileName, KConfig::NoGlobals, "data" );
     const QStringList tmpList = postsBackup.groupList();
 
     // don't load old archives
     if (tmpList.isEmpty() || !(QDateTime::fromString(tmpList.first()).isValid())) {
         return list;
     }
 
     QList<QDateTime> groupList;
     Q_FOREACH (const QString& str, tmpList) {
         groupList.append(QDateTime::fromString(str));
     }
     qSort(groupList);
     PumpIOPost *st;
     Q_FOREACH (const QDateTime& datetime, groupList) {
         st = new PumpIOPost;
         KConfigGroup grp(&postsBackup, datetime.toString());
         st->creationDateTime = grp.readEntry("creationDateTime", QDateTime::currentDateTime());
         st->postId = grp.readEntry("postId", QString());
         st->link = grp.readEntry("link", QString());
         st->content = grp.readEntry("content", QString());
         st->source = grp.readEntry("source", QString());
         st->isFavorited = grp.readEntry("favorited", false);
         st->author.userId = grp.readEntry("authorId", QString());
         st->author.userName = grp.readEntry("authorUserName", QString());
         st->author.realName = grp.readEntry("authorRealName", QString());
         st->author.location = grp.readEntry("authorLocation", QString());
         st->author.description = grp.readEntry("authorDescription" , QString());
         st->author.profileImageUrl = grp.readEntry("authorProfileImageUrl", QString());
         st->author.homePageUrl = grp.readEntry("authorHomePageUrl", QString());
         st->type = grp.readEntry("type", QString());
         st->isRead = grp.readEntry("isRead", true);
         st->conversationId = grp.readEntry("conversationId", QString());
         st->to = grp.readEntry("to", QStringList());
         st->cc = grp.readEntry("cc", QStringList());
         st->shares = grp.readEntry("shares", QStringList());
-        st->replies = grp.readEntry("replies", QStringList());
+        st->replies = grp.readEntry("replies", QString());
         list.append(st);
     }
 
     if (!list.isEmpty()) {
         setLastTimelineId(account, timelineName, list.last()->conversationId);
     }
 
     return list;
 }
 
 QString PumpIOMicroBlog::postUrl(Choqok::Account* account, const QString& username,
                                  const QString& postId) const
 {
     Q_UNUSED(account);
     return QString(postId).replace("/api/", '/' + username + '/');
 }
 
 QString PumpIOMicroBlog::profileUrl(Choqok::Account* account, const QString& username) const
 {
     Q_UNUSED(account)
     if (username.contains("acct:")) {
         return QString("https://%1/%2").arg(hostFromAcct(username)).arg(userNameFromAcct(username));
     } else {
         return username;
     }
 }
 
 void PumpIOMicroBlog::saveTimeline(Choqok::Account* account, const QString& timelineName,
                                    const QList< Choqok::UI::PostWidget* >& timeline)
 {
     const QString fileName = Choqok::AccountManager::generatePostBackupFileName(account->alias(),
                                                                                 timelineName);
     KConfig postsBackup("choqok/" + fileName, KConfig::NoGlobals, "data");
 
     ///Clear previous data:
     Q_FOREACH (const QString& group, postsBackup.groupList()) {
         postsBackup.deleteGroup(group);
     }
 
     QList< Choqok::UI::PostWidget *>::const_iterator it, endIt = timeline.constEnd();
     for (it = timeline.constBegin(); it != endIt; ++it) {
         PumpIOPost *post = dynamic_cast<PumpIOPost* >((*it)->currentPost());
         KConfigGroup grp(&postsBackup, post->creationDateTime.toString());
         grp.writeEntry("creationDateTime", post->creationDateTime);
         grp.writeEntry("postId", post->postId.toString());
         grp.writeEntry("link", post->link);
         grp.writeEntry("content", post->content);
         grp.writeEntry("source", post->source);
         grp.writeEntry("favorited", post->isFavorited);
         grp.writeEntry("authorId", post->author.userId.toString());
         grp.writeEntry("authorRealName", post->author.realName);
         grp.writeEntry("authorUserName", post->author.userName);
         grp.writeEntry("authorLocation" , post->author.location);
         grp.writeEntry("authorDescription" , post->author.description);
         grp.writeEntry("authorProfileImageUrl", post->author.profileImageUrl);
         grp.writeEntry("authorHomePageUrl" , post->author.homePageUrl);
         grp.writeEntry("type" , post->type);
         grp.writeEntry("isRead", post->isRead);
         grp.writeEntry("conversationId", post->conversationId.toString());
         grp.writeEntry("to", post->to);
         grp.writeEntry("cc", post->cc);
         grp.writeEntry("shares", post->shares);
         grp.writeEntry("replies", post->replies);
     }
     postsBackup.sync();
 
     if (Choqok::Application::isShuttingDown()) {
         --d->countOfTimelinesToSave;
         if (d->countOfTimelinesToSave < 1) {
             emit readyForUnload();
         }
     }
 }
 
 Choqok::TimelineInfo* PumpIOMicroBlog::timelineInfo(const QString& timelineName)
 {
     return m_timelinesInfos.value(timelineName);
 }
 
 void PumpIOMicroBlog::updateTimelines(Choqok::Account* theAccount)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
     if (acc) {
         Q_FOREACH (const QString& timeline, acc->timelineNames()) {
             KUrl url(acc->host());
             url.addPath(m_timelinesPaths[timeline].arg(acc->username()));
 
             QOAuth::ParamMap oAuthParams;
             const ChoqokId lastActivityId(lastTimelineId(theAccount, timeline));
             if (!lastActivityId.isEmpty()) {
                 oAuthParams.insert("count", QByteArray::number(200));
                 oAuthParams.insert("since", KUrl::toPercentEncoding(lastActivityId.toString()));
             } else {
                 oAuthParams.insert("count", QByteArray::number(Choqok::BehaviorSettings::countOfPosts()));
             }
 
             KIO::StoredTransferJob *job = KIO::storedGet(url, KIO::Reload, KIO::HideProgressInfo);
             if (!job) {
                 kDebug() << "Cannot create an http GET request!";
                 continue;
             }
             job->addMetaData("customHTTPHeader", authorizationMetaData(acc, url, QOAuth::GET,
                                                                        oAuthParams));
             m_timelinesRequests[job] = timeline;
             m_accountJobs[job] = acc;
             connect(job, SIGNAL(result(KJob*)), this, SLOT(slotUpdateTimeline(KJob*)));
             job->start();
         }
     } else {
         kDebug() << "theAccount is not a PumpIOAccount!";
     }
 }
 
 void PumpIOMicroBlog::fetchFollowing(Choqok::Account* theAccount)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
     if (acc) {
         KUrl url(acc->host());
         url.addPath(QString("/api/user/%1/following").arg(acc->username()));
 
         QOAuth::ParamMap oAuthParams;
         oAuthParams.insert("count", QByteArray::number(200));
         if (!acc->following().isEmpty()) {
             oAuthParams.insert("since", KUrl::toPercentEncoding(acc->following().last()));
         }
 
         KIO::StoredTransferJob *job = KIO::storedGet(url, KIO::Reload, KIO::HideProgressInfo);
         if (!job) {
             kDebug() << "Cannot create an http GET request!";
             return;
         }
         job->addMetaData("customHTTPHeader", authorizationMetaData(acc, url, QOAuth::GET,
                                                                    oAuthParams));
         m_accountJobs[job] = acc;
         connect(job, SIGNAL(result(KJob*)), this, SLOT(slotFollowing(KJob*)));
         job->start();
     } else {
         kDebug() << "theAccount is not a PumpIOAccount!";
     }
 }
 
 void PumpIOMicroBlog::share(Choqok::Account* theAccount, Choqok::Post* post)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
     if (acc) {
         QVariantMap object;
         object.insert("objectType", post->type);
         object.insert("id", post->postId.toString());
 
         QVariantMap item;
         item.insert("verb", "share");
         item.insert("object", object);
 
         QJson::Serializer serializer;
         const QByteArray data = serializer.serialize(item);
 
         KUrl url(acc->host());
         url.addPath(outboxActivity.arg(acc->username()));
         KIO::StoredTransferJob *job = KIO::storedHttpPost(data, url, KIO::HideProgressInfo);
         job->addMetaData("content-type", "Content-Type: application/json");
         job->addMetaData("customHTTPHeader", authorizationMetaData(acc, url, QOAuth::POST));
         if (!job) {
             kDebug() << "Cannot create an http POST request!";
             return;
         }
         m_accountJobs[job] = acc;
         m_shareJobs[job] = post;
         connect(job, SIGNAL(result(KJob*)), this, SLOT(slotShare(KJob*)));
         job->start();
     } else {
         kDebug() << "theAccount is not a PumpIOAccount!";
     }
 }
 
 void PumpIOMicroBlog::toggleFavorite(Choqok::Account* theAccount, Choqok::Post* post)
 {
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
     if (acc) {
         QVariantMap object;
         object.insert("objectType", post->type);
         object.insert("id", post->postId.toString());
 
         QVariantMap item;
         item.insert("verb", post->isFavorited ? "unfavorite" : "favorite");
         item.insert("object", object);
 
         QJson::Serializer serializer;
         const QByteArray data = serializer.serialize(item);
 
         KUrl url(acc->host());
         url.addPath(outboxActivity.arg(acc->username()));
         KIO::StoredTransferJob *job = KIO::storedHttpPost(data, url, KIO::HideProgressInfo);
         job->addMetaData("content-type", "Content-Type: application/json");
         job->addMetaData("customHTTPHeader", authorizationMetaData(acc, url, QOAuth::POST));
         if (!job) {
             kDebug() << "Cannot create an http POST request!";
             return;
         }
         m_accountJobs[job] = acc;
         m_favoriteJobs[job] = post;
         connect(job, SIGNAL(result(KJob*)), this, SLOT(slotFavorite(KJob*)));
         job->start();
     } else {
         kDebug() << "theAccount is not a PumpIOAccount!";
     }
 }
 
 void PumpIOMicroBlog::slotCreatePost(KJob* job)
 {
     if (!job) {
         kDebug() << "Job is null pointer";
         return;
     }
     Choqok::Post *post = m_createPostJobs.take(job);
     Choqok::Account *theAccount = m_accountJobs.take(job);
     if (!post || !theAccount) {
         kDebug() << "Account or Post is NULL pointer";
         return;
     }
     int ret = 1;
     if (job->error()) {
         kDebug() << "Job Error: " << job->errorString();
     } else {
         KIO::StoredTransferJob* j = qobject_cast<KIO::StoredTransferJob* >(job);
         bool ok;
         QJson::Parser parser;
         const QVariantMap reply = parser.parse(j->data(), &ok).toMap();
         if (ok) {
             if (!reply["object"].toMap().value("id").toString().isEmpty()) {
                 Choqok::NotifyManager::success(i18n("New post submitted successfully"));
                 ret = 0;
                 emit postCreated(theAccount, post);
             }
         } else {
             kDebug() << "Cannot parse JSON reply";
         }
     }
 
     if (ret) {
         emit errorPost(theAccount, post, Choqok::MicroBlog::CommunicationError,
                        i18n("Creating the new post failed. %1", job->errorString()),
                        MicroBlog::Critical);
     }
 }
 
 void PumpIOMicroBlog::slotFavorite(KJob* job)
 {
     if (!job) {
         kDebug() << "Job is null pointer";
         return;
     }
     Choqok::Post *post = m_favoriteJobs.take(job);
     Choqok::Account *theAccount = m_accountJobs.take(job);
     if (!post || !theAccount) {
         kDebug() << "Account or Post is NULL pointer";
         return;
     }
     if (job->error()) {
         kDebug() << "Job Error: " << job->errorString();
         emit error(theAccount, Choqok::MicroBlog::CommunicationError,
                    i18n("Cannot set the post as (un)favorite. %1", job->errorString()));
     } else {
         post->isFavorited = !post->isFavorited;
         emit favorite(theAccount, post);
     }
 }
 
 void PumpIOMicroBlog::slotFetchPost(KJob* job)
 {
     if (!job) {
         kDebug() << "Job is null pointer";
         return;
     }
-    ChoqokId postId = m_fetchPostJobs.take(job);
     Choqok::Account *theAccount = m_accountJobs.take(job);
-    if (postId.isNull() || !theAccount) {
+    if (!theAccount) {
         kDebug() << "Account or postId is NULL pointer";
         return;
     }
     int ret = 1;
     if (job->error()) {
         kDebug() << "Job Error: " << job->errorString();
     } else {
         KIO::StoredTransferJob* j = qobject_cast<KIO::StoredTransferJob* >(job);
         bool ok;
         QJson::Parser parser;
         const QVariantMap reply = parser.parse(j->data(), &ok).toMap();
         if (ok) {
             PumpIOPost* post = new PumpIOPost;
             readPost(reply, post);
             ret = 0;
             emit postFetched(theAccount, post);
         } else {
             kDebug() << "Cannot parse JSON reply";
         }
     }
 
     if (ret) {
         emit error(theAccount, Choqok::MicroBlog::CommunicationError,
                    i18n("Cannot fetch post. %1", job->errorString()),
                    MicroBlog::Critical);
     }
 }
 
+void PumpIOMicroBlog::slotFetchReplies(KJob* job)
+{
+    if (!job) {
+        kDebug() << "Job is null pointer";
+        return;
+    }
+    Choqok::Account *theAccount = m_accountJobs.take(job);
+    if (!theAccount) {
+        kDebug() << "Account or postId is NULL pointer";
+        return;
+    }
+    int ret = 1;
+    if (job->error()) {
+        kDebug() << "Job Error: " << job->errorString();
+    } else {
+        KIO::StoredTransferJob* j = qobject_cast<KIO::StoredTransferJob* >(job);
+        bool ok;
+        QJson::Parser parser;
+        const QVariantMap reply = parser.parse(j->data(), &ok).toMap();
+        if (ok) {
+            const QVariantList items = reply["items"].toList();
+            Q_FOREACH (const QVariant& item, items) {
+                PumpIOPost* reply = new PumpIOPost;
+                readPost(item.toMap(), reply);
+                emit postFetched(theAccount, reply);
+            }
+            ret = 0;
+        } else {
+            kDebug() << "Cannot parse JSON reply";
+        }
+    }
+
+    if (ret) {
+        emit error(theAccount, Choqok::MicroBlog::CommunicationError,
+                   i18n("Cannot fetch replies. %1", job->errorString()),
+                   MicroBlog::Critical);
+    }
+
+}
+
 void PumpIOMicroBlog::slotFollowing(KJob* job)
 {
     if (!job) {
         kDebug() << "Job is null pointer";
         return;
     }
     Choqok::Account *theAccount = m_accountJobs.take(job);
     if (!theAccount) {
         kDebug() << "Account is NULL pointer";
         return;
     }
     if (job->error()) {
         kDebug() << "Job Error: " << job->errorString();
     }
     bool ret = 1;
     PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
     if (acc) {
         Choqok::UI::Global::mainWindow()->showStatusMessage(
             i18n("Following list for account %1 has been updated.",
             acc->username()));
         KIO::StoredTransferJob* j = qobject_cast<KIO::StoredTransferJob* >(job);
         bool ok;
         QJson::Parser parser;
         const QVariantList items = parser.parse(j->data(), &ok).toMap().value("items").toList();
         if (ok) {
             QStringList following;
             Q_FOREACH (const QVariant& element, items) {
                 following.append(element.toMap().value("preferredUsername").toString());
             }
             acc->setFollowing(following);
             ret = 0;
         } else {
             kDebug() << "Cannot parse JSON reply";
         }
     } else {
         kDebug() << "theAccount is not a PumpIOAccount!";
     }
 
     if (ret) {
         emit error(theAccount, Choqok::MicroBlog::CommunicationError,
                    i18n("Cannot retrieve the following list. %1", job->errorString()));
     }
 }
 
 void PumpIOMicroBlog::slotShare(KJob* job)
 {
     if (!job) {
         kDebug() << "Job is null pointer";
         return;
     }
     Choqok::Post *post = m_shareJobs.take(job);
     Choqok::Account *theAccount = m_accountJobs.take(job);
     if (!post || !theAccount) {
         kDebug() << "Account or Post is NULL pointer";
         return;
     }
     int ret = 1;
     if (job->error()) {
         kDebug() << "Job Error: " << job->errorString();
     } else {
         Choqok::UI::Global::mainWindow()->showStatusMessage(
                             i18n("The post has been shared!."));
         KIO::StoredTransferJob* j = qobject_cast<KIO::StoredTransferJob* >(job);
         bool ok;
         QJson::Parser parser;
         const QVariantMap object = parser.parse(j->data(), &ok).toMap().value("object").toMap();
         if (ok) {
             ret = 0;
         } else {
             kDebug() << "Cannot parse JSON reply";
         }
     }
 
     if (ret) {
         emit error(theAccount, Choqok::MicroBlog::CommunicationError,
                    i18n("Cannot share the post. %1", job->errorString()));
     }
 }
 
 void PumpIOMicroBlog::slotRemovePost(KJob* job)
 {
     if (!job) {
         kDebug() << "Job is null pointer";
         return;
     }
     Choqok::Post *post = m_removePostJobs.take(job);
     Choqok::Account *theAccount = m_accountJobs.take(job);
     if (!post || !theAccount) {
         kDebug() << "Account or Post is NULL pointer";
         return;
     }
     int ret = 1;
     if (job->error()) {
         kDebug() << "Job Error: " << job->errorString();
     } else {
         KIO::StoredTransferJob* j = qobject_cast<KIO::StoredTransferJob* >(job);
         bool ok;
         QJson::Parser parser;
         const QVariantMap object = parser.parse(j->data(), &ok).toMap().value("object").toMap();
         if (ok) {
             if (!object["deleted"].toString().isEmpty()) {
                 Choqok::NotifyManager::success(i18n("Post removed successfully"));
                 ret = 0;
                 emit postRemoved(theAccount, post);
             }
         } else {
             kDebug() << "Cannot parse JSON reply";
         }
     }
 
     if (ret) {
         emit errorPost(theAccount, post, Choqok::MicroBlog::CommunicationError,
                        i18n("Removing the post failed. %1", job->errorString()),
                        MicroBlog::Critical);
     }
 }
 
 void PumpIOMicroBlog::slotUpdateTimeline(KJob* job)
 {
     if (!job) {
         kDebug() << "Job is null pointer";
         return;
     }
     Choqok::Account *account = m_accountJobs.take(job);
     if (!account) {
         kDebug() << "Account or Post is NULL pointer";
         return;
     }
     if (job->error()) {
         kDebug() << "Job Error: " << job->errorString();
         emit error(account, Choqok::MicroBlog::CommunicationError,
                    i18n("An error occurred when fetching the timeline"));
     } else {
         KIO::StoredTransferJob* j = qobject_cast<KIO::StoredTransferJob* >(job);
         const QList<Choqok::Post* > list = readTimeline(j->data());
         const QString timeline(m_timelinesRequests.take(job));
         if (!list.isEmpty()) {
             setLastTimelineId(account, timeline, list.last()->conversationId);
         }
 
         emit timelineDataReceived(account, timeline, list);
     }
 }
 
 QString PumpIOMicroBlog::authorizationMetaData(PumpIOAccount* account, const KUrl& url,
                                                const QOAuth::HttpMethod& method,
                                                const QOAuth::ParamMap& paramMap) const
 {
     const QByteArray authorization = account->oAuth()->createParametersString(url.url(),
                                                        method, account->token().toLocal8Bit(),
                                                        account->tokenSecret().toLocal8Bit(),
                                                        QOAuth::HMAC_SHA1, paramMap,
                                                        QOAuth::ParseForHeaderArguments);
     return "Authorization: " + authorization;
 }
 
+void PumpIOMicroBlog::fetchReplies(Choqok::Account* theAccount, const QString& url)
+{
+    PumpIOAccount *acc = qobject_cast<PumpIOAccount*>(theAccount);
+    if (acc) {
+        if (!url.startsWith(acc->host())) {
+            kDebug() << "You can only fetch replies from your host!";
+            return;
+        }
+        KUrl u(url);
+
+        KIO::StoredTransferJob *job = KIO::storedGet(u, KIO::Reload, KIO::HideProgressInfo);
+        if (!job) {
+            kDebug() << "Cannot create an http GET request!";
+            return;
+        }
+        job->addMetaData("customHTTPHeader", authorizationMetaData(acc, u, QOAuth::GET));
+        m_accountJobs[job] = acc;
+        connect(job, SIGNAL(result(KJob*)), this, SLOT(slotFetchReplies(KJob*)));
+        job->start();
+    } else {
+        kDebug() << "theAccount is not a PumpIOAccount!";
+    }
+}
+
 QString PumpIOMicroBlog::hostFromAcct(const QString& acct) const
 {
     if (acct.contains("acct:")) {
         return acct.split(':')[1].split('@')[1];
     }
 
     return acct;
 }
 
 ChoqokId PumpIOMicroBlog::lastTimelineId(Choqok::Account* theAccount,
                                          const QString& timeline) const
 {
     kDebug() << "Latest ID for timeline " << timeline << m_timelinesLatestIds[theAccount][timeline];
     return m_timelinesLatestIds[theAccount][timeline];
 }
 
 Choqok::Post* PumpIOMicroBlog::readPost(const QVariantMap& var, Choqok::Post* post)
 {
     PumpIOPost *p = dynamic_cast< PumpIOPost* >(post);
     if (p) {
         QVariantMap object;
         if (var.value("verb").toString() == "post" ||
             var.value("verb").toString() == "share") {
             object = var["object"].toMap();
         } else {
             object = var;
         }
 
         QTextDocument content;
         if (!object["displayName"].isNull()) {
             content.setHtml(object["displayName"].toString());
             p->content = content.toPlainText().trimmed();
             p->content += '\n';
         }
 
         content.setHtml(object["content"].toString());
         p->content += content.toPlainText().trimmed();
 
         if (!object["fullImage"].isNull()) {
             const QString imagePath = object["fullImage"].toMap().value("url").toString();
             if (!imagePath.isEmpty()) {
                 p->content += '\n' + imagePath;
             }
         }
         p->creationDateTime = QDateTime::fromString(var["published"].toString(),
                                                    "yyyy-MM-dd'T'hh:mm:ss'Z'");
         p->postId = object["id"].toString();
         p->link = object["url"].toString();
         p->type = object["objectType"].toString();
         p->isFavorited = object["liked"].toBool();
         if (p->isFavorited) {
             p->isRead = true;
         }
         p->conversationId = var["id"].toString();
 
         QString author;
         var["author"].isNull() ? author = "actor" : author = "author";
         QVariantMap actor;
         if (var.value("verb").toString() == "share") {
             actor = object["author"].toMap();
             const QVariantList shares = object["shares"].toMap().value("items").toList();
             Q_FOREACH (const QVariant& element, shares) {
                 p->shares.append(element.toMap().value("id").toString());
             }
         } else {
             actor = var[author].toMap();
         }
         p->author.userId = actor["id"].toString();
         p->author.userName = actor["preferredUsername"].toString();
         p->author.realName = actor["displayName"].toString();
         p->author.homePageUrl = actor["url"].toString();
         p->author.location = actor["location"].toMap().value("displayName").toString();
         p->author.description = actor["summary"].toString();
         p->author.profileImageUrl = actor["image"].toMap().value("url").toString();
 
         if (!var["generator"].isNull()) {
             p->source = var["generator"].toMap().value("displayName").toString();
         }
 
         const QVariantList to = var["to"].toList();
         Q_FOREACH (const QVariant& element, to) {
             p->to.append(element.toMap().value("id").toString());
         }
 
         const QVariantList cc = var["cc"].toList();
         Q_FOREACH (const QVariant& element, cc) {
             p->cc.append(element.toMap().value("id").toString());
         }
 
-        const QVariantList replies = object["replies"].toMap().value("items").toList();
-        Q_FOREACH (const QVariant& element, replies) {
-            p->replies.append(element.toMap().value("id").toString());
+        const QVariantMap replies = object["replies"].toMap();
+        if (replies.value("pump_io").isNull()) {
+            p->replies = replies["url"].toString();
+        } else {
+            p->replies = replies["pump_io"].toMap().value("proxyURL").toString();
         }
 
         return p;
     } else {
         kDebug() << "post is not a PumpIOPost!";
         return post;
     }
 }
 
 QList< Choqok::Post* > PumpIOMicroBlog::readTimeline(const QByteArray& buffer)
 {
     QList<Choqok::Post* > posts;
     bool ok;
     QJson::Parser parser;
     const QVariantList list = parser.parse(buffer, &ok).toMap().value("items").toList();
     if (ok) {
         Q_FOREACH (const QVariant& element, list) {
             const QVariantMap elementMap = element.toMap();
             if (!elementMap["object"].toMap().value("deleted").isNull()) {
                 // Skip deleted posts
                 continue;
             }
             posts.prepend(readPost(elementMap, new PumpIOPost));
         }
     } else {
         kDebug() << "Cannot parse JSON reply";
     }
 
     return posts;
 }
 
 void PumpIOMicroBlog::setLastTimelineId(Choqok::Account* theAccount,
                                         const QString& timeline,
                                         const ChoqokId& id)
 {
     m_timelinesLatestIds[theAccount][timeline] = id;
 }
 
 void PumpIOMicroBlog::setTimelinesInfo()
 {
     Choqok::TimelineInfo *t = new Choqok::TimelineInfo;
     t->name = i18nc("Timeline Name", "Activity");
     t->description = i18nc("Timeline description", "You and people you follow");
     t->icon = "user-home";
     m_timelinesInfos["Activity"] = t;
     m_timelinesPaths["Activity"] = inboxActivity + "/major";
 
     t = new Choqok::TimelineInfo;
     t->name = i18nc("Timeline Name", "Favorites");
     t->description = i18nc("Timeline description", "Posts you favorited");
     t->icon = "favorites";
     m_timelinesInfos["Favorites"] = t;
     m_timelinesPaths["Favorites"] = "/api/user/%1/favorites";
 
     t = new Choqok::TimelineInfo;
     t->name = i18nc("Timeline Name", "Inbox");
     t->description = i18nc("Timeline description", "Posts sent to you");
     t->icon = "mail-folder-inbox";
     m_timelinesInfos["Inbox"] = t;
     m_timelinesPaths["Inbox"] = inboxActivity + "/direct/major/";
 
     t = new Choqok::TimelineInfo;
     t->name = i18nc("Timeline Name", "Outbox");
     t->description = i18nc("Timeline description", "Posts you sent");
     t->icon = "mail-folder-outbox";
     m_timelinesInfos["Outbox"] = t;
     m_timelinesPaths["Outbox"] = outboxActivity + "/major/";
 }
 
 QString PumpIOMicroBlog::userNameFromAcct(const QString& acct) const
 {
     if (acct.contains("acct:")) {
         return acct.split(':')[1].split('@')[0];
     }
 
     return acct;
 }
diff --git a/microblogs/pumpio/pumpiomicroblog.h b/microblogs/pumpio/pumpiomicroblog.h
index 0fb2f400..a9fbab7e 100644
--- a/microblogs/pumpio/pumpiomicroblog.h
+++ b/microblogs/pumpio/pumpiomicroblog.h
@@ -1,136 +1,138 @@
 /*
     This file is part of Choqok, the KDE micro-blogging client
 
     Copyright (C) 2013 Andrea Scarpino <scarpino@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 PUMPIOMICROBLOG_H
 #define PUMPIOMICROBLOG_H
 
 #include "QtOAuth/qoauth_namespace.h"
 
 #include "microblog.h"
 
 class KJob;
 class KUrl;
 class PumpIOAccount;
 
 class PumpIOMicroBlog : public Choqok::MicroBlog
 {
     Q_OBJECT
 public:
     explicit PumpIOMicroBlog(QObject* parent, const QVariantList& args);
     virtual ~PumpIOMicroBlog();
 
     virtual void abortAllJobs(Choqok::Account* theAccount);
 
     virtual void abortCreatePost(Choqok::Account* theAccount, Choqok::Post* post = 0);
 
     virtual void aboutToUnload();
 
     virtual ChoqokEditAccountWidget* createEditAccountWidget(Choqok::Account* account,
                                                              QWidget* parent);
 
     virtual Choqok::Account* createNewAccount(const QString& alias);
 
     virtual void createPost(Choqok::Account* theAccount, Choqok::Post* post);
 
     virtual Choqok::UI::PostWidget* createPostWidget(Choqok::Account* account,
                                                      Choqok::Post* post,
                                                      QWidget* parent);
 
     virtual void fetchPost(Choqok::Account* theAccount, Choqok::Post* post);
 
     virtual QList<Choqok::Post* > loadTimeline(Choqok::Account* account,
                                                const QString& timelineName);
 
     virtual void removePost(Choqok::Account* theAccount, Choqok::Post* post);
 
     virtual QString postUrl(Choqok::Account* account, const QString& username,
                             const QString& postId) const;
 
     virtual QString profileUrl(Choqok::Account* account, const QString& username) const;
 
     virtual void saveTimeline(Choqok::Account* account, const QString& timelineName,
                               const QList< Choqok::UI::PostWidget* >& timeline);
 
     virtual Choqok::TimelineInfo* timelineInfo(const QString& timelineName);
 
     virtual void updateTimelines(Choqok::Account* theAccount);
 
     void fetchFollowing(Choqok::Account* theAccount);
 
     QString hostFromAcct(const QString& acct) const;
 
     void share(Choqok::Account* theAccount, Choqok::Post* post);
 
     void toggleFavorite(Choqok::Account* theAccount, Choqok::Post* post);
 
     QString userNameFromAcct(const QString& acct) const;
 
+    void fetchReplies(Choqok::Account* theAccount, const QString& url);
+
 Q_SIGNALS:
     void favorite(Choqok::Account*, Choqok::Post*);
 
 protected Q_SLOTS:
     void slotCreatePost(KJob* job);
     void slotFavorite(KJob* job);
     void slotFetchPost(KJob* job);
+    void slotFetchReplies(KJob* job);
     void slotFollowing(KJob* job);
     void slotRemovePost(KJob* job);
     void slotShare(KJob* job);
     void slotUpdateTimeline(KJob* job);
 
 protected:
     static const QString inboxActivity;
     static const QString outboxActivity;
 
     QString authorizationMetaData(PumpIOAccount* account, const KUrl& url,
                                   const QOAuth::HttpMethod& method,
                                   const QOAuth::ParamMap& map = QOAuth::ParamMap()) const;
 
     ChoqokId lastTimelineId(Choqok::Account* theAccount, const QString& timeline) const;
 
     Choqok::Post* readPost(const QVariantMap& var, Choqok::Post* post);
 
     QList<Choqok::Post* > readTimeline(const QByteArray& buffer);
 
     void setLastTimelineId(Choqok::Account* theAccount, const QString& timeline,
                            const ChoqokId& id);
 
     void setTimelinesInfo();
 
     QMap<KJob*, Choqok::Account* > m_accountJobs;
     QMap<KJob*, Choqok::Post* > m_createPostJobs;
     QMap<KJob*, Choqok::Post* > m_favoriteJobs;
-    QMap<KJob*, ChoqokId > m_fetchPostJobs;
     QMap<KJob*, Choqok::Post* > m_removePostJobs;
     QMap<KJob*, Choqok::Post* > m_shareJobs;
     QMap<QString, Choqok::TimelineInfo* > m_timelinesInfos;
     QHash<Choqok::Account*, QMap<QString, ChoqokId> > m_timelinesLatestIds;
     QHash<QString, QString> m_timelinesPaths;
     QMap<KJob*, QString> m_timelinesRequests;
 
 private:
     class Private;
     Private * const d;
 
 };
 
 #endif // PUMPIOMICROBLOG_H
\ No newline at end of file
diff --git a/microblogs/pumpio/pumpiopost.h b/microblogs/pumpio/pumpiopost.h
index e189e58b..c3a76e66 100644
--- a/microblogs/pumpio/pumpiopost.h
+++ b/microblogs/pumpio/pumpiopost.h
@@ -1,43 +1,43 @@
 /*
     This file is part of Choqok, the KDE micro-blogging client
 
     Copyright (C) 2013  Andrea Scarpino <scarpino@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 PUMPIOPOST_H
 #define PUMPIOPOST_H
 
 #include <QStringList>
 
 #include "choqoktypes.h"
 
 class PumpIOPost : public Choqok::Post
 {
 public:
     PumpIOPost();
     virtual ~PumpIOPost();
 
-    QStringList replies;
+    QString replies;
     QStringList shares;
     QStringList to;
     QStringList cc;
 };
 
 #endif //PUMPIOPOST_H
\ No newline at end of file
diff --git a/microblogs/pumpio/pumpiopostwidget.cpp b/microblogs/pumpio/pumpiopostwidget.cpp
index 7540d07e..ada05699 100644
--- a/microblogs/pumpio/pumpiopostwidget.cpp
+++ b/microblogs/pumpio/pumpiopostwidget.cpp
@@ -1,215 +1,214 @@
 /*
     This file is part of Choqok, the KDE micro-blogging client
 
     Copyright (C) 2013 Andrea Scarpino <scarpino@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 "pumpiopostwidget.h"
 
 #include <KDebug>
 #include <KLocalizedString>
 #include <KPushButton>
 
 #include "mediamanager.h"
 #include "textbrowser.h"
 
 #include "pumpioaccount.h"
 #include "pumpiomicroblog.h"
 #include "pumpiopost.h"
 #include "pumpioshowthread.h"
 
 const KIcon PumpIOPostWidget::unFavIcon(Choqok::MediaManager::convertToGrayScale(KIcon("rating").pixmap(16)));
 
 class PumpIOPostWidget::Private
 {
 public:
     KPushButton *btnFav;
 };
 
 PumpIOPostWidget::PumpIOPostWidget(Choqok::Account* account, Choqok::Post* post,
                                    QWidget* parent):
     PostWidget(account, post, parent), d(new Private)
 {
     mainWidget()->document()->addResource(QTextDocument::ImageResource,
                                           QUrl("icon://thread"),
                                           KIcon("go-top").pixmap(10));
 }
 
 PumpIOPostWidget::~PumpIOPostWidget()
 {
     delete d->btnFav;
     delete d;
 }
 
 void PumpIOPostWidget::checkAnchor(const QUrl& url)
 {
     if (url.scheme() == "thread") {
         PumpIOShowThread *thread = new PumpIOShowThread(currentAccount(), currentPost());
         thread->resize(this->width(), thread->height());
         thread->show();
     } else {
         Choqok::UI::PostWidget::checkAnchor(url);
     }
 }
 
 QString PumpIOPostWidget::generateSign()
 {
     QString ss;
 
     PumpIOPost *post = dynamic_cast<PumpIOPost* >(currentPost());
     PumpIOAccount *account = qobject_cast<PumpIOAccount* >(currentAccount());
     PumpIOMicroBlog *microblog = qobject_cast<PumpIOMicroBlog* >(account->microblog());
     if (post) {
         if (post->author.userName != account->username()) {
             ss += "<b><a href='"+ microblog->profileUrl(account, post->author.homePageUrl)
                   + "' title=\"" + post->author.realName + "\">" +
                   post->author.userName + "</a></b> - ";
         }
 
         ss += "<a href=\"" + post->link + "\" title=\""
               + post->creationDateTime.toString(Qt::DefaultLocaleLongDate)
               + "\">%1</a>";
 
         if (!post->source.isEmpty()) {
             ss += " - " + post->source;
         }
 
         const QRegExp followers("/api/user/\\w+/followers");
         if (!post->to.isEmpty()) {
             ss += " - ";
             ss += i18n("To:") + ' ';
 
             Q_FOREACH (const QString& id, post->to) {
                 if (id == "http://activityschema.org/collection/public") {
                     ss += i18n("Public") + ' ';
                 } else if (followers.indexIn(id) != -1) {
                     ss += "<a href=\"" + QString(id).remove("/api/user") + "\">"
                           + i18n("Followers") + "</a> ";
                 } else if (id == "acct:" + account->webfingerID()) {
                     ss += i18n("You") + ' ';
                 } else {
                     ss += "<a href=\"" + microblog->profileUrl(account, id)
                           + "\">" + microblog->userNameFromAcct(id) + "</a> ";
                 }
             }
             ss = ss.trimmed();
         }
 
         if (!post->cc.isEmpty()) {
             ss += " - ";
             ss += i18n("Cc:") + ' ';
 
             Q_FOREACH (const QString& id, post->cc) {
                 if (id == "http://activityschema.org/collection/public") {
                     ss += i18n("Public") + ' ';
                 } else if (followers.indexIn(id) != -1) {
                     ss += "<a href=\"" + QString(id).remove("/api/user") + "\">"
                           + i18n("Followers") + "</a> ";
                 } else if (id == "acct:" + account->webfingerID()) {
                     ss += i18n("You") + ' ';
                 } else {
                     ss += "<a href=\"" + microblog->profileUrl(account, id)
                           + "\">" + microblog->userNameFromAcct(id) + "</a> ";
                 }
             }
             ss = ss.trimmed();
         }
 
         if (!post->shares.isEmpty()) {
             ss += " - ";
             ss += i18n("Shared by:") + ' ';
 
             Q_FOREACH (const QString& id, post->shares) {
                 if (id == "acct:" + account->webfingerID()) {
                     ss += i18n("You") + ' ';
                 } else {
                     ss += "<a href=\"" + microblog->profileUrl(account, id)
                           + "\">" + microblog->userNameFromAcct(id) + "</a> ";
                 }
             }
             ss = ss.trimmed();
         }
 
-        if (!post->replies.isEmpty()) {
-            ss += " - " + i18n("Replies") + " <a href=\"thread://" +
-                  post->conversationId + "\"><img src=\"icon://thread\"/></a>";
-        }
+        ss += " - ";
+        ss += i18n("View replies");
+        ss += " <a href=\"thread://\"><img src=\"icon://thread\"/></a>";
     } else {
         kDebug() << "post is not a PumpIOPost!";
     }
 
     return ss;
 }
 
 void PumpIOPostWidget::initUi()
 {
     Choqok::UI::PostWidget::initUi();
 
     d->btnFav = addButton("btnFavorite", i18nc("@info:tooltip", "Favorite"), "rating");
     d->btnFav->setCheckable(true);
     connect(d->btnFav, SIGNAL(clicked(bool)), this, SLOT(toggleFavorite()));
     updateFavStat();
 }
 
 void PumpIOPostWidget::toggleFavorite()
 {
     setReadWithSignal();
     PumpIOMicroBlog* microBlog = qobject_cast<PumpIOMicroBlog*>(currentAccount()->microblog());
     connect(microBlog, SIGNAL(favorite(Choqok::Account*, Choqok::Post*)),
             this, SLOT(slotToggleFavorite(Choqok::Account*, Choqok::Post*)));
     microBlog->toggleFavorite(currentAccount(), currentPost());
 }
 
 void PumpIOPostWidget::slotToggleFavorite(Choqok::Account*, Choqok::Post*)
 {
     updateFavStat();
 }
 
 void PumpIOPostWidget::slotPostError(Choqok::Account* theAccount, Choqok::Post* post,
                                      Choqok::MicroBlog::ErrorType error,
                                      const QString& errorMessage)
 {
     Q_UNUSED(error)
     if (theAccount == currentAccount() && post == currentPost()) {
         kDebug() << errorMessage;
         disconnect(currentAccount()->microblog(), SIGNAL(postRemoved(Choqok::Account*,Choqok::Post*)),
                   this, SLOT(slotCurrentPostRemoved(Choqok::Account*,Choqok::Post*)) );
         disconnect(currentAccount()->microblog(),
                    SIGNAL(errorPost(Choqok::Account*,Choqok::Post*,Choqok::MicroBlog::ErrorType,QString,Choqok::MicroBlog::ErrorLevel)),
                    this, SLOT(slotPostError(Choqok::Account*,Choqok::Post*,Choqok::MicroBlog::ErrorType,QString)));
     }
 }
 
 void PumpIOPostWidget::slotResendPost()
 {
     setReadWithSignal();
     PumpIOMicroBlog* microBlog = qobject_cast<PumpIOMicroBlog*>(currentAccount()->microblog());
     microBlog->share(currentAccount(), currentPost());
 }
 
 void PumpIOPostWidget::updateFavStat()
 {
     d->btnFav->setChecked(currentPost()->isFavorited);
     if (currentPost()->isFavorited){
         d->btnFav->setIcon(KIcon("rating"));
     } else {
         d->btnFav->setIcon(unFavIcon);
     }
 }
diff --git a/microblogs/pumpio/pumpioshowthread.cpp b/microblogs/pumpio/pumpioshowthread.cpp
index b12c5963..57f96e89 100644
--- a/microblogs/pumpio/pumpioshowthread.cpp
+++ b/microblogs/pumpio/pumpioshowthread.cpp
@@ -1,64 +1,68 @@
 /*
     This file is part of Choqok, the KDE micro-blogging client
 
     Copyright (C) 2013  Andrea Scarpino <scarpino@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 "pumpioshowthread.h"
 
 #include <KDebug>
 
+#include "pumpiomicroblog.h"
 #include "pumpiopost.h"
 #include "pumpiopostwidget.h"
 
 PumpIOShowThread::PumpIOShowThread(Choqok::Account* account, Choqok::Post* post,
                                    QWidget* parent): QWidget(parent)
 {
     setupUi(this);
 
     connect(account->microblog(), SIGNAL(postFetched(Choqok::Account*,Choqok::Post*)),
             this, SLOT(slotAddPost(Choqok::Account*,Choqok::Post*)));
 
     PumpIOPost* p = dynamic_cast<PumpIOPost*>(post);
     if (p) {
-        account->microblog()->fetchPost(account, p);
+        PumpIOPostWidget *widget = new PumpIOPostWidget(account, p, this);
+        widget->initUi();
+        widget->setRead();
+        mainLayout->addWidget(widget);
 
-        PumpIOPost *reply;
-        Q_FOREACH (const ChoqokId& replyId, p->replies) {
-            reply = new PumpIOPost;
-            reply->postId = replyId;
-            account->microblog()->fetchPost(account, reply);
+        PumpIOMicroBlog* microblog = dynamic_cast<PumpIOMicroBlog*>(account->microblog());
+        if (microblog) {
+            microblog->fetchReplies(account, p->replies);
+        } else {
+            kDebug() << "Microblog is not a PumpIOMicroBlog";
         }
     } else {
         kDebug() << "Post is not a PumpIOPost";
     }
 }
 
 PumpIOShowThread::~PumpIOShowThread()
 {
 }
 
 void PumpIOShowThread::slotAddPost(Choqok::Account* theAccount, Choqok::Post* post)
 {
     PumpIOPostWidget *widget = new PumpIOPostWidget(theAccount, post, this);
     widget->initUi();
     widget->setRead();
-    mainLayout->insertWidget(0, widget);
+    mainLayout->addWidget(widget);
 }