connect(controller, &KItemListController::escapePressed, this, &DolphinView::stopLoading);
connect(controller, &KItemListController::modelChanged, this, &DolphinView::slotModelChanged);
connect(controller, &KItemListController::selectedItemTextPressed, this, &DolphinView::slotSelectedItemTextPressed);
+ connect(controller, &KItemListController::increaseZoom, this, &DolphinView::slotIncreaseZoom);
+ connect(controller, &KItemListController::decreaseZoom, this, &DolphinView::slotDecreaseZoom);
+ connect(controller, &KItemListController::swipeUp, this, &DolphinView::slotSwipeUp);
connect(m_model, &KFileItemModel::directoryLoadingStarted, this, &DolphinView::slotDirectoryLoadingStarted);
connect(m_model, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
if (active) {
m_container->setFocus();
- emit activated();
- emit writeStateChanged(m_isFolderWritable);
+ Q_EMIT activated();
+ Q_EMIT writeStateChanged(m_isFolderWritable);
}
}
const int oldZoomLevel = m_view->zoomLevel();
m_view->setPreviewsShown(show);
- emit previewsShownChanged(show);
+ Q_EMIT previewsShownChanged(show);
const int newZoomLevel = m_view->zoomLevel();
if (newZoomLevel != oldZoomLevel) {
- emit zoomLevelChanged(newZoomLevel, oldZoomLevel);
+ Q_EMIT zoomLevelChanged(newZoomLevel, oldZoomLevel);
}
}
props.setHiddenFilesShown(show);
m_model->setShowHiddenFiles(show);
- emit hiddenFilesShownChanged(show);
+ Q_EMIT hiddenFilesShownChanged(show);
}
bool DolphinView::hiddenFilesShown() const
m_container->controller()->model()->setGroupedSorting(grouped);
- emit groupedSortingChanged(grouped);
+ Q_EMIT groupedSortingChanged(grouped);
}
bool DolphinView::groupedSorting() const
m_view->setZoomLevel(level);
if (zoomLevel() != oldZoomLevel) {
hideToolTip();
- emit zoomLevelChanged(zoomLevel(), oldZoomLevel);
+ Q_EMIT zoomLevelChanged(zoomLevel(), oldZoomLevel);
}
}
m_visibleRoles = roles;
m_view->setVisibleRoles(roles);
- emit visibleRolesChanged(m_visibleRoles, previousRoles);
+ Q_EMIT visibleRolesChanged(m_visibleRoles, previousRoles);
}
QList<QByteArray> DolphinView::visibleRoles() const
const int newZoomLevel = m_view->zoomLevel();
if (newZoomLevel != oldZoomLevel) {
- emit zoomLevelChanged(newZoomLevel, oldZoomLevel);
+ Q_EMIT zoomLevelChanged(newZoomLevel, oldZoomLevel);
}
}
if (m_container->controller()->selectionManager()->hasSelection()) {
// Give a summary of the status of the selected files
const KFileItemList list = selectedItems();
- foreach (const KFileItem& item, list) {
+ for (const KFileItem& item : list) {
if (item.isDir()) {
++folderCount;
} else {
applyViewProperties();
loadDirectory(url);
- emit urlChanged(url);
+ Q_EMIT urlChanged(url);
}
void DolphinView::selectAll()
if (GeneralSettings::useTabForSwitchingSplitView()) {
QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
if (keyEvent->key() == Qt::Key_Tab && keyEvent->modifiers() == Qt::NoModifier) {
- emit toggleActiveViewRequested();
+ Q_EMIT toggleActiveViewRequested();
return true;
}
}
void DolphinView::wheelEvent(QWheelEvent* event)
{
if (event->modifiers().testFlag(Qt::ControlModifier)) {
- const int numDegrees = event->delta() / 8;
- const int numSteps = numDegrees / 15;
+ const QPoint numDegrees = event->angleDelta() / 8;
+ const QPoint numSteps = numDegrees / 15;
- setZoomLevel(zoomLevel() + numSteps);
+ setZoomLevel(zoomLevel() + numSteps.y());
event->accept();
} else {
event->ignore();
const KFileItem item = m_model->fileItem(index);
if (!item.isNull()) {
- emit itemActivated(item);
+ Q_EMIT itemActivated(item);
}
}
const QUrl& url = openItemAsFolderUrl(item);
if (!url.isEmpty()) { // Open folders in new tabs
- emit tabRequested(url, DolphinTabWidget::AfterLastTab);
+ Q_EMIT tabRequested(url, DolphinTabWidget::AfterLastTab);
} else {
items.append(item);
}
}
if (items.count() == 1) {
- emit itemActivated(items.first());
+ Q_EMIT itemActivated(items.first());
} else if (items.count() > 1) {
- emit itemsActivated(items);
+ Q_EMIT itemsActivated(items);
}
}
const KFileItem& item = m_model->fileItem(index);
const QUrl& url = openItemAsFolderUrl(item);
if (!url.isEmpty()) {
- emit tabRequested(url, DolphinTabWidget::AfterCurrentTab);
+ Q_EMIT tabRequested(url, DolphinTabWidget::AfterCurrentTab);
} else if (isTabsForFilesEnabled()) {
- emit tabRequested(item.url(), DolphinTabWidget::AfterCurrentTab);
+ Q_EMIT tabRequested(item.url(), DolphinTabWidget::AfterCurrentTab);
}
}
}
const KFileItem item = m_model->fileItem(index);
- emit requestContextMenu(pos.toPoint(), item, url(), QList<QAction*>());
+ Q_EMIT requestContextMenu(pos.toPoint(), item, url(), QList<QAction*>());
}
void DolphinView::slotViewContextMenuRequested(const QPointF& pos)
{
- emit requestContextMenu(pos.toPoint(), KFileItem(), url(), QList<QAction*>());
+ Q_EMIT requestContextMenu(pos.toPoint(), KFileItem(), url(), QList<QAction*>());
}
void DolphinView::slotHeaderContextMenuRequested(const QPointF& pos)
QPointer<QMenu> menu = new QMenu(QApplication::activeWindow());
KItemListView* view = m_container->controller()->view();
- const QSet<QByteArray> visibleRolesSet = view->visibleRoles().toSet();
+ const QList<QByteArray> visibleRolesSet = view->visibleRoles();
bool indexingEnabled = false;
#ifdef HAVE_BALOO
// Add all roles to the menu that can be shown or hidden by the user
const QList<KFileItemModel::RoleInfo> rolesInfo = KFileItemModel::rolesInformation();
- foreach (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;
// Apply the current column-widths as custom column-widths and turn
// off the automatic resizing of the columns
QList<int> columnWidths;
- columnWidths.reserve(view->visibleRoles().count());
- foreach (const QByteArray& role, view->visibleRoles()) {
+ const auto visibleRoles = view->visibleRoles();
+ columnWidths.reserve(visibleRoles.count());
+ for (const QByteArray& role : visibleRoles) {
columnWidths.append(header->columnWidth(role));
}
props.setHeaderColumnWidths(columnWidths);
QList<int> columnWidths;
if (!header->automaticColumnResizing()) {
- columnWidths.reserve(view->visibleRoles().count());
- foreach (const QByteArray& role, view->visibleRoles()) {
+ const auto visibleRoles = view->visibleRoles();
+ columnWidths.reserve(visibleRoles.count());
+ for (const QByteArray& role : visibleRoles) {
columnWidths.append(header->columnWidth(role));
}
}
columnWidths.clear();
columnWidths.reserve(visibleRoles.count());
const KItemListHeader* header = m_view->header();
- foreach (const QByteArray& role, visibleRoles) {
+ for (const QByteArray& role : visibleRoles) {
const int width = header->columnWidth(role);
columnWidths.append(width);
}
#endif
}
- emit requestItemInfo(item);
+ Q_EMIT requestItemInfo(item);
}
void DolphinView::slotItemUnhovered(int index)
{
Q_UNUSED(index)
hideToolTip();
- emit requestItemInfo(KFileItem());
+ Q_EMIT requestItemInfo(KFileItem());
}
void DolphinView::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* event)
hideToolTip();
if (buttons & Qt::BackButton) {
- emit goBackRequested();
+ Q_EMIT goBackRequested();
} else if (buttons & Qt::ForwardButton) {
- emit goForwardRequested();
+ Q_EMIT goForwardRequested();
}
}
void DolphinView::slotJobResult(KJob *job)
{
if (job->error()) {
- emit errorMessage(job->errorString());
+ Q_EMIT errorMessage(job->errorString());
}
if (!m_selectedUrls.isEmpty()) {
m_selectedUrls = KDirModel::simplifiedUrlList(m_selectedUrls);
void DolphinView::emitSelectionChangedSignal()
{
m_selectionChangedTimer->stop();
- emit selectionChanged(selectedItems());
+ Q_EMIT selectionChanged(selectedItems());
}
void DolphinView::updateSortRole(const QByteArray& role)
KItemModelBase* model = m_container->controller()->model();
model->setSortRole(role);
- emit sortRoleChanged(role);
+ Q_EMIT sortRoleChanged(role);
}
void DolphinView::updateSortOrder(Qt::SortOrder order)
m_model->setSortOrder(order);
- emit sortOrderChanged(order);
+ Q_EMIT sortOrderChanged(order);
}
void DolphinView::updateSortFoldersFirst(bool foldersFirst)
m_model->setSortDirectoriesFirst(foldersFirst);
- emit sortFoldersFirstChanged(foldersFirst);
+ Q_EMIT sortFoldersFirstChanged(foldersFirst);
}
QPair<bool, QString> DolphinView::pasteInfo() const
void DolphinView::slotDirectoryRedirection(const QUrl& oldUrl, const QUrl& newUrl)
{
if (oldUrl.matches(url(), QUrl::StripTrailingSlash)) {
- emit redirection(oldUrl, newUrl);
+ Q_EMIT redirection(oldUrl, newUrl);
m_url = newUrl; // #186947
}
}
if (GeneralSettings::showToolTips()) {
m_toolTipManager->hideToolTip(behavior);
}
+#else
+ Q_UNUSED(behavior)
#endif
}
void DolphinView::slotTrashFileFinished(KJob* job)
{
if (job->error() == 0) {
- emit operationCompletedMessage(i18nc("@info:status", "Trash operation completed."));
+ Q_EMIT operationCompletedMessage(i18nc("@info:status", "Trash operation completed."));
} else if (job->error() != KIO::ERR_USER_CANCELED) {
- emit errorMessage(job->errorString());
+ Q_EMIT errorMessage(job->errorString());
}
}
void DolphinView::slotDeleteFileFinished(KJob* job)
{
if (job->error() == 0) {
- emit operationCompletedMessage(i18nc("@info:status", "Delete operation completed."));
+ Q_EMIT operationCompletedMessage(i18nc("@info:status", "Delete operation completed."));
} else if (job->error() != KIO::ERR_USER_CANCELED) {
- emit errorMessage(job->errorString());
+ Q_EMIT errorMessage(job->errorString());
}
}
// in DolphinView::slotDirectoryLoadingCompleted()
if (m_isFolderWritable) {
m_isFolderWritable = false;
- emit writeStateChanged(m_isFolderWritable);
+ Q_EMIT writeStateChanged(m_isFolderWritable);
}
- emit directoryLoadingStarted();
+ Q_EMIT directoryLoadingStarted();
}
void DolphinView::slotDirectoryLoadingCompleted()
// because the view might not be in its final state yet.
QTimer::singleShot(0, this, &DolphinView::updateViewState);
- emit directoryLoadingCompleted();
+ Q_EMIT directoryLoadingCompleted();
updateWritableState();
}
ViewProperties props(viewPropertiesUrl());
props.setSortOrder(current);
- emit sortOrderChanged(current);
+ Q_EMIT sortOrderChanged(current);
}
void DolphinView::slotSortRoleChangedByHeader(const QByteArray& current, const QByteArray& previous)
ViewProperties props(viewPropertiesUrl());
props.setSortRole(current);
- emit sortRoleChanged(current);
+ Q_EMIT sortRoleChanged(current);
}
void DolphinView::slotVisibleRolesChangedByHeader(const QList<QByteArray>& current,
ViewProperties props(viewPropertiesUrl());
props.setVisibleRoles(m_visibleRoles);
- emit visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
+ Q_EMIT visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
}
void DolphinView::slotRoleEditingCanceled()
if (!url.isValid()) {
const QString location(url.toDisplayString(QUrl::PreferLocalFile));
if (location.isEmpty()) {
- emit errorMessage(i18nc("@info:status", "The location is empty."));
+ Q_EMIT errorMessage(i18nc("@info:status", "The location is empty."));
} else {
- emit errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location));
+ Q_EMIT errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location));
}
return;
}
const int oldZoomLevel = m_view->zoomLevel();
applyModeToView();
- emit modeChanged(m_mode, previousMode);
+ Q_EMIT modeChanged(m_mode, previousMode);
if (m_view->zoomLevel() != oldZoomLevel) {
- emit zoomLevelChanged(m_view->zoomLevel(), oldZoomLevel);
+ Q_EMIT zoomLevelChanged(m_view->zoomLevel(), oldZoomLevel);
}
}
const bool hiddenFilesShown = props.hiddenFilesShown();
if (hiddenFilesShown != m_model->showHiddenFiles()) {
m_model->setShowHiddenFiles(hiddenFilesShown);
- emit hiddenFilesShownChanged(hiddenFilesShown);
+ Q_EMIT hiddenFilesShownChanged(hiddenFilesShown);
}
const bool groupedSorting = props.groupedSorting();
if (groupedSorting != m_model->groupedSorting()) {
m_model->setGroupedSorting(groupedSorting);
- emit groupedSortingChanged(groupedSorting);
+ Q_EMIT groupedSortingChanged(groupedSorting);
}
const QByteArray sortRole = props.sortRole();
if (sortRole != m_model->sortRole()) {
m_model->setSortRole(sortRole);
- emit sortRoleChanged(sortRole);
+ Q_EMIT sortRoleChanged(sortRole);
}
const Qt::SortOrder sortOrder = props.sortOrder();
if (sortOrder != m_model->sortOrder()) {
m_model->setSortOrder(sortOrder);
- emit sortOrderChanged(sortOrder);
+ Q_EMIT sortOrderChanged(sortOrder);
}
const bool sortFoldersFirst = props.sortFoldersFirst();
if (sortFoldersFirst != m_model->sortDirectoriesFirst()) {
m_model->setSortDirectoriesFirst(sortFoldersFirst);
- emit sortFoldersFirstChanged(sortFoldersFirst);
+ Q_EMIT sortFoldersFirstChanged(sortFoldersFirst);
}
const QList<QByteArray> visibleRoles = props.visibleRoles();
const QList<QByteArray> previousVisibleRoles = m_visibleRoles;
m_visibleRoles = visibleRoles;
m_view->setVisibleRoles(visibleRoles);
- emit visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
+ Q_EMIT visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
}
const bool previewsShown = props.previewsShown();
const int oldZoomLevel = zoomLevel();
m_view->setPreviewsShown(previewsShown);
- emit previewsShownChanged(previewsShown);
+ Q_EMIT previewsShownChanged(previewsShown);
// Changing the preview-state might result in a changed zoom-level
if (oldZoomLevel != zoomLevel()) {
- emit zoomLevelChanged(zoomLevel(), oldZoomLevel);
+ Q_EMIT zoomLevelChanged(zoomLevel(), oldZoomLevel);
}
}
const KFileItemList items = selectedItems();
urls.reserve(items.count());
- foreach (const KFileItem& item, items) {
+ for (const KFileItem& item : items) {
urls.append(item.url());
}
m_isFolderWritable = capabilities.supportsWriting();
if (m_isFolderWritable != wasFolderWritable) {
- emit writeStateChanged(m_isFolderWritable);
+ Q_EMIT writeStateChanged(m_isFolderWritable);
}
}
}
clipboard->setText(path);
}
+
+void DolphinView::slotIncreaseZoom()
+{
+ setZoomLevel(zoomLevel() + 1);
+}
+
+void DolphinView::slotDecreaseZoom()
+{
+ setZoomLevel(zoomLevel() - 1);
+}
+
+void DolphinView::slotSwipeUp()
+{
+ Q_EMIT goUpRequested();
+}
projects / dolphin.git / blobdiff