X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/e8bc9f1072bfc43d7605315c8df69f37bfc71cc3..d1099ee5bf4ed626a9ae9e5d30ec5ff3c468fa01:/src/dolphiniconsview.cpp diff --git a/src/dolphiniconsview.cpp b/src/dolphiniconsview.cpp index ed2593c97..a8188d971 100644 --- a/src/dolphiniconsview.cpp +++ b/src/dolphiniconsview.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2006 by Peter Penz (peter.penz@gmx.at) * + * Copyright (C) 2006-2009 by Peter Penz * * * * 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 * @@ -21,89 +21,107 @@ #include "dolphincategorydrawer.h" #include "dolphincontroller.h" -#include "dolphinsettings.h" +#include "settings/dolphinsettings.h" +#include "dolphinsortfilterproxymodel.h" #include "dolphin_iconsmodesettings.h" +#include "dolphin_generalsettings.h" +#include "draganddrophelper.h" +#include "selectionmanager.h" +#include "viewextensionsfactory.h" +#include "zoomlevelinfo.h" #include #include -#include +#include #include #include -#include -#include +#include -DolphinIconsView::DolphinIconsView(QWidget* parent, DolphinController* controller) : +DolphinIconsView::DolphinIconsView(QWidget* parent, + DolphinController* controller, + DolphinSortFilterProxyModel* proxyModel) : KCategorizedView(parent), m_controller(controller), m_categoryDrawer(0), + m_extensionsFactory(0), + m_font(), + m_decorationSize(), + m_decorationPosition(QStyleOptionViewItem::Top), + m_displayAlignment(Qt::AlignHCenter), m_itemSize(), - m_dragging(false), m_dropRect() { Q_ASSERT(controller != 0); + setModel(proxyModel); + setLayoutDirection(Qt::LeftToRight); setViewMode(QListView::IconMode); setResizeMode(QListView::Adjust); - setSpacing(KDialog::spacingHint()); - setMovement(QListView::Snap); + setMovement(QListView::Static); + setDragEnabled(true); + setEditTriggers(QAbstractItemView::NoEditTriggers); + viewport()->setAcceptDrops(true); + setMouseTracking(true); - viewport()->setAttribute(Qt::WA_Hover); - // 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(triggerItem(const QModelIndex&))); + controller, SLOT(triggerItem(const QModelIndex&))); } else { connect(this, SIGNAL(doubleClicked(const QModelIndex&)), - this, SLOT(triggerItem(const QModelIndex&))); + controller, SLOT(triggerItem(const QModelIndex&))); } + + connect(this, SIGNAL(entered(const QModelIndex&)), + controller, SLOT(emitItemEntered(const QModelIndex&))); connect(this, SIGNAL(viewportEntered()), controller, SLOT(emitViewportEntered())); - connect(controller, SIGNAL(zoomIn()), - this, SLOT(zoomIn())); - connect(controller, SIGNAL(zoomOut()), - this, SLOT(zoomOut())); + connect(controller, SIGNAL(zoomLevelChanged(int)), + this, SLOT(setZoomLevel(int))); const DolphinView* view = controller->dolphinView(); connect(view, SIGNAL(showPreviewChanged()), this, SLOT(slotShowPreviewChanged())); - connect(view, SIGNAL(additionalInfoChanged(const KFileItemDelegate::InformationList&)), - this, SLOT(slotAdditionalInfoChanged(const KFileItemDelegate::InformationList&))); - - connect(this, SIGNAL(entered(const QModelIndex&)), - this, SLOT(slotEntered(const QModelIndex&))); + connect(view, SIGNAL(additionalInfoChanged()), + this, SLOT(slotAdditionalInfoChanged())); // apply the icons mode settings to the widget const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); Q_ASSERT(settings != 0); - m_viewOptions = KCategorizedView::viewOptions(); - m_viewOptions.showDecorationSelected = true; - - QFont font(settings->fontFamily(), settings->fontSize()); - font.setItalic(settings->italicFont()); - font.setBold(settings->boldFont()); - m_viewOptions.font = font; + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); + } else { + m_font = QFont(settings->fontFamily(), + settings->fontSize(), + settings->fontWeight(), + settings->italicFont()); + } setWordWrap(settings->numberOfTextlines() > 1); - updateGridSize(view->showPreview(), 0); if (settings->arrangement() == QListView::TopToBottom) { setFlow(QListView::LeftToRight); - m_viewOptions.decorationPosition = QStyleOptionViewItem::Top; + m_decorationPosition = QStyleOptionViewItem::Top; + m_displayAlignment = Qt::AlignHCenter; } else { setFlow(QListView::TopToBottom); - m_viewOptions.decorationPosition = QStyleOptionViewItem::Left; - m_viewOptions.displayAlignment = Qt::AlignLeft | Qt::AlignVCenter; + m_decorationPosition = QStyleOptionViewItem::Left; + m_displayAlignment = Qt::AlignLeft | Qt::AlignVCenter; } m_categoryDrawer = new DolphinCategoryDrawer(); setCategoryDrawer(m_categoryDrawer); setFocus(); + + connect(KGlobalSettings::self(), SIGNAL(settingsChanged(int)), + this, SLOT(slotGlobalSettingsChanged(int))); + + updateGridSize(view->showPreview(), 0); + m_extensionsFactory = new ViewExtensionsFactory(this, controller); } DolphinIconsView::~DolphinIconsView() @@ -112,52 +130,28 @@ DolphinIconsView::~DolphinIconsView() m_categoryDrawer = 0; } -QRect DolphinIconsView::visualRect(const QModelIndex& index) const +void DolphinIconsView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight) { - const bool leftToRightFlow = (flow() == QListView::LeftToRight); - - QRect itemRect = KCategorizedView::visualRect(index); - const int maxWidth = m_itemSize.width(); - const int maxHeight = m_itemSize.height(); - - if (itemRect.width() > maxWidth) { - // assure that the maximum item width is not exceeded - if (leftToRightFlow) { - const int left = itemRect.left() + (itemRect.width() - maxWidth) / 2; - itemRect.setLeft(left); - } - itemRect.setWidth(maxWidth); - } - - if (itemRect.height() > maxHeight) { - // assure that the maximum item height is not exceeded - if (!leftToRightFlow) { - const int top = itemRect.top() + (itemRect.height() - maxHeight) / 2; - itemRect.setTop(top); - } - itemRect.setHeight(maxHeight); - } + KCategorizedView::dataChanged(topLeft, bottomRight); KCategorizedSortFilterProxyModel* proxyModel = dynamic_cast(model()); - if (leftToRightFlow && !proxyModel->isCategorizedModel()) { - // TODO: This workaround bypasses a layout issue in QListView::visualRect(), where - // the horizontal position of items might get calculated in a wrong manner when the item - // name is too long. I'll try create a patch for Qt but as Dolphin must also work with - // Qt 4.3.0 this workaround must get applied at least for KDE 4.0. - const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); - const int margin = settings->gridSpacing() / 2; - const int gridWidth = gridSize().width(); - int left = itemRect.left(); - left = ((left - margin + 1) / gridWidth) * gridWidth + margin; - itemRect.moveLeft(left); + if (!proxyModel->isCategorizedModel()) { + // bypass a QListView issue that items are not layout correctly if the decoration size of + // an index changes + scheduleDelayedItemsLayout(); } - - return itemRect; } QStyleOptionViewItem DolphinIconsView::viewOptions() const { - return m_viewOptions; + QStyleOptionViewItem viewOptions = KCategorizedView::viewOptions(); + viewOptions.font = m_font; + viewOptions.fontMetrics = QFontMetrics(m_font); + viewOptions.decorationPosition = m_decorationPosition; + viewOptions.decorationSize = m_decorationSize; + viewOptions.displayAlignment = m_displayAlignment; + viewOptions.showDecorationSelected = true; + return viewOptions; } void DolphinIconsView::contextMenuEvent(QContextMenuEvent* event) @@ -169,7 +163,20 @@ void DolphinIconsView::contextMenuEvent(QContextMenuEvent* event) void DolphinIconsView::mousePressEvent(QMouseEvent* event) { m_controller->requestActivation(); - if (!indexAt(event->pos()).isValid()) { + const QModelIndex index = indexAt(event->pos()); + if (index.isValid() && (event->button() == Qt::LeftButton)) { + // TODO: It should not be necessary to manually set the dragging state, but I could + // not reproduce this issue with a Qt-only example yet to find the root cause. + // Issue description: start Dolphin, split the view and drag an item from the + // inactive view to the active view by a very fast mouse movement. Result: + // the item gets selected instead of being dragged... + setState(QAbstractItemView::DraggingState); + } + + if (!index.isValid()) { + if (QApplication::mouseButtons() & Qt::MidButton) { + m_controller->replaceUrlByClipboard(); + } const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers(); if (!(modifier & Qt::ShiftModifier) && !(modifier & Qt::ControlModifier)) { clearSelection(); @@ -179,20 +186,21 @@ void DolphinIconsView::mousePressEvent(QMouseEvent* event) KCategorizedView::mousePressEvent(event); } +void DolphinIconsView::startDrag(Qt::DropActions supportedActions) +{ + DragAndDropHelper::instance().startDrag(this, supportedActions, m_controller); +} + void DolphinIconsView::dragEnterEvent(QDragEnterEvent* event) { - if (event->mimeData()->hasUrls()) { + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { event->acceptProposedAction(); } - m_dragging = true; } void DolphinIconsView::dragLeaveEvent(QDragLeaveEvent* event) { KCategorizedView::dragLeaveEvent(event); - - // TODO: remove this code when the issue #160611 is solved in Qt 4.4 - m_dragging = false; setDirtyRegion(m_dropRect); } @@ -203,185 +211,222 @@ void DolphinIconsView::dragMoveEvent(QDragMoveEvent* event) // TODO: remove this code when the issue #160611 is solved in Qt 4.4 const QModelIndex index = indexAt(event->pos()); setDirtyRegion(m_dropRect); - if (itemForIndex(index).isDir()) { - m_dropRect = visualRect(index); - } else { - m_dropRect.setSize(QSize()); // set as invalid + + m_dropRect.setSize(QSize()); // set as invalid + if (index.isValid()) { + const KFileItem item = m_controller->itemForIndex(index); + if (!item.isNull() && item.isDir()) { + m_dropRect = visualRect(index); + } else { + m_dropRect.setSize(QSize()); // set as invalid + } + } + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { + // accept url drops, independently from the destination item + event->acceptProposedAction(); } + setDirtyRegion(m_dropRect); } void DolphinIconsView::dropEvent(QDropEvent* event) { - if (!selectionModel()->isSelected(indexAt(event->pos()))) { - const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData()); - if (!urls.isEmpty()) { - const QModelIndex index = indexAt(event->pos()); - const KFileItem item = itemForIndex(index); - m_controller->indicateDroppedUrls(urls, - m_controller->url(), - item); - event->acceptProposedAction(); - } - } - - KCategorizedView::dropEvent(event); - m_dragging = false; + const QModelIndex index = indexAt(event->pos()); + const KFileItem item = m_controller->itemForIndex(index); + m_controller->indicateDroppedUrls(item, m_controller->url(), event); + // don't call KCategorizedView::dropEvent(event), as it moves + // the items which is not wanted } -void DolphinIconsView::paintEvent(QPaintEvent* event) +QModelIndex DolphinIconsView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers) { - KCategorizedView::paintEvent(event); + const QModelIndex oldCurrent = currentIndex(); - // 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); + QModelIndex newCurrent = KCategorizedView::moveCursor(cursorAction, modifiers); + if (newCurrent != oldCurrent) { + return newCurrent; } + + // The cursor has not been moved by the base implementation. Provide a + // wrap behavior, so that the cursor will go to the next item when reaching + // the border. + const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); + if (settings->arrangement() == QListView::LeftToRight) { + switch (cursorAction) { + case MoveUp: + if (newCurrent.row() == 0) { + return newCurrent; + } + newCurrent = KCategorizedView::moveCursor(MoveLeft, modifiers); + selectionModel()->setCurrentIndex(newCurrent, QItemSelectionModel::NoUpdate); + newCurrent = KCategorizedView::moveCursor(MovePageDown, modifiers); + break; + + case MoveDown: + if (newCurrent.row() == (model()->rowCount() - 1)) { + return newCurrent; + } + newCurrent = KCategorizedView::moveCursor(MovePageUp, modifiers); + selectionModel()->setCurrentIndex(newCurrent, QItemSelectionModel::NoUpdate); + newCurrent = KCategorizedView::moveCursor(MoveRight, modifiers); + break; + + default: + break; + } + } else { + QModelIndex current = oldCurrent; + switch (cursorAction) { + case MoveLeft: + if (newCurrent.row() == 0) { + return newCurrent; + } + newCurrent = KCategorizedView::moveCursor(MoveUp, modifiers); + do { + selectionModel()->setCurrentIndex(newCurrent, QItemSelectionModel::NoUpdate); + current = newCurrent; + newCurrent = KCategorizedView::moveCursor(MoveRight, modifiers); + } while (newCurrent != current); + break; + + case MoveRight: + if (newCurrent.row() == (model()->rowCount() - 1)) { + return newCurrent; + } + do { + selectionModel()->setCurrentIndex(newCurrent, QItemSelectionModel::NoUpdate); + current = newCurrent; + newCurrent = KCategorizedView::moveCursor(MoveLeft, modifiers); + } while (newCurrent != current); + newCurrent = KCategorizedView::moveCursor(MoveDown, modifiers); + break; + + default: + break; + } + } + + // Revert all changes of the current item to make sure that item selection works correctly + selectionModel()->setCurrentIndex(oldCurrent, QItemSelectionModel::NoUpdate); + return newCurrent; } void DolphinIconsView::keyPressEvent(QKeyEvent* event) { KCategorizedView::keyPressEvent(event); + m_controller->handleKeyPressEvent(event); +} - const QItemSelectionModel* selModel = selectionModel(); - const QModelIndex currentIndex = selModel->currentIndex(); - const bool trigger = currentIndex.isValid() - && (event->key() == Qt::Key_Return) - && (selModel->selectedIndexes().count() <= 1); - if (trigger) { - triggerItem(currentIndex); +void DolphinIconsView::wheelEvent(QWheelEvent* event) +{ + horizontalScrollBar()->setSingleStep(m_itemSize.width() / 5); + verticalScrollBar()->setSingleStep(m_itemSize.height() / 5); + + KCategorizedView::wheelEvent(event); + // if the icons are aligned left to right, the vertical wheel event should + // be applied to the horizontal scrollbar + const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); + const bool scrollHorizontal = (event->orientation() == Qt::Vertical) && + (settings->arrangement() == QListView::LeftToRight); + if (scrollHorizontal) { + QWheelEvent horizEvent(event->pos(), + event->delta(), + event->buttons(), + event->modifiers(), + Qt::Horizontal); + QApplication::sendEvent(horizontalScrollBar(), &horizEvent); } } -void DolphinIconsView::triggerItem(const QModelIndex& index) +void DolphinIconsView::showEvent(QShowEvent* event) { - m_controller->triggerItem(itemForIndex(index)); + KFileItemDelegate* delegate = dynamic_cast(itemDelegate()); + delegate->setMaximumSize(m_itemSize); + + KCategorizedView::showEvent(event); } -void DolphinIconsView::slotEntered(const QModelIndex& index) +void DolphinIconsView::leaveEvent(QEvent* event) { - m_controller->emitItemEntered(itemForIndex(index)); + KCategorizedView::leaveEvent(event); + // 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(); } -void DolphinIconsView::slotShowPreviewChanged() +void DolphinIconsView::currentChanged(const QModelIndex& current, const QModelIndex& previous) { - const DolphinView* view = m_controller->dolphinView(); - const int infoCount = view->additionalInfo().count(); - updateGridSize(view->showPreview(), infoCount); + KCategorizedView::currentChanged(current, previous); + m_extensionsFactory->handleCurrentIndexChange(current, previous); } -void DolphinIconsView::slotAdditionalInfoChanged(const KFileItemDelegate::InformationList& info) +void DolphinIconsView::resizeEvent(QResizeEvent* event) { - const bool showPreview = m_controller->dolphinView()->showPreview(); - updateGridSize(showPreview, info.count()); + KCategorizedView::resizeEvent(event); + const DolphinView* view = m_controller->dolphinView(); + updateGridSize(view->showPreview(), view->additionalInfo().count()); } -void DolphinIconsView::zoomIn() +void DolphinIconsView::slotShowPreviewChanged() { - if (isZoomInPossible()) { - IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); - - const int oldIconSize = settings->iconSize(); - int newIconSize = oldIconSize; - - const bool showPreview = m_controller->dolphinView()->showPreview(); - if (showPreview) { - const int previewSize = increasedIconSize(settings->previewSize()); - settings->setPreviewSize(previewSize); - } else { - newIconSize = increasedIconSize(oldIconSize); - settings->setIconSize(newIconSize); - if (settings->previewSize() < newIconSize) { - // assure that the preview size is always >= the icon size - settings->setPreviewSize(newIconSize); - } - } - - // increase also the grid size - const int diff = newIconSize - oldIconSize; - settings->setItemWidth(settings->itemWidth() + diff); - settings->setItemHeight(settings->itemHeight() + diff); - - const int infoCount = m_controller->dolphinView()->additionalInfo().count(); - updateGridSize(showPreview, infoCount); - } + const DolphinView* view = m_controller->dolphinView(); + updateGridSize(view->showPreview(), additionalInfoCount()); } -void DolphinIconsView::zoomOut() +void DolphinIconsView::slotAdditionalInfoChanged() { - if (isZoomOutPossible()) { - IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); - - const int oldIconSize = settings->iconSize(); - int newIconSize = oldIconSize; - - const bool showPreview = m_controller->dolphinView()->showPreview(); - if (showPreview) { - const int previewSize = decreasedIconSize(settings->previewSize()); - settings->setPreviewSize(previewSize); - if (settings->iconSize() > previewSize) { - // assure that the icon size is always <= the preview size - newIconSize = previewSize; - settings->setIconSize(newIconSize); - } - } else { - newIconSize = decreasedIconSize(settings->iconSize()); - settings->setIconSize(newIconSize); - } - - // decrease also the grid size - const int diff = oldIconSize - newIconSize; - settings->setItemWidth(settings->itemWidth() - diff); - settings->setItemHeight(settings->itemHeight() - diff); - - const int infoCount = m_controller->dolphinView()->additionalInfo().count(); - updateGridSize(showPreview, infoCount); - } + const DolphinView* view = m_controller->dolphinView(); + const bool showPreview = view->showPreview(); + updateGridSize(showPreview, view->additionalInfo().count()); } -bool DolphinIconsView::isZoomInPossible() const +void DolphinIconsView::setZoomLevel(int level) { IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); + + const int oldIconSize = settings->iconSize(); + int newIconSize = oldIconSize; + const bool showPreview = m_controller->dolphinView()->showPreview(); - const int size = showPreview ? settings->previewSize() : settings->iconSize(); - return size < KIconLoader::SizeEnormous; + if (showPreview) { + const int previewSize = ZoomLevelInfo::iconSizeForZoomLevel(level); + settings->setPreviewSize(previewSize); + } else { + newIconSize = ZoomLevelInfo::iconSizeForZoomLevel(level); + settings->setIconSize(newIconSize); + } + + // increase also the grid size + const int diff = newIconSize - oldIconSize; + settings->setItemWidth(settings->itemWidth() + diff); + settings->setItemHeight(settings->itemHeight() + diff); + + updateGridSize(showPreview, additionalInfoCount()); } -bool DolphinIconsView::isZoomOutPossible() const +void DolphinIconsView::requestActivation() { - IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); - const bool showPreview = m_controller->dolphinView()->showPreview(); - const int size = showPreview ? settings->previewSize() : settings->iconSize(); - return size > KIconLoader::SizeSmall; + m_controller->requestActivation(); } -int DolphinIconsView::increasedIconSize(int size) const +void DolphinIconsView::slotGlobalSettingsChanged(int category) { - int incSize = 0; - switch (size) { - case KIconLoader::SizeSmall: incSize = KIconLoader::SizeSmallMedium; break; - case KIconLoader::SizeSmallMedium: incSize = KIconLoader::SizeMedium; break; - case KIconLoader::SizeMedium: incSize = KIconLoader::SizeLarge; break; - case KIconLoader::SizeLarge: incSize = KIconLoader::SizeHuge; break; - case KIconLoader::SizeHuge: incSize = KIconLoader::SizeEnormous; break; - default: Q_ASSERT(false); break; + Q_UNUSED(category); + + const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); + Q_ASSERT(settings != 0); + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); } - return incSize; -} -int DolphinIconsView::decreasedIconSize(int size) const -{ - int decSize = 0; - switch (size) { - case KIconLoader::SizeSmallMedium: decSize = KIconLoader::SizeSmall; break; - case KIconLoader::SizeMedium: decSize = KIconLoader::SizeSmallMedium; break; - case KIconLoader::SizeLarge: decSize = KIconLoader::SizeMedium; break; - case KIconLoader::SizeHuge: decSize = KIconLoader::SizeLarge; break; - case KIconLoader::SizeEnormous: decSize = KIconLoader::SizeHuge; break; - default: Q_ASSERT(false); break; + 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))); } - return decSize; } void DolphinIconsView::updateGridSize(bool showPreview, int additionalInfoCount) @@ -396,7 +441,6 @@ void DolphinIconsView::updateGridSize(bool showPreview, int additionalInfoCount) if (showPreview) { const int previewSize = settings->previewSize(); const int diff = previewSize - size; - Q_ASSERT(diff >= 0); itemWidth += diff; itemHeight += diff; @@ -404,33 +448,60 @@ void DolphinIconsView::updateGridSize(bool showPreview, int additionalInfoCount) } Q_ASSERT(additionalInfoCount >= 0); - itemHeight += additionalInfoCount * m_viewOptions.font.pointSize() * 2; - + itemHeight += additionalInfoCount * m_font.pointSize() * 2; + + // Optimize the item size of the grid in a way to prevent large gaps on the + // right border (= row arrangement) or the bottom border (= column arrangement). + // There is no public API in QListView to find out the used width of the viewport + // for the layout. The following calculation of 'contentWidth'/'contentHeight' + // is based on QListViewPrivate::prepareItemsLayout() (Copyright (C) 2009 Nokia Corporation). + int frameAroundContents = 0; + if (style()->styleHint(QStyle::SH_ScrollView_FrameOnlyAroundContents)) { + frameAroundContents = style()->pixelMetric(QStyle::PM_DefaultFrameWidth) * 2; + } + const int spacing = settings->gridSpacing(); if (settings->arrangement() == QListView::TopToBottom) { + const int contentWidth = viewport()->width() - 1 + - frameAroundContents + - style()->pixelMetric(QStyle::PM_ScrollBarExtent, 0, horizontalScrollBar()); + const int gridWidth = itemWidth + spacing * 2; + const int horizItemCount = contentWidth / gridWidth; + if (horizItemCount > 0) { + itemWidth += (contentWidth - horizItemCount * gridWidth) / horizItemCount; + } + // The decoration width indirectly defines the maximum // width for the text wrapping. To use the maximum item width // for text wrapping, it is used as decoration width. - m_viewOptions.decorationSize = QSize(itemWidth, size); + m_decorationSize = QSize(itemWidth, size); + setIconSize(QSize(itemWidth, size)); } else { - m_viewOptions.decorationSize = QSize(size, size); - } + const int contentHeight = viewport()->height() - 1 + - frameAroundContents + - style()->pixelMetric(QStyle::PM_ScrollBarExtent, 0, verticalScrollBar()); + const int gridHeight = itemHeight + spacing; + const int vertItemCount = contentHeight / gridHeight; + if (vertItemCount > 0) { + itemHeight += (contentHeight - vertItemCount * gridHeight) / vertItemCount; + } - const int spacing = settings->gridSpacing(); - setGridSize(QSize(itemWidth + spacing, itemHeight + spacing)); + m_decorationSize = QSize(size, size); + setIconSize(QSize(size, size)); + } m_itemSize = QSize(itemWidth, itemHeight); + setGridSizeOwn(QSize(itemWidth + spacing * 2, itemHeight + spacing)); - m_controller->setZoomInPossible(isZoomInPossible()); - m_controller->setZoomOutPossible(isZoomOutPossible()); + KFileItemDelegate* delegate = dynamic_cast(itemDelegate()); + if (delegate != 0) { + delegate->setMaximumSize(m_itemSize); + } } -KFileItem DolphinIconsView::itemForIndex(const QModelIndex& index) const +int DolphinIconsView::additionalInfoCount() const { - QAbstractProxyModel* proxyModel = static_cast(model()); - KDirModel* dirModel = static_cast(proxyModel->sourceModel()); - const QModelIndex dirIndex = proxyModel->mapToSource(index); - return dirModel->itemForIndex(dirIndex); + const DolphinView* view = m_controller->dolphinView(); + return view->additionalInfo().count(); } - #include "dolphiniconsview.moc"