diff --git a/microblogs/pumpio/CMakeLists.txt b/microblogs/pumpio/CMakeLists.txt index 7beb1f24..40d549d0 100644 --- a/microblogs/pumpio/CMakeLists.txt +++ b/microblogs/pumpio/CMakeLists.txt @@ -1,32 +1,34 @@ include_directories( ${CHOQOK_INCLUDES} ${CMAKE_CURRENT_BINARY_DIR} ) set(choqok_pumpio_SRCS pumpioaccount.cpp pumpioeditaccountwidget.cpp + pumpiomessagedialog.cpp pumpiomicroblog.cpp pumpiopost.cpp pumpiopostwidget.cpp pumpioshowthread.cpp ) kde4_add_ui_files(choqok_pumpio_SRCS pumpioeditaccountwidget.ui + pumpiomessagedialog.ui pumpioshowthread.ui ) kde4_add_plugin(choqok_pumpio ${choqok_pumpio_SRCS}) target_link_libraries(choqok_pumpio choqok ${KDE4_KDEUI_LIBS} ${KDE4_KIO_LIBS} ${QTOAUTH_LIBRARY} ${QJSON_LIBRARY} ) install(TARGETS choqok_pumpio DESTINATION ${PLUGIN_INSTALL_DIR}) install(FILES choqok_pumpio.desktop DESTINATION ${SERVICES_INSTALL_DIR}) add_subdirectory(icons) \ No newline at end of file diff --git a/microblogs/pumpio/pumpiomessagedialog.cpp b/microblogs/pumpio/pumpiomessagedialog.cpp new file mode 100644 index 00000000..0532db7f --- /dev/null +++ b/microblogs/pumpio/pumpiomessagedialog.cpp @@ -0,0 +1,104 @@ +/* + This file is part of Choqok, the KDE micro-blogging client + + Copyright (C) 2013 Andrea Scarpino + + 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 "pumpiomessagedialog.h" + +#include "pumpioaccount.h" +#include "pumpiomicroblog.h" +#include "pumpiopost.h" + +class PumpIOMessageDialog::Private +{ +public: + Choqok::Account *account; +}; + +PumpIOMessageDialog::PumpIOMessageDialog(Choqok::Account* theAccount, QWidget* parent, + Qt::WindowFlags flags) + : KDialog(parent, flags) + , d(new Private) +{ + d->account = theAccount; + + setupUi(this); + + PumpIOAccount* acc = qobject_cast(theAccount); + if (acc) { + Q_FOREACH (const QString& username, acc->following()) { + cmbFollowing->addItem(PumpIOMicroBlog::userNameFromAcct(username)); + } + } + + connect(btnReload, SIGNAL(clicked(bool)), this, SLOT(fetchFollowing())); + connect(buttonBox, SIGNAL(accepted()), this, SLOT(sendPost())); +} + +PumpIOMessageDialog::~PumpIOMessageDialog() +{ +} + +void PumpIOMessageDialog::fetchFollowing() +{ + cmbFollowing->clear(); + PumpIOMicroBlog *microblog = qobject_cast(d->account->microblog()); + if (microblog) { + microblog->fetchFollowing(d->account); + connect(microblog, SIGNAL(followingFetched(Choqok::Account*)), this, + SLOT(slotFetchFollowing(Choqok::Account*))); + } +} + +void PumpIOMessageDialog::slotFetchFollowing(Choqok::Account* theAccount) +{ + if (theAccount == d->account) { + PumpIOAccount* acc = qobject_cast(theAccount); + if (acc) { + Q_FOREACH (const QString& username, acc->following()) { + cmbFollowing->addItem(PumpIOMicroBlog::userNameFromAcct(username)); + } + } + } +} + +void PumpIOMessageDialog::sendPost() +{ + PumpIOAccount* acc = qobject_cast(d->account); + if (acc) { + if (acc->following().isEmpty() || txtMessage->toPlainText().isEmpty() + || cmbFollowing->currentText().isEmpty()) { + return; + } + hide(); + PumpIOMicroBlog* microblog = qobject_cast(d->account->microblog()); + if (microblog) { + PumpIOPost* post = new PumpIOPost; + post->content = txtMessage->toPlainText(); + QVariantList to; + QVariantMap user; + user.insert("objectType", "person"); + user.insert("id", acc->following().at(cmbFollowing->currentIndex())); + to.append(user); + microblog->createPost(acc, post, to); + } + } +} diff --git a/microblogs/pumpio/pumpiomessagedialog.h b/microblogs/pumpio/pumpiomessagedialog.h new file mode 100644 index 00000000..79cff8dc --- /dev/null +++ b/microblogs/pumpio/pumpiomessagedialog.h @@ -0,0 +1,55 @@ +/* + This file is part of Choqok, the KDE micro-blogging client + + Copyright (C) 2013 Andrea Scarpino + + 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 PUMPIOMESSAGEDIALOG_H +#define PUMPIOMESSAGEDIALOG_H + +#include + +#include "ui_pumpiomessagedialog.h" + +namespace Choqok { + class Account; +} + +class PumpIOMessageDialog : public KDialog, Ui::PumpIOMessageDialog +{ + Q_OBJECT + +public: + explicit PumpIOMessageDialog(Choqok::Account *theAccount, QWidget* parent = 0, + Qt::WindowFlags flags = 0); + virtual ~PumpIOMessageDialog(); + +protected Q_SLOTS: + void fetchFollowing(); + void sendPost(); + void slotFetchFollowing(Choqok::Account*); + +private: + class Private; + Private * const d; + +}; + +#endif // PUMPIOMESSAGEDIALOG_H \ No newline at end of file diff --git a/microblogs/pumpio/pumpiomessagedialog.ui b/microblogs/pumpio/pumpiomessagedialog.ui new file mode 100644 index 00000000..29f7771f --- /dev/null +++ b/microblogs/pumpio/pumpiomessagedialog.ui @@ -0,0 +1,106 @@ + + + PumpIOMessageDialog + + + + 0 + 0 + 264 + 262 + + + + Dialog + + + + + + + + To: + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + + + + + + + + + + + + + + + + Qt::Horizontal + + + QDialogButtonBox::Cancel|QDialogButtonBox::Ok + + + + + + + + + buttonBox + accepted() + PumpIOMessageDialog + accept() + + + 248 + 254 + + + 157 + 274 + + + + + buttonBox + rejected() + PumpIOMessageDialog + reject() + + + 316 + 260 + + + 286 + 274 + + + + + diff --git a/microblogs/pumpio/pumpiomicroblog.cpp b/microblogs/pumpio/pumpiomicroblog.cpp index a3bd12ae..5cf105cd 100644 --- a/microblogs/pumpio/pumpiomicroblog.cpp +++ b/microblogs/pumpio/pumpiomicroblog.cpp @@ -1,974 +1,1004 @@ /* This file is part of Choqok, the KDE micro-blogging client Copyright (C) 2013 Andrea Scarpino 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 #include #include #include +#include #include #include #include #include "accountmanager.h" #include "application.h" #include "choqokbehaviorsettings.h" #include "notifymanager.h" #include "pumpioaccount.h" #include "pumpioeditaccountwidget.h" +#include "pumpiomessagedialog.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(); } +QMenu* PumpIOMicroBlog::createActionsMenu(Choqok::Account* theAccount, QWidget* parent) +{ + QMenu *menu = MicroBlog::createActionsMenu(theAccount, parent); + + KAction *directMessge = new KAction(KIcon("mail-message-new"), i18n("Send Private Message..."), menu); + directMessge->setData(theAccount->alias()); + connect(directMessge, SIGNAL(triggered(bool)), this, SLOT(showDirectMessageDialog())); + menu->addAction(directMessge); + + return menu; +} + ChoqokEditAccountWidget* PumpIOMicroBlog::createEditAccountWidget(Choqok::Account* account, QWidget* parent) { PumpIOAccount *acc = qobject_cast(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( 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) +{ + QVariantList to; + QVariantMap thePublic; + thePublic.insert("objectType", "collection"); + thePublic.insert("id", "http://activityschema.org/collection/public"); + to.append(thePublic); + + createPost(theAccount, post, to); +} + +void PumpIOMicroBlog::createPost(Choqok::Account* theAccount, Choqok::Post* post, + const QVariantList& to) { PumpIOAccount *acc = qobject_cast(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(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; 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(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 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", 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((*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(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(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(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(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::showDirectMessageDialog() +{ + const QString alias = qobject_cast(sender())->data().toString(); + PumpIOAccount *theAccount = qobject_cast(Choqok::AccountManager::self()->findAccount(alias)); + PumpIOMessageDialog *msg = new PumpIOMessageDialog(theAccount, Choqok::UI::Global::mainWindow()); + msg->show(); +} + 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(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; } 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(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(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* r = new PumpIOPost; readPost(item.toMap(), r); r->replyToPostId = reply["url"].toString().remove("/replies"); emit postFetched(theAccount, r); } 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(theAccount); if (acc) { Choqok::UI::Global::mainWindow()->showStatusMessage( i18n("Following list for account %1 has been updated.", acc->username())); KIO::StoredTransferJob* j = qobject_cast(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()); + following.append(element.toMap().value("id").toString()); } acc->setFollowing(following); ret = 0; + emit followingFetched(acc); } 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(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(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(job); const QList 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(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 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 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 +QString PumpIOMicroBlog::hostFromAcct(const QString& acct) +{ + if (acct.contains("acct:")) { + return acct.split(':')[1].split('@')[1]; + } + + return acct; +} + +QString PumpIOMicroBlog::userNameFromAcct(const QString& acct) { 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 a9fbab7e..c747541c 100644 --- a/microblogs/pumpio/pumpiomicroblog.h +++ b/microblogs/pumpio/pumpiomicroblog.h @@ -1,138 +1,144 @@ /* This file is part of Choqok, the KDE micro-blogging client Copyright (C) 2013 Andrea Scarpino 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 QMenu* createActionsMenu(Choqok::Account* theAccount, + QWidget* parent = Choqok::UI::Global::mainWindow()); + 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 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); + void createPost(Choqok::Account* theAccount, Choqok::Post* post, const QVariantList& to); - QString hostFromAcct(const QString& acct) const; + void fetchFollowing(Choqok::Account* theAccount); 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); + static QString userNameFromAcct(const QString& acct); + static QString hostFromAcct(const QString& acct); + Q_SIGNALS: void favorite(Choqok::Account*, Choqok::Post*); + void followingFetched(Choqok::Account*); protected Q_SLOTS: + void showDirectMessageDialog(); 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 readTimeline(const QByteArray& buffer); void setLastTimelineId(Choqok::Account* theAccount, const QString& timeline, const ChoqokId& id); void setTimelinesInfo(); QMap m_accountJobs; QMap m_createPostJobs; QMap m_favoriteJobs; QMap m_removePostJobs; QMap m_shareJobs; QMap m_timelinesInfos; QHash > m_timelinesLatestIds; QHash m_timelinesPaths; QMap m_timelinesRequests; private: class Private; Private * const d; }; #endif // PUMPIOMICROBLOG_H \ No newline at end of file diff --git a/microblogs/pumpio/pumpiopostwidget.cpp b/microblogs/pumpio/pumpiopostwidget.cpp index ada05699..3f598ff8 100644 --- a/microblogs/pumpio/pumpiopostwidget.cpp +++ b/microblogs/pumpio/pumpiopostwidget.cpp @@ -1,214 +1,213 @@ /* This file is part of Choqok, the KDE micro-blogging client Copyright (C) 2013 Andrea Scarpino 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 #include #include #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; + KPushButton *btnFavorite; }; 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(currentPost()); PumpIOAccount *account = qobject_cast(currentAccount()); PumpIOMicroBlog *microblog = qobject_cast(account->microblog()); if (post) { if (post->author.userName != account->username()) { ss += "author.realName + "\">" + post->author.userName + " - "; } ss += "link + "\" title=\"" + post->creationDateTime.toString(Qt::DefaultLocaleLongDate) + "\">%1"; 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 += "" + i18n("Followers") + " "; } else if (id == "acct:" + account->webfingerID()) { ss += i18n("You") + ' '; } else { ss += "profileUrl(account, id) - + "\">" + microblog->userNameFromAcct(id) + " "; + + "\">" + PumpIOMicroBlog::userNameFromAcct(id) + " "; } } 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 += "" + i18n("Followers") + " "; } else if (id == "acct:" + account->webfingerID()) { ss += i18n("You") + ' '; } else { ss += "profileUrl(account, id) - + "\">" + microblog->userNameFromAcct(id) + " "; + + "\">" + PumpIOMicroBlog::userNameFromAcct(id) + " "; } } 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 += "profileUrl(account, id) - + "\">" + microblog->userNameFromAcct(id) + " "; + + "\">" + PumpIOMicroBlog::userNameFromAcct(id) + " "; } } ss = ss.trimmed(); } ss += " - "; ss += i18n("View replies"); ss += " "; } 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())); + d->btnFavorite = addButton("btnFavorite", i18nc("@info:tooltip", "Favorite"), "rating"); + d->btnFavorite->setCheckable(true); + connect(d->btnFavorite, SIGNAL(clicked(bool)), this, SLOT(toggleFavorite())); updateFavStat(); } void PumpIOPostWidget::toggleFavorite() { setReadWithSignal(); PumpIOMicroBlog* microBlog = qobject_cast(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(currentAccount()->microblog()); microBlog->share(currentAccount(), currentPost()); } void PumpIOPostWidget::updateFavStat() { - d->btnFav->setChecked(currentPost()->isFavorited); + d->btnFavorite->setChecked(currentPost()->isFavorited); if (currentPost()->isFavorited){ - d->btnFav->setIcon(KIcon("rating")); + d->btnFavorite->setIcon(KIcon("rating")); } else { - d->btnFav->setIcon(unFavIcon); + d->btnFavorite->setIcon(unFavIcon); } }