File indexing completed on 2024-04-28 17:05:55

 /*
     SPDX-FileCopyrightText: 2002 Shie Erlich <erlich@users.sourceforge.net>
     SPDX-FileCopyrightText: 2002 Rafi Yanai <yanai@users.sourceforge.net>
     SPDX-FileCopyrightText: 2004-2022 Krusader Krew <https://krusader.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "popularurls.h"
 
 #include <stdio.h>
 
 // QtCore
 #include <QList>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QGridLayout>
 #include <QHeaderView>
 #include <QLabel>
 #include <QLayout>
 #include <QPushButton>
 #include <QToolButton>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KItemViews/KTreeWidgetSearchLine>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "../GUI/krtreewidget.h"
 #include "../icon.h"
 #include "../krglobal.h"
 #include "../krslots.h"
 
 #define STARTING_RANK 20
 #define INCREASE 2
 #define DECREASE 1
 
 PopularUrls::PopularUrls(QObject *parent)
     : QObject(parent)
     , head(nullptr)
     , tail(nullptr)
     , count(0)
 {
     dlg = new PopularUrlsDlg();
 }
 
 PopularUrls::~PopularUrls()
 {
     clearList();
     delete dlg;
 }
 
 void PopularUrls::clearList()
 {
     if (head) {
         UrlNodeP p = head, tmp;
         while (p) {
             tmp = p;
             p = p->next;
             delete tmp;
         }
     }
     ranks.clear();
     head = tail = nullptr;
 }
 
 void PopularUrls::save()
 {
     KConfigGroup svr(krConfig, "Private");
     // prepare the string list containing urls and int list with ranks
     QStringList urlList;
     QList<int> rankList;
     UrlNodeP p = head;
     while (p) {
         urlList << p->url.toDisplayString();
         rankList << p->rank;
         p = p->next;
     }
     svr.writeEntry("PopularUrls", urlList);
     svr.writeEntry("PopularUrlsRank", rankList);
 }
 
 void PopularUrls::load()
 {
     KConfigGroup svr(krConfig, "Private");
     QStringList urlList = svr.readEntry("PopularUrls", QStringList());
     QList<int> rankList = svr.readEntry("PopularUrlsRank", QList<int>());
     if (urlList.count() != rankList.count()) {
         KMessageBox::error(krMainWindow, i18n("The saved 'Popular URLs' are invalid. The list will be cleared."));
         return;
     }
     clearList();
     count = 0;
     // iterate through both lists and
     QStringList::Iterator uit;
     QList<int>::Iterator rit;
     for (uit = urlList.begin(), rit = rankList.begin(); uit != urlList.end() && rit != rankList.end(); ++uit, ++rit) {
         auto node = new UrlNode;
         node->url = QUrl(*uit);
         node->rank = *rit;
         appendNode(node);
         ranks.insert(*uit, node);
     }
 }
 
 // returns a url list with the 'max' top popular urls
 QList<QUrl> PopularUrls::getMostPopularUrls(int max)
 {
     // get at most 'max' urls
     QList<QUrl> list;
     UrlNodeP p = head;
     int tmp = 0;
     if (maxUrls < max)
         max = maxUrls; // don't give more than maxUrls
     while (p && tmp < max) {
         list << p->url;
         p = p->next;
         ++tmp;
     }
 
     return list;
 }
 
 // adds a url to the list, or increase rank of an existing url, making
 // sure to bump it up the list if needed
 void PopularUrls::addUrl(const QUrl &url)
 {
     QUrl tmpurl = url;
     tmpurl.setPassword(QString()); // make sure no passwords are permanently stored
     if (!tmpurl.path().endsWith('/')) // make a uniform trailing slash policy
         tmpurl.setPath(tmpurl.path() + '/');
     UrlNodeP pnode;
 
     decreaseRanks();
     if (!head) { // if the list is empty ... (assumes dict to be empty as well)
         pnode = new UrlNode;
         pnode->rank = STARTING_RANK;
         pnode->url = tmpurl;
         appendNode(pnode);
         ranks.insert(tmpurl.url(), head);
     } else {
         if (ranks.find(tmpurl.url()) == ranks.end()) { // is the added url new? if so, append it
             pnode = new UrlNode;
             pnode->rank = STARTING_RANK;
             pnode->url = tmpurl;
             appendNode(pnode);
             ranks.insert(tmpurl.url(), pnode);
         } else {
             pnode = ranks[tmpurl.url()];
             pnode->rank += INCREASE;
         }
     }
 
     // do we need to change location for this one?
     relocateIfNeeded(pnode);
 
     // too many urls?
     if (count > maxUrls)
         removeNode(tail);
 
     // dumpList();
 }
 
 // checks if 'node' needs to be bumped-up the ranking list and does it if needed
 void PopularUrls::relocateIfNeeded(UrlNodeP node)
 {
     if (node->prev && (node->prev->rank < node->rank)) {
         // iterate until we find the correct place to put it
         UrlNodeP tmp = node->prev->prev;
         while (tmp) {
             if (tmp->rank >= node->rank)
                 break; // found it!
             else
                 tmp = tmp->prev;
         }
         // now, if tmp isn't null, we need to move node to tmp->next
         // else move it to become head
         removeNode(node);
         insertNode(node, tmp);
     }
 }
 
 // iterate over the list, decreasing each url's rank
 // this is very naive, but a 1..30 for loop is acceptable (i hope)
 void PopularUrls::decreaseRanks()
 {
     if (head) {
         UrlNodeP p = head;
         while (p) {
             if (p->rank - DECREASE >= 0)
                 p->rank -= DECREASE;
             else
                 p->rank = 0;
             p = p->next;
         }
     }
 }
 
 // removes a node from the list, but doesn't free memory!
 // note: this will be buggy in case the list becomes empty (which should never happen)
 void PopularUrls::removeNode(UrlNodeP node)
 {
     if (node->prev) {
         if (tail == node)
             tail = node->prev;
         node->prev->next = node->next;
     }
     if (node->next) {
         if (head == node)
             head = node->next;
         node->next->prev = node->prev;
     }
     --count;
 }
 
 void PopularUrls::insertNode(UrlNodeP node, UrlNodeP after)
 {
     if (!after) { // make node head
         node->next = head;
         node->prev = nullptr;
         head->prev = node;
         head = node;
     } else {
         if (tail == after)
             tail = node;
         node->prev = after;
         node->next = after->next;
         if (node->next) {
             after->next->prev = node;
             after->next = node;
         }
     }
     ++count;
 }
 
 // appends 'node' to the end of the list, collecting garbage if needed
 void PopularUrls::appendNode(UrlNodeP node)
 {
     if (!tail) { // creating the first element
         head = tail = node;
         node->prev = node->next = nullptr;
     } else {
         node->next = nullptr;
         node->prev = tail;
         tail->next = node;
         tail = node;
     }
     ++count;
 }
 
 void PopularUrls::dumpList()
 {
     UrlNodeP p = head;
     printf("====start %d====\n", count);
     while (p) {
         printf("%d : %s\n", p->rank, p->url.url().toLatin1().data());
         p = p->next;
     }
     fflush(stdout);
 }
 
 void PopularUrls::showDialog()
 {
     QList<QUrl> list = getMostPopularUrls(maxUrls);
     dlg->run(list);
     if (dlg->result() == -1)
         return;
     SLOTS->refresh(list[dlg->result()]);
     // printf("running %s\n", list[dlg->result()].url().toLatin1());fflush(stdout);
 }
 
 // ===================================== PopularUrlsDlg ======================================
 PopularUrlsDlg::PopularUrlsDlg()
     : QDialog(krMainWindow)
 {
     setWindowTitle(i18n("Popular URLs"));
     setWindowModality(Qt::WindowModal);
 
     auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     auto *layout = new QGridLayout;
     layout->setContentsMargins(0, 0, 0, 0);
 
     // listview to contain the urls
     urls = new KrTreeWidget(this);
     urls->header()->hide();
     urls->setSortingEnabled(false);
     urls->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 
     // quick search
     search = new KTreeWidgetSearchLine(this, urls);
     QLabel *lbl = new QLabel(i18n("&Search:"), this);
     lbl->setBuddy(search);
 
     layout->addWidget(lbl, 0, 0);
     layout->addWidget(search, 0, 1);
     layout->addWidget(urls, 1, 0, 1, 2);
 
     mainLayout->addLayout(layout);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     setTabOrder(search, urls);
     setTabOrder((QWidget *)urls, buttonBox->button(QDialogButtonBox::Close));
 
     connect(buttonBox, &QDialogButtonBox::rejected, this, &PopularUrlsDlg::reject);
     connect(urls, &KrTreeWidget::activated, this, &PopularUrlsDlg::slotItemSelected);
     connect(search, &KTreeWidgetSearchLine::hiddenChanged, this, &PopularUrlsDlg::slotVisibilityChanged);
 }
 
 void PopularUrlsDlg::slotItemSelected(const QModelIndex &ndx)
 {
     selection = ndx.row();
     accept();
 }
 
 void PopularUrlsDlg::slotVisibilityChanged()
 {
     // select the first visible item
     QList<QTreeWidgetItem *> list = urls->selectedItems();
     if (list.count() > 0 && !list[0]->isHidden())
         return;
 
     urls->clearSelection();
     urls->setCurrentItem(nullptr);
 
     QTreeWidgetItemIterator it(urls);
     while (*it) {
         if (!(*it)->isHidden()) {
             (*it)->setSelected(true);
             urls->setCurrentItem(*it);
             break;
         }
         it++;
     }
 }
 
 PopularUrlsDlg::~PopularUrlsDlg()
 {
     delete search;
     delete urls;
 }
 
 void PopularUrlsDlg::run(QList<QUrl> list)
 {
     // populate the listview
     urls->clear();
     QList<QUrl>::Iterator it;
 
     QTreeWidgetItem *lastItem = nullptr;
 
     for (it = list.begin(); it != list.end(); ++it) {
         auto *item = new QTreeWidgetItem(urls, lastItem);
         lastItem = item;
         item->setText(0, (*it).isLocalFile() ? (*it).path() : (*it).toDisplayString());
         item->setIcon(0, (*it).isLocalFile() ? Icon("folder") : Icon("folder-html"));
     }
 
     setMinimumSize(urls->sizeHint().width() + 45, 400);
 
     search->clear();
     search->setFocus();
     selection = -1;
     slotVisibilityChanged();
     exec();
 }