X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/e4dbe5626b092a884cfda0e99f0f0b4ba5cbc2ef..bbf9faa05396d66b3dbe101a0c309459e3ffacb1:/src/dolphiniconsview.cpp diff --git a/src/dolphiniconsview.cpp b/src/dolphiniconsview.cpp index 0f619ff30..30e47da89 100644 --- a/src/dolphiniconsview.cpp +++ b/src/dolphiniconsview.cpp @@ -19,59 +19,149 @@ #include "dolphiniconsview.h" +#include "dolphincategorydrawer.h" #include "dolphincontroller.h" +#include "dolphinsettings.h" -#include +#include "dolphin_iconsmodesettings.h" + +#include #include -#include #include +#include +#include +#include DolphinIconsView::DolphinIconsView(QWidget* parent, DolphinController* controller) : - QListView(parent), - m_controller(controller) + KCategorizedView(parent), + m_controller(controller), + m_categoryDrawer(0), + m_itemSize(), + m_dragging(false), + m_dropRect() { - assert(controller != 0); - + Q_ASSERT(controller != 0); + setViewMode(QListView::IconMode); setResizeMode(QListView::Adjust); + setSpacing(KDialog::spacingHint()); + setMouseTracking(true); + viewport()->setAttribute(Qt::WA_Hover); - // TODO: read out settings - setViewMode(QListView::IconMode); - setGridSize(QSize(128, 96)); + // 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&)), + this, SLOT(triggerItem(const QModelIndex&))); + } else { + connect(this, SIGNAL(doubleClicked(const QModelIndex&)), + this, SLOT(triggerItem(const QModelIndex&))); + } + connect(this, SIGNAL(viewportEntered()), + controller, SLOT(emitViewportEntered())); + 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(const KFileItemDelegate::InformationList&)), + this, SLOT(slotAdditionalInfoChanged(const KFileItemDelegate::InformationList&))); + + connect(this, SIGNAL(entered(const QModelIndex&)), + this, SLOT(slotEntered(const QModelIndex&))); + + // 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; + + setWordWrap(settings->numberOfTextlines() > 1); + updateGridSize(view->showPreview(), 0); + + if (settings->arrangement() == QListView::TopToBottom) { + setFlow(QListView::LeftToRight); + m_viewOptions.decorationPosition = QStyleOptionViewItem::Top; + } else { + setFlow(QListView::TopToBottom); + m_viewOptions.decorationPosition = QStyleOptionViewItem::Left; + m_viewOptions.displayAlignment = Qt::AlignLeft | Qt::AlignVCenter; + } - connect(this, SIGNAL(clicked(const QModelIndex&)), - controller, SLOT(triggerItem(const QModelIndex&))); + m_categoryDrawer = new DolphinCategoryDrawer(); + setCategoryDrawer(m_categoryDrawer); + + setFocus(); } DolphinIconsView::~DolphinIconsView() { + delete m_categoryDrawer; + m_categoryDrawer = 0; } -QStyleOptionViewItem DolphinIconsView::viewOptions() const +QRect DolphinIconsView::visualRect(const QModelIndex& index) const { - return QListView::viewOptions(); + 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); + } - // TODO: the view options should been read from the settings; - // the following code is just for testing... - //QStyleOptionViewItem options = QListView::viewOptions(); - //options.decorationAlignment = Qt::AlignRight; - //options.decorationPosition = QStyleOptionViewItem::Right; - //options.decorationSize = QSize(100, 100); - //options.showDecorationSelected = true; - //options.state = QStyle::State_MouseOver; - //return options; + return itemRect; +} + +QStyleOptionViewItem DolphinIconsView::viewOptions() const +{ + return m_viewOptions; } void DolphinIconsView::contextMenuEvent(QContextMenuEvent* event) { - QListView::contextMenuEvent(event); + KCategorizedView::contextMenuEvent(event); m_controller->triggerContextMenuRequest(event->pos()); } -void DolphinIconsView::mouseReleaseEvent(QMouseEvent* event) +void DolphinIconsView::mousePressEvent(QMouseEvent* event) { - QListView::mouseReleaseEvent(event); - m_controller->triggerActivation(); + m_controller->requestActivation(); + if (!indexAt(event->pos()).isValid()) { + const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers(); + if (!(modifier & Qt::ShiftModifier) && !(modifier & Qt::ControlModifier)) { + clearSelection(); + } + } + + KCategorizedView::mousePressEvent(event); } void DolphinIconsView::dragEnterEvent(QDragEnterEvent* event) @@ -79,18 +169,252 @@ void DolphinIconsView::dragEnterEvent(QDragEnterEvent* event) if (event->mimeData()->hasUrls()) { 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); +} + +void DolphinIconsView::dragMoveEvent(QDragMoveEvent* 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); + setDirtyRegion(m_dropRect); } void DolphinIconsView::dropEvent(QDropEvent* event) { - const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData()); - if (urls.isEmpty() || (event->source() == this)) { - QListView::dropEvent(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()); + if (index.isValid()) { + const KFileItem item = itemForIndex(index); + m_controller->indicateDroppedUrls(urls, + m_controller->url(), + item, + event->source()); + event->acceptProposedAction(); + } + } } - else { - event->acceptProposedAction(); - m_controller->indicateDroppedUrls(urls, event->pos()); + + KCategorizedView::dropEvent(event); + m_dragging = false; +} + +void DolphinIconsView::paintEvent(QPaintEvent* event) +{ + KCategorizedView::paintEvent(event); + + // TODO: remove this code when the issue #160611 is solved in Qt 4.4 + if (m_dragging) { + const QBrush& brush = m_viewOptions.palette.brush(QPalette::Normal, QPalette::Highlight); + DolphinController::drawHoverIndication(viewport(), m_dropRect, brush); + } +} + +void DolphinIconsView::keyPressEvent(QKeyEvent* event) +{ + KCategorizedView::keyPressEvent(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::triggerItem(const QModelIndex& index) +{ + m_controller->triggerItem(itemForIndex(index)); +} + +void DolphinIconsView::slotEntered(const QModelIndex& index) +{ + m_controller->emitItemEntered(itemForIndex(index)); +} + +void DolphinIconsView::slotShowPreviewChanged() +{ + const DolphinView* view = m_controller->dolphinView(); + const int infoCount = view->additionalInfo().count(); + updateGridSize(view->showPreview(), infoCount); +} + +void DolphinIconsView::slotAdditionalInfoChanged(const KFileItemDelegate::InformationList& info) +{ + const bool showPreview = m_controller->dolphinView()->showPreview(); + updateGridSize(showPreview, info.count()); +} + +void DolphinIconsView::zoomIn() +{ + 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); + } +} + +void DolphinIconsView::zoomOut() +{ + 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); + } +} + +bool DolphinIconsView::isZoomInPossible() const +{ + IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); + 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 bool showPreview = m_controller->dolphinView()->showPreview(); + const int size = showPreview ? settings->previewSize() : settings->iconSize(); + return size > KIconLoader::SizeSmall; +} + +int DolphinIconsView::increasedIconSize(int size) const +{ + 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; + } + 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; + } + return decSize; +} + +void DolphinIconsView::updateGridSize(bool showPreview, int additionalInfoCount) +{ + const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); + Q_ASSERT(settings != 0); + + int itemWidth = settings->itemWidth(); + int itemHeight = settings->itemHeight(); + int size = settings->iconSize(); + + if (showPreview) { + const int previewSize = settings->previewSize(); + const int diff = previewSize - size; + Q_ASSERT(diff >= 0); + itemWidth += diff; + itemHeight += diff; + + size = previewSize; } + + Q_ASSERT(additionalInfoCount >= 0); + itemHeight += additionalInfoCount * m_viewOptions.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); + } else { + m_viewOptions.decorationSize = QSize(size, size); + } + + const int spacing = settings->gridSpacing(); + setGridSize(QSize(itemWidth + spacing, itemHeight + spacing)); + + m_itemSize = QSize(itemWidth, itemHeight); + + m_controller->setZoomInPossible(isZoomInPossible()); + m_controller->setZoomOutPossible(isZoomOutPossible()); +} + +KFileItem DolphinIconsView::itemForIndex(const QModelIndex& index) const +{ + QAbstractProxyModel* proxyModel = static_cast(model()); + KDirModel* dirModel = static_cast(proxyModel->sourceModel()); + const QModelIndex dirIndex = proxyModel->mapToSource(index); + return dirModel->itemForIndex(dirIndex); } + #include "dolphiniconsview.moc"