#include "dolphinview.h"
-#include "dolphin_generalsettings.h"
#include "dolphin_detailsmodesettings.h"
+#include "dolphin_generalsettings.h"
#include "dolphinitemlistview.h"
#include "dolphinnewfilemenuobserver.h"
#include "draganddrophelper.h"
+#ifndef QT_NO_ACCESSIBILITY
+#include "kitemviews/accessibility/kitemlistviewaccessible.h"
+#endif
#include "kitemviews/kfileitemlistview.h"
#include "kitemviews/kfileitemmodel.h"
#include "kitemviews/kitemlistcontainer.h"
#include "kitemviews/kitemlistheader.h"
#include "kitemviews/kitemlistselectionmanager.h"
#include "kitemviews/private/kitemlistroleeditor.h"
-#include "settings/viewmodes/viewmodesettings.h"
#include "selectionmode/singleclickselectionproxystyle.h"
+#include "settings/viewmodes/viewmodesettings.h"
#include "versioncontrol/versioncontrolobserver.h"
#include "viewproperties.h"
#include "views/tooltips/tooltipmanager.h"
#include <KFileItemListProperties>
#include <KFormat>
#include <KIO/CopyJob>
-#include <KIO/DeleteJob>
+#include <KIO/DeleteOrTrashJob>
#include <KIO/DropJob>
#include <KIO/JobUiDelegate>
#include <KIO/Paste>
#include <KProtocolManager>
#include <KUrlMimeData>
+#include <kwidgetsaddons_version.h>
+
#include <QAbstractItemView>
+#ifndef QT_NO_ACCESSIBILITY
+#include <QAccessible>
+#endif
#include <QActionGroup>
#include <QApplication>
#include <QClipboard>
#include <QToolTip>
#include <QVBoxLayout>
-DolphinView::DolphinView(const QUrl& url, QWidget* parent) :
- QWidget(parent),
- m_active(true),
- m_tabsForFiles(false),
- m_assureVisibleCurrentIndex(false),
- m_isFolderWritable(true),
- m_dragging(false),
- m_url(url),
- m_viewPropertiesContext(),
- m_mode(DolphinView::IconsView),
- m_visibleRoles(),
- m_topLayout(nullptr),
- m_model(nullptr),
- m_view(nullptr),
- m_container(nullptr),
- m_toolTipManager(nullptr),
- m_selectionChangedTimer(nullptr),
- m_currentItemUrl(),
- m_scrollToCurrentItem(false),
- m_restoredContentsPosition(),
- m_selectedUrls(),
- m_clearSelectionBeforeSelectingNewItems(false),
- m_markFirstNewlySelectedItemAsCurrent(false),
- m_versionControlObserver(nullptr),
- m_twoClicksRenamingTimer(nullptr),
- m_placeholderLabel(nullptr),
- m_showLoadingPlaceholderTimer(nullptr)
+DolphinView::DolphinView(const QUrl &url, QWidget *parent)
+ : QWidget(parent)
+ , m_active(true)
+ , m_tabsForFiles(false)
+ , m_assureVisibleCurrentIndex(false)
+ , m_isFolderWritable(true)
+ , m_dragging(false)
+ , m_selectNextItem(false)
+ , m_url(url)
+ , m_viewPropertiesContext()
+ , m_mode(DolphinView::IconsView)
+ , m_visibleRoles()
+ , m_topLayout(nullptr)
+ , m_model(nullptr)
+ , m_view(nullptr)
+ , m_container(nullptr)
+ , m_toolTipManager(nullptr)
+ , m_selectionChangedTimer(nullptr)
+ , m_currentItemUrl()
+ , m_scrollToCurrentItem(false)
+ , m_restoredContentsPosition()
+ , m_controlWheelAccumulatedDelta(0)
+ , m_selectedUrls()
+ , m_clearSelectionBeforeSelectingNewItems(false)
+ , m_markFirstNewlySelectedItemAsCurrent(false)
+ , m_versionControlObserver(nullptr)
+ , m_twoClicksRenamingTimer(nullptr)
+ , m_placeholderLabel(nullptr)
+ , m_showLoadingPlaceholderTimer(nullptr)
{
m_topLayout = new QVBoxLayout(this);
m_topLayout->setSpacing(0);
// When a new item has been created by the "Create New..." menu, the item should
// get selected and it must be assured that the item will get visible. As the
// creation is done asynchronously, several signals must be checked:
- connect(&DolphinNewFileMenuObserver::instance(), &DolphinNewFileMenuObserver::itemCreated,
- this, &DolphinView::observeCreatedItem);
+ connect(&DolphinNewFileMenuObserver::instance(), &DolphinNewFileMenuObserver::itemCreated, this, &DolphinView::observeCreatedItem);
m_selectionChangedTimer = new QTimer(this);
m_selectionChangedTimer->setSingleShot(true);
m_selectionChangedTimer->setInterval(300);
- connect(m_selectionChangedTimer, &QTimer::timeout,
- this, &DolphinView::emitSelectionChangedSignal);
+ connect(m_selectionChangedTimer, &QTimer::timeout, this, &DolphinView::emitSelectionChangedSignal);
m_model = new KFileItemModel(this);
m_view = new DolphinItemListView();
m_view->setVisibleRoles({"text"});
applyModeToView();
- KItemListController* controller = new KItemListController(m_model, m_view, this);
- const int delay = GeneralSettings::autoExpandFolders() ? 750 : -1;
- controller->setAutoActivationDelay(delay);
+ KItemListController *controller = new KItemListController(m_model, m_view, this);
+ controller->setAutoActivationEnabled(GeneralSettings::autoExpandFolders());
+ connect(controller, &KItemListController::doubleClickViewBackground, this, &DolphinView::doubleClickViewBackground);
// The EnlargeSmallPreviews setting can only be changed after the model
// has been set in the view by KItemListController.
m_container = new KItemListContainer(controller, this);
m_container->installEventFilter(this);
+#ifndef QT_NO_ACCESSIBILITY
+ m_view->setAccessibleParentsObject(m_container);
+#endif
setFocusProxy(m_container);
- connect(m_container->horizontalScrollBar(), &QScrollBar::valueChanged, this, [=] { hideToolTip(); });
- connect(m_container->verticalScrollBar(), &QScrollBar::valueChanged, this, [=] { hideToolTip(); });
+ connect(m_container->horizontalScrollBar(), &QScrollBar::valueChanged, this, [this] {
+ hideToolTip();
+ });
+ connect(m_container->verticalScrollBar(), &QScrollBar::valueChanged, this, [this] {
+ hideToolTip();
+ });
m_showLoadingPlaceholderTimer = new QTimer(this);
m_showLoadingPlaceholderTimer->setInterval(500);
// This is made using a heavily-modified QLabel rather than a KTitleWidget
// because KTitleWidget can't be told to turn off mouse-selectable text
m_placeholderLabel = new QLabel(this);
+ // Don't consume mouse events
+ m_placeholderLabel->setAttribute(Qt::WA_TransparentForMouseEvents);
+
QFont placeholderLabelFont;
// To match the size of a level 2 Heading/KTitleWidget
placeholderLabelFont.setPointSize(qRound(placeholderLabelFont.pointSize() * 1.3));
m_placeholderLabel->setFont(placeholderLabelFont);
- m_placeholderLabel->setTextInteractionFlags(Qt::NoTextInteraction);
m_placeholderLabel->setWordWrap(true);
m_placeholderLabel->setAlignment(Qt::AlignCenter);
// Match opacity of QML placeholder label component
connect(controller, &KItemListController::swipeUp, this, &DolphinView::slotSwipeUp);
connect(controller, &KItemListController::selectionModeChangeRequested, this, &DolphinView::selectionModeChangeRequested);
- connect(m_model, &KFileItemModel::directoryLoadingStarted, this, &DolphinView::slotDirectoryLoadingStarted);
- connect(m_model, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
- connect(m_model, &KFileItemModel::directoryLoadingCanceled, this, &DolphinView::slotDirectoryLoadingCanceled);
- connect(m_model, &KFileItemModel::directoryLoadingProgress, this, &DolphinView::directoryLoadingProgress);
- connect(m_model, &KFileItemModel::directorySortingProgress, this, &DolphinView::directorySortingProgress);
- connect(m_model, &KFileItemModel::itemsChanged,
- this, &DolphinView::slotItemsChanged);
- connect(m_model, &KFileItemModel::itemsRemoved, this, &DolphinView::itemCountChanged);
- connect(m_model, &KFileItemModel::itemsInserted, this, &DolphinView::itemCountChanged);
- connect(m_model, &KFileItemModel::infoMessage, this, &DolphinView::infoMessage);
- connect(m_model, &KFileItemModel::errorMessage, this, &DolphinView::errorMessage);
+ connect(m_model, &KFileItemModel::directoryLoadingStarted, this, &DolphinView::slotDirectoryLoadingStarted);
+ connect(m_model, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
+ connect(m_model, &KFileItemModel::directoryLoadingCanceled, this, &DolphinView::slotDirectoryLoadingCanceled);
+ connect(m_model, &KFileItemModel::directoryLoadingProgress, this, &DolphinView::directoryLoadingProgress);
+ connect(m_model, &KFileItemModel::directorySortingProgress, this, &DolphinView::directorySortingProgress);
+ connect(m_model, &KFileItemModel::itemsChanged, this, &DolphinView::slotItemsChanged);
+ connect(m_model, &KFileItemModel::itemsRemoved, this, &DolphinView::itemCountChanged);
+ connect(m_model, &KFileItemModel::itemsInserted, this, &DolphinView::itemCountChanged);
+ connect(m_model, &KFileItemModel::infoMessage, this, &DolphinView::infoMessage);
+ connect(m_model, &KFileItemModel::errorMessage, this, &DolphinView::errorMessage);
connect(m_model, &KFileItemModel::directoryRedirection, this, &DolphinView::slotDirectoryRedirection);
- connect(m_model, &KFileItemModel::urlIsFileError, this, &DolphinView::urlIsFileError);
- connect(m_model, &KFileItemModel::fileItemsChanged, this, &DolphinView::fileItemsChanged);
+ connect(m_model, &KFileItemModel::urlIsFileError, this, &DolphinView::urlIsFileError);
+ connect(m_model, &KFileItemModel::fileItemsChanged, this, &DolphinView::fileItemsChanged);
+ connect(m_model, &KFileItemModel::currentDirectoryRemoved, this, &DolphinView::currentDirectoryRemoved);
- connect(this, &DolphinView::itemCountChanged,
- this, &DolphinView::updatePlaceholderLabel);
+ connect(this, &DolphinView::itemCountChanged, this, &DolphinView::updatePlaceholderLabel);
m_view->installEventFilter(this);
- connect(m_view, &DolphinItemListView::sortOrderChanged,
- this, &DolphinView::slotSortOrderChangedByHeader);
- connect(m_view, &DolphinItemListView::sortRoleChanged,
- this, &DolphinView::slotSortRoleChangedByHeader);
- connect(m_view, &DolphinItemListView::visibleRolesChanged,
- this, &DolphinView::slotVisibleRolesChangedByHeader);
- connect(m_view, &DolphinItemListView::roleEditingCanceled,
- this, &DolphinView::slotRoleEditingCanceled);
- connect(m_view->header(), &KItemListHeader::columnWidthChangeFinished,
- this, &DolphinView::slotHeaderColumnWidthChangeFinished);
- connect(m_view->header(), &KItemListHeader::sidePaddingChanged,
- this, &DolphinView::slotSidePaddingWidthChanged);
-
- KItemListSelectionManager* selectionManager = controller->selectionManager();
- connect(selectionManager, &KItemListSelectionManager::selectionChanged,
- this, &DolphinView::slotSelectionChanged);
+ connect(m_view, &DolphinItemListView::sortOrderChanged, this, &DolphinView::slotSortOrderChangedByHeader);
+ connect(m_view, &DolphinItemListView::sortRoleChanged, this, &DolphinView::slotSortRoleChangedByHeader);
+ connect(m_view, &DolphinItemListView::visibleRolesChanged, this, &DolphinView::slotVisibleRolesChangedByHeader);
+ connect(m_view, &DolphinItemListView::roleEditingCanceled, this, &DolphinView::slotRoleEditingCanceled);
+
+ connect(m_view, &DolphinItemListView::columnHovered, this, [this](int columnIndex) {
+ m_hoveredColumnHeaderIndex = columnIndex;
+ });
+ connect(m_view, &DolphinItemListView::columnUnHovered, this, [this](int /* columnIndex */) {
+ m_hoveredColumnHeaderIndex = std::nullopt;
+ });
+ connect(m_view->header(), &KItemListHeader::columnWidthChangeFinished, this, &DolphinView::slotHeaderColumnWidthChangeFinished);
+ connect(m_view->header(), &KItemListHeader::sidePaddingChanged, this, &DolphinView::slotSidePaddingWidthChanged);
+
+ KItemListSelectionManager *selectionManager = controller->selectionManager();
+ connect(selectionManager, &KItemListSelectionManager::selectionChanged, this, &DolphinView::slotSelectionChanged);
#if HAVE_BALOO
m_toolTipManager = new ToolTipManager(this);
m_versionControlObserver->setView(this);
m_versionControlObserver->setModel(m_model);
connect(m_versionControlObserver, &VersionControlObserver::infoMessage, this, &DolphinView::infoMessage);
- connect(m_versionControlObserver, &VersionControlObserver::errorMessage, this, &DolphinView::errorMessage);
+ connect(m_versionControlObserver, &VersionControlObserver::errorMessage, this, [this](const QString &message) {
+ Q_EMIT errorMessage(message, KIO::ERR_UNKNOWN);
+ });
connect(m_versionControlObserver, &VersionControlObserver::operationCompletedMessage, this, &DolphinView::operationCompletedMessage);
m_twoClicksRenamingTimer = new QTimer(this);
if (active) {
m_container->setFocus();
Q_EMIT activated();
- Q_EMIT writeStateChanged(m_isFolderWritable);
}
}
void DolphinView::setViewMode(Mode mode)
{
if (mode != m_mode) {
+ // Reset scrollbars before changing the view mode.
+ m_container->horizontalScrollBar()->setValue(0);
+ m_container->verticalScrollBar()->setValue(0);
+
ViewProperties props(viewPropertiesUrl());
props.setViewMode(mode);
void DolphinView::setSelectionModeEnabled(const bool enabled)
{
if (enabled) {
- m_proxyStyle = std::make_unique<SelectionMode::SingleClickSelectionProxyStyle>();
+ if (!m_proxyStyle) {
+ m_proxyStyle = std::make_unique<SelectionMode::SingleClickSelectionProxyStyle>();
+ }
setStyle(m_proxyStyle.get());
m_view->setStyle(m_proxyStyle.get());
m_view->setEnabledSelectionToggles(DolphinItemListView::SelectionTogglesEnabled::False);
} else {
- setStyle(QApplication::style());
- m_view->setStyle(QApplication::style());
+ setStyle(nullptr);
+ m_view->setStyle(nullptr);
m_view->setEnabledSelectionToggles(DolphinItemListView::SelectionTogglesEnabled::FollowSetting);
}
m_container->controller()->setSelectionModeEnabled(enabled);
+#ifndef QT_NO_ACCESSIBILITY
+ if (QAccessible::isActive()) {
+ auto accessibleViewInterface = static_cast<KItemListViewAccessible *>(QAccessible::queryAccessibleInterface(m_view));
+ accessibleViewInterface->announceSelectionModeEnabled(enabled);
+ }
+#endif
}
bool DolphinView::selectionMode() const
ViewProperties props(viewPropertiesUrl());
props.setGroupedSorting(grouped);
- props.save();
- m_container->controller()->model()->setGroupedSorting(grouped);
+ m_model->setGroupedSorting(grouped);
Q_EMIT groupedSortingChanged(grouped);
}
KFileItemList DolphinView::selectedItems() const
{
- const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+ const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
KFileItemList selectedItems;
const auto items = selectionManager->selectedItems();
int DolphinView::selectedItemsCount() const
{
- const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+ const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
return selectionManager->selectedItems().count();
}
-void DolphinView::markUrlsAsSelected(const QList<QUrl>& urls)
+void DolphinView::markUrlsAsSelected(const QList<QUrl> &urls)
{
m_selectedUrls = urls;
+ m_selectJobCreatedItems = false;
}
void DolphinView::markUrlAsCurrent(const QUrl &url)
void DolphinView::selectItems(const QRegularExpression ®exp, bool enabled)
{
- const KItemListSelectionManager::SelectionMode mode = enabled
- ? KItemListSelectionManager::Select
- : KItemListSelectionManager::Deselect;
- KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+ const KItemListSelectionManager::SelectionMode mode = enabled ? KItemListSelectionManager::Select : KItemListSelectionManager::Deselect;
+ KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
for (int index = 0; index < m_model->count(); index++) {
const KFileItem item = m_model->fileItem(index);
return m_view->zoomLevel();
}
-void DolphinView::setSortRole(const QByteArray& role)
+void DolphinView::setSortRole(const QByteArray &role)
{
if (role != sortRole()) {
- updateSortRole(role);
+ ViewProperties props(viewPropertiesUrl());
+ props.setSortRole(role);
+
+ KItemModelBase *model = m_container->controller()->model();
+ model->setSortRole(role);
+
+ Q_EMIT sortRoleChanged(role);
}
}
QByteArray DolphinView::sortRole() const
{
- const KItemModelBase* model = m_container->controller()->model();
+ const KItemModelBase *model = m_container->controller()->model();
return model->sortRole();
}
void DolphinView::setSortOrder(Qt::SortOrder order)
{
if (sortOrder() != order) {
- updateSortOrder(order);
+ ViewProperties props(viewPropertiesUrl());
+ props.setSortOrder(order);
+
+ m_model->setSortOrder(order);
+
+ Q_EMIT sortOrderChanged(order);
}
}
return m_model->sortHiddenLast();
}
-void DolphinView::setVisibleRoles(const QList<QByteArray>& roles)
+void DolphinView::setVisibleRoles(const QList<QByteArray> &roles)
{
const QList<QByteArray> previousRoles = roles;
m_view->readSettings();
applyViewProperties();
- const int delay = GeneralSettings::autoExpandFolders() ? 750 : -1;
- m_container->controller()->setAutoActivationDelay(delay);
+ m_container->controller()->setAutoActivationEnabled(GeneralSettings::autoExpandFolders());
const int newZoomLevel = m_view->zoomLevel();
if (newZoomLevel != oldZoomLevel) {
m_view->writeSettings();
}
-void DolphinView::setNameFilter(const QString& nameFilter)
+void DolphinView::setNameFilter(const QString &nameFilter)
{
m_model->setNameFilter(nameFilter);
}
return m_model->nameFilter();
}
-void DolphinView::setMimeTypeFilters(const QStringList& filters)
+void DolphinView::setMimeTypeFilters(const QStringList &filters)
{
return m_model->setMimeTypeFilters(filters);
}
// Give a summary of the status of the selected files
const KFileItemList list = selectedItems();
- for (const KFileItem& item : list) {
+ for (const KFileItem &item : list) {
if (item.isDir()) {
++folderCount;
} else {
return;
}
- m_statJobForStatusBarText = KIO::statDetails(m_model->rootItem().url(),
- KIO::StatJob::SourceSide, KIO::StatRecursiveSize, KIO::HideProgressInfo);
- connect(m_statJobForStatusBarText, &KJob::result,
- this, &DolphinView::slotStatJobResult);
+ m_statJobForStatusBarText = KIO::stat(m_model->rootItem().url(), KIO::StatJob::SourceSide, KIO::StatRecursiveSize, KIO::HideProgressInfo);
+ connect(m_statJobForStatusBarText, &KJob::result, this, &DolphinView::slotStatJobResult);
m_statJobForStatusBarText->start();
}
}
-void DolphinView::emitStatusBarText(const int folderCount, const int fileCount,
- KIO::filesize_t totalFileSize, const Selection selection)
+void DolphinView::emitStatusBarText(const int folderCount, const int fileCount, KIO::filesize_t totalFileSize, const Selection selection)
{
QString foldersText;
QString filesText;
if (selection == HasSelection) {
// At least 2 items are selected because the case of 1 selected item is handled in
// DolphinView::requestStatusBarText().
- foldersText = i18ncp("@info:status", "1 Folder selected", "%1 Folders selected", folderCount);
- filesText = i18ncp("@info:status", "1 File selected", "%1 Files selected", fileCount);
+ foldersText = i18ncp("@info:status", "1 folder selected", "%1 folders selected", folderCount);
+ filesText = i18ncp("@info:status", "1 file selected", "%1 files selected", fileCount);
} else {
- foldersText = i18ncp("@info:status", "1 Folder", "%1 Folders", folderCount);
- filesText = i18ncp("@info:status", "1 File", "%1 Files", fileCount);
+ foldersText = i18ncp("@info:status", "1 folder", "%1 folders", folderCount);
+ filesText = i18ncp("@info:status", "1 file", "%1 files", fileCount);
}
if (fileCount > 0 && folderCount > 0) {
- summary = i18nc("@info:status folders, files (size)", "%1, %2 (%3)",
- foldersText, filesText,
- KFormat().formatByteSize(totalFileSize));
+ summary = i18nc("@info:status folders, files (size)", "%1, %2 (%3)", foldersText, filesText, KFormat().formatByteSize(totalFileSize));
} else if (fileCount > 0) {
- summary = i18nc("@info:status files (size)", "%1 (%2)",
- filesText,
- KFormat().formatByteSize(totalFileSize));
+ summary = i18nc("@info:status files (size)", "%1 (%2)", filesText, KFormat().formatByteSize(totalFileSize));
} else if (folderCount > 0) {
summary = foldersText;
} else {
- summary = i18nc("@info:status", "0 Folders, 0 Files");
+ summary = i18nc("@info:status", "0 folders, 0 files");
}
Q_EMIT statusBarTextChanged(summary);
}
-QList<QAction*> DolphinView::versionControlActions(const KFileItemList& items) const
+QList<QAction *> DolphinView::versionControlActions(const KFileItemList &items) const
{
- QList<QAction*> actions;
+ QList<QAction *> actions;
if (items.isEmpty()) {
const KFileItem item = m_model->rootItem();
return actions;
}
-void DolphinView::setUrl(const QUrl& url)
+void DolphinView::setUrl(const QUrl &url)
{
if (url == m_url) {
return;
hideToolTip();
- disconnect(m_view, &DolphinItemListView::roleEditingFinished,
- this, &DolphinView::slotRoleEditingFinished);
+ disconnect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
// It is important to clear the items from the model before
// applying the view properties, otherwise expensive operations
void DolphinView::selectAll()
{
- KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+ KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
selectionManager->setSelected(0, m_model->count());
}
void DolphinView::invertSelection()
{
- KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+ KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
selectionManager->setSelected(0, m_model->count(), KItemListSelectionManager::Toggle);
}
void DolphinView::clearSelection()
{
+ m_selectJobCreatedItems = false;
m_selectedUrls.clear();
m_container->controller()->selectionManager()->clearSelection();
}
if (items.count() == 1 && GeneralSettings::renameInline()) {
const int index = m_model->index(items.first());
- QMetaObject::Connection * const connection = new QMetaObject::Connection;
- *connection = connect(m_view, &KItemListView::scrollingStopped, this, [=](){
- QObject::disconnect(*connection);
- delete connection;
-
- m_view->editRole(index, "text");
+ connect(
+ m_view,
+ &KItemListView::scrollingStopped,
+ this,
+ [this, index]() {
+ m_view->editRole(index, "text");
- hideToolTip();
+ hideToolTip();
- connect(m_view, &DolphinItemListView::roleEditingFinished,
- this, &DolphinView::slotRoleEditingFinished);
- });
+ connect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
+ },
+ Qt::SingleShotConnection);
m_view->scrollToItem(index);
} else {
- KIO::RenameFileDialog* dialog = new KIO::RenameFileDialog(items, this);
- connect(dialog, &KIO::RenameFileDialog::renamingFinished,
- this, &DolphinView::slotRenameDialogRenamingFinished);
+ KIO::RenameFileDialog *dialog = new KIO::RenameFileDialog(items, this);
+ connect(dialog, &KIO::RenameFileDialog::renamingFinished, this, [this, items](const QList<QUrl> &urls) {
+ // The model may have already been updated, so it's possible that we don't find the old items.
+ for (int i = 0; i < items.count(); ++i) {
+ const int index = m_model->index(items[i]);
+ if (index >= 0) {
+ QHash<QByteArray, QVariant> data;
+ data.insert("text", urls[i].fileName());
+ m_model->setData(index, data);
+ }
+ }
+
+ forceUrlsSelection(urls.first(), urls);
+ updateSelectionState();
+ });
+ connect(dialog, &KIO::RenameFileDialog::error, this, [this](KJob *job) {
+ KMessageBox::error(this, job->errorString());
+ });
dialog->open();
}
void DolphinView::trashSelectedItems()
{
const QList<QUrl> list = simplifiedSelectedUrls();
- KIO::JobUiDelegate uiDelegate;
- uiDelegate.setWindow(window());
- if (uiDelegate.askDeleteConfirmation(list, KIO::JobUiDelegate::Trash, KIO::JobUiDelegate::DefaultConfirmation)) {
- KIO::Job* job = KIO::trash(list);
- KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Trash, list, QUrl(QStringLiteral("trash:/")), job);
- KJobWidgets::setWindow(job, this);
- connect(job, &KIO::Job::result,
- this, &DolphinView::slotTrashFileFinished);
- }
+
+ using Iface = KIO::AskUserActionInterface;
+ auto *trashJob = new KIO::DeleteOrTrashJob(list, Iface::Trash, Iface::DefaultConfirmation, this);
+ connect(trashJob, &KJob::result, this, &DolphinView::slotTrashFileFinished);
+ m_selectNextItem = true;
+ trashJob->start();
}
void DolphinView::deleteSelectedItems()
{
const QList<QUrl> list = simplifiedSelectedUrls();
- KIO::JobUiDelegate uiDelegate;
- uiDelegate.setWindow(window());
- if (uiDelegate.askDeleteConfirmation(list, KIO::JobUiDelegate::Delete, KIO::JobUiDelegate::DefaultConfirmation)) {
- KIO::Job* job = KIO::del(list);
- KJobWidgets::setWindow(job, this);
- connect(job, &KIO::Job::result,
- this, &DolphinView::slotDeleteFileFinished);
- }
+ using Iface = KIO::AskUserActionInterface;
+ auto *trashJob = new KIO::DeleteOrTrashJob(list, Iface::Delete, Iface::DefaultConfirmation, this);
+ connect(trashJob, &KJob::result, this, &DolphinView::slotDeleteFileFinished);
+ m_selectNextItem = true;
+ trashJob->start();
}
void DolphinView::cutSelectedItemsToClipboard()
{
- QMimeData* mimeData = selectionMimeData();
+ QMimeData *mimeData = selectionMimeData();
KIO::setClipboardDataCut(mimeData, true);
KUrlMimeData::exportUrlsToPortal(mimeData);
QApplication::clipboard()->setMimeData(mimeData);
void DolphinView::copySelectedItems(const KFileItemList &selection, const QUrl &destinationUrl)
{
- KIO::CopyJob* job = KIO::copy(selection.urlList(), destinationUrl, KIO::DefaultFlags);
+ if (selection.isEmpty() || !destinationUrl.isValid()) {
+ return;
+ }
+
+ m_clearSelectionBeforeSelectingNewItems = true;
+ m_markFirstNewlySelectedItemAsCurrent = true;
+ m_selectJobCreatedItems = true;
+
+ KIO::CopyJob *job = KIO::copy(selection.urlList(), destinationUrl, KIO::DefaultFlags);
KJobWidgets::setWindow(job, this);
- connect(job, &KIO::DropJob::result, this, &DolphinView::slotJobResult);
- connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotCopyingDone);
+ connect(job, &KIO::CopyJob::result, this, &DolphinView::slotJobResult);
+ connect(job, &KIO::CopyJob::copying, this, &DolphinView::slotItemCreatedFromJob);
+ connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotItemCreatedFromJob);
KIO::FileUndoManager::self()->recordCopyJob(job);
}
void DolphinView::moveSelectedItems(const KFileItemList &selection, const QUrl &destinationUrl)
{
- KIO::CopyJob* job = KIO::move(selection.urlList(), destinationUrl, KIO::DefaultFlags);
+ if (selection.isEmpty() || !destinationUrl.isValid()) {
+ return;
+ }
+
+ m_clearSelectionBeforeSelectingNewItems = true;
+ m_markFirstNewlySelectedItemAsCurrent = true;
+ m_selectJobCreatedItems = true;
+
+ KIO::CopyJob *job = KIO::move(selection.urlList(), destinationUrl, KIO::DefaultFlags);
KJobWidgets::setWindow(job, this);
- connect(job, &KIO::DropJob::result, this, &DolphinView::slotJobResult);
- connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotCopyingDone);
+ connect(job, &KIO::CopyJob::result, this, &DolphinView::slotJobResult);
+ connect(job, &KIO::CopyJob::moving, this, &DolphinView::slotItemCreatedFromJob);
+ connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotItemCreatedFromJob);
KIO::FileUndoManager::self()->recordCopyJob(job);
-
}
void DolphinView::paste()
const QMimeDatabase db;
+ m_clearSelectionBeforeSelectingNewItems = true;
+ m_markFirstNewlySelectedItemAsCurrent = true;
+ m_selectJobCreatedItems = true;
+
// Duplicate all selected items and append "copy" to the end of the file name
// but before the filename extension, if present
- QList<QUrl> newSelection;
for (const auto &item : itemList) {
- const QUrl originalURL = item.url();
+ const QUrl originalURL = item.url();
const QString originalDirectoryPath = originalURL.adjusted(QUrl::RemoveFilename).path();
const QString originalFileName = item.name();
// No extension; new filename is "<oldfilename> copy"
if (extension.isEmpty()) {
duplicateURL.setPath(originalDirectoryPath + i18nc("<filename> copy", "%1 copy", originalFileName));
- // There's an extension; new filename is "<oldfilename> copy.<extension>"
+
// There's an extension; new filename is "<oldfilename> copy.<extension>"
} else {
// Need to add a dot since QMimeDatabase::suffixForFileName() doesn't include it
extension = QLatin1String(".") + extension;
duplicateURL.setPath(originalDirectoryPath + i18nc("<filename> copy", "%1 copy", originalFilenameWithoutExtension) + originalExtension);
}
- KIO::CopyJob* job = KIO::copyAs(originalURL, duplicateURL);
+ KIO::CopyJob *job = KIO::copyAs(originalURL, duplicateURL);
+ job->setAutoRename(true);
KJobWidgets::setWindow(job, this);
- if (job) {
- newSelection << duplicateURL;
- KIO::FileUndoManager::self()->recordCopyJob(job);
- }
+ connect(job, &KIO::CopyJob::result, this, &DolphinView::slotJobResult);
+ connect(job, &KIO::CopyJob::copyingDone, this, &DolphinView::slotItemCreatedFromJob);
+ connect(job, &KIO::CopyJob::copyingLinkDone, this, &DolphinView::slotItemLinkCreatedFromJob);
+ KIO::FileUndoManager::self()->recordCopyJob(job);
}
-
- forceUrlsSelection(newSelection.first(), newSelection);
}
void DolphinView::stopLoading()
color.setAlpha(150);
}
- QWidget* viewport = m_container->viewport();
+ QWidget *viewport = m_container->viewport();
if (viewport) {
QPalette palette;
palette.setColor(viewport->backgroundRole(), color);
m_twoClicksRenamingTimer->stop();
}
-bool DolphinView::eventFilter(QObject* watched, QEvent* event)
+bool DolphinView::eventFilter(QObject *watched, QEvent *event)
{
switch (event->type()) {
case QEvent::PaletteChange:
case QEvent::KeyPress:
hideToolTip(ToolTipManager::HideBehavior::Instantly);
if (GeneralSettings::useTabForSwitchingSplitView()) {
- QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
+ QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
if (keyEvent->key() == Qt::Key_Tab && keyEvent->modifiers() == Qt::NoModifier) {
Q_EMIT toggleActiveViewRequested();
return true;
}
}
break;
+ case QEvent::KeyRelease:
+ if (static_cast<QKeyEvent *>(event)->key() == Qt::Key_Control) {
+ m_controlWheelAccumulatedDelta = 0;
+ }
+ break;
case QEvent::FocusIn:
if (watched == m_container) {
setActive(true);
}
break;
- case QEvent::ToolTip:
- tryShowNameToolTip(static_cast<QHelpEvent*>(event));
+ case QEvent::ToolTip: {
+ const auto helpEvent = static_cast<QHelpEvent *>(event);
+ if (tryShowNameToolTip(helpEvent)) {
+ return true;
+ } else if (m_hoveredColumnHeaderIndex) {
+ const auto rolesInfo = KFileItemModel::rolesInformation();
+ const auto visibleRole = m_visibleRoles.value(*m_hoveredColumnHeaderIndex);
+
+ for (const KFileItemModel::RoleInfo &info : rolesInfo) {
+ if (visibleRole == info.role) {
+ QToolTip::showText(helpEvent->globalPos(), info.tooltip, this);
+ return true;
+ }
+ }
+ }
+ break;
+ }
default:
break;
}
return QWidget::eventFilter(watched, event);
}
-void DolphinView::wheelEvent(QWheelEvent* event)
+void DolphinView::wheelEvent(QWheelEvent *event)
{
if (event->modifiers().testFlag(Qt::ControlModifier)) {
- const QPoint numDegrees = event->angleDelta() / 8;
- const QPoint numSteps = numDegrees / 15;
+ m_controlWheelAccumulatedDelta += event->angleDelta().y();
+
+ if (m_controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep) {
+ slotDecreaseZoom();
+ m_controlWheelAccumulatedDelta += QWheelEvent::DefaultDeltasPerStep;
+ } else if (m_controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep) {
+ slotIncreaseZoom();
+ m_controlWheelAccumulatedDelta -= QWheelEvent::DefaultDeltasPerStep;
+ }
- setZoomLevel(zoomLevel() + numSteps.y());
event->accept();
} else {
event->ignore();
}
}
-void DolphinView::hideEvent(QHideEvent* event)
+void DolphinView::hideEvent(QHideEvent *event)
{
hideToolTip();
QWidget::hideEvent(event);
}
-bool DolphinView::event(QEvent* event)
+bool DolphinView::event(QEvent *event)
{
if (event->type() == QEvent::WindowDeactivate) {
/* See Bug 297355
if (indexes.count() > 5) {
QString question = i18np("Are you sure you want to open 1 item?", "Are you sure you want to open %1 items?", indexes.count());
- const int answer = KMessageBox::warningYesNo(this, question, {},
- KGuiItem(i18ncp("@action:button", "Open %1 Item", "Open %1 Items", indexes.count()),
- QStringLiteral("document-open")),
- KStandardGuiItem::cancel());
- if (answer != KMessageBox::Yes) {
+ const int answer = KMessageBox::warningContinueCancel(
+ this,
+ question,
+ {},
+ KGuiItem(i18ncp("@action:button", "Open %1 Item", "Open %1 Items", indexes.count()), QStringLiteral("document-open")),
+ KStandardGuiItem::cancel(),
+ QStringLiteral("ConfirmOpenManyFolders"));
+ if (answer != KMessageBox::PrimaryAction && answer != KMessageBox::Continue) {
return;
}
}
for (int index : indexes) {
KFileItem item = m_model->fileItem(index);
- const QUrl& url = openItemAsFolderUrl(item);
+ const QUrl &url = openItemAsFolderUrl(item);
if (!url.isEmpty()) {
// Open folders in new tabs or in new windows depending on the modifier
void DolphinView::slotItemMiddleClicked(int index)
{
- const KFileItem& item = m_model->fileItem(index);
- const QUrl& url = openItemAsFolderUrl(item);
+ const KFileItem &item = m_model->fileItem(index);
+ const QUrl &url = openItemAsFolderUrl(item, GeneralSettings::browseThroughArchives());
const auto modifiers = QGuiApplication::keyboardModifiers();
if (!url.isEmpty()) {
// keep in sync with KUrlNavigator::slotNavigatorButtonClicked
} else {
Q_EMIT tabRequested(item.url());
}
+ } else {
+ Q_EMIT fileMiddleClickActivated(item);
}
}
-void DolphinView::slotItemContextMenuRequested(int index, const QPointF& pos)
+void DolphinView::slotItemContextMenuRequested(int index, const QPointF &pos)
{
// Force emit of a selection changed signal before we request the
// context menu, to update the edit-actions first. (See Bug 294013)
if (m_selectionChangedTimer->isActive()) {
emitSelectionChangedSignal();
}
+ if (m_twoClicksRenamingTimer->isActive()) {
+ abortTwoClicksRenaming();
+ }
const KFileItem item = m_model->fileItem(index);
Q_EMIT requestContextMenu(pos.toPoint(), item, selectedItems(), url());
}
-void DolphinView::slotViewContextMenuRequested(const QPointF& pos)
+void DolphinView::slotViewContextMenuRequested(const QPointF &pos)
{
Q_EMIT requestContextMenu(pos.toPoint(), KFileItem(), selectedItems(), url());
}
-void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
+void DolphinView::slotHeaderContextMenuRequested(const QPointF &pos)
{
ViewProperties props(viewPropertiesUrl());
- QPointer<QMenu> menu = new QMenu(QApplication::activeWindow());
+ QPointer<QMenu> menu = new QMenu(this);
- KItemListView* view = m_container->controller()->view();
+ KItemListView *view = m_container->controller()->view();
const QList<QByteArray> visibleRolesSet = view->visibleRoles();
bool indexingEnabled = false;
#endif
QString groupName;
- QMenu* groupMenu = nullptr;
+ QMenu *groupMenu = nullptr;
// Add all roles to the menu that can be shown or hidden by the user
const QList<KFileItemModel::RoleInfo> rolesInfo = KFileItemModel::rolesInformation();
- for (const KFileItemModel::RoleInfo& info : rolesInfo) {
+ for (const KFileItemModel::RoleInfo &info : rolesInfo) {
if (info.role == "text") {
// It should not be possible to hide the "text" role
continue;
}
const QString text = m_model->roleDescription(info.role);
- QAction* action = nullptr;
+ QAction *action = nullptr;
if (info.group.isEmpty()) {
action = menu->addAction(text);
} else {
action->setCheckable(true);
action->setChecked(visibleRolesSet.contains(info.role));
action->setData(info.role);
+ action->setToolTip(info.tooltip);
- const bool enable = (!info.requiresBaloo && !info.requiresIndexer) ||
- (info.requiresBaloo) ||
- (info.requiresIndexer && indexingEnabled);
+ const bool enable = (!info.requiresBaloo && !info.requiresIndexer) || (info.requiresBaloo) || (info.requiresIndexer && indexingEnabled);
action->setEnabled(enable);
}
menu->addSeparator();
- QActionGroup* widthsGroup = new QActionGroup(menu);
+ QActionGroup *widthsGroup = new QActionGroup(menu);
const bool autoColumnWidths = props.headerColumnWidths().isEmpty();
- QAction* toggleSidePaddingAction = menu->addAction(i18nc("@action:inmenu", "Side Padding"));
+ QAction *toggleSidePaddingAction = menu->addAction(i18nc("@action:inmenu", "Side Padding"));
toggleSidePaddingAction->setCheckable(true);
- toggleSidePaddingAction->setChecked(view->header()->sidePadding() > 0);
+ toggleSidePaddingAction->setChecked(layoutDirection() == Qt::LeftToRight ? view->header()->leftPadding() > 0 : view->header()->rightPadding() > 0);
- QAction* autoAdjustWidthsAction = menu->addAction(i18nc("@action:inmenu", "Automatic Column Widths"));
+ QAction *autoAdjustWidthsAction = menu->addAction(i18nc("@action:inmenu", "Automatic Column Widths"));
autoAdjustWidthsAction->setCheckable(true);
autoAdjustWidthsAction->setChecked(autoColumnWidths);
autoAdjustWidthsAction->setActionGroup(widthsGroup);
- QAction* customWidthsAction = menu->addAction(i18nc("@action:inmenu", "Custom Column Widths"));
+ QAction *customWidthsAction = menu->addAction(i18nc("@action:inmenu", "Custom Column Widths"));
customWidthsAction->setCheckable(true);
customWidthsAction->setChecked(!autoColumnWidths);
customWidthsAction->setActionGroup(widthsGroup);
- QAction* action = menu->exec(pos.toPoint());
+ QAction *action = menu->exec(pos.toPoint());
if (menu && action) {
- KItemListHeader* header = view->header();
+ KItemListHeader *header = view->header();
if (action == autoAdjustWidthsAction) {
// Clear the column-widths from the viewproperties and turn on
QList<int> columnWidths;
const auto visibleRoles = view->visibleRoles();
columnWidths.reserve(visibleRoles.count());
- for (const QByteArray& role : visibleRoles) {
+ for (const QByteArray &role : visibleRoles) {
columnWidths.append(header->columnWidth(role));
}
props.setHeaderColumnWidths(columnWidths);
header->setAutomaticColumnResizing(false);
} else if (action == toggleSidePaddingAction) {
- header->setSidePadding(toggleSidePaddingAction->isChecked() ? 20 : 0);
+ if (toggleSidePaddingAction->isChecked()) {
+ header->setSidePadding(20, 20);
+ } else {
+ header->setSidePadding(0, 0);
+ }
} else {
// Show or hide the selected role
const QByteArray selectedRole = action->data().toByteArray();
if (!header->automaticColumnResizing()) {
const auto visibleRoles = view->visibleRoles();
columnWidths.reserve(visibleRoles.count());
- for (const QByteArray& role : visibleRoles) {
+ for (const QByteArray &role : visibleRoles) {
columnWidths.append(header->columnWidth(role));
}
}
delete menu;
}
-void DolphinView::slotHeaderColumnWidthChangeFinished(const QByteArray& role, qreal current)
+void DolphinView::slotHeaderColumnWidthChangeFinished(const QByteArray &role, qreal current)
{
const QList<QByteArray> visibleRoles = m_view->visibleRoles();
if (columnWidths.count() != visibleRoles.count()) {
columnWidths.clear();
columnWidths.reserve(visibleRoles.count());
- const KItemListHeader* header = m_view->header();
- for (const QByteArray& role : visibleRoles) {
+ const KItemListHeader *header = m_view->header();
+ for (const QByteArray &role : visibleRoles) {
const int width = header->columnWidth(role);
columnWidths.append(width);
}
props.setHeaderColumnWidths(columnWidths);
}
-void DolphinView::slotSidePaddingWidthChanged(qreal width)
+void DolphinView::slotSidePaddingWidthChanged(qreal leftPaddingWidth, qreal rightPaddingWidth)
{
ViewProperties props(viewPropertiesUrl());
- DetailsModeSettings::setSidePadding(int(width));
+ DetailsModeSettings::setLeftPadding(int(leftPaddingWidth));
+ DetailsModeSettings::setRightPadding(int(rightPaddingWidth));
m_view->writeSettings();
}
Q_EMIT requestItemInfo(KFileItem());
}
-void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* event)
+void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent *event)
{
QUrl destUrl;
KFileItem destItem = m_model->fileItem(index);
destUrl = destItem.mostLocalUrl();
}
- QDropEvent dropEvent(event->pos().toPoint(),
- event->possibleActions(),
- event->mimeData(),
- event->buttons(),
- event->modifiers());
+ QDropEvent dropEvent(event->pos().toPoint(), event->possibleActions(), event->mimeData(), event->buttons(), event->modifiers());
dropUrls(destUrl, &dropEvent, this);
setActive(true);
void DolphinView::dropUrls(const QUrl &destUrl, QDropEvent *dropEvent, QWidget *dropWidget)
{
- KIO::DropJob* job = DragAndDropHelper::dropUrls(destUrl, dropEvent, dropWidget);
+ KIO::DropJob *job = DragAndDropHelper::dropUrls(destUrl, dropEvent, dropWidget);
if (job) {
connect(job, &KIO::DropJob::result, this, &DolphinView::slotJobResult);
// Mark the dropped urls as selected.
m_clearSelectionBeforeSelectingNewItems = true;
m_markFirstNewlySelectedItemAsCurrent = true;
+ m_selectJobCreatedItems = true;
connect(job, &KIO::DropJob::itemCreated, this, &DolphinView::slotItemCreated);
+ connect(job, &KIO::DropJob::copyJobStarted, this, [this](const KIO::CopyJob *copyJob) {
+ connect(copyJob, &KIO::CopyJob::copying, this, &DolphinView::slotItemCreatedFromJob);
+ connect(copyJob, &KIO::CopyJob::moving, this, &DolphinView::slotItemCreatedFromJob);
+ connect(copyJob, &KIO::CopyJob::linking, this, [this](KIO::Job *job, const QString &src, const QUrl &dest) {
+ Q_UNUSED(job)
+ Q_UNUSED(src)
+ slotItemCreated(dest);
+ });
+ });
}
}
}
-void DolphinView::slotModelChanged(KItemModelBase* current, KItemModelBase* previous)
+void DolphinView::slotModelChanged(KItemModelBase *current, KItemModelBase *previous)
{
if (previous != nullptr) {
- Q_ASSERT(qobject_cast<KFileItemModel*>(previous));
- KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(previous);
+ Q_ASSERT(qobject_cast<KFileItemModel *>(previous));
+ KFileItemModel *fileItemModel = static_cast<KFileItemModel *>(previous);
disconnect(fileItemModel, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
m_versionControlObserver->setModel(nullptr);
}
if (current) {
- Q_ASSERT(qobject_cast<KFileItemModel*>(current));
- KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(current);
+ Q_ASSERT(qobject_cast<KFileItemModel *>(current));
+ KFileItemModel *fileItemModel = static_cast<KFileItemModel *>(current);
connect(fileItemModel, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
m_versionControlObserver->setModel(fileItemModel);
}
}
}
-void DolphinView::slotCopyingDone(KIO::Job *, const QUrl &, const QUrl &to)
+void DolphinView::slotItemCreatedFromJob(KIO::Job *, const QUrl &, const QUrl &to)
{
slotItemCreated(to);
}
-void DolphinView::slotItemCreated(const QUrl& url)
+void DolphinView::slotItemLinkCreatedFromJob(KIO::Job *, const QUrl &, const QString &, const QUrl &to)
+{
+ slotItemCreated(to);
+}
+
+void DolphinView::slotItemCreated(const QUrl &url)
{
if (m_markFirstNewlySelectedItemAsCurrent) {
markUrlAsCurrent(url);
m_markFirstNewlySelectedItemAsCurrent = false;
}
- m_selectedUrls << url;
+ if (m_selectJobCreatedItems && !m_selectedUrls.contains(url)) {
+ m_selectedUrls << url;
+ }
+}
+
+void DolphinView::onDirectoryLoadingCompletedAfterJob()
+{
+ // the model should now contain all the items created by the job
+ m_selectJobCreatedItems = true; // to make sure we overwrite selection
+ // update the view: scroll into View and selection
+ updateViewState();
+ m_selectJobCreatedItems = false;
+ m_selectedUrls.clear();
}
void DolphinView::slotJobResult(KJob *job)
{
if (job->error() && job->error() != KIO::ERR_USER_CANCELED) {
- Q_EMIT errorMessage(job->errorString());
+ Q_EMIT errorMessage(job->errorString(), job->error());
+ }
+ if (!m_selectJobCreatedItems) {
+ m_selectedUrls.clear();
+ return;
}
if (!m_selectedUrls.isEmpty()) {
m_selectedUrls = KDirModel::simplifiedUrlList(m_selectedUrls);
+
+ updateSelectionState();
+ if (!m_selectedUrls.isEmpty()) {
+ // not all urls were found, the model may not be up to date
+ connect(m_model, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::onDirectoryLoadingCompletedAfterJob, Qt::SingleShotConnection);
+ } else {
+ m_selectJobCreatedItems = false;
+ m_selectedUrls.clear();
+ }
}
}
-void DolphinView::slotSelectionChanged(const KItemSet& current, const KItemSet& previous)
+void DolphinView::slotSelectionChanged(const KItemSet ¤t, const KItemSet &previous)
{
+ m_selectNextItem = false;
const int currentCount = current.count();
const int previousCount = previous.count();
- const bool selectionStateChanged = (currentCount == 0 && previousCount > 0) ||
- (currentCount > 0 && previousCount == 0);
+ const bool selectionStateChanged = (currentCount == 0 && previousCount > 0) || (currentCount > 0 && previousCount == 0);
// If nothing has been selected before and something got selected (or if something
// was selected before and now nothing is selected) the selectionChangedSignal must
KIO::filesize_t totalFileSize = 0;
bool countFileSize = true;
- const auto entry = static_cast<KIO::StatJob *>(job)->statResult();
+ const auto entry = static_cast<KIO::StatJob *>(job)->statResult();
if (entry.contains(KIO::UDSEntry::UDS_RECURSIVE_SIZE)) {
// We have a precomputed value.
- totalFileSize = static_cast<KIO::filesize_t>(
- entry.numberValue(KIO::UDSEntry::UDS_RECURSIVE_SIZE));
+ totalFileSize = static_cast<KIO::filesize_t>(entry.numberValue(KIO::UDSEntry::UDS_RECURSIVE_SIZE));
countFileSize = false;
}
emitStatusBarText(folderCount, fileCount, totalFileSize, NoSelection);
}
-void DolphinView::updateSortRole(const QByteArray& role)
-{
- ViewProperties props(viewPropertiesUrl());
- props.setSortRole(role);
-
- KItemModelBase* model = m_container->controller()->model();
- model->setSortRole(role);
-
- Q_EMIT sortRoleChanged(role);
-}
-
-void DolphinView::updateSortOrder(Qt::SortOrder order)
-{
- ViewProperties props(viewPropertiesUrl());
- props.setSortOrder(order);
-
- m_model->setSortOrder(order);
-
- Q_EMIT sortOrderChanged(order);
-}
-
void DolphinView::updateSortFoldersFirst(bool foldersFirst)
{
ViewProperties props(viewPropertiesUrl());
Q_EMIT sortHiddenLastChanged(hiddenLast);
}
-
QPair<bool, QString> DolphinView::pasteInfo() const
{
const QMimeData *mimeData = QApplication::clipboard()->mimeData();
return m_mode == DetailsView;
}
-bool DolphinView::isExpanded(const KFileItem& item) const
+bool DolphinView::isExpanded(const KFileItem &item) const
{
Q_ASSERT(item.isDir());
Q_ASSERT(items().contains(item));
return m_model->isExpanded(m_model->index(item));
}
-void DolphinView::restoreState(QDataStream& stream)
+void DolphinView::restoreState(QDataStream &stream)
{
// Read the version number of the view state and check if the version is supported.
quint32 version = 0;
m_model->restoreExpandedDirectories(urls);
}
-void DolphinView::saveState(QDataStream& stream)
+void DolphinView::saveState(QDataStream &stream)
{
stream << quint32(1); // View state version
return m_model->rootItem();
}
-void DolphinView::setViewPropertiesContext(const QString& context)
+void DolphinView::setViewPropertiesContext(const QString &context)
{
m_viewPropertiesContext = context;
}
return m_viewPropertiesContext;
}
-QUrl DolphinView::openItemAsFolderUrl(const KFileItem& item, const bool browseThroughArchives)
+QUrl DolphinView::openItemAsFolderUrl(const KFileItem &item, const bool browseThroughArchives)
{
if (item.isNull()) {
return QUrl();
}
if (item.isMimeTypeKnown()) {
- const QString& mimetype = item.mimetype();
+ const QString &mimetype = item.mimetype();
if (browseThroughArchives && item.isFile() && url.isLocalFile()) {
// Generic mechanism for redirecting to tar:/<path>/ when clicking on a tar file,
// The .protocol file specifies the mimetype that the kioslave handles.
// Note that we don't use mimetype inheritance since we don't want to
// open OpenDocument files as zip folders...
- const QString& protocol = KProtocolManager::protocolForArchiveMimetype(mimetype);
+ const QString &protocol = KProtocolManager::protocolForArchiveMimetype(mimetype);
if (!protocol.isEmpty()) {
url.setScheme(protocol);
return url;
setZoomLevel(ZoomLevelInfo::zoomLevelForIconSize(QSize(defaultIconSize, defaultIconSize)));
}
-void DolphinView::observeCreatedItem(const QUrl& url)
+void DolphinView::observeCreatedItem(const QUrl &url)
{
if (m_active) {
forceUrlsSelection(url, {url});
}
}
-void DolphinView::slotDirectoryRedirection(const QUrl& oldUrl, const QUrl& newUrl)
+void DolphinView::slotDirectoryRedirection(const QUrl &oldUrl, const QUrl &newUrl)
{
if (oldUrl.matches(url(), QUrl::StripTrailingSlash)) {
Q_EMIT redirection(oldUrl, newUrl);
}
}
+void DolphinView::updateSelectionState()
+{
+ if (!m_selectedUrls.isEmpty()) {
+ KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
+
+ const bool shouldScrollToCurrentItem = m_clearSelectionBeforeSelectingNewItems;
+ // if there is a selection already, leave it that way
+ // unless some drop/paste job are in the process of creating items
+ if (!selectionManager->hasSelection() || m_selectJobCreatedItems) {
+ if (m_clearSelectionBeforeSelectingNewItems) {
+ selectionManager->clearSelection();
+ m_clearSelectionBeforeSelectingNewItems = false;
+ }
+
+ KItemSet selectedItems = selectionManager->selectedItems();
+
+ QList<QUrl>::iterator it = m_selectedUrls.begin();
+ while (it != m_selectedUrls.end()) {
+ const int index = m_model->index(*it);
+ if (index >= 0) {
+ selectedItems.insert(index);
+ it = m_selectedUrls.erase(it);
+ } else {
+ ++it;
+ }
+ }
+
+ if (!selectedItems.isEmpty()) {
+ selectionManager->beginAnchoredSelection(selectionManager->currentItem());
+ selectionManager->setSelectedItems(selectedItems);
+ if (shouldScrollToCurrentItem) {
+ m_view->scrollToItem(selectedItems.first());
+ }
+ }
+ }
+ }
+}
+
void DolphinView::updateViewState()
{
if (m_currentItemUrl != QUrl()) {
- KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+ KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
// if there is a selection already, leave it that way
if (!selectionManager->hasSelection()) {
// scroll to current item and reset the state
if (m_scrollToCurrentItem) {
- m_view->scrollToItem(currentIndex);
+ m_view->scrollToItem(currentIndex, KItemListView::ViewItemPosition::Middle);
m_scrollToCurrentItem = false;
}
m_currentItemUrl = QUrl();
m_container->verticalScrollBar()->setValue(y);
}
- if (!m_selectedUrls.isEmpty()) {
- KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
-
- // if there is a selection already, leave it that way
- if (!selectionManager->hasSelection()) {
- if (m_clearSelectionBeforeSelectingNewItems) {
- selectionManager->clearSelection();
- m_clearSelectionBeforeSelectingNewItems = false;
- }
-
- KItemSet selectedItems = selectionManager->selectedItems();
-
- QList<QUrl>::iterator it = m_selectedUrls.begin();
- while (it != m_selectedUrls.end()) {
- const int index = m_model->index(*it);
- if (index >= 0) {
- selectedItems.insert(index);
- it = m_selectedUrls.erase(it);
- } else {
- ++it;
- }
- }
-
- if (!selectedItems.isEmpty()) {
- selectionManager->beginAnchoredSelection(selectionManager->currentItem());
- selectionManager->setSelectedItems(selectedItems);
- }
- }
- }
+ updateSelectionState();
}
void DolphinView::hideToolTip(const ToolTipManager::HideBehavior behavior)
Q_UNUSED(behavior)
#endif
} else if (m_mode == DolphinView::IconsView) {
- QToolTip::hideText();
+ QToolTip::hideText();
}
}
+bool DolphinView::handleSpaceAsNormalKey() const
+{
+ return !m_container->hasFocus() || m_container->controller()->isSearchAsYouTypeActive();
+}
+
void DolphinView::slotTwoClicksRenamingTimerTimeout()
{
- const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+ const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
// verify that only one item is selected
if (selectionManager->selectedItems().count() == 1) {
}
}
-void DolphinView::slotTrashFileFinished(KJob* job)
+void DolphinView::slotTrashFileFinished(KJob *job)
{
if (job->error() == 0) {
+ selectNextItem(); // Fixes BUG: 419914 via selecting next item
Q_EMIT operationCompletedMessage(i18nc("@info:status", "Trash operation completed."));
} else if (job->error() != KIO::ERR_USER_CANCELED) {
- Q_EMIT errorMessage(job->errorString());
+ Q_EMIT errorMessage(job->errorString(), job->error());
}
}
-void DolphinView::slotDeleteFileFinished(KJob* job)
+void DolphinView::slotDeleteFileFinished(KJob *job)
{
if (job->error() == 0) {
+ selectNextItem(); // Fixes BUG: 419914 via selecting next item
Q_EMIT operationCompletedMessage(i18nc("@info:status", "Delete operation completed."));
} else if (job->error() != KIO::ERR_USER_CANCELED) {
- Q_EMIT errorMessage(job->errorString());
+ Q_EMIT errorMessage(job->errorString(), job->error());
}
}
-void DolphinView::slotRenamingResult(KJob* job)
+void DolphinView::selectNextItem()
{
- if (job->error()) {
+ if (m_active && m_selectNextItem) {
+ KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
+ if (selectedItems().isEmpty()) {
+ Q_ASSERT_X(false, "DolphinView", "Selecting the next item failed.");
+ return;
+ }
+ const auto lastSelectedIndex = m_model->index(selectedItems().constLast());
+ if (lastSelectedIndex < 0) {
+ Q_ASSERT_X(false, "DolphinView", "Selecting the next item failed.");
+ return;
+ }
+ auto nextItem = lastSelectedIndex + 1;
+ if (nextItem >= itemsCount()) {
+ nextItem = lastSelectedIndex - selectedItemsCount();
+ }
+ if (nextItem >= 0) {
+ selectionManager->setSelected(nextItem, 1);
+ selectionManager->beginAnchoredSelection(nextItem);
+ }
+ m_selectNextItem = false;
+ }
+}
+
+void DolphinView::slotRenamingResult(KJob *job)
+{
+ // Change model data after renaming has succeeded. On failure we do nothing.
+ // If there is already an item with the newUrl, the copyjob will open a dialog for it, and
+ // KFileItemModel will update the data when the dir lister signals that the file name has changed.
+ if (!job->error()) {
KIO::CopyJob *copyJob = qobject_cast<KIO::CopyJob *>(job);
Q_ASSERT(copyJob);
const QUrl newUrl = copyJob->destUrl();
+ const QUrl oldUrl = copyJob->srcUrls().at(0);
const int index = m_model->index(newUrl);
- if (index >= 0) {
+ if (m_model->index(oldUrl) == index) {
QHash<QByteArray, QVariant> data;
- const QUrl oldUrl = copyJob->srcUrls().at(0);
- data.insert("text", oldUrl.fileName());
+ data.insert("text", newUrl.fileName());
m_model->setData(index, data);
}
}
Q_EMIT directoryLoadingCompleted();
+ applyDynamicView();
updatePlaceholderLabel();
updateWritableState();
}
Q_EMIT sortOrderChanged(current);
}
-void DolphinView::slotSortRoleChangedByHeader(const QByteArray& current, const QByteArray& previous)
+void DolphinView::slotSortRoleChangedByHeader(const QByteArray ¤t, const QByteArray &previous)
{
Q_UNUSED(previous)
Q_ASSERT(m_model->sortRole() == current);
Q_EMIT sortRoleChanged(current);
}
-void DolphinView::slotVisibleRolesChangedByHeader(const QList<QByteArray>& current,
- const QList<QByteArray>& previous)
+void DolphinView::slotVisibleRolesChangedByHeader(const QList<QByteArray> ¤t, const QList<QByteArray> &previous)
{
Q_UNUSED(previous)
Q_ASSERT(m_container->controller()->view()->visibleRoles() == current);
void DolphinView::slotRoleEditingCanceled()
{
- disconnect(m_view, &DolphinItemListView::roleEditingFinished,
- this, &DolphinView::slotRoleEditingFinished);
+ disconnect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
}
-void DolphinView::slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value)
+void DolphinView::slotRoleEditingFinished(int index, const QByteArray &role, const QVariant &value)
{
- disconnect(m_view, &DolphinItemListView::roleEditingFinished,
- this, &DolphinView::slotRoleEditingFinished);
+ disconnect(m_view, &DolphinItemListView::roleEditingFinished, this, &DolphinView::slotRoleEditingFinished);
const KFileItemList items = selectedItems();
if (items.count() != 1) {
newUrl.setPath(newUrl.path() + KIO::encodeFileName(newName));
#ifndef Q_OS_WIN
- //Confirm hiding file/directory by renaming inline
+ // Confirm hiding file/directory by renaming inline
if (!hiddenFilesShown() && newName.startsWith(QLatin1Char('.')) && !oldItem.name().startsWith(QLatin1Char('.'))) {
- KGuiItem yesGuiItem(KStandardGuiItem::yes());
- yesGuiItem.setText(i18nc("@action:button", "Rename and Hide"));
-
- const auto code = KMessageBox::questionYesNo(this,
- oldItem.isFile() ? i18n("Adding a dot to the beginning of this file's name will hide it from view.\n"
- "Do you still want to rename it?")
- : i18n("Adding a dot to the beginning of this folder's name will hide it from view.\n"
- "Do you still want to rename it?"),
- oldItem.isFile() ? i18n("Hide this File?") : i18n("Hide this Folder?"),
- yesGuiItem,
- KStandardGuiItem::cancel(),
- QStringLiteral("ConfirmHide")
- );
-
- if (code == KMessageBox::No) {
- return;
+ KGuiItem yesGuiItem(i18nc("@action:button", "Rename and Hide"), QStringLiteral("view-hidden"));
+
+ const auto code =
+ KMessageBox::questionTwoActions(this,
+ oldItem.isFile() ? i18n("Adding a dot to the beginning of this file's name will hide it from view.\n"
+ "Do you still want to rename it?")
+ : i18n("Adding a dot to the beginning of this folder's name will hide it from view.\n"
+ "Do you still want to rename it?"),
+ oldItem.isFile() ? i18n("Hide this File?") : i18n("Hide this Folder?"),
+ yesGuiItem,
+ KStandardGuiItem::cancel(),
+ QStringLiteral("ConfirmHide"));
+
+ if (code == KMessageBox::SecondaryAction) {
+ return;
}
}
#endif
- const bool newNameExistsAlready = (m_model->index(newUrl) >= 0);
- if (!newNameExistsAlready && m_model->index(oldUrl) == index) {
- // Only change the data in the model if no item with the new name
- // is in the model yet. If there is an item with the new name
- // already, calling KIO::CopyJob will open a dialog
- // asking for a new name, and KFileItemModel will update the
- // data when the dir lister signals that the file name has changed.
- QHash<QByteArray, QVariant> data;
- data.insert(role, retVal.newName);
- m_model->setData(index, data);
- }
-
- KIO::Job * job = KIO::moveAs(oldUrl, newUrl);
+ KIO::Job *job = KIO::moveAs(oldUrl, newUrl);
KJobWidgets::setWindow(job, this);
KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Rename, {oldUrl}, newUrl, job);
job->uiDelegate()->setAutoErrorHandlingEnabled(true);
- forceUrlsSelection(newUrl, {newUrl});
+ if (m_model->index(newUrl) < 0) {
+ forceUrlsSelection(newUrl, {newUrl});
+ updateSelectionState();
- if (!newNameExistsAlready) {
// Only connect the result signal if there is no item with the new name
// in the model yet, see bug 328262.
connect(job, &KJob::result, this, &DolphinView::slotRenamingResult);
if (retVal.direction != EditDone) {
const short indexShift = retVal.direction == EditNext ? 1 : -1;
m_container->controller()->selectionManager()->setSelected(index, 1, KItemListSelectionManager::Deselect);
- m_container->controller()->selectionManager()->setSelected(index + indexShift, 1,
- KItemListSelectionManager::Select);
+ m_container->controller()->selectionManager()->setSelected(index + indexShift, 1, KItemListSelectionManager::Select);
renameSelectedItems();
}
}
}
-void DolphinView::loadDirectory(const QUrl& url, bool reload)
+void DolphinView::loadDirectory(const QUrl &url, bool reload)
{
if (!url.isValid()) {
const QString location(url.toDisplayString(QUrl::PreferLocalFile));
if (location.isEmpty()) {
- Q_EMIT errorMessage(i18nc("@info:status", "The location is empty."));
+ Q_EMIT errorMessage(i18nc("@info:status", "The location is empty."), KIO::ERR_UNKNOWN);
} else {
- Q_EMIT errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location));
+ Q_EMIT errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location), KIO::ERR_UNKNOWN);
}
return;
}
applyViewProperties(props);
}
-void DolphinView::applyViewProperties(const ViewProperties& props)
+void DolphinView::applyViewProperties(const ViewProperties &props)
{
m_view->beginTransaction();
}
}
- KItemListView* itemListView = m_container->controller()->view();
+ KItemListView *itemListView = m_container->controller()->view();
if (itemListView->isHeaderVisible()) {
- KItemListHeader* header = itemListView->header();
+ KItemListHeader *header = itemListView->header();
const QList<int> headerColumnWidths = props.headerColumnWidths();
const int rolesCount = m_visibleRoles.count();
if (headerColumnWidths.count() == rolesCount) {
} else {
header->setAutomaticColumnResizing(true);
}
- header->setSidePadding(DetailsModeSettings::sidePadding());
+ header->setSidePadding(DetailsModeSettings::leftPadding(), DetailsModeSettings::rightPadding());
}
m_view->endTransaction();
void DolphinView::applyModeToView()
{
switch (m_mode) {
- case IconsView: m_view->setItemLayout(KFileItemListView::IconsLayout); break;
- case CompactView: m_view->setItemLayout(KFileItemListView::CompactLayout); break;
- case DetailsView: m_view->setItemLayout(KFileItemListView::DetailsLayout); break;
- default: Q_ASSERT(false); break;
+ case IconsView:
+ m_view->setItemLayout(KFileItemListView::IconsLayout);
+ break;
+ case CompactView:
+ m_view->setItemLayout(KFileItemListView::CompactLayout);
+ break;
+ case DetailsView:
+ m_view->setItemLayout(KFileItemListView::DetailsLayout);
+ break;
+ default:
+ Q_ASSERT(false);
+ break;
}
}
-void DolphinView::pasteToUrl(const QUrl& url)
+void DolphinView::applyDynamicView()
+{
+ ViewProperties props(viewPropertiesUrl());
+ /* return early if:
+ * - dynamic view is not enabled
+ * - the current view mode is already Icon View
+ * - dynamic view has previously changed the view mode
+ */
+ if (!GeneralSettings::dynamicView() || m_mode == IconsView || props.dynamicViewPassed()) {
+ return;
+ }
+
+ uint imageAndVideoCount = 0;
+ uint checkedItems = 0;
+ const uint totalItems = itemsCount();
+ const KFileItemList itemList = items();
+ bool applyDynamicView = false;
+
+ for (const auto &file : itemList) {
+ ++checkedItems;
+ const QString type = file.mimetype().slice(0, 5);
+
+ if (type == "image" || type == "video") {
+ ++imageAndVideoCount;
+ // if 2/3 or more of the items are images/videos, dynamic view should be applied
+ applyDynamicView = imageAndVideoCount >= (totalItems * 2 / 3);
+ if (applyDynamicView) {
+ break;
+ }
+ } else if (checkedItems - imageAndVideoCount > totalItems / 3) {
+ // if more than a third of the checked files are not media files, return
+ return;
+ }
+ }
+
+ if (!applyDynamicView) {
+ return;
+ }
+
+ props.setAutoSaveEnabled(!GeneralSettings::globalViewProps());
+ props.setDynamicViewPassed(true);
+ props.setViewMode(IconsView);
+ applyViewProperties(props);
+}
+
+void DolphinView::pasteToUrl(const QUrl &url)
{
KIO::PasteJob *job = KIO::paste(QApplication::clipboard()->mimeData(), url);
KJobWidgets::setWindow(job, this);
m_clearSelectionBeforeSelectingNewItems = true;
m_markFirstNewlySelectedItemAsCurrent = true;
+ m_selectJobCreatedItems = true;
connect(job, &KIO::PasteJob::itemCreated, this, &DolphinView::slotItemCreated);
+ connect(job, &KIO::PasteJob::copyJobStarted, this, [this](const KIO::CopyJob *copyJob) {
+ connect(copyJob, &KIO::CopyJob::copying, this, &DolphinView::slotItemCreatedFromJob);
+ connect(copyJob, &KIO::CopyJob::moving, this, &DolphinView::slotItemCreatedFromJob);
+ connect(copyJob, &KIO::CopyJob::linking, this, [this](KIO::Job *job, const QString &src, const QUrl &dest) {
+ Q_UNUSED(job)
+ Q_UNUSED(src)
+ slotItemCreated(dest);
+ });
+ });
connect(job, &KIO::PasteJob::result, this, &DolphinView::slotJobResult);
}
const KFileItemList items = selectedItems();
urls.reserve(items.count());
- for (const KFileItem& item : items) {
+ for (const KFileItem &item : items) {
urls.append(item.url());
}
return urls;
}
-QMimeData* DolphinView::selectionMimeData() const
+QMimeData *DolphinView::selectionMimeData() const
{
- const KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
+ const KItemListSelectionManager *selectionManager = m_container->controller()->selectionManager();
const KItemSet selectedIndexes = selectionManager->selectedItems();
return m_model->createMimeData(selectedIndexes);
}
}
+bool DolphinView::isFolderWritable() const
+{
+ return m_isFolderWritable;
+}
+
+int DolphinView::horizontalScrollBarHeight() const
+{
+ if (m_container && m_container->horizontalScrollBar() && m_container->horizontalScrollBar()->isVisible()) {
+ return m_container->horizontalScrollBar()->height();
+ }
+ return 0;
+}
+
+void DolphinView::setStatusBarOffset(int offset)
+{
+ KItemListView *view = m_container->controller()->view();
+ if (view) {
+ view->setStatusBarOffset(offset);
+ }
+}
+
QUrl DolphinView::viewPropertiesUrl() const
{
if (m_viewPropertiesContext.isEmpty()) {
return url;
}
-void DolphinView::slotRenameDialogRenamingFinished(const QList<QUrl>& urls)
-{
- forceUrlsSelection(urls.first(), urls);
-}
-
-void DolphinView::forceUrlsSelection(const QUrl& current, const QList<QUrl>& selected)
+void DolphinView::forceUrlsSelection(const QUrl ¤t, const QList<QUrl> &selected)
{
clearSelection();
m_clearSelectionBeforeSelectingNewItems = true;
if (list.isEmpty()) {
return;
}
- const KFileItem& item = list.at(0);
+ const KFileItem &item = list.at(0);
QString path = item.localPath();
if (path.isEmpty()) {
path = item.url().toDisplayString();
}
- QClipboard* clipboard = QApplication::clipboard();
+ QClipboard *clipboard = QApplication::clipboard();
if (clipboard == nullptr) {
return;
}
- clipboard->setText(path);
+ clipboard->setText(QDir::toNativeSeparators(path));
}
void DolphinView::slotIncreaseZoom()
void DolphinView::showLoadingPlaceholder()
{
- m_placeholderLabel->setText(i18n("Loading..."));
+ m_placeholderLabel->setText(i18n("Loading…"));
m_placeholderLabel->setVisible(true);
+#ifndef QT_NO_ACCESSIBILITY
+ if (QAccessible::isActive()) {
+ static_cast<KItemListViewAccessible *>(QAccessible::queryAccessibleInterface(m_view))->announceNewlyLoadedLocation(m_placeholderLabel->text());
+ }
+#endif
}
void DolphinView::updatePlaceholderLabel()
{
m_showLoadingPlaceholderTimer->stop();
if (itemsCount() > 0) {
+#ifndef QT_NO_ACCESSIBILITY
+ if (QAccessible::isActive()) {
+ static_cast<KItemListViewAccessible *>(QAccessible::queryAccessibleInterface(m_view))->announceNewlyLoadedLocation(QString());
+ }
+#endif
m_placeholderLabel->setVisible(false);
return;
}
m_placeholderLabel->setText(i18n("No relevant network resources found"));
} else if (m_url.scheme() == QLatin1String("mtp") && m_url.path() == QLatin1String("/")) {
m_placeholderLabel->setText(i18n("No MTP-compatible devices found"));
+ } else if (m_url.scheme() == QLatin1String("afc") && m_url.path() == QLatin1String("/")) {
+ m_placeholderLabel->setText(i18n("No Apple devices found"));
} else if (m_url.scheme() == QLatin1String("bluetooth")) {
m_placeholderLabel->setText(i18n("No Bluetooth devices found"));
} else {
}
m_placeholderLabel->setVisible(true);
+#ifndef QT_NO_ACCESSIBILITY
+ if (QAccessible::isActive()) {
+ static_cast<KItemListViewAccessible *>(QAccessible::queryAccessibleInterface(m_view))->announceNewlyLoadedLocation(m_placeholderLabel->text());
+ }
+#endif
}
-void DolphinView::tryShowNameToolTip(QHelpEvent* event)
+bool DolphinView::tryShowNameToolTip(QHelpEvent *event)
{
if (!GeneralSettings::showToolTips() && m_mode == DolphinView::IconsView) {
const std::optional<int> index = m_view->itemAt(event->pos());
if (!index.has_value()) {
- return;
+ return false;
}
// Check whether the filename has been elided
const bool isElided = m_view->isElided(index.value());
- if(isElided) {
+ if (isElided) {
const KFileItem item = m_model->fileItem(index.value());
const QString text = item.text();
const QPoint pos = mapToGlobal(event->pos());
- QToolTip::showText(pos, text);
+ QToolTip::showText(pos, text, this);
+ return true;
}
}
+ return false;
}
+
+#include "moc_dolphinview.cpp"
projects / dolphin.git / blobdiff