X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/be9746e87bb6a42e641dbf36c528a60fb564420a..629ec98952bcf38bc99f2b11bc37bdc2ec7aabcc:/src/dolphiniconsview.cpp diff --git a/src/dolphiniconsview.cpp b/src/dolphiniconsview.cpp index d21ffba32..3cb9b929d 100644 --- a/src/dolphiniconsview.cpp +++ b/src/dolphiniconsview.cpp @@ -19,102 +19,195 @@ #include "dolphiniconsview.h" +#include "dolphincategorydrawer.h" #include "dolphincontroller.h" #include "dolphinsettings.h" -#include "dolphinitemcategorizer.h" - #include "dolphin_iconsmodesettings.h" +#include "dolphin_generalsettings.h" +#include "draganddrophelper.h" +#include "selectionmanager.h" + +#include +#include +#include +#include #include #include -#include -#include +#include DolphinIconsView::DolphinIconsView(QWidget* parent, DolphinController* controller) : - KListView(parent), + KCategorizedView(parent), + m_enableScrollTo(false), m_controller(controller), - m_dragging(false) + m_selectionManager(0), + m_categoryDrawer(0), + m_font(), + m_decorationSize(), + m_decorationPosition(QStyleOptionViewItem::Top), + m_displayAlignment(Qt::AlignHCenter), + m_itemSize(), + m_dropRect() { Q_ASSERT(controller != 0); setViewMode(QListView::IconMode); setResizeMode(QListView::Adjust); + setSpacing(KDialog::spacingHint()); + 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(). if (KGlobalSettings::singleClick()) { connect(this, SIGNAL(clicked(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())); + } } else { connect(this, SIGNAL(doubleClicked(const QModelIndex&)), controller, SLOT(triggerItem(const QModelIndex&))); } - connect(this, SIGNAL(activated(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(showPreviewChanged(bool)), - this, SLOT(slotShowPreviewChanged(bool))); - connect(controller, SIGNAL(showAdditionalInfoChanged(bool)), - this, SLOT(slotShowAdditionalInfoChanged(bool))); connect(controller, SIGNAL(zoomIn()), this, SLOT(zoomIn())); connect(controller, SIGNAL(zoomOut()), this, SLOT(zoomOut())); + const DolphinView* view = controller->dolphinView(); + connect(view, SIGNAL(showPreviewChanged()), + this, SLOT(slotShowPreviewChanged())); + 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 = KListView::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(controller->showPreview(), controller->showAdditionalInfo()); + 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(kdisplayFontChanged()), + this, SLOT(updateFont())); } DolphinIconsView::~DolphinIconsView() { + delete m_categoryDrawer; + m_categoryDrawer = 0; +} + +void DolphinIconsView::scrollTo(const QModelIndex& index, ScrollHint hint) +{ + // Enable the QListView implementation of scrollTo() only if it has been + // triggered by a key press. Otherwise QAbstractItemView wants to scroll to the current + // index each time the layout has been changed. This becomes an issue when + // previews are loaded and the scrollbar is used: the scrollbar will always + // be reset to 0 on each new preview. + if (m_enableScrollTo || (state() != QAbstractItemView::NoState)) { + KCategorizedView::scrollTo(index, hint); + m_enableScrollTo = false; + } +} + +void DolphinIconsView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight) +{ + KCategorizedView::dataChanged(topLeft, bottomRight); + + KCategorizedSortFilterProxyModel* proxyModel = dynamic_cast(model()); + if ((flow() == QListView::LeftToRight) && !proxyModel->isCategorizedModel()) { + // bypass a QListView issue that items are not layout correctly if the decoration size of + // an index changes + scheduleDelayedItemsLayout(); + } } QStyleOptionViewItem DolphinIconsView::viewOptions() const { - return m_viewOptions; + QStyleOptionViewItem viewOptions = KCategorizedView::viewOptions(); + viewOptions.font = m_font; + viewOptions.decorationPosition = m_decorationPosition; + viewOptions.decorationSize = m_decorationSize; + viewOptions.displayAlignment = m_displayAlignment; + viewOptions.showDecorationSelected = true; + return viewOptions; } void DolphinIconsView::contextMenuEvent(QContextMenuEvent* event) { - KListView::contextMenuEvent(event); + KCategorizedView::contextMenuEvent(event); m_controller->triggerContextMenuRequest(event->pos()); } void DolphinIconsView::mousePressEvent(QMouseEvent* event) { - m_controller->triggerActivation(); - if (!indexAt(event->pos()).isValid()) { + m_controller->requestActivation(); + 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(); } } - KListView::mousePressEvent(event); + KCategorizedView::mousePressEvent(event); +} + +void DolphinIconsView::startDrag(Qt::DropActions supportedActions) +{ + // TODO: invoking KCategorizedView::startDrag() should not be necessary, we'll + // fix this in KDE 4.1 + KCategorizedView::startDrag(supportedActions); + DragAndDropHelper::startDrag(this, supportedActions); } void DolphinIconsView::dragEnterEvent(QDragEnterEvent* event) @@ -122,67 +215,118 @@ void DolphinIconsView::dragEnterEvent(QDragEnterEvent* event) if (event->mimeData()->hasUrls()) { event->acceptProposedAction(); } - m_dragging = true; } void DolphinIconsView::dragLeaveEvent(QDragLeaveEvent* event) { - KListView::dragLeaveEvent(event); - - // TODO: remove this code when the issue #160611 is solved in Qt 4.4 - m_dragging = false; + KCategorizedView::dragLeaveEvent(event); setDirtyRegion(m_dropRect); } void DolphinIconsView::dragMoveEvent(QDragMoveEvent* event) { - KListView::dragMoveEvent(event); + KCategorizedView::dragMoveEvent(event); // TODO: remove this code when the issue #160611 is solved in Qt 4.4 const QModelIndex index = indexAt(event->pos()); setDirtyRegion(m_dropRect); - m_dropRect = visualRect(index); + + 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 (event->mimeData()->hasUrls()) { + // accept url drops, independently from the destination item + event->acceptProposedAction(); + } + setDirtyRegion(m_dropRect); } void DolphinIconsView::dropEvent(QDropEvent* event) { - const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData()); - if (!urls.isEmpty()) { - m_controller->indicateDroppedUrls(urls, - indexAt(event->pos()), - event->source()); - event->acceptProposedAction(); + 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 = m_controller->itemForIndex(index); + m_controller->indicateDroppedUrls(urls, + m_controller->url(), + item); + event->acceptProposedAction(); + } } - KListView::dropEvent(event); - m_dragging = false; + + KCategorizedView::dropEvent(event); } -void DolphinIconsView::paintEvent(QPaintEvent* event) +void DolphinIconsView::keyPressEvent(QKeyEvent* event) { - KListView::paintEvent(event); - - if (m_dragging) { - // TODO: remove this code when the issue #160611 is solved in Qt 4.4 - QPainter painter(viewport()); - painter.save(); - QBrush brush(m_viewOptions.palette.brush(QPalette::Normal, QPalette::Highlight)); - QColor color = brush.color(); - color.setAlpha(64); - brush.setColor(color); - painter.fillRect(m_dropRect, brush); - painter.restore(); + KCategorizedView::keyPressEvent(event); + m_controller->handleKeyPressEvent(event); + m_enableScrollTo = true; // see DolphinIconsView::scrollTo() +} + +void DolphinIconsView::wheelEvent(QWheelEvent* event) +{ + if (m_selectionManager != 0) { + m_selectionManager->reset(); + } + + // let Ctrl+wheel events propagate to the DolphinView for icon zooming + if (event->modifiers() & Qt::ControlModifier) { + event->ignore(); + return; + } + 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::slotShowPreviewChanged(bool showPreview) +void DolphinIconsView::showEvent(QShowEvent* event) +{ + KFileItemDelegate* delegate = dynamic_cast(itemDelegate()); + delegate->setMaximumSize(m_itemSize); + + KCategorizedView::showEvent(event); +} + +void DolphinIconsView::leaveEvent(QEvent* event) { - updateGridSize(showPreview, m_controller->showAdditionalInfo()); + 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::slotShowAdditionalInfoChanged(bool showAdditionalInfo) +void DolphinIconsView::slotShowPreviewChanged() { - updateGridSize(m_controller->showPreview(), showAdditionalInfo); + const DolphinView* view = m_controller->dolphinView(); + updateGridSize(view->showPreview(), additionalInfoCount()); +} + +void DolphinIconsView::slotAdditionalInfoChanged() +{ + const DolphinView* view = m_controller->dolphinView(); + const bool showPreview = view->showPreview(); + updateGridSize(showPreview, view->additionalInfo().count()); } void DolphinIconsView::zoomIn() @@ -193,17 +337,13 @@ void DolphinIconsView::zoomIn() const int oldIconSize = settings->iconSize(); int newIconSize = oldIconSize; - const bool showPreview = m_controller->showPreview(); + 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 @@ -211,7 +351,7 @@ void DolphinIconsView::zoomIn() settings->setItemWidth(settings->itemWidth() + diff); settings->setItemHeight(settings->itemHeight() + diff); - updateGridSize(showPreview, m_controller->showAdditionalInfo()); + updateGridSize(showPreview, additionalInfoCount()); } } @@ -223,15 +363,10 @@ void DolphinIconsView::zoomOut() const int oldIconSize = settings->iconSize(); int newIconSize = oldIconSize; - const bool showPreview = m_controller->showPreview(); + 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); @@ -242,34 +377,50 @@ void DolphinIconsView::zoomOut() settings->setItemWidth(settings->itemWidth() - diff); settings->setItemHeight(settings->itemHeight() - diff); - updateGridSize(showPreview, m_controller->showAdditionalInfo()); + updateGridSize(showPreview, additionalInfoCount()); + } +} + +void DolphinIconsView::requestActivation() +{ + m_controller->requestActivation(); +} + +void DolphinIconsView::updateFont() +{ + const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); + Q_ASSERT(settings != 0); + + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); } } bool DolphinIconsView::isZoomInPossible() const { IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); - const int size = m_controller->showPreview() ? settings->previewSize() : settings->iconSize(); - return size < K3Icon::SizeEnormous; + const bool showPreview = m_controller->dolphinView()->showPreview(); + const int size = showPreview ? settings->previewSize() : settings->iconSize(); + return size < KIconLoader::SizeEnormous; } bool DolphinIconsView::isZoomOutPossible() const { IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); - const int size = m_controller->showPreview() ? settings->previewSize() : settings->iconSize(); - return size > K3Icon::SizeSmall; + const bool showPreview = m_controller->dolphinView()->showPreview(); + const int size = showPreview ? settings->previewSize() : settings->iconSize(); + return size > KIconLoader::SizeSmall; } int DolphinIconsView::increasedIconSize(int size) const { - // TODO: get rid of K3Icon sizes int incSize = 0; switch (size) { - case K3Icon::SizeSmall: incSize = K3Icon::SizeSmallMedium; break; - case K3Icon::SizeSmallMedium: incSize = K3Icon::SizeMedium; break; - case K3Icon::SizeMedium: incSize = K3Icon::SizeLarge; break; - case K3Icon::SizeLarge: incSize = K3Icon::SizeHuge; break; - case K3Icon::SizeHuge: incSize = K3Icon::SizeEnormous; break; + 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; } return incSize; @@ -277,20 +428,19 @@ int DolphinIconsView::increasedIconSize(int size) const int DolphinIconsView::decreasedIconSize(int size) const { - // TODO: get rid of K3Icon sizes int decSize = 0; switch (size) { - case K3Icon::SizeSmallMedium: decSize = K3Icon::SizeSmall; break; - case K3Icon::SizeMedium: decSize = K3Icon::SizeSmallMedium; break; - case K3Icon::SizeLarge: decSize = K3Icon::SizeMedium; break; - case K3Icon::SizeHuge: decSize = K3Icon::SizeLarge; break; - case K3Icon::SizeEnormous: decSize = K3Icon::SizeHuge; break; + 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; } return decSize; } -void DolphinIconsView::updateGridSize(bool showPreview, bool showAdditionalInfo) +void DolphinIconsView::updateGridSize(bool showPreview, int additionalInfoCount) { const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); Q_ASSERT(settings != 0); @@ -302,31 +452,48 @@ void DolphinIconsView::updateGridSize(bool showPreview, bool showAdditionalInfo) if (showPreview) { const int previewSize = settings->previewSize(); const int diff = previewSize - size; - Q_ASSERT(diff >= 0); itemWidth += diff; itemHeight += diff; size = previewSize; } - if (showAdditionalInfo) { - itemHeight += m_viewOptions.font.pointSize() * 2; - } + Q_ASSERT(additionalInfoCount >= 0); + itemHeight += additionalInfoCount * m_font.pointSize() * 2; if (settings->arrangement() == QListView::TopToBottom) { // 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); + m_decorationSize = QSize(size, size); + setIconSize(QSize(size, size)); } + m_itemSize = QSize(itemWidth, itemHeight); + const int spacing = settings->gridSpacing(); - setGridSize(QSize(itemWidth + spacing, itemHeight + spacing)); + setGridSize(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); + } + + if (m_selectionManager != 0) { + m_selectionManager->reset(); + } +} + +int DolphinIconsView::additionalInfoCount() const +{ + const DolphinView* view = m_controller->dolphinView(); + return view->additionalInfo().count(); } #include "dolphiniconsview.moc"