newstabwidget.cpp

/* ============================================================
* QuiteRSS is a open-source cross-platform RSS/Atom news feeds reader
* Copyright (C) 2011-2020 QuiteRSS Team <quiterssteam@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
* ============================================================ */
#include"newstabwidget.h"

#include"mainapplication.h"
#include"adblockicon.h"
#include"settings.h"
#include"webpage.h"

#if defined(Q_OS_WIN)
#include<qt_windows.h>
#endif
#include<qzregexp.h>

NewsTabWidget::NewsTabWidget(QWidget *parent, TabType type, int feedId, int feedParId)
 : QWidget(parent)
 , type_(type)
 , feedId_(feedId)
 , feedParId_(feedParId)
 , currentNewsIdOld(-1)
 , autoLoadImages_(true)
{
 mainWindow_ = mainApp->mainWindow();
 db_ = QSqlDatabase::database();
 feedsView_ = mainWindow_->feedsView_;
 feedsModel_ = mainWindow_->feedsModel_;
 feedsProxyModel_ = mainWindow_->feedsProxyModel_;

 newsIconTitle_ = newQLabel();
 newsIconMovie_ = newQMovie(":/images/loading");
 newsIconTitle_->setMovie(newsIconMovie_);
 newsTextTitle_ = newQLabel();
 newsTextTitle_->setObjectName("newsTextTitle_");

 closeButton_ = newQToolButton();
 closeButton_->setFixedSize(15, 15);
 closeButton_->setCursor(Qt::ArrowCursor);
 closeButton_->setStyleSheet(
"QToolButton { background-color: transparent;"
"border: none; padding: 0px;"
"image: url(:/images/close); }"
"QToolButton:hover {"
"image: url(:/images/closeHover); }"
 );
connect(closeButton_, SIGNAL(clicked()),
this, SLOT(slotTabClose()));

 QHBoxLayout *newsTitleLayout = newQHBoxLayout();
 newsTitleLayout->setMargin(0);
 newsTitleLayout->setSpacing(0);
 newsTitleLayout->addWidget(newsIconTitle_);
 newsTitleLayout->addSpacing(3);
 newsTitleLayout->addWidget(newsTextTitle_, 1);
 newsTitleLayout->addWidget(closeButton_);

 newsTitleLabel_ = newQWidget();
 newsTitleLabel_->setObjectName("newsTitleLabel_");
 newsTitleLabel_->setMinimumHeight(16);
 newsTitleLabel_->setLayout(newsTitleLayout);
 newsTitleLabel_->setVisible(false);

 Settings settings;
bool showCloseButtonTab = settings.value("Settings/showCloseButtonTab", true).toBool();
if (!showCloseButtonTab) {
 closeButton_->hide();
 newsTitleLabel_->setFixedWidth(MAX_TAB_WIDTH-15);
 } else {
 newsTitleLabel_->setFixedWidth(MAX_TAB_WIDTH);
 }

if (type_ != TabTypeDownloads) {
if (type_ != TabTypeWeb) {
createNewsList();
 } else {
 autoLoadImages_ = mainWindow_->autoLoadImages_;
 }
createWebWidget();

if (type_ != TabTypeWeb) {
 newsTabWidgetSplitter_ = newQSplitter(this);
 newsTabWidgetSplitter_->setObjectName("newsTabWidgetSplitter");

if ((mainWindow_->browserPosition_ == TOP_POSITION) ||
 (mainWindow_->browserPosition_ == LEFT_POSITION)) {
 newsTabWidgetSplitter_->addWidget(webWidget_);
 newsTabWidgetSplitter_->addWidget(newsWidget_);
 } else {
 newsTabWidgetSplitter_->addWidget(newsWidget_);
 newsTabWidgetSplitter_->addWidget(webWidget_);
 }
 }
 }

 QVBoxLayout *layout = newQVBoxLayout();
 layout->setMargin(0);
 layout->setSpacing(0);
if (type_ == TabTypeDownloads)
 layout->addWidget(mainApp->downloadManager());
elseif (type_ != TabTypeWeb)
 layout->addWidget(newsTabWidgetSplitter_);
else
 layout->addWidget(webWidget_);
setLayout(layout);

if (type_ < TabTypeWeb) {
 newsTabWidgetSplitter_->setHandleWidth(1);

if ((mainWindow_->browserPosition_ == RIGHT_POSITION) ||
 (mainWindow_->browserPosition_ == LEFT_POSITION)) {
 newsTabWidgetSplitter_->setOrientation(Qt::Horizontal);
 newsTabWidgetSplitter_->setStyleSheet(
QString("QSplitter::handle {background: qlineargradient("
"x1: 0, y1: 0, x2: 0, y2: 1,"
"stop: 0 %1, stop: 0.07 %2);}").
arg(newsPanelWidget_->palette().background().color().name()).
arg(qApp->palette().color(QPalette::Dark).name()));
 } else {
 newsTabWidgetSplitter_->setOrientation(Qt::Vertical);
 newsTabWidgetSplitter_->setStyleSheet(
QString("QSplitter::handle {background: %1; margin-top: 1px; margin-bottom: 1px;}").
arg(qApp->palette().color(QPalette::Dark).name()));
 }
 }

connect(this, SIGNAL(signalSetTextTab(QString,NewsTabWidget*)),
 mainWindow_, SLOT(setTextTitle(QString,NewsTabWidget*)));
}

NewsTabWidget::~NewsTabWidget()
{
if (type_ == TabTypeDownloads) {
 mainApp->downloadManager()->hide();
 mainApp->downloadManager()->setParent(mainWindow_);
 }
}

voidNewsTabWidget::disconnectObjects()
{
disconnect(this);
if (type_ != TabTypeDownloads) {
 webView_->disconnect(this);
 webView_->disconnectObjects();
 qobject_cast<WebPage*>(webView_->page())->disconnectObjects();
 }
}

/** @brief Create news list with all related panels
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::createNewsList()
{
 newsView_ = newNewsView(this);
 newsView_->setFrameStyle(QFrame::NoFrame);
 newsModel_ = newNewsModel(this, newsView_);
 newsModel_->setTable("news");
 newsModel_->setFilter("feedId=-1");
 newsHeader_ = newNewsHeader(newsModel_, newsView_);

 newsView_->setModel(newsModel_);
 newsView_->setHeader(newsHeader_);

 newsHeader_->init();

 newsToolBar_ = newQToolBar(this);
 newsToolBar_->setObjectName("newsToolBar");
 newsToolBar_->setStyleSheet("QToolBar { border: none; padding: 0px; }");

 Settings settings;
 QString actionListStr = "markNewsRead,markAllNewsRead,Separator,markStarAct,"
"newsLabelAction,shareMenuAct,openInExternalBrowserAct,Separator,"
"nextUnreadNewsAct,prevUnreadNewsAct,Separator,"
"newsFilter,Separator,deleteNewsAct";
 QString str = settings.value("Settings/newsToolBar", actionListStr).toString();

foreach (QString actionStr, str.split(",", QString::SkipEmptyParts)) {
if (actionStr == "Separator") {
 newsToolBar_->addSeparator();
 } else {
 QListIterator<QAction *> iter(mainWindow_->actions());
while (iter.hasNext()) {
 QAction *pAction = iter.next();
if (!pAction->icon().isNull()) {
if (pAction->objectName() == actionStr) {
 newsToolBar_->addAction(pAction);
break;
 }
 }
 }
 }
 }
 separatorRAct_ = newsToolBar_->addSeparator();
 separatorRAct_->setObjectName("separatorRAct");
 newsToolBar_->addAction(mainWindow_->restoreNewsAct_);

 findText_ = newFindTextContent(this);
 findText_->setFixedWidth(200);

 QHBoxLayout *newsPanelLayout = newQHBoxLayout();
 newsPanelLayout->setMargin(2);
 newsPanelLayout->setSpacing(2);
 newsPanelLayout->addWidget(newsToolBar_);
 newsPanelLayout->addStretch(1);
 newsPanelLayout->addWidget(findText_);

 newsPanelWidget_ = newQWidget(this);
 newsPanelWidget_->setObjectName("newsPanelWidget_");
 newsPanelWidget_->setStyleSheet(
QString("#newsPanelWidget_ {border-bottom: 1px solid %1;}").
arg(qApp->palette().color(QPalette::Dark).name()));

 newsPanelWidget_->setLayout(newsPanelLayout);
if (!mainWindow_->newsToolbarToggle_->isChecked())
 newsPanelWidget_->hide();

 QVBoxLayout *newsLayout = newQVBoxLayout();
 newsLayout->setMargin(0);
 newsLayout->setSpacing(0);
 newsLayout->addWidget(newsPanelWidget_);
 newsLayout->addWidget(newsView_);

 newsWidget_ = newQWidget(this);
 newsWidget_->setLayout(newsLayout);

 markNewsReadTimer_ = newQTimer(this);

 QFile htmlFile;
 htmlFile.setFileName(":/html/newspaper_head");
 htmlFile.open(QFile::ReadOnly);
 newspaperHeadHtml_ = QString::fromUtf8(htmlFile.readAll());
 htmlFile.close();
 htmlFile.setFileName(":/html/newspaper_description");
 htmlFile.open(QFile::ReadOnly);
 newspaperHtml_ = QString::fromUtf8(htmlFile.readAll());
 htmlFile.close();
 htmlFile.setFileName(":/html/newspaper_description_rtl");
 htmlFile.open(QFile::ReadOnly);
 newspaperHtmlRtl_ = QString::fromUtf8(htmlFile.readAll());
 htmlFile.close();
 htmlFile.setFileName(":/html/description");
 htmlFile.open(QFile::ReadOnly);
 htmlString_ = QString::fromUtf8(htmlFile.readAll());
 htmlFile.close();
 htmlFile.setFileName(":/html/description_rtl");
 htmlFile.open(QFile::ReadOnly);
 htmlRtlString_ = QString::fromUtf8(htmlFile.readAll());
 htmlFile.close();

connect(newsView_, SIGNAL(pressed(QModelIndex)),
this, SLOT(slotNewsViewClicked(QModelIndex)));
connect(newsView_, SIGNAL(pressKeyUp(QModelIndex)),
this, SLOT(slotNewsUpPressed(QModelIndex)));
connect(newsView_, SIGNAL(pressKeyDown(QModelIndex)),
this, SLOT(slotNewsDownPressed(QModelIndex)));
connect(newsView_, SIGNAL(pressKeyHome(QModelIndex)),
this, SLOT(slotNewsHomePressed(QModelIndex)));
connect(newsView_, SIGNAL(pressKeyEnd(QModelIndex)),
this, SLOT(slotNewsEndPressed(QModelIndex)));
connect(newsView_, SIGNAL(pressKeyPageUp(QModelIndex)),
this, SLOT(slotNewsPageUpPressed(QModelIndex)));
connect(newsView_, SIGNAL(pressKeyPageDown(QModelIndex)),
this, SLOT(slotNewsPageDownPressed(QModelIndex)));
connect(newsView_, SIGNAL(signalSetItemRead(QModelIndex, int)),
this, SLOT(slotSetItemRead(QModelIndex, int)));
connect(newsView_, SIGNAL(signalSetItemStar(QModelIndex,int)),
this, SLOT(slotSetItemStar(QModelIndex,int)));
connect(newsView_, SIGNAL(signalDoubleClicked(QModelIndex)),
this, SLOT(slotNewsViewDoubleClicked(QModelIndex)));
connect(newsView_, SIGNAL(signalMiddleClicked(QModelIndex)),
this, SLOT(slotNewsMiddleClicked(QModelIndex)));
connect(newsView_, SIGNAL(signaNewslLabelClicked(QModelIndex)),
this, SLOT(slotNewslLabelClicked(QModelIndex)));
connect(markNewsReadTimer_, SIGNAL(timeout()),
this, SLOT(slotMarkReadTimeout()));
connect(newsView_, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(showContextMenuNews(const QPoint &)));

connect(newsModel_, SIGNAL(signalSort(int,int)),
this, SLOT(slotSort(int,int)));

connect(findText_, SIGNAL(textChanged(QString)),
this, SLOT(slotFindText(QString)));
connect(findText_, SIGNAL(signalSelectFind()),
this, SLOT(slotSelectFind()));
connect(findText_, SIGNAL(returnPressed()),
this, SLOT(slotSelectFind()));
connect(findText_, SIGNAL(signalVisible(bool)),
 mainWindow_, SLOT(findText()));

connect(mainWindow_->newsToolbarToggle_, SIGNAL(toggled(bool)),
 newsPanelWidget_, SLOT(setVisible(bool)));
}

/** @brief Call context menu of selected news in news list
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::showContextMenuNews(const QPoint &pos)
{
if (!newsView_->currentIndex().isValid()) return;

 QMenu menu;
 menu.addAction(mainWindow_->restoreNewsAct_);
 menu.addSeparator();
 menu.addAction(mainWindow_->openInBrowserAct_);
 menu.addAction(mainWindow_->openInExternalBrowserAct_);
 menu.addAction(mainWindow_->openNewsNewTabAct_);
 menu.addSeparator();
 menu.addAction(mainWindow_->markNewsRead_);
 menu.addAction(mainWindow_->markAllNewsRead_);
 menu.addSeparator();
 menu.addAction(mainWindow_->markStarAct_);
 menu.addAction(mainWindow_->newsLabelMenuAction_);
 menu.addAction(mainWindow_->shareMenuAct_);
 menu.addAction(mainWindow_->copyLinkAct_);
 menu.addSeparator();
 menu.addAction(mainWindow_->updateFeedAct_);
 menu.addSeparator();
 menu.addAction(mainWindow_->deleteNewsAct_);
 menu.addAction(mainWindow_->deleteAllNewsAct_);

 menu.exec(newsView_->viewport()->mapToGlobal(pos));
}

/** @brief Create web-widget and control panel
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::createWebWidget()
{
 webView_ = newWebView(this);

 webViewProgress_ = newQProgressBar(this);
 webViewProgress_->setObjectName("webViewProgress_");
 webViewProgress_->setFixedHeight(15);
 webViewProgress_->setMinimum(0);
 webViewProgress_->setMaximum(100);
 webViewProgress_->setVisible(true);
connect(this, SIGNAL(loadProgress(int)),
 webViewProgress_, SLOT(setValue(int)), Qt::QueuedConnection);

 webViewProgressLabel_ = newQLabel(this);
 webViewProgressLabel_->setObjectName("webViewProgressLabel_");
 webViewProgressLabel_->setStyleSheet("background: none;");
 QHBoxLayout *progressLayout = newQHBoxLayout();
 progressLayout->setMargin(0);
 progressLayout->addWidget(webViewProgressLabel_, 0, Qt::AlignLeft|Qt::AlignVCenter);
 webViewProgress_->setLayout(progressLayout);

//! Create web control panel
 webToolBar_ = newQToolBar(this);
 webToolBar_->setStyleSheet("QToolBar { border: none; padding: 0px; }");
 webToolBar_->setIconSize(QSize(18, 18));

 webHomePageAct_ = newQAction(this);
 webHomePageAct_->setIcon(QIcon(":/images/homePage"));

 webToolBar_->addAction(webHomePageAct_);
 QAction *webAction = webView_->pageAction(QWebPage::Back);
 webToolBar_->addAction(webAction);
 webAction = webView_->pageAction(QWebPage::Forward);
 webToolBar_->addAction(webAction);
 webAction = webView_->pageAction(QWebPage::Reload);
 webToolBar_->addAction(webAction);
 webAction = webView_->pageAction(QWebPage::Stop);
 webToolBar_->addAction(webAction);
 webToolBar_->addSeparator();

 webToolBar_->addAction(mainApp->mainWindow()->shareMenuAct_);

 webExternalBrowserAct_ = newQAction(this);
 webExternalBrowserAct_->setIcon(QIcon(":/images/openBrowser"));
 webToolBar_->addAction(webExternalBrowserAct_);

 locationBar_ = newLocationBar(webView_, this);

 QHBoxLayout *webControlPanelLayout = newQHBoxLayout();
 webControlPanelLayout->setMargin(2);
 webControlPanelLayout->setSpacing(2);
 webControlPanelLayout->addWidget(webToolBar_);
 webControlPanelLayout->addWidget(locationBar_, 1);

 webControlPanel_ = newQWidget(this);
 webControlPanel_->setObjectName("webControlPanel_");
 webControlPanel_->setStyleSheet(
QString("#webControlPanel_ {border-bottom: 1px solid %1;}").
arg(qApp->palette().color(QPalette::Dark).name()));
 webControlPanel_->setLayout(webControlPanelLayout);

if (type_ != TabTypeWeb)
setWebToolbarVisible(false, false);
else
setWebToolbarVisible(true, false);

//! Create web layout
 QVBoxLayout *webLayout = newQVBoxLayout();
 webLayout->setMargin(0);
 webLayout->setSpacing(0);
 webLayout->addWidget(webControlPanel_);
 webLayout->addWidget(webView_, 1);
 webLayout->addWidget(webViewProgress_);

 webWidget_ = newQWidget(this);
 webWidget_->setObjectName("webWidget_");
 webWidget_->setLayout(webLayout);
 webWidget_->setMinimumWidth(400);
 webWidget_->setMinimumHeight(100);

 webView_->page()->action(QWebPage::OpenLink)->disconnect();
 webView_->page()->action(QWebPage::OpenLinkInNewWindow)->disconnect();

 urlExternalBrowserAct_ = newQAction(this);
 urlExternalBrowserAct_->setIcon(QIcon(":/images/openBrowser"));

connect(webHomePageAct_, SIGNAL(triggered()),
this, SLOT(webHomePage()));
connect(webExternalBrowserAct_, SIGNAL(triggered()),
this, SLOT(openPageInExternalBrowser()));
connect(urlExternalBrowserAct_, SIGNAL(triggered()),
this, SLOT(openUrlInExternalBrowser()));
connect(this, SIGNAL(signalSetHtmlWebView(QString)),
SLOT(slotSetHtmlWebView(QString)), Qt::QueuedConnection);
connect(webView_, SIGNAL(loadStarted()), this, SLOT(slotLoadStarted()));
connect(webView_, SIGNAL(loadFinished(bool)), this, SLOT(slotLoadFinished(bool)));
connect(webView_, SIGNAL(linkClicked(QUrl)), this, SLOT(slotLinkClicked(QUrl)));
connect(webView_->page(), SIGNAL(linkHovered(QString,QString,QString)),
this, SLOT(slotLinkHovered(QString,QString,QString)));
connect(webView_, SIGNAL(loadProgress(int)), this, SLOT(slotSetValue(int)), Qt::QueuedConnection);

connect(webView_, SIGNAL(titleChanged(QString)),
this, SLOT(webTitleChanged(QString)));
connect(webView_->page()->action(QWebPage::OpenLink), SIGNAL(triggered()),
this, SLOT(openLink()));
connect(webView_->page()->action(QWebPage::OpenLinkInNewWindow), SIGNAL(triggered()),
this, SLOT(openLinkInNewTab()));

connect(webView_, SIGNAL(showContextMenu(QPoint)),
this, SLOT(showContextWebPage(QPoint)), Qt::QueuedConnection);
connect(webView_, SIGNAL(signalGoHome()),
this, SLOT(webHomePage()));

connect(mainWindow_->autoLoadImagesToggle_, SIGNAL(triggered()),
this, SLOT(setAutoLoadImages()));
connect(mainWindow_->browserToolbarToggle_, SIGNAL(triggered()),
this, SLOT(setWebToolbarVisible()));

connect(locationBar_, SIGNAL(returnPressed()),this, SLOT(slotUrlEnter()));
connect(webView_, SIGNAL(rssChanged(bool)), locationBar_, SLOT(showRssIcon(bool)));
connect(webView_, SIGNAL(urlChanged(QUrl)),
this, SLOT(slotUrlChanged(QUrl)), Qt::QueuedConnection);
}

/** @brief Read settings from ini-file
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::setSettings(bool init, bool newTab)
{
 Settings settings;

if (type_ == TabTypeDownloads) return;

 QString style = settings.value("Settings/styleApplication", "defaultStyle_").toString();
if (style == "darkStyle_")
 newsIconMovie_->setFileName(":/images/loading_dark");
else
 newsIconMovie_->setFileName(":/images/loading");

if (newTab) {
if (type_ < TabTypeWeb) {
 newsTabWidgetSplitter_->restoreState(settings.value("NewsTabSplitterState").toByteArray());
 QString iconStr = settings.value("Settings/newsToolBarIconSize", "toolBarIconSmall_").toString();
 mainWindow_->setToolBarIconSize(newsToolBar_, iconStr);

 newsView_->setFont(
QFont(mainWindow_->newsListFontFamily_, mainWindow_->newsListFontSize_));
 newsModel_->formatDate_ = mainWindow_->formatDate_;
 newsModel_->formatTime_ = mainWindow_->formatTime_;
 newsModel_->simplifiedDateTime_ = mainWindow_->simplifiedDateTime_;

 newsModel_->textColor_ = mainWindow_->newsListTextColor_;
 newsView_->setStyleSheet(QString("#newsView_ {background: %1;}").arg(mainWindow_->newsListBackgroundColor_));
 newsModel_->newNewsTextColor_ = mainWindow_->newNewsTextColor_;
 newsModel_->unreadNewsTextColor_ = mainWindow_->unreadNewsTextColor_;
 newsModel_->focusedNewsTextColor_ = mainWindow_->focusedNewsTextColor_;
 newsModel_->focusedNewsBGColor_ = mainWindow_->focusedNewsBGColor_;

 QString styleSheetNews = settings.value("Settings/styleSheetNews",
 mainApp->styleSheetNewsDefaultFile()).toString();
 QFile file(styleSheetNews);
if (!file.open(QFile::ReadOnly)) {
 file.setFileName(":/style/newsStyle");
 file.open(QFile::ReadOnly);
 }
 cssString_ = QString::fromUtf8(file.readAll()).
arg(mainWindow_->newsTextFontFamily_).
arg(mainWindow_->newsTextFontSize_).
arg(mainWindow_->newsTitleFontFamily_).
arg(mainWindow_->newsTitleFontSize_).
arg(0).
arg(qApp->palette().color(QPalette::Dark).name()). // color separator
arg(mainWindow_->newsBackgroundColor_). // news background
arg(mainWindow_->newsTitleBackgroundColor_). // title background
arg(mainWindow_->linkColor_). // link color
arg(mainWindow_->titleColor_). // title color
arg(mainWindow_->dateColor_). // date color
arg(mainWindow_->authorColor_). // author color
arg(mainWindow_->newsTextColor_); // text color
 file.close();

 file.setFileName(":/html/audioplayer");
 file.open(QFile::ReadOnly);
 audioPlayerHtml_ = QString::fromUtf8(file.readAll());
 file.close();

 file.setFileName(":/html/videoplayer");
 file.open(QFile::ReadOnly);
 videoPlayerHtml_ = QString::fromUtf8(file.readAll());
 file.close();
 }

if (mainWindow_->externalBrowserOn_ <= 0) {
 webView_->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
 } else {
 webView_->page()->setLinkDelegationPolicy(QWebPage::DelegateExternalLinks);
 }

 webView_->page()->action(QWebPage::Back)->setShortcut(mainWindow_->backWebPageAct_->shortcut());
 webView_->page()->action(QWebPage::Forward)->setShortcut(mainWindow_->forwardWebPageAct_->shortcut());
 webView_->page()->action(QWebPage::Reload)->setShortcut(mainWindow_->reloadWebPageAct_->shortcut());

QWebSettings::setObjectCacheCapacities(0, 0, 0);
 }

 QModelIndex feedIndex = feedsModel_->indexById(feedId_);

if (init) {
QWebSettings::clearMemoryCaches();

if (type_ == TabTypeFeed) {
int displayEmbeddedImages = feedsModel_->dataField(feedIndex, "displayEmbeddedImages").toInt();
if (displayEmbeddedImages == 2) {
 autoLoadImages_ = true;
 } elseif (displayEmbeddedImages == 1) {
 autoLoadImages_ = mainWindow_->autoLoadImages_;
 } else {
 autoLoadImages_ = false;
 }
 } else {
 autoLoadImages_ = mainWindow_->autoLoadImages_;
 }
 webView_->settings()->setAttribute(QWebSettings::AutoLoadImages, autoLoadImages_);

 webView_->setZoomFactor(qreal(mainWindow_->defaultZoomPages_)/100.0);
 }
setAutoLoadImages(false);

if (type_ == TabTypeFeed) {
int javaScriptEnable = feedsModel_->dataField(feedIndex, "javaScriptEnable").toInt();
if (javaScriptEnable == 2) {
 webView_->settings()->setAttribute(QWebSettings::JavascriptEnabled, true);
 } elseif (javaScriptEnable == 1) {
 webView_->settings()->setAttribute(QWebSettings::JavascriptEnabled, mainWindow_->javaScriptEnable_);
 } elseif (javaScriptEnable == 0) {
 webView_->settings()->setAttribute(QWebSettings::JavascriptEnabled, false);
 }

int layoutDirection = feedsModel_->dataField(feedIndex, "layoutDirection").toInt();
if (!layoutDirection) {
 newsView_->setLayoutDirection(Qt::LeftToRight);
 } else {
 newsView_->setLayoutDirection(Qt::RightToLeft);
 }
 } else {
 webView_->settings()->setAttribute(QWebSettings::JavascriptEnabled, mainWindow_->javaScriptEnable_);
 }

if (type_ < TabTypeWeb) {
 newsView_->setAlternatingRowColors(mainWindow_->alternatingRowColorsNews_);

 QPalette palette = newsView_->palette();
 palette.setColor(QPalette::AlternateBase, mainWindow_->alternatingRowColors_);
 newsView_->setPalette(palette);

if (!newTab)
 newsModel_->setFilter("feedId=-1");
 newsHeader_->setColumns(feedIndex);
 mainWindow_->slotUpdateStatus(feedId_, false);
 mainWindow_->newsFilter_->setEnabled(type_ == TabTypeFeed);
 separatorRAct_->setVisible(type_ == TabTypeDel);
 mainWindow_->restoreNewsAct_->setVisible(type_ == TabTypeDel);

switch (mainWindow_->newsLayout_) {
case1:
 newsWidget_->setVisible(false);
break;
default:
 newsWidget_->setVisible(true);
 }
 }
}

/** @brief Reload translation
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::retranslateStrings() {
if (type_ != TabTypeDownloads) {
 webViewProgress_->setFormat(tr("Loading... (%p%)"));

 webHomePageAct_->setText(tr("Home"));
 webExternalBrowserAct_->setText(tr("Open Page in External Browser"));
 urlExternalBrowserAct_->setText(tr("Open Link in External Browser"));

if (type_ != TabTypeWeb) {
 findText_->retranslateStrings();
 newsHeader_->retranslateStrings();
 }

if (mainWindow_->currentNewsTab == this) {
if (autoLoadImages_) {
 mainWindow_->autoLoadImagesToggle_->setText(tr("Load Images"));
 mainWindow_->autoLoadImagesToggle_->setToolTip(tr("Auto Load Images to News View"));
 } else {
 mainWindow_->autoLoadImagesToggle_->setText(tr("No Load Images"));
 mainWindow_->autoLoadImagesToggle_->setToolTip(tr("No Load Images to News View"));
 }
 }
 }

 closeButton_->setToolTip(tr("Close Tab"));
}

voidNewsTabWidget::setAutoLoadImages(bool apply)
{
if (type_ == NewsTabWidget::TabTypeDownloads) return;
if (mainWindow_->currentNewsTab != this) return;

if (apply)
 autoLoadImages_ = !autoLoadImages_;

if (autoLoadImages_) {
 mainWindow_->autoLoadImagesToggle_->setText(tr("Load Images"));
 mainWindow_->autoLoadImagesToggle_->setToolTip(tr("Auto Load Images in News View"));
 mainWindow_->autoLoadImagesToggle_->setIcon(QIcon(":/images/imagesOn"));
 } else {
 mainWindow_->autoLoadImagesToggle_->setText(tr("Don't Load Images"));
 mainWindow_->autoLoadImagesToggle_->setToolTip(tr("Don't Load Images in News View"));
 mainWindow_->autoLoadImagesToggle_->setIcon(QIcon(":/images/imagesOff"));
 }

if (apply) {
 webView_->settings()->setAttribute(QWebSettings::AutoLoadImages, autoLoadImages_);
if (autoLoadImages_) {
if ((webView_->title() == "news_descriptions") &&
 (type_ == NewsTabWidget::TabTypeFeed)) {
switch (mainWindow_->newsLayout_) {
case1:
loadNewspaper();
break;
default:
updateWebView(newsView_->currentIndex());
 }
 } else {
 webView_->reload();
 }
 }
 }
}

/** @brief Process mouse click in news list
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::slotNewsViewClicked(QModelIndex index)
{
slotNewsViewSelected(index);
}

// ----------------------------------------------------------------------------
voidNewsTabWidget::slotNewsViewSelected(QModelIndex index, bool clicked)
{
if (mainWindow_->newsLayout_ == 1) return;

int newsId = newsModel_->dataField(index.row(), "id").toInt();
if (mainWindow_->markNewsReadOn_ && mainWindow_->markPrevNewsRead_ &&
 (newsId != currentNewsIdOld)) {
 QModelIndex startIndex = newsModel_->index(0, newsModel_->fieldIndex("id"));
 QModelIndexList indexList = newsModel_->match(startIndex, Qt::EditRole, currentNewsIdOld);
if (!indexList.isEmpty()) {
slotSetItemRead(indexList.first(), 1);
 }
 }

if (!index.isValid()) {
hideWebContent();
 currentNewsIdOld = newsId;
return;
 }

if (!((newsId == currentNewsIdOld) &&
 newsModel_->dataField(index.row(), "read").toInt() >= 1) ||
 clicked) {
 markNewsReadTimer_->stop();
if (mainWindow_->markNewsReadOn_ && mainWindow_->markCurNewsRead_) {
if (mainWindow_->markNewsReadTime_ == 0) {
slotSetItemRead(index, 1);
 } else {
 markNewsReadTimer_->start(mainWindow_->markNewsReadTime_*1000);
 }
 }

if (type_ == TabTypeFeed) {
// Write current news to feed
 QString qStr = QString("UPDATE feeds SET currentNews='%1' WHERE id=='%2'").
arg(newsId).arg(feedId_);
 mainApp->sqlQueryExec(qStr);

 QModelIndex feedIndex = feedsModel_->indexById(feedId_);
 feedsModel_->setData(feedsModel_->indexSibling(feedIndex, "currentNews"), newsId);
 } elseif (type_ == TabTypeLabel) {
 QString qStr = QString("UPDATE labels SET currentNews='%1' WHERE id=='%2'").
arg(newsId).
arg(mainWindow_->categoriesTree_->currentItem()->text(2).toInt());
 mainApp->sqlQueryExec(qStr);

 mainWindow_->categoriesTree_->currentItem()->setText(3, QString::number(newsId));
 }

updateWebView(index);
 mainWindow_->statusBar()->showMessage(linkNewsString_, 3000);
 }
 currentNewsIdOld = newsId;
}

// ----------------------------------------------------------------------------
voidNewsTabWidget::slotNewsViewDoubleClicked(QModelIndex index)
{
if (!index.isValid()) return;

 QUrl url = QUrl::fromEncoded(getLinkNews(index.row()).toUtf8());
slotLinkClicked(url);
}

// ----------------------------------------------------------------------------
voidNewsTabWidget::slotNewsMiddleClicked(QModelIndex index)
{
if (!index.isValid()) return;

if (mainWindow_->markNewsReadOn_ && mainWindow_->markCurNewsRead_)
slotSetItemRead(index, 1);

if (QApplication::keyboardModifiers() == Qt::NoModifier) {
 webView_->buttonClick_ = MIDDLE_BUTTON;
 } elseif (QApplication::keyboardModifiers() == Qt::AltModifier) {
 webView_->buttonClick_ = LEFT_BUTTON_ALT;
 } else {
 webView_->buttonClick_ = MIDDLE_BUTTON_MOD;
 }

 QUrl url = QUrl::fromEncoded(getLinkNews(index.row()).toUtf8());
slotLinkClicked(url);
}

/** @brief Process pressing UP-key
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::slotNewsUpPressed(QModelIndex index)
{
if (type_ >= TabTypeWeb) return;

int row;
if (!index.isValid()) {
if (!newsView_->currentIndex().isValid())
 row = 0;
else
 row = newsView_->currentIndex().row() - 1;
if (row < 0)
return;
index = newsModel_->index(row, newsModel_->fieldIndex("title"));
 newsView_->setCurrentIndex(index);
 } else {
 row = index.row();
 }

int value = newsView_->verticalScrollBar()->value();
int pageStep = newsView_->verticalScrollBar()->pageStep();
if (row < (value + pageStep/2))
 newsView_->verticalScrollBar()->setValue(row - pageStep/2);

slotNewsViewSelected(index);
}

/** @brief Process pressing DOWN-key
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::slotNewsDownPressed(QModelIndex index)
{
if (type_ >= TabTypeWeb) return;

int row;
if (!index.isValid()) {
if (!newsView_->currentIndex().isValid())
 row = 0;
else
 row = newsView_->currentIndex().row() + 1;
if (row >= newsModel_->rowCount())
return;
index = newsModel_->index(row, newsModel_->fieldIndex("title"));
 newsView_->setCurrentIndex(index);
 } else {
 row = index.row();
 }

int value = newsView_->verticalScrollBar()->value();
int pageStep = newsView_->verticalScrollBar()->pageStep();
if (row > (value + pageStep/2))
 newsView_->verticalScrollBar()->setValue(row - pageStep/2);
slotNewsViewSelected(index);
}

/** @brief Process pressing HOME-key
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::slotNewsHomePressed(QModelIndex index)
{
slotNewsViewSelected(index);
}

/** @brief Process pressing END-key
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::slotNewsEndPressed(QModelIndex index)
{
slotNewsViewSelected(index);
}

/** @brief Process pressing PageUp-key
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::slotNewsPageUpPressed(QModelIndex index)
{
int row;
if (!index.isValid()) {
if (!newsView_->currentIndex().isValid())
 row = 0;
else
 row = newsView_->currentIndex().row() - newsView_->verticalScrollBar()->pageStep();
if (row < 0)
 row = 0;
index = newsModel_->index(row, newsModel_->fieldIndex("title"));
 newsView_->setCurrentIndex(index);
 }

slotNewsViewSelected(index);
}

/** @brief Process pressing PageDown-key
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::slotNewsPageDownPressed(QModelIndex index)
{
int row;
if (!index.isValid()) {
if (!newsView_->currentIndex().isValid())
 row = 0;
else
 row = newsView_->currentIndex().row() + newsView_->verticalScrollBar()->pageStep();
if (row >= newsModel_->rowCount())
 row = newsModel_->rowCount()-1;
index = newsModel_->index(row, newsModel_->fieldIndex("title"));
 newsView_->setCurrentIndex(index);
 }

slotNewsViewSelected(index);
}

/** @brief Mark news Read
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::slotSetItemRead(QModelIndex index, int read)
{
 markNewsReadTimer_->stop();
if (!index.isValid() || (newsModel_->rowCount() == 0)) return;

bool changed = false;
int newsId = newsModel_->dataField(index.row(), "id").toInt();

if (read == 1) {
if (newsModel_->dataField(index.row(), "new").toInt() == 1) {
 newsModel_->setData(
 newsModel_->index(index.row(), newsModel_->fieldIndex("new")),
0);
 mainApp->sqlQueryExec(QString("UPDATE news SET new=0 WHERE id=='%1'").arg(newsId));
 }
if (newsModel_->dataField(index.row(), "read").toInt() == 0) {
 newsModel_->setData(
 newsModel_->index(index.row(), newsModel_->fieldIndex("read")),
1);
 mainApp->sqlQueryExec(QString("UPDATE news SET read=1 WHERE id=='%1'").arg(newsId));
 changed = true;
 }
 } else {
if (newsModel_->dataField(index.row(), "read").toInt() != 0) {
 newsModel_->setData(
 newsModel_->index(index.row(), newsModel_->fieldIndex("read")),
0);
 mainApp->sqlQueryExec(QString("UPDATE news SET read=0 WHERE id=='%1'").arg(newsId));
 changed = true;
 }
 }

if (changed) {
 newsView_->viewport()->update();
int feedId = newsModel_->dataField(index.row(), "feedId").toInt();
 mainWindow_->slotUpdateStatus(feedId);
 mainWindow_->recountCategoryCounts();
 }
}

/** @brief Mark news Star
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::slotSetItemStar(QModelIndex index, int starred)
{
if (!index.isValid()) return;

 newsModel_->setData(index, starred);

int newsId = newsModel_->dataField(index.row(), "id").toInt();
 mainApp->sqlQueryExec(QString("UPDATE news SET starred='%1' WHERE id=='%2'").
arg(starred).arg(newsId));
 mainWindow_->recountCategoryCounts();
}

voidNewsTabWidget::slotMarkReadTimeout()
{
slotSetItemRead(newsView_->currentIndex(), 1);
}

/** @brief Mark selected news Read
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::markNewsRead()
{
if (type_ >= TabTypeWeb) return;
 markNewsReadTimer_->stop();

 QModelIndex curIndex;
 QList<QModelIndex> indexes = newsView_->selectionModel()->selectedRows(0);

int cnt = indexes.count();
if (cnt == 0) return;

if (cnt == 1) {
 curIndex = indexes.at(0);
if (newsModel_->dataField(curIndex.row(), "read").toInt() == 0) {
slotSetItemRead(curIndex, 1);
 } else {
slotSetItemRead(curIndex, 0);
 }
 } else {
 QStringList feedIdList;

bool markRead = false;
for (int i = cnt-1; i >= 0; --i) {
 curIndex = indexes.at(i);
if (newsModel_->dataField(curIndex.row(), "read").toInt() == 0) {
 markRead = true;
break;
 }
 }

 db_.transaction();
 QSqlQuery q;
for (int i = cnt-1; i >= 0; --i) {
 curIndex = indexes.at(i);
 newsModel_->setData(
 newsModel_->index(curIndex.row(), newsModel_->fieldIndex("new")),
0);
 newsModel_->setData(
 newsModel_->index(curIndex.row(), newsModel_->fieldIndex("read")),
 markRead);

int newsId = newsModel_->dataField(curIndex.row(), "id").toInt();
 q.exec(QString("UPDATE news SET new=0, read='%1' WHERE id=='%2'").
arg(markRead).arg(newsId));
 QString feedId = newsModel_->dataField(curIndex.row(), "feedId").toString();
if (!feedIdList.contains(feedId)) feedIdList.append(feedId);
 }
 db_.commit();

foreach (QString feedId, feedIdList) {
 mainWindow_->slotUpdateStatus(feedId.toInt());
 }
 mainWindow_->recountCategoryCounts();
 newsView_->viewport()->update();
 }
}

/** @brief Mark all news of the feed Read
 *----------------------------------------------------------------------------*/
voidNewsTabWidget::markAllNewsRead()
{
if (type_ >= TabTypeWeb) return;
 markNewsReadTimer_->stop();