src/views/dolphinview.cpp

   1 /*
   2  * SPDX-FileCopyrightText: 2006-2009 Peter Penz <peter.penz19@gmail.com>
   3  * SPDX-FileCopyrightText: 2006 Gregor Kališnik <gregor@podnapisi.net>
   4  *
   5  * SPDX-License-Identifier: GPL-2.0-or-later
   6  */
   7
   8 #include "dolphinview.h"
   9
  10 #include "dolphin_detailsmodesettings.h"
  11 #include "dolphin_generalsettings.h"
  12 #include "dolphinitemlistview.h"
  13 #include "dolphinnewfilemenuobserver.h"
  14 #include "draganddrophelper.h"
  15 #include "kitemviews/kfileitemlistview.h"
  16 #include "kitemviews/kfileitemmodel.h"
  17 #include "kitemviews/kitemlistcontainer.h"
  18 #include "kitemviews/kitemlistcontroller.h"
  19 #include "kitemviews/kitemlistheader.h"
  20 #include "kitemviews/kitemlistselectionmanager.h"
  21 #include "kitemviews/private/kitemlistroleeditor.h"
  22 #include "selectionmode/singleclickselectionproxystyle.h"
  23 #include "settings/viewmodes/viewmodesettings.h"
  24 #include "versioncontrol/versioncontrolobserver.h"
  25 #include "viewproperties.h"
  26 #include "views/tooltips/tooltipmanager.h"
  27 #include "zoomlevelinfo.h"
  28
  29 #if HAVE_BALOO
  30 #include <Baloo/IndexerConfig>
  31 #endif
  32 #include <KColorScheme>
  33 #include <KDesktopFile>
  34 #include <KDirModel>
  35 #include <KFileItemListProperties>
  36 #include <KFormat>
  37 #include <KIO/CopyJob>
  38 #include <KIO/DeleteOrTrashJob>
  39 #include <KIO/DropJob>
  40 #include <KIO/JobUiDelegate>
  41 #include <KIO/Paste>
  42 #include <KIO/PasteJob>
  43 #include <KIO/RenameFileDialog>
  44 #include <KJobWidgets>
  45 #include <KLocalizedString>
  46 #include <KMessageBox>
  47 #include <KProtocolManager>
  48 #include <KUrlMimeData>
  49
  50 #include <kwidgetsaddons_version.h>
  51
  52 #include <QAbstractItemView>
  53 #include <QActionGroup>
  54 #include <QApplication>
  55 #include <QClipboard>
  56 #include <QDropEvent>
  57 #include <QGraphicsOpacityEffect>
  58 #include <QGraphicsSceneDragDropEvent>
  59 #include <QLabel>
  60 #include <QMenu>
  61 #include <QMimeDatabase>
  62 #include <QPixmapCache>
  63 #include <QScrollBar>
  64 #include <QSize>
  65 #include <QTimer>
  66 #include <QToolTip>
  67 #include <QVBoxLayout>
  68
  69 DolphinView::DolphinView(const QUrl &url, QWidget *parent)
  70     : QWidget(parent)
  71     , m_active(true)
  72     , m_tabsForFiles(false)
  73     , m_assureVisibleCurrentIndex(false)
  74     , m_isFolderWritable(true)
  75     , m_dragging(false)
  76     , m_selectNextItem(false)
  77     , m_url(url)
  78     , m_viewPropertiesContext()
  79     , m_mode(DolphinView::IconsView)
  80     , m_visibleRoles()
  81     , m_topLayout(nullptr)
  82     , m_model(nullptr)
  83     , m_view(nullptr)
  84     , m_container(nullptr)
  85     , m_toolTipManager(nullptr)
  86     , m_selectionChangedTimer(nullptr)
  87     , m_currentItemUrl()
  88     , m_scrollToCurrentItem(false)
  89     , m_restoredContentsPosition()
  90     , m_selectedUrls()
  91     , m_clearSelectionBeforeSelectingNewItems(false)
  92     , m_markFirstNewlySelectedItemAsCurrent(false)
  93     , m_versionControlObserver(nullptr)
  94     , m_twoClicksRenamingTimer(nullptr)
  95     , m_placeholderLabel(nullptr)
  96     , m_showLoadingPlaceholderTimer(nullptr)
  97 {
  98     m_topLayout = new QVBoxLayout(this);
  99     m_topLayout->setSpacing(0);
 100     m_topLayout->setContentsMargins(0, 0, 0, 0);
 101
 102     // When a new item has been created by the "Create New..." menu, the item should
 103     // get selected and it must be assured that the item will get visible. As the
 104     // creation is done asynchronously, several signals must be checked:
 105     connect(&DolphinNewFileMenuObserver::instance(), &DolphinNewFileMenuObserver::itemCreated, this, &DolphinView::observeCreatedItem);
 106
 107     m_selectionChangedTimer = new QTimer(this);
 108     m_selectionChangedTimer->setSingleShot(true);
 109     m_selectionChangedTimer->setInterval(300);
 110     connect(m_selectionChangedTimer, &QTimer::timeout, this, &DolphinView::emitSelectionChangedSignal);
 111
 112     m_model = new KFileItemModel(this);
 113     m_view = new DolphinItemListView();
 114     m_view->setEnabledSelectionToggles(DolphinItemListView::SelectionTogglesEnabled::FollowSetting);
 115     m_view->setVisibleRoles({"text"});
 116     applyModeToView();
 117
 118     KItemListController *controller = new KItemListController(m_model, m_view, this);
 119     const int delay = GeneralSettings::autoExpandFolders() ? 750 : -1;
 120     controller->setAutoActivationDelay(delay);
 121
 122     // The EnlargeSmallPreviews setting can only be changed after the model
 123     // has been set in the view by KItemListController.
 124     m_view->setEnlargeSmallPreviews(GeneralSettings::enlargeSmallPreviews());
 125
 126     m_container = new KItemListContainer(controller, this);
 127     m_container->installEventFilter(this);
 128     setFocusProxy(m_container);
 129     connect(m_container->horizontalScrollBar(), &QScrollBar::valueChanged, this, [=] {
 130         hideToolTip();
 131     });
 132     connect(m_container->verticalScrollBar(), &QScrollBar::valueChanged, this, [=] {
 133         hideToolTip();
 134     });
 135
 136     m_showLoadingPlaceholderTimer = new QTimer(this);
 137     m_showLoadingPlaceholderTimer->setInterval(500);
 138     m_showLoadingPlaceholderTimer->setSingleShot(true);
 139     connect(m_showLoadingPlaceholderTimer, &QTimer::timeout, this, &DolphinView::showLoadingPlaceholder);
 140
 141     // Show some placeholder text for empty folders
 142     // This is made using a heavily-modified QLabel rather than a KTitleWidget
 143     // because KTitleWidget can't be told to turn off mouse-selectable text
 144     m_placeholderLabel = new QLabel(this);
 145     QFont placeholderLabelFont;
 146     // To match the size of a level 2 Heading/KTitleWidget
 147     placeholderLabelFont.setPointSize(qRound(placeholderLabelFont.pointSize() * 1.3));
 148     m_placeholderLabel->setFont(placeholderLabelFont);
 149     m_placeholderLabel->setTextInteractionFlags(Qt::NoTextInteraction);
 150     m_placeholderLabel->setWordWrap(true);
 151     m_placeholderLabel->setAlignment(Qt::AlignCenter);
 152     // Match opacity of QML placeholder label component
 153     auto *effect = new QGraphicsOpacityEffect(m_placeholderLabel);
 154     effect->setOpacity(0.5);
 155     m_placeholderLabel->setGraphicsEffect(effect);
 156     // Set initial text and visibility
 157     updatePlaceholderLabel();
 158
 159     auto *centeringLayout = new QVBoxLayout(m_container);
 160     centeringLayout->addWidget(m_placeholderLabel);
 161     centeringLayout->setAlignment(m_placeholderLabel, Qt::AlignCenter);
 162     m_placeholderLabel->setContextMenuPolicy(Qt::CustomContextMenu);
 163     connect(m_placeholderLabel, &QWidget::customContextMenuRequested, this, [this](const QPoint &pos) {
 164         slotViewContextMenuRequested(m_placeholderLabel->mapToGlobal(pos));
 165     });
 166
 167     controller->setSelectionBehavior(KItemListController::MultiSelection);
 168     connect(controller, &KItemListController::itemActivated, this, &DolphinView::slotItemActivated);
 169     connect(controller, &KItemListController::itemsActivated, this, &DolphinView::slotItemsActivated);
 170     connect(controller, &KItemListController::itemMiddleClicked, this, &DolphinView::slotItemMiddleClicked);
 171     connect(controller, &KItemListController::itemContextMenuRequested, this, &DolphinView::slotItemContextMenuRequested);
 172     connect(controller, &KItemListController::viewContextMenuRequested, this, &DolphinView::slotViewContextMenuRequested);
 173     connect(controller, &KItemListController::headerContextMenuRequested, this, &DolphinView::slotHeaderContextMenuRequested);
 174     connect(controller, &KItemListController::mouseButtonPressed, this, &DolphinView::slotMouseButtonPressed);
 175     connect(controller, &KItemListController::itemHovered, this, &DolphinView::slotItemHovered);
 176     connect(controller, &KItemListController::itemUnhovered, this, &DolphinView::slotItemUnhovered);
 177     connect(controller, &KItemListController::itemDropEvent, this, &DolphinView::slotItemDropEvent);
 178     connect(controller, &KItemListController::escapePressed, this, &DolphinView::stopLoading);
 179     connect(controller, &KItemListController::modelChanged, this, &DolphinView::slotModelChanged);
 180     connect(controller, &KItemListController::selectedItemTextPressed, this, &DolphinView::slotSelectedItemTextPressed);
 181     connect(controller, &KItemListController::increaseZoom, this, &DolphinView::slotIncreaseZoom);
 182     connect(controller, &KItemListController::decreaseZoom, this, &DolphinView::slotDecreaseZoom);
 183     connect(controller, &KItemListController::swipeUp, this, &DolphinView::slotSwipeUp);
 184     connect(controller, &KItemListController::selectionModeChangeRequested, this, &DolphinView::selectionModeChangeRequested);
 185
 186     connect(m_model, &KFileItemModel::directoryLoadingStarted, this, &DolphinView::slotDirectoryLoadingStarted);
 187     connect(m_model, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
 188     connect(m_model, &KFileItemModel::directoryLoadingCanceled, this, &DolphinView::slotDirectoryLoadingCanceled);
 189     connect(m_model, &KFileItemModel::directoryLoadingProgress, this, &DolphinView::directoryLoadingProgress);
 190     connect(m_model, &KFileItemModel::directorySortingProgress, this, &DolphinView::directorySortingProgress);
 191     connect(m_model, &KFileItemModel::itemsChanged, this, &DolphinView::slotItemsChanged);
 192     connect(m_model, &KFileItemModel::itemsRemoved, this, &DolphinView::itemCountChanged);
 193     connect(m_model, &KFileItemModel::itemsInserted, this, &DolphinView::itemCountChanged);
 194     connect(m_model, &KFileItemModel::infoMessage, this, &DolphinView::infoMessage);
 195     connect(m_model, &KFileItemModel::errorMessage, this, &DolphinView::errorMessage);
 196     connect(m_model, &KFileItemModel::directoryRedirection, this, &DolphinView::slotDirectoryRedirection);
 197     connect(m_model, &KFileItemModel::urlIsFileError, this, &DolphinView::urlIsFileError);
 198     connect(m_model, &KFileItemModel::fileItemsChanged, this, &DolphinView::fileItemsChanged);
 199     connect(m_model, &KFileItemModel::currentDirectoryRemoved, this, &DolphinView::currentDirectoryRemoved);
 200
 201     connect(this, &DolphinView::itemCountChanged, this, &DolphinView::updatePlaceholderLabel);
 202
 203     m_view->installEventFilter(this);
 204     connect(m_view, &DolphinItemListView::sortOrderChanged, this, &DolphinView::slotSortOrderChangedByHeader);
 205     connect(m_view, &DolphinItemListView::sortRoleChanged, this, &DolphinView::slotSortRoleChangedByHeader);
 206     connect(m_view, &DolphinItemListView::visibleRolesChanged, this, &DolphinView::slotVisibleRolesChangedByHeader);
 207     connect(m_view, &DolphinItemListView::roleEditingCanceled, this, &DolphinView::slotRoleEditingCanceled);
 208
 209     connect(m_view, &DolphinItemListView::columnHovered, this, [this](int columnIndex) {
 210         m_hoveredColumnHeaderIndex = columnIndex;
 211     });
 212     connect(m_view, &DolphinItemListView::columnUnHovered, this, [this](int /* columnIndex */) {
 213         m_hoveredColumnHeaderIndex = std::nullopt;
 214     });
 215     connect(m_view->header(), &KItemListHeader::columnWidthChangeFinished, this, &DolphinView::slotHeaderColumnWidthChangeFinished);
 216     connect(m_view->header(), &KItemListHeader::sidePaddingChanged, this, &DolphinView::slotSidePaddingWidthChanged);
 217
 218     KItemListSelectionManager *selectionManager = controller->selectionManager();
 219     connect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &DolphinView::slotSelectionChanged);
 220
 221 #if HAVE_BALOO
 222     m_toolTipManager = new ToolTipManager(this);
 223     connect(m_toolTipManager, &ToolTipManager::urlActivated, this, &DolphinView::urlActivated);
 224 #endif
 225
 226     m_versionControlObserver = new VersionControlObserver(this);
 227     m_versionControlObserver->setView(this);
 228     m_versionControlObserver->setModel(m_model);
 229     connect(m_versionControlObserver, &VersionControlObserver::infoMessage, this, &DolphinView::infoMessage);
 230     connect(m_versionControlObserver, &VersionControlObserver::errorMessage, this, &DolphinView::errorMessage);
 231     connect(m_versionControlObserver, &VersionControlObserver::operationCompletedMessage, this, &DolphinView::operationCompletedMessage);
 232
 233     m_twoClicksRenamingTimer = new QTimer(this);
 234     m_twoClicksRenamingTimer->setSingleShot(true);
 235     connect(m_twoClicksRenamingTimer, &QTimer::timeout, this, &DolphinView::slotTwoClicksRenamingTimerTimeout);
 236
 237     applyViewProperties();
 238     m_topLayout->addWidget(m_container);
 239
 240     loadDirectory(url);
 241 }
 242
 243 DolphinView::~DolphinView()
 244 {
 245     disconnect(m_container->controller(), &KItemListController::modelChanged, this, &DolphinView::slotModelChanged);
 246 }
 247
 248 QUrl DolphinView::url() const
 249 {
 250     return m_url;
 251 }
 252
 253 void DolphinView::setActive(bool active)
 254 {
 255     if (active == m_active) {
 256         return;
 257     }
 258
 259     m_active = active;
 260
 261     updatePalette();
 262
 263     if (active) {
 264         m_container->setFocus();
 265         Q_EMIT activated();
 266         Q_EMIT writeStateChanged(m_isFolderWritable);
 267     }
 268 }
 269
 270 bool DolphinView::isActive() const
 271 {
 272     return m_active;
 273 }
 274
 275 void DolphinView::setViewMode(Mode mode)
 276 {
 277     if (mode != m_mode) {
 278         ViewProperties props(viewPropertiesUrl());
 279         props.setViewMode(mode);
 280
 281         // We pass the new ViewProperties to applyViewProperties, rather than
 282         // storing them on disk and letting applyViewProperties() read them
 283         // from there, to prevent that changing the view mode fails if the
 284         // .directory file is not writable (see bug 318534).
 285         applyViewProperties(props);
 286     }
 287 }
 288
 289 DolphinView::Mode DolphinView::viewMode() const
 290 {
 291     return m_mode;
 292 }
 293
 294 void DolphinView::setSelectionModeEnabled(const bool enabled)
 295 {
 296     if (enabled) {
 297         if (!m_proxyStyle) {
 298             m_proxyStyle = std::make_unique<SelectionMode::SingleClickSelectionProxyStyle>();
 299         }
 300         setStyle(m_proxyStyle.get());
 301         m_view->setStyle(m_proxyStyle.get());
 302         m_view->setEnabledSelectionToggles(DolphinItemListView::SelectionTogglesEnabled::False);
 303     } else {
 304         setStyle(QApplication::style());
 305         m_view->setStyle(QApplication::style());
 306         m_view->setEnabledSelectionToggles(DolphinItemListView::SelectionTogglesEnabled::FollowSetting);
 307     }
 308     m_container->controller()->setSelectionModeEnabled(enabled);
 309 }
 310
 311 bool DolphinView::selectionMode() const
 312 {
 313     return m_container->controller()->selectionMode();
 314 }
 315
 316 void DolphinView::setPreviewsShown(bool show)
 317 {
 318     if (previewsShown() == show) {
 319         return;
 320     }
 321
 322     ViewProperties props(viewPropertiesUrl());
 323     props.setPreviewsShown(show);
 324
 325     const int oldZoomLevel = m_view->zoomLevel();
 326     m_view->setPreviewsShown(show);
 327     Q_EMIT previewsShownChanged(show);
 328
 329     const int newZoomLevel = m_view->zoomLevel();
 330     if (newZoomLevel != oldZoomLevel) {
 331         Q_EMIT zoomLevelChanged(newZoomLevel, oldZoomLevel);
 332     }
 333 }
 334
 335 bool DolphinView::previewsShown() const
 336 {
 337     return m_view->previewsShown();
 338 }
 339
 340 void DolphinView::setHiddenFilesShown(bool show)
 341 {
 342     if (m_model->showHiddenFiles() == show) {
 343         return;
 344     }
 345
 346     const KFileItemList itemList = selectedItems();
 347     m_selectedUrls.clear();
 348     m_selectedUrls = itemList.urlList();
 349
 350     ViewProperties props(viewPropertiesUrl());
 351     props.setHiddenFilesShown(show);
 352
 353     m_model->setShowHiddenFiles(show);
 354     Q_EMIT hiddenFilesShownChanged(show);
 355 }
 356
 357 bool DolphinView::hiddenFilesShown() const
 358 {
 359     return m_model->showHiddenFiles();
 360 }
 361
 362 void DolphinView::setGroupedSorting(bool grouped)
 363 {
 364     if (grouped == groupedSorting()) {
 365         return;
 366     }
 367
 368     ViewProperties props(viewPropertiesUrl());
 369     props.setGroupedSorting(grouped);
 370     props.save();
 371
 372     m_container->controller()->model()->setGroupedSorting(grouped);
 373
 374     Q_EMIT groupedSortingChanged(grouped);
 375 }
 376
 377 bool DolphinView::groupedSorting() const
 378 {
 379     return m_model->groupedSorting();
 380 }
 381
 382 KFileItemList DolphinView::items() const
 383 {
 384     KFileItemList list;
 385     const int itemCount = m_model->count();
 386     list.reserve(itemCount);
 387
 388     for (int i = 0; i < itemCount; ++i) {
 389         list.append(m_model->fileItem(i));
 390     }
 391
 392     return list;
 393 }
 394
 395 int DolphinView::itemsCount() const
 396 {
 397     return m_model->count();
 398 }
 399
 400 KFileItemList DolphinView::selectedItems() const
 401 {
 402     const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
 403
 404     KFileItemList selectedItems;
 405     const auto items = selectionManager->selectedItems();
 406     selectedItems.reserve(items.count());
 407     for (int index : items) {
 408         selectedItems.append(m_model->fileItem(index));
 409     }
 410     return selectedItems;
 411 }
 412
 413 int DolphinView::selectedItemsCount() const
 414 {
 415     const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
 416     return selectionManager->selectedItems().count();
 417 }
 418
 419 void DolphinView::markUrlsAsSelected(const QList<QUrl> &urls)
 420 {
 421     m_selectedUrls = urls;
 422     m_selectJobCreatedItems = false;
 423 }
 424
 425 void DolphinView::markUrlAsCurrent(const QUrl &url)
 426 {
 427     m_currentItemUrl = url;
 428     m_scrollToCurrentItem = true;
 429 }
 430
 431 void DolphinView::selectItems(const QRegularExpression &regexp, bool enabled)
 432 {
 433     const KItemListSelectionManager::SelectionMode mode = enabled ? KItemListSelectionManager::Select : KItemListSelectionManager::Deselect;
 434     KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
 435
 436     for (int index = 0; index < m_model->count(); index++) {
 437         const KFileItem item = m_model->fileItem(index);
 438         if (regexp.match(item.text()).hasMatch()) {
 439             // An alternative approach would be to store the matching items in a KItemSet and
 440             // select them in one go after the loop, but we'd need a new function
 441             // KItemListSelectionManager::setSelected(KItemSet, SelectionMode mode)
 442             // for that.
 443             selectionManager->setSelected(index, 1, mode);
 444         }
 445     }
 446 }
 447
 448 void DolphinView::setZoomLevel(int level)
 449 {
 450     const int oldZoomLevel = zoomLevel();
 451     m_view->setZoomLevel(level);
 452     if (zoomLevel() != oldZoomLevel) {
 453         hideToolTip();
 454         Q_EMIT zoomLevelChanged(zoomLevel(), oldZoomLevel);
 455     }
 456 }
 457
 458 int DolphinView::zoomLevel() const
 459 {
 460     return m_view->zoomLevel();
 461 }
 462
 463 void DolphinView::setSortRole(const QByteArray &role)
 464 {
 465     if (role != sortRole()) {
 466         updateSortRole(role);
 467     }
 468 }
 469
 470 QByteArray DolphinView::sortRole() const
 471 {
 472     const KItemModelBase *model = m_container->controller()->model();
 473     return model->sortRole();
 474 }
 475
 476 void DolphinView::setSortOrder(Qt::SortOrder order)
 477 {
 478     if (sortOrder() != order) {
 479         updateSortOrder(order);
 480     }
 481 }
 482
 483 Qt::SortOrder DolphinView::sortOrder() const
 484 {
 485     return m_model->sortOrder();
 486 }
 487
 488 void DolphinView::setSortFoldersFirst(bool foldersFirst)
 489 {
 490     if (sortFoldersFirst() != foldersFirst) {
 491         updateSortFoldersFirst(foldersFirst);
 492     }
 493 }
 494
 495 bool DolphinView::sortFoldersFirst() const
 496 {
 497     return m_model->sortDirectoriesFirst();
 498 }
 499
 500 void DolphinView::setSortHiddenLast(bool hiddenLast)
 501 {
 502     if (sortHiddenLast() != hiddenLast) {
 503         updateSortHiddenLast(hiddenLast);
 504     }
 505 }
 506
 507 bool DolphinView::sortHiddenLast() const
 508 {
 509     return m_model->sortHiddenLast();
 510 }
 511
 512 void DolphinView::setVisibleRoles(const QList<QByteArray> &roles)
 513 {
 514     const QList<QByteArray> previousRoles = roles;
 515
 516     ViewProperties props(viewPropertiesUrl());
 517     props.setVisibleRoles(roles);
 518
 519     m_visibleRoles = roles;
 520     m_view->setVisibleRoles(roles);
 521
 522     Q_EMIT visibleRolesChanged(m_visibleRoles, previousRoles);
 523 }
 524
 525 QList<QByteArray> DolphinView::visibleRoles() const
 526 {
 527     return m_visibleRoles;
 528 }
 529
 530 void DolphinView::reload()
 531 {
 532     QByteArray viewState;
 533     QDataStream saveStream(&viewState, QIODevice::WriteOnly);
 534     saveState(saveStream);
 535
 536     setUrl(url());
 537     loadDirectory(url(), true);
 538
 539     QDataStream restoreStream(viewState);
 540     restoreState(restoreStream);
 541 }
 542
 543 void DolphinView::readSettings()
 544 {
 545     const int oldZoomLevel = m_view->zoomLevel();
 546
 547     GeneralSettings::self()->load();
 548     m_view->readSettings();
 549     applyViewProperties();
 550
 551     const int delay = GeneralSettings::autoExpandFolders() ? 750 : -1;
 552     m_container->controller()->setAutoActivationDelay(delay);
 553
 554     const int newZoomLevel = m_view->zoomLevel();
 555     if (newZoomLevel != oldZoomLevel) {
 556         Q_EMIT zoomLevelChanged(newZoomLevel, oldZoomLevel);
 557     }
 558 }
 559
 560 void DolphinView::writeSettings()
 561 {
 562     GeneralSettings::self()->save();
 563     m_view->writeSettings();
 564 }
 565
 566 void DolphinView::setNameFilter(const QString &nameFilter)
 567 {
 568     m_model->setNameFilter(nameFilter);
 569 }
 570
 571 QString DolphinView::nameFilter() const
 572 {
 573     return m_model->nameFilter();
 574 }
 575
 576 void DolphinView::setMimeTypeFilters(const QStringList &filters)
 577 {
 578     return m_model->setMimeTypeFilters(filters);
 579 }
 580
 581 QStringList DolphinView::mimeTypeFilters() const
 582 {
 583     return m_model->mimeTypeFilters();
 584 }
 585
 586 void DolphinView::requestStatusBarText()
 587 {
 588     if (m_statJobForStatusBarText) {
 589         // Kill the pending request.
 590         m_statJobForStatusBarText->kill();
 591     }
 592
 593     if (m_container->controller()->selectionManager()->hasSelection()) {
 594         int folderCount = 0;
 595         int fileCount = 0;
 596         KIO::filesize_t totalFileSize = 0;
 597
 598         // Give a summary of the status of the selected files
 599         const KFileItemList list = selectedItems();
 600         for (const KFileItem &item : list) {
 601             if (item.isDir()) {
 602                 ++folderCount;
 603             } else {
 604                 ++fileCount;
 605                 totalFileSize += item.size();
 606             }
 607         }
 608
 609         if (folderCount + fileCount == 1) {
 610             // If only one item is selected, show info about it
 611             Q_EMIT statusBarTextChanged(list.first().getStatusBarInfo());
 612         } else {
 613             // At least 2 items are selected
 614             emitStatusBarText(folderCount, fileCount, totalFileSize, HasSelection);
 615         }
 616     } else { // has no selection
 617         if (!m_model->rootItem().url().isValid()) {
 618             return;
 619         }
 620
 621         m_statJobForStatusBarText = KIO::stat(m_model->rootItem().url(), KIO::StatJob::SourceSide, KIO::StatRecursiveSize, KIO::HideProgressInfo);
 622         connect(m_statJobForStatusBarText, &KJob::result, this, &DolphinView::slotStatJobResult);
 623         m_statJobForStatusBarText->start();
 624     }
 625 }
 626
 627 void DolphinView::emitStatusBarText(const int folderCount, const int fileCount, KIO::filesize_t totalFileSize, const Selection selection)
 628 {
 629     QString foldersText;
 630     QString filesText;
 631     QString summary;
 632
 633     if (selection == HasSelection) {
 634         // At least 2 items are selected because the case of 1 selected item is handled in
 635         // DolphinView::requestStatusBarText().
 636         foldersText = i18ncp("@info:status", "1 Folder selected", "%1 Folders selected", folderCount);
 637         filesText = i18ncp("@info:status", "1 File selected", "%1 Files selected", fileCount);
 638     } else {
 639         foldersText = i18ncp("@info:status", "1 Folder", "%1 Folders", folderCount);
 640         filesText = i18ncp("@info:status", "1 File", "%1 Files", fileCount);
 641     }
 642
 643     if (fileCount > 0 && folderCount > 0) {
 644         summary = i18nc("@info:status folders, files (size)", "%1, %2 (%3)", foldersText, filesText, KFormat().formatByteSize(totalFileSize));
 645     } else if (fileCount > 0) {
 646         summary = i18nc("@info:status files (size)", "%1 (%2)", filesText, KFormat().formatByteSize(totalFileSize));
 647     } else if (folderCount > 0) {
 648         summary = foldersText;
 649     } else {
 650         summary = i18nc("@info:status", "0 Folders, 0 Files");
 651     }
 652     Q_EMIT statusBarTextChanged(summary);
 653 }
 654
 655 QList<QAction *> DolphinView::versionControlActions(const KFileItemList &items) const
 656 {
 657     QList<QAction *> actions;
 658
 659     if (items.isEmpty()) {
 660         const KFileItem item = m_model->rootItem();
 661         if (!item.isNull()) {
 662             actions = m_versionControlObserver->actions(KFileItemList() << item);
 663         }
 664     } else {
 665         actions = m_versionControlObserver->actions(items);
 666     }
 667
 668     return actions;
 669 }
 670
 671 void DolphinView::setUrl(const QUrl &url)
 672 {
 673     if (url == m_url) {
 674         return;
 675     }
 676
 677     clearSelection();
 678
 679     m_url = url;
 680
 681     hideToolTip();
 682
 683     disconnect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
 684
 685     // It is important to clear the items from the model before
 686     // applying the view properties, otherwise expensive operations
 687     // might be done on the existing items although they get cleared
 688     // anyhow afterwards by loadDirectory().
 689     m_model->clear();
 690     applyViewProperties();
 691     loadDirectory(url);
 692
 693     Q_EMIT urlChanged(url);
 694 }
 695
 696 void DolphinView::selectAll()
 697 {
 698     KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
 699     selectionManager->setSelected(0, m_model->count());
 700 }
 701
 702 void DolphinView::invertSelection()
 703 {
 704     KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
 705     selectionManager->setSelected(0, m_model->count(), KItemListSelectionManager::Toggle);
 706 }
 707
 708 void DolphinView::clearSelection()
 709 {
 710     m_selectJobCreatedItems = false;
 711     m_selectedUrls.clear();
 712     m_container->controller()->selectionManager()->clearSelection();
 713 }
 714
 715 void DolphinView::renameSelectedItems()
 716 {
 717     const KFileItemList items = selectedItems();
 718     if (items.isEmpty()) {
 719         return;
 720     }
 721
 722     if (items.count() == 1 && GeneralSettings::renameInline()) {
 723         const int index = m_model->index(items.first());
 724
 725         QMetaObject::Connection *const connection = new QMetaObject::Connection;
 726         *connection = connect(m_view, &KItemListView::scrollingStopped, this, [=]() {
 727             QObject::disconnect(*connection);
 728             delete connection;
 729
 730             m_view->editRole(index, "text");
 731
 732             hideToolTip();
 733
 734             connect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
 735         });
 736         m_view->scrollToItem(index);
 737
 738     } else {
 739         KIO::RenameFileDialog *dialog = new KIO::RenameFileDialog(items, this);
 740         connect(dialog, &KIO::RenameFileDialog::renamingFinished, this, &DolphinView::slotRenameDialogRenamingFinished);
 741
 742         dialog->open();
 743     }
 744
 745     // Assure that the current index remains visible when KFileItemModel
 746     // will notify the view about changed items (which might result in
 747     // a changed sorting).
 748     m_assureVisibleCurrentIndex = true;
 749 }
 750
 751 void DolphinView::trashSelectedItems()
 752 {
 753     const QList<QUrl> list = simplifiedSelectedUrls();
 754
 755     using Iface = KIO::AskUserActionInterface;
 756     auto *trashJob = new KIO::DeleteOrTrashJob(list, Iface::Trash, Iface::DefaultConfirmation, this);
 757     connect(trashJob, &KJob::result, this, &DolphinView::slotTrashFileFinished);
 758     m_selectNextItem = true;
 759     trashJob->start();
 760 }
 761
 762 void DolphinView::deleteSelectedItems()
 763 {
 764     const QList<QUrl> list = simplifiedSelectedUrls();
 765
 766     using Iface = KIO::AskUserActionInterface;
 767     auto *trashJob = new KIO::DeleteOrTrashJob(list, Iface::Delete, Iface::DefaultConfirmation, this);
 768     connect(trashJob, &KJob::result, this, &DolphinView::slotTrashFileFinished);
 769     m_selectNextItem = true;
 770     trashJob->start();
 771 }
 772
 773 void DolphinView::cutSelectedItemsToClipboard()
 774 {
 775     QMimeData *mimeData = selectionMimeData();
 776     KIO::setClipboardDataCut(mimeData, true);
 777     KUrlMimeData::exportUrlsToPortal(mimeData);
 778     QApplication::clipboard()->setMimeData(mimeData);
 779 }
 780
 781 void DolphinView::copySelectedItemsToClipboard()
 782 {
 783     QMimeData *mimeData = selectionMimeData();
 784     KUrlMimeData::exportUrlsToPortal(mimeData);
 785     QApplication::clipboard()->setMimeData(mimeData);
 786 }
 787
 788 void DolphinView::copySelectedItems(const KFileItemList &selection, const QUrl &destinationUrl)
 789 {
 790     if (selection.isEmpty() || !destinationUrl.isValid()) {
 791         return;
 792     }
 793
 794     m_clearSelectionBeforeSelectingNewItems = true;
 795     m_markFirstNewlySelectedItemAsCurrent = true;
 796     m_selectJobCreatedItems = true;
 797
 798     KIO::CopyJob *job = KIO::copy(selection.urlList(), destinationUrl, KIO::DefaultFlags);
 799     KJobWidgets::setWindow(job, this);
 800
 801     connect(job, &KIO::DropJob::result, this, &DolphinView::slotJobResult);
 802     connect(job, &KIO::CopyJob::copying, this, &DolphinView::slotItemCreatedFromJob);
 803     connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotItemCreatedFromJob);
 804     KIO::FileUndoManager::self()->recordCopyJob(job);
 805 }
 806
 807 void DolphinView::moveSelectedItems(const KFileItemList &selection, const QUrl &destinationUrl)
 808 {
 809     if (selection.isEmpty() || !destinationUrl.isValid()) {
 810         return;
 811     }
 812
 813     m_clearSelectionBeforeSelectingNewItems = true;
 814     m_markFirstNewlySelectedItemAsCurrent = true;
 815     m_selectJobCreatedItems = true;
 816
 817     KIO::CopyJob *job = KIO::move(selection.urlList(), destinationUrl, KIO::DefaultFlags);
 818     KJobWidgets::setWindow(job, this);
 819
 820     connect(job, &KIO::DropJob::result, this, &DolphinView::slotJobResult);
 821     connect(job, &KIO::CopyJob::moving, this, &DolphinView::slotItemCreatedFromJob);
 822     connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotItemCreatedFromJob);
 823     KIO::FileUndoManager::self()->recordCopyJob(job);
 824 }
 825
 826 void DolphinView::paste()
 827 {
 828     pasteToUrl(url());
 829 }
 830
 831 void DolphinView::pasteIntoFolder()
 832 {
 833     const KFileItemList items = selectedItems();
 834     if ((items.count() == 1) && items.first().isDir()) {
 835         pasteToUrl(items.first().url());
 836     }
 837 }
 838
 839 void DolphinView::duplicateSelectedItems()
 840 {
 841     const KFileItemList itemList = selectedItems();
 842     if (itemList.isEmpty()) {
 843         return;
 844     }
 845
 846     const QMimeDatabase db;
 847
 848     // Duplicate all selected items and append "copy" to the end of the file name
 849     // but before the filename extension, if present
 850     QList<QUrl> newSelection;
 851     for (const auto &item : itemList) {
 852         const QUrl originalURL = item.url();
 853         const QString originalDirectoryPath = originalURL.adjusted(QUrl::RemoveFilename).path();
 854         const QString originalFileName = item.name();
 855
 856         QString extension = db.suffixForFileName(originalFileName);
 857
 858         QUrl duplicateURL = originalURL;
 859
 860         // No extension; new filename is "<oldfilename> copy"
 861         if (extension.isEmpty()) {
 862             duplicateURL.setPath(originalDirectoryPath + i18nc("<filename> copy", "%1 copy", originalFileName));
 863             // There's an extension; new filename is "<oldfilename> copy.<extension>"
 864         } else {
 865             // Need to add a dot since QMimeDatabase::suffixForFileName() doesn't include it
 866             extension = QLatin1String(".") + extension;
 867             const QString originalFilenameWithoutExtension = originalFileName.chopped(extension.size());
 868             // Preserve file's original filename extension in case the casing differs
 869             // from what QMimeDatabase::suffixForFileName() returned
 870             const QString originalExtension = originalFileName.right(extension.size());
 871             duplicateURL.setPath(originalDirectoryPath + i18nc("<filename> copy", "%1 copy", originalFilenameWithoutExtension) + originalExtension);
 872         }
 873
 874         KIO::CopyJob *job = KIO::copyAs(originalURL, duplicateURL);
 875         KJobWidgets::setWindow(job, this);
 876
 877         if (job) {
 878             newSelection << duplicateURL;
 879             KIO::FileUndoManager::self()->recordCopyJob(job);
 880         }
 881     }
 882
 883     forceUrlsSelection(newSelection.first(), newSelection);
 884 }
 885
 886 void DolphinView::stopLoading()
 887 {
 888     m_model->cancelDirectoryLoading();
 889 }
 890
 891 void DolphinView::updatePalette()
 892 {
 893     QColor color = KColorScheme(isActiveWindow() ? QPalette::Active : QPalette::Inactive, KColorScheme::View).background().color();
 894     if (!m_active) {
 895         color.setAlpha(150);
 896     }
 897
 898     QWidget *viewport = m_container->viewport();
 899     if (viewport) {
 900         QPalette palette;
 901         palette.setColor(viewport->backgroundRole(), color);
 902         viewport->setPalette(palette);
 903     }
 904
 905     update();
 906 }
 907
 908 void DolphinView::abortTwoClicksRenaming()
 909 {
 910     m_twoClicksRenamingItemUrl.clear();
 911     m_twoClicksRenamingTimer->stop();
 912 }
 913
 914 bool DolphinView::eventFilter(QObject *watched, QEvent *event)
 915 {
 916     switch (event->type()) {
 917     case QEvent::PaletteChange:
 918         updatePalette();
 919         QPixmapCache::clear();
 920         break;
 921
 922     case QEvent::WindowActivate:
 923     case QEvent::WindowDeactivate:
 924         updatePalette();
 925         break;
 926
 927     case QEvent::KeyPress:
 928         hideToolTip(ToolTipManager::HideBehavior::Instantly);
 929         if (GeneralSettings::useTabForSwitchingSplitView()) {
 930             QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
 931             if (keyEvent->key() == Qt::Key_Tab && keyEvent->modifiers() == Qt::NoModifier) {
 932                 Q_EMIT toggleActiveViewRequested();
 933                 return true;
 934             }
 935         }
 936         break;
 937     case QEvent::KeyRelease:
 938         if (static_cast<QKeyEvent *>(event)->key() == Qt::Key_Control) {
 939             m_controlWheelAccumulatedDelta = 0;
 940         }
 941         break;
 942     case QEvent::FocusIn:
 943         if (watched == m_container) {
 944             setActive(true);
 945         }
 946         break;
 947
 948     case QEvent::GraphicsSceneDragEnter:
 949         if (watched == m_view) {
 950             m_dragging = true;
 951             abortTwoClicksRenaming();
 952         }
 953         break;
 954
 955     case QEvent::GraphicsSceneDragLeave:
 956         if (watched == m_view) {
 957             m_dragging = false;
 958         }
 959         break;
 960
 961     case QEvent::GraphicsSceneDrop:
 962         if (watched == m_view) {
 963             m_dragging = false;
 964         }
 965         break;
 966
 967     case QEvent::ToolTip: {
 968         const auto helpEvent = static_cast<QHelpEvent *>(event);
 969         if (tryShowNameToolTip(helpEvent)) {
 970             return true;
 971
 972         } else if (m_hoveredColumnHeaderIndex) {
 973             const auto rolesInfo = KFileItemModel::rolesInformation();
 974             const auto visibleRole = m_visibleRoles.value(*m_hoveredColumnHeaderIndex);
 975
 976             for (const KFileItemModel::RoleInfo &info : rolesInfo) {
 977                 if (visibleRole == info.role) {
 978                     QToolTip::showText(helpEvent->globalPos(), info.tooltip, this);
 979                     return true;
 980                 }
 981             }
 982         }
 983         break;
 984     }
 985     default:
 986         break;
 987     }
 988
 989     return QWidget::eventFilter(watched, event);
 990 }
 991
 992 void DolphinView::wheelEvent(QWheelEvent *event)
 993 {
 994     if (event->modifiers().testFlag(Qt::ControlModifier)) {
 995         m_controlWheelAccumulatedDelta += event->angleDelta().y();
 996
 997         if (m_controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep) {
 998             slotDecreaseZoom();
 999             m_controlWheelAccumulatedDelta += QWheelEvent::DefaultDeltasPerStep;
1000         } else if (m_controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep) {
1001             slotIncreaseZoom();
1002             m_controlWheelAccumulatedDelta -= QWheelEvent::DefaultDeltasPerStep;
1003         }
1004
1005         event->accept();
1006     } else {
1007         event->ignore();
1008     }
1009 }
1010
1011 void DolphinView::hideEvent(QHideEvent *event)
1012 {
1013     hideToolTip();
1014     QWidget::hideEvent(event);
1015 }
1016
1017 bool DolphinView::event(QEvent *event)
1018 {
1019     if (event->type() == QEvent::WindowDeactivate) {
1020         /* See Bug 297355
1021          * Dolphin leaves file preview tooltips open even when is not visible.
1022          *
1023          * Hide tool-tip when Dolphin loses focus.
1024          */
1025         hideToolTip();
1026         abortTwoClicksRenaming();
1027     }
1028
1029     return QWidget::event(event);
1030 }
1031
1032 void DolphinView::activate()
1033 {
1034     setActive(true);
1035 }
1036
1037 void DolphinView::slotItemActivated(int index)
1038 {
1039     abortTwoClicksRenaming();
1040
1041     const KFileItem item = m_model->fileItem(index);
1042     if (!item.isNull()) {
1043         Q_EMIT itemActivated(item);
1044     }
1045 }
1046
1047 void DolphinView::slotItemsActivated(const KItemSet &indexes)
1048 {
1049     Q_ASSERT(indexes.count() >= 2);
1050
1051     abortTwoClicksRenaming();
1052
1053     const auto modifiers = QGuiApplication::keyboardModifiers();
1054
1055     if (indexes.count() > 5) {
1056         QString question = i18np("Are you sure you want to open 1 item?", "Are you sure you want to open %1 items?", indexes.count());
1057 #if KWIDGETSADDONS_VERSION >= QT_VERSION_CHECK(5, 100, 0)
1058         const int answer = KMessageBox::warningTwoActions(
1059             this,
1060             question,
1061             {},
1062 #else
1063         const int answer =
1064             KMessageBox::warningYesNo(this,
1065                                       question,
1066                                       {},
1067 #endif
1068             KGuiItem(i18ncp("@action:button", "Open %1 Item", "Open %1 Items", indexes.count()), QStringLiteral("document-open")),
1069             KStandardGuiItem::cancel());
1070 #if KWIDGETSADDONS_VERSION >= QT_VERSION_CHECK(5, 100, 0)
1071         if (answer != KMessageBox::PrimaryAction) {
1072 #else
1073         if (answer != KMessageBox::Yes) {
1074 #endif
1075             return;
1076         }
1077     }
1078
1079     KFileItemList items;
1080     items.reserve(indexes.count());
1081
1082     for (int index : indexes) {
1083         KFileItem item = m_model->fileItem(index);
1084         const QUrl &url = openItemAsFolderUrl(item);
1085
1086         if (!url.isEmpty()) {
1087             // Open folders in new tabs or in new windows depending on the modifier
1088             // The ctrl+shift behavior is ignored because we are handling multiple items
1089             // keep in sync with KUrlNavigator::slotNavigatorButtonClicked
1090             if (modifiers & Qt::ShiftModifier && !(modifiers & Qt::ControlModifier)) {
1091                 Q_EMIT windowRequested(url);
1092             } else {
1093                 Q_EMIT tabRequested(url);
1094             }
1095         } else {
1096             items.append(item);
1097         }
1098     }
1099
1100     if (items.count() == 1) {
1101         Q_EMIT itemActivated(items.first());
1102     } else if (items.count() > 1) {
1103         Q_EMIT itemsActivated(items);
1104     }
1105 }
1106
1107 void DolphinView::slotItemMiddleClicked(int index)
1108 {
1109     const KFileItem &item = m_model->fileItem(index);
1110     const QUrl &url = openItemAsFolderUrl(item);
1111     const auto modifiers = QGuiApplication::keyboardModifiers();
1112     if (!url.isEmpty()) {
1113         // keep in sync with KUrlNavigator::slotNavigatorButtonClicked
1114         if (modifiers & Qt::ShiftModifier) {
1115             Q_EMIT activeTabRequested(url);
1116         } else {
1117             Q_EMIT tabRequested(url);
1118         }
1119     } else if (isTabsForFilesEnabled()) {
1120         // keep in sync with KUrlNavigator::slotNavigatorButtonClicked
1121         if (modifiers & Qt::ShiftModifier) {
1122             Q_EMIT activeTabRequested(item.url());
1123         } else {
1124             Q_EMIT tabRequested(item.url());
1125         }
1126     }
1127 }
1128
1129 void DolphinView::slotItemContextMenuRequested(int index, const QPointF &pos)
1130 {
1131     // Force emit of a selection changed signal before we request the
1132     // context menu, to update the edit-actions first. (See Bug 294013)
1133     if (m_selectionChangedTimer->isActive()) {
1134         emitSelectionChangedSignal();
1135     }
1136
1137     const KFileItem item = m_model->fileItem(index);
1138     Q_EMIT requestContextMenu(pos.toPoint(), item, selectedItems(), url());
1139 }
1140
1141 void DolphinView::slotViewContextMenuRequested(const QPointF &pos)
1142 {
1143     Q_EMIT requestContextMenu(pos.toPoint(), KFileItem(), selectedItems(), url());
1144 }
1145
1146 void DolphinView::slotHeaderContextMenuRequested(const QPointF &pos)
1147 {
1148     ViewProperties props(viewPropertiesUrl());
1149
1150     QPointer<QMenu> menu = new QMenu(QApplication::activeWindow());
1151
1152     KItemListView *view = m_container->controller()->view();
1153     const QList<QByteArray> visibleRolesSet = view->visibleRoles();
1154
1155     bool indexingEnabled = false;
1156 #if HAVE_BALOO
1157     Baloo::IndexerConfig config;
1158     indexingEnabled = config.fileIndexingEnabled();
1159 #endif
1160
1161     QString groupName;
1162     QMenu *groupMenu = nullptr;
1163
1164     // Add all roles to the menu that can be shown or hidden by the user
1165     const QList<KFileItemModel::RoleInfo> rolesInfo = KFileItemModel::rolesInformation();
1166     for (const KFileItemModel::RoleInfo &info : rolesInfo) {
1167         if (info.role == "text") {
1168             // It should not be possible to hide the "text" role
1169             continue;
1170         }
1171
1172         const QString text = m_model->roleDescription(info.role);
1173         QAction *action = nullptr;
1174         if (info.group.isEmpty()) {
1175             action = menu->addAction(text);
1176         } else {
1177             if (!groupMenu || info.group != groupName) {
1178                 groupName = info.group;
1179                 groupMenu = menu->addMenu(groupName);
1180             }
1181
1182             action = groupMenu->addAction(text);
1183         }
1184
1185         action->setCheckable(true);
1186         action->setChecked(visibleRolesSet.contains(info.role));
1187         action->setData(info.role);
1188         action->setToolTip(info.tooltip);
1189
1190         const bool enable = (!info.requiresBaloo && !info.requiresIndexer) || (info.requiresBaloo) || (info.requiresIndexer && indexingEnabled);
1191         action->setEnabled(enable);
1192     }
1193
1194     menu->addSeparator();
1195
1196     QActionGroup *widthsGroup = new QActionGroup(menu);
1197     const bool autoColumnWidths = props.headerColumnWidths().isEmpty();
1198
1199     QAction *toggleSidePaddingAction = menu->addAction(i18nc("@action:inmenu", "Side Padding"));
1200     toggleSidePaddingAction->setCheckable(true);
1201     toggleSidePaddingAction->setChecked(view->header()->sidePadding() > 0);
1202
1203     QAction *autoAdjustWidthsAction = menu->addAction(i18nc("@action:inmenu", "Automatic Column Widths"));
1204     autoAdjustWidthsAction->setCheckable(true);
1205     autoAdjustWidthsAction->setChecked(autoColumnWidths);
1206     autoAdjustWidthsAction->setActionGroup(widthsGroup);
1207
1208     QAction *customWidthsAction = menu->addAction(i18nc("@action:inmenu", "Custom Column Widths"));
1209     customWidthsAction->setCheckable(true);
1210     customWidthsAction->setChecked(!autoColumnWidths);
1211     customWidthsAction->setActionGroup(widthsGroup);
1212
1213     QAction *action = menu->exec(pos.toPoint());
1214     if (menu && action) {
1215         KItemListHeader *header = view->header();
1216
1217         if (action == autoAdjustWidthsAction) {
1218             // Clear the column-widths from the viewproperties and turn on
1219             // the automatic resizing of the columns
1220             props.setHeaderColumnWidths(QList<int>());
1221             header->setAutomaticColumnResizing(true);
1222         } else if (action == customWidthsAction) {
1223             // Apply the current column-widths as custom column-widths and turn
1224             // off the automatic resizing of the columns
1225             QList<int> columnWidths;
1226             const auto visibleRoles = view->visibleRoles();
1227             columnWidths.reserve(visibleRoles.count());
1228             for (const QByteArray &role : visibleRoles) {
1229                 columnWidths.append(header->columnWidth(role));
1230             }
1231             props.setHeaderColumnWidths(columnWidths);
1232             header->setAutomaticColumnResizing(false);
1233         } else if (action == toggleSidePaddingAction) {
1234             header->setSidePadding(toggleSidePaddingAction->isChecked() ? 20 : 0);
1235         } else {
1236             // Show or hide the selected role
1237             const QByteArray selectedRole = action->data().toByteArray();
1238
1239             QList<QByteArray> visibleRoles = view->visibleRoles();
1240             if (action->isChecked()) {
1241                 visibleRoles.append(selectedRole);
1242             } else {
1243                 visibleRoles.removeOne(selectedRole);
1244             }
1245
1246             view->setVisibleRoles(visibleRoles);
1247             props.setVisibleRoles(visibleRoles);
1248
1249             QList<int> columnWidths;
1250             if (!header->automaticColumnResizing()) {
1251                 const auto visibleRoles = view->visibleRoles();
1252                 columnWidths.reserve(visibleRoles.count());
1253                 for (const QByteArray &role : visibleRoles) {
1254                     columnWidths.append(header->columnWidth(role));
1255                 }
1256             }
1257             props.setHeaderColumnWidths(columnWidths);
1258         }
1259     }
1260
1261     delete menu;
1262 }
1263
1264 void DolphinView::slotHeaderColumnWidthChangeFinished(const QByteArray &role, qreal current)
1265 {
1266     const QList<QByteArray> visibleRoles = m_view->visibleRoles();
1267
1268     ViewProperties props(viewPropertiesUrl());
1269     QList<int> columnWidths = props.headerColumnWidths();
1270     if (columnWidths.count() != visibleRoles.count()) {
1271         columnWidths.clear();
1272         columnWidths.reserve(visibleRoles.count());
1273         const KItemListHeader *header = m_view->header();
1274         for (const QByteArray &role : visibleRoles) {
1275             const int width = header->columnWidth(role);
1276             columnWidths.append(width);
1277         }
1278     }
1279
1280     const int roleIndex = visibleRoles.indexOf(role);
1281     Q_ASSERT(roleIndex >= 0 && roleIndex < columnWidths.count());
1282     columnWidths[roleIndex] = current;
1283
1284     props.setHeaderColumnWidths(columnWidths);
1285 }
1286
1287 void DolphinView::slotSidePaddingWidthChanged(qreal width)
1288 {
1289     ViewProperties props(viewPropertiesUrl());
1290     DetailsModeSettings::setSidePadding(int(width));
1291     m_view->writeSettings();
1292 }
1293
1294 void DolphinView::slotItemHovered(int index)
1295 {
1296     const KFileItem item = m_model->fileItem(index);
1297
1298     if (GeneralSettings::showToolTips() && !m_dragging) {
1299         QRectF itemRect = m_container->controller()->view()->itemContextRect(index);
1300         const QPoint pos = m_container->mapToGlobal(itemRect.topLeft().toPoint());
1301         itemRect.moveTo(pos);
1302
1303 #if HAVE_BALOO
1304         auto nativeParent = nativeParentWidget();
1305         if (nativeParent) {
1306             m_toolTipManager->showToolTip(item, itemRect, nativeParent->windowHandle());
1307         }
1308 #endif
1309     }
1310
1311     Q_EMIT requestItemInfo(item);
1312 }
1313
1314 void DolphinView::slotItemUnhovered(int index)
1315 {
1316     Q_UNUSED(index)
1317     hideToolTip();
1318     Q_EMIT requestItemInfo(KFileItem());
1319 }
1320
1321 void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent *event)
1322 {
1323     QUrl destUrl;
1324     KFileItem destItem = m_model->fileItem(index);
1325     if (destItem.isNull() || (!destItem.isDir() && !destItem.isDesktopFile())) {
1326         // Use the URL of the view as drop target if the item is no directory
1327         // or desktop-file
1328         destItem = m_model->rootItem();
1329         destUrl = url();
1330     } else {
1331         // The item represents a directory or desktop-file
1332         destUrl = destItem.mostLocalUrl();
1333     }
1334
1335     QDropEvent dropEvent(event->pos().toPoint(), event->possibleActions(), event->mimeData(), event->buttons(), event->modifiers());
1336     dropUrls(destUrl, &dropEvent, this);
1337
1338     setActive(true);
1339 }
1340
1341 void DolphinView::dropUrls(const QUrl &destUrl, QDropEvent *dropEvent, QWidget *dropWidget)
1342 {
1343     KIO::DropJob *job = DragAndDropHelper::dropUrls(destUrl, dropEvent, dropWidget);
1344
1345     if (job) {
1346         connect(job, &KIO::DropJob::result, this, &DolphinView::slotJobResult);
1347
1348         if (destUrl == url()) {
1349             // Mark the dropped urls as selected.
1350             m_clearSelectionBeforeSelectingNewItems = true;
1351             m_markFirstNewlySelectedItemAsCurrent = true;
1352             m_selectJobCreatedItems = true;
1353             connect(job, &KIO::DropJob::itemCreated, this, &DolphinView::slotItemCreated);
1354             connect(job, &KIO::DropJob::copyJobStarted, this, [this](const KIO::CopyJob *copyJob) {
1355                 connect(copyJob, &KIO::CopyJob::copying, this, &DolphinView::slotItemCreatedFromJob);
1356                 connect(copyJob, &KIO::CopyJob::moving, this, &DolphinView::slotItemCreatedFromJob);
1357                 connect(copyJob, &KIO::CopyJob::linking, this, [this](KIO::Job *job, const QString &src, const QUrl &dest) {
1358                     Q_UNUSED(job)
1359                     Q_UNUSED(src)
1360                     slotItemCreated(dest);
1361                 });
1362             });
1363         }
1364     }
1365 }
1366
1367 void DolphinView::slotModelChanged(KItemModelBase *current, KItemModelBase *previous)
1368 {
1369     if (previous != nullptr) {
1370         Q_ASSERT(qobject_cast<KFileItemModel *>(previous));
1371         KFileItemModel *fileItemModel = static_cast<KFileItemModel *>(previous);
1372         disconnect(fileItemModel, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
1373         m_versionControlObserver->setModel(nullptr);
1374     }
1375
1376     if (current) {
1377         Q_ASSERT(qobject_cast<KFileItemModel *>(current));
1378         KFileItemModel *fileItemModel = static_cast<KFileItemModel *>(current);
1379         connect(fileItemModel, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
1380         m_versionControlObserver->setModel(fileItemModel);
1381     }
1382 }
1383
1384 void DolphinView::slotMouseButtonPressed(int itemIndex, Qt::MouseButtons buttons)
1385 {
1386     Q_UNUSED(itemIndex)
1387
1388     hideToolTip();
1389
1390     if (buttons & Qt::BackButton) {
1391         Q_EMIT goBackRequested();
1392     } else if (buttons & Qt::ForwardButton) {
1393         Q_EMIT goForwardRequested();
1394     }
1395 }
1396
1397 void DolphinView::slotSelectedItemTextPressed(int index)
1398 {
1399     if (GeneralSettings::renameInline() && !m_view->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick)) {
1400         const KFileItem item = m_model->fileItem(index);
1401         const KFileItemListProperties capabilities(KFileItemList() << item);
1402         if (capabilities.supportsMoving()) {
1403             m_twoClicksRenamingItemUrl = item.url();
1404             m_twoClicksRenamingTimer->start(QApplication::doubleClickInterval());
1405         }
1406     }
1407 }
1408
1409 void DolphinView::slotItemCreatedFromJob(KIO::Job *, const QUrl &, const QUrl &to)
1410 {
1411     slotItemCreated(to);
1412 }
1413
1414 void DolphinView::slotItemCreated(const QUrl &url)
1415 {
1416     if (m_markFirstNewlySelectedItemAsCurrent) {
1417         markUrlAsCurrent(url);
1418         m_markFirstNewlySelectedItemAsCurrent = false;
1419     }
1420     if (m_selectJobCreatedItems && !m_selectedUrls.contains(url)) {
1421         m_selectedUrls << url;
1422     }
1423 }
1424
1425 void DolphinView::slotJobResult(KJob *job)
1426 {
1427     if (job->error() && job->error() != KIO::ERR_USER_CANCELED) {
1428         Q_EMIT errorMessage(job->errorString());
1429     }
1430     if (!m_selectJobCreatedItems) {
1431         m_selectedUrls.clear();
1432         return;
1433     }
1434     if (!m_selectedUrls.isEmpty()) {
1435         m_selectedUrls = KDirModel::simplifiedUrlList(m_selectedUrls);
1436
1437         updateSelectionState();
1438         if (!m_selectedUrls.isEmpty()) {
1439             // not all urls were found, the model may not be up to date
1440             // TODO KF6 replace with Qt::singleShotConnection
1441             QMetaObject::Connection *const connection = new QMetaObject::Connection;
1442             *connection = connect(
1443                 m_model,
1444                 &KFileItemModel::directoryLoadingCompleted,
1445                 this,
1446                 [this, connection]() {
1447                     // the model should now contain all the items created by the job
1448                     updateSelectionState();
1449                     m_selectJobCreatedItems = false;
1450                     m_selectedUrls.clear();
1451                     QObject::disconnect(*connection);
1452                     delete connection;
1453                 },
1454                 Qt::UniqueConnection);
1455         } else {
1456             m_selectJobCreatedItems = false;
1457             m_selectedUrls.clear();
1458         }
1459     }
1460 }
1461
1462 void DolphinView::slotSelectionChanged(const KItemSet &current, const KItemSet &previous)
1463 {
1464     m_selectNextItem = false;
1465     const int currentCount = current.count();
1466     const int previousCount = previous.count();
1467     const bool selectionStateChanged = (currentCount == 0 && previousCount > 0) || (currentCount > 0 && previousCount == 0);
1468
1469     // If nothing has been selected before and something got selected (or if something
1470     // was selected before and now nothing is selected) the selectionChangedSignal must
1471     // be emitted asynchronously as fast as possible to update the edit-actions.
1472     m_selectionChangedTimer->setInterval(selectionStateChanged ? 0 : 300);
1473     m_selectionChangedTimer->start();
1474 }
1475
1476 void DolphinView::emitSelectionChangedSignal()
1477 {
1478     m_selectionChangedTimer->stop();
1479     Q_EMIT selectionChanged(selectedItems());
1480 }
1481
1482 void DolphinView::slotStatJobResult(KJob *job)
1483 {
1484     int folderCount = 0;
1485     int fileCount = 0;
1486     KIO::filesize_t totalFileSize = 0;
1487     bool countFileSize = true;
1488
1489     const auto entry = static_cast<KIO::StatJob *>(job)->statResult();
1490     if (entry.contains(KIO::UDSEntry::UDS_RECURSIVE_SIZE)) {
1491         // We have a precomputed value.
1492         totalFileSize = static_cast<KIO::filesize_t>(entry.numberValue(KIO::UDSEntry::UDS_RECURSIVE_SIZE));
1493         countFileSize = false;
1494     }
1495
1496     const int itemCount = m_model->count();
1497     for (int i = 0; i < itemCount; ++i) {
1498         const KFileItem item = m_model->fileItem(i);
1499         if (item.isDir()) {
1500             ++folderCount;
1501         } else {
1502             ++fileCount;
1503             if (countFileSize) {
1504                 totalFileSize += item.size();
1505             }
1506         }
1507     }
1508     emitStatusBarText(folderCount, fileCount, totalFileSize, NoSelection);
1509 }
1510
1511 void DolphinView::updateSortRole(const QByteArray &role)
1512 {
1513     ViewProperties props(viewPropertiesUrl());
1514     props.setSortRole(role);
1515
1516     KItemModelBase *model = m_container->controller()->model();
1517     model->setSortRole(role);
1518
1519     Q_EMIT sortRoleChanged(role);
1520 }
1521
1522 void DolphinView::updateSortOrder(Qt::SortOrder order)
1523 {
1524     ViewProperties props(viewPropertiesUrl());
1525     props.setSortOrder(order);
1526
1527     m_model->setSortOrder(order);
1528
1529     Q_EMIT sortOrderChanged(order);
1530 }
1531
1532 void DolphinView::updateSortFoldersFirst(bool foldersFirst)
1533 {
1534     ViewProperties props(viewPropertiesUrl());
1535     props.setSortFoldersFirst(foldersFirst);
1536
1537     m_model->setSortDirectoriesFirst(foldersFirst);
1538
1539     Q_EMIT sortFoldersFirstChanged(foldersFirst);
1540 }
1541
1542 void DolphinView::updateSortHiddenLast(bool hiddenLast)
1543 {
1544     ViewProperties props(viewPropertiesUrl());
1545     props.setSortHiddenLast(hiddenLast);
1546
1547     m_model->setSortHiddenLast(hiddenLast);
1548
1549     Q_EMIT sortHiddenLastChanged(hiddenLast);
1550 }
1551
1552 QPair<bool, QString> DolphinView::pasteInfo() const
1553 {
1554     const QMimeData *mimeData = QApplication::clipboard()->mimeData();
1555     QPair<bool, QString> info;
1556     info.second = KIO::pasteActionText(mimeData, &info.first, rootItem());
1557     return info;
1558 }
1559
1560 void DolphinView::setTabsForFilesEnabled(bool tabsForFiles)
1561 {
1562     m_tabsForFiles = tabsForFiles;
1563 }
1564
1565 bool DolphinView::isTabsForFilesEnabled() const
1566 {
1567     return m_tabsForFiles;
1568 }
1569
1570 bool DolphinView::itemsExpandable() const
1571 {
1572     return m_mode == DetailsView;
1573 }
1574
1575 bool DolphinView::isExpanded(const KFileItem &item) const
1576 {
1577     Q_ASSERT(item.isDir());
1578     Q_ASSERT(items().contains(item));
1579     if (!itemsExpandable()) {
1580         return false;
1581     }
1582     return m_model->isExpanded(m_model->index(item));
1583 }
1584
1585 void DolphinView::restoreState(QDataStream &stream)
1586 {
1587     // Read the version number of the view state and check if the version is supported.
1588     quint32 version = 0;
1589     stream >> version;
1590     if (version != 1) {
1591         // The version of the view state isn't supported, we can't restore it.
1592         return;
1593     }
1594
1595     // Restore the current item that had the keyboard focus
1596     stream >> m_currentItemUrl;
1597
1598     // Restore the previously selected items
1599     stream >> m_selectedUrls;
1600
1601     // Restore the view position
1602     stream >> m_restoredContentsPosition;
1603
1604     // Restore expanded folders (only relevant for the details view - will be ignored by the view in other view modes)
1605     QSet<QUrl> urls;
1606     stream >> urls;
1607     m_model->restoreExpandedDirectories(urls);
1608 }
1609
1610 void DolphinView::saveState(QDataStream &stream)
1611 {
1612     stream << quint32(1); // View state version
1613
1614     // Save the current item that has the keyboard focus
1615     const int currentIndex = m_container->controller()->selectionManager()->currentItem();
1616     if (currentIndex != -1) {
1617         KFileItem item = m_model->fileItem(currentIndex);
1618         Q_ASSERT(!item.isNull()); // If the current index is valid a item must exist
1619         QUrl currentItemUrl = item.url();
1620         stream << currentItemUrl;
1621     } else {
1622         stream << QUrl();
1623     }
1624
1625     // Save the selected urls
1626     stream << selectedItems().urlList();
1627
1628     // Save view position
1629     const qreal x = m_container->horizontalScrollBar()->value();
1630     const qreal y = m_container->verticalScrollBar()->value();
1631     stream << QPoint(x, y);
1632
1633     // Save expanded folders (only relevant for the details view - the set will be empty in other view modes)
1634     stream << m_model->expandedDirectories();
1635 }
1636
1637 KFileItem DolphinView::rootItem() const
1638 {
1639     return m_model->rootItem();
1640 }
1641
1642 void DolphinView::setViewPropertiesContext(const QString &context)
1643 {
1644     m_viewPropertiesContext = context;
1645 }
1646
1647 QString DolphinView::viewPropertiesContext() const
1648 {
1649     return m_viewPropertiesContext;
1650 }
1651
1652 QUrl DolphinView::openItemAsFolderUrl(const KFileItem &item, const bool browseThroughArchives)
1653 {
1654     if (item.isNull()) {
1655         return QUrl();
1656     }
1657
1658     QUrl url = item.targetUrl();
1659
1660     if (item.isDir()) {
1661         return url;
1662     }
1663
1664     if (item.isMimeTypeKnown()) {
1665         const QString &mimetype = item.mimetype();
1666
1667         if (browseThroughArchives && item.isFile() && url.isLocalFile()) {
1668             // Generic mechanism for redirecting to tar:/<path>/ when clicking on a tar file,
1669             // zip:/<path>/ when clicking on a zip file, etc.
1670             // The .protocol file specifies the mimetype that the kioslave handles.
1671             // Note that we don't use mimetype inheritance since we don't want to
1672             // open OpenDocument files as zip folders...
1673             const QString &protocol = KProtocolManager::protocolForArchiveMimetype(mimetype);
1674             if (!protocol.isEmpty()) {
1675                 url.setScheme(protocol);
1676                 return url;
1677             }
1678         }
1679
1680         if (mimetype == QLatin1String("application/x-desktop")) {
1681             // Redirect to the URL in Type=Link desktop files, unless it is a http(s) URL.
1682             KDesktopFile desktopFile(url.toLocalFile());
1683             if (desktopFile.hasLinkType()) {
1684                 const QString linkUrl = desktopFile.readUrl();
1685                 if (!linkUrl.startsWith(QLatin1String("http"))) {
1686                     return QUrl::fromUserInput(linkUrl);
1687                 }
1688             }
1689         }
1690     }
1691
1692     return QUrl();
1693 }
1694
1695 void DolphinView::resetZoomLevel()
1696 {
1697     ViewModeSettings settings{m_mode};
1698     settings.useDefaults(true);
1699     const int defaultIconSize = settings.iconSize();
1700     settings.useDefaults(false);
1701
1702     setZoomLevel(ZoomLevelInfo::zoomLevelForIconSize(QSize(defaultIconSize, defaultIconSize)));
1703 }
1704
1705 void DolphinView::observeCreatedItem(const QUrl &url)
1706 {
1707     if (m_active) {
1708         forceUrlsSelection(url, {url});
1709     }
1710 }
1711
1712 void DolphinView::slotDirectoryRedirection(const QUrl &oldUrl, const QUrl &newUrl)
1713 {
1714     if (oldUrl.matches(url(), QUrl::StripTrailingSlash)) {
1715         Q_EMIT redirection(oldUrl, newUrl);
1716         m_url = newUrl; // #186947
1717     }
1718 }
1719
1720 void DolphinView::updateSelectionState()
1721 {
1722     if (!m_selectedUrls.isEmpty()) {
1723         KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
1724
1725         // if there is a selection already, leave it that way
1726         // unless some drop/paste job are in the process of creating items
1727         if (!selectionManager->hasSelection() || m_selectJobCreatedItems) {
1728             if (m_clearSelectionBeforeSelectingNewItems) {
1729                 selectionManager->clearSelection();
1730                 m_clearSelectionBeforeSelectingNewItems = false;
1731             }
1732
1733             KItemSet selectedItems = selectionManager->selectedItems();
1734
1735             QList<QUrl>::iterator it = m_selectedUrls.begin();
1736             while (it != m_selectedUrls.end()) {
1737                 const int index = m_model->index(*it);
1738                 if (index >= 0) {
1739                     selectedItems.insert(index);
1740                     it = m_selectedUrls.erase(it);
1741                 } else {
1742                     ++it;
1743                 }
1744             }
1745
1746             if (!selectedItems.isEmpty()) {
1747                 selectionManager->beginAnchoredSelection(selectionManager->currentItem());
1748                 selectionManager->setSelectedItems(selectedItems);
1749             }
1750         }
1751     }
1752 }
1753
1754 void DolphinView::updateViewState()
1755 {
1756     if (m_currentItemUrl != QUrl()) {
1757         KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
1758
1759         // if there is a selection already, leave it that way
1760         if (!selectionManager->hasSelection()) {
1761             const int currentIndex = m_model->index(m_currentItemUrl);
1762             if (currentIndex != -1) {
1763                 selectionManager->setCurrentItem(currentIndex);
1764
1765                 // scroll to current item and reset the state
1766                 if (m_scrollToCurrentItem) {
1767                     m_view->scrollToItem(currentIndex);
1768                     m_scrollToCurrentItem = false;
1769                 }
1770                 m_currentItemUrl = QUrl();
1771             } else {
1772                 selectionManager->setCurrentItem(0);
1773             }
1774         } else {
1775             m_currentItemUrl = QUrl();
1776         }
1777     }
1778
1779     if (!m_restoredContentsPosition.isNull()) {
1780         const int x = m_restoredContentsPosition.x();
1781         const int y = m_restoredContentsPosition.y();
1782         m_restoredContentsPosition = QPoint();
1783
1784         m_container->horizontalScrollBar()->setValue(x);
1785         m_container->verticalScrollBar()->setValue(y);
1786     }
1787
1788     updateSelectionState();
1789 }
1790
1791 void DolphinView::hideToolTip(const ToolTipManager::HideBehavior behavior)
1792 {
1793     if (GeneralSettings::showToolTips()) {
1794 #if HAVE_BALOO
1795         m_toolTipManager->hideToolTip(behavior);
1796 #else
1797         Q_UNUSED(behavior)
1798 #endif
1799     } else if (m_mode == DolphinView::IconsView) {
1800         QToolTip::hideText();
1801     }
1802 }
1803
1804 bool DolphinView::handleSpaceAsNormalKey() const
1805 {
1806     return !m_container->hasFocus() || m_container->controller()->isSearchAsYouTypeActive();
1807 }
1808
1809 void DolphinView::slotTwoClicksRenamingTimerTimeout()
1810 {
1811     const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
1812
1813     // verify that only one item is selected
1814     if (selectionManager->selectedItems().count() == 1) {
1815         const int index = selectionManager->currentItem();
1816         const QUrl fileItemUrl = m_model->fileItem(index).url();
1817
1818         // check if the selected item was the same item that started the twoClicksRenaming
1819         if (fileItemUrl.isValid() && m_twoClicksRenamingItemUrl == fileItemUrl) {
1820             renameSelectedItems();
1821         }
1822     }
1823 }
1824
1825 void DolphinView::slotTrashFileFinished(KJob *job)
1826 {
1827     if (job->error() == 0) {
1828         selectNextItem(); // Fixes BUG: 419914 via selecting next item
1829         Q_EMIT operationCompletedMessage(i18nc("@info:status", "Trash operation completed."));
1830     } else if (job->error() != KIO::ERR_USER_CANCELED) {
1831         Q_EMIT errorMessage(job->errorString());
1832     }
1833 }
1834
1835 void DolphinView::slotDeleteFileFinished(KJob *job)
1836 {
1837     if (job->error() == 0) {
1838         selectNextItem(); // Fixes BUG: 419914 via selecting next item
1839         Q_EMIT operationCompletedMessage(i18nc("@info:status", "Delete operation completed."));
1840     } else if (job->error() != KIO::ERR_USER_CANCELED) {
1841         Q_EMIT errorMessage(job->errorString());
1842     }
1843 }
1844
1845 void DolphinView::selectNextItem()
1846 {
1847     if (m_active && m_selectNextItem) {
1848         KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
1849         if (selectedItems().isEmpty()) {
1850             Q_ASSERT_X(false, "DolphinView", "Selecting the next item failed.");
1851             return;
1852         }
1853         const auto lastSelectedIndex = m_model->index(selectedItems().last());
1854         if (lastSelectedIndex < 0) {
1855             Q_ASSERT_X(false, "DolphinView", "Selecting the next item failed.");
1856             return;
1857         }
1858         auto nextItem = lastSelectedIndex + 1;
1859         if (nextItem >= itemsCount()) {
1860             nextItem = lastSelectedIndex - selectedItemsCount();
1861         }
1862         if (nextItem >= 0) {
1863             selectionManager->setSelected(nextItem, 1);
1864         }
1865         m_selectNextItem = false;
1866     }
1867 }
1868
1869 void DolphinView::slotRenamingResult(KJob *job)
1870 {
1871     if (job->error()) {
1872         KIO::CopyJob *copyJob = qobject_cast<KIO::CopyJob *>(job);
1873         Q_ASSERT(copyJob);
1874         const QUrl newUrl = copyJob->destUrl();
1875         const int index = m_model->index(newUrl);
1876         if (index >= 0) {
1877             QHash<QByteArray, QVariant> data;
1878             const QUrl oldUrl = copyJob->srcUrls().at(0);
1879             data.insert("text", oldUrl.fileName());
1880             m_model->setData(index, data);
1881         }
1882     }
1883 }
1884
1885 void DolphinView::slotDirectoryLoadingStarted()
1886 {
1887     m_loadingState = LoadingState::Loading;
1888     updatePlaceholderLabel();
1889
1890     // Disable the writestate temporary until it can be determined in a fast way
1891     // in DolphinView::slotDirectoryLoadingCompleted()
1892     if (m_isFolderWritable) {
1893         m_isFolderWritable = false;
1894         Q_EMIT writeStateChanged(m_isFolderWritable);
1895     }
1896
1897     Q_EMIT directoryLoadingStarted();
1898 }
1899
1900 void DolphinView::slotDirectoryLoadingCompleted()
1901 {
1902     m_loadingState = LoadingState::Completed;
1903
1904     // Update the view-state. This has to be done asynchronously
1905     // because the view might not be in its final state yet.
1906     QTimer::singleShot(0, this, &DolphinView::updateViewState);
1907
1908     // Update the placeholder label in case we found that the folder was empty
1909     // after loading it
1910
1911     Q_EMIT directoryLoadingCompleted();
1912
1913     updatePlaceholderLabel();
1914     updateWritableState();
1915 }
1916
1917 void DolphinView::slotDirectoryLoadingCanceled()
1918 {
1919     m_loadingState = LoadingState::Canceled;
1920
1921     updatePlaceholderLabel();
1922
1923     Q_EMIT directoryLoadingCanceled();
1924 }
1925
1926 void DolphinView::slotItemsChanged()
1927 {
1928     m_assureVisibleCurrentIndex = false;
1929 }
1930
1931 void DolphinView::slotSortOrderChangedByHeader(Qt::SortOrder current, Qt::SortOrder previous)
1932 {
1933     Q_UNUSED(previous)
1934     Q_ASSERT(m_model->sortOrder() == current);
1935
1936     ViewProperties props(viewPropertiesUrl());
1937     props.setSortOrder(current);
1938
1939     Q_EMIT sortOrderChanged(current);
1940 }
1941
1942 void DolphinView::slotSortRoleChangedByHeader(const QByteArray &current, const QByteArray &previous)
1943 {
1944     Q_UNUSED(previous)
1945     Q_ASSERT(m_model->sortRole() == current);
1946
1947     ViewProperties props(viewPropertiesUrl());
1948     props.setSortRole(current);
1949
1950     Q_EMIT sortRoleChanged(current);
1951 }
1952
1953 void DolphinView::slotVisibleRolesChangedByHeader(const QList<QByteArray> &current, const QList<QByteArray> &previous)
1954 {
1955     Q_UNUSED(previous)
1956     Q_ASSERT(m_container->controller()->view()->visibleRoles() == current);
1957
1958     const QList<QByteArray> previousVisibleRoles = m_visibleRoles;
1959
1960     m_visibleRoles = current;
1961
1962     ViewProperties props(viewPropertiesUrl());
1963     props.setVisibleRoles(m_visibleRoles);
1964
1965     Q_EMIT visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
1966 }
1967
1968 void DolphinView::slotRoleEditingCanceled()
1969 {
1970     disconnect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
1971 }
1972
1973 void DolphinView::slotRoleEditingFinished(int index, const QByteArray &role, const QVariant &value)
1974 {
1975     disconnect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
1976
1977     const KFileItemList items = selectedItems();
1978     if (items.count() != 1) {
1979         return;
1980     }
1981
1982     if (role == "text") {
1983         const KFileItem oldItem = items.first();
1984         const EditResult retVal = value.value<EditResult>();
1985         const QString newName = retVal.newName;
1986         if (!newName.isEmpty() && newName != oldItem.text() && newName != QLatin1Char('.') && newName != QLatin1String("..")) {
1987             const QUrl oldUrl = oldItem.url();
1988
1989             QUrl newUrl = oldUrl.adjusted(QUrl::RemoveFilename);
1990             newUrl.setPath(newUrl.path() + KIO::encodeFileName(newName));
1991
1992 #ifndef Q_OS_WIN
1993             // Confirm hiding file/directory by renaming inline
1994             if (!hiddenFilesShown() && newName.startsWith(QLatin1Char('.')) && !oldItem.name().startsWith(QLatin1Char('.'))) {
1995                 KGuiItem yesGuiItem(i18nc("@action:button", "Rename and Hide"), QStringLiteral("view-hidden"));
1996
1997 #if KWIDGETSADDONS_VERSION >= QT_VERSION_CHECK(5, 100, 0)
1998                 const auto code =
1999                     KMessageBox::questionTwoActions(this,
2000 #else
2001                 const auto code =
2002                     KMessageBox::questionYesNo(this,
2003 #endif
2004                                                     oldItem.isFile() ? i18n("Adding a dot to the beginning of this file's name will hide it from view.\n"
2005                                                                             "Do you still want to rename it?")
2006                                                                      : i18n("Adding a dot to the beginning of this folder's name will hide it from view.\n"
2007                                                                             "Do you still want to rename it?"),
2008                                                     oldItem.isFile() ? i18n("Hide this File?") : i18n("Hide this Folder?"),
2009                                                     yesGuiItem,
2010                                                     KStandardGuiItem::cancel(),
2011                                                     QStringLiteral("ConfirmHide"));
2012
2013 #if KWIDGETSADDONS_VERSION >= QT_VERSION_CHECK(5, 100, 0)
2014                 if (code == KMessageBox::SecondaryAction) {
2015 #else
2016                 if (code == KMessageBox::No) {
2017 #endif
2018                     return;
2019                 }
2020             }
2021 #endif
2022
2023             const bool newNameExistsAlready = (m_model->index(newUrl) >= 0);
2024             if (!newNameExistsAlready && m_model->index(oldUrl) == index) {
2025                 // Only change the data in the model if no item with the new name
2026                 // is in the model yet. If there is an item with the new name
2027                 // already, calling KIO::CopyJob will open a dialog
2028                 // asking for a new name, and KFileItemModel will update the
2029                 // data when the dir lister signals that the file name has changed.
2030                 QHash<QByteArray, QVariant> data;
2031                 data.insert(role, retVal.newName);
2032                 m_model->setData(index, data);
2033             }
2034
2035             KIO::Job *job = KIO::moveAs(oldUrl, newUrl);
2036             KJobWidgets::setWindow(job, this);
2037             KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Rename, {oldUrl}, newUrl, job);
2038             job->uiDelegate()->setAutoErrorHandlingEnabled(true);
2039
2040             forceUrlsSelection(newUrl, {newUrl});
2041
2042             if (!newNameExistsAlready) {
2043                 // Only connect the result signal if there is no item with the new name
2044                 // in the model yet, see bug 328262.
2045                 connect(job, &KJob::result, this, &DolphinView::slotRenamingResult);
2046             }
2047         }
2048         if (retVal.direction != EditDone) {
2049             const short indexShift = retVal.direction == EditNext ? 1 : -1;
2050             m_container->controller()->selectionManager()->setSelected(index, 1, KItemListSelectionManager::Deselect);
2051             m_container->controller()->selectionManager()->setSelected(index + indexShift, 1, KItemListSelectionManager::Select);
2052             renameSelectedItems();
2053         }
2054     }
2055 }
2056
2057 void DolphinView::loadDirectory(const QUrl &url, bool reload)
2058 {
2059     if (!url.isValid()) {
2060         const QString location(url.toDisplayString(QUrl::PreferLocalFile));
2061         if (location.isEmpty()) {
2062             Q_EMIT errorMessage(i18nc("@info:status", "The location is empty."));
2063         } else {
2064             Q_EMIT errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location));
2065         }
2066         return;
2067     }
2068
2069     if (reload) {
2070         m_model->refreshDirectory(url);
2071     } else {
2072         m_model->loadDirectory(url);
2073     }
2074 }
2075
2076 void DolphinView::applyViewProperties()
2077 {
2078     const ViewProperties props(viewPropertiesUrl());
2079     applyViewProperties(props);
2080 }
2081
2082 void DolphinView::applyViewProperties(const ViewProperties &props)
2083 {
2084     m_view->beginTransaction();
2085
2086     const Mode mode = props.viewMode();
2087     if (m_mode != mode) {
2088         const Mode previousMode = m_mode;
2089         m_mode = mode;
2090
2091         // Changing the mode might result in changing
2092         // the zoom level. Remember the old zoom level so
2093         // that zoomLevelChanged() can get emitted.
2094         const int oldZoomLevel = m_view->zoomLevel();
2095         applyModeToView();
2096
2097         Q_EMIT modeChanged(m_mode, previousMode);
2098
2099         if (m_view->zoomLevel() != oldZoomLevel) {
2100             Q_EMIT zoomLevelChanged(m_view->zoomLevel(), oldZoomLevel);
2101         }
2102     }
2103
2104     const bool hiddenFilesShown = props.hiddenFilesShown();
2105     if (hiddenFilesShown != m_model->showHiddenFiles()) {
2106         m_model->setShowHiddenFiles(hiddenFilesShown);
2107         Q_EMIT hiddenFilesShownChanged(hiddenFilesShown);
2108     }
2109
2110     const bool groupedSorting = props.groupedSorting();
2111     if (groupedSorting != m_model->groupedSorting()) {
2112         m_model->setGroupedSorting(groupedSorting);
2113         Q_EMIT groupedSortingChanged(groupedSorting);
2114     }
2115
2116     const QByteArray sortRole = props.sortRole();
2117     if (sortRole != m_model->sortRole()) {
2118         m_model->setSortRole(sortRole);
2119         Q_EMIT sortRoleChanged(sortRole);
2120     }
2121
2122     const Qt::SortOrder sortOrder = props.sortOrder();
2123     if (sortOrder != m_model->sortOrder()) {
2124         m_model->setSortOrder(sortOrder);
2125         Q_EMIT sortOrderChanged(sortOrder);
2126     }
2127
2128     const bool sortFoldersFirst = props.sortFoldersFirst();
2129     if (sortFoldersFirst != m_model->sortDirectoriesFirst()) {
2130         m_model->setSortDirectoriesFirst(sortFoldersFirst);
2131         Q_EMIT sortFoldersFirstChanged(sortFoldersFirst);
2132     }
2133
2134     const bool sortHiddenLast = props.sortHiddenLast();
2135     if (sortHiddenLast != m_model->sortHiddenLast()) {
2136         m_model->setSortHiddenLast(sortHiddenLast);
2137         Q_EMIT sortHiddenLastChanged(sortHiddenLast);
2138     }
2139
2140     const QList<QByteArray> visibleRoles = props.visibleRoles();
2141     if (visibleRoles != m_visibleRoles) {
2142         const QList<QByteArray> previousVisibleRoles = m_visibleRoles;
2143         m_visibleRoles = visibleRoles;
2144         m_view->setVisibleRoles(visibleRoles);
2145         Q_EMIT visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
2146     }
2147
2148     const bool previewsShown = props.previewsShown();
2149     if (previewsShown != m_view->previewsShown()) {
2150         const int oldZoomLevel = zoomLevel();
2151
2152         m_view->setPreviewsShown(previewsShown);
2153         Q_EMIT previewsShownChanged(previewsShown);
2154
2155         // Changing the preview-state might result in a changed zoom-level
2156         if (oldZoomLevel != zoomLevel()) {
2157             Q_EMIT zoomLevelChanged(zoomLevel(), oldZoomLevel);
2158         }
2159     }
2160
2161     KItemListView *itemListView = m_container->controller()->view();
2162     if (itemListView->isHeaderVisible()) {
2163         KItemListHeader *header = itemListView->header();
2164         const QList<int> headerColumnWidths = props.headerColumnWidths();
2165         const int rolesCount = m_visibleRoles.count();
2166         if (headerColumnWidths.count() == rolesCount) {
2167             header->setAutomaticColumnResizing(false);
2168
2169             QHash<QByteArray, qreal> columnWidths;
2170             for (int i = 0; i < rolesCount; ++i) {
2171                 columnWidths.insert(m_visibleRoles[i], headerColumnWidths[i]);
2172             }
2173             header->setColumnWidths(columnWidths);
2174         } else {
2175             header->setAutomaticColumnResizing(true);
2176         }
2177         header->setSidePadding(DetailsModeSettings::sidePadding());
2178     }
2179
2180     m_view->endTransaction();
2181 }
2182
2183 void DolphinView::applyModeToView()
2184 {
2185     switch (m_mode) {
2186     case IconsView:
2187         m_view->setItemLayout(KFileItemListView::IconsLayout);
2188         break;
2189     case CompactView:
2190         m_view->setItemLayout(KFileItemListView::CompactLayout);
2191         break;
2192     case DetailsView:
2193         m_view->setItemLayout(KFileItemListView::DetailsLayout);
2194         break;
2195     default:
2196         Q_ASSERT(false);
2197         break;
2198     }
2199 }
2200
2201 void DolphinView::pasteToUrl(const QUrl &url)
2202 {
2203     KIO::PasteJob *job = KIO::paste(QApplication::clipboard()->mimeData(), url);
2204     KJobWidgets::setWindow(job, this);
2205     m_clearSelectionBeforeSelectingNewItems = true;
2206     m_markFirstNewlySelectedItemAsCurrent = true;
2207     m_selectJobCreatedItems = true;
2208     // TODO KF6 use KIO::PasteJob::copyJobStarted to hook to earlier events copying/moving
2209     connect(job, &KIO::PasteJob::itemCreated, this, &DolphinView::slotItemCreated);
2210     connect(job, &KIO::PasteJob::result, this, &DolphinView::slotJobResult);
2211 }
2212
2213 QList<QUrl> DolphinView::simplifiedSelectedUrls() const
2214 {
2215     QList<QUrl> urls;
2216
2217     const KFileItemList items = selectedItems();
2218     urls.reserve(items.count());
2219     for (const KFileItem &item : items) {
2220         urls.append(item.url());
2221     }
2222
2223     if (itemsExpandable()) {
2224         // TODO: Check if we still need KDirModel for this in KDE 5.0
2225         urls = KDirModel::simplifiedUrlList(urls);
2226     }
2227
2228     return urls;
2229 }
2230
2231 QMimeData *DolphinView::selectionMimeData() const
2232 {
2233     const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
2234     const KItemSet selectedIndexes = selectionManager->selectedItems();
2235
2236     return m_model->createMimeData(selectedIndexes);
2237 }
2238
2239 void DolphinView::updateWritableState()
2240 {
2241     const bool wasFolderWritable = m_isFolderWritable;
2242     m_isFolderWritable = false;
2243
2244     KFileItem item = m_model->rootItem();
2245     if (item.isNull()) {
2246         // Try to find out if the URL is writable even if the "root item" is
2247         // null, see https://bugs.kde.org/show_bug.cgi?id=330001
2248         item = KFileItem(url());
2249         item.setDelayedMimeTypes(true);
2250     }
2251
2252     KFileItemListProperties capabilities(KFileItemList() << item);
2253     m_isFolderWritable = capabilities.supportsWriting();
2254
2255     if (m_isFolderWritable != wasFolderWritable) {
2256         Q_EMIT writeStateChanged(m_isFolderWritable);
2257     }
2258 }
2259
2260 QUrl DolphinView::viewPropertiesUrl() const
2261 {
2262     if (m_viewPropertiesContext.isEmpty()) {
2263         return m_url;
2264     }
2265
2266     QUrl url;
2267     url.setScheme(m_url.scheme());
2268     url.setPath(m_viewPropertiesContext);
2269     return url;
2270 }
2271
2272 void DolphinView::slotRenameDialogRenamingFinished(const QList<QUrl> &urls)
2273 {
2274     forceUrlsSelection(urls.first(), urls);
2275 }
2276
2277 void DolphinView::forceUrlsSelection(const QUrl &current, const QList<QUrl> &selected)
2278 {
2279     clearSelection();
2280     m_clearSelectionBeforeSelectingNewItems = true;
2281     markUrlAsCurrent(current);
2282     markUrlsAsSelected(selected);
2283 }
2284
2285 void DolphinView::copyPathToClipboard()
2286 {
2287     const KFileItemList list = selectedItems();
2288     if (list.isEmpty()) {
2289         return;
2290     }
2291     const KFileItem &item = list.at(0);
2292     QString path = item.localPath();
2293     if (path.isEmpty()) {
2294         path = item.url().toDisplayString();
2295     }
2296     QClipboard *clipboard = QApplication::clipboard();
2297     if (clipboard == nullptr) {
2298         return;
2299     }
2300     clipboard->setText(path);
2301 }
2302
2303 void DolphinView::slotIncreaseZoom()
2304 {
2305     setZoomLevel(zoomLevel() + 1);
2306 }
2307
2308 void DolphinView::slotDecreaseZoom()
2309 {
2310     setZoomLevel(zoomLevel() - 1);
2311 }
2312
2313 void DolphinView::slotSwipeUp()
2314 {
2315     Q_EMIT goUpRequested();
2316 }
2317
2318 void DolphinView::showLoadingPlaceholder()
2319 {
2320     m_placeholderLabel->setText(i18n("Loading..."));
2321     m_placeholderLabel->setVisible(true);
2322 }
2323
2324 void DolphinView::updatePlaceholderLabel()
2325 {
2326     m_showLoadingPlaceholderTimer->stop();
2327     if (itemsCount() > 0) {
2328         m_placeholderLabel->setVisible(false);
2329         return;
2330     }
2331
2332     if (m_loadingState == LoadingState::Loading) {
2333         m_placeholderLabel->setVisible(false);
2334         m_showLoadingPlaceholderTimer->start();
2335         return;
2336     }
2337
2338     if (m_loadingState == LoadingState::Canceled) {
2339         m_placeholderLabel->setText(i18n("Loading canceled"));
2340     } else if (!nameFilter().isEmpty()) {
2341         m_placeholderLabel->setText(i18n("No items matching the filter"));
2342     } else if (m_url.scheme() == QLatin1String("baloosearch") || m_url.scheme() == QLatin1String("filenamesearch")) {
2343         m_placeholderLabel->setText(i18n("No items matching the search"));
2344     } else if (m_url.scheme() == QLatin1String("trash") && m_url.path() == QLatin1String("/")) {
2345         m_placeholderLabel->setText(i18n("Trash is empty"));
2346     } else if (m_url.scheme() == QLatin1String("tags")) {
2347         if (m_url.path() == QLatin1Char('/')) {
2348             m_placeholderLabel->setText(i18n("No tags"));
2349         } else {
2350             const QString tagName = m_url.path().mid(1); // Remove leading /
2351             m_placeholderLabel->setText(i18n("No files tagged with \"%1\"", tagName));
2352         }
2353
2354     } else if (m_url.scheme() == QLatin1String("recentlyused")) {
2355         m_placeholderLabel->setText(i18n("No recently used items"));
2356     } else if (m_url.scheme() == QLatin1String("smb")) {
2357         m_placeholderLabel->setText(i18n("No shared folders found"));
2358     } else if (m_url.scheme() == QLatin1String("network")) {
2359         m_placeholderLabel->setText(i18n("No relevant network resources found"));
2360     } else if (m_url.scheme() == QLatin1String("mtp") && m_url.path() == QLatin1String("/")) {
2361         m_placeholderLabel->setText(i18n("No MTP-compatible devices found"));
2362     } else if (m_url.scheme() == QLatin1String("afc") && m_url.path() == QLatin1String("/")) {
2363         m_placeholderLabel->setText(i18n("No Apple devices found"));
2364     } else if (m_url.scheme() == QLatin1String("bluetooth")) {
2365         m_placeholderLabel->setText(i18n("No Bluetooth devices found"));
2366     } else {
2367         m_placeholderLabel->setText(i18n("Folder is empty"));
2368     }
2369
2370     m_placeholderLabel->setVisible(true);
2371 }
2372
2373 bool DolphinView::tryShowNameToolTip(QHelpEvent *event)
2374 {
2375     if (!GeneralSettings::showToolTips() && m_mode == DolphinView::IconsView) {
2376         const std::optional<int> index = m_view->itemAt(event->pos());
2377
2378         if (!index.has_value()) {
2379             return false;
2380         }
2381
2382         // Check whether the filename has been elided
2383         const bool isElided = m_view->isElided(index.value());
2384
2385         if (isElided) {
2386             const KFileItem item = m_model->fileItem(index.value());
2387             const QString text = item.text();
2388             const QPoint pos = mapToGlobal(event->pos());
2389             QToolTip::showText(pos, text);
2390             return true;
2391         }
2392     }
2393     return false;
2394 }