akregator/src/mainwidget.cpp

   1 /*
   2     This file is part of Akregator.
   3
   4     Copyright (C) 2004 Stanislav Karchebny <Stanislav.Karchebny@kdemail.net>
   5                   2004 Sashmit Bhaduri <smt@vfemail.net>
   6                   2005 Frank Osterfeld <osterfeld@kde.org>
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  21
  22     As a special exception, permission is given to link this program
  23     with any edition of Qt, and distribute the resulting executable,
  24     without including the source code for Qt in the source distribution.
  25 */
  26
  27 #include "mainwidget.h"
  28 #include "utils.h"
  29 #include "actionmanagerimpl.h"
  30 #include "addfeeddialog.h"
  31 #include "articlelistview.h"
  32 #include "articleviewerwidget.h"
  33 #include "abstractselectioncontroller.h"
  34 #include "articlejobs.h"
  35 #include "articlematcher.h"
  36 #include "akregatorconfig.h"
  37 #include "akregator_part.h"
  38 #include "Libkdepim/BroadcastStatus"
  39 #include "createfeedcommand.h"
  40 #include "createfoldercommand.h"
  41 #include "deletesubscriptioncommand.h"
  42 #include "editsubscriptioncommand.h"
  43 #include "expireitemscommand.h"
  44 #include "importfeedlistcommand.h"
  45 #include "feed.h"
  46 #include "feedlist.h"
  47 #include "feedpropertiesdialog.h"
  48 #include "fetchqueue.h"
  49 #include "folder.h"
  50 #include "framemanager.h"
  51 #include "kernel.h"
  52 #include "notificationmanager.h"
  53 #include "openurlrequest.h"
  54 #include "progressmanager.h"
  55 #include "widgets/searchbar.h"
  56 #include "selectioncontroller.h"
  57 #include "subscriptionlistjobs.h"
  58 #include "subscriptionlistmodel.h"
  59 #include "subscriptionlistview.h"
  60 #include "tabwidget.h"
  61 #include "treenode.h"
  62 #include "treenodevisitor.h"
  63 #include "types.h"
  64 #include "mainframe.h"
  65 #include <WebEngineViewer/ZoomActionMenu>
  66 #include "job/downloadarticlejob.h"
  67
  68 #include <QAction>
  69 #include <kfileitem.h>
  70 #include <KLocalizedString>
  71 #include <kmessagebox.h>
  72 #include <krandom.h>
  73 #include <kshell.h>
  74
  75 #include <ktoggleaction.h>
  76 #include <QUrl>
  77
  78 #include <QClipboard>
  79 #include <QNetworkConfigurationManager>
  80 #include <QSplitter>
  81 #include <QTextDocument>
  82 #include <QDomDocument>
  83 #include <QTimer>
  84 #include <QDesktopServices>
  85 #include <QUrlQuery>
  86
  87 #include <algorithm>
  88 #include <memory>
  89 #include <cassert>
  90
  91 #include <webengine/webengineframe.h>
  92 #include "articleviewer-ng/webengine/articleviewerwebenginewidgetng.h"
  93
  94 using namespace Akregator;
  95
  96 MainWidget::~MainWidget()
  97 {
  98     // if m_shuttingDown is false, slotOnShutdown was not called. That
  99     // means that not the whole app is shutdown, only the part. So it
 100     // should be no risk to do the cleanups now
 101     if (!m_shuttingDown) {
 102         slotOnShutdown();
 103     }
 104 }
 105
 106 MainWidget::MainWidget(Part *part, QWidget *parent, ActionManagerImpl *actionManager, const QString &name)
 107     : QWidget(parent),
 108       m_feedList(),
 109       m_viewMode(NormalView),
 110       m_actionManager(actionManager),
 111       m_feedListManagementInterface(new FeedListManagementImpl),
 112       m_networkConfigManager(new QNetworkConfigurationManager(this))
 113 {
 114     setObjectName(name);
 115
 116     FeedListManagementInterface::setInstance(m_feedListManagementInterface);
 117
 118     m_actionManager->initMainWidget(this);
 119     m_part = part;
 120     m_shuttingDown = false;
 121     m_displayingAboutPage = false;
 122     setFocusPolicy(Qt::StrongFocus);
 123
 124     QVBoxLayout *lt = new QVBoxLayout(this);
 125     lt->setMargin(0);
 126
 127     m_horizontalSplitter = new QSplitter(Qt::Horizontal, this);
 128
 129     m_horizontalSplitter->setOpaqueResize(true);
 130     m_horizontalSplitter->setChildrenCollapsible(false);
 131     lt->addWidget(m_horizontalSplitter);
 132
 133     connect(Kernel::self()->fetchQueue(), &FetchQueue::signalStarted,
 134             this, &MainWidget::slotFetchingStarted);
 135     connect(Kernel::self()->fetchQueue(), &FetchQueue::signalStopped,
 136             this, &MainWidget::slotFetchingStopped);
 137
 138     m_feedListView = new SubscriptionListView(m_horizontalSplitter);
 139     m_feedListView->setObjectName(QStringLiteral("feedtree"));
 140     m_actionManager->initSubscriptionListView(m_feedListView);
 141
 142     connect(m_feedListView, &SubscriptionListView::userActionTakingPlace,
 143             this, &MainWidget::ensureArticleTabVisible);
 144
 145     m_tabWidget = new TabWidget(m_horizontalSplitter);
 146     m_actionManager->initTabWidget(m_tabWidget);
 147
 148     connect(m_part, &Part::signalSettingsChanged,
 149             this, &MainWidget::slotSettingsChanged);
 150
 151     connect(m_tabWidget, &TabWidget::signalCurrentFrameChanged,
 152             this, &MainWidget::slotCurrentFrameChanged);
 153
 154     connect(m_tabWidget, &TabWidget::signalRemoveFrameRequest,
 155             Kernel::self()->frameManager(), &FrameManager::slotRemoveFrame);
 156
 157     connect(m_tabWidget, SIGNAL(signalOpenUrlRequest(Akregator::OpenUrlRequest&)),
 158             Kernel::self()->frameManager(), SLOT(slotOpenUrlRequest(Akregator::OpenUrlRequest&)));
 159
 160     connect(Kernel::self()->frameManager(), &FrameManager::signalFrameAdded,
 161             m_tabWidget, &TabWidget::slotAddFrame);
 162
 163     connect(Kernel::self()->frameManager(), &FrameManager::signalSelectFrame,
 164             m_tabWidget, &TabWidget::slotSelectFrame);
 165
 166     connect(Kernel::self()->frameManager(), &FrameManager::signalFrameRemoved,
 167             m_tabWidget, &TabWidget::slotRemoveFrame);
 168
 169     connect(Kernel::self()->frameManager(), &FrameManager::signalRequestNewFrame,
 170             this, &MainWidget::slotRequestNewFrame);
 171
 172     connect(Kernel::self()->frameManager(), &FrameManager::signalFrameRemoved,
 173             this, &MainWidget::slotFramesChanged);
 174     connect(Kernel::self()->frameManager(), &FrameManager::signalCompleted,
 175             this, &MainWidget::slotFramesChanged);
 176
 177     connect(m_networkConfigManager, &QNetworkConfigurationManager::onlineStateChanged,
 178             this, &MainWidget::slotNetworkStatusChanged);
 179
 180     m_tabWidget->setWhatsThis(i18n("You can view multiple articles in several open tabs."));
 181
 182     m_mainTab = new QWidget(this);
 183     m_mainTab->setObjectName(QStringLiteral("Article Tab"));
 184     m_mainTab->setWhatsThis(i18n("Articles list."));
 185
 186     QVBoxLayout *mainTabLayout = new QVBoxLayout(m_mainTab);
 187     mainTabLayout->setMargin(0);
 188
 189     m_searchBar = new SearchBar(m_mainTab);
 190     if (!Settings::showQuickFilter()) {
 191         m_searchBar->hide();
 192     }
 193     m_articleSplitter = new QSplitter(Qt::Vertical, m_mainTab);
 194     m_articleSplitter->setObjectName(QStringLiteral("panner2"));
 195     m_articleSplitter->setChildrenCollapsible(false);
 196
 197     m_articleWidget = new QWidget(m_articleSplitter);
 198     QVBoxLayout *articleWidgetLayout = new QVBoxLayout;
 199     m_articleWidget->setLayout(articleWidgetLayout);
 200     articleWidgetLayout->setMargin(0);
 201     articleWidgetLayout->setSpacing(0);
 202
 203     m_articleListView = new ArticleListView;
 204     articleWidgetLayout->addWidget(m_searchBar);
 205     articleWidgetLayout->addWidget(m_articleListView);
 206     connect(m_articleListView, &ArticleListView::userActionTakingPlace,
 207             this, &MainWidget::ensureArticleTabVisible);
 208
 209     m_selectionController = new SelectionController(this);
 210     m_selectionController->setArticleLister(m_articleListView);
 211     m_selectionController->setFeedSelector(m_feedListView);
 212
 213     connect(m_searchBar, &SearchBar::signalSearch,
 214             m_selectionController, &AbstractSelectionController::setFilters);
 215
 216     FolderExpansionHandler *expansionHandler = new FolderExpansionHandler(this);
 217     connect(m_feedListView, &QTreeView::expanded, expansionHandler, &FolderExpansionHandler::itemExpanded);
 218     connect(m_feedListView, &QTreeView::collapsed, expansionHandler, &FolderExpansionHandler::itemCollapsed);
 219
 220     m_selectionController->setFolderExpansionHandler(expansionHandler);
 221
 222     connect(m_selectionController, &AbstractSelectionController::currentSubscriptionChanged,
 223             this, &MainWidget::slotNodeSelected);
 224
 225     connect(m_selectionController, &AbstractSelectionController::currentArticleChanged,
 226             this, &MainWidget::slotArticleSelected);
 227
 228     connect(m_selectionController, &AbstractSelectionController::articleDoubleClicked,
 229             this, &MainWidget::slotOpenArticleInBrowser);
 230
 231     m_actionManager->initArticleListView(m_articleListView);
 232
 233     connect(m_articleListView, &ArticleListView::signalMouseButtonPressed,
 234             this, &MainWidget::slotMouseButtonPressed);
 235
 236     m_articleViewer = new ArticleViewerWidget(Settings::grantleeDirectory(), m_actionManager->actionCollection(), m_articleSplitter);
 237     m_articleListView->setFocusProxy(m_articleViewer);
 238     setFocusProxy(m_articleViewer);
 239
 240     connect(m_articleViewer, &ArticleViewerWidget::showStatusBarMessage, this, &MainWidget::slotShowStatusBarMessage);
 241     connect(m_articleViewer, SIGNAL(signalOpenUrlRequest(Akregator::OpenUrlRequest&)),
 242             Kernel::self()->frameManager(), SLOT(slotOpenUrlRequest(Akregator::OpenUrlRequest&)));
 243     connect(m_searchBar, &SearchBar::signalSearch,
 244             m_articleViewer, &ArticleViewerWidget::setFilters);
 245     mainTabLayout->addWidget(m_articleSplitter);
 246
 247     m_mainFrame = new MainFrame(this, m_mainTab);
 248     m_mainFrame->slotSetTitle(i18n("Articles"));
 249     m_mainFrame->setArticleViewer(m_articleViewer);
 250     connect(m_articleViewer->articleViewerWidgetNg()->articleViewerNg(), &ArticleViewerWebEngine::articleAction, this, &MainWidget::slotArticleAction);
 251     connect(m_tabWidget, &TabWidget::signalCopyInFrame, m_mainFrame, &MainFrame::slotCopyInFrame);
 252     connect(m_tabWidget, &TabWidget::signalPrintInFrame, m_mainFrame, &MainFrame::slotPrintInFrame);
 253     connect(m_tabWidget, &TabWidget::signalZoomChangedInFrame, m_mainFrame, &MainFrame::slotZoomChangeInFrame);
 254     connect(m_tabWidget, &TabWidget::signalPrintPreviewInFrame, m_mainFrame, &MainFrame::slotPrintPreviewInFrame);
 255     connect(m_tabWidget, &TabWidget::signalFindTextInFrame, m_mainFrame, &MainFrame::slotFindTextInFrame);
 256     connect(m_tabWidget, &TabWidget::signalTextToSpeechInFrame, m_mainFrame, &MainFrame::slotTextToSpeechInFrame);
 257     connect(m_tabWidget, &TabWidget::signalSaveLinkAsInFrame, m_mainFrame, &MainFrame::slotSaveLinkAsInFrame);
 258     connect(m_tabWidget, &TabWidget::signalCopyLinkAsInFrame, m_mainFrame, &MainFrame::slotCopyLinkAsInFrame);
 259     connect(m_tabWidget, &TabWidget::signalCopyImageLocation, m_mainFrame, &MainFrame::slotCopyImageLocationInFrame);
 260     connect(m_tabWidget, &TabWidget::signalSaveImageOnDisk, m_mainFrame, &MainFrame::slotSaveImageOnDiskInFrame);
 261     connect(m_tabWidget, &TabWidget::signalMute, m_mainFrame, &MainFrame::slotMute);
 262
 263     Kernel::self()->frameManager()->slotAddFrame(m_mainFrame);
 264
 265     const QList<int> sp1sizes = Settings::splitter1Sizes();
 266     if (sp1sizes.count() >= m_horizontalSplitter->count()) {
 267         m_horizontalSplitter->setSizes(sp1sizes);
 268     }
 269     const QList<int> sp2sizes = Settings::splitter2Sizes();
 270     if (sp2sizes.count() >= m_articleSplitter->count()) {
 271         m_articleSplitter->setSizes(sp2sizes);
 272     }
 273
 274     if (!Settings::self()->disableIntroduction()) {
 275         m_articleWidget->hide();
 276         m_articleViewer->displayAboutPage();
 277         m_mainFrame->slotSetTitle(i18n("About"));
 278         m_displayingAboutPage = true;
 279     }
 280
 281     m_fetchTimer = new QTimer(this);
 282     connect(m_fetchTimer, &QTimer::timeout,
 283             this, &MainWidget::slotDoIntervalFetches);
 284     m_fetchTimer->start(1000 * 60);
 285
 286     // delete expired articles once per hour
 287     m_expiryTimer = new QTimer(this);
 288     connect(m_expiryTimer, &QTimer::timeout,
 289             this, &MainWidget::slotDeleteExpiredArticles);
 290     m_expiryTimer->start(3600 * 1000);
 291
 292     m_markReadTimer = new QTimer(this);
 293     m_markReadTimer->setSingleShot(true);
 294     connect(m_markReadTimer, &QTimer::timeout, this, &MainWidget::slotSetCurrentArticleReadDelayed);
 295
 296     setFeedList(QSharedPointer<FeedList>(new FeedList(Kernel::self()->storage())));
 297
 298     switch (Settings::viewMode()) {
 299     case CombinedView:
 300         slotCombinedView();
 301         break;
 302     case WidescreenView:
 303         slotWidescreenView();
 304         break;
 305     default:
 306         slotNormalView();
 307     }
 308
 309     if (!Settings::resetQuickFilterOnNodeChange()) {
 310         m_searchBar->slotSetStatus(Settings::statusFilter());
 311         m_searchBar->slotSetText(Settings::textFilter());
 312     }
 313 }
 314
 315 void MainWidget::slotSettingsChanged()
 316 {
 317     m_tabWidget->slotSettingsChanged();
 318     m_articleViewer->updateAfterConfigChanged();
 319 }
 320
 321 void MainWidget::slotOnShutdown()
 322 {
 323     disconnect(m_tabWidget, &TabWidget::signalCurrentFrameChanged,
 324                this, &MainWidget::slotCurrentFrameChanged);
 325
 326     m_shuttingDown = true;
 327
 328     // close all pageviewers in a controlled way
 329     // fixes bug 91660, at least when no part loading data
 330     while (m_tabWidget->count() > 1) {   // remove frames until only the main frame remains
 331         m_tabWidget->setCurrentIndex(m_tabWidget->count() - 1);   // select last page
 332         m_tabWidget->slotRemoveCurrentFrame();
 333     }
 334
 335     Kernel::self()->fetchQueue()->slotAbort();
 336     setFeedList(QSharedPointer<FeedList>());
 337
 338     delete m_feedListManagementInterface;
 339     delete m_feedListView; // call delete here, so that the header settings will get saved
 340     delete m_articleListView; // same for this one
 341
 342     delete m_mainTab;
 343     delete m_mainFrame;
 344     m_mainFrame = 0;
 345
 346     Settings::self()->save();
 347 }
 348
 349 void MainWidget::saveSettings()
 350 {
 351     const QList<int> spl1 = m_horizontalSplitter->sizes();
 352     if (std::count(spl1.begin(), spl1.end(), 0) == 0) {
 353         Settings::setSplitter1Sizes(spl1);
 354     }
 355     const QList<int> spl2 = m_articleSplitter->sizes();
 356     if (std::count(spl2.begin(), spl2.end(), 0) == 0) {
 357         Settings::setSplitter2Sizes(spl2);
 358     }
 359     Settings::setViewMode(m_viewMode);
 360     Settings::self()->save();
 361 }
 362
 363 void MainWidget::connectFrame(Akregator::WebEngineFrame *frame)
 364 {
 365     connect(m_tabWidget, &TabWidget::signalCopyInFrame, frame, &WebEngineFrame::slotCopyInFrame);
 366     connect(m_tabWidget, &TabWidget::signalPrintInFrame, frame, &WebEngineFrame::slotPrintInFrame);
 367     connect(m_tabWidget, &TabWidget::signalZoomChangedInFrame, frame, &WebEngineFrame::slotZoomChangeInFrame);
 368     connect(m_tabWidget, &TabWidget::signalPrintPreviewInFrame, frame, &WebEngineFrame::slotPrintPreviewInFrame);
 369     connect(m_tabWidget, &TabWidget::signalFindTextInFrame, frame, &WebEngineFrame::slotFindTextInFrame);
 370     connect(m_tabWidget, &TabWidget::signalTextToSpeechInFrame, frame, &WebEngineFrame::slotTextToSpeechInFrame);
 371     connect(m_tabWidget, &TabWidget::signalSaveLinkAsInFrame, frame, &WebEngineFrame::slotSaveLinkAsInFrame);
 372     connect(m_tabWidget, &TabWidget::signalCopyLinkAsInFrame, frame, &WebEngineFrame::slotCopyLinkAsInFrame);
 373     connect(m_tabWidget, &TabWidget::signalCopyImageLocation, frame, &WebEngineFrame::slotCopyImageLocationInFrame);
 374     connect(m_tabWidget, &TabWidget::signalSaveImageOnDisk, frame, &WebEngineFrame::slotSaveImageOnDiskInFrame);
 375     connect(m_tabWidget, &TabWidget::signalMute, frame, &WebEngineFrame::slotMute);
 376
 377     connect(frame, &WebEngineFrame::showStatusBarMessage, this, &MainWidget::slotShowStatusBarMessage);
 378     connect(frame, &WebEngineFrame::signalIconChanged, m_tabWidget, &TabWidget::slotSetIcon);
 379     connect(frame, &WebEngineFrame::webPageMutedOrAudibleChanged, m_tabWidget, &TabWidget::slotWebPageMutedOrAudibleChanged);
 380 }
 381
 382 void MainWidget::slotRequestNewFrame(int &frameId)
 383 {
 384     WebEngineFrame *frame = new WebEngineFrame(m_actionManager->actionCollection(), m_tabWidget);
 385     connectFrame(frame);
 386
 387     Kernel::self()->frameManager()->slotAddFrame(frame);
 388
 389     frameId = frame->id();
 390 }
 391
 392 void MainWidget::sendArticle(bool attach)
 393 {
 394     QByteArray text;
 395     QString title;
 396
 397     Frame *frame = Kernel::self()->frameManager()->currentFrame();
 398
 399     if (frame && frame->id() > 0) { // are we in some other tab than the articlelist?
 400         text = frame->url().toString().toLatin1();
 401         title = frame->title();
 402     } else { // nah, we're in articlelist..
 403         const Article article =  m_selectionController->currentArticle();
 404         if (!article.isNull()) {
 405             text = article.link().toDisplayString().toLatin1();
 406             title = Akregator::Utils::convertHtmlTags(article.title());
 407         }
 408     }
 409
 410     if (text.isEmpty()) {
 411         return;
 412     }
 413     sendArticle(text, title, attach);
 414 }
 415
 416 void MainWidget::cleanUpDownloadFile()
 417 {
 418     Q_FOREACH (QPointer<Akregator::DownloadArticleJob> job, mListDownloadArticleJobs) {
 419         if (job) {
 420             job->forceCleanupTemporaryFile();
 421         }
 422     }
 423 }
 424
 425 void MainWidget::sendArticle(const QByteArray &text, const QString &title, bool attach)
 426 {
 427     if (attach) {
 428         QPointer<Akregator::DownloadArticleJob> download = new Akregator::DownloadArticleJob(this);
 429         download->setArticleUrl(QUrl(QString::fromUtf8(text)));
 430         download->setText(QString::fromUtf8(text));
 431         download->setTitle(title);
 432         mListDownloadArticleJobs.append(download);
 433         download->start();
 434     } else {
 435         QUrlQuery query;
 436         query.addQueryItem(QStringLiteral("subject"), title);
 437         query.addQueryItem(QStringLiteral("body"), QString::fromUtf8(text));
 438         QUrl url;
 439         url.setScheme(QStringLiteral("mailto"));
 440         url.setQuery(query);
 441         QDesktopServices::openUrl(url);
 442     }
 443 }
 444
 445 void MainWidget::importFeedList(const QDomDocument &doc)
 446 {
 447     ImportFeedListCommand *cmd = new ImportFeedListCommand;
 448     cmd->setParentWidget(this);
 449     cmd->setFeedListDocument(doc);
 450     cmd->setTargetList(m_feedList);
 451     cmd->start();
 452 }
 453
 454 void MainWidget::setFeedList(const QSharedPointer<FeedList> &list)
 455 {
 456     if (list == m_feedList) {
 457         return;
 458     }
 459     const QSharedPointer<FeedList> oldList = m_feedList;
 460
 461     m_feedList = list;
 462     if (m_feedList) {
 463         connect(m_feedList.data(), &FeedList::unreadCountChanged,
 464                 this, &MainWidget::slotSetTotalUnread);
 465     }
 466
 467     slotSetTotalUnread();
 468
 469     m_feedListManagementInterface->setFeedList(m_feedList);
 470     Kernel::self()->setFeedList(m_feedList);
 471     ProgressManager::self()->setFeedList(m_feedList);
 472     m_selectionController->setFeedList(m_feedList);
 473
 474     if (oldList) {
 475         oldList->disconnect(this);
 476     }
 477
 478     slotDeleteExpiredArticles();
 479 }
 480
 481 void MainWidget::deleteExpiredArticles(const QSharedPointer<FeedList> &list)
 482 {
 483     if (!list) {
 484         return;
 485     }
 486     ExpireItemsCommand *cmd = new ExpireItemsCommand(this);
 487     cmd->setParentWidget(this);
 488     cmd->setFeedList(list);
 489     cmd->setFeeds(list->feedIds());
 490     cmd->start();
 491 }
 492
 493 void MainWidget::slotDeleteExpiredArticles()
 494 {
 495     deleteExpiredArticles(m_feedList);
 496 }
 497
 498 QDomDocument MainWidget::feedListToOPML()
 499 {
 500     QDomDocument dom;
 501     if (m_feedList) {
 502         dom = m_feedList->toOpml();
 503     }
 504     return dom;
 505 }
 506
 507 void MainWidget::addFeedToGroup(const QString &url, const QString &groupName)
 508 {
 509     // Locate the group.
 510     QList<TreeNode *> namedGroups = m_feedList->findByTitle(groupName);
 511     Folder *group = 0;
 512     foreach (TreeNode *const candidate, namedGroups) {
 513         if (candidate->isGroup()) {
 514             group =  static_cast<Folder *>(candidate);
 515             break;
 516         }
 517     }
 518
 519     if (!group) {
 520         Folder *g = new Folder(groupName);
 521         m_feedList->allFeedsFolder()->appendChild(g);
 522         group = g;
 523     }
 524
 525     // Invoke the Add Feed dialog with url filled in.
 526     addFeed(url, 0, group, true);
 527 }
 528
 529 void MainWidget::slotNormalView()
 530 {
 531     if (m_viewMode == NormalView) {
 532         return;
 533     }
 534
 535     if (m_viewMode == CombinedView) {
 536         m_articleWidget->show();
 537
 538         const Article article =  m_selectionController->currentArticle();
 539
 540         if (!article.isNull()) {
 541             m_articleViewer->showArticle(article);
 542         } else {
 543             m_articleViewer->slotShowSummary(m_selectionController->selectedSubscription());
 544         }
 545     }
 546
 547     m_articleSplitter->setOrientation(Qt::Vertical);
 548     m_viewMode = NormalView;
 549
 550     Settings::setViewMode(m_viewMode);
 551 }
 552
 553 void MainWidget::slotWidescreenView()
 554 {
 555     if (m_viewMode == WidescreenView) {
 556         return;
 557     }
 558
 559     if (m_viewMode == CombinedView) {
 560         m_articleWidget->show();
 561
 562         Article article =  m_selectionController->currentArticle();
 563
 564         if (!article.isNull()) {
 565             m_articleViewer->showArticle(article);
 566         } else {
 567             m_articleViewer->slotShowSummary(m_selectionController->selectedSubscription());
 568         }
 569     }
 570
 571     m_articleSplitter->setOrientation(Qt::Horizontal);
 572     m_viewMode = WidescreenView;
 573
 574     Settings::setViewMode(m_viewMode);
 575 }
 576
 577 void MainWidget::slotCombinedView()
 578 {
 579     if (m_viewMode == CombinedView) {
 580         return;
 581     }
 582
 583     m_articleListView->slotClear();
 584     m_articleWidget->hide();
 585     m_viewMode = CombinedView;
 586
 587     Settings::setViewMode(m_viewMode);
 588 }
 589
 590 void MainWidget::slotMoveCurrentNodeUp()
 591 {
 592     TreeNode *current = m_selectionController->selectedSubscription();
 593     if (!current) {
 594         return;
 595     }
 596     TreeNode *prev = current->prevSibling();
 597     Folder *parent = current->parent();
 598
 599     if (!prev || !parent) {
 600         return;
 601     }
 602
 603     parent->removeChild(prev);
 604     parent->insertChild(prev, current);
 605     m_feedListView->ensureNodeVisible(current);
 606 }
 607
 608 void MainWidget::slotMoveCurrentNodeDown()
 609 {
 610     TreeNode *current = m_selectionController->selectedSubscription();
 611     if (!current) {
 612         return;
 613     }
 614     TreeNode *next = current->nextSibling();
 615     Folder *parent = current->parent();
 616
 617     if (!next || !parent) {
 618         return;
 619     }
 620
 621     parent->removeChild(current);
 622     parent->insertChild(current, next);
 623     m_feedListView->ensureNodeVisible(current);
 624 }
 625
 626 void MainWidget::slotMoveCurrentNodeLeft()
 627 {
 628     TreeNode *current = m_selectionController->selectedSubscription();
 629     if (!current || !current->parent() || !current->parent()->parent()) {
 630         return;
 631     }
 632
 633     Folder *parent = current->parent();
 634     Folder *grandparent = current->parent()->parent();
 635
 636     parent->removeChild(current);
 637     grandparent->insertChild(current, parent);
 638     m_feedListView->ensureNodeVisible(current);
 639 }
 640
 641 void MainWidget::slotMoveCurrentNodeRight()
 642 {
 643     TreeNode *current = m_selectionController->selectedSubscription();
 644     if (!current || !current->parent()) {
 645         return;
 646     }
 647     TreeNode *prev = current->prevSibling();
 648
 649     if (prev && prev->isGroup()) {
 650         Folder *fg = static_cast<Folder *>(prev);
 651         current->parent()->removeChild(current);
 652         fg->appendChild(current);
 653         m_feedListView->ensureNodeVisible(current);
 654     }
 655 }
 656
 657 void MainWidget::slotSendLink()
 658 {
 659     sendArticle();
 660 }
 661
 662 void MainWidget::slotSendFile()
 663 {
 664     sendArticle(true);
 665 }
 666
 667 void MainWidget::slotNodeSelected(TreeNode *node)
 668 {
 669     m_markReadTimer->stop();
 670
 671     if (m_displayingAboutPage) {
 672         m_mainFrame->slotSetTitle(i18n("Articles"));
 673         if (m_viewMode != CombinedView) {
 674             m_articleWidget->show();
 675         }
 676         if (Settings::showQuickFilter()) {
 677             m_searchBar->show();
 678         }
 679         m_displayingAboutPage = false;
 680     }
 681
 682     m_tabWidget->setCurrentWidget(m_mainFrame);
 683     if (Settings::resetQuickFilterOnNodeChange()) {
 684         m_searchBar->slotClearSearch();
 685     }
 686
 687     if (m_viewMode == CombinedView) {
 688         m_articleViewer->showNode(node);
 689     } else {
 690         m_articleViewer->slotShowSummary(node);
 691     }
 692
 693     if (node) {
 694         m_mainFrame->setWindowTitle(node->title());
 695     }
 696
 697     m_actionManager->slotNodeSelected(node);
 698 }
 699
 700 void MainWidget::slotFeedAdd()
 701 {
 702     Folder *group = 0;
 703     if (!m_selectionController->selectedSubscription()) {
 704         group = m_feedList->allFeedsFolder();
 705     } else {
 706         if (m_selectionController->selectedSubscription()->isGroup()) {
 707             group = static_cast<Folder *>(m_selectionController->selectedSubscription());
 708         } else {
 709             group = m_selectionController->selectedSubscription()->parent();
 710         }
 711
 712     }
 713
 714     TreeNode *const lastChild = !group->children().isEmpty() ? group->children().last() : Q_NULLPTR;
 715
 716     addFeed(QString(), lastChild, group, false);
 717 }
 718
 719 void MainWidget::addFeed(const QString &url, TreeNode *after, Folder *parent, bool autoExec)
 720 {
 721     CreateFeedCommand *cmd(new CreateFeedCommand(this));
 722     cmd->setParentWidget(this);
 723     cmd->setPosition(parent, after);
 724     cmd->setRootFolder(m_feedList->allFeedsFolder());
 725     cmd->setAutoExecute(autoExec);
 726     cmd->setUrl(url);
 727     cmd->setSubscriptionListView(m_feedListView);
 728     cmd->start();
 729 }
 730
 731 void MainWidget::slotFeedAddGroup()
 732 {
 733     CreateFolderCommand *cmd = new CreateFolderCommand(this);
 734     cmd->setParentWidget(this);
 735     cmd->setSelectedSubscription(m_selectionController->selectedSubscription());
 736     cmd->setRootFolder(m_feedList->allFeedsFolder());
 737     cmd->setSubscriptionListView(m_feedListView);
 738     cmd->start();
 739 }
 740
 741 void MainWidget::slotFeedRemove()
 742 {
 743     TreeNode *selectedNode = m_selectionController->selectedSubscription();
 744
 745     // don't delete root element! (safety valve)
 746     if (!selectedNode || selectedNode == m_feedList->allFeedsFolder()) {
 747         return;
 748     }
 749
 750     DeleteSubscriptionCommand *cmd = new DeleteSubscriptionCommand(this);
 751     cmd->setParentWidget(this);
 752     cmd->setSubscription(m_feedList, selectedNode->id());
 753     cmd->start();
 754 }
 755
 756 void MainWidget::slotFeedModify()
 757 {
 758     TreeNode *const node = m_selectionController->selectedSubscription();
 759     if (!node) {
 760         return;
 761     }
 762     EditSubscriptionCommand *cmd = new EditSubscriptionCommand(this);
 763     cmd->setParentWidget(this);
 764     cmd->setSubscription(m_feedList, node->id());
 765     cmd->setSubscriptionListView(m_feedListView);
 766     cmd->start();
 767 }
 768
 769 void MainWidget::slotNextUnreadArticle()
 770 {
 771     ensureArticleTabVisible();
 772     if (m_viewMode == CombinedView) {
 773         m_feedListView->slotNextUnreadFeed();
 774         return;
 775     }
 776     TreeNode *sel = m_selectionController->selectedSubscription();
 777     if (sel && sel->unread() > 0) {
 778         m_articleListView->slotNextUnreadArticle();
 779     } else {
 780         m_feedListView->slotNextUnreadFeed();
 781     }
 782 }
 783
 784 void MainWidget::slotPrevUnreadArticle()
 785 {
 786     ensureArticleTabVisible();
 787     if (m_viewMode == CombinedView) {
 788         m_feedListView->slotPrevUnreadFeed();
 789         return;
 790     }
 791     TreeNode *sel = m_selectionController->selectedSubscription();
 792     if (sel && sel->unread() > 0) {
 793         m_articleListView->slotPreviousUnreadArticle();
 794     } else {
 795         m_feedListView->slotPrevUnreadFeed();
 796     }
 797 }
 798
 799 void MainWidget::slotMarkAllFeedsRead()
 800 {
 801     KJob *job = m_feedList->createMarkAsReadJob();
 802     connect(job, &KJob::finished, m_selectionController, &AbstractSelectionController::forceFilterUpdate);
 803     job->start();
 804 }
 805
 806 void MainWidget::slotMarkAllRead()
 807 {
 808     if (!m_selectionController->selectedSubscription()) {
 809         return;
 810     }
 811     KJob *job = m_selectionController->selectedSubscription()->createMarkAsReadJob();
 812     connect(job, &KJob::finished, m_selectionController, &AbstractSelectionController::forceFilterUpdate);
 813     job->start();
 814 }
 815
 816 void MainWidget::slotSetTotalUnread()
 817 {
 818     Q_EMIT signalUnreadCountChanged(m_feedList ? m_feedList->unread() : 0);
 819 }
 820
 821 void MainWidget::slotDoIntervalFetches()
 822 {
 823     if (!m_feedList) {
 824         return;
 825     }
 826 #if 0
 827     // the following solid check apparently doesn't work reliably and causes
 828     // interval fetching not working although the user is actually online (but solid reports he's not
 829     const Networking::Status status = Solid::Networking::status();
 830     if (status != Networking::Connected && status != Networking::Unknown) {
 831         return;
 832     }
 833 #endif
 834     m_feedList->addToFetchQueue(Kernel::self()->fetchQueue(), true);
 835 }
 836
 837 void MainWidget::slotFetchCurrentFeed()
 838 {
 839     if (!m_selectionController->selectedSubscription()) {
 840         return;
 841     }
 842     if (isNetworkAvailable()) {
 843         m_selectionController->selectedSubscription()->slotAddToFetchQueue(Kernel::self()->fetchQueue());
 844     } else {
 845         m_mainFrame->slotSetStatusText(i18n("Networking is not available."));
 846     }
 847 }
 848
 849 void MainWidget::slotFetchAllFeeds()
 850 {
 851     if (m_feedList && isNetworkAvailable()) {
 852         m_feedList->addToFetchQueue(Kernel::self()->fetchQueue());
 853     } else if (m_feedList) {
 854         m_mainFrame->slotSetStatusText(i18n("Networking is not available."));
 855     }
 856 }
 857
 858 void MainWidget::slotFetchingStarted()
 859 {
 860     m_mainFrame->slotSetState(Frame::Started);
 861     m_actionManager->action(QStringLiteral("feed_stop"))->setEnabled(true);
 862     m_mainFrame->slotSetStatusText(i18n("Fetching Feeds..."));
 863 }
 864
 865 void MainWidget::slotFetchingStopped()
 866 {
 867     m_mainFrame->slotSetState(Frame::Completed);
 868     m_actionManager->action(QStringLiteral("feed_stop"))->setEnabled(false);
 869     m_mainFrame->slotSetStatusText(QString());
 870 }
 871
 872 void MainWidget::slotArticleSelected(const Akregator::Article &article)
 873 {
 874     if (m_viewMode == CombinedView) {
 875         return;
 876     }
 877
 878     m_markReadTimer->stop();
 879
 880     Q_ASSERT(article.isNull() || article.feed());
 881
 882     QVector<Article> articles = m_selectionController->selectedArticles();
 883     Q_EMIT signalArticlesSelected(articles);
 884
 885     KToggleAction *const maai = qobject_cast<KToggleAction *>(m_actionManager->action(QStringLiteral("article_set_status_important")));
 886     Q_ASSERT(maai);
 887     maai->setChecked(article.keep());
 888
 889     m_articleViewer->showArticle(article);
 890     if (m_selectionController->selectedArticles().count() == 0) {
 891         m_articleListView->setCurrentIndex(m_selectionController->currentArticleIndex());
 892     }
 893
 894     if (article.isNull() || article.status() == Akregator::Read) {
 895         return;
 896     }
 897
 898     if (!Settings::useMarkReadDelay()) {
 899         return;
 900     }
 901
 902     const int delay = Settings::markReadDelay();
 903
 904     if (delay > 0) {
 905         m_markReadTimer->start(delay * 1000);
 906     } else {
 907         Akregator::ArticleModifyJob *job = new Akregator::ArticleModifyJob;
 908         const Akregator::ArticleId aid = { article.feed()->xmlUrl(), article.guid() };
 909         job->setStatus(aid, Akregator::Read);
 910         job->start();
 911     }
 912 }
 913
 914 void MainWidget::slotMouseButtonPressed(int button, const QUrl &url)
 915 {
 916     if (button != Qt::MidButton) {
 917         return;
 918     }
 919
 920     if (!url.isValid()) {
 921         return;
 922     }
 923
 924     OpenUrlRequest req(url);
 925
 926     switch (Settings::mMBBehaviour()) {
 927     case Settings::EnumMMBBehaviour::OpenInExternalBrowser:
 928         req.setOptions(OpenUrlRequest::ExternalBrowser);
 929         break;
 930     case Settings::EnumMMBBehaviour::OpenInBackground:
 931         req.setOptions(OpenUrlRequest::NewTab);
 932         req.setOpenInBackground(true);
 933         break;
 934     default:
 935         req.setOptions(OpenUrlRequest::NewTab);
 936         req.setOpenInBackground(false);
 937     }
 938
 939     Kernel::self()->frameManager()->slotOpenUrlRequest(req);
 940 }
 941
 942 void MainWidget::slotOpenHomepage()
 943 {
 944     Feed *feed = dynamic_cast<Feed *>(m_selectionController->selectedSubscription());
 945
 946     if (!feed) {
 947         return;
 948     }
 949
 950     QUrl url(feed->htmlUrl());
 951
 952     if (url.isValid()) {
 953         OpenUrlRequest req(url);
 954         req.setOptions(OpenUrlRequest::ExternalBrowser);
 955         Kernel::self()->frameManager()->slotOpenUrlRequest(req);
 956     }
 957 }
 958
 959 void MainWidget::slotOpenSelectedArticlesInBrowser()
 960 {
 961     const QVector<Article> articles = m_selectionController->selectedArticles();
 962
 963     Q_FOREACH (const Akregator::Article &article, articles) {
 964         slotOpenArticleInBrowser(article);
 965     }
 966 }
 967
 968 void MainWidget::slotOpenArticleInBrowser(const Akregator::Article &article)
 969 {
 970     if (!article.isNull() && article.link().isValid()) {
 971         OpenUrlRequest req(article.link());
 972         req.setOptions(OpenUrlRequest::ExternalBrowser);
 973         Kernel::self()->frameManager()->slotOpenUrlRequest(req);
 974     }
 975 }
 976
 977 void MainWidget::openSelectedArticles(bool openInBackground)
 978 {
 979     const QVector<Article> articles = m_selectionController->selectedArticles();
 980
 981     Q_FOREACH (const Akregator::Article &article, articles) {
 982         const QUrl url = article.link();
 983         if (!url.isValid()) {
 984             continue;
 985         }
 986
 987         OpenUrlRequest req(url);
 988         req.setOptions(OpenUrlRequest::NewTab);
 989         if (openInBackground) {
 990             req.setOpenInBackground(true);
 991             Kernel::self()->frameManager()->slotOpenUrlRequest(req, false /*don't use settings for open in background*/);
 992         } else {
 993             Kernel::self()->frameManager()->slotOpenUrlRequest(req);
 994         }
 995     }
 996
 997 }
 998
 999 void MainWidget::currentArticleInfo(QString &link, QString &title)
1000 {
1001     const Article article =  m_selectionController->currentArticle();
1002
1003     if (article.isNull()) {
1004         return;
1005     }
1006     if (article.link().isValid()) {
1007         link = article.link().url();
1008         title = Utils::convertHtmlTags(article.title());
1009     }
1010 }
1011
1012 void MainWidget::updateQuickSearchLineText()
1013 {
1014     m_searchBar->updateQuickSearchLineText(m_actionManager->quickSearchLineText());
1015 }
1016
1017 void MainWidget::slotCopyLinkAddress()
1018 {
1019     const Article article =  m_selectionController->currentArticle();
1020
1021     if (article.isNull()) {
1022         return;
1023     }
1024
1025     QString link;
1026     if (article.link().isValid()) {
1027         link = article.link().url();
1028         QClipboard *cb = QApplication::clipboard();
1029         cb->setText(link, QClipboard::Clipboard);
1030         // don't set url to selection as it's a no-no according to a fd.o spec
1031         //cb->setText(link, QClipboard::Selection);
1032     }
1033 }
1034
1035 void MainWidget::slotToggleShowQuickFilter()
1036 {
1037     if (Settings::showQuickFilter()) {
1038         Settings::setShowQuickFilter(false);
1039         m_searchBar->slotClearSearch();
1040         m_searchBar->hide();
1041     } else {
1042         Settings::setShowQuickFilter(true);
1043         if (!m_displayingAboutPage) {
1044             m_searchBar->show();
1045         }
1046     }
1047
1048 }
1049
1050 void MainWidget::slotArticleDelete()
1051 {
1052
1053     if (m_viewMode == CombinedView) {
1054         return;
1055     }
1056
1057     const QVector<Article> articles = m_selectionController->selectedArticles();
1058
1059     QString msg;
1060     switch (articles.count()) {
1061     case 0:
1062         return;
1063     case 1:
1064         msg = i18n("<qt>Are you sure you want to delete article <b>%1</b>?</qt>", articles.first().title());
1065         break;
1066     default:
1067         msg = i18np("<qt>Are you sure you want to delete the selected article?</qt>", "<qt>Are you sure you want to delete the %1 selected articles?</qt>", articles.count());
1068     }
1069
1070     if (KMessageBox::warningContinueCancel(this,
1071                                            msg, i18n("Delete Article"),
1072                                            KStandardGuiItem::del(),
1073                                            KStandardGuiItem::cancel(),
1074                                            QStringLiteral("Disable delete article confirmation")) != KMessageBox::Continue) {
1075         return;
1076     }
1077
1078     TreeNode *const selected = m_selectionController->selectedSubscription();
1079
1080     if (selected) {
1081         selected->setNotificationMode(false);
1082     }
1083
1084     Akregator::ArticleDeleteJob *job = new Akregator::ArticleDeleteJob;
1085     Q_FOREACH (const Akregator::Article &i, articles) {
1086         Feed *const feed = i.feed();
1087         if (!feed) {
1088             continue;
1089         }
1090         const Akregator::ArticleId aid = { feed->xmlUrl(), i.guid() };
1091         job->appendArticleId(aid);
1092     }
1093
1094     job->start();
1095
1096     if (selected) {
1097         selected->setNotificationMode(true);
1098     }
1099 }
1100
1101 void MainWidget::slotFramesChanged()
1102 {
1103     // We need to wait till the frame is fully loaded
1104     QMetaObject::invokeMethod(m_part, "slotAutoSave", Qt::QueuedConnection);
1105 }
1106
1107 void MainWidget::slotArticleToggleKeepFlag(bool)
1108 {
1109     const QVector<Article> articles = m_selectionController->selectedArticles();
1110
1111     if (articles.isEmpty()) {
1112         return;
1113     }
1114
1115     bool allFlagsSet = true;
1116     Q_FOREACH (const Akregator::Article &i, articles) {
1117         allFlagsSet = allFlagsSet && i.keep();
1118         if (!allFlagsSet) {
1119             break;
1120         }
1121     }
1122
1123     Akregator::ArticleModifyJob *job = new Akregator::ArticleModifyJob;
1124     Q_FOREACH (const Akregator::Article &i, articles) {
1125         const Akregator::ArticleId aid = { i.feed()->xmlUrl(), i.guid() };
1126         job->setKeep(aid, !allFlagsSet);
1127     }
1128     job->start();
1129 }
1130
1131 namespace
1132 {
1133
1134 void setArticleStatus(const QString &feedUrl, const QString &articleId, int status)
1135 {
1136     if (!feedUrl.isEmpty() && !articleId.isEmpty()) {
1137         Akregator::ArticleModifyJob *job = new Akregator::ArticleModifyJob;
1138         const Akregator::ArticleId aid = { feedUrl, articleId };
1139         job->setStatus(aid, status);
1140         job->start();
1141     }
1142 }
1143
1144 void setSelectedArticleStatus(const Akregator::AbstractSelectionController *controller, int status)
1145 {
1146     const QVector<Akregator::Article> articles = controller->selectedArticles();
1147
1148     if (articles.isEmpty()) {
1149         return;
1150     }
1151
1152     Akregator::ArticleModifyJob *job = new Akregator::ArticleModifyJob;
1153     Q_FOREACH (const Akregator::Article &i, articles) {
1154         const Akregator::ArticleId aid = { i.feed()->xmlUrl(), i.guid() };
1155         job->setStatus(aid, status);
1156     }
1157     job->start();
1158 }
1159
1160 }
1161
1162 void MainWidget::slotSetSelectedArticleRead()
1163 {
1164     ::setSelectedArticleStatus(m_selectionController, Akregator::Read);
1165 }
1166
1167 void MainWidget::slotSetSelectedArticleUnread()
1168 {
1169     ::setSelectedArticleStatus(m_selectionController, Akregator::Unread);
1170 }
1171
1172 void MainWidget::slotSetSelectedArticleNew()
1173 {
1174     ::setSelectedArticleStatus(m_selectionController, Akregator::New);
1175 }
1176
1177 void MainWidget::slotSetCurrentArticleReadDelayed()
1178 {
1179     const Article article =  m_selectionController->currentArticle();
1180
1181     if (article.isNull()) {
1182         return;
1183     }
1184
1185     Akregator::ArticleModifyJob *const job = new Akregator::ArticleModifyJob;
1186     const Akregator::ArticleId aid = { article.feed()->xmlUrl(), article.guid() };
1187     job->setStatus(aid, Akregator::Read);
1188     job->start();
1189 }
1190
1191 void MainWidget::slotShowStatusBarMessage(const QString &msg)
1192 {
1193     KPIM::BroadcastStatus::instance()->setStatusMsg(msg);
1194 }
1195
1196 void MainWidget::readProperties(const KConfigGroup &config)
1197 {
1198     if (!Settings::resetQuickFilterOnNodeChange()) {
1199         // read filter settings
1200         m_searchBar->slotSetText(config.readEntry("searchLine"));
1201         m_searchBar->slotSetStatus(config.readEntry("searchCombo").toInt());
1202     }
1203     const QString currentTabName = config.readEntry("CurrentTab");
1204     // Reopen tabs
1205     const QStringList childList = config.readEntry(QStringLiteral("Children"), QStringList());
1206     int currentFrameId = -1;
1207     Q_FOREACH (const QString &framePrefix, childList) {
1208         WebEngineFrame *const frame = new WebEngineFrame(m_actionManager->actionCollection(), m_tabWidget);
1209         frame->loadConfig(config, framePrefix + QLatin1Char('_'));
1210
1211         connectFrame(frame);
1212         Kernel::self()->frameManager()->slotAddFrame(frame);
1213         if (currentTabName == framePrefix) {
1214             currentFrameId = frame->id();
1215         }
1216     }
1217     if (currentFrameId != -1) {
1218         m_tabWidget->slotSelectFrame(currentFrameId);
1219     }
1220 }
1221
1222 void MainWidget::saveProperties(KConfigGroup &config)
1223 {
1224     // save filter settings
1225     const QString searchStr(m_searchBar->text());
1226     if (searchStr.isEmpty()) {
1227         config.deleteEntry("searchLine");
1228     } else {
1229         config.writeEntry("searchLine", m_searchBar->text());
1230     }
1231     config.writeEntry("searchCombo", m_searchBar->status());
1232
1233     Kernel::self()->frameManager()->saveProperties(config);
1234 }
1235
1236 void MainWidget::ensureArticleTabVisible()
1237 {
1238     m_tabWidget->setCurrentWidget(m_mainFrame);
1239 }
1240
1241 void MainWidget::slotReloadAllTabs()
1242 {
1243     m_tabWidget->slotReloadAllTabs();
1244 }
1245
1246 bool MainWidget::isNetworkAvailable() const
1247 {
1248     return m_networkConfigManager->isOnline();
1249 }
1250
1251 void MainWidget::slotNetworkStatusChanged(bool status)
1252 {
1253     if (status) {
1254         m_mainFrame->slotSetStatusText(i18n("Networking is available now."));
1255         this->slotFetchAllFeeds();
1256     } else {
1257         m_mainFrame->slotSetStatusText(i18n("Networking is not available."));
1258     }
1259 }
1260
1261 void MainWidget::slotOpenSelectedArticles()
1262 {
1263     openSelectedArticles(false);
1264 }
1265
1266 void MainWidget::slotOpenSelectedArticlesInBackground()
1267 {
1268     openSelectedArticles(true);
1269 }
1270
1271 void MainWidget::slotCurrentFrameChanged(int frameId)
1272 {
1273     Kernel::self()->frameManager()->slotChangeFrame(frameId);
1274     m_actionManager->zoomActionMenu()->setZoomFactor(Kernel::self()->frameManager()->currentFrame()->zoomFactor() * 100);
1275 }
1276
1277 void MainWidget::slotFocusQuickSearch()
1278 {
1279     m_searchBar->setFocusSearchLine();
1280 }
1281
1282 void MainWidget::slotArticleAction(Akregator::ArticleViewerWebEngine::ArticleAction type, const QString &articleId, const QString &feed)
1283 {
1284     switch (type) {
1285     case ArticleViewerWebEngine::DeleteAction: {
1286         Akregator::ArticleDeleteJob *job = new Akregator::ArticleDeleteJob;
1287         const Akregator::ArticleId aid = { feed, articleId };
1288         job->appendArticleId(aid);
1289         job->start();
1290         break;
1291     }
1292     case ArticleViewerWebEngine::MarkAsRead:
1293         ::setArticleStatus(feed, articleId, Akregator::Read);
1294         break;
1295     case ArticleViewerWebEngine::MarkAsUnRead:
1296         ::setArticleStatus(feed, articleId, Akregator::Unread);
1297         break;
1298
1299     case ArticleViewerWebEngine::MarkAsImportant: {
1300         Akregator::ArticleModifyJob *job = new Akregator::ArticleModifyJob;
1301         const Akregator::Article article = m_feedList->findArticle(feed, articleId);
1302         const Akregator::ArticleId aid = { feed, articleId };
1303         job->setKeep(aid, !article.keep());
1304         job->start();
1305         break;
1306     }
1307     case ArticleViewerWebEngine::SendUrlArticle: {
1308         case ArticleViewerWebEngine::SendFileArticle:
1309             const Article article =  m_feedList->findArticle(feed, articleId);
1310             const QByteArray text = article.link().toDisplayString().toLatin1();
1311             const QString title = Akregator::Utils::convertHtmlTags(article.title());
1312             if (text.isEmpty()) {
1313                 return;
1314             }
1315             sendArticle(text, title, (type == ArticleViewerWebEngine::SendFileArticle));
1316             break;
1317         }
1318     case ArticleViewerWebEngine::OpenInBackgroundTab: {
1319         const Akregator::Article article = m_feedList->findArticle(feed, articleId);
1320         const QUrl url = article.link();
1321         if (url.isValid()) {
1322             OpenUrlRequest req(url);
1323             req.setOptions(OpenUrlRequest::NewTab);
1324             req.setOpenInBackground(true);
1325             Kernel::self()->frameManager()->slotOpenUrlRequest(req, false /*don't use settings for open in background*/);
1326         }
1327         break;
1328     }
1329     case ArticleViewerWebEngine::OpenInExternalBrowser: {
1330         const Akregator::Article article = m_feedList->findArticle(feed, articleId);
1331         slotOpenArticleInBrowser(article);
1332         break;
1333     }
1334     case ArticleViewerWebEngine::Share:
1335         const Akregator::Article article = m_feedList->findArticle(feed, articleId);
1336         const QUrl url = article.link();
1337         if (url.isValid()) {
1338             //TODO
1339         }
1340         break;
1341     }
1342 }