X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/02e2ef207d60098708de5ef77847e4cd1ca08397..148282e2d856b47ceb191eeef4c834118c8cdffd:/src/dolphindetailsview.cpp diff --git a/src/dolphindetailsview.cpp b/src/dolphindetailsview.cpp index c26d3d5b5..32deb873b 100644 --- a/src/dolphindetailsview.cpp +++ b/src/dolphindetailsview.cpp @@ -1,6 +1,6 @@ /*************************************************************************** - * Copyright (C) 2006 by Peter Penz * - * peter.penz@gmx.at * + * Copyright (C) 2006 by Peter Penz (peter.penz@gmx.at) * + * Copyright (C) 2008 by Simon St. James (kdedevel@etotheipiplusone.com) * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * @@ -22,15 +22,23 @@ #include "dolphinmodel.h" #include "dolphincontroller.h" +#include "dolphinfileitemdelegate.h" #include "dolphinsettings.h" #include "dolphinsortfilterproxymodel.h" +#include "dolphinviewautoscroller.h" +#include "draganddrophelper.h" +#include "selectionmanager.h" #include "viewproperties.h" +#include "zoomlevelinfo.h" #include "dolphin_detailsmodesettings.h" +#include "dolphin_generalsettings.h" +#include #include #include +#include #include #include #include @@ -40,25 +48,35 @@ DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* controller) : QTreeView(parent), + m_autoResize(true), + m_expandingTogglePressed(false), + m_keyPressed(false), + m_useDefaultIndexAt(true), + m_ignoreScrollTo(false), m_controller(controller), - m_dragging(false), - m_showElasticBand(false), - m_elasticBandOrigin(), - m_elasticBandDestination() + m_selectionManager(0), + m_font(), + m_decorationSize(), + m_band() { + const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + Q_ASSERT(settings != 0); Q_ASSERT(controller != 0); + setLayoutDirection(Qt::LeftToRight); setAcceptDrops(true); - setRootIsDecorated(false); setSortingEnabled(true); setUniformRowHeights(true); setSelectionBehavior(SelectItems); setDragDropMode(QAbstractItemView::DragDrop); setDropIndicatorShown(false); setAlternatingRowColors(true); + setRootIsDecorated(settings->expandableFolders()); + setItemsExpandable(settings->expandableFolders()); + setEditTriggers(QAbstractItemView::NoEditTriggers); setMouseTracking(true); - viewport()->setAttribute(Qt::WA_Hover); + new DolphinViewAutoScroller(this); const ViewProperties props(controller->url()); setSortIndicatorSection(props.sorting()); @@ -70,54 +88,70 @@ DolphinDetailsView::DolphinDetailsView(QWidget* parent, DolphinController* contr headerView->setContextMenuPolicy(Qt::CustomContextMenu); connect(headerView, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(configureColumns(const QPoint&))); + connect(headerView, SIGNAL(sectionResized(int, int, int)), + this, SLOT(slotHeaderSectionResized(int, int, int))); + connect(headerView, SIGNAL(sectionHandleDoubleClicked(int)), + this, SLOT(disableAutoResizing())); connect(parent, SIGNAL(sortingChanged(DolphinView::Sorting)), this, SLOT(setSortIndicatorSection(DolphinView::Sorting))); connect(parent, SIGNAL(sortOrderChanged(Qt::SortOrder)), this, SLOT(setSortIndicatorOrder(Qt::SortOrder))); - // TODO: Connecting to the signal 'activated()' is not possible, as kstyle - // does not forward the single vs. doubleclick to it yet (KDE 4.1?). Hence it is - // necessary connecting the signal 'singleClick()' or 'doubleClick' and to handle the - // RETURN-key in keyPressEvent(). + connect(this, SIGNAL(clicked(const QModelIndex&)), + controller, SLOT(requestTab(const QModelIndex&))); if (KGlobalSettings::singleClick()) { connect(this, SIGNAL(clicked(const QModelIndex&)), - this, SLOT(slotItemActivated(const QModelIndex&))); + controller, SLOT(triggerItem(const QModelIndex&))); } else { connect(this, SIGNAL(doubleClicked(const QModelIndex&)), - this, SLOT(slotItemActivated(const QModelIndex&))); + controller, SLOT(triggerItem(const QModelIndex&))); + } + + if (DolphinSettings::instance().generalSettings()->showSelectionToggle()) { + m_selectionManager = new SelectionManager(this); + connect(m_selectionManager, SIGNAL(selectionChanged()), + this, SLOT(requestActivation())); + connect(m_controller, SIGNAL(urlChanged(const KUrl&)), + m_selectionManager, SLOT(reset())); } + connect(this, SIGNAL(entered(const QModelIndex&)), this, SLOT(slotEntered(const QModelIndex&))); connect(this, SIGNAL(viewportEntered()), controller, SLOT(emitViewportEntered())); - connect(controller, SIGNAL(zoomIn()), - this, SLOT(zoomIn())); - connect(controller, SIGNAL(zoomOut()), - this, SLOT(zoomOut())); - - // apply the details mode settings to the widget - const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - Q_ASSERT(settings != 0); - - m_viewOptions = QTreeView::viewOptions(); - - QFont font(settings->fontFamily(), settings->fontSize()); - font.setItalic(settings->italicFont()); - font.setBold(settings->boldFont()); - m_viewOptions.font = font; - m_viewOptions.showDecorationSelected = true; + connect(controller, SIGNAL(zoomLevelChanged(int)), + this, SLOT(setZoomLevel(int))); + connect(controller->dolphinView(), SIGNAL(additionalInfoChanged()), + this, SLOT(updateColumnVisibility())); + connect(controller, SIGNAL(activationChanged(bool)), + this, SLOT(slotActivationChanged(bool))); + + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); + } else { + m_font = QFont(settings->fontFamily(), + settings->fontSize(), + settings->fontWeight(), + settings->italicFont()); + } -// TODO: Remove this check when 4.3.2 is released and KDE requires it... this -// check avoids a division by zero happening on versions before 4.3.1. -// Right now KDE in theory can be shipped with Qt 4.3.0 and above. -// ereslibre -#if (QT_VERSION >= QT_VERSION_CHECK(4, 3, 2)) setVerticalScrollMode(QTreeView::ScrollPerPixel); setHorizontalScrollMode(QTreeView::ScrollPerPixel); -#endif + + const DolphinView* view = controller->dolphinView(); + connect(view, SIGNAL(showPreviewChanged()), + this, SLOT(slotShowPreviewChanged())); - updateDecorationSize(); + updateDecorationSize(view->showPreview()); + + setFocus(); + viewport()->installEventFilter(this); + + connect(KGlobalSettings::self(), SIGNAL(kdisplayFontChanged()), + this, SLOT(updateFont())); + + m_useDefaultIndexAt = false; } DolphinDetailsView::~DolphinDetailsView() @@ -127,60 +161,31 @@ DolphinDetailsView::~DolphinDetailsView() bool DolphinDetailsView::event(QEvent* event) { if (event->type() == QEvent::Polish) { - // Assure that by respecting the available width that: - // - the 'Name' column is stretched as large as possible - // - the remaining columns are as small as possible QHeaderView* headerView = header(); - headerView->setStretchLastSection(false); - headerView->setResizeMode(QHeaderView::ResizeToContents); - headerView->setResizeMode(0, QHeaderView::Stretch); + headerView->setResizeMode(QHeaderView::Interactive); headerView->setMovable(false); - // hide columns if this is indicated by the settings - const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - Q_ASSERT(settings != 0); - if (!settings->showDate()) { - hideColumn(DolphinModel::ModifiedTime); - } - - if (!settings->showPermissions()) { - hideColumn(DolphinModel::Permissions); - } - - if (!settings->showOwner()) { - hideColumn(DolphinModel::Owner); - } - - if (!settings->showGroup()) { - hideColumn(DolphinModel::Group); - } - - if (!settings->showType()) { - hideColumn(DolphinModel::Type); - } + updateColumnVisibility(); hideColumn(DolphinModel::Rating); hideColumn(DolphinModel::Tags); - } -// TODO: Remove this check when 4.3.2 is released and KDE requires it... this -// check avoids a division by zero happening on versions before 4.3.1. -// Right now KDE in theory can be shipped with Qt 4.3.0 and above. -// ereslibre -#if (QT_VERSION >= QT_VERSION_CHECK(4, 3, 2)) - else if (event->type() == QEvent::UpdateRequest) { + } else if (event->type() == QEvent::UpdateRequest) { // a wheel movement will scroll 4 items if (model()->rowCount() > 0) { verticalScrollBar()->setSingleStep((sizeHintForRow(0) / 3) * 4); } } -#endif return QTreeView::event(event); } QStyleOptionViewItem DolphinDetailsView::viewOptions() const { - return m_viewOptions; + QStyleOptionViewItem viewOptions = QTreeView::viewOptions(); + viewOptions.font = m_font; + viewOptions.showDecorationSelected = true; + viewOptions.decorationSize = m_decorationSize; + return viewOptions; } void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event) @@ -191,65 +196,136 @@ void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event) void DolphinDetailsView::mousePressEvent(QMouseEvent* event) { - m_controller->triggerActivation(); + m_controller->requestActivation(); + const QModelIndex current = currentIndex(); QTreeView::mousePressEvent(event); + m_expandingTogglePressed = false; const QModelIndex index = indexAt(event->pos()); + const bool updateState = index.isValid() && + (index.column() == DolphinModel::Name) && + (event->button() == Qt::LeftButton); + if (updateState) { + // TODO: See comment in DolphinIconsView::mousePressEvent(). Only update + // the state if no expanding/collapsing area has been hit: + const QRect rect = visualRect(index); + if (event->pos().x() >= rect.x() + indentation()) { + setState(QAbstractItemView::DraggingState); + } else { + m_expandingTogglePressed = true; + kDebug() << "m_expandingTogglePressed " << m_expandingTogglePressed; + } + } + if (!index.isValid() || (index.column() != DolphinModel::Name)) { + // the mouse press is done somewhere outside the filename column + if (QApplication::mouseButtons() & Qt::MidButton) { + m_controller->replaceUrlByClipboard(); + } + const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers(); if (!(modifier & Qt::ShiftModifier) && !(modifier & Qt::ControlModifier)) { clearSelection(); } - } - - if (event->button() == Qt::LeftButton) { - m_showElasticBand = true; - const QPoint pos(contentsPos()); - m_elasticBandOrigin = event->pos(); - m_elasticBandOrigin.setX(m_elasticBandOrigin.x() + pos.x()); - m_elasticBandOrigin.setY(m_elasticBandOrigin.y() + pos.y()); - m_elasticBandDestination = event->pos(); - } + // restore the current index, other columns are handled as viewport area. + // setCurrentIndex(...) implicitly calls scrollTo(...), which we want to ignore. + m_ignoreScrollTo = true; + selectionModel()->setCurrentIndex(current, QItemSelectionModel::Current); + m_ignoreScrollTo = false; + + if ((event->button() == Qt::LeftButton) && !m_expandingTogglePressed) { + // Inform Qt about what we are doing - otherwise it starts dragging items around! + setState(DragSelectingState); + m_band.show = true; + // Incremental update data will not be useful - start from scratch. + m_band.ignoreOldInfo = true; + const QPoint pos = contentsPos(); + const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value()); + m_band.origin = event->pos() + pos + scrollPos; + m_band.destination = m_band.origin; + m_band.originalSelection = selectionModel()->selection(); + } + } } void DolphinDetailsView::mouseMoveEvent(QMouseEvent* event) { - QTreeView::mouseMoveEvent(event); - if (m_showElasticBand) { + if (m_band.show) { + const QPoint mousePos = event->pos(); + const QModelIndex index = indexAt(mousePos); + if (!index.isValid()) { + // the destination of the selection rectangle is above the viewport. In this + // case QTreeView does no selection at all, which is not the wanted behavior + // in Dolphin -> select all items within the elastic band rectangle + updateElasticBandSelection(); + } + + // TODO: enable QTreeView::mouseMoveEvent(event) again, as soon + // as the Qt-issue #199631 has been fixed. + // QTreeView::mouseMoveEvent(event); + QAbstractItemView::mouseMoveEvent(event); updateElasticBand(); + } else { + // TODO: enable QTreeView::mouseMoveEvent(event) again, as soon + // as the Qt-issue #199631 has been fixed. + // QTreeView::mouseMoveEvent(event); + QAbstractItemView::mouseMoveEvent(event); + } + + if (m_expandingTogglePressed) { + // Per default QTreeView starts either a selection or a drag operation when dragging + // the expanding toggle button (Qt-issue - see TODO comment in DolphinIconsView::mousePressEvent()). + // Turn off this behavior in Dolphin to stay predictable: + clearSelection(); + setState(QAbstractItemView::NoState); } } void DolphinDetailsView::mouseReleaseEvent(QMouseEvent* event) { - QTreeView::mouseReleaseEvent(event); - if (m_showElasticBand) { + const QModelIndex index = indexAt(event->pos()); + if (index.isValid() && (index.column() == DolphinModel::Name)) { + QTreeView::mouseReleaseEvent(event); + } else { + // don't change the current index if the cursor is released + // above any other column than the name column, as the other + // columns act as viewport + const QModelIndex current = currentIndex(); + QTreeView::mouseReleaseEvent(event); + selectionModel()->setCurrentIndex(current, QItemSelectionModel::Current); + } + + m_expandingTogglePressed = false; + if (m_band.show) { + setState(NoState); updateElasticBand(); - m_showElasticBand = false; + m_band.show = false; } } +void DolphinDetailsView::startDrag(Qt::DropActions supportedActions) +{ + DragAndDropHelper::instance().startDrag(this, supportedActions, m_controller); + m_band.show = false; +} + void DolphinDetailsView::dragEnterEvent(QDragEnterEvent* event) { - if (event->mimeData()->hasUrls()) { + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { event->acceptProposedAction(); } - if (m_showElasticBand) { + if (m_band.show) { updateElasticBand(); - m_showElasticBand = false; + m_band.show = false; } - m_dragging = true; } void DolphinDetailsView::dragLeaveEvent(QDragLeaveEvent* event) { QTreeView::dragLeaveEvent(event); - - // TODO: remove this code when the issue #160611 is solved in Qt 4.4 - m_dragging = false; setDirtyRegion(m_dropRect); } @@ -260,33 +336,37 @@ void DolphinDetailsView::dragMoveEvent(QDragMoveEvent* event) // TODO: remove this code when the issue #160611 is solved in Qt 4.4 setDirtyRegion(m_dropRect); const QModelIndex index = indexAt(event->pos()); - if (!index.isValid() || (index.column() != DolphinModel::Name)) { - m_dragging = false; - } else { - m_dragging = true; - m_dropRect = visualRect(index); + if (index.isValid() && (index.column() == DolphinModel::Name)) { + const KFileItem item = m_controller->itemForIndex(index); + if (!item.isNull() && item.isDir()) { + m_dropRect = visualRect(index); + } else { + m_dropRect.setSize(QSize()); // set as invalid + } setDirtyRegion(m_dropRect); } + + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { + // accept url drops, independently from the destination item + event->acceptProposedAction(); + } } void DolphinDetailsView::dropEvent(QDropEvent* event) { - const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData()); - if (!urls.isEmpty()) { - event->acceptProposedAction(); - m_controller->indicateDroppedUrls(urls, - m_controller->url(), - indexAt(event->pos()), - event->source()); + const QModelIndex index = indexAt(event->pos()); + KFileItem item; + if (index.isValid() && (index.column() == DolphinModel::Name)) { + item = m_controller->itemForIndex(index); } + m_controller->indicateDroppedUrls(item, m_controller->url(), event); QTreeView::dropEvent(event); - m_dragging = false; } void DolphinDetailsView::paintEvent(QPaintEvent* event) { QTreeView::paintEvent(event); - if (m_showElasticBand) { + if (m_band.show) { // The following code has been taken from QListView // and adapted to DolphinDetailsView. // (C) 1992-2007 Trolltech ASA @@ -301,61 +381,102 @@ void DolphinDetailsView::paintEvent(QPaintEvent* event) style()->drawControl(QStyle::CE_RubberBand, &opt, &painter); painter.restore(); } - - // TODO: remove this code when the issue #160611 is solved in Qt 4.4 - if (m_dragging) { - const QBrush& brush = m_viewOptions.palette.brush(QPalette::Normal, QPalette::Highlight); - DolphinController::drawHoverIndication(viewport(), m_dropRect, brush); - } } void DolphinDetailsView::keyPressEvent(QKeyEvent* event) { + // If the Control modifier is pressed, a multiple selection + // is done and DolphinDetailsView::currentChanged() may not + // not change the selection in a custom way. + m_keyPressed = !(event->modifiers() & Qt::ControlModifier); + QTreeView::keyPressEvent(event); + m_controller->handleKeyPressEvent(event); +} - const QItemSelectionModel* selModel = selectionModel(); - const QModelIndex currentIndex = selModel->currentIndex(); - const bool triggerItem = currentIndex.isValid() - && (event->key() == Qt::Key_Return) - && (selModel->selectedIndexes().count() <= 1); - if (triggerItem) { - m_controller->triggerItem(currentIndex); - } +void DolphinDetailsView::keyReleaseEvent(QKeyEvent* event) +{ + QTreeView::keyReleaseEvent(event); + m_keyPressed = false; } void DolphinDetailsView::resizeEvent(QResizeEvent* event) { QTreeView::resizeEvent(event); + if (m_autoResize) { + resizeColumns(); + } +} - // assure that the width of the name-column does not get too small - const int minWidth = 120; - QHeaderView* headerView = header(); - bool useFixedWidth = (headerView->sectionSize(KDirModel::Name) <= minWidth) - && (headerView->resizeMode(0) != QHeaderView::Fixed); - if (useFixedWidth) { - // the current width of the name-column is too small, hence - // use a fixed size - headerView->setResizeMode(QHeaderView::Fixed); - headerView->setResizeMode(0, QHeaderView::Fixed); - headerView->resizeSection(KDirModel::Name, minWidth); - } else if (headerView->resizeMode(0) != QHeaderView::Stretch) { - // check whether there is enough available viewport width - // to automatically resize the columns - const int availableWidth = viewport()->width(); - - int headerWidth = 0; - const int count = headerView->count(); - for (int i = 0; i < count; ++i) { - headerWidth += headerView->sectionSize(i); - } +void DolphinDetailsView::wheelEvent(QWheelEvent* event) +{ + if (m_selectionManager != 0) { + m_selectionManager->reset(); + } - if (headerWidth < availableWidth) { - headerView->setResizeMode(QHeaderView::ResizeToContents); - headerView->setResizeMode(0, QHeaderView::Stretch); - } + // let Ctrl+wheel events propagate to the DolphinView for icon zooming + if (event->modifiers() & Qt::ControlModifier) { + event->ignore(); + return; + } + + QTreeView::wheelEvent(event); +} + +void DolphinDetailsView::currentChanged(const QModelIndex& current, const QModelIndex& previous) +{ + QTreeView::currentChanged(current, previous); + + // Stay consistent with QListView: When changing the current index by key presses, + // also change the selection. + if (m_keyPressed) { + selectionModel()->select(current, QItemSelectionModel::ClearAndSelect); + } +} + +bool DolphinDetailsView::eventFilter(QObject* watched, QEvent* event) +{ + if ((watched == viewport()) && (event->type() == QEvent::Leave)) { + // if the mouse is above an item and moved very fast outside the widget, + // no viewportEntered() signal might be emitted although the mouse has been moved + // above the viewport + m_controller->emitViewportEntered(); + } + + return QTreeView::eventFilter(watched, event); +} + +QModelIndex DolphinDetailsView::indexAt(const QPoint& point) const +{ + // the blank portion of the name column counts as empty space + const QModelIndex index = QTreeView::indexAt(point); + const bool isAboveEmptySpace = !m_useDefaultIndexAt && + (index.column() == KDirModel::Name) && !nameColumnRect(index).contains(point); + return isAboveEmptySpace ? QModelIndex() : index; +} + +void DolphinDetailsView::setSelection(const QRect &rect, QItemSelectionModel::SelectionFlags command) +{ + // We must override setSelection() as Qt calls it internally and when this happens + // we must ensure that the default indexAt() is used. + if (!m_band.show) { + m_useDefaultIndexAt = true; + QTreeView::setSelection(rect, command); + m_useDefaultIndexAt = false; + } else { + + // Use our own elastic band selection algorithm + updateElasticBandSelection(); } } +void DolphinDetailsView::scrollTo(const QModelIndex & index, ScrollHint hint) +{ + if (m_ignoreScrollTo) + return; + QTreeView::scrollTo(index, hint); +} + void DolphinDetailsView::setSortIndicatorSection(DolphinView::Sorting sorting) { QHeaderView* headerView = header(); @@ -380,59 +501,61 @@ void DolphinDetailsView::synchronizeSortingState(int column) void DolphinDetailsView::slotEntered(const QModelIndex& index) { - const QPoint pos = viewport()->mapFromGlobal(QCursor::pos()); - const int nameColumnWidth = header()->sectionSize(DolphinModel::Name); - if (pos.x() < nameColumnWidth) { + if (index.column() == DolphinModel::Name) { m_controller->emitItemEntered(index); - } - else { + } else { m_controller->emitViewportEntered(); } } void DolphinDetailsView::updateElasticBand() { - Q_ASSERT(m_showElasticBand); - QRect dirtyRegion(elasticBandRect()); - m_elasticBandDestination = viewport()->mapFromGlobal(QCursor::pos()); - dirtyRegion = dirtyRegion.united(elasticBandRect()); - setDirtyRegion(dirtyRegion); + if (m_band.show) { + QRect dirtyRegion(elasticBandRect()); + const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value()); + m_band.destination = viewport()->mapFromGlobal(QCursor::pos()) + scrollPos; + // Going above the (logical) top-left of the view causes complications during selection; + // we may as well prevent it. + if (m_band.destination.y() < 0) + m_band.destination.setY(0); + if (m_band.destination.x() < 0) + m_band.destination.setX(0); + + dirtyRegion = dirtyRegion.united(elasticBandRect()); + setDirtyRegion(dirtyRegion); + } } -void DolphinDetailsView::zoomIn() +QRect DolphinDetailsView::elasticBandRect() const { - if (isZoomInPossible()) { - DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - switch (settings->iconSize()) { - case KIconLoader::SizeSmall: settings->setIconSize(KIconLoader::SizeMedium); break; - case KIconLoader::SizeMedium: settings->setIconSize(KIconLoader::SizeLarge); break; - default: Q_ASSERT(false); break; - } - updateDecorationSize(); - } + const QPoint pos(contentsPos()); + const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value()); + + const QPoint topLeft = m_band.origin - pos - scrollPos; + const QPoint bottomRight = m_band.destination - pos - scrollPos; + return QRect(topLeft, bottomRight).normalized(); } -void DolphinDetailsView::zoomOut() +void DolphinDetailsView::setZoomLevel(int level) { - if (isZoomOutPossible()) { - DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - switch (settings->iconSize()) { - case KIconLoader::SizeLarge: settings->setIconSize(KIconLoader::SizeMedium); break; - case KIconLoader::SizeMedium: settings->setIconSize(KIconLoader::SizeSmall); break; - default: Q_ASSERT(false); break; - } - updateDecorationSize(); + const int size = ZoomLevelInfo::iconSizeForZoomLevel(level); + DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + + const bool showPreview = m_controller->dolphinView()->showPreview(); + if (showPreview) { + settings->setPreviewSize(size); + } else { + settings->setIconSize(size); } + + updateDecorationSize(showPreview); } -void DolphinDetailsView::slotItemActivated(const QModelIndex& index) + +void DolphinDetailsView::slotShowPreviewChanged() { - if (index.isValid() && (index.column() == KDirModel::Name)) { - m_controller->triggerItem(index); - } else { - clearSelection(); - m_controller->emitItemEntered(index); - } + const DolphinView* view = m_controller->dolphinView(); + updateDecorationSize(view->showPreview()); } void DolphinDetailsView::configureColumns(const QPoint& pos) @@ -441,7 +564,7 @@ void DolphinDetailsView::configureColumns(const QPoint& pos) popup.addTitle(i18nc("@title:menu", "Columns")); QHeaderView* headerView = header(); - for (int i = DolphinModel::ModifiedTime; i <= DolphinModel::Type; ++i) { + for (int i = DolphinModel::Size; i <= DolphinModel::Type; ++i) { const int logicalIndex = headerView->logicalIndex(i); const QString text = model()->headerData(i, Qt::Horizontal).toString(); QAction* action = popup.addAction(text); @@ -453,49 +576,270 @@ void DolphinDetailsView::configureColumns(const QPoint& pos) QAction* activatedAction = popup.exec(header()->mapToGlobal(pos)); if (activatedAction != 0) { const bool show = activatedAction->isChecked(); - DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - Q_ASSERT(settings != 0); - - // remember the changed column visibility in the settings const int columnIndex = activatedAction->data().toInt(); - switch (columnIndex) { - case DolphinModel::ModifiedTime: settings->setShowDate(show); break; - case DolphinModel::Permissions: settings->setShowPermissions(show); break; - case DolphinModel::Owner: settings->setShowOwner(show); break; - case DolphinModel::Group: settings->setShowGroup(show); break; - case DolphinModel::Type: settings->setShowType(show); break; - default: break; - } - // apply the changed column visibility + KFileItemDelegate::InformationList list = m_controller->dolphinView()->additionalInfo(); + const KFileItemDelegate::Information info = infoForColumn(columnIndex); if (show) { - showColumn(columnIndex); + Q_ASSERT(!list.contains(info)); + list.append(info); } else { - hideColumn(columnIndex); + Q_ASSERT(list.contains(info)); + const int index = list.indexOf(info); + list.removeAt(index); } + + m_controller->indicateAdditionalInfoChange(list); + setColumnHidden(columnIndex, !show); + resizeColumns(); } } -bool DolphinDetailsView::isZoomInPossible() const +void DolphinDetailsView::updateColumnVisibility() { - DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - return settings->iconSize() < KIconLoader::SizeLarge; + const KFileItemDelegate::InformationList list = m_controller->dolphinView()->additionalInfo(); + for (int i = DolphinModel::Size; i <= DolphinModel::Type; ++i) { + const KFileItemDelegate::Information info = infoForColumn(i); + const bool hide = !list.contains(info); + if (isColumnHidden(i) != hide) { + setColumnHidden(i, hide); + } + } + + resizeColumns(); } -bool DolphinDetailsView::isZoomOutPossible() const +void DolphinDetailsView::slotHeaderSectionResized(int logicalIndex, int oldSize, int newSize) { - DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - return settings->iconSize() > KIconLoader::SizeSmall; + Q_UNUSED(logicalIndex); + Q_UNUSED(oldSize); + Q_UNUSED(newSize); + // If the user changes the size of the headers, the autoresize feature should be + // turned off. As there is no dedicated interface to find out whether the header + // section has been resized by the user or by a resize event, the following approach is used: + if ((QApplication::mouseButtons() & Qt::LeftButton) && isVisible()) { + disableAutoResizing(); + } +} + +void DolphinDetailsView::slotActivationChanged(bool active) +{ + setAlternatingRowColors(active); +} + +void DolphinDetailsView::disableAutoResizing() +{ + m_autoResize = false; +} + +void DolphinDetailsView::requestActivation() +{ + m_controller->requestActivation(); +} + +void DolphinDetailsView::updateFont() +{ + const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + Q_ASSERT(settings != 0); + + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); + } } -void DolphinDetailsView::updateDecorationSize() +void DolphinDetailsView::updateElasticBandSelection() +{ + if (!m_band.show) { + return; + } + + // Ensure the elastic band itself is up-to-date, in + // case we are being called due to e.g. a drag event. + updateElasticBand(); + + // Clip horizontally to the name column, as some filenames will be + // longer than the column. We don't clip vertically as origin + // may be above or below the current viewport area. + const int nameColumnX = header()->sectionPosition(DolphinModel::Name); + const int nameColumnWidth = header()->sectionSize(DolphinModel::Name); + QRect selRect = elasticBandRect().normalized(); + QRect nameColumnArea(nameColumnX, selRect.y(), nameColumnWidth, selRect.height()); + selRect = nameColumnArea.intersect(selRect).normalized(); + // Get the last elastic band rectangle, expressed in viewpoint coordinates. + const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value()); + QRect oldSelRect = QRect(m_band.lastSelectionOrigin - scrollPos, m_band.lastSelectionDestination - scrollPos).normalized(); + + if (selRect.isNull()) { + selectionModel()->select(m_band.originalSelection, QItemSelectionModel::ClearAndSelect); + m_band.ignoreOldInfo = true; + return; + } + + if (!m_band.ignoreOldInfo) { + // Do some quick checks to see if we can rule out the need to + // update the selection. + Q_ASSERT(uniformRowHeights()); + QModelIndex dummyIndex = model()->index(0, 0); + if (!dummyIndex.isValid()) { + // No items in the model presumably. + return; + } + + // If the elastic band does not cover the same rows as before, we'll + // need to re-check, and also invalidate the old item distances. + const int rowHeight = QTreeView::rowHeight(dummyIndex); + const bool coveringSameRows = + (selRect.top() / rowHeight == oldSelRect.top() / rowHeight) && + (selRect.bottom() / rowHeight == oldSelRect.bottom() / rowHeight); + if (coveringSameRows) { + // Covering the same rows, but have we moved far enough horizontally + // that we might have (de)selected some other items? + const bool itemSelectionChanged = + ((selRect.left() > oldSelRect.left()) && + (selRect.left() > m_band.insideNearestLeftEdge)) || + ((selRect.left() < oldSelRect.left()) && + (selRect.left() <= m_band.outsideNearestLeftEdge)) || + ((selRect.right() < oldSelRect.right()) && + (selRect.left() >= m_band.insideNearestRightEdge)) || + ((selRect.right() > oldSelRect.right()) && + (selRect.right() >= m_band.outsideNearestRightEdge)); + + if (!itemSelectionChanged) { + return; + } + } + } + else { + // This is the only piece of optimization data that needs to be explicitly + // discarded. + m_band.lastSelectionOrigin = QPoint(); + m_band.lastSelectionDestination = QPoint(); + oldSelRect = selRect; + } + + // Do the selection from scratch. Force a update of the horizontal distances info. + m_band.insideNearestLeftEdge = nameColumnX + nameColumnWidth + 1; + m_band.insideNearestRightEdge = nameColumnX - 1; + m_band.outsideNearestLeftEdge = nameColumnX - 1; + m_band.outsideNearestRightEdge = nameColumnX + nameColumnWidth + 1; + + // Include the old selection rect as well, so we can deselect + // items that were inside it but not in the new selRect. + const QRect boundingRect = selRect.united(oldSelRect).normalized(); + if (boundingRect.isNull()) { + return; + } + + // Get the index of the item in this row in the name column. + // TODO - would this still work if the columns could be re-ordered? + QModelIndex startIndex = QTreeView::indexAt(boundingRect.topLeft()); + if (startIndex.parent().isValid()) { + startIndex = startIndex.parent().child(startIndex.row(), KDirModel::Name); + } else { + startIndex = model()->index(startIndex.row(), KDirModel::Name); + } + if (!startIndex.isValid()) { + selectionModel()->select(m_band.originalSelection, QItemSelectionModel::ClearAndSelect); + m_band.ignoreOldInfo = true; + return; + } + + // Go through all indexes between the top and bottom of boundingRect, and + // update the selection. + const int verticalCutoff = boundingRect.bottom(); + QModelIndex currIndex = startIndex; + QModelIndex lastIndex; + bool allItemsInBoundDone = false; + + // Calling selectionModel()->select(...) for each item that needs to be + // toggled is slow as each call emits selectionChanged(...) so store them + // and do the selection toggle in one batch. + QItemSelection itemsToToggle; + // QItemSelection's deal with continuous ranges of indexes better than + // single indexes, so try to portion items that need to be toggled into ranges. + bool formingToggleIndexRange = false; + QModelIndex toggleIndexRangeBegin = QModelIndex(); + + do { + QRect currIndexRect = nameColumnRect(currIndex); + + // Update some optimization info as we go. + const int cr = currIndexRect.right(); + const int cl = currIndexRect.left(); + const int sl = selRect.left(); + const int sr = selRect.right(); + // "The right edge of the name is outside of the rect but nearer than m_outsideNearestLeft", etc + if ((cr < sl && cr > m_band.outsideNearestLeftEdge)) { + m_band.outsideNearestLeftEdge = cr; + } + if ((cl > sr && cl < m_band.outsideNearestRightEdge)) { + m_band.outsideNearestRightEdge = cl; + } + if ((cl >= sl && cl <= sr && cl > m_band.insideNearestRightEdge)) { + m_band.insideNearestRightEdge = cl; + } + if ((cr >= sl && cr <= sr && cr < m_band.insideNearestLeftEdge)) { + m_band.insideNearestLeftEdge = cr; + } + + bool currentlySelected = selectionModel()->isSelected(currIndex); + bool originallySelected = m_band.originalSelection.contains(currIndex); + bool intersectsSelectedRect = currIndexRect.intersects(selRect); + bool shouldBeSelected = (intersectsSelectedRect && !originallySelected) || (!intersectsSelectedRect && originallySelected); + bool needToToggleItem = (currentlySelected && !shouldBeSelected) || (!currentlySelected && shouldBeSelected); + if (needToToggleItem && !formingToggleIndexRange) { + toggleIndexRangeBegin = currIndex; + formingToggleIndexRange = true; + } + + // NOTE: indexBelow actually walks up and down expanded trees for us. + QModelIndex nextIndex = indexBelow(currIndex); + allItemsInBoundDone = !nextIndex.isValid() || currIndexRect.top() > verticalCutoff; + + const bool commitToggleIndexRange = formingToggleIndexRange && + (!needToToggleItem || + allItemsInBoundDone || + currIndex.parent() != toggleIndexRangeBegin.parent()); + if (commitToggleIndexRange) { + formingToggleIndexRange = false; + // If this is the last item in the bounds and it is also the beginning of a range, + // don't toggle lastIndex - it will already have been dealt with. + if (!allItemsInBoundDone || toggleIndexRangeBegin != currIndex) { + itemsToToggle.select(toggleIndexRangeBegin, lastIndex); + } + // Need to start a new range immediately with currIndex? + if (needToToggleItem) { + toggleIndexRangeBegin = currIndex; + formingToggleIndexRange = true; + } + if (allItemsInBoundDone && needToToggleItem) { + // Toggle the very last item in the bounds. + itemsToToggle.select(currIndex, currIndex); + } + } + + // next item + lastIndex = currIndex; + currIndex = nextIndex; + } while (!allItemsInBoundDone); + + selectionModel()->select(itemsToToggle, QItemSelectionModel::Toggle); + + m_band.lastSelectionOrigin = m_band.origin; + m_band.lastSelectionDestination = m_band.destination; + m_band.ignoreOldInfo = false; +} + +void DolphinDetailsView::updateDecorationSize(bool showPreview) { DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - const int iconSize = settings->iconSize(); - m_viewOptions.decorationSize = QSize(iconSize, iconSize); + const int iconSize = showPreview ? settings->previewSize() : settings->iconSize(); + setIconSize(QSize(iconSize, iconSize)); + m_decorationSize = QSize(iconSize, iconSize); - m_controller->setZoomInPossible(isZoomInPossible()); - m_controller->setZoomOutPossible(isZoomOutPossible()); + if (m_selectionManager != 0) { + m_selectionManager->reset(); + } doItemsLayout(); } @@ -518,16 +862,83 @@ QPoint DolphinDetailsView::contentsPos() const return QPoint(0, y); } -QRect DolphinDetailsView::elasticBandRect() const +KFileItemDelegate::Information DolphinDetailsView::infoForColumn(int columnIndex) const { - const QPoint pos(contentsPos()); - const QPoint topLeft(m_elasticBandOrigin.x() - pos.x(), m_elasticBandOrigin.y() - pos.y()); - return QRect(topLeft, m_elasticBandDestination).normalized(); + KFileItemDelegate::Information info = KFileItemDelegate::NoInformation; + + switch (columnIndex) { + case DolphinModel::Size: info = KFileItemDelegate::Size; break; + case DolphinModel::ModifiedTime: info = KFileItemDelegate::ModificationTime; break; + case DolphinModel::Permissions: info = KFileItemDelegate::Permissions; break; + case DolphinModel::Owner: info = KFileItemDelegate::Owner; break; + case DolphinModel::Group: info = KFileItemDelegate::OwnerAndGroup; break; + case DolphinModel::Type: info = KFileItemDelegate::FriendlyMimeType; break; + default: break; + } + + return info; +} + +void DolphinDetailsView::resizeColumns() +{ + // Using the resize mode QHeaderView::ResizeToContents is too slow (it takes + // around 3 seconds for each (!) resize operation when having > 10000 items). + // This gets a problem especially when opening large directories, where several + // resize operations are received for showing the currently available items during + // loading (the application hangs around 20 seconds when loading > 10000 items). + + QHeaderView* headerView = header(); + QFontMetrics fontMetrics(viewport()->font()); + + int columnWidth[KDirModel::ColumnCount]; + columnWidth[KDirModel::Size] = fontMetrics.width("00000 Items"); + columnWidth[KDirModel::ModifiedTime] = fontMetrics.width("0000-00-00 00:00"); + columnWidth[KDirModel::Permissions] = fontMetrics.width("xxxxxxxxxx"); + columnWidth[KDirModel::Owner] = fontMetrics.width("xxxxxxxxxx"); + columnWidth[KDirModel::Group] = fontMetrics.width("xxxxxxxxxx"); + columnWidth[KDirModel::Type] = fontMetrics.width("XXXX Xxxxxxx"); + + int requiredWidth = 0; + for (int i = KDirModel::Size; i <= KDirModel::Type; ++i) { + if (!isColumnHidden(i)) { + columnWidth[i] += 20; // provide a default gap + requiredWidth += columnWidth[i]; + headerView->resizeSection(i, columnWidth[i]); + } + } + + // resize the name column in a way that the whole available width is used + columnWidth[KDirModel::Name] = viewport()->width() - requiredWidth; + if (columnWidth[KDirModel::Name] < 120) { + columnWidth[KDirModel::Name] = 120; + } + headerView->resizeSection(KDirModel::Name, columnWidth[KDirModel::Name]); +} + +QRect DolphinDetailsView::nameColumnRect(const QModelIndex& index) const +{ + QRect rect = visualRect(index); + const KFileItem item = m_controller->itemForIndex(index); + if (!item.isNull()) { + const int width = DolphinFileItemDelegate::nameColumnWidth(item.text(), viewOptions()); + rect.setWidth(width); + } + + return rect; } -static bool isValidNameIndex(const QModelIndex& index) +DolphinDetailsView::ElasticBand::ElasticBand() : + show(false), + origin(), + destination(), + lastSelectionOrigin(), + lastSelectionDestination(), + ignoreOldInfo(true), + outsideNearestLeftEdge(0), + outsideNearestRightEdge(0), + insideNearestLeftEdge(0), + insideNearestRightEdge(0) { - return index.isValid() && (index.column() == KDirModel::Name); } #include "dolphindetailsview.moc"