smb4k/smb4k/smb4kconfigpagebookmarks.cpp

0001 /*
0002     The configuration page for bookmarks
0003
0004     SPDX-FileCopyrightText: 2023 Alexander Reinholdt <alexander.reinholdt@kdemail.net>
0005     SPDX-License-Identifier: GPL-2.0-or-later
0006 */
0007
0008 // application specific includes
0009 #include "smb4kconfigpagebookmarks.h"
0010 #include "core/smb4kbookmarkhandler.h"
0011
0012 // Qt includes
0013 #include <QDialogButtonBox>
0014 #include <QGridLayout>
0015 #include <QHBoxLayout>
0016 #include <QHostAddress>
0017 #include <QKeyEvent>
0018 #include <QMouseEvent>
0019 #include <QTimer>
0020 #include <QUrl>
0021 #include <QVBoxLayout>
0022
0023 // KF includes
0024 #include <KIconLoader>
0025 #include <KLocalizedString>
0026
0027 Smb4KConfigPageBookmarks::Smb4KConfigPageBookmarks(QWidget *parent)
0028     : QWidget(parent)
0029 {
0030     m_bookmarksChanged = false;
0031     m_savingBookmarks = false;
0032
0033     QHBoxLayout *layout = new QHBoxLayout(this);
0034     QVBoxLayout *leftLayout = new QVBoxLayout();
0035
0036     m_treeWidget = new QTreeWidget(this);
0037     m_treeWidget->headerItem()->setHidden(true);
0038     m_treeWidget->setColumnCount(1);
0039     m_treeWidget->setRootIsDecorated(false);
0040     m_treeWidget->setSelectionMode(QTreeWidget::SingleSelection);
0041     m_treeWidget->setItemsExpandable(false);
0042     m_treeWidget->setDragEnabled(true);
0043     m_treeWidget->setDragDropMode(QTreeWidget::InternalMove);
0044     m_treeWidget->setDropIndicatorShown(true);
0045     m_treeWidget->installEventFilter(this);
0046     m_treeWidget->viewport()->installEventFilter(this);
0047
0048     connect(m_treeWidget, &QTreeWidget::currentItemChanged, this, &Smb4KConfigPageBookmarks::slotCurrentItemChanged);
0049     connect(m_treeWidget, &QTreeWidget::itemSelectionChanged, this, &Smb4KConfigPageBookmarks::slotItemSelectionChanged);
0050     connect(m_treeWidget, &QTreeWidget::itemDoubleClicked, this, &Smb4KConfigPageBookmarks::slotItemDoubleClicked);
0051
0052     m_editorWidget = new QWidget(this);
0053     m_editorWidget->setVisible(false);
0054
0055     QGridLayout *editorWidgetLayout = new QGridLayout(m_editorWidget);
0056     editorWidgetLayout->setContentsMargins(0, 0, 0, 0);
0057
0058     m_labelLabel = new QLabel(i18n("Label:"), m_editorWidget);
0059     m_labelEdit = new KLineEdit(m_editorWidget);
0060     m_labelEdit->setClearButtonEnabled(true);
0061     m_labelEdit->setCompletionMode(KCompletion::CompletionNone);
0062
0063     connect(m_labelEdit, &KLineEdit::textChanged, this, &Smb4KConfigPageBookmarks::slotLabelChanged);
0064     connect(m_labelEdit, &KLineEdit::editingFinished, this, &Smb4KConfigPageBookmarks::slotLabelEdited);
0065
0066     m_categoryLabel = new QLabel(i18n("Category:"), m_editorWidget);
0067     m_categoryEdit = new KComboBox(m_editorWidget);
0068     m_categoryEdit->setEditable(true);
0069     m_categoryEdit->lineEdit()->setClearButtonEnabled(true);
0070     m_categoryEdit->setCompletionMode(KCompletion::CompletionNone);
0071
0072     connect(m_categoryEdit->lineEdit(), &KLineEdit::textChanged, this, &Smb4KConfigPageBookmarks::slotCategoryChanged);
0073     connect(m_categoryEdit->lineEdit(), &QLineEdit::editingFinished, this, &Smb4KConfigPageBookmarks::slotCategoryEdited);
0074
0075     m_userNameLabel = new QLabel(i18n("Username:"), m_editorWidget);
0076     m_userNameEdit = new KLineEdit(m_editorWidget);
0077     m_userNameEdit->setObjectName(QStringLiteral("UserNameEdit"));
0078     m_userNameEdit->setClearButtonEnabled(true);
0079     m_userNameEdit->setCompletionMode(KCompletion::CompletionNone);
0080
0081     connect(m_userNameEdit, &KLineEdit::textChanged, this, &Smb4KConfigPageBookmarks::slotUserNameChanged);
0082     connect(m_userNameEdit, &KLineEdit::editingFinished, this, &Smb4KConfigPageBookmarks::slotUserNameEdited);
0083
0084     m_workgroupLabel = new QLabel(i18n("Workgroup:"), m_editorWidget);
0085     m_workgroupEdit = new KLineEdit(m_editorWidget);
0086     m_workgroupEdit->setClearButtonEnabled(true);
0087     m_workgroupEdit->setCompletionMode(KCompletion::CompletionNone);
0088
0089     connect(m_workgroupEdit, &KLineEdit::textChanged, this, &Smb4KConfigPageBookmarks::slotWorkgroupChanged);
0090     connect(m_workgroupEdit, &KLineEdit::editingFinished, this, &Smb4KConfigPageBookmarks::slotWorkgroupEdited);
0091
0092     m_ipAddressLabel = new QLabel(i18n("IP Address:"), m_editorWidget);
0093     m_ipAddressEdit = new KLineEdit(m_editorWidget);
0094     m_ipAddressEdit->setClearButtonEnabled(true);
0095     m_ipAddressEdit->setCompletionMode(KCompletion::CompletionNone);
0096     // FIXME: Do we need an input mask?
0097
0098     connect(m_ipAddressEdit, &KLineEdit::textChanged, this, &Smb4KConfigPageBookmarks::slotIpAddressChanged);
0099     connect(m_ipAddressEdit, &KLineEdit::editingFinished, this, &Smb4KConfigPageBookmarks::slotIpAddressEdited);
0100
0101     editorWidgetLayout->addWidget(m_labelLabel, 0, 0);
0102     editorWidgetLayout->addWidget(m_labelEdit, 0, 1);
0103     editorWidgetLayout->addWidget(m_categoryLabel, 1, 0);
0104     editorWidgetLayout->addWidget(m_categoryEdit, 1, 1);
0105     editorWidgetLayout->addWidget(m_userNameLabel, 2, 0);
0106     editorWidgetLayout->addWidget(m_userNameEdit, 2, 1);
0107     editorWidgetLayout->addWidget(m_workgroupLabel, 3, 0);
0108     editorWidgetLayout->addWidget(m_workgroupEdit, 3, 1);
0109     editorWidgetLayout->addWidget(m_ipAddressLabel, 4, 0);
0110     editorWidgetLayout->addWidget(m_ipAddressEdit, 4, 1);
0111
0112     leftLayout->addWidget(m_treeWidget);
0113     leftLayout->addWidget(m_editorWidget);
0114
0115     layout->addLayout(leftLayout);
0116
0117     QDialogButtonBox *buttonBox = new QDialogButtonBox(Qt::Vertical, this);
0118
0119     m_resetButton = buttonBox->addButton(QDialogButtonBox::Reset);
0120     m_resetButton->setEnabled(false);
0121     m_resetButton->setObjectName(QStringLiteral("ResetButton"));
0122
0123     connect(m_resetButton, &QPushButton::clicked, this, &Smb4KConfigPageBookmarks::slotResetButtonClicked);
0124
0125     m_editButton = buttonBox->addButton(i18n("Edit"), QDialogButtonBox::ActionRole);
0126     m_editButton->setIcon(KDE::icon(QStringLiteral("bookmark-edit")));
0127     m_editButton->setEnabled(false);
0128
0129     connect(m_editButton, &QPushButton::clicked, this, &Smb4KConfigPageBookmarks::slotEditButtonClicked);
0130
0131     m_addCategoryButton = buttonBox->addButton(i18n("Add Category"), QDialogButtonBox::ActionRole);
0132     m_addCategoryButton->setIcon(KDE::icon(QStringLiteral("bookmark-add-folder")));
0133     m_addCategoryButton->setEnabled(!Smb4KBookmarkHandler::self()->bookmarkList().isEmpty());
0134
0135     connect(m_addCategoryButton, &QPushButton::clicked, this, &Smb4KConfigPageBookmarks::slotAddCategoryButtonClicked);
0136
0137     m_removeButton = buttonBox->addButton(i18n("Remove"), QDialogButtonBox::ActionRole);
0138     m_removeButton->setIcon(KDE::icon(QStringLiteral("bookmark-remove")));
0139     m_removeButton->setEnabled(false);
0140
0141     connect(m_removeButton, &QPushButton::clicked, this, &Smb4KConfigPageBookmarks::slotRemoveButtonClicked);
0142
0143     m_clearButton = buttonBox->addButton(i18n("Clear List"), QDialogButtonBox::ActionRole);
0144     m_clearButton->setIcon(KDE::icon(QStringLiteral("edit-clear")));
0145     m_clearButton->setEnabled(!Smb4KBookmarkHandler::self()->bookmarkList().isEmpty());
0146
0147     connect(m_clearButton, &QPushButton::clicked, this, &Smb4KConfigPageBookmarks::slotClearButtonClicked);
0148
0149     layout->addWidget(buttonBox);
0150
0151     loadBookmarks();
0152
0153     connect(this, &Smb4KConfigPageBookmarks::bookmarksModified, this, &Smb4KConfigPageBookmarks::slotEnableButtons);
0154     connect(Smb4KBookmarkHandler::self(), &Smb4KBookmarkHandler::updated, this, &Smb4KConfigPageBookmarks::loadBookmarks);
0155     connect(KIconLoader::global(), &KIconLoader::iconChanged, this, &Smb4KConfigPageBookmarks::slotIconSizeChanged);
0156 }
0157
0158 Smb4KConfigPageBookmarks::~Smb4KConfigPageBookmarks()
0159 {
0160 }
0161
0162 void Smb4KConfigPageBookmarks::loadBookmarks()
0163 {
0164     if (m_savingBookmarks) {
0165         return;
0166     }
0167
0168     if (m_treeWidget->topLevelItemCount() != 0) {
0169         m_treeWidget->clear();
0170     }
0171
0172     QStringList categories = Smb4KBookmarkHandler::self()->categoryList();
0173     m_categoryEdit->addItems(categories);
0174
0175     if (!m_categoryEdit->contains(QStringLiteral(""))) {
0176         m_categoryEdit->addItem(QStringLiteral(""));
0177     }
0178
0179     for (const QString &category : qAsConst(categories)) {
0180         QList<BookmarkPtr> bookmarks = Smb4KBookmarkHandler::self()->bookmarkList(category);
0181         QTreeWidgetItem *categoryItem = nullptr;
0182
0183         if (!category.isEmpty() && !bookmarks.isEmpty()) {
0184             categoryItem = addCategoryItem(category);
0185         }
0186
0187         if (!bookmarks.isEmpty()) {
0188             for (const BookmarkPtr &bookmark : qAsConst(bookmarks)) {
0189                 QVariant variant = QVariant::fromValue(*bookmark.data());
0190                 QTreeWidgetItem *bookmarkItem = nullptr;
0191
0192                 if (categoryItem) {
0193                     bookmarkItem = new QTreeWidgetItem(categoryItem);
0194                 } else {
0195                     bookmarkItem = new QTreeWidgetItem(m_treeWidget);
0196                 }
0197
0198                 bookmarkItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled);
0199                 bookmarkItem->setText(0, bookmark->displayString());
0200                 bookmarkItem->setIcon(0, bookmark->icon());
0201                 bookmarkItem->setData(0, TypeRole, BookmarkType);
0202                 bookmarkItem->setData(0, DataRole, variant);
0203             }
0204         }
0205     }
0206
0207     sortItems();
0208
0209     for (int i = 0; i < m_treeWidget->topLevelItemCount(); ++i) {
0210         QTreeWidgetItem *item = m_treeWidget->topLevelItem(i);
0211
0212         if (item->childCount() > 0) {
0213             item->setExpanded(true);
0214         }
0215     }
0216
0217     m_bookmarksChanged = false;
0218     Q_EMIT bookmarksModified();
0219 }
0220
0221 void Smb4KConfigPageBookmarks::saveBookmarks()
0222 {
0223     if (m_bookmarksChanged) {
0224         QTreeWidgetItemIterator it(m_treeWidget, QTreeWidgetItemIterator::NoChildren);
0225         QList<BookmarkPtr> bookmarksList;
0226
0227         while (*it) {
0228             if ((*it)->data(0, TypeRole).toInt() == BookmarkType) {
0229                 BookmarkPtr bookmarkPtr = BookmarkPtr(new Smb4KBookmark((*it)->data(0, DataRole).value<Smb4KBookmark>()));
0230
0231                 if (bookmarkPtr) {
0232                     bookmarksList << bookmarkPtr;
0233                 }
0234             }
0235             ++it;
0236         }
0237
0238         m_savingBookmarks = true;
0239         Smb4KBookmarkHandler::self()->addBookmarks(bookmarksList, true);
0240         m_savingBookmarks = false;
0241
0242         m_bookmarksChanged = false;
0243         Q_EMIT bookmarksModified();
0244     }
0245 }
0246
0247 void Smb4KConfigPageBookmarks::setCompletionItems(const QMap<QString, QStringList> &items)
0248 {
0249     m_labelEdit->setCompletionMode(KCompletion::CompletionPopupAuto);
0250     m_labelEdit->completionObject()->setItems(items[QStringLiteral("LabelCompletion")]);
0251
0252     m_categoryEdit->setCompletionMode(KCompletion::CompletionPopupAuto);
0253     m_categoryEdit->completionObject()->setItems(items[QStringLiteral("CategoryCompletion")]);
0254
0255     m_userNameEdit->setCompletionMode(KCompletion::CompletionPopupAuto);
0256     m_userNameEdit->completionObject()->setItems(items[QStringLiteral("LoginCompletion")]);
0257
0258     m_ipAddressEdit->setCompletionMode(KCompletion::CompletionPopupAuto);
0259     m_ipAddressEdit->completionObject()->setItems(items[QStringLiteral("IpAddressCompletion")]);
0260
0261     m_workgroupEdit->setCompletionMode(KCompletion::CompletionPopupAuto);
0262     m_workgroupEdit->completionObject()->setItems(items[QStringLiteral("WorkgroupCompletion")]);
0263 }
0264
0265 QMap<QString, QStringList> Smb4KConfigPageBookmarks::completionItems() const
0266 {
0267     QMap<QString, QStringList> items;
0268
0269     if (m_labelEdit->completionMode() != KCompletion::CompletionNone) {
0270         items[QStringLiteral("LabelCompletion")] = m_labelEdit->completionObject()->items();
0271     }
0272
0273     if (m_categoryEdit->completionMode() != KCompletion::CompletionNone) {
0274         items[QStringLiteral("CategoryCompletion")] = m_categoryEdit->completionObject()->items();
0275     }
0276
0277     if (m_userNameEdit->completionMode() != KCompletion::CompletionNone) {
0278         items[QStringLiteral("LoginCompletion")] = m_userNameEdit->completionObject()->items();
0279     }
0280
0281     if (m_ipAddressEdit->completionMode() != KCompletion::CompletionNone) {
0282         items[QStringLiteral("IpAddressCompletion")] = m_ipAddressEdit->completionObject()->items();
0283     }
0284
0285     if (m_workgroupEdit->completionMode() != KCompletion::CompletionNone) {
0286         items[QStringLiteral("WorkgroupCompletion")] = m_workgroupEdit->completionObject()->items();
0287     }
0288
0289     return items;
0290 }
0291
0292 bool Smb4KConfigPageBookmarks::bookmarksChanged() const
0293 {
0294     return m_bookmarksChanged;
0295 }
0296
0297 QTreeWidgetItem *Smb4KConfigPageBookmarks::addCategoryItem(const QString &text)
0298 {
0299     QTreeWidgetItem *categoryItem = new QTreeWidgetItem(m_treeWidget, QTreeWidgetItem::UserType);
0300     categoryItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDropEnabled | Qt::ItemIsEnabled);
0301     categoryItem->setText(0, text);
0302     categoryItem->setIcon(0, KDE::icon(QStringLiteral("folder-favorites")));
0303     categoryItem->setData(0, TypeRole, CategoryType);
0304     categoryItem->setData(0, DataRole, text);
0305     QFont font = categoryItem->font(0);
0306     font.setBold(true);
0307     categoryItem->setFont(0, font);
0308     categoryItem->setExpanded(true);
0309
0310     return categoryItem;
0311 }
0312
0313 void Smb4KConfigPageBookmarks::startEditingCategoryItem(QTreeWidgetItem *item)
0314 {
0315     m_treeWidget->setCurrentItem(item);
0316     m_treeWidget->openPersistentEditor(item, 0);
0317     m_treeWidget->setFocus();
0318 }
0319
0320 void Smb4KConfigPageBookmarks::endEditingCategoryItem(QTreeWidgetItem *item)
0321 {
0322     if (m_treeWidget->isPersistentEditorOpen(item, 0)) {
0323         m_treeWidget->closePersistentEditor(item, 0);
0324         item->setData(0, DataRole, item->text(0));
0325
0326         if (item->childCount() != 0) {
0327             for (int i = 0; i < item->childCount(); ++i) {
0328                 Smb4KBookmark bookmark = item->child(i)->data(0, DataRole).value<Smb4KBookmark>();
0329                 bookmark.setCategoryName(item->text(0));
0330
0331                 QVariant variant = QVariant::fromValue(bookmark);
0332                 item->child(i)->setData(0, DataRole, variant);
0333             }
0334
0335             m_bookmarksChanged = true;
0336         }
0337
0338         m_categoryEdit->addItem(item->text(0));
0339         m_categoryEdit->completionObject()->addItem(item->text(0));
0340
0341         Q_EMIT bookmarksModified();
0342     }
0343 }
0344
0345 void Smb4KConfigPageBookmarks::checkValues()
0346 {
0347     if (m_treeWidget->currentItem() && m_treeWidget->currentItem()->data(0, TypeRole).toInt() == BookmarkType && m_editorWidget->isVisible()) {
0348         Smb4KBookmark bookmark = m_treeWidget->currentItem()->data(0, DataRole).value<Smb4KBookmark>();
0349
0350         if (bookmark.label() != m_labelEdit->text()) {
0351             m_bookmarksChanged = true;
0352             Q_EMIT bookmarksModified();
0353             return;
0354         }
0355
0356         if (bookmark.categoryName() != m_categoryEdit->currentText()) {
0357             m_bookmarksChanged = true;
0358             Q_EMIT bookmarksModified();
0359             return;
0360         }
0361
0362         if (bookmark.userName() != m_userNameEdit->text()) {
0363             m_bookmarksChanged = true;
0364             Q_EMIT bookmarksModified();
0365             return;
0366         }
0367
0368         if (bookmark.workgroupName() != m_workgroupEdit->text()) {
0369             m_bookmarksChanged = true;
0370             Q_EMIT bookmarksModified();
0371             return;
0372         }
0373
0374         if (bookmark.hostIpAddress() != m_ipAddressEdit->text()) {
0375             m_bookmarksChanged = true;
0376             Q_EMIT bookmarksModified();
0377             return;
0378         }
0379
0380         Q_EMIT bookmarksModified();
0381     }
0382 }
0383
0384 bool Smb4KConfigPageBookmarks::eventFilter(QObject *obj, QEvent *e)
0385 {
0386     if (obj == m_treeWidget->viewport()) {
0387         if (e->type() == QEvent::MouseButtonPress) {
0388             QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(e);
0389 #if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
0390             QPointF pos = m_treeWidget->viewport()->mapFromGlobal(mouseEvent->globalPosition());
0391             QTreeWidgetItem *item = m_treeWidget->itemAt(pos.toPoint());
0392 #else
0393             QPoint pos = m_treeWidget->viewport()->mapFromGlobal(mouseEvent->globalPos());
0394             QTreeWidgetItem *item = m_treeWidget->itemAt(pos);
0395 #endif
0396             m_editButton->setEnabled(item != nullptr);
0397             m_removeButton->setEnabled(item != nullptr);
0398
0399             if (!item) {
0400                 m_treeWidget->clearSelection();
0401             }
0402
0403             if (m_treeWidget->isPersistentEditorOpen(m_treeWidget->currentItem(), 0)) {
0404                 endEditingCategoryItem(m_treeWidget->currentItem());
0405             }
0406         }
0407     } else if (obj == m_treeWidget) {
0408         if (e->type() == QEvent::KeyPress) {
0409             QKeyEvent *keyEvent = static_cast<QKeyEvent *>(e);
0410
0411             if (keyEvent->key() == Qt::Key_Return) {
0412                 if (m_treeWidget->isPersistentEditorOpen(m_treeWidget->currentItem(), 0)) {
0413                     endEditingCategoryItem(m_treeWidget->currentItem());
0414                     return true;
0415                 }
0416             }
0417         } else if (e->type() == QEvent::ChildRemoved) {
0418             // NOTE: Occurs after a drop event on the viewport if an item was moved.
0419             // We use it to get the categories right.
0420             QTreeWidgetItemIterator it(m_treeWidget);
0421
0422             while (*it) {
0423                 if ((*it)->data(0, TypeRole).toInt() == BookmarkType) {
0424                     Smb4KBookmark bookmark = (*it)->data(0, DataRole).value<Smb4KBookmark>();
0425
0426                     if ((*it)->parent()) {
0427                         bookmark.setCategoryName((*it)->parent()->data(0, DataRole).toString());
0428                     } else {
0429                         bookmark.setCategoryName(QStringLiteral(""));
0430                     }
0431
0432                     QVariant variant = QVariant::fromValue(bookmark);
0433                     (*it)->setData(0, DataRole, variant);
0434                 }
0435
0436                 ++it;
0437             }
0438         }
0439     }
0440
0441     return QObject::eventFilter(obj, e);
0442 }
0443
0444 void Smb4KConfigPageBookmarks::slotResetButtonClicked(bool checked)
0445 {
0446     Q_UNUSED(checked);
0447     m_treeWidget->clear();
0448     loadBookmarks();
0449 }
0450
0451 void Smb4KConfigPageBookmarks::slotEditButtonClicked(bool checked)
0452 {
0453     Q_UNUSED(checked);
0454
0455     if (m_treeWidget->currentItem()) {
0456         slotItemDoubleClicked(m_treeWidget->currentItem(), 0);
0457     }
0458 }
0459
0460 void Smb4KConfigPageBookmarks::slotAddCategoryButtonClicked(bool checked)
0461 {
0462     Q_UNUSED(checked)
0463     QTreeWidgetItem *item = addCategoryItem(i18n("New Category"));
0464     startEditingCategoryItem(item);
0465 }
0466
0467 void Smb4KConfigPageBookmarks::slotRemoveButtonClicked(bool checked)
0468 {
0469     Q_UNUSED(checked);
0470
0471     if (m_treeWidget->currentItem()) {
0472         QTreeWidgetItem *parentItem = nullptr;
0473
0474         if (m_treeWidget->currentItem()->data(0, TypeRole).toInt() == BookmarkType) {
0475             parentItem = m_treeWidget->currentItem()->parent();
0476         }
0477
0478         delete m_treeWidget->currentItem();
0479         m_treeWidget->setCurrentItem(nullptr);
0480
0481         if (parentItem && parentItem->childCount() == 0) {
0482             delete parentItem;
0483         }
0484
0485         m_bookmarksChanged = true;
0486         Q_EMIT bookmarksModified();
0487     }
0488 }
0489
0490 void Smb4KConfigPageBookmarks::slotClearButtonClicked(bool checked)
0491 {
0492     Q_UNUSED(checked);
0493     m_treeWidget->clear();
0494     m_bookmarksChanged = true;
0495     Q_EMIT bookmarksModified();
0496 }
0497
0498 void Smb4KConfigPageBookmarks::slotCurrentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
0499 {
0500     Q_UNUSED(current);
0501
0502     if (m_treeWidget->isPersistentEditorOpen(previous)) {
0503         endEditingCategoryItem(previous);
0504     }
0505 }
0506
0507 void Smb4KConfigPageBookmarks::slotItemSelectionChanged()
0508 {
0509     bool enableButtons = !m_treeWidget->selectedItems().isEmpty();
0510
0511     m_editButton->setEnabled(enableButtons);
0512     m_removeButton->setEnabled(enableButtons);
0513
0514     if (m_editorWidget->isVisible()) {
0515         m_editorWidget->setVisible(false);
0516         m_labelEdit->clear();
0517         m_categoryEdit->lineEdit()->clear();
0518         m_userNameEdit->clear();
0519         m_workgroupEdit->clear();
0520         m_ipAddressEdit->clear();
0521     }
0522 }
0523
0524 void Smb4KConfigPageBookmarks::slotItemDoubleClicked(QTreeWidgetItem *item, int column)
0525 {
0526     Q_UNUSED(column);
0527
0528     if (item->data(0, TypeRole).toInt() == BookmarkType) {
0529         QString label = item->data(0, DataRole).value<Smb4KBookmark>().label();
0530         m_labelEdit->setText(label);
0531
0532         if (!m_labelEdit->completionObject()->items().contains(label)) {
0533             m_labelEdit->completionObject()->addItem(label);
0534         }
0535
0536         QString categoryName = item->data(0, DataRole).value<Smb4KBookmark>().categoryName();
0537         m_categoryEdit->setCurrentItem(categoryName, true);
0538
0539         if (!m_categoryEdit->completionObject()->items().contains(categoryName)) {
0540             m_categoryEdit->completionObject()->addItem(categoryName);
0541         }
0542
0543         QString userName = item->data(0, DataRole).value<Smb4KBookmark>().userName();
0544         m_userNameEdit->setText(userName);
0545
0546         if (!m_userNameEdit->completionObject()->items().contains(userName)) {
0547             m_userNameEdit->completionObject()->addItem(userName);
0548         }
0549
0550         QString workgroupName = item->data(0, DataRole).value<Smb4KBookmark>().workgroupName();
0551         m_workgroupEdit->setText(workgroupName);
0552
0553         if (!m_workgroupEdit->completionObject()->items().contains(workgroupName)) {
0554             m_workgroupEdit->completionObject()->addItem(workgroupName);
0555         }
0556
0557         QString hostIpAddress = item->data(0, DataRole).value<Smb4KBookmark>().hostIpAddress();
0558         m_ipAddressEdit->setText(hostIpAddress);
0559
0560         if (!m_ipAddressEdit->completionObject()->items().contains(hostIpAddress)) {
0561             m_ipAddressEdit->completionObject()->addItem(hostIpAddress);
0562         }
0563
0564         m_editorWidget->setVisible(true);
0565     } else {
0566         startEditingCategoryItem(item);
0567     }
0568 }
0569
0570 void Smb4KConfigPageBookmarks::slotLabelChanged(const QString &text)
0571 {
0572     Q_UNUSED(text);
0573     checkValues();
0574 }
0575
0576 void Smb4KConfigPageBookmarks::slotLabelEdited()
0577 {
0578     if (m_treeWidget->currentItem() && m_editorWidget->isVisible()) {
0579         if (m_treeWidget->currentItem()->data(0, TypeRole).toInt() == BookmarkType) {
0580             Smb4KBookmark bookmark = m_treeWidget->currentItem()->data(0, DataRole).value<Smb4KBookmark>();
0581             bookmark.setLabel(m_labelEdit->text());
0582
0583             QVariant variant = QVariant::fromValue(bookmark);
0584             m_treeWidget->currentItem()->setData(0, DataRole, variant);
0585
0586             if (m_labelEdit->completionMode() != KCompletion::CompletionNone) {
0587                 m_labelEdit->completionObject()->addItem(m_labelEdit->text());
0588             }
0589         }
0590     }
0591 }
0592
0593 void Smb4KConfigPageBookmarks::slotCategoryChanged(const QString &text)
0594 {
0595     Q_UNUSED(text);
0596     checkValues();
0597 }
0598
0599 void Smb4KConfigPageBookmarks::slotCategoryEdited()
0600 {
0601     if (m_treeWidget->currentItem() && m_editorWidget->isVisible()) {
0602         if (m_treeWidget->currentItem()->data(0, TypeRole).toInt() == BookmarkType) {
0603             Smb4KBookmark bookmark = m_treeWidget->currentItem()->data(0, DataRole).value<Smb4KBookmark>();
0604             bookmark.setCategoryName(m_categoryEdit->currentText());
0605
0606             QVariant variant = QVariant::fromValue(bookmark);
0607             m_treeWidget->currentItem()->setData(0, DataRole, variant);
0608
0609             QTreeWidgetItem *categoryItem = nullptr;
0610
0611             for (int i = 0; i < m_treeWidget->topLevelItemCount(); ++i) {
0612                 QTreeWidgetItem *item = m_treeWidget->topLevelItem(i);
0613
0614                 if (item->data(0, TypeRole).toInt() == CategoryType) {
0615                     if (item->data(0, DataRole).toString() == bookmark.categoryName()) {
0616                         categoryItem = item;
0617                         break;
0618                     }
0619                 }
0620             }
0621
0622             if (!categoryItem) {
0623                 categoryItem = addCategoryItem(bookmark.categoryName());
0624             }
0625
0626             if (categoryItem != m_treeWidget->currentItem()->parent()) {
0627                 QTreeWidgetItem *itemToMove = m_treeWidget->currentItem();
0628                 QTreeWidgetItem *parentItem = nullptr;
0629
0630                 if (!itemToMove->parent()) {
0631                     parentItem = m_treeWidget->invisibleRootItem();
0632                 } else {
0633                     parentItem = itemToMove->parent();
0634                 }
0635
0636                 parentItem->removeChild(itemToMove);
0637                 categoryItem->addChild(itemToMove);
0638             }
0639
0640             if (!m_categoryEdit->contains(m_categoryEdit->currentText())) {
0641                 m_categoryEdit->addItem(m_categoryEdit->currentText());
0642             }
0643
0644             if (m_categoryEdit->completionMode() != KCompletion::CompletionNone) {
0645                 m_categoryEdit->completionObject()->addItem(m_categoryEdit->currentText());
0646             }
0647
0648             sortItems();
0649         }
0650     }
0651 }
0652
0653 void Smb4KConfigPageBookmarks::slotUserNameChanged(const QString &text)
0654 {
0655     Q_UNUSED(text);
0656     checkValues();
0657 }
0658
0659 void Smb4KConfigPageBookmarks::slotUserNameEdited()
0660 {
0661     if (m_treeWidget->currentItem() && m_editorWidget->isVisible()) {
0662         if (m_treeWidget->currentItem()->data(0, TypeRole).toInt() == BookmarkType) {
0663             Smb4KBookmark bookmark = m_treeWidget->currentItem()->data(0, DataRole).value<Smb4KBookmark>();
0664             bookmark.setUserName(m_userNameEdit->text());
0665
0666             QVariant variant = QVariant::fromValue(bookmark);
0667             m_treeWidget->currentItem()->setData(0, DataRole, variant);
0668
0669             if (m_userNameEdit->completionMode() != KCompletion::CompletionNone) {
0670                 m_userNameEdit->completionObject()->addItem(m_userNameEdit->text());
0671             }
0672         }
0673     }
0674 }
0675
0676 void Smb4KConfigPageBookmarks::slotWorkgroupChanged(const QString &text)
0677 {
0678     Q_UNUSED(text);
0679     checkValues();
0680 }
0681
0682 void Smb4KConfigPageBookmarks::slotWorkgroupEdited()
0683 {
0684     if (m_treeWidget->currentItem() && m_editorWidget->isVisible()) {
0685         if (m_treeWidget->currentItem()->data(0, TypeRole).toInt() == BookmarkType) {
0686             Smb4KBookmark bookmark = m_treeWidget->currentItem()->data(0, DataRole).value<Smb4KBookmark>();
0687             bookmark.setWorkgroupName(m_workgroupEdit->text());
0688
0689             QVariant variant = QVariant::fromValue(bookmark);
0690             m_treeWidget->currentItem()->setData(0, DataRole, variant);
0691
0692             if (m_workgroupEdit->completionMode() != KCompletion::CompletionNone) {
0693                 m_workgroupEdit->completionObject()->addItem(m_workgroupEdit->text());
0694             }
0695         }
0696     }
0697 }
0698
0699 void Smb4KConfigPageBookmarks::slotIpAddressChanged(const QString &text)
0700 {
0701     Q_UNUSED(text);
0702     checkValues();
0703 }
0704
0705 void Smb4KConfigPageBookmarks::slotIpAddressEdited()
0706 {
0707     if (m_treeWidget->currentItem() && m_editorWidget->isVisible()) {
0708         if (m_treeWidget->currentItem()->data(0, TypeRole).toInt() == BookmarkType) {
0709             if (QHostAddress(m_ipAddressEdit->text()).protocol() == QAbstractSocket::UnknownNetworkLayerProtocol) {
0710                 return;
0711             }
0712
0713             Smb4KBookmark bookmark = m_treeWidget->currentItem()->data(0, DataRole).value<Smb4KBookmark>();
0714             bookmark.setHostIpAddress(m_ipAddressEdit->text());
0715
0716             QVariant variant = QVariant::fromValue(bookmark);
0717             m_treeWidget->currentItem()->setData(0, DataRole, variant);
0718
0719             if (m_ipAddressEdit->completionMode() != KCompletion::CompletionNone) {
0720                 m_ipAddressEdit->completionObject()->addItem(m_ipAddressEdit->text());
0721             }
0722
0723             m_bookmarksChanged = true;
0724             Q_EMIT bookmarksModified();
0725         }
0726     }
0727 }
0728
0729 void Smb4KConfigPageBookmarks::slotEnableButtons()
0730 {
0731     m_resetButton->setEnabled(m_bookmarksChanged);
0732     m_clearButton->setEnabled(m_treeWidget->topLevelItemCount() != 0);
0733     m_addCategoryButton->setEnabled(m_treeWidget->topLevelItemCount() != 0);
0734 }
0735
0736 void Smb4KConfigPageBookmarks::slotIconSizeChanged(int group)
0737 {
0738     switch (group) {
0739     case KIconLoader::Small: {
0740         int iconSize = KIconLoader::global()->currentSize(KIconLoader::Small);
0741         m_treeWidget->setIconSize(QSize(iconSize, iconSize));
0742         break;
0743     }
0744     default: {
0745         break;
0746     }
0747     }
0748 }
0749
0750 void Smb4KConfigPageBookmarks::sortItems()
0751 {
0752     QMap<QString, QTreeWidgetItem *> itemMap;
0753
0754     while (m_treeWidget->topLevelItemCount() > 0) {
0755         QTreeWidgetItem *item = m_treeWidget->takeTopLevelItem(0);
0756
0757         if (item->data(0, TypeRole).toInt() == CategoryType) {
0758             item->sortChildren(0, Qt::AscendingOrder);
0759             itemMap[QStringLiteral("00_") + item->data(0, DataRole).toString()] = item;
0760         } else {
0761             itemMap[QStringLiteral("01_") + item->data(0, DataRole).value<Smb4KBookmark>().displayString()] = item;
0762         }
0763     }
0764
0765     QMapIterator<QString, QTreeWidgetItem *> it(itemMap);
0766
0767     while (it.hasNext()) {
0768         it.next();
0769         m_treeWidget->addTopLevelItem(it.value());
0770
0771         if (it.value()->childCount() != 0) {
0772             it.value()->setExpanded(true);
0773         }
0774     }
0775 }