X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/5252c12db4929886dbe502013e0a1fee6500f568..b1c9b5126d:/src/dolphindetailsview.cpp diff --git a/src/dolphindetailsview.cpp b/src/dolphindetailsview.cpp index 1c779b8dc..dd58e5842 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 * @@ -15,801 +15,965 @@ * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * ***************************************************************************/ #include "dolphindetailsview.h" -#include -#include -#include -#include -#include -#include -//Added by qt3to4: -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "dolphinview.h" +#include "dolphinmodel.h" +#include "dolphincontroller.h" +#include "dolphinfileitemdelegate.h" +#include "settings/dolphinsettings.h" +#include "dolphinsortfilterproxymodel.h" +#include "dolphinviewautoscroller.h" +#include "draganddrophelper.h" +#include "selectionmanager.h" #include "viewproperties.h" -#include "dolphin.h" -#include "kiconeffect.h" -#include "dolphinsettings.h" -#include "dolphinstatusbar.h" -#include "detailsmodesettings.h" - -DolphinDetailsView::DolphinDetailsView(DolphinView* parent) : - KFileDetailView(parent, 0), - m_dolphinView(parent), - m_resizeTimer(0), - m_scrollTimer(0), - m_rubber(0) -{ - m_resizeTimer = new QTimer(this); - connect(m_resizeTimer, SIGNAL(timeout()), - this, SLOT(updateColumnsWidth())); +#include "zoomlevelinfo.h" + +#include "dolphin_detailsmodesettings.h" +#include "dolphin_generalsettings.h" +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +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_selectionManager(0), + m_autoScroller(0), + m_expandableFoldersAction(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); - setSelectionMode(KFile::Extended); - setHScrollBarMode(Q3ScrollView::AlwaysOff); - - setColumnAlignment(SizeColumn, Qt::AlignRight); - for (int i = DateColumn; i <= GroupColumn; ++i) { - setColumnAlignment(i, Qt::AlignHCenter); - } - - Dolphin& dolphin = Dolphin::mainWin(); - - connect(this, SIGNAL(onItem(Q3ListViewItem*)), - this, SLOT(slotOnItem(Q3ListViewItem*))); - connect(this, SIGNAL(onViewport()), - this, SLOT(slotOnViewport())); - connect(this, SIGNAL(contextMenuRequested(Q3ListViewItem*, const QPoint&, int)), - this, SLOT(slotContextMenuRequested(Q3ListViewItem*, const QPoint&, int))); - connect(this, SIGNAL(selectionChanged()), - &dolphin, SLOT(slotSelectionChanged())); - connect(&dolphin, SIGNAL(activeViewChanged()), - this, SLOT(slotActivationUpdate())); - connect(this, SIGNAL(itemRenamed(Q3ListViewItem*, const QString&, int)), - this, SLOT(slotItemRenamed(Q3ListViewItem*, const QString&, int))); - connect(this, SIGNAL(dropped(QDropEvent*, const KURL::List&, const KURL&)), - parent, SLOT(slotURLListDropped(QDropEvent*, const KURL::List&, const KURL&))); - - QClipboard* clipboard = QApplication::clipboard(); - connect(clipboard, SIGNAL(dataChanged()), - this, SLOT(slotUpdateDisabledItems())); - - Q3Header* viewHeader = header(); - viewHeader->setResizeEnabled(false); - viewHeader->setMovingEnabled(false); - connect(viewHeader, SIGNAL(clicked(int)), - this, SLOT(slotHeaderClicked(int))); + setSortingEnabled(true); + setUniformRowHeights(true); + setSelectionBehavior(SelectItems); + setDragDropMode(QAbstractItemView::DragDrop); + setDropIndicatorShown(false); + setAlternatingRowColors(true); + setRootIsDecorated(settings->expandableFolders()); + setItemsExpandable(settings->expandableFolders()); + setEditTriggers(QAbstractItemView::NoEditTriggers); setMouseTracking(true); - setDefaultRenameAction(Q3ListView::Accept); - - refreshSettings(); + m_autoScroller = new DolphinViewAutoScroller(this); + + const ViewProperties props(controller->url()); + setSortIndicatorSection(props.sorting()); + setSortIndicatorOrder(props.sortOrder()); + + QHeaderView* headerView = header(); + connect(headerView, SIGNAL(sectionClicked(int)), + this, SLOT(synchronizeSortingState(int))); + headerView->setContextMenuPolicy(Qt::CustomContextMenu); + connect(headerView, SIGNAL(customContextMenuRequested(const QPoint&)), + this, SLOT(configureSettings(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))); + + connect(this, SIGNAL(clicked(const QModelIndex&)), + controller, SLOT(requestTab(const QModelIndex&))); + if (KGlobalSettings::singleClick()) { + connect(this, SIGNAL(clicked(const QModelIndex&)), + controller, SLOT(triggerItem(const QModelIndex&))); + } else { + connect(this, SIGNAL(doubleClicked(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(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()); + } + + setVerticalScrollMode(QTreeView::ScrollPerPixel); + setHorizontalScrollMode(QTreeView::ScrollPerPixel); + + const DolphinView* view = controller->dolphinView(); + connect(view, SIGNAL(showPreviewChanged()), + this, SLOT(slotShowPreviewChanged())); + + updateDecorationSize(view->showPreview()); + + setFocus(); + viewport()->installEventFilter(this); + + connect(KGlobalSettings::self(), SIGNAL(settingsChanged(int)), + this, SLOT(slotGlobalSettingsChanged(int))); + + m_useDefaultIndexAt = false; + + m_expandableFoldersAction = new QAction(i18nc("@option:check", "Expandable Folders"), this); + m_expandableFoldersAction->setCheckable(true); + connect(m_expandableFoldersAction, SIGNAL(toggled(bool)), + this, SLOT(setFoldersExpandable(bool))); } DolphinDetailsView::~DolphinDetailsView() -{ - delete m_rubber; - m_rubber = 0; -} - -void DolphinDetailsView::beginItemUpdates() { } -void DolphinDetailsView::endItemUpdates() +bool DolphinDetailsView::event(QEvent* event) { - updateDisabledItems(); + if (event->type() == QEvent::Polish) { + QHeaderView* headerView = header(); + headerView->setResizeMode(QHeaderView::Interactive); + headerView->setMovable(false); - // Restore the current item. Use the information stored in the history if - // available. Otherwise use the first item as current item. + updateColumnVisibility(); - const KFileListViewItem* item = static_cast(firstChild()); - if (item != 0) { - setCurrentItem(item->fileInfo()); - } - - int index = 0; - const Q3ValueList history = m_dolphinView->urlHistory(index); - if (!history.isEmpty()) { - KFileView* fileView = static_cast(this); - fileView->setCurrentItem(history[index].currentFileName()); - setContentsPos(history[index].contentsX(), history[index].contentsY()); - } - - updateColumnsWidth(); -} - -void DolphinDetailsView::insertItem(KFileItem* fileItem) -{ - KFileView::insertItem(fileItem); - - DolphinListViewItem* item = new DolphinListViewItem(static_cast(this), fileItem); - - QDir::SortSpec spec = KFileView::sorting(); - if (spec & QDir::Time) { - item->setKey(sortingKey(fileItem->time(KIO::UDS_MODIFICATION_TIME), - fileItem->isDir(), - spec)); - } - else if (spec & QDir::Size) { - item->setKey(sortingKey(fileItem->size(), fileItem->isDir(), spec)); - } - else { - item->setKey(sortingKey(fileItem->text(), fileItem->isDir(), spec)); + hideColumn(DolphinModel::Rating); + hideColumn(DolphinModel::Tags); } - fileItem->setExtraData(this, item); + return QTreeView::event(event); } -bool DolphinDetailsView::isOnFilename(const Q3ListViewItem* item, const QPoint& pos) const +QStyleOptionViewItem DolphinDetailsView::viewOptions() const { - const QPoint absPos(mapToGlobal(QPoint(0, 0))); - return (pos.x() - absPos.x()) <= filenameWidth(item); + QStyleOptionViewItem viewOptions = QTreeView::viewOptions(); + viewOptions.font = m_font; + viewOptions.showDecorationSelected = true; + viewOptions.decorationSize = m_decorationSize; + return viewOptions; } -void DolphinDetailsView::refreshSettings() +void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event) { - const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - assert(settings != 0); + QTreeView::contextMenuEvent(event); - if (!settings->showGroup()) { - removeColumn(GroupColumn); - } - if (!settings->showOwner()) { - removeColumn(OwnerColumn); - } - if (!settings->showPermissions()) { - removeColumn(PermissionsColumn); - } - if (!settings->showDate()) { - removeColumn(DateColumn); + DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + m_expandableFoldersAction->setChecked(settings->expandableFolders()); + m_controller->triggerContextMenuRequest(event->pos(), + QList() << m_expandableFoldersAction); +} + +void DolphinDetailsView::mousePressEvent(QMouseEvent* event) +{ + 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; + } } - QFont adjustedFont(font()); - adjustedFont.setFamily(settings->fontFamily()); - adjustedFont.setPointSize(settings->fontSize()); - setFont(adjustedFont); + 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(); + } - updateView(true); -} + const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers(); + if (!(modifier & Qt::ShiftModifier) && !(modifier & Qt::ControlModifier)) { + clearSelection(); + } -void DolphinDetailsView::zoomIn() -{ - if (isZoomInPossible()) { - DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - switch (settings->iconSize()) { - case KIcon::SizeSmall: settings->setIconSize(KIcon::SizeMedium); break; - case KIcon::SizeMedium: settings->setIconSize(KIcon::SizeLarge); break; - default: assert(false); break; + // 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 scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value()); + m_band.origin = event->pos() + scrollPos; + m_band.destination = m_band.origin; + m_band.originalSelection = selectionModel()->selection(); } - ItemEffectsManager::zoomIn(); } } -void DolphinDetailsView::zoomOut() +void DolphinDetailsView::mouseMoveEvent(QMouseEvent* event) { - if (isZoomOutPossible()) { - DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - switch (settings->iconSize()) { - case KIcon::SizeLarge: settings->setIconSize(KIcon::SizeMedium); break; - case KIcon::SizeMedium: settings->setIconSize(KIcon::SizeSmall); break; - default: assert(false); break; + 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(); } - ItemEffectsManager::zoomOut(); + + // 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); } -} -bool DolphinDetailsView::isZoomInPossible() const -{ - DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - return settings->iconSize() < KIcon::SizeLarge; + 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); + } } -bool DolphinDetailsView::isZoomOutPossible() const +void DolphinDetailsView::mouseReleaseEvent(QMouseEvent* event) { - DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - return settings->iconSize() > KIcon::SizeSmall; + 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_band.show = false; + } } -void DolphinDetailsView::resizeContents(int width, int height) +void DolphinDetailsView::startDrag(Qt::DropActions supportedActions) { - KFileDetailView::resizeContents(width, height); - - // When loading several 1000 items a punch of resize events - // drops in. As updating the column width is a quite expensive - // operation, this operation will be postponed until there is - // no resize event for at least 50 milliseconds. - m_resizeTimer->stop(); - m_resizeTimer->start(50, true); + DragAndDropHelper::instance().startDrag(this, supportedActions, m_controller); + m_band.show = false; } -void DolphinDetailsView::slotOnItem(Q3ListViewItem* item) +void DolphinDetailsView::dragEnterEvent(QDragEnterEvent* event) { - if (isOnFilename(item, QCursor::pos())) { - activateItem(item); - KFileItem* fileItem = static_cast(item)->fileInfo(); - m_dolphinView->requestItemInfo(fileItem->url()); + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { + event->acceptProposedAction(); } - else { - resetActivatedItem(); + + if (m_band.show) { + updateElasticBand(); + m_band.show = false; } } -void DolphinDetailsView::slotOnViewport() +void DolphinDetailsView::dragLeaveEvent(QDragLeaveEvent* event) { - resetActivatedItem(); - m_dolphinView->requestItemInfo(KURL()); + QTreeView::dragLeaveEvent(event); + setDirtyRegion(m_dropRect); } -void DolphinDetailsView::setContextPixmap(void* context, - const QPixmap& pixmap) +void DolphinDetailsView::dragMoveEvent(QDragMoveEvent* event) { - reinterpret_cast(context)->setPixmap(0, pixmap); -} + QTreeView::dragMoveEvent(event); -const QPixmap* DolphinDetailsView::contextPixmap(void* context) -{ - return reinterpret_cast(context)->pixmap(0); -} + // 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)) { + 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); + } -void* DolphinDetailsView::firstContext() -{ - return reinterpret_cast(firstChild()); + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { + // accept url drops, independently from the destination item + event->acceptProposedAction(); + } } -void* DolphinDetailsView::nextContext(void* context) +void DolphinDetailsView::dropEvent(QDropEvent* event) { - KFileListViewItem* listViewItem = reinterpret_cast(context); - return reinterpret_cast(listViewItem->nextSibling()); + 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); } -KFileItem* DolphinDetailsView::contextFileInfo(void* context) +void DolphinDetailsView::paintEvent(QPaintEvent* event) { - return reinterpret_cast(context)->fileInfo(); -} + QTreeView::paintEvent(event); + if (m_band.show) { + // The following code has been taken from QListView + // and adapted to DolphinDetailsView. + // (C) 1992-2007 Trolltech ASA + QStyleOptionRubberBand opt; + opt.initFrom(this); + opt.shape = QRubberBand::Rectangle; + opt.opaque = false; + opt.rect = elasticBandRect(); + QPainter painter(viewport()); + painter.save(); + style()->drawControl(QStyle::CE_RubberBand, &opt, &painter); + painter.restore(); + } +} -void DolphinDetailsView::contentsDragMoveEvent(QDragMoveEvent* event) +void DolphinDetailsView::keyPressEvent(QKeyEvent* event) { - KFileDetailView::contentsDragMoveEvent(event); - - // If a dragging is done above a directory, show the icon as 'active' for - // a visual feedback - KFileListViewItem* item = static_cast(itemAt(event->pos())); + // 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); - bool showActive = false; - if (item != 0) { - const KFileItem* fileInfo = item->fileInfo(); - showActive = (fileInfo != 0) && fileInfo->isDir(); - } + QTreeView::keyPressEvent(event); + m_controller->handleKeyPressEvent(event); +} - if (showActive) { - slotOnItem(item); - } - else { - slotOnViewport(); - } +void DolphinDetailsView::keyReleaseEvent(QKeyEvent* event) +{ + QTreeView::keyReleaseEvent(event); + m_keyPressed = false; } void DolphinDetailsView::resizeEvent(QResizeEvent* event) { - KFileDetailView::resizeEvent(event); - - // When loading several 1000 items a punch of resize events - // drops in. As updating the column width is a quite expensive - // operation, this operation will be postponed until there is - // no resize event for at least 50 milliseconds. - m_resizeTimer->stop(); - m_resizeTimer->start(50, true); -} - -bool DolphinDetailsView::acceptDrag(QDropEvent* event) const -{ - bool accept = KURLDrag::canDecode(event) && - (event->action() == QDropEvent::Copy || - event->action() == QDropEvent::Move || - event->action() == QDropEvent::Link); - if (accept) { - if (static_cast(event->source()) == this) { - KFileListViewItem* item = static_cast(itemAt(event->pos())); - accept = (item != 0); - if (accept) { - KFileItem* fileItem = item->fileInfo(); - accept = fileItem->isDir(); - } - } + QTreeView::resizeEvent(event); + if (m_autoResize) { + resizeColumns(); } - - return accept; } -void DolphinDetailsView::contentsDropEvent(QDropEvent* event) +void DolphinDetailsView::wheelEvent(QWheelEvent* event) { - // KFileDetailView::contentsDropEvent does not care whether the mouse - // cursor is above a filename or not, the destination URL is always - // the URL of the item. This is fixed here in a way that the destination - // URL is only the URL of the item if the cursor is above the filename. - const QPoint pos(QCursor::pos()); - const QPoint viewportPos(viewport()->mapToGlobal(QPoint(0, 0))); - Q3ListViewItem* item = itemAt(QPoint(pos.x() - viewportPos.x(), pos.y() - viewportPos.y())); - if ((item == 0) || ((item != 0) && isOnFilename(item, pos))) { - // dropping is done on the viewport or directly above a filename - KFileDetailView::contentsDropEvent(event); - return; + if (m_selectionManager != 0) { + m_selectionManager->reset(); } - // Dropping is done above an item, but the mouse cursor is not above the file name. - // In this case the signals of the base implementation will be blocked and send - // in a corrected manner afterwards. - assert(item != 0); - const bool block = signalsBlocked(); - blockSignals(true); - KFileDetailView::contentsDropEvent(event); - blockSignals(block); - - if (!acceptDrag(event)) { + // let Ctrl+wheel events propagate to the DolphinView for icon zooming + if (event->modifiers() & Qt::ControlModifier) { + event->ignore(); return; } - emit dropped(event, 0); - KURL::List urls; - if (KURLDrag::decode(event, urls) && !urls.isEmpty()) { - emit dropped(event, urls, KURL()); - sig->dropURLs(0, event, urls); - } + const int height = m_decorationSize.height(); + const int step = (height >= KIconLoader::SizeHuge) ? height / 10 : (KIconLoader::SizeHuge - height) / 2; + verticalScrollBar()->setSingleStep(step); + QTreeView::wheelEvent(event); } -void DolphinDetailsView::contentsMousePressEvent(QMouseEvent* event) +void DolphinDetailsView::currentChanged(const QModelIndex& current, const QModelIndex& previous) { - if (m_rubber != 0) { - drawRubber(); - delete m_rubber; - m_rubber = 0; + QTreeView::currentChanged(current, previous); + if (current.isValid() && !m_autoScroller->isActive()) { + scrollTo(current); } - // Swallow the base implementation of the mouse press event - // if the mouse cursor is not above the filename. This prevents - // that the item gets selected and simulates an equal usability - // like in the icon view. - const QPoint pos(QCursor::pos()); - const QPoint viewportPos(viewport()->mapToGlobal(QPoint(0, 0))); - Q3ListViewItem* item = itemAt(QPoint(pos.x() - viewportPos.x(), pos.y() - viewportPos.y())); - if ((item != 0) && isOnFilename(item, pos)) { - KFileDetailView::contentsMousePressEvent(event); - } - else if (event->button() == Qt::LeftButton) { - const ButtonState keyboardState = KApplication::keyboardMouseState(); - const bool isSelectionActive = (keyboardState & ShiftButton) || - (keyboardState & ControlButton); - if (!isSelectionActive) { - clearSelection(); - } - - assert(m_rubber == 0); - m_rubber = new QRect(event->x(), event->y(), 0, 0); + // Stay consistent with QListView: When changing the current index by key presses, + // also change the selection. + if (m_keyPressed) { + selectionModel()->select(current, QItemSelectionModel::ClearAndSelect); } - - resetActivatedItem(); - emit signalRequestActivation(); - - m_dolphinView->statusBar()->clear(); } -void DolphinDetailsView::contentsMouseMoveEvent(QMouseEvent* event) +bool DolphinDetailsView::eventFilter(QObject* watched, QEvent* event) { - if (m_rubber != 0) { - slotAutoScroll(); - return; + 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(); } - KFileDetailView::contentsMouseMoveEvent(event); - - const QPoint& pos = event->globalPos(); - const QPoint viewportPos = viewport()->mapToGlobal(QPoint(0, 0)); - Q3ListViewItem* item = itemAt(QPoint(pos.x() - viewportPos.x(), pos.y() - viewportPos.y())); - if ((item != 0) && isOnFilename(item, pos)) { - activateItem(item); - } - else { - resetActivatedItem(); - } + return QTreeView::eventFilter(watched, event); } -void DolphinDetailsView::contentsMouseReleaseEvent(QMouseEvent* event) +QModelIndex DolphinDetailsView::indexAt(const QPoint& point) const { - if (m_rubber != 0) { - drawRubber(); - delete m_rubber; - m_rubber = 0; - } - - if (m_scrollTimer != 0) { - disconnect(m_scrollTimer, SIGNAL(timeout()), - this, SLOT(slotAutoScroll())); - m_scrollTimer->stop(); - delete m_scrollTimer; - m_scrollTimer = 0; - } - - KFileDetailView::contentsMouseReleaseEvent(event); + // 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::paintEmptyArea(QPainter* painter, const QRect& rect) +void DolphinDetailsView::setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command) { - if (m_dolphinView->isActive()) { - KFileDetailView::paintEmptyArea(painter, rect); - } - else { - const QBrush brush(colorGroup().background()); - painter->fillRect(rect, brush); + // 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::drawRubber() +void DolphinDetailsView::scrollTo(const QModelIndex & index, ScrollHint hint) { - // Parts of the following code have been taken - // from the class KonqBaseListViewWidget located in - // konqueror/listview/konq_listviewwidget.h of Konqueror. - // (Copyright (C) 1998, 1999 Torben Weis - // 2001, 2002, 2004 Michael Brade ) - if (m_rubber == 0) { - return; + if (!m_ignoreScrollTo) { + QTreeView::scrollTo(index, hint); } - - QPainter p; - p.begin(viewport()); - p.setRasterOp(NotROP); - p.setPen(QPen(color0, 1)); - p.setBrush(NoBrush); - - QPoint point(m_rubber->x(), m_rubber->y()); - point = contentsToViewport(point); - style().drawPrimitive(QStyle::PE_FocusRect, &p, - QRect(point.x(), point.y(), m_rubber->width(), m_rubber->height()), - colorGroup(), QStyle::Style_Default, colorGroup().base()); - p.end(); } -void DolphinDetailsView::viewportPaintEvent(QPaintEvent* paintEvent) +void DolphinDetailsView::setSortIndicatorSection(DolphinView::Sorting sorting) { - drawRubber(); - KFileDetailView::viewportPaintEvent(paintEvent); - drawRubber(); + header()->setSortIndicator(sorting, header()->sortIndicatorOrder()); } -void DolphinDetailsView::leaveEvent(QEvent* event) +void DolphinDetailsView::setSortIndicatorOrder(Qt::SortOrder sortOrder) { - KFileDetailView::leaveEvent(event); - slotOnViewport(); + header()->setSortIndicator(header()->sortIndicatorSection(), sortOrder); } -void DolphinDetailsView::slotActivationUpdate() +void DolphinDetailsView::synchronizeSortingState(int column) { - update(); - - // TODO: there must be a simpler way to say - // "update all children" - const QObjectList* list = children(); - if (list == 0) { - return; - } + // The sorting has already been changed in QTreeView if this slot is + // invoked, but Dolphin is not informed about this. + DolphinView::Sorting sorting = DolphinSortFilterProxyModel::sortingForColumn(column); + const Qt::SortOrder sortOrder = header()->sortIndicatorOrder(); + m_controller->indicateSortingChange(sorting); + m_controller->indicateSortOrderChange(sortOrder); +} - QObjectListIterator it(*list); - QObject* object = 0; - while ((object = it.current()) != 0) { - if (object->inherits("QWidget")) { - QWidget* widget = static_cast(object); - widget->update(); - } - ++it; +void DolphinDetailsView::slotEntered(const QModelIndex& index) +{ + if (index.column() == DolphinModel::Name) { + m_controller->emitItemEntered(index); + } else { + m_controller->emitViewportEntered(); } } -void DolphinDetailsView::slotContextMenuRequested(Q3ListViewItem* item, - const QPoint& pos, - int /* col */) +void DolphinDetailsView::updateElasticBand() { - KFileItem* fileInfo = 0; - if ((item != 0) && isOnFilename(item, pos)) { - fileInfo = static_cast(item)->fileInfo(); + 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); } - m_dolphinView->openContextMenu(fileInfo, pos); - } -void DolphinDetailsView::slotUpdateDisabledItems() +QRect DolphinDetailsView::elasticBandRect() const { - updateDisabledItems(); + const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value()); + + const QPoint topLeft = m_band.origin - scrollPos; + const QPoint bottomRight = m_band.destination - scrollPos; + return QRect(topLeft, bottomRight).normalized(); } -void DolphinDetailsView::slotAutoScroll() +void DolphinDetailsView::setZoomLevel(int level) { - // Parts of the following code have been taken - // from the class KonqBaseListViewWidget located in - // konqueror/listview/konq_listviewwidget.h of Konqueror. - // (Copyright (C) 1998, 1999 Torben Weis - // 2001, 2002, 2004 Michael Brade ) - - const QPoint pos(viewport()->mapFromGlobal(QCursor::pos())); - const QPoint vc(viewportToContents(pos)); + const int size = ZoomLevelInfo::iconSizeForZoomLevel(level); + DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - if (vc == m_rubber->bottomRight()) { - return; + const bool showPreview = m_controller->dolphinView()->showPreview(); + if (showPreview) { + settings->setPreviewSize(size); + } else { + settings->setIconSize(size); } - drawRubber(); - - m_rubber->setBottomRight(vc); + updateDecorationSize(showPreview); +} - Q3ListViewItem* item = itemAt(QPoint(0,0)); - const bool block = signalsBlocked(); - blockSignals(true); +void DolphinDetailsView::slotShowPreviewChanged() +{ + const DolphinView* view = m_controller->dolphinView(); + updateDecorationSize(view->showPreview()); +} - const QRect rubber(m_rubber->normalize()); - const int bottom = contentsY() + visibleHeight() - 1; +void DolphinDetailsView::configureSettings(const QPoint& pos) +{ + KMenu popup(this); + popup.addTitle(i18nc("@title:menu", "Columns")); - // select all items which intersect with the rubber, deselect all others - bool bottomReached = false; - while ((item != 0) && !bottomReached) { - QRect rect(itemRect(item)); - rect.setWidth(filenameWidth(item)); - rect = QRect(viewportToContents(rect.topLeft()), - viewportToContents(rect.bottomRight())); - if (rect.isValid() && (rect.top() <= bottom)) { - const KFileItem* fileItem = static_cast(item)->fileInfo(); - setSelected(fileItem, rect.intersects(rubber)); - item = item->itemBelow(); - } - else { - bottomReached = true; - } + // add checkbox items for each column + QHeaderView* headerView = header(); + 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); + action->setCheckable(true); + action->setChecked(!headerView->isSectionHidden(logicalIndex)); + action->setData(i); } + popup.addSeparator(); + + QAction* activatedAction = popup.exec(header()->mapToGlobal(pos)); + if (activatedAction != 0) { + const bool show = activatedAction->isChecked(); + const int columnIndex = activatedAction->data().toInt(); - blockSignals(block); - emit selectionChanged(); - - drawRubber(); - - // scroll the viewport if the top or bottom margin is reached - const int scrollMargin = 40; - ensureVisible(vc.x(), vc.y(), scrollMargin, scrollMargin); - const bool scroll = !QRect(scrollMargin, - scrollMargin, - viewport()->width() - 2 * scrollMargin, - viewport()->height() - 2 * scrollMargin).contains(pos); - if (scroll) { - if (m_scrollTimer == 0) { - m_scrollTimer = new QTimer( this ); - connect(m_scrollTimer, SIGNAL(timeout()), - this, SLOT(slotAutoScroll())); - m_scrollTimer->start(100, false); + KFileItemDelegate::InformationList list = m_controller->dolphinView()->additionalInfo(); + const KFileItemDelegate::Information info = infoForColumn(columnIndex); + if (show) { + Q_ASSERT(!list.contains(info)); + list.append(info); + } else { + Q_ASSERT(list.contains(info)); + const int index = list.indexOf(info); + list.removeAt(index); } - } - else if (m_scrollTimer != 0) { - disconnect(m_scrollTimer, SIGNAL(timeout()), - this, SLOT(slotAutoScroll())); - m_scrollTimer->stop(); - delete m_scrollTimer; - m_scrollTimer = 0; + + m_controller->indicateAdditionalInfoChange(list); + setColumnHidden(columnIndex, !show); + resizeColumns(); } } -void DolphinDetailsView::updateColumnsWidth() +void DolphinDetailsView::updateColumnVisibility() { - const int columnCount = columns(); - int requiredWidth = 0; - for (int i = 1; i < columnCount; ++i) { - // When a directory contains no items, a minimum width for - // the column must be available, so that the header is readable. - // TODO: use header data instead of the hardcoded 64 value... - int columnWidth = 64; - QFontMetrics fontMetrics(font()); - for (Q3ListViewItem* item = firstChild(); item != 0; item = item->nextSibling()) { - const int width = item->width(fontMetrics, this, i); - if (width > columnWidth) { - columnWidth = width; - } + 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); } - columnWidth += 16; // add custom margin - setColumnWidth(i, columnWidth); - requiredWidth += columnWidth; } - // resize the first column in a way that the - // whole available width is used - int firstColumnWidth = visibleWidth() - requiredWidth; - if (firstColumnWidth < 128) { - firstColumnWidth = 128; + resizeColumns(); +} + +void DolphinDetailsView::slotHeaderSectionResized(int logicalIndex, int oldSize, int newSize) +{ + 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, another approach is used. + // Attention: Take care when changing the if-condition to verify that there is no + // regression in combination with bug 178630 (see fix in comment #8). + if ((QApplication::mouseButtons() & Qt::LeftButton) && header()->underMouse()) { + disableAutoResizing(); } - setColumnWidth(0, firstColumnWidth); } -void DolphinDetailsView::slotItemRenamed(Q3ListViewItem* item, - const QString& name, - int /* column */) +void DolphinDetailsView::slotActivationChanged(bool active) { - KFileItem* fileInfo = static_cast(item)->fileInfo(); - m_dolphinView->rename(KURL(fileInfo->url()), name); + setAlternatingRowColors(active); } -void DolphinDetailsView::slotHeaderClicked(int /* section */) +void DolphinDetailsView::disableAutoResizing() { - // The sorting has already been changed in QListView if this slot is - // invoked, but Dolphin was not informed about this (no signal is available - // which indicates a change of the sorting). This is bypassed by changing - // the sorting and sort order to a temporary other value and readjust it again. - const int column = sortColumn(); - if (column <= DateColumn) { - DolphinView::Sorting sorting = DolphinView::SortByName; - switch (column) { - case SizeColumn: sorting = DolphinView::SortBySize; break; - case DateColumn: sorting = DolphinView::SortByDate; break; - case NameColumn: - default: break; - } + m_autoResize = false; +} - const Qt::SortOrder currSortOrder = sortOrder(); +void DolphinDetailsView::requestActivation() +{ + m_controller->requestActivation(); +} - // temporary adjust the sorting and sort order to different values... - const DolphinView::Sorting tempSorting = (sorting == DolphinView::SortByName) ? - DolphinView::SortBySize : - DolphinView::SortByName; - m_dolphinView->setSorting(tempSorting); - const Qt::SortOrder tempSortOrder = (currSortOrder == Qt::Ascending) ? - Qt::Descending : Qt::Ascending; - m_dolphinView->setSortOrder(tempSortOrder); +void DolphinDetailsView::slotGlobalSettingsChanged(int category) +{ + Q_UNUSED(category); - // ... so that setting them again results in storing the new setting. - m_dolphinView->setSorting(sorting); - m_dolphinView->setSortOrder(currSortOrder); + const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + Q_ASSERT(settings != 0); + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); + } + //Disconnect then reconnect, since the settings have been changed, the connection requirements may have also. + disconnect(this, SIGNAL(clicked(QModelIndex)), m_controller, SLOT(triggerItem(QModelIndex))); + disconnect(this, SIGNAL(doubleClicked(QModelIndex)), m_controller, SLOT(triggerItem(QModelIndex))); + if (KGlobalSettings::singleClick()) { + connect(this, SIGNAL(clicked(QModelIndex)), m_controller, SLOT(triggerItem(QModelIndex))); + } else { + connect(this, SIGNAL(doubleClicked(QModelIndex)), m_controller, SLOT(triggerItem(QModelIndex))); } } -DolphinDetailsView::DolphinListViewItem::DolphinListViewItem(Q3ListView* parent, - KFileItem* fileItem) : - KFileListViewItem(parent, fileItem) +void DolphinDetailsView::updateElasticBandSelection() { - const int iconSize = DolphinSettings::instance().detailsModeSettings()->iconSize(); - KFileItem* info = fileInfo(); - setPixmap(DolphinDetailsView::NameColumn, info->pixmap(iconSize)); + if (!m_band.show) { + return; + } - // The base class KFileListViewItem represents the column 'Size' only as byte values. - // Adjust those values in a way that a mapping to GBytes, MBytes, KBytes and Bytes - // is done. As the file size for directories is useless (only the size of the directory i-node - // is given), it is removed completely. - if (fileItem->isDir()) { - setText(SizeColumn, " - "); + // 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 { - QString sizeText(KIO::convertSize(fileItem->size())); - sizeText.append(" "); - setText(SizeColumn, sizeText); + // 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; } - // Dolphin allows to remove specific columns, but the base class KFileListViewItem - // is not aware about this (or at least the class KFileDetailView does not react on - // QListView::remove()). Therefore the columns are rearranged here. - const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); - assert(settings != 0); + // 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; + } - int column_idx = DateColumn; // the columns for 'name' and 'size' cannot get removed - for (int i = DolphinDetailsView::DateColumn; i <= DolphinDetailsView::GroupColumn; ++i) { - if (column_idx < i) { - setText(column_idx, text(i)); + // 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::setFoldersExpandable(bool expandable) +{ + if (!expandable) { + // collapse all expanded folders, as QTreeView::setItemsExpandable(false) + // does not do this task + const int rowCount = model()->rowCount(); + for (int row = 0; row < rowCount; ++row) { + setExpanded(model()->index(row, 0), false); } + } + DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + settings->setExpandableFolders(expandable); + setRootIsDecorated(expandable); + setItemsExpandable(expandable); +} - bool inc = false; - switch (i) { - case DateColumn: inc = settings->showDate(); break; - case PermissionsColumn: inc = settings->showPermissions(); break; - case OwnerColumn: inc = settings->showOwner(); break; - case GroupColumn: inc = settings->showGroup(); break; - default: break; - } +void DolphinDetailsView::updateDecorationSize(bool showPreview) +{ + DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + const int iconSize = showPreview ? settings->previewSize() : settings->iconSize(); + setIconSize(QSize(iconSize, iconSize)); + m_decorationSize = QSize(iconSize, iconSize); - if (inc) { - ++column_idx; - } + if (m_selectionManager != 0) { + m_selectionManager->reset(); } + + doItemsLayout(); } -DolphinDetailsView::DolphinListViewItem::~DolphinListViewItem() +KFileItemDelegate::Information DolphinDetailsView::infoForColumn(int columnIndex) const { + 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::DolphinListViewItem::paintCell(QPainter* painter, - const QColorGroup& colorGroup, - int column, - int cellWidth, - int alignment) +void DolphinDetailsView::resizeColumns() { - const Q3ListView* view = listView(); - const bool isActive = view->parent() == Dolphin::mainWin().activeView(); - if (isSelected()) { - // Per default the selection is drawn above the whole width of the item. As a consistent - // behavior with the icon view is wanted, only the the column containing the file name - // should be shown as selected. - QColorGroup defaultColorGroup(colorGroup); - const QColor highlightColor(isActive ? backgroundColor(column) : view->colorGroup().background()); - defaultColorGroup.setColor(QColorGroup::Highlight , highlightColor); - defaultColorGroup.setColor(QColorGroup::HighlightedText, colorGroup.color(QColorGroup::Text)); - KFileListViewItem::paintCell(painter, defaultColorGroup, column, cellWidth, alignment); + // 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). - if (column == 0) { - // draw the selection only on the first column - Q3ListView* parent = listView(); - const int itemWidth = width(parent->fontMetrics(), parent, 0); - if (isActive) { - KFileListViewItem::paintCell(painter, colorGroup, column, itemWidth, alignment); - } - else { - Q3ListViewItem::paintCell(painter, colorGroup, column, itemWidth, alignment); - } + 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]); } } - else { - if (isActive) { - KFileListViewItem::paintCell(painter, colorGroup, column, cellWidth, alignment); - } - else { - Q3ListViewItem::paintCell(painter, colorGroup, column, cellWidth, alignment); + + // resize the name column in a way that the whole available width is used + columnWidth[KDirModel::Name] = viewport()->width() - requiredWidth; + + const int minNameWidth = 300; + if (columnWidth[KDirModel::Name] < minNameWidth) { + columnWidth[KDirModel::Name] = minNameWidth; + + // It might be possible that the name column width can be + // decreased without clipping any text. For performance + // reasons the exact necessary width for full visible names is + // only checked for up to 200 items: + const int rowCount = model()->rowCount(); + if (rowCount > 0 && rowCount < 200) { + const int nameWidth = sizeHintForColumn(DolphinModel::Name); + if (nameWidth + requiredWidth <= viewport()->width()) { + columnWidth[KDirModel::Name] = viewport()->width() - requiredWidth; + } else if (nameWidth < minNameWidth) { + columnWidth[KDirModel::Name] = nameWidth; + } } } - if (column < listView()->columns() - 1) { - // draw a separator between columns - painter->setPen(KGlobalSettings::buttonBackground()); - painter->drawLine(cellWidth - 1, 0, cellWidth - 1, height() - 1); - } + headerView->resizeSection(KDirModel::Name, columnWidth[KDirModel::Name]); } -void DolphinDetailsView::DolphinListViewItem::paintFocus(QPainter* painter, - const QColorGroup& colorGroup, - const QRect& rect) +QRect DolphinDetailsView::nameColumnRect(const QModelIndex& index) const { - // draw the focus consistently with the selection (see implementation notes - // in DolphinListViewItem::paintCell) - Q3ListView* parent = listView(); - int visibleWidth = width(parent->fontMetrics(), parent, 0); - const int colWidth = parent->columnWidth(0); - if (visibleWidth > colWidth) { - visibleWidth = colWidth; + 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); } - QRect focusRect(rect); - focusRect.setWidth(visibleWidth); - - KFileListViewItem::paintFocus(painter, colorGroup, focusRect); + return rect; } -int DolphinDetailsView::filenameWidth(const Q3ListViewItem* item) const +DolphinDetailsView::ElasticBand::ElasticBand() : + show(false), + origin(), + destination(), + lastSelectionOrigin(), + lastSelectionDestination(), + ignoreOldInfo(true), + outsideNearestLeftEdge(0), + outsideNearestRightEdge(0), + insideNearestLeftEdge(0), + insideNearestRightEdge(0) { - assert(item != 0); - - int visibleWidth = item->width(fontMetrics(), this, 0); - const int colWidth = columnWidth(0); - if (visibleWidth > colWidth) { - visibleWidth = colWidth; - } - - return visibleWidth; } + #include "dolphindetailsview.moc"