diff options
Diffstat (limited to 'src/views')
30 files changed, 8658 insertions, 0 deletions
diff --git a/src/views/dolphincategorydrawer.cpp b/src/views/dolphincategorydrawer.cpp new file mode 100644 index 000000000..59743b7f5 --- /dev/null +++ b/src/views/dolphincategorydrawer.cpp @@ -0,0 +1,378 @@ +/* + * This file is part of the KDE project + * Copyright (C) 2007 Rafael Fernández López <[email protected]> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#include "dolphincategorydrawer.h" + +#include <config-nepomuk.h> + +#include <QPainter> +#include <QFile> +#include <QDir> +#include <QApplication> +#include <QStyleOption> + +#ifdef HAVE_NEPOMUK +#include <nepomuk/kratingpainter.h> +#endif + +#include <kiconloader.h> +#include <kiconeffect.h> +#include <kcategorizedsortfilterproxymodel.h> +#include <qimageblitz.h> +#include <kuser.h> +#include <kcategorizedview.h> + +#include "dolphinview.h" +#include "dolphinmodel.h" + +#define HORIZONTAL_HINT 3 + +DolphinCategoryDrawer::DolphinCategoryDrawer(KCategorizedView *view) + : KCategoryDrawerV3(view) + , hotSpotPressed(NoneHotSpot) + , selectAll(KIconLoader::global()->loadIcon("list-add", KIconLoader::Desktop, 16)) + , selectAllHovered(KIconLoader::global()->iconEffect()->apply(selectAll, KIconLoader::Desktop, KIconLoader::ActiveState)) + , selectAllDisabled(KIconLoader::global()->iconEffect()->apply(selectAll, KIconLoader::Desktop, KIconLoader::DisabledState)) + , unselectAll(KIconLoader::global()->loadIcon("list-remove", KIconLoader::Desktop, 16)) + , unselectAllHovered(KIconLoader::global()->iconEffect()->apply(unselectAll, KIconLoader::Desktop, KIconLoader::ActiveState)) + , unselectAllDisabled(KIconLoader::global()->iconEffect()->apply(unselectAll, KIconLoader::Desktop, KIconLoader::DisabledState)) +{ +} + +DolphinCategoryDrawer::~DolphinCategoryDrawer() +{ +} + +bool DolphinCategoryDrawer::allCategorySelected(const QString &category) const +{ + const QModelIndexList list = view()->block(category); + foreach (const QModelIndex &index, list) { + if (!view()->selectionModel()->isSelected(index)) { + return false; + } + } + return true; +} + +bool DolphinCategoryDrawer::someCategorySelected(const QString &category) const +{ + const QModelIndexList list = view()->block(category); + foreach (const QModelIndex &index, list) { + if (view()->selectionModel()->isSelected(index)) { + return true; + } + } + return false; +} + +void DolphinCategoryDrawer::drawCategory(const QModelIndex &index, int sortRole, + const QStyleOption &option, QPainter *painter) const +{ + Q_UNUSED(sortRole); + painter->setRenderHint(QPainter::Antialiasing); + + if (!index.isValid()) { + return; + } + + const QString category = index.model()->data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); + const QRect optRect = option.rect; + QFont font(QApplication::font()); + font.setBold(true); + const QFontMetrics fontMetrics = QFontMetrics(font); + + QColor outlineColor = option.palette.text().color(); + outlineColor.setAlphaF(0.35); + + //BEGIN: top left corner + { + painter->save(); + painter->setPen(outlineColor); + const QPointF topLeft(optRect.topLeft()); + QRectF arc(topLeft, QSizeF(4, 4)); + arc.translate(0.5, 0.5); + painter->drawArc(arc, 1440, 1440); + painter->restore(); + } + //END: top left corner + + //BEGIN: left vertical line + { + QPoint start(optRect.topLeft()); + start.ry() += 3; + QPoint verticalGradBottom(optRect.topLeft()); + verticalGradBottom.ry() += fontMetrics.height() + 5; + QLinearGradient gradient(start, verticalGradBottom); + gradient.setColorAt(0, outlineColor); + gradient.setColorAt(1, Qt::transparent); + painter->fillRect(QRect(start, QSize(1, fontMetrics.height() + 5)), gradient); + } + //END: left vertical line + + //BEGIN: horizontal line + { + QPoint start(optRect.topLeft()); + start.rx() += 3; + QPoint horizontalGradTop(optRect.topLeft()); + horizontalGradTop.rx() += optRect.width() - 6; + painter->fillRect(QRect(start, QSize(optRect.width() - 6, 1)), outlineColor); + } + //END: horizontal line + + //BEGIN: top right corner + { + painter->save(); + painter->setPen(outlineColor); + QPointF topRight(optRect.topRight()); + topRight.rx() -= 4; + QRectF arc(topRight, QSizeF(4, 4)); + arc.translate(0.5, 0.5); + painter->drawArc(arc, 0, 1440); + painter->restore(); + } + //END: top right corner + + //BEGIN: right vertical line + { + QPoint start(optRect.topRight()); + start.ry() += 3; + QPoint verticalGradBottom(optRect.topRight()); + verticalGradBottom.ry() += fontMetrics.height() + 5; + QLinearGradient gradient(start, verticalGradBottom); + gradient.setColorAt(0, outlineColor); + gradient.setColorAt(1, Qt::transparent); + painter->fillRect(QRect(start, QSize(1, fontMetrics.height() + 5)), gradient); + } + //END: right vertical line + + const int iconSize = KIconLoader::global()->currentSize(KIconLoader::Small); + + //BEGIN: select/unselect all + { + if (this->category == category) { + QRect iconAllRect(option.rect); + iconAllRect.setTop(iconAllRect.top() + 4); + iconAllRect.setLeft(iconAllRect.right() - 16 - 7); + iconAllRect.setSize(QSize(iconSize, iconSize)); + if (!allCategorySelected(category)) { + if (iconAllRect.contains(pos)) { + painter->drawPixmap(iconAllRect, selectAllHovered); + } else { + painter->drawPixmap(iconAllRect, selectAll); + } + } else { + painter->drawPixmap(iconAllRect, selectAllDisabled); + } + QRect iconNoneRect(option.rect); + iconNoneRect.setTop(iconNoneRect.top() + 4); + iconNoneRect.setLeft(iconNoneRect.right() - 16 * 2 - 7 * 2); + iconNoneRect.setSize(QSize(iconSize, iconSize)); + if (someCategorySelected(category)) { + if (iconNoneRect.contains(pos)) { + painter->drawPixmap(iconNoneRect, unselectAllHovered); + } else { + painter->drawPixmap(iconNoneRect, unselectAll); + } + } else { + painter->drawPixmap(iconNoneRect, unselectAllDisabled); + } + } + } + //END: select/unselect all + + //BEGIN: category information + { + bool paintIcon; + QPixmap icon; + switch (index.column()) { + case KDirModel::Owner: { + paintIcon = true; + KUser user(category); + const QString faceIconPath = user.faceIconPath(); + if (faceIconPath.isEmpty()) { + icon = KIconLoader::global()->loadIcon("user-identity", KIconLoader::NoGroup, iconSize); + } else { + icon = QPixmap::fromImage(QImage(faceIconPath).scaledToHeight(iconSize, Qt::SmoothTransformation)); + } + } + break; + case KDirModel::Type: { + paintIcon = true; + const KCategorizedSortFilterProxyModel *proxyModel = static_cast<const KCategorizedSortFilterProxyModel*>(index.model()); + const DolphinModel *model = static_cast<const DolphinModel*>(proxyModel->sourceModel()); + KFileItem item = model->itemForIndex(proxyModel->mapToSource(index)); + // This is the only way of getting the icon right. Others will fail on corner + // cases like the item representing this group has been set a different icon, + // so the group icon drawn is that one particularly. This way assures the drawn + // icon is the one of the mimetype of the group itself. (ereslibre) + icon = KIconLoader::global()->loadMimeTypeIcon(item.mimeTypePtr()->iconName(), KIconLoader::NoGroup, iconSize); + } + break; + default: + paintIcon = false; + } + + if (paintIcon) { + QRect iconRect(option.rect); + iconRect.setTop(iconRect.top() + 4); + iconRect.setLeft(iconRect.left() + 7); + iconRect.setSize(QSize(iconSize, iconSize)); + + painter->drawPixmap(iconRect, icon); + } + + //BEGIN: text + { + QRect textRect(option.rect); + textRect.setTop(textRect.top() + 7); + textRect.setLeft(textRect.left() + 7 + (paintIcon ? (iconSize + 6) : 0)); + textRect.setHeight(qMax(fontMetrics.height(), iconSize)); + textRect.setRight(textRect.right() - 7); + textRect.setBottom(textRect.bottom() - 5); // only one pixel separation here (no gradient) + + painter->save(); + painter->setFont(font); + QColor penColor(option.palette.text().color()); + penColor.setAlphaF(0.6); + painter->setPen(penColor); + painter->drawText(textRect, Qt::AlignLeft | Qt::AlignVCenter, category); + painter->restore(); + } + //END: text + } + //BEGIN: category information +} + +int DolphinCategoryDrawer::categoryHeight(const QModelIndex &index, const QStyleOption &) const +{ + int iconSize = KIconLoader::global()->currentSize(KIconLoader::Small); + QFont font(QApplication::font()); + font.setBold(true); + const QFontMetrics fontMetrics = QFontMetrics(font); + int heightWithoutIcon = fontMetrics.height() + (iconSize / 4) * 2 + 1; /* 1 pixel-width gradient */ + bool paintIcon; + + switch (index.column()) { + case KDirModel::Owner: + case KDirModel::Type: + paintIcon = true; + break; + default: + paintIcon = false; + } + + if (paintIcon) { + return qMax(heightWithoutIcon + 5, iconSize + 1 /* 1 pixel-width gradient */ + + 5 /* top and bottom separation */); + } + + return heightWithoutIcon + 5; +} + +void DolphinCategoryDrawer::mouseButtonPressed(const QModelIndex &index, const QRect &blockRect, QMouseEvent *event) +{ + if (!index.isValid()) { + event->ignore(); + return; + } + const QString category = index.model()->data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); + int iconSize = KIconLoader::global()->currentSize(KIconLoader::Small); + if (this->category == category) { + QRect iconAllRect(blockRect); + iconAllRect.setTop(iconAllRect.top() + 4); + iconAllRect.setLeft(iconAllRect.right() - 16 - 7); + iconAllRect.setSize(QSize(iconSize, iconSize)); + if (iconAllRect.contains(pos)) { + event->accept(); + hotSpotPressed = SelectAllHotSpot; + categoryPressed = index; + return; + } + QRect iconNoneRect(blockRect); + iconNoneRect.setTop(iconNoneRect.top() + 4); + iconNoneRect.setLeft(iconNoneRect.right() - 16 * 2 - 7 * 2); + iconNoneRect.setSize(QSize(iconSize, iconSize)); + if (iconNoneRect.contains(pos)) { + event->accept(); + hotSpotPressed = UnselectAllHotSpot; + categoryPressed = index; + return; + } + } + event->ignore(); +} + +void DolphinCategoryDrawer::mouseButtonReleased(const QModelIndex &index, const QRect &blockRect, QMouseEvent *event) +{ + if (!index.isValid() || hotSpotPressed == NoneHotSpot || categoryPressed != index) { + event->ignore(); + return; + } + categoryPressed = QModelIndex(); + const QString category = index.model()->data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); + int iconSize = KIconLoader::global()->currentSize(KIconLoader::Small); + if (this->category == category) { + QRect iconAllRect(blockRect); + iconAllRect.setTop(iconAllRect.top() + 4); + iconAllRect.setLeft(iconAllRect.right() - 16 - 7); + iconAllRect.setSize(QSize(iconSize, iconSize)); + if (iconAllRect.contains(pos)) { + if (hotSpotPressed == SelectAllHotSpot) { + event->accept(); + emit actionRequested(SelectAll, index); + } else { + event->ignore(); + hotSpotPressed = NoneHotSpot; + } + return; + } + QRect iconNoneRect(blockRect); + iconNoneRect.setTop(iconNoneRect.top() + 4); + iconNoneRect.setLeft(iconNoneRect.right() - 16 * 2 - 7 * 2); + iconNoneRect.setSize(QSize(iconSize, iconSize)); + if (iconNoneRect.contains(pos)) { + if (hotSpotPressed == UnselectAllHotSpot) { + event->accept(); + emit actionRequested(UnselectAll, index); + } else { + event->ignore(); + hotSpotPressed = NoneHotSpot; + } + return; + } + } + event->ignore(); +} + +void DolphinCategoryDrawer::mouseMoved(const QModelIndex &index, const QRect &, QMouseEvent *event) +{ + event->ignore(); + if (!index.isValid()) { + return; + } + pos = event->pos(); + category = index.model()->data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); +} + +void DolphinCategoryDrawer::mouseLeft(const QModelIndex &, const QRect &) +{ + pos = QPoint(); + category = QString(); +} diff --git a/src/views/dolphincategorydrawer.h b/src/views/dolphincategorydrawer.h new file mode 100644 index 000000000..d9849727e --- /dev/null +++ b/src/views/dolphincategorydrawer.h @@ -0,0 +1,85 @@ +/* This file is part of the KDE project + * Copyright (C) 2007 Rafael Fernández López <[email protected]> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. +*/ + +#ifndef DOLPHINCATEGORYDRAWER_H +#define DOLPHINCATEGORYDRAWER_H + +#include <kcategorydrawer.h> + +#include <QStyleOption> +#include <QModelIndex> + +#include <libdolphin_export.h> + +class LIBDOLPHINPRIVATE_EXPORT DolphinCategoryDrawer + : public KCategoryDrawerV3 +{ +public: + using KCategoryDrawerV2::mouseButtonPressed; + using KCategoryDrawerV2::mouseButtonReleased; + + enum Action { + SelectAll = 0, + UnselectAll + }; + + DolphinCategoryDrawer(KCategorizedView *view); + + virtual ~DolphinCategoryDrawer(); + + bool allCategorySelected(const QString &category) const; + + bool someCategorySelected(const QString &category) const; + + virtual void drawCategory(const QModelIndex &index, int sortRole, + const QStyleOption &option, QPainter *painter) const; + + virtual int categoryHeight(const QModelIndex &index, const QStyleOption &option) const; + +protected: + virtual void mouseButtonPressed(const QModelIndex &index, const QRect &blockRect, QMouseEvent *event); + + virtual void mouseButtonReleased(const QModelIndex &index, const QRect &blockRect, QMouseEvent *event); + + virtual void mouseMoved(const QModelIndex &index, const QRect &blockRect, QMouseEvent *event); + + virtual void mouseLeft(const QModelIndex &index,const QRect &blockRect); + +private: + enum HotSpot { + NoneHotSpot = 0, + SelectAllHotSpot, + UnselectAllHotSpot + }; + + HotSpot hotSpotPressed; + QModelIndex categoryPressed; + + QPixmap selectAll; + QPixmap selectAllHovered; + QPixmap selectAllDisabled; + QPixmap unselectAll; + QPixmap unselectAllHovered; + QPixmap unselectAllDisabled; + + QPoint pos; + QString category; +}; + +#endif // DOLPHINCATEGORYDRAWER_H diff --git a/src/views/dolphincolumnview.cpp b/src/views/dolphincolumnview.cpp new file mode 100644 index 000000000..7e2b522b4 --- /dev/null +++ b/src/views/dolphincolumnview.cpp @@ -0,0 +1,466 @@ +/*************************************************************************** + * Copyright (C) 2007-2009 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "dolphincolumnview.h" + +#include "dolphinmodel.h" +#include "dolphincolumnviewcontainer.h" +#include "dolphinviewcontroller.h" +#include "dolphindirlister.h" +#include "dolphinsortfilterproxymodel.h" +#include "settings/dolphinsettings.h" +#include "dolphinviewautoscroller.h" +#include "dolphin_columnmodesettings.h" +#include "dolphin_generalsettings.h" +#include "draganddrophelper.h" +#include "folderexpander.h" +#include "tooltips/tooltipmanager.h" +#include "viewextensionsfactory.h" +#include "viewmodecontroller.h" +#include "zoomlevelinfo.h" + +#include <kcolorscheme.h> +#include <kdirlister.h> +#include <kfileitem.h> +#include <kio/previewjob.h> +#include <kiconeffect.h> +#include <kjob.h> +#include <konqmimedata.h> + +#include <QApplication> +#include <QClipboard> +#include <QPainter> +#include <QPoint> +#include <QScrollBar> + +DolphinColumnView::DolphinColumnView(QWidget* parent, + DolphinColumnViewContainer* container, + const KUrl& url) : + QListView(parent), + m_active(false), + m_container(container), + m_extensionsFactory(0), + m_url(url), + m_childUrl(), + m_font(), + m_decorationSize(), + m_dirLister(0), + m_dolphinModel(0), + m_proxyModel(0), + m_dropRect() +{ + setMouseTracking(true); + setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded); + setSelectionBehavior(SelectItems); + setSelectionMode(QAbstractItemView::ExtendedSelection); + setDragDropMode(QAbstractItemView::DragDrop); + setDropIndicatorShown(false); + setSelectionRectVisible(true); + setEditTriggers(QAbstractItemView::NoEditTriggers); + + setVerticalScrollMode(QListView::ScrollPerPixel); + setHorizontalScrollMode(QListView::ScrollPerPixel); + + // apply the column mode settings to the widget + const ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings(); + Q_ASSERT(settings != 0); + + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); + } else { + m_font = QFont(settings->fontFamily(), + qRound(settings->fontSize()), + settings->fontWeight(), + settings->italicFont()); + m_font.setPointSizeF(settings->fontSize()); + } + + connect(this, SIGNAL(viewportEntered()), + m_container->m_dolphinViewController, SLOT(emitViewportEntered())); + connect(this, SIGNAL(entered(const QModelIndex&)), + this, SLOT(slotEntered(const QModelIndex&))); + + const DolphinView* dolphinView = m_container->m_dolphinViewController->view(); + connect(dolphinView, SIGNAL(showPreviewChanged()), + this, SLOT(slotShowPreviewChanged())); + + m_dirLister = new DolphinDirLister(); + m_dirLister->setAutoUpdate(true); + m_dirLister->setMainWindow(window()); + m_dirLister->setDelayedMimeTypes(true); + const bool showHiddenFiles = m_container->m_dolphinViewController->view()->showHiddenFiles(); + m_dirLister->setShowingDotFiles(showHiddenFiles); + + m_dolphinModel = new DolphinModel(this); + m_dolphinModel->setDirLister(m_dirLister); + m_dolphinModel->setDropsAllowed(DolphinModel::DropOnDirectory); + + m_proxyModel = new DolphinSortFilterProxyModel(this); + m_proxyModel->setSourceModel(m_dolphinModel); + m_proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive); + + m_proxyModel->setSorting(dolphinView->sorting()); + m_proxyModel->setSortOrder(dolphinView->sortOrder()); + m_proxyModel->setSortFoldersFirst(dolphinView->sortFoldersFirst()); + + setModel(m_proxyModel); + + connect(KGlobalSettings::self(), SIGNAL(kdisplayFontChanged()), + this, SLOT(updateFont())); + + const ViewModeController* viewModeController = m_container->m_viewModeController; + connect(viewModeController, SIGNAL(zoomLevelChanged(int)), + this, SLOT(setZoomLevel(int))); + const QString nameFilter = viewModeController->nameFilter(); + if (!nameFilter.isEmpty()) { + m_proxyModel->setFilterFixedString(nameFilter); + } + + updateDecorationSize(dolphinView->showPreview()); + updateBackground(); + + DolphinViewController* dolphinViewController = m_container->m_dolphinViewController; + m_extensionsFactory = new ViewExtensionsFactory(this, dolphinViewController, viewModeController); + + m_dirLister->openUrl(url, KDirLister::NoFlags); +} + +DolphinColumnView::~DolphinColumnView() +{ + delete m_proxyModel; + m_proxyModel = 0; + delete m_dolphinModel; + m_dolphinModel = 0; + m_dirLister = 0; // deleted by m_dolphinModel +} + +void DolphinColumnView::setActive(bool active) +{ + if (m_active != active) { + m_active = active; + + if (active) { + activate(); + } else { + deactivate(); + } + } +} + +void DolphinColumnView::updateBackground() +{ + // TODO: The alpha-value 150 is copied from DolphinView::setActive(). When + // cleaning up the cut-indication of DolphinColumnView with the code from + // DolphinView a common helper-class should be available which can be shared + // by all view implementations -> no hardcoded value anymore + const QPalette::ColorRole role = viewport()->backgroundRole(); + QColor color = viewport()->palette().color(role); + color.setAlpha((m_active && m_container->m_active) ? 255 : 150); + + QPalette palette = viewport()->palette(); + palette.setColor(role, color); + viewport()->setPalette(palette); + + update(); +} + +KFileItem DolphinColumnView::itemAt(const QPoint& pos) const +{ + KFileItem item; + const QModelIndex index = indexAt(pos); + if (index.isValid() && (index.column() == DolphinModel::Name)) { + const QModelIndex dolphinModelIndex = m_proxyModel->mapToSource(index); + item = m_dolphinModel->itemForIndex(dolphinModelIndex); + } + return item; +} + +void DolphinColumnView::setSelectionModel(QItemSelectionModel* model) +{ + // If a change of the selection is done although the view is not active + // (e. g. by the selection markers), the column must be activated. This + // is done by listening to the current selectionChanged() signal. + if (selectionModel() != 0) { + disconnect(selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), + this, SLOT(requestActivation())); + } + + QListView::setSelectionModel(model); + + connect(selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), + this, SLOT(requestActivation())); +} + +QStyleOptionViewItem DolphinColumnView::viewOptions() const +{ + QStyleOptionViewItem viewOptions = QListView::viewOptions(); + viewOptions.font = m_font; + viewOptions.fontMetrics = QFontMetrics(m_font); + viewOptions.decorationSize = m_decorationSize; + viewOptions.showDecorationSelected = true; + return viewOptions; +} + +void DolphinColumnView::startDrag(Qt::DropActions supportedActions) +{ + DragAndDropHelper::instance().startDrag(this, supportedActions, m_container->m_dolphinViewController); +} + +void DolphinColumnView::dragEnterEvent(QDragEnterEvent* event) +{ + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { + event->acceptProposedAction(); + requestActivation(); + } +} + +void DolphinColumnView::dragLeaveEvent(QDragLeaveEvent* event) +{ + QListView::dragLeaveEvent(event); + setDirtyRegion(m_dropRect); +} + +void DolphinColumnView::dragMoveEvent(QDragMoveEvent* event) +{ + QListView::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.setSize(QSize()); // set as invalid + if (index.isValid()) { + m_container->m_dolphinViewController->setItemView(this); + const KFileItem item = m_container->m_dolphinViewController->itemForIndex(index); + if (!item.isNull() && item.isDir()) { + m_dropRect = visualRect(index); + } + } + setDirtyRegion(m_dropRect); + + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { + // accept url drops, independently from the destination item + event->acceptProposedAction(); + } +} + +void DolphinColumnView::dropEvent(QDropEvent* event) +{ + const QModelIndex index = indexAt(event->pos()); + m_container->m_dolphinViewController->setItemView(this); + const KFileItem item = m_container->m_dolphinViewController->itemForIndex(index); + m_container->m_dolphinViewController->indicateDroppedUrls(item, url(), event); + QListView::dropEvent(event); +} + +void DolphinColumnView::paintEvent(QPaintEvent* event) +{ + if (!m_childUrl.isEmpty()) { + // indicate the shown URL of the next column by highlighting the shown folder item + const QModelIndex dirIndex = m_dolphinModel->indexForUrl(m_childUrl); + const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex); + if (proxyIndex.isValid() && !selectionModel()->isSelected(proxyIndex)) { + const QRect itemRect = visualRect(proxyIndex); + QPainter painter(viewport()); + QColor color = KColorScheme(QPalette::Active, KColorScheme::View).foreground().color(); + color.setAlpha(32); + painter.setPen(Qt::NoPen); + painter.setBrush(color); + painter.drawRect(itemRect); + } + } + + QListView::paintEvent(event); +} + +void DolphinColumnView::mousePressEvent(QMouseEvent* event) +{ + requestActivation(); + if (!indexAt(event->pos()).isValid()) { + if (QApplication::mouseButtons() & Qt::MidButton) { + m_container->m_dolphinViewController->replaceUrlByClipboard(); + } + } else if (event->button() == Qt::LeftButton) { + // TODO: see comment in DolphinIconsView::mousePressEvent() + setState(QAbstractItemView::DraggingState); + } + QListView::mousePressEvent(event); +} + +void DolphinColumnView::keyPressEvent(QKeyEvent* event) +{ + QListView::keyPressEvent(event); + + DolphinViewController* controller = m_container->m_dolphinViewController; + controller->handleKeyPressEvent(event); + switch (event->key()) { + case Qt::Key_Right: { + // Special key handling for the column: A Key_Right should + // open a new column for the currently selected folder. + const QModelIndex index = currentIndex(); + const KFileItem item = controller->itemForIndex(index); + if (!item.isNull() && item.isDir()) { + controller->emitItemTriggered(item); + } + break; + } + + case Qt::Key_Escape: + selectionModel()->setCurrentIndex(selectionModel()->currentIndex(), + QItemSelectionModel::Current | + QItemSelectionModel::Clear); + break; + + default: + break; + } +} + +void DolphinColumnView::contextMenuEvent(QContextMenuEvent* event) +{ + requestActivation(); + QListView::contextMenuEvent(event); + m_container->m_dolphinViewController->triggerContextMenuRequest(event->pos()); +} + +void DolphinColumnView::wheelEvent(QWheelEvent* event) +{ + const int step = m_decorationSize.height(); + verticalScrollBar()->setSingleStep(step); + QListView::wheelEvent(event); +} + +void DolphinColumnView::leaveEvent(QEvent* event) +{ + QListView::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_container->m_dolphinViewController->emitViewportEntered(); +} + +void DolphinColumnView::currentChanged(const QModelIndex& current, const QModelIndex& previous) +{ + QListView::currentChanged(current, previous); + m_extensionsFactory->handleCurrentIndexChange(current, previous); +} + +void DolphinColumnView::setZoomLevel(int level) +{ + const int size = ZoomLevelInfo::iconSizeForZoomLevel(level); + ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings(); + + const bool showPreview = m_container->m_dolphinViewController->view()->showPreview(); + if (showPreview) { + settings->setPreviewSize(size); + } else { + settings->setIconSize(size); + } + + updateDecorationSize(showPreview); +} + +void DolphinColumnView::slotEntered(const QModelIndex& index) +{ + m_container->m_dolphinViewController->setItemView(this); + m_container->m_dolphinViewController->emitItemEntered(index); +} + +void DolphinColumnView::requestActivation() +{ + m_container->m_dolphinViewController->requestActivation(); + if (!m_active) { + m_container->requestActivation(this); + selectionModel()->clear(); + } +} + +void DolphinColumnView::updateFont() +{ + const ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings(); + Q_ASSERT(settings != 0); + + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); + } +} + +void DolphinColumnView::slotShowPreviewChanged() +{ + const DolphinView* view = m_container->m_dolphinViewController->view(); + updateDecorationSize(view->showPreview()); +} + +void DolphinColumnView::activate() +{ + setFocus(Qt::OtherFocusReason); + + if (KGlobalSettings::singleClick()) { + connect(this, SIGNAL(clicked(const QModelIndex&)), + m_container->m_dolphinViewController, SLOT(triggerItem(const QModelIndex&))); + } else { + connect(this, SIGNAL(doubleClicked(const QModelIndex&)), + m_container->m_dolphinViewController, SLOT(triggerItem(const QModelIndex&))); + } + + if (selectionModel() && selectionModel()->currentIndex().isValid()) { + selectionModel()->setCurrentIndex(selectionModel()->currentIndex(), QItemSelectionModel::SelectCurrent); + } + + updateBackground(); +} + +void DolphinColumnView::deactivate() +{ + clearFocus(); + if (KGlobalSettings::singleClick()) { + disconnect(this, SIGNAL(clicked(const QModelIndex&)), + m_container->m_dolphinViewController, SLOT(triggerItem(const QModelIndex&))); + } else { + disconnect(this, SIGNAL(doubleClicked(const QModelIndex&)), + m_container->m_dolphinViewController, SLOT(triggerItem(const QModelIndex&))); + } + + // It is important to disconnect the connection to requestActivation() temporary, otherwise the internal + // clearing of the selection would result in activating the column again. + disconnect(selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), + this, SLOT(requestActivation())); + const QModelIndex current = selectionModel()->currentIndex(); + selectionModel()->clear(); + selectionModel()->setCurrentIndex(current, QItemSelectionModel::NoUpdate); + connect(selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), + this, SLOT(requestActivation())); + + updateBackground(); +} + +void DolphinColumnView::updateDecorationSize(bool showPreview) +{ + ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings(); + const int iconSize = showPreview ? settings->previewSize() : settings->iconSize(); + const QSize size(iconSize, iconSize); + setIconSize(size); + + m_decorationSize = size; + + doItemsLayout(); +} + +#include "dolphincolumnview.moc" diff --git a/src/views/dolphincolumnview.h b/src/views/dolphincolumnview.h new file mode 100644 index 000000000..64feac4f9 --- /dev/null +++ b/src/views/dolphincolumnview.h @@ -0,0 +1,170 @@ +/*************************************************************************** + * Copyright (C) 2007-2009 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef DOLPHINCOLUMNVIEW_H +#define DOLPHINCOLUMNVIEW_H + +#include "dolphinview.h" + +#include <QFont> +#include <QListView> +#include <QSize> +#include <QStyleOption> + +#include <kurl.h> + +class DolphinColumnViewContainer; +class DolphinModel; +class DolphinSortFilterProxyModel; +class DolphinDirLister; +class KFileItem; +class SelectionManager; +class ViewExtensionsFactory; + +/** + * Represents one column inside the DolphinColumnViewContainer. + */ +class DolphinColumnView : public QListView +{ + Q_OBJECT + +public: + DolphinColumnView(QWidget* parent, + DolphinColumnViewContainer* container, + const KUrl& url); + virtual ~DolphinColumnView(); + + /** + * An active column is defined as column, which shows the same URL + * as indicated by the URL navigator. The active column is usually + * drawn in a lighter color. All operations are applied to this column. + */ + void setActive(bool active); + bool isActive() const; + + /** + * Sets the directory URL of the child column that is shown next to + * this column. This property is only used for a visual indication + * of the shown directory, it does not trigger a loading of the model. + */ + void setChildUrl(const KUrl& url); + KUrl childUrl() const; + + /** Sets the directory URL that is shown inside the column widget. */ + void setUrl(const KUrl& url); + + /** Returns the directory URL that is shown inside the column widget. */ + KUrl url() const; + + /** + * Updates the background color dependent from the activation state + * \a isViewActive of the column view. + */ + void updateBackground(); + + /** + * Returns the item on the position \a pos. The KFileItem instance + * is null if no item is below the position. + */ + KFileItem itemAt(const QPoint& pos) const; + + virtual void setSelectionModel(QItemSelectionModel* model); + +protected: + virtual QStyleOptionViewItem viewOptions() const; + virtual void startDrag(Qt::DropActions supportedActions); + virtual void dragEnterEvent(QDragEnterEvent* event); + virtual void dragLeaveEvent(QDragLeaveEvent* event); + virtual void dragMoveEvent(QDragMoveEvent* event); + virtual void dropEvent(QDropEvent* event); + virtual void paintEvent(QPaintEvent* event); + virtual void mousePressEvent(QMouseEvent* event); + virtual void keyPressEvent(QKeyEvent* event); + virtual void contextMenuEvent(QContextMenuEvent* event); + virtual void wheelEvent(QWheelEvent* event); + virtual void leaveEvent(QEvent* event); + virtual void currentChanged(const QModelIndex& current, const QModelIndex& previous); + +private slots: + void setZoomLevel(int level); + + void slotEntered(const QModelIndex& index); + void requestActivation(); + void updateFont(); + + void slotShowPreviewChanged(); + +private: + /** Used by DolphinColumnView::setActive(). */ + void activate(); + + /** Used by DolphinColumnView::setActive(). */ + void deactivate(); + + void updateDecorationSize(bool showPreview); + +private: + bool m_active; + DolphinColumnViewContainer* m_container; + SelectionManager* m_selectionManager; + ViewExtensionsFactory* m_extensionsFactory; + KUrl m_url; // URL of the directory that is shown + KUrl m_childUrl; // URL of the next column that is shown + + QFont m_font; + QSize m_decorationSize; + + DolphinDirLister* m_dirLister; + DolphinModel* m_dolphinModel; + DolphinSortFilterProxyModel* m_proxyModel; + + QRect m_dropRect; + + friend class DolphinColumnViewContainer; +}; + +inline bool DolphinColumnView::isActive() const +{ + return m_active; +} + +inline void DolphinColumnView::setChildUrl(const KUrl& url) +{ + m_childUrl = url; +} + +inline KUrl DolphinColumnView::childUrl() const +{ + return m_childUrl; +} + +inline void DolphinColumnView::setUrl(const KUrl& url) +{ + if (url != m_url) { + m_url = url; + //reload(); + } +} + +inline KUrl DolphinColumnView::url() const +{ + return m_url; +} + +#endif diff --git a/src/views/dolphincolumnviewcontainer.cpp b/src/views/dolphincolumnviewcontainer.cpp new file mode 100644 index 000000000..344d38d8a --- /dev/null +++ b/src/views/dolphincolumnviewcontainer.cpp @@ -0,0 +1,416 @@ +/*************************************************************************** + * Copyright (C) 2007-2009 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "dolphincolumnviewcontainer.h" + +#include "dolphin_columnmodesettings.h" + +#include "dolphincolumnview.h" +#include "dolphinviewcontroller.h" +#include "dolphinsortfilterproxymodel.h" +#include "draganddrophelper.h" +#include "settings/dolphinsettings.h" +#include "viewmodecontroller.h" + +#include <QPoint> +#include <QScrollBar> +#include <QTimeLine> +#include <QTimer> + +DolphinColumnViewContainer::DolphinColumnViewContainer(QWidget* parent, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController) : + QScrollArea(parent), + m_dolphinViewController(dolphinViewController), + m_viewModeController(viewModeController), + m_active(false), + m_index(-1), + m_contentX(0), + m_columns(), + m_emptyViewport(0), + m_animation(0), + m_dragSource(0), + m_activeUrlTimer(0) +{ + Q_ASSERT(dolphinViewController != 0); + Q_ASSERT(viewModeController != 0); + + setAcceptDrops(true); + setFocusPolicy(Qt::NoFocus); + setFrameShape(QFrame::NoFrame); + setLayoutDirection(Qt::LeftToRight); + + connect(viewModeController, SIGNAL(activationChanged(bool)), + this, SLOT(updateColumnsBackground(bool))); + + connect(horizontalScrollBar(), SIGNAL(valueChanged(int)), + this, SLOT(moveContentHorizontally(int))); + + m_animation = new QTimeLine(500, this); + connect(m_animation, SIGNAL(frameChanged(int)), horizontalScrollBar(), SLOT(setValue(int))); + + m_activeUrlTimer = new QTimer(this); + m_activeUrlTimer->setSingleShot(true); + m_activeUrlTimer->setInterval(200); + connect(m_activeUrlTimer, SIGNAL(timeout()), + this, SLOT(updateActiveUrl())); + + DolphinColumnView* column = new DolphinColumnView(viewport(), this, viewModeController->url()); + m_columns.append(column); + requestActivation(column); + + m_emptyViewport = new QFrame(viewport()); + m_emptyViewport->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken); + + updateColumnsBackground(true); + +} + +DolphinColumnViewContainer::~DolphinColumnViewContainer() +{ + delete m_dragSource; + m_dragSource = 0; +} + +KUrl DolphinColumnViewContainer::rootUrl() const +{ + return m_columns[0]->url(); +} + +QAbstractItemView* DolphinColumnViewContainer::activeColumn() const +{ + return m_columns[m_index]; +} + +void DolphinColumnViewContainer::showColumn(const KUrl& url) +{ + if (!rootUrl().isParentOf(url)) { + removeAllColumns(); + m_columns[0]->setUrl(url); + return; + } + + int columnIndex = 0; + foreach (DolphinColumnView* column, m_columns) { + if (column->url() == url) { + // the column represents already the requested URL, hence activate it + requestActivation(column); + layoutColumns(); + return; + } else if (!column->url().isParentOf(url)) { + // the column is no parent of the requested URL, hence + // just delete all remaining columns + if (columnIndex > 0) { + QList<DolphinColumnView*>::iterator start = m_columns.begin() + columnIndex; + QList<DolphinColumnView*>::iterator end = m_columns.end(); + for (QList<DolphinColumnView*>::iterator it = start; it != end; ++it) { + deleteColumn(*it); + } + m_columns.erase(start, end); + + const int maxIndex = m_columns.count() - 1; + Q_ASSERT(maxIndex >= 0); + if (m_index > maxIndex) { + m_index = maxIndex; + } + break; + } + } + ++columnIndex; + } + + // Create missing columns. Assuming that the path is "/home/peter/Temp/" and + // the target path is "/home/peter/Temp/a/b/c/", then the columns "a", "b" and + // "c" will be created. + const int lastIndex = m_columns.count() - 1; + Q_ASSERT(lastIndex >= 0); + + const KUrl& activeUrl = m_columns[lastIndex]->url(); + Q_ASSERT(activeUrl.isParentOf(url)); + Q_ASSERT(activeUrl != url); + + QString path = activeUrl.url(KUrl::AddTrailingSlash); + const QString targetPath = url.url(KUrl::AddTrailingSlash); + + columnIndex = lastIndex; + int slashIndex = path.count('/'); + bool hasSubPath = (slashIndex >= 0); + while (hasSubPath) { + const QString subPath = targetPath.section('/', slashIndex, slashIndex); + if (subPath.isEmpty()) { + hasSubPath = false; + } else { + path += subPath + '/'; + ++slashIndex; + + const KUrl childUrl = KUrl(path); + m_columns[columnIndex]->setChildUrl(childUrl); + columnIndex++; + + DolphinColumnView* column = new DolphinColumnView(viewport(), this, childUrl); + m_columns.append(column); + + // Before invoking layoutColumns() the column must be set visible temporary. + // To prevent a flickering the initial geometry is set to a hidden position. + column->setGeometry(QRect(-1, -1, 1, 1)); + column->show(); + layoutColumns(); + updateScrollBar(); + } + } + + requestActivation(m_columns[columnIndex]); +} + +void DolphinColumnViewContainer::mousePressEvent(QMouseEvent* event) +{ + m_dolphinViewController->requestActivation(); + QScrollArea::mousePressEvent(event); +} + +void DolphinColumnViewContainer::keyPressEvent(QKeyEvent* event) +{ + if (event->key() == Qt::Key_Left) { + if (m_index > 0) { + requestActivation(m_columns[m_index - 1]); + } + } else { + QScrollArea::keyPressEvent(event); + } +} + +void DolphinColumnViewContainer::resizeEvent(QResizeEvent* event) +{ + QScrollArea::resizeEvent(event); + layoutColumns(); + updateScrollBar(); + assureVisibleActiveColumn(); +} + +void DolphinColumnViewContainer::wheelEvent(QWheelEvent* event) +{ + // let Ctrl+wheel events propagate to the DolphinView for icon zooming + if ((event->modifiers() & Qt::ControlModifier) == Qt::ControlModifier) { + event->ignore(); + } else { + QScrollArea::wheelEvent(event); + } +} + +void DolphinColumnViewContainer::moveContentHorizontally(int x) +{ + m_contentX = isRightToLeft() ? +x : -x; + layoutColumns(); +} + +void DolphinColumnViewContainer::updateColumnsBackground(bool active) +{ + if (active == m_active) { + return; + } + + m_active = active; + + // dim the background of the viewport + const QPalette::ColorRole role = viewport()->backgroundRole(); + QColor background = viewport()->palette().color(role); + background.setAlpha(0); // make background transparent + + QPalette palette = viewport()->palette(); + palette.setColor(role, background); + viewport()->setPalette(palette); + + foreach (DolphinColumnView* column, m_columns) { + column->updateBackground(); + } +} + +void DolphinColumnViewContainer::updateActiveUrl() +{ + const KUrl activeUrl = m_columns[m_index]->url(); + m_dolphinViewController->requestUrlChange(activeUrl); +} + +void DolphinColumnViewContainer::layoutColumns() +{ + const int gap = 4; + + ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings(); + const int columnWidth = settings->columnWidth(); + + QRect emptyViewportRect; + if (isRightToLeft()) { + int x = viewport()->width() - columnWidth + m_contentX; + foreach (DolphinColumnView* column, m_columns) { + column->setGeometry(QRect(x, 0, columnWidth - gap, viewport()->height())); + x -= columnWidth; + } + emptyViewportRect = QRect(0, 0, x + columnWidth - gap, viewport()->height()); + } else { + int x = m_contentX; + foreach (DolphinColumnView* column, m_columns) { + column->setGeometry(QRect(x, 0, columnWidth - gap, viewport()->height())); + x += columnWidth; + } + emptyViewportRect = QRect(x, 0, viewport()->width() - x - gap, viewport()->height()); + } + + if (emptyViewportRect.isValid()) { + m_emptyViewport->show(); + m_emptyViewport->setGeometry(emptyViewportRect); + } else { + m_emptyViewport->hide(); + } +} + +void DolphinColumnViewContainer::updateScrollBar() +{ + ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings(); + const int contentWidth = m_columns.count() * settings->columnWidth(); + + horizontalScrollBar()->setPageStep(contentWidth); + horizontalScrollBar()->setRange(0, contentWidth - viewport()->width()); +} + +void DolphinColumnViewContainer::assureVisibleActiveColumn() +{ + const int viewportWidth = viewport()->width(); + const int x = activeColumn()->x(); + + ColumnModeSettings* settings = DolphinSettings::instance().columnModeSettings(); + const int width = settings->columnWidth(); + + if (x + width > viewportWidth) { + const int newContentX = m_contentX - x - width + viewportWidth; + if (isRightToLeft()) { + m_animation->setFrameRange(m_contentX, newContentX); + } else { + m_animation->setFrameRange(-m_contentX, -newContentX); + } + if (m_animation->state() != QTimeLine::Running) { + m_animation->start(); + } + } else if (x < 0) { + const int newContentX = m_contentX - x; + if (isRightToLeft()) { + m_animation->setFrameRange(m_contentX, newContentX); + } else { + m_animation->setFrameRange(-m_contentX, -newContentX); + } + if (m_animation->state() != QTimeLine::Running) { + m_animation->start(); + } + } +} + +void DolphinColumnViewContainer::requestActivation(DolphinColumnView* column) +{ + if (m_dolphinViewController->itemView() != column) { + m_dolphinViewController->setItemView(column); + } + if (focusProxy() != column) { + setFocusProxy(column); + } + + if (column->isActive()) { + assureVisibleActiveColumn(); + } else { + // Deactivate the currently active column + if (m_index >= 0) { + m_columns[m_index]->setActive(false); + } + + // Get the index of the column that should get activated + int index = 0; + foreach (DolphinColumnView* currColumn, m_columns) { + if (currColumn == column) { + break; + } + ++index; + } + + Q_ASSERT(index != m_index); + Q_ASSERT(index < m_columns.count()); + + // Activate the requested column + m_index = index; + m_columns[m_index]->setActive(true); + + assureVisibleActiveColumn(); + m_activeUrlTimer->start(); // calls slot updateActiveUrl() + } +} + +void DolphinColumnViewContainer::removeAllColumns() +{ + QList<DolphinColumnView*>::iterator start = m_columns.begin() + 1; + QList<DolphinColumnView*>::iterator end = m_columns.end(); + for (QList<DolphinColumnView*>::iterator it = start; it != end; ++it) { + deleteColumn(*it); + } + m_columns.erase(start, end); + m_index = 0; + m_columns[0]->setActive(true); + assureVisibleActiveColumn(); +} + +QPoint DolphinColumnViewContainer::columnPosition(DolphinColumnView* column, const QPoint& point) const +{ + const QPoint topLeft = column->frameGeometry().topLeft(); + return QPoint(point.x() - topLeft.x(), point.y() - topLeft.y()); +} + +void DolphinColumnViewContainer::deleteColumn(DolphinColumnView* column) +{ + if (column == 0) { + return; + } + + if (m_dolphinViewController->itemView() == column) { + m_dolphinViewController->setItemView(0); + } + // deleteWhenNotDragSource(column) does not necessarily delete column, + // and we want its preview generator destroyed immediately. + column->hide(); + // Prevent automatic destruction of column when this DolphinColumnViewContainer + // is destroyed. + column->setParent(0); + column->disconnect(); + + if (DragAndDropHelper::instance().isDragSource(column)) { + // The column is a drag source (the feature "Open folders + // during drag operations" is used). Deleting the view + // during an ongoing drag operation is not allowed, so + // this will postponed. + if (m_dragSource != 0) { + // the old stored view is obviously not the drag source anymore + m_dragSource->deleteLater(); + m_dragSource = 0; + } + column->hide(); + column->setParent(0); + column->disconnect(); + + m_dragSource = column; + } else { + column->deleteLater(); + } +} + +#include "dolphincolumnviewcontainer.moc" diff --git a/src/views/dolphincolumnviewcontainer.h b/src/views/dolphincolumnviewcontainer.h new file mode 100644 index 000000000..c67fb3cff --- /dev/null +++ b/src/views/dolphincolumnviewcontainer.h @@ -0,0 +1,147 @@ +/*************************************************************************** + * Copyright (C) 2007-2009 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef DOLPHINCOLUMNVIEWCONTAINER_H +#define DOLPHINCOLUMNVIEWCONTAINER_H + +#include "dolphinview.h" + +#include <kurl.h> + +#include <QList> +#include <QScrollArea> +#include <QString> + +class DolphinColumnView; +class DolphinViewController; +class QFrame; +class QTimeLine; +class QTimer; + +/** + * @brief Represents a container for columns represented as instances + * of DolphinColumnView. + * + * @see DolphinColumnView + */ +class DolphinColumnViewContainer : public QScrollArea +{ + Q_OBJECT + +public: + /** + * @param parent Parent widget. + * @param dolphinViewController Allows the DolphinColumnView to control the + * DolphinView in a limited way. + * @param viewModeController Controller that is used by the DolphinView + * to control the DolphinColumnView. The DolphinColumnView + * only has read access to the controller. + * @param model Directory that is shown. + */ + explicit DolphinColumnViewContainer(QWidget* parent, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController); + virtual ~DolphinColumnViewContainer(); + + KUrl rootUrl() const; + + QAbstractItemView* activeColumn() const; + + /** + * Shows the column which represents the URL \a url. If the column + * is already shown, it gets activated, otherwise it will be created. + */ + void showColumn(const KUrl& url); + +protected: + virtual void mousePressEvent(QMouseEvent* event); + virtual void keyPressEvent(QKeyEvent* event); + virtual void resizeEvent(QResizeEvent* event); + virtual void wheelEvent(QWheelEvent* event); + +private slots: + /** + * Moves the content of the columns view to represent + * the scrollbar position \a x. + */ + void moveContentHorizontally(int x); + + /** + * Updates the background color of the columns to respect + * the current activation state \a active. + */ + void updateColumnsBackground(bool active); + + /** + * Tells the Dolphin controller to update the active URL + * to m_activeUrl. The slot is called asynchronously with a + * small delay, as this prevents a flickering when a directory + * from an inactive column gets selected. + */ + void updateActiveUrl(); + +private: + void layoutColumns(); + void updateScrollBar(); + + /** + * Assures that the currently active column is fully visible + * by adjusting the horizontal position of the content. + */ + void assureVisibleActiveColumn(); + + /** + * Request the activation for the column \a column. It is assured + * that the columns gets fully visible by adjusting the horizontal + * position of the content. + */ + void requestActivation(DolphinColumnView* column); + + /** Removes all columns except of the root column. */ + void removeAllColumns(); + + /** + * Returns the position of the point \a point relative to the column + * \a column. + */ + QPoint columnPosition(DolphinColumnView* column, const QPoint& point) const; + + /** + * Deletes the column. If the itemview of the controller is set to the column, + * the controllers itemview is set to 0. + */ + void deleteColumn(DolphinColumnView* column); + +private: + DolphinViewController* m_dolphinViewController; + const ViewModeController* m_viewModeController; + bool m_active; + int m_index; + int m_contentX; + QList<DolphinColumnView*> m_columns; + QFrame* m_emptyViewport; + QTimeLine* m_animation; + QAbstractItemView* m_dragSource; + + QTimer* m_activeUrlTimer; + + friend class DolphinColumnView; +}; + +#endif diff --git a/src/views/dolphindetailsview.cpp b/src/views/dolphindetailsview.cpp new file mode 100644 index 000000000..961bd7872 --- /dev/null +++ b/src/views/dolphindetailsview.cpp @@ -0,0 +1,1113 @@ +/*************************************************************************** + * Copyright (C) 2006 by Peter Penz ([email protected]) * + * Copyright (C) 2008 by Simon St. James ([email protected]) * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "dolphindetailsview.h" + +#include "additionalinfoaccessor.h" +#include "dolphinmodel.h" +#include "dolphinviewcontroller.h" +#include "dolphinfileitemdelegate.h" +#include "settings/dolphinsettings.h" +#include "dolphinsortfilterproxymodel.h" +#include "dolphinviewautoscroller.h" +#include "draganddrophelper.h" +#include "viewextensionsfactory.h" +#include "viewmodecontroller.h" +#include "viewproperties.h" +#include "zoomlevelinfo.h" + +#include "dolphin_detailsmodesettings.h" +#include "dolphin_generalsettings.h" + +#include <kdirmodel.h> +#include <klocale.h> +#include <kmenu.h> + +#include <QAction> +#include <QApplication> +#include <QHeaderView> +#include <QRubberBand> +#include <QPainter> +#include <QScrollBar> + +DolphinDetailsView::DolphinDetailsView(QWidget* parent, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController, + DolphinSortFilterProxyModel* proxyModel) : + QTreeView(parent), + m_autoResize(true), + m_expandingTogglePressed(false), + m_keyPressed(false), + m_useDefaultIndexAt(true), + m_ignoreScrollTo(false), + m_dolphinViewController(dolphinViewController), + m_viewModeController(viewModeController), + m_extensionsFactory(0), + m_expandableFoldersAction(0), + m_expandedUrls(), + m_font(), + m_decorationSize(), + m_band() +{ + const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + Q_ASSERT(settings != 0); + Q_ASSERT(dolphinViewController != 0); + Q_ASSERT(viewModeController != 0); + + setLayoutDirection(Qt::LeftToRight); + setAcceptDrops(true); + setSortingEnabled(true); + setUniformRowHeights(true); + setSelectionBehavior(SelectItems); + setDragDropMode(QAbstractItemView::DragDrop); + setDropIndicatorShown(false); + setAlternatingRowColors(true); + setRootIsDecorated(settings->expandableFolders()); + setItemsExpandable(settings->expandableFolders()); + setEditTriggers(QAbstractItemView::NoEditTriggers); + setModel(proxyModel); + + setMouseTracking(true); + + const ViewProperties props(viewModeController->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&)), + dolphinViewController, SLOT(requestTab(const QModelIndex&))); + if (KGlobalSettings::singleClick()) { + connect(this, SIGNAL(clicked(const QModelIndex&)), + dolphinViewController, SLOT(triggerItem(const QModelIndex&))); + } else { + connect(this, SIGNAL(doubleClicked(const QModelIndex&)), + dolphinViewController, SLOT(triggerItem(const QModelIndex&))); + } + + connect(this, SIGNAL(entered(const QModelIndex&)), + this, SLOT(slotEntered(const QModelIndex&))); + connect(this, SIGNAL(viewportEntered()), + dolphinViewController, SLOT(emitViewportEntered())); + connect(viewModeController, SIGNAL(zoomLevelChanged(int)), + this, SLOT(setZoomLevel(int))); + connect(dolphinViewController->view(), SIGNAL(additionalInfoChanged()), + this, SLOT(updateColumnVisibility())); + connect(viewModeController, SIGNAL(activationChanged(bool)), + this, SLOT(slotActivationChanged(bool))); + + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); + } else { + m_font = QFont(settings->fontFamily(), + qRound(settings->fontSize()), + settings->fontWeight(), + settings->italicFont()); + m_font.setPointSizeF(settings->fontSize()); + } + + setVerticalScrollMode(QTreeView::ScrollPerPixel); + setHorizontalScrollMode(QTreeView::ScrollPerPixel); + + const DolphinView* view = dolphinViewController->view(); + connect(view, SIGNAL(showPreviewChanged()), + this, SLOT(slotShowPreviewChanged())); + + + 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))); + + connect(this, SIGNAL(expanded(const QModelIndex&)), this, SLOT(slotExpanded(const QModelIndex&))); + connect(this, SIGNAL(collapsed(const QModelIndex&)), this, SLOT(slotCollapsed(const QModelIndex&))); + + updateDecorationSize(view->showPreview()); + + m_extensionsFactory = new ViewExtensionsFactory(this, dolphinViewController, viewModeController); + m_extensionsFactory->fileItemDelegate()->setMinimizedNameColumn(true); + m_extensionsFactory->setAutoFolderExpandingEnabled(settings->expandableFolders()); +} + +DolphinDetailsView::~DolphinDetailsView() +{ +} + +QSet<KUrl> DolphinDetailsView::expandedUrls() const +{ + return m_expandedUrls; +} + +QRegion DolphinDetailsView::visualRegionForSelection(const QItemSelection& selection) const +{ + // We have to make sure that the visualRect of each model index is inside the region. + // QTreeView::visualRegionForSelection does not do it right because it assumes implicitly + // that all visualRects have the same width, which is in general not the case here. + QRegion selectionRegion; + const QModelIndexList indexes = selection.indexes(); + + foreach(const QModelIndex& index, indexes) { + selectionRegion += visualRect(index); + } + + return selectionRegion; +} + +bool DolphinDetailsView::event(QEvent* event) +{ + switch (event->type()) { + case QEvent::Polish: + header()->setResizeMode(QHeaderView::Interactive); + updateColumnVisibility(); + break; + + case QEvent::FocusOut: + // If a key-press triggers an action that e. g. opens a dialog, the + // widget gets no key-release event. Assure that the pressed state + // is reset to prevent accidently setting the current index during a selection. + m_keyPressed = false; + break; + + default: + break; + } + + return QTreeView::event(event); +} + +QStyleOptionViewItem DolphinDetailsView::viewOptions() const +{ + QStyleOptionViewItem viewOptions = QTreeView::viewOptions(); + viewOptions.font = m_font; + viewOptions.fontMetrics = QFontMetrics(m_font); + viewOptions.showDecorationSelected = true; + viewOptions.decorationSize = m_decorationSize; + return viewOptions; +} + +void DolphinDetailsView::contextMenuEvent(QContextMenuEvent* event) +{ + QTreeView::contextMenuEvent(event); + + DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + m_expandableFoldersAction->setChecked(settings->expandableFolders()); + m_dolphinViewController->triggerContextMenuRequest(event->pos(), + QList<QAction*>() << m_expandableFoldersAction); +} + +void DolphinDetailsView::mousePressEvent(QMouseEvent* event) +{ + m_dolphinViewController->requestActivation(); + + const QModelIndex current = currentIndex(); + QTreeView::mousePressEvent(event); + + m_expandingTogglePressed = isAboveExpandingToggle(event->pos()); + + const QModelIndex index = indexAt(event->pos()); + const bool updateState = index.isValid() && + (index.column() == DolphinModel::Name) && + (event->button() == Qt::LeftButton); + if (updateState) { + setState(QAbstractItemView::DraggingState); + } + + if (!index.isValid() || (index.column() != DolphinModel::Name)) { + // the mouse press is done somewhere outside the filename column + if (QApplication::mouseButtons() & Qt::MidButton) { + m_dolphinViewController->replaceUrlByClipboard(); + } + + const Qt::KeyboardModifiers mod = QApplication::keyboardModifiers(); + if (!m_expandingTogglePressed && !(mod & Qt::ShiftModifier) && !(mod & Qt::ControlModifier)) { + clearSelection(); + } + + // 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(); + } + } +} + +void DolphinDetailsView::mouseMoveEvent(QMouseEvent* event) +{ + if (m_expandingTogglePressed) { + // Per default QTreeView starts either a selection or a drag operation when dragging + // the expanding toggle button (Qt-issue - see TODO comment in DolphinIconsView::mousePressEvent()). + // Turn off this behavior in Dolphin to stay predictable: + setState(QAbstractItemView::NoState); + return; + } + + if (m_band.show) { + const QPoint mousePos = event->pos(); + const QModelIndex index = indexAt(mousePos); + if (!index.isValid()) { + // the destination of the selection rectangle is above the viewport. In this + // case QTreeView does no selection at all, which is not the wanted behavior + // in Dolphin -> select all items within the elastic band rectangle + updateElasticBandSelection(); + } + + // TODO: enable QTreeView::mouseMoveEvent(event) again, as soon + // as the Qt-issue #199631 has been fixed. + // QTreeView::mouseMoveEvent(event); + QAbstractItemView::mouseMoveEvent(event); + updateElasticBand(); + } else { + // TODO: enable QTreeView::mouseMoveEvent(event) again, as soon + // as the Qt-issue #199631 has been fixed. + // QTreeView::mouseMoveEvent(event); + QAbstractItemView::mouseMoveEvent(event); + } +} + +void DolphinDetailsView::mouseReleaseEvent(QMouseEvent* event) +{ + if (!m_expandingTogglePressed) { + 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::startDrag(Qt::DropActions supportedActions) +{ + DragAndDropHelper::instance().startDrag(this, supportedActions, m_dolphinViewController); + m_band.show = false; +} + +void DolphinDetailsView::dragEnterEvent(QDragEnterEvent* event) +{ + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { + event->acceptProposedAction(); + } + + if (m_band.show) { + updateElasticBand(); + m_band.show = false; + } +} + +void DolphinDetailsView::dragLeaveEvent(QDragLeaveEvent* event) +{ + QTreeView::dragLeaveEvent(event); + setDirtyRegion(m_dropRect); +} + +void DolphinDetailsView::dragMoveEvent(QDragMoveEvent* event) +{ + QTreeView::dragMoveEvent(event); + + // TODO: remove this code when the issue #160611 is solved in Qt 4.4 + setDirtyRegion(m_dropRect); + const QModelIndex index = indexAt(event->pos()); + if (index.isValid() && (index.column() == DolphinModel::Name)) { + const KFileItem item = m_dolphinViewController->itemForIndex(index); + if (!item.isNull() && item.isDir()) { + m_dropRect = visualRect(index); + } else { + m_dropRect.setSize(QSize()); // set as invalid + } + setDirtyRegion(m_dropRect); + } + + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { + // accept url drops, independently from the destination item + event->acceptProposedAction(); + } +} + +void DolphinDetailsView::dropEvent(QDropEvent* event) +{ + const QModelIndex index = indexAt(event->pos()); + KFileItem item; + if (index.isValid() && (index.column() == DolphinModel::Name)) { + item = m_dolphinViewController->itemForIndex(index); + } + m_dolphinViewController->indicateDroppedUrls(item, m_viewModeController->url(), event); + QTreeView::dropEvent(event); +} + +void DolphinDetailsView::paintEvent(QPaintEvent* event) +{ + 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::keyPressEvent(QKeyEvent* event) +{ + // If the Control modifier is pressed, a multiple selection + // is done and DolphinDetailsView::currentChanged() may not + // not change the selection in a custom way. + m_keyPressed = !(event->modifiers() & Qt::ControlModifier); + + QTreeView::keyPressEvent(event); + m_dolphinViewController->handleKeyPressEvent(event); +} + +void DolphinDetailsView::keyReleaseEvent(QKeyEvent* event) +{ + QTreeView::keyReleaseEvent(event); + m_keyPressed = false; +} + +void DolphinDetailsView::resizeEvent(QResizeEvent* event) +{ + QTreeView::resizeEvent(event); + if (m_autoResize) { + resizeColumns(); + } +} + +void DolphinDetailsView::wheelEvent(QWheelEvent* event) +{ + const int step = m_decorationSize.height(); + verticalScrollBar()->setSingleStep(step); + QTreeView::wheelEvent(event); +} + +void DolphinDetailsView::currentChanged(const QModelIndex& current, const QModelIndex& previous) +{ + QTreeView::currentChanged(current, previous); + m_extensionsFactory->handleCurrentIndexChange(current, previous); + + // Stay consistent with QListView: When changing the current index by key presses, + // also change the selection. + if (m_keyPressed) { + setCurrentIndex(current); + } + + // If folders are expanded, the width which is available for editing may have changed + // because it depends on the level of the current item in the folder hierarchy. + adjustMaximumSizeForEditing(current); +} + +bool DolphinDetailsView::eventFilter(QObject* watched, QEvent* event) +{ + if ((watched == viewport()) && (event->type() == QEvent::Leave)) { + // if the mouse is above an item and moved very fast outside the widget, + // no viewportEntered() signal might be emitted although the mouse has been moved + // above the viewport + m_dolphinViewController->emitViewportEntered(); + } + + return QTreeView::eventFilter(watched, event); +} + +QModelIndex DolphinDetailsView::indexAt(const QPoint& point) const +{ + // the blank portion of the name column counts as empty space + const QModelIndex index = QTreeView::indexAt(point); + const bool isAboveEmptySpace = !m_useDefaultIndexAt && + (index.column() == KDirModel::Name) && !visualRect(index).contains(point); + return isAboveEmptySpace ? QModelIndex() : index; +} + +QRect DolphinDetailsView::visualRect(const QModelIndex& index) const +{ + QRect rect = QTreeView::visualRect(index); + const KFileItem item = m_dolphinViewController->itemForIndex(index); + if (!item.isNull()) { + const int width = DolphinFileItemDelegate::nameColumnWidth(item.text(), viewOptions()); + rect.setWidth(width); + } + + return rect; +} + +void DolphinDetailsView::setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command) +{ + // We must override setSelection() as Qt calls it internally and when this happens + // we must ensure that the default indexAt() is used. + if (!m_band.show) { + m_useDefaultIndexAt = true; + QTreeView::setSelection(rect, command); + m_useDefaultIndexAt = false; + } else { + // Use our own elastic band selection algorithm + updateElasticBandSelection(); + } +} + +void DolphinDetailsView::scrollTo(const QModelIndex & index, ScrollHint hint) +{ + if (!m_ignoreScrollTo) { + QTreeView::scrollTo(index, hint); + } +} + +void DolphinDetailsView::setSortIndicatorSection(DolphinView::Sorting sorting) +{ + header()->setSortIndicator(sorting, header()->sortIndicatorOrder()); +} + +void DolphinDetailsView::setSortIndicatorOrder(Qt::SortOrder sortOrder) +{ + header()->setSortIndicator(header()->sortIndicatorSection(), sortOrder); +} + +void DolphinDetailsView::synchronizeSortingState(int column) +{ + // 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_dolphinViewController->indicateSortingChange(sorting); + m_dolphinViewController->indicateSortOrderChange(sortOrder); +} + +void DolphinDetailsView::slotEntered(const QModelIndex& index) +{ + if (index.column() == DolphinModel::Name) { + m_dolphinViewController->emitItemEntered(index); + } else { + m_dolphinViewController->emitViewportEntered(); + } +} + +void DolphinDetailsView::updateElasticBand() +{ + 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); + } +} + +QRect DolphinDetailsView::elasticBandRect() const +{ + 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::setZoomLevel(int level) +{ + const int size = ZoomLevelInfo::iconSizeForZoomLevel(level); + DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + + const bool showPreview = m_dolphinViewController->view()->showPreview(); + if (showPreview) { + settings->setPreviewSize(size); + } else { + settings->setIconSize(size); + } + + updateDecorationSize(showPreview); +} + +void DolphinDetailsView::slotShowPreviewChanged() +{ + const DolphinView* view = m_dolphinViewController->view(); + updateDecorationSize(view->showPreview()); +} + +void DolphinDetailsView::configureSettings(const QPoint& pos) +{ + KMenu popup(this); + popup.addTitle(i18nc("@title:menu", "Columns")); + + // add checkbox items for each column + QHeaderView* headerView = header(); + const int columns = model()->columnCount(); + for (int i = 0; i < columns; ++i) { + const int logicalIndex = headerView->logicalIndex(i); + const QString text = model()->headerData(logicalIndex, Qt::Horizontal).toString(); + if (!text.isEmpty()) { + QAction* action = popup.addAction(text); + action->setCheckable(true); + action->setChecked(!headerView->isSectionHidden(logicalIndex)); + action->setData(logicalIndex); + action->setEnabled(logicalIndex != DolphinModel::Name); + } + } + popup.addSeparator(); + + QAction* activatedAction = popup.exec(header()->mapToGlobal(pos)); + if (activatedAction != 0) { + const bool show = activatedAction->isChecked(); + const int columnIndex = activatedAction->data().toInt(); + + KFileItemDelegate::InformationList list = m_dolphinViewController->view()->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); + } + + m_dolphinViewController->indicateAdditionalInfoChange(list); + setColumnHidden(columnIndex, !show); + resizeColumns(); + } +} + +void DolphinDetailsView::updateColumnVisibility() +{ + QHeaderView* headerView = header(); + disconnect(headerView, SIGNAL(sectionMoved(int, int, int)), + this, SLOT(saveColumnPositions())); + + const DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + const QList<int> columnPositions = settings->columnPositions(); + + const KFileItemDelegate::InformationList list = m_dolphinViewController->view()->additionalInfo(); + for (int i = DolphinModel::Name; i < DolphinModel::ExtraColumnCount; ++i) { + const KFileItemDelegate::Information info = infoForColumn(i); + const bool hide = !list.contains(info) && (i != DolphinModel::Name); + if (isColumnHidden(i) != hide) { + setColumnHidden(i, hide); + } + + // If the list columnPositions has been written by an older Dolphin version, + // its length might be smaller than DolphinModel::ExtraColumnCount. Therefore, + // we have to check if item number i exists before accessing it. + if (i < columnPositions.length()) { + const int position = columnPositions[i]; + + // The position might be outside the correct range if the list columnPositions + // has been written by a newer Dolphin version with more columns. + if (position < DolphinModel::ExtraColumnCount) { + const int from = headerView->visualIndex(i); + headerView->moveSection(from, position); + } + } + } + + resizeColumns(); + + connect(headerView, SIGNAL(sectionMoved(int, int, int)), + this, SLOT(saveColumnPositions())); +} + +void DolphinDetailsView::saveColumnPositions() +{ + QList<int> columnPositions; + for (int i = DolphinModel::Name; i < DolphinModel::ExtraColumnCount; ++i) { + columnPositions.append(header()->visualIndex(i)); + } + + DetailsModeSettings* settings = DolphinSettings::instance().detailsModeSettings(); + settings->setColumnPositions(columnPositions); +} + +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(); + } + + adjustMaximumSizeForEditing(currentIndex()); +} + +void DolphinDetailsView::slotActivationChanged(bool active) +{ + setAlternatingRowColors(active); +} + +void DolphinDetailsView::disableAutoResizing() +{ + m_autoResize = false; +} + +void DolphinDetailsView::requestActivation() +{ + m_dolphinViewController->requestActivation(); +} + +void DolphinDetailsView::slotGlobalSettingsChanged(int category) +{ + Q_UNUSED(category); + + 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_dolphinViewController, SLOT(triggerItem(QModelIndex))); + disconnect(this, SIGNAL(doubleClicked(QModelIndex)), m_dolphinViewController, SLOT(triggerItem(QModelIndex))); + if (KGlobalSettings::singleClick()) { + connect(this, SIGNAL(clicked(QModelIndex)), m_dolphinViewController, SLOT(triggerItem(QModelIndex))); + } else { + connect(this, SIGNAL(doubleClicked(QModelIndex)), m_dolphinViewController, SLOT(triggerItem(QModelIndex))); + } +} + +void DolphinDetailsView::updateElasticBandSelection() +{ + if (!m_band.show) { + return; + } + + // Ensure the elastic band itself is up-to-date, in + // case we are being called due to e.g. a drag event. + updateElasticBand(); + + // Clip horizontally to the name column, as some filenames will be + // longer than the column. We don't clip vertically as origin + // may be above or below the current viewport area. + const int nameColumnX = header()->sectionPosition(DolphinModel::Name); + const int nameColumnWidth = header()->sectionSize(DolphinModel::Name); + QRect selRect = elasticBandRect().normalized(); + QRect nameColumnArea(nameColumnX, selRect.y(), nameColumnWidth, selRect.height()); + selRect = nameColumnArea.intersect(selRect).normalized(); + // Get the last elastic band rectangle, expressed in viewpoint coordinates. + const QPoint scrollPos(horizontalScrollBar()->value(), verticalScrollBar()->value()); + QRect oldSelRect = QRect(m_band.lastSelectionOrigin - scrollPos, m_band.lastSelectionDestination - scrollPos).normalized(); + + if (selRect.isNull()) { + selectionModel()->select(m_band.originalSelection, QItemSelectionModel::ClearAndSelect); + m_band.ignoreOldInfo = true; + return; + } + + if (!m_band.ignoreOldInfo) { + // Do some quick checks to see if we can rule out the need to + // update the selection. + Q_ASSERT(uniformRowHeights()); + QModelIndex dummyIndex = model()->index(0, 0); + if (!dummyIndex.isValid()) { + // No items in the model presumably. + return; + } + + // If the elastic band does not cover the same rows as before, we'll + // need to re-check, and also invalidate the old item distances. + const int rowHeight = QTreeView::rowHeight(dummyIndex); + const bool coveringSameRows = + (selRect.top() / rowHeight == oldSelRect.top() / rowHeight) && + (selRect.bottom() / rowHeight == oldSelRect.bottom() / rowHeight); + if (coveringSameRows) { + // Covering the same rows, but have we moved far enough horizontally + // that we might have (de)selected some other items? + const bool itemSelectionChanged = + ((selRect.left() > oldSelRect.left()) && + (selRect.left() > m_band.insideNearestLeftEdge)) || + ((selRect.left() < oldSelRect.left()) && + (selRect.left() <= m_band.outsideNearestLeftEdge)) || + ((selRect.right() < oldSelRect.right()) && + (selRect.left() >= m_band.insideNearestRightEdge)) || + ((selRect.right() > oldSelRect.right()) && + (selRect.right() >= m_band.outsideNearestRightEdge)); + + if (!itemSelectionChanged) { + return; + } + } + } else { + // This is the only piece of optimization data that needs to be explicitly + // discarded. + m_band.lastSelectionOrigin = QPoint(); + m_band.lastSelectionDestination = QPoint(); + oldSelRect = selRect; + } + + // Do the selection from scratch. Force a update of the horizontal distances info. + m_band.insideNearestLeftEdge = nameColumnX + nameColumnWidth + 1; + m_band.insideNearestRightEdge = nameColumnX - 1; + m_band.outsideNearestLeftEdge = nameColumnX - 1; + m_band.outsideNearestRightEdge = nameColumnX + nameColumnWidth + 1; + + // Include the old selection rect as well, so we can deselect + // items that were inside it but not in the new selRect. + const QRect boundingRect = selRect.united(oldSelRect).normalized(); + if (boundingRect.isNull()) { + return; + } + + // Get the index of the item in this row in the name column. + // TODO - would this still work if the columns could be re-ordered? + QModelIndex startIndex = QTreeView::indexAt(boundingRect.topLeft()); + if (startIndex.parent().isValid()) { + startIndex = startIndex.parent().child(startIndex.row(), KDirModel::Name); + } else { + startIndex = model()->index(startIndex.row(), KDirModel::Name); + } + if (!startIndex.isValid()) { + selectionModel()->select(m_band.originalSelection, QItemSelectionModel::ClearAndSelect); + m_band.ignoreOldInfo = true; + return; + } + + // Go through all indexes between the top and bottom of boundingRect, and + // update the selection. + const int verticalCutoff = boundingRect.bottom(); + QModelIndex currIndex = startIndex; + QModelIndex lastIndex; + bool allItemsInBoundDone = false; + + // Calling selectionModel()->select(...) for each item that needs to be + // toggled is slow as each call emits selectionChanged(...) so store them + // and do the selection toggle in one batch. + QItemSelection itemsToToggle; + // QItemSelection's deal with continuous ranges of indexes better than + // single indexes, so try to portion items that need to be toggled into ranges. + bool formingToggleIndexRange = false; + QModelIndex toggleIndexRangeBegin = QModelIndex(); + + do { + QRect currIndexRect = visualRect(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); + + // The width of the space which is available for editing has changed + // because of the (dis)appearance of the expanding toggles + adjustMaximumSizeForEditing(currentIndex()); +} + +void DolphinDetailsView::slotExpanded(const QModelIndex& index) +{ + KFileItem item = m_dolphinViewController->itemForIndex(index); + if (!item.isNull()) { + m_expandedUrls.insert(item.url()); + } +} + +void DolphinDetailsView::slotCollapsed(const QModelIndex& index) +{ + KFileItem item = m_dolphinViewController->itemForIndex(index); + if (!item.isNull()) { + m_expandedUrls.remove(item.url()); + } +} + +void DolphinDetailsView::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end) +{ + removeExpandedIndexes(parent, start, end); + QTreeView::rowsAboutToBeRemoved(parent, start, end); +} + +void DolphinDetailsView::removeExpandedIndexes(const QModelIndex& parent, int start, int end) +{ + if (m_expandedUrls.isEmpty()) { + return; + } + + for (int row = start; row <= end; row++) { + const QModelIndex index = model()->index(row, 0, parent); + if (isExpanded(index)) { + slotCollapsed(index); + removeExpandedIndexes(index, 0, model()->rowCount(index) - 1); + } + } +} + +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); + + doItemsLayout(); +} + +KFileItemDelegate::Information DolphinDetailsView::infoForColumn(int columnIndex) const +{ + return AdditionalInfoAccessor::instance().keyForColumn(columnIndex); +} + +void DolphinDetailsView::resizeColumns() +{ + // Using the resize mode QHeaderView::ResizeToContents is too slow (it takes + // around 3 seconds for each (!) resize operation when having > 10000 items). + // This gets a problem especially when opening large directories, where several + // resize operations are received for showing the currently available items during + // loading (the application hangs around 20 seconds when loading > 10000 items). + + QHeaderView* headerView = header(); + QFontMetrics fontMetrics(viewport()->font()); + + // Calculate the required with for each column and store it in columnWidth[] + int columnWidth[DolphinModel::ExtraColumnCount]; + const int defaultWidth = fontMetrics.width("xxxxxxxxxx"); + + for (int i = 0; i < DolphinModel::ExtraColumnCount; ++i) { + const int logicalIndex = headerView->logicalIndex(i); + const QString headline = model()->headerData(logicalIndex, Qt::Horizontal).toString(); + const int headlineWidth = fontMetrics.width(headline); + + columnWidth[i] = qMax(defaultWidth, headlineWidth); + } + + const int defaultSizeWidth = fontMetrics.width("00000 Items"); + if (defaultSizeWidth > columnWidth[DolphinModel::Size]) { + columnWidth[DolphinModel::Size] = defaultSizeWidth; + } + + const int defaultTimeWidth = fontMetrics.width("0000-00-00 00:00"); + if (defaultTimeWidth > columnWidth[DolphinModel::ModifiedTime]) { + columnWidth[DolphinModel::ModifiedTime] = defaultTimeWidth; + } + + int requiredWidth = 0; + for (int i = KDirModel::Size; i < DolphinModel::ExtraColumnCount; ++i) { + if (!isColumnHidden(i)) { + columnWidth[i] += 20; // provide a default gap + requiredWidth += columnWidth[i]; + headerView->resizeSection(i, columnWidth[i]); + } + } + + // Resize the name column in a way that the whole available width is used + columnWidth[KDirModel::Name] = viewport()->width() - requiredWidth; + + 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; + } + } + } + + headerView->resizeSection(KDirModel::Name, columnWidth[KDirModel::Name]); +} + +bool DolphinDetailsView::isAboveExpandingToggle(const QPoint& pos) const +{ + // QTreeView offers no public API to get the information whether an index has an + // expanding toggle and what boundaries the toggle has. The following approach + // also assumes a toggle for file items. + if (itemsExpandable()) { + const QModelIndex index = QTreeView::indexAt(pos); + if (index.isValid() && (index.column() == KDirModel::Name)) { + QRect rect = visualRect(index); + const int toggleSize = rect.height(); + if (isRightToLeft()) { + rect.moveRight(rect.right()); + } else { + rect.moveLeft(rect.x() - toggleSize); + } + rect.setWidth(toggleSize); + + QStyleOption opt; + opt.initFrom(this); + opt.rect = rect; + rect = style()->subElementRect(QStyle::SE_TreeViewDisclosureItem, &opt, this); + + return rect.contains(pos); + } + } + return false; +} + +void DolphinDetailsView::adjustMaximumSizeForEditing(const QModelIndex& index) +{ + // Make sure that the full width of the "Name" column is available for "Rename Inline" + m_extensionsFactory->fileItemDelegate()->setMaximumSize(QTreeView::visualRect(index).size()); +} + +DolphinDetailsView::ElasticBand::ElasticBand() : + show(false), + origin(), + destination(), + lastSelectionOrigin(), + lastSelectionDestination(), + ignoreOldInfo(true), + outsideNearestLeftEdge(0), + outsideNearestRightEdge(0), + insideNearestLeftEdge(0), + insideNearestRightEdge(0) +{ +} + +#include "dolphindetailsview.moc" diff --git a/src/views/dolphindetailsview.h b/src/views/dolphindetailsview.h new file mode 100644 index 000000000..3ac08d337 --- /dev/null +++ b/src/views/dolphindetailsview.h @@ -0,0 +1,287 @@ +/*************************************************************************** + * Copyright (C) 2006 by Peter Penz ([email protected]) * + * Copyright (C) 2008 by Simon St. James ([email protected]) * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef DOLPHINDETAILSVIEW_H +#define DOLPHINDETAILSVIEW_H + +#include <QTreeView> +#include <libdolphin_export.h> +#include <views/dolphinview.h> + +class DolphinViewController; +class DolphinSortFilterProxyModel; +class ViewExtensionsFactory; + +/** + * @brief Represents the details view which shows the name, size, + * date, permissions, owner and group of an item. + * + * The width of the columns is automatically adjusted in a way + * that full available width of the view is used by stretching the width + * of the name column. + */ +class LIBDOLPHINPRIVATE_EXPORT DolphinDetailsView : public QTreeView +{ + Q_OBJECT + +public: + /** + * @param parent Parent widget. + * @param dolphinViewController Allows the DolphinDetailsView to control the + * DolphinView in a limited way. + * @param viewModeController Controller that is used by the DolphinView + * to control the DolphinDetailsView. The DolphinDetailsView + * only has read access to the controller. + * @param model Directory that is shown. + */ + explicit DolphinDetailsView(QWidget* parent, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController, + DolphinSortFilterProxyModel* model); + virtual ~DolphinDetailsView(); + + /** + * Returns a set containing the URLs of all expanded items. + */ + QSet<KUrl> expandedUrls() const; + + virtual QRegion visualRegionForSelection(const QItemSelection& selection) const; + +protected: + virtual bool event(QEvent* event); + virtual QStyleOptionViewItem viewOptions() const; + virtual void contextMenuEvent(QContextMenuEvent* event); + virtual void mousePressEvent(QMouseEvent* event); + virtual void mouseMoveEvent(QMouseEvent* event); + virtual void mouseReleaseEvent(QMouseEvent* event); + virtual void startDrag(Qt::DropActions supportedActions); + virtual void dragEnterEvent(QDragEnterEvent* event); + virtual void dragLeaveEvent(QDragLeaveEvent* event); + virtual void dragMoveEvent(QDragMoveEvent* event); + virtual void dropEvent(QDropEvent* event); + virtual void paintEvent(QPaintEvent* event); + virtual void keyPressEvent(QKeyEvent* event); + virtual void keyReleaseEvent(QKeyEvent* event); + virtual void resizeEvent(QResizeEvent* event); + virtual void wheelEvent(QWheelEvent* event); + virtual void currentChanged(const QModelIndex& current, const QModelIndex& previous); + virtual bool eventFilter(QObject* watched, QEvent* event); + virtual QModelIndex indexAt (const QPoint& point) const; + virtual QRect visualRect(const QModelIndex& index) const; + virtual void setSelection(const QRect& rect, QItemSelectionModel::SelectionFlags command); + virtual void scrollTo(const QModelIndex& index, ScrollHint hint = EnsureVisible); + +private slots: + /** + * Sets the sort indicator section of the header view + * corresponding to \a sorting. + */ + void setSortIndicatorSection(DolphinView::Sorting sorting); + + /** + * Sets the sort indicator order of the header view + * corresponding to \a sortOrder. + */ + void setSortIndicatorOrder(Qt::SortOrder sortOrder); + + /** + * Synchronizes the sorting state of the Dolphin menu 'View -> Sort' + * with the current state of the details view. + * @param column Index of the current sorting column. + */ + void synchronizeSortingState(int column); + + /** + * Is invoked when the mouse cursor has entered an item. The controller + * gets informed to emit the itemEntered() signal if the mouse cursor + * is above the name column. Otherwise the controller gets informed + * to emit the itemViewportEntered() signal (all other columns should + * behave as viewport area). + */ + void slotEntered(const QModelIndex& index); + + /** + * Updates the destination \a destination from + * the elastic band to the current mouse position and triggers + * an update. + */ + void updateElasticBand(); + + /** + * Returns the rectangle for the elastic band dependent from the + * origin \a origin, the current destination + * \a destination and the viewport position. + */ + QRect elasticBandRect() const; + + void setZoomLevel(int level); + + void slotShowPreviewChanged(); + + /** + * Opens a context menu at the position \a pos and allows to + * configure the visibility of the header columns and whether + * expandable folders should be shown. + */ + void configureSettings(const QPoint& pos); + + /** + * Updates the visibilty state of columns and their order. + */ + void updateColumnVisibility(); + + /** + * Saves order of the columns as global setting. + */ + void saveColumnPositions(); + + /** + * Disables the automatical resizing of columns, if the user has resized the columns + * with the mouse. + */ + void slotHeaderSectionResized(int logicalIndex, int oldSize, int newSize); + + /** + * Changes the alternating row colors setting depending from + * the activation state \a active. + */ + void slotActivationChanged(bool active); + + /** + * Disables the automatical resizing of the columns. Per default all columns + * are resized to use the maximum available width of the view as good as possible. + */ + void disableAutoResizing(); + + void requestActivation(); + + void slotGlobalSettingsChanged(int category); + + /** + * If the elastic band is currently shown, update the elastic band based on + * the current mouse position and ensure that the selection is the set of items + * intersecting it. + */ + void updateElasticBandSelection(); + + /** + * If \a expandable is true, the details view acts as tree view. + * The current expandable state is remembered in the settings. + */ + void setFoldersExpandable(bool expandable); + + /** + * These slots update the list of expanded items. + */ + void slotExpanded(const QModelIndex& index); + void slotCollapsed(const QModelIndex& index); + +protected slots: + + virtual void rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end); + +private: + /** + * Removes the URLs corresponding to the children of \a index in the rows + * between \a start and \a end inclusive from the set of expanded URLs. + */ + void removeExpandedIndexes(const QModelIndex& parent, int start, int end); + + /** + * Updates the size of the decoration dependent on the + * icon size of the DetailsModeSettings. The controller + * will get informed about possible zoom in/zoom out + * operations. + */ + void updateDecorationSize(bool showPreview); + + KFileItemDelegate::Information infoForColumn(int columnIndex) const; + + /** + * Resizes all columns in a way to use the whole available width of the view. + */ + void resizeColumns(); + + /** + * Returns true, if \a pos is within the expanding toggle of a tree. + */ + bool isAboveExpandingToggle(const QPoint& pos) const; + + /** + * Sets the maximum size available for editing in the delegate. + */ + void adjustMaximumSizeForEditing(const QModelIndex& index); + +private: + bool m_autoResize : 1; // if true, the columns are resized automatically to the available width + bool m_expandingTogglePressed : 1; + bool m_keyPressed : 1; // true if a key is pressed currently; info used by currentChanged() + bool m_useDefaultIndexAt : 1; // true, if QTreeView::indexAt() should be used + bool m_ignoreScrollTo : 1; // true if calls to scrollTo(...) should do nothing. + + DolphinViewController* m_dolphinViewController; + const ViewModeController* m_viewModeController; + ViewExtensionsFactory* m_extensionsFactory; + QAction* m_expandableFoldersAction; + + // A set containing the URLs of all currently expanded folders. + // We cannot use a QSet<QModelIndex> because a QModelIndex is not guaranteed to remain valid over time. + // Also a QSet<QPersistentModelIndex> does not work as expected because it is not guaranteed that + // subsequent expand/collapse events of the same file item will yield the same QPersistentModelIndex. + QSet<KUrl> m_expandedUrls; + + QFont m_font; + QSize m_decorationSize; + + QRect m_dropRect; + + struct ElasticBand + { + ElasticBand(); + + // Elastic band origin and destination coordinates are relative to t + // he origin of the view, not the viewport. + bool show; + QPoint origin; + QPoint destination; + + // Optimization mechanisms for use with elastic band selection. + // Basically, allow "incremental" updates to the selection based + // on the last elastic band shape. + QPoint lastSelectionOrigin; + QPoint lastSelectionDestination; + + // If true, compute the set of selected elements from scratch (slower) + bool ignoreOldInfo; + + // Edges of the filenames that are closest to the edges of oldSelectionRect. + // Used to decide whether horizontal changes in the elastic band are likely + // to require us to re-check which items are selected. + int outsideNearestLeftEdge; + int outsideNearestRightEdge; + int insideNearestLeftEdge; + int insideNearestRightEdge; + // The set of items that were selected at the time this band was shown. + // NOTE: Unless CTRL was pressed when the band was created, this is always empty. + QItemSelection originalSelection; + } m_band; +}; + +#endif diff --git a/src/views/dolphindetailsviewexpander.cpp b/src/views/dolphindetailsviewexpander.cpp new file mode 100644 index 000000000..0f3d3fde1 --- /dev/null +++ b/src/views/dolphindetailsviewexpander.cpp @@ -0,0 +1,87 @@ +/*************************************************************************** + * Copyright (C) 2009 by Frank Reininghaus ([email protected]) * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "dolphindetailsviewexpander.h" + +#include "dolphindetailsview.h" +#include "dolphinmodel.h" +#include "dolphinsortfilterproxymodel.h" + +#include <kdirlister.h> +#include <kdirmodel.h> + +DolphinDetailsViewExpander::DolphinDetailsViewExpander(DolphinDetailsView* parent, + const QSet<KUrl>& urlsToExpand) : + QObject(parent), + m_detailsView(parent), + m_dirLister(0), + m_dolphinModel(0), + m_proxyModel(0) +{ + Q_ASSERT(parent != 0); + + m_proxyModel = qobject_cast<const DolphinSortFilterProxyModel*>(parent->model()); + Q_ASSERT(m_proxyModel != 0); + + m_dolphinModel = qobject_cast<const DolphinModel*>(m_proxyModel->sourceModel()); + Q_ASSERT(m_dolphinModel != 0); + + m_dirLister = m_dolphinModel->dirLister(); + Q_ASSERT(m_dirLister != 0); + + // The URLs must be sorted. E.g. /home/user/ cannot be expanded before /home/ + // because it is not known to the dir model before. + m_urlsToExpand = urlsToExpand.toList(); + qSort(m_urlsToExpand); + + // The dir lister must have completed the folder listing before a subfolder can be expanded. + connect(m_dirLister, SIGNAL(completed()), this, SLOT(slotDirListerCompleted())); +} + +DolphinDetailsViewExpander::~DolphinDetailsViewExpander() +{ +} + +void DolphinDetailsViewExpander::stop() +{ + disconnect(m_dirLister, SIGNAL(completed()), this, SLOT(slotDirListerCompleted())); + deleteLater(); +} + +void DolphinDetailsViewExpander::slotDirListerCompleted() +{ + QModelIndex dirIndex; + + while(!m_urlsToExpand.isEmpty() && !dirIndex.isValid()) { + const KUrl url = m_urlsToExpand.takeFirst(); + dirIndex = m_dolphinModel->indexForUrl(url); + } + + if(dirIndex.isValid()) { + // A valid model index was found. Note that only one item is expanded in each call of this slot + // because expanding any item will trigger KDirLister::openUrl(...) via KDirModel::fetchMore(...), + // and we can only continue when the dir lister is done. + const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex); + m_detailsView->expand(proxyIndex); + } + else { + emit completed(); + stop(); + } +} diff --git a/src/views/dolphindetailsviewexpander.h b/src/views/dolphindetailsviewexpander.h new file mode 100644 index 000000000..b4dc2fc72 --- /dev/null +++ b/src/views/dolphindetailsviewexpander.h @@ -0,0 +1,77 @@ +/*************************************************************************** + * Copyright (C) 2009 by Frank Reininghaus ([email protected]) * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef DOLPHINDETAILSVIEWEXPANDER_H +#define DOLPHINDETAILSVIEWEXPANDER_H + +#include <QObject> +#include <QSet> +#include <QList> + +class DolphinDetailsView; +class KUrl; +class KDirLister; +class DolphinModel; +class DolphinSortFilterProxyModel; + +/** + * @brief Expands a given set of subfolders in collaboration with the dir lister and the dir model. + * + * Note that only one subfolder can be expanded at a time. Each expansion triggers KDirLister::openUrl(...), + * and further expansions can only be done the next time the dir lister emits its completed() signal. + */ +class DolphinDetailsViewExpander : public QObject +{ + Q_OBJECT + +public: + explicit DolphinDetailsViewExpander(DolphinDetailsView* parent, + const QSet<KUrl>& urlsToExpand); + + virtual ~DolphinDetailsViewExpander(); + + /** + * Stops the expansion and deletes the object via deleteLater(). + */ + void stop(); + +private slots: + /** + * This slot is invoked every time the dir lister has completed a listing. + * It expands the first URL from the list m_urlsToExpand that can be found in the dir model. + * If the list is empty, stop() is called. + */ + void slotDirListerCompleted(); + +signals: + /** + * Is emitted when the expander has finished expanding URLs in the details view. + */ + void completed(); + +private: + QList<KUrl> m_urlsToExpand; + + DolphinDetailsView* m_detailsView; + const KDirLister* m_dirLister; + const DolphinModel* m_dolphinModel; + const DolphinSortFilterProxyModel* m_proxyModel; +}; + +#endif diff --git a/src/views/dolphinfileitemdelegate.cpp b/src/views/dolphinfileitemdelegate.cpp new file mode 100644 index 000000000..17447d8cb --- /dev/null +++ b/src/views/dolphinfileitemdelegate.cpp @@ -0,0 +1,180 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "dolphinfileitemdelegate.h" + +#include <dolphinmodel.h> +#include <kfileitem.h> +#include <kicon.h> +#include <kiconloader.h> + +#include <QAbstractItemModel> +#include <QAbstractProxyModel> +#include <QFontMetrics> +#include <QPalette> +#include <QPainter> +#include <QStyleOptionViewItemV4> + +DolphinFileItemDelegate::DolphinFileItemDelegate(QObject* parent) : + KFileItemDelegate(parent), + m_hasMinimizedNameColumn(false), + m_cachedSize(), + m_cachedEmblems() +{ + setJobTransfersVisible(true); +} + +DolphinFileItemDelegate::~DolphinFileItemDelegate() +{ +} + +void DolphinFileItemDelegate::paint(QPainter* painter, + const QStyleOptionViewItem& option, + const QModelIndex& index) const +{ + const QAbstractProxyModel* proxyModel = static_cast<const QAbstractProxyModel*>(index.model()); + const DolphinModel* dolphinModel = static_cast<const DolphinModel*>(proxyModel->sourceModel()); + const bool isNameColumn = (index.column() == KDirModel::Name); + + QStyleOptionViewItemV4 opt(option); + if (m_hasMinimizedNameColumn && isNameColumn) { + adjustOptionWidth(opt, proxyModel, dolphinModel, index); + } + + if (dolphinModel->hasVersionData() && isNameColumn) { + // The currently shown items are under revision control. Show the current revision + // state by adding an emblem and changing the text tintColor. + const QModelIndex dirIndex = proxyModel->mapToSource(index); + const QModelIndex revisionIndex = dolphinModel->index(dirIndex.row(), DolphinModel::Version, dirIndex.parent()); + const QVariant data = dolphinModel->data(revisionIndex, Qt::DecorationRole); + const KVersionControlPlugin::VersionState state = static_cast<KVersionControlPlugin::VersionState>(data.toInt()); + + adjustOptionTextColor(opt, state); + + KFileItemDelegate::paint(painter, opt, index); + + if (state != KVersionControlPlugin::UnversionedVersion) { + const QRect rect = iconRect(option, index); + const QPixmap emblem = emblemForState(state, rect.size()); + painter->drawPixmap(rect.x(), rect.y() + rect.height() - emblem.height(), emblem); + } + } else { + KFileItemDelegate::paint(painter, opt, index); + } +} + +int DolphinFileItemDelegate::nameColumnWidth(const QString& name, const QStyleOptionViewItem& option) +{ + QFontMetrics fontMetrics(option.font); + int width = option.decorationSize.width() + fontMetrics.width(name) + 16; + + const int defaultWidth = option.rect.width(); + if ((defaultWidth > 0) && (defaultWidth < width)) { + width = defaultWidth; + } + return width; +} + +void DolphinFileItemDelegate::adjustOptionWidth(QStyleOptionViewItemV4& option, + const QAbstractProxyModel* proxyModel, + const DolphinModel* dolphinModel, + const QModelIndex& index) +{ + const QModelIndex dirIndex = proxyModel->mapToSource(index); + const KFileItem item = dolphinModel->itemForIndex(dirIndex); + if (!item.isNull()) { + // symbolic links are displayed in an italic font + if (item.isLink()) { + option.font.setItalic(true); + } + + const int width = nameColumnWidth(item.text(), option); + option.rect.setWidth(width); + } +} + +void DolphinFileItemDelegate::adjustOptionTextColor(QStyleOptionViewItemV4& option, + KVersionControlPlugin::VersionState state) +{ + QColor tintColor; + + // Using hardcoded colors is generally a bad idea. In this case the colors just act + // as tint colors and are mixed with the current set text color. The tint colors + // have been optimized for the base colors of the corresponding Oxygen emblems. + switch (state) { + case KVersionControlPlugin::UpdateRequiredVersion: tintColor = Qt::yellow; break; + case KVersionControlPlugin::LocallyModifiedVersion: tintColor = Qt::green; break; + case KVersionControlPlugin::AddedVersion: tintColor = Qt::darkGreen; break; + case KVersionControlPlugin::RemovedVersion: tintColor = Qt::darkRed; break; + case KVersionControlPlugin::ConflictingVersion: tintColor = Qt::red; break; + case KVersionControlPlugin::UnversionedVersion: + case KVersionControlPlugin::NormalVersion: + default: + // use the default text color + return; + } + + QPalette palette = option.palette; + const QColor textColor = palette.color(QPalette::Text); + tintColor = QColor((tintColor.red() + textColor.red()) / 2, + (tintColor.green() + textColor.green()) / 2, + (tintColor.blue() + textColor.blue()) / 2, + (tintColor.alpha() + textColor.alpha()) / 2); + palette.setColor(QPalette::Text, tintColor); + option.palette = palette; +} + +QPixmap DolphinFileItemDelegate::emblemForState(KVersionControlPlugin::VersionState state, const QSize& size) const +{ + Q_ASSERT(state <= KVersionControlPlugin::ConflictingVersion); + if (m_cachedSize != size) { + m_cachedSize = size; + + const int iconHeight = size.height(); + int emblemHeight = KIconLoader::SizeSmall; + if (iconHeight >= KIconLoader::SizeEnormous) { + emblemHeight = KIconLoader::SizeMedium; + } else if (iconHeight >= KIconLoader::SizeLarge) { + emblemHeight = KIconLoader::SizeSmallMedium; + } else if (iconHeight >= KIconLoader::SizeMedium) { + emblemHeight = KIconLoader::SizeSmall; + } else { + emblemHeight = KIconLoader::SizeSmall / 2; + } + + const QSize emblemSize(emblemHeight, emblemHeight); + for (int i = KVersionControlPlugin::NormalVersion; i <= KVersionControlPlugin::ConflictingVersion; ++i) { + QString iconName; + switch (i) { + case KVersionControlPlugin::NormalVersion: iconName = "vcs-normal"; break; + case KVersionControlPlugin::UpdateRequiredVersion: iconName = "vcs-update-required"; break; + case KVersionControlPlugin::LocallyModifiedVersion: iconName = "vcs-locally-modified"; break; + case KVersionControlPlugin::AddedVersion: iconName = "vcs-added"; break; + case KVersionControlPlugin::RemovedVersion: iconName = "vcs-removed"; break; + case KVersionControlPlugin::ConflictingVersion: iconName = "vcs-conflicting"; break; + case KVersionControlPlugin::UnversionedVersion: + default: Q_ASSERT(false); break; + } + + m_cachedEmblems[i] = KIcon(iconName).pixmap(emblemSize); + } + } + return m_cachedEmblems[state]; +} + diff --git a/src/views/dolphinfileitemdelegate.h b/src/views/dolphinfileitemdelegate.h new file mode 100644 index 000000000..405f24916 --- /dev/null +++ b/src/views/dolphinfileitemdelegate.h @@ -0,0 +1,90 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef DOLPHINFILEITEMDELEGATE_H +#define DOLPHINFILEITEMDELEGATE_H + +#include <dolphinmodel.h> +#include <kfileitemdelegate.h> + +class QAbstractProxyModel; + +/** + * Extends KFileItemDelegate by the ability to show the hover effect + * and the selection in a minimized way for the name column of + * the details view. + * + * Note that this is a workaround, as Qt does not support having custom + * shapes within the visual rect of an item view. The visual part of + * workaround is handled inside DolphinFileItemDelegate, the behavior + * changes are handled in DolphinDetailsView. + */ +class DolphinFileItemDelegate : public KFileItemDelegate +{ +public: + explicit DolphinFileItemDelegate(QObject* parent = 0); + virtual ~DolphinFileItemDelegate(); + + /** + * If \a minimized is true, the hover effect and the selection are + * only drawn above the icon and text of an item. Per default + * \a minimized is false, which means that the whole visual rect is + * used like in KFileItemDelegate. + */ + void setMinimizedNameColumn(bool minimized); + bool hasMinimizedNameColumn() const; + + virtual void paint(QPainter* painter, + const QStyleOptionViewItem& option, + const QModelIndex& index) const; + + /** + * Returns the minimized width of the name column for the name \a name. This method + * is also used in DolphinDetailsView to handle the selection of items correctly. + */ + static int nameColumnWidth(const QString& name, const QStyleOptionViewItem& option); + +private: + static void adjustOptionWidth(QStyleOptionViewItemV4& option, + const QAbstractProxyModel* proxyModel, + const DolphinModel* dolphinModel, + const QModelIndex& index); + + static void adjustOptionTextColor(QStyleOptionViewItemV4& option, + KVersionControlPlugin::VersionState state); + + QPixmap emblemForState(KVersionControlPlugin::VersionState state, const QSize& size) const; + +private: + bool m_hasMinimizedNameColumn; + mutable QSize m_cachedSize; + mutable QPixmap m_cachedEmblems[KVersionControlPlugin::ConflictingVersion + 1]; +}; + +inline void DolphinFileItemDelegate::setMinimizedNameColumn(bool minimized) +{ + m_hasMinimizedNameColumn = minimized; +} + +inline bool DolphinFileItemDelegate::hasMinimizedNameColumn() const +{ + return m_hasMinimizedNameColumn; +} + +#endif diff --git a/src/views/dolphiniconsview.cpp b/src/views/dolphiniconsview.cpp new file mode 100644 index 000000000..636bdd66c --- /dev/null +++ b/src/views/dolphiniconsview.cpp @@ -0,0 +1,532 @@ +/*************************************************************************** + * Copyright (C) 2006-2009 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "dolphiniconsview.h" + +#include "dolphincategorydrawer.h" +#include "dolphinviewcontroller.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 "viewmodecontroller.h" +#include "zoomlevelinfo.h" + +#include <kcategorizedsortfilterproxymodel.h> +#include <kdialog.h> +#include <kfileitemdelegate.h> + +#include <QAbstractProxyModel> +#include <QApplication> +#include <QScrollBar> + +DolphinIconsView::DolphinIconsView(QWidget* parent, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController, + DolphinSortFilterProxyModel* proxyModel) : + KCategorizedView(parent), + m_dolphinViewController(dolphinViewController), + m_viewModeController(viewModeController), + m_categoryDrawer(new DolphinCategoryDrawer(this)), + m_extensionsFactory(0), + m_font(), + m_decorationSize(), + m_decorationPosition(QStyleOptionViewItem::Top), + m_displayAlignment(Qt::AlignHCenter), + m_itemSize(), + m_dropRect() +{ + Q_ASSERT(dolphinViewController != 0); + Q_ASSERT(viewModeController != 0); + + setModel(proxyModel); + setLayoutDirection(Qt::LeftToRight); + setViewMode(QListView::IconMode); + setResizeMode(QListView::Adjust); + setMovement(QListView::Static); + setDragEnabled(true); + setEditTriggers(QAbstractItemView::NoEditTriggers); + viewport()->setAcceptDrops(true); + + setMouseTracking(true); + + connect(this, SIGNAL(clicked(const QModelIndex&)), + dolphinViewController, SLOT(requestTab(const QModelIndex&))); + if (KGlobalSettings::singleClick()) { + connect(this, SIGNAL(clicked(const QModelIndex&)), + dolphinViewController, SLOT(triggerItem(const QModelIndex&))); + } else { + connect(this, SIGNAL(doubleClicked(const QModelIndex&)), + dolphinViewController, SLOT(triggerItem(const QModelIndex&))); + } + + connect(this, SIGNAL(entered(const QModelIndex&)), + dolphinViewController, SLOT(emitItemEntered(const QModelIndex&))); + connect(this, SIGNAL(viewportEntered()), + dolphinViewController, SLOT(emitViewportEntered())); + connect(viewModeController, SIGNAL(zoomLevelChanged(int)), + this, SLOT(setZoomLevel(int))); + + const DolphinView* view = dolphinViewController->view(); + 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); + + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); + } else { + m_font = QFont(settings->fontFamily(), + qRound(settings->fontSize()), + settings->fontWeight(), + settings->italicFont()); + m_font.setPointSizeF(settings->fontSize()); + } + + setWordWrap(settings->numberOfTextlines() > 1); + + if (settings->arrangement() == QListView::TopToBottom) { + setFlow(QListView::LeftToRight); + m_decorationPosition = QStyleOptionViewItem::Top; + m_displayAlignment = Qt::AlignHCenter; + } else { + setFlow(QListView::TopToBottom); + m_decorationPosition = QStyleOptionViewItem::Left; + m_displayAlignment = Qt::AlignLeft | Qt::AlignVCenter; + } + + connect(m_categoryDrawer, SIGNAL(actionRequested(int,QModelIndex)), this, SLOT(categoryDrawerActionRequested(int,QModelIndex))); + setCategoryDrawer(m_categoryDrawer); + + setFocus(); + + connect(KGlobalSettings::self(), SIGNAL(settingsChanged(int)), + this, SLOT(slotGlobalSettingsChanged(int))); + + updateGridSize(view->showPreview(), 0); + m_extensionsFactory = new ViewExtensionsFactory(this, dolphinViewController, viewModeController); +} + +DolphinIconsView::~DolphinIconsView() +{ +} + +void DolphinIconsView::dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight) +{ + KCategorizedView::dataChanged(topLeft, bottomRight); + + KCategorizedSortFilterProxyModel* proxyModel = dynamic_cast<KCategorizedSortFilterProxyModel*>(model()); + if (!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 +{ + 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) +{ + KCategorizedView::contextMenuEvent(event); + m_dolphinViewController->triggerContextMenuRequest(event->pos()); +} + +void DolphinIconsView::mousePressEvent(QMouseEvent* event) +{ + m_dolphinViewController->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() && (QApplication::mouseButtons() & Qt::MidButton)) { + m_dolphinViewController->replaceUrlByClipboard(); + } + + KCategorizedView::mousePressEvent(event); +} + +void DolphinIconsView::startDrag(Qt::DropActions supportedActions) +{ + DragAndDropHelper::instance().startDrag(this, supportedActions, m_dolphinViewController); +} + +void DolphinIconsView::dragEnterEvent(QDragEnterEvent* event) +{ + if (DragAndDropHelper::instance().isMimeDataSupported(event->mimeData())) { + event->acceptProposedAction(); + } +} + +void DolphinIconsView::dragLeaveEvent(QDragLeaveEvent* event) +{ + KCategorizedView::dragLeaveEvent(event); + 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.setSize(QSize()); // set as invalid + if (index.isValid()) { + const KFileItem item = m_dolphinViewController->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) +{ + const QModelIndex index = indexAt(event->pos()); + const KFileItem item = m_dolphinViewController->itemForIndex(index); + m_dolphinViewController->indicateDroppedUrls(item, m_viewModeController->url(), event); + // don't call KCategorizedView::dropEvent(event), as it moves + // the items which is not wanted +} + +QModelIndex DolphinIconsView::moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers) +{ + const QModelIndex oldCurrent = currentIndex(); + + 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_dolphinViewController->handleKeyPressEvent(event); +} + +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::showEvent(QShowEvent* event) +{ + KFileItemDelegate* delegate = dynamic_cast<KFileItemDelegate*>(itemDelegate()); + delegate->setMaximumSize(m_itemSize); + + KCategorizedView::showEvent(event); +} + +void DolphinIconsView::leaveEvent(QEvent* event) +{ + 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_dolphinViewController->emitViewportEntered(); +} + +void DolphinIconsView::currentChanged(const QModelIndex& current, const QModelIndex& previous) +{ + KCategorizedView::currentChanged(current, previous); + m_extensionsFactory->handleCurrentIndexChange(current, previous); +} + +void DolphinIconsView::resizeEvent(QResizeEvent* event) +{ + KCategorizedView::resizeEvent(event); + const DolphinView* view = m_dolphinViewController->view(); + updateGridSize(view->showPreview(), view->additionalInfo().count()); +} + +void DolphinIconsView::slotShowPreviewChanged() +{ + const DolphinView* view = m_dolphinViewController->view(); + updateGridSize(view->showPreview(), additionalInfoCount()); +} + +void DolphinIconsView::slotAdditionalInfoChanged() +{ + const DolphinView* view = m_dolphinViewController->view(); + const bool showPreview = view->showPreview(); + updateGridSize(showPreview, view->additionalInfo().count()); +} + +void DolphinIconsView::setZoomLevel(int level) +{ + IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); + + const int oldIconSize = settings->iconSize(); + int newIconSize = oldIconSize; + + const bool showPreview = m_dolphinViewController->view()->showPreview(); + 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()); +} + +void DolphinIconsView::requestActivation() +{ + m_dolphinViewController->requestActivation(); +} + +void DolphinIconsView::slotGlobalSettingsChanged(int category) +{ + Q_UNUSED(category); + + const IconsModeSettings* settings = DolphinSettings::instance().iconsModeSettings(); + Q_ASSERT(settings != 0); + if (settings->useSystemFont()) { + m_font = KGlobalSettings::generalFont(); + } + + disconnect(this, SIGNAL(clicked(QModelIndex)), m_dolphinViewController, SLOT(triggerItem(QModelIndex))); + disconnect(this, SIGNAL(doubleClicked(QModelIndex)), m_dolphinViewController, SLOT(triggerItem(QModelIndex))); + if (KGlobalSettings::singleClick()) { + connect(this, SIGNAL(clicked(QModelIndex)), m_dolphinViewController, SLOT(triggerItem(QModelIndex))); + } else { + connect(this, SIGNAL(doubleClicked(QModelIndex)), m_dolphinViewController, SLOT(triggerItem(QModelIndex))); + } +} + +void DolphinIconsView::categoryDrawerActionRequested(int action, const QModelIndex &index) +{ + const QSortFilterProxyModel *model = dynamic_cast<const QSortFilterProxyModel*>(index.model()); + const QModelIndex topLeft = model->index(index.row(), modelColumn()); + QModelIndex bottomRight = topLeft; + const QString category = model->data(index, KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); + QModelIndex current = topLeft; + while (true) { + current = model->index(current.row() + 1, modelColumn()); + const QString curCategory = model->data(model->index(current.row(), index.column()), KCategorizedSortFilterProxyModel::CategoryDisplayRole).toString(); + if (!current.isValid() || category != curCategory) { + break; + } + bottomRight = current; + } + switch (action) { + case DolphinCategoryDrawer::SelectAll: + selectionModel()->select(QItemSelection(topLeft, bottomRight), QItemSelectionModel::Select); + break; + case DolphinCategoryDrawer::UnselectAll: + selectionModel()->select(QItemSelection(topLeft, bottomRight), QItemSelectionModel::Deselect); + break; + default: + break; + } +} + +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; + itemWidth += diff; + itemHeight += diff; + + size = previewSize; + } + + Q_ASSERT(additionalInfoCount >= 0); + itemHeight += additionalInfoCount * QFontMetrics(m_font).height(); + + // 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_decorationSize = QSize(itemWidth, size); + setIconSize(QSize(itemWidth, size)); + } else { + 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; + } + + m_decorationSize = QSize(size, size); + setIconSize(QSize(size, size)); + } + + m_itemSize = QSize(itemWidth, itemHeight); + setGridSizeOwn(QSize(itemWidth + spacing * 2, itemHeight + spacing)); + + KFileItemDelegate* delegate = dynamic_cast<KFileItemDelegate*>(itemDelegate()); + if (delegate != 0) { + delegate->setMaximumSize(m_itemSize); + } +} + +int DolphinIconsView::additionalInfoCount() const +{ + const DolphinView* view = m_dolphinViewController->view(); + return view->additionalInfo().count(); +} + +#include "dolphiniconsview.moc" diff --git a/src/views/dolphiniconsview.h b/src/views/dolphiniconsview.h new file mode 100644 index 000000000..21e37ba02 --- /dev/null +++ b/src/views/dolphiniconsview.h @@ -0,0 +1,122 @@ +/*************************************************************************** + * Copyright (C) 2006-2009 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef DOLPHINICONSVIEW_H +#define DOLPHINICONSVIEW_H + +#include <kcategorizedview.h> + +#include <kfileitem.h> +#include <kfileitemdelegate.h> + +#include <QFont> +#include <QSize> +#include <QStyleOption> + +#include <libdolphin_export.h> + +class DolphinViewController; +class DolphinCategoryDrawer; +class DolphinSortFilterProxyModel; +class ViewExtensionsFactory; +class ViewModeController; + +/** + * @brief Represents the view, where each item is shown as an icon. + * + * It is also possible that instead of the icon a preview of the item + * content is shown. + */ +class LIBDOLPHINPRIVATE_EXPORT DolphinIconsView : public KCategorizedView +{ + Q_OBJECT + +public: + /** + * @param parent Parent widget. + * @param dolphinViewController Allows the DolphinIconsView to control the + * DolphinView in a limited way. + * @param viewModeController Controller that is used by the DolphinView + * to control the DolphinIconsView. The DolphinIconsView + * only has read access to the controller. + * @param model Directory that is shown. + */ + explicit DolphinIconsView(QWidget* parent, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController, + DolphinSortFilterProxyModel* proxyModel); + virtual ~DolphinIconsView(); + +protected slots: + virtual void dataChanged(const QModelIndex& topLeft, const QModelIndex& bottomRight); + +protected: + virtual QStyleOptionViewItem viewOptions() const; + virtual void contextMenuEvent(QContextMenuEvent* event); + virtual void mousePressEvent(QMouseEvent* event); + virtual void startDrag(Qt::DropActions supportedActions); + virtual void dragEnterEvent(QDragEnterEvent* event); + virtual void dragLeaveEvent(QDragLeaveEvent* event); + virtual void dragMoveEvent(QDragMoveEvent* event); + virtual void dropEvent(QDropEvent* event); + virtual QModelIndex moveCursor(CursorAction cursorAction, Qt::KeyboardModifiers modifiers); + virtual void keyPressEvent(QKeyEvent* event); + virtual void wheelEvent(QWheelEvent* event); + virtual void showEvent(QShowEvent* event); + virtual void leaveEvent(QEvent* event); + virtual void currentChanged(const QModelIndex& current, const QModelIndex& previous); + virtual void resizeEvent(QResizeEvent* event); + +private slots: + void slotShowPreviewChanged(); + void slotAdditionalInfoChanged(); + void setZoomLevel(int level); + void requestActivation(); + void slotGlobalSettingsChanged(int category); + void categoryDrawerActionRequested(int action, const QModelIndex &index); + +private: + /** + * Updates the size of the grid depending on the state + * of \a showPreview and \a additionalInfoCount. + */ + void updateGridSize(bool showPreview, int additionalInfoCount); + + /** + * Returns the number of additional information lines that should + * be shown below the item name. + */ + int additionalInfoCount() const; + +private: + DolphinViewController* m_dolphinViewController; + const ViewModeController* m_viewModeController; + DolphinCategoryDrawer* m_categoryDrawer; + ViewExtensionsFactory* m_extensionsFactory; + + QFont m_font; + QSize m_decorationSize; + QStyleOptionViewItem::Position m_decorationPosition; + Qt::Alignment m_displayAlignment; + + QSize m_itemSize; + QRect m_dropRect; +}; + +#endif diff --git a/src/views/dolphinview.cpp b/src/views/dolphinview.cpp new file mode 100644 index 000000000..73a0c63c3 --- /dev/null +++ b/src/views/dolphinview.cpp @@ -0,0 +1,1569 @@ +/*************************************************************************** + * Copyright (C) 2006-2009 by Peter Penz <[email protected]> * + * Copyright (C) 2006 by Gregor Kališnik <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "dolphinview.h" + +#include <QAbstractItemView> +#include <QApplication> +#include <QClipboard> +#include <QKeyEvent> +#include <QItemSelection> +#include <QBoxLayout> +#include <QTimer> +#include <QScrollBar> + +#include <kactioncollection.h> +#include <kcolorscheme.h> +#include <kdirlister.h> +#include <kiconeffect.h> +#include <kfileitem.h> +#include <klocale.h> +#include <kio/deletejob.h> +#include <kio/netaccess.h> +#include <kio/previewjob.h> +#include <kjob.h> +#include <kmenu.h> +#include <kmessagebox.h> +#include <kmimetyperesolver.h> +#include <konq_fileitemcapabilities.h> +#include <konq_operations.h> +#include <konqmimedata.h> +#include <kstringhandler.h> +#include <ktoggleaction.h> +#include <kurl.h> + +#include "additionalinfoaccessor.h" +#include "dolphinmodel.h" +#include "dolphincolumnviewcontainer.h" +#include "dolphinviewcontroller.h" +#include "dolphindetailsview.h" +#include "dolphinfileitemdelegate.h" +#include "dolphinnewmenuobserver.h" +#include "dolphinsortfilterproxymodel.h" +#include "dolphin_detailsmodesettings.h" +#include "dolphiniconsview.h" +#include "dolphin_generalsettings.h" +#include "draganddrophelper.h" +#include "renamedialog.h" +#include "settings/dolphinsettings.h" +#include "viewmodecontroller.h" +#include "viewproperties.h" +#include "zoomlevelinfo.h" +#include "dolphindetailsviewexpander.h" + +/** + * Helper function for sorting items with qSort() in + * DolphinView::renameSelectedItems(). + */ +bool lessThan(const KFileItem& item1, const KFileItem& item2) +{ + return KStringHandler::naturalCompare(item1.name(), item2.name()) < 0; +} + +DolphinView::DolphinView(QWidget* parent, + const KUrl& url, + DolphinSortFilterProxyModel* proxyModel) : + QWidget(parent), + m_active(true), + m_showPreview(false), + m_storedCategorizedSorting(false), + m_tabsForFiles(false), + m_isContextMenuOpen(false), + m_ignoreViewProperties(false), + m_assureVisibleCurrentIndex(false), + m_mode(DolphinView::IconsView), + m_topLayout(0), + m_dolphinViewController(0), + m_viewModeController(0), + m_viewAccessor(proxyModel), + m_selectionModel(0), + m_selectionChangedTimer(0), + m_rootUrl(), + m_activeItemUrl(), + m_restoredContentsPosition(), + m_createdItemUrl(), + m_selectedItems(), + m_newFileNames() +{ + m_topLayout = new QVBoxLayout(this); + m_topLayout->setSpacing(0); + m_topLayout->setMargin(0); + + m_dolphinViewController = new DolphinViewController(this); + + m_viewModeController = new ViewModeController(this); + m_viewModeController->setUrl(url); + + connect(m_viewModeController, SIGNAL(urlChanged(const KUrl&)), + this, SIGNAL(urlChanged(const KUrl&))); + + connect(m_dolphinViewController, SIGNAL(requestContextMenu(const QPoint&, const QList<QAction*>&)), + this, SLOT(openContextMenu(const QPoint&, const QList<QAction*>&))); + connect(m_dolphinViewController, SIGNAL(urlsDropped(const KFileItem&, const KUrl&, QDropEvent*)), + this, SLOT(dropUrls(const KFileItem&, const KUrl&, QDropEvent*))); + connect(m_dolphinViewController, SIGNAL(sortingChanged(DolphinView::Sorting)), + this, SLOT(updateSorting(DolphinView::Sorting))); + connect(m_dolphinViewController, SIGNAL(sortOrderChanged(Qt::SortOrder)), + this, SLOT(updateSortOrder(Qt::SortOrder))); + connect(m_dolphinViewController, SIGNAL(sortFoldersFirstChanged(bool)), + this, SLOT(updateSortFoldersFirst(bool))); + connect(m_dolphinViewController, SIGNAL(additionalInfoChanged(const KFileItemDelegate::InformationList&)), + this, SLOT(updateAdditionalInfo(const KFileItemDelegate::InformationList&))); + connect(m_dolphinViewController, SIGNAL(itemTriggered(const KFileItem&)), + this, SLOT(triggerItem(const KFileItem&))); + connect(m_dolphinViewController, SIGNAL(tabRequested(const KUrl&)), + this, SIGNAL(tabRequested(const KUrl&))); + connect(m_dolphinViewController, SIGNAL(activated()), + this, SLOT(activate())); + connect(m_dolphinViewController, SIGNAL(itemEntered(const KFileItem&)), + this, SLOT(showHoverInformation(const KFileItem&))); + connect(m_dolphinViewController, SIGNAL(viewportEntered()), + this, SLOT(clearHoverInformation())); + connect(m_dolphinViewController, SIGNAL(urlChangeRequested(KUrl)), + m_viewModeController, SLOT(setUrl(KUrl))); + + KDirLister* dirLister = m_viewAccessor.dirLister(); + connect(dirLister, SIGNAL(redirection(KUrl,KUrl)), + this, SLOT(slotRedirection(KUrl,KUrl))); + connect(dirLister, SIGNAL(completed()), + this, SLOT(slotDirListerCompleted())); + connect(dirLister, SIGNAL(refreshItems(const QList<QPair<KFileItem,KFileItem>>&)), + this, SLOT(slotRefreshItems())); + + // When a new item has been created by the "Create New..." menu, the item should + // get selected and it must be assured that the item will get visible. As the + // creation is done asynchronously, several signals must be checked: + connect(&DolphinNewMenuObserver::instance(), SIGNAL(itemCreated(const KUrl&)), + this, SLOT(observeCreatedItem(const KUrl&))); + + m_selectionChangedTimer = new QTimer(this); + m_selectionChangedTimer->setSingleShot(true); + m_selectionChangedTimer->setInterval(300); + connect(m_selectionChangedTimer, SIGNAL(timeout()), + this, SLOT(emitSelectionChangedSignal())); + + applyViewProperties(); + m_topLayout->addWidget(m_viewAccessor.layoutTarget()); +} + +DolphinView::~DolphinView() +{ +} + +KUrl DolphinView::url() const +{ + return m_viewModeController->url(); +} + +KUrl DolphinView::rootUrl() const +{ + const KUrl viewUrl = url(); + const KUrl root = m_viewAccessor.rootUrl(); + if (root.isEmpty() || !root.isParentOf(viewUrl)) { + return viewUrl; + } + return root; +} + +void DolphinView::setActive(bool active) +{ + if (active == m_active) { + return; + } + + m_active = active; + + QColor color = KColorScheme(QPalette::Active, KColorScheme::View).background().color(); + if (active) { + emitSelectionChangedSignal(); + } else { + color.setAlpha(150); + } + + QWidget* viewport = m_viewAccessor.itemView()->viewport(); + QPalette palette; + palette.setColor(viewport->backgroundRole(), color); + viewport->setPalette(palette); + + update(); + + if (active) { + m_viewAccessor.itemView()->setFocus(); + emit activated(); + } + + m_viewModeController->indicateActivationChange(active); +} + +bool DolphinView::isActive() const +{ + return m_active; +} + +void DolphinView::setMode(Mode mode) +{ + if (mode == m_mode) { + return; // the wished mode is already set + } + + const int oldZoomLevel = m_viewModeController->zoomLevel(); + m_mode = mode; + + // remember the currently selected items, so that they will + // be restored after reloading the directory + m_selectedItems = selectedItems(); + + deleteView(); + + const KUrl viewPropsUrl = rootUrl(); + ViewProperties props(viewPropsUrl); + props.setViewMode(m_mode); + createView(); + + // the file item delegate has been recreated, apply the current + // additional information manually + const KFileItemDelegate::InformationList infoList = props.additionalInfo(); + m_viewAccessor.itemDelegate()->setShowInformation(infoList); + emit additionalInfoChanged(); + + // Not all view modes support categorized sorting. Adjust the sorting model + // if changing the view mode results in a change of the categorized sorting + // capabilities. + m_storedCategorizedSorting = props.categorizedSorting(); + const bool categorized = m_storedCategorizedSorting && supportsCategorizedSorting(); + if (categorized != m_viewAccessor.proxyModel()->isCategorizedModel()) { + m_viewAccessor.proxyModel()->setCategorizedModel(categorized); + emit categorizedSortingChanged(); + } + + emit modeChanged(); + + updateZoomLevel(oldZoomLevel); + loadDirectory(viewPropsUrl); +} + +DolphinView::Mode DolphinView::mode() const +{ + return m_mode; +} + +bool DolphinView::showPreview() const +{ + return m_showPreview; +} + +bool DolphinView::showHiddenFiles() const +{ + return m_viewAccessor.dirLister()->showingDotFiles(); +} + +bool DolphinView::categorizedSorting() const +{ + // If all view modes would support categorized sorting, returning + // m_viewAccessor.proxyModel()->isCategorizedModel() would be the way to go. As + // currently only the icons view supports caterized sorting, we remember + // the stored view properties state in m_storedCategorizedSorting and + // return this state. The application takes care to disable the corresponding + // checkbox by checking DolphinView::supportsCategorizedSorting() to indicate + // that this setting is not applied to the current view mode. + return m_storedCategorizedSorting; +} + +bool DolphinView::supportsCategorizedSorting() const +{ + return m_viewAccessor.supportsCategorizedSorting(); +} + +bool DolphinView::hasSelection() const +{ + const QAbstractItemView* view = m_viewAccessor.itemView(); + return (view != 0) && view->selectionModel()->hasSelection(); +} + +void DolphinView::markUrlsAsSelected(const QList<KUrl>& urls) +{ + foreach (const KUrl& url, urls) { + KFileItem item(KFileItem::Unknown, KFileItem::Unknown, url); + m_selectedItems.append(item); + } +} + +KFileItemList DolphinView::selectedItems() const +{ + KFileItemList itemList; + const QAbstractItemView* view = m_viewAccessor.itemView(); + if (view == 0) { + return itemList; + } + + const QItemSelection selection = m_viewAccessor.proxyModel()->mapSelectionToSource(view->selectionModel()->selection()); + + const QModelIndexList indexList = selection.indexes(); + foreach (const QModelIndex &index, indexList) { + KFileItem item = m_viewAccessor.dirModel()->itemForIndex(index); + if (!item.isNull()) { + itemList.append(item); + } + } + + return itemList; +} + +KUrl::List DolphinView::selectedUrls() const +{ + KUrl::List urls; + const KFileItemList list = selectedItems(); + foreach (const KFileItem &item, list) { + urls.append(item.url()); + } + return urls; +} + +int DolphinView::selectedItemsCount() const +{ + const QAbstractItemView* view = m_viewAccessor.itemView(); + if (view == 0) { + return 0; + } + + return view->selectionModel()->selectedIndexes().count(); +} + +QItemSelectionModel* DolphinView::selectionModel() const +{ + return m_viewAccessor.itemView()->selectionModel(); +} + +void DolphinView::setZoomLevel(int level) +{ + if (level < ZoomLevelInfo::minimumLevel()) { + level = ZoomLevelInfo::minimumLevel(); + } else if (level > ZoomLevelInfo::maximumLevel()) { + level = ZoomLevelInfo::maximumLevel(); + } + + if (level != zoomLevel()) { + m_viewModeController->setZoomLevel(level); + emit zoomLevelChanged(level); + } +} + +int DolphinView::zoomLevel() const +{ + return m_viewModeController->zoomLevel(); +} + +void DolphinView::setSorting(Sorting sorting) +{ + if (sorting != this->sorting()) { + updateSorting(sorting); + } +} + +DolphinView::Sorting DolphinView::sorting() const +{ + return m_viewAccessor.proxyModel()->sorting(); +} + +void DolphinView::setSortOrder(Qt::SortOrder order) +{ + if (sortOrder() != order) { + updateSortOrder(order); + } +} + +Qt::SortOrder DolphinView::sortOrder() const +{ + return m_viewAccessor.proxyModel()->sortOrder(); +} + +void DolphinView::setSortFoldersFirst(bool foldersFirst) +{ + if (sortFoldersFirst() != foldersFirst) { + updateSortFoldersFirst(foldersFirst); + } +} + +bool DolphinView::sortFoldersFirst() const +{ + return m_viewAccessor.proxyModel()->sortFoldersFirst(); +} + +void DolphinView::setAdditionalInfo(KFileItemDelegate::InformationList info) +{ + const KUrl viewPropsUrl = rootUrl(); + ViewProperties props(viewPropsUrl); + props.setAdditionalInfo(info); + m_viewAccessor.itemDelegate()->setShowInformation(info); + + emit additionalInfoChanged(); + + if (m_viewAccessor.reloadOnAdditionalInfoChange()) { + loadDirectory(viewPropsUrl); + } +} + +KFileItemDelegate::InformationList DolphinView::additionalInfo() const +{ + return m_viewAccessor.itemDelegate()->showInformation(); +} + +void DolphinView::reload() +{ + QByteArray viewState; + QDataStream saveStream(&viewState, QIODevice::WriteOnly); + saveState(saveStream); + m_selectedItems= selectedItems(); + + setUrl(url()); + loadDirectory(url(), true); + + QDataStream restoreStream(viewState); + restoreState(restoreStream); +} + +void DolphinView::refresh() +{ + m_ignoreViewProperties = false; + + const bool oldActivationState = m_active; + const int oldZoomLevel = m_viewModeController->zoomLevel(); + m_active = true; + + createView(); + applyViewProperties(); + reload(); + + setActive(oldActivationState); + updateZoomLevel(oldZoomLevel); +} + +void DolphinView::setNameFilter(const QString& nameFilter) +{ + m_viewModeController->setNameFilter(nameFilter); +} + +void DolphinView::calculateItemCount(int& fileCount, + int& folderCount, + KIO::filesize_t& totalFileSize) const +{ + foreach (const KFileItem& item, m_viewAccessor.dirLister()->items()) { + if (item.isDir()) { + ++folderCount; + } else { + ++fileCount; + totalFileSize += item.size(); + } + } +} + +QString DolphinView::statusBarText() const +{ + QString text; + int folderCount = 0; + int fileCount = 0; + KIO::filesize_t totalFileSize = 0; + + if (hasSelection()) { + // give a summary of the status of the selected files + const KFileItemList list = selectedItems(); + if (list.isEmpty()) { + // when an item is triggered, it is temporary selected but selectedItems() + // will return an empty list + return text; + } + + KFileItemList::const_iterator it = list.begin(); + const KFileItemList::const_iterator end = list.end(); + while (it != end) { + const KFileItem& item = *it; + if (item.isDir()) { + ++folderCount; + } else { + ++fileCount; + totalFileSize += item.size(); + } + ++it; + } + + if (folderCount + fileCount == 1) { + // if only one item is selected, show the filename + const QString name = list.first().text(); + text = (folderCount == 1) ? i18nc("@info:status", "<filename>%1</filename> selected", name) : + i18nc("@info:status", "<filename>%1</filename> selected (%2)", + name, KIO::convertSize(totalFileSize)); + } else { + // at least 2 items are selected + const QString foldersText = i18ncp("@info:status", "1 Folder selected", "%1 Folders selected", folderCount); + const QString filesText = i18ncp("@info:status", "1 File selected", "%1 Files selected", fileCount); + if ((folderCount > 0) && (fileCount > 0)) { + text = i18nc("@info:status folders, files (size)", "%1, %2 (%3)", + foldersText, filesText, KIO::convertSize(totalFileSize)); + } else if (fileCount > 0) { + text = i18nc("@info:status files (size)", "%1 (%2)", filesText, KIO::convertSize(totalFileSize)); + } else { + Q_ASSERT(folderCount > 0); + text = foldersText; + } + } + } else { + calculateItemCount(fileCount, folderCount, totalFileSize); + text = KIO::itemsSummaryString(fileCount + folderCount, + fileCount, folderCount, + totalFileSize, true); + } + + return text; +} + +QList<QAction*> DolphinView::versionControlActions(const KFileItemList& items) const +{ + return m_dolphinViewController->versionControlActions(items); +} + +void DolphinView::setUrl(const KUrl& url) +{ + if (m_viewModeController->url() != url) { + m_newFileNames.clear(); + + m_viewModeController->setUrl(url); // emits urlChanged, which we forward + m_viewAccessor.prepareUrlChange(url); + applyViewProperties(); + loadDirectory(url); + + // When changing the URL there is no need to keep the version + // data of the previous URL. + m_viewAccessor.dirModel()->clearVersionData(); + + emit startedPathLoading(url); + } + + // the selection model might have changed in the case of a column view + QItemSelectionModel* selectionModel = m_viewAccessor.itemView()->selectionModel(); + if (m_selectionModel != selectionModel) { + disconnect(m_selectionModel, SIGNAL(selectionChanged(QItemSelection, QItemSelection)), + this, SLOT(slotSelectionChanged(QItemSelection, QItemSelection))); + m_selectionModel = selectionModel; + connect(m_selectionModel, SIGNAL(selectionChanged(QItemSelection, QItemSelection)), + this, SLOT(slotSelectionChanged(QItemSelection, QItemSelection))); + } +} + +void DolphinView::selectAll() +{ + m_viewAccessor.itemView()->selectAll(); +} + +void DolphinView::invertSelection() +{ + QItemSelectionModel* selectionModel = m_viewAccessor.itemView()->selectionModel(); + const QAbstractItemModel* itemModel = selectionModel->model(); + + const QModelIndex topLeft = itemModel->index(0, 0); + const QModelIndex bottomRight = itemModel->index(itemModel->rowCount() - 1, + itemModel->columnCount() - 1); + + const QItemSelection selection(topLeft, bottomRight); + selectionModel->select(selection, QItemSelectionModel::Toggle); +} + +void DolphinView::clearSelection() +{ + m_viewAccessor.itemView()->clearSelection(); +} + +void DolphinView::renameSelectedItems() +{ + KFileItemList items = selectedItems(); + const int itemCount = items.count(); + if (itemCount < 1) { + return; + } + + if (itemCount > 1) { + // More than one item has been selected for renaming. Open + // a rename dialog and rename all items afterwards. + QPointer<RenameDialog> dialog = new RenameDialog(this, items); + if (dialog->exec() == QDialog::Rejected) { + delete dialog; + return; + } + + const QString newName = dialog->newName(); + if (newName.isEmpty()) { + emit errorMessage(dialog->errorString()); + delete dialog; + return; + } + delete dialog; + + // the selection would be invalid after renaming the items, so just clear + // it before + clearSelection(); + + // TODO: check how this can be integrated into KIO::FileUndoManager/KonqOperations + // as one operation instead of n rename operations like it is done now... + Q_ASSERT(newName.contains('#')); + + // currently the items are sorted by the selection order, resort + // them by the file name + qSort(items.begin(), items.end(), lessThan); + + // iterate through all selected items and rename them... + int index = 1; + foreach (const KFileItem& item, items) { + const KUrl& oldUrl = item.url(); + QString number; + number.setNum(index++); + + QString name = newName; + name.replace('#', number); + + if (oldUrl.fileName() != name) { + KUrl newUrl = oldUrl; + newUrl.setFileName(name); + KonqOperations::rename(this, oldUrl, newUrl); + } + } + } else if (DolphinSettings::instance().generalSettings()->renameInline()) { + Q_ASSERT(itemCount == 1); + const QModelIndex dirIndex = m_viewAccessor.dirModel()->indexForItem(items.first()); + const QModelIndex proxyIndex = m_viewAccessor.proxyModel()->mapFromSource(dirIndex); + m_viewAccessor.itemView()->edit(proxyIndex); + } else { + Q_ASSERT(itemCount == 1); + + QPointer<RenameDialog> dialog = new RenameDialog(this, items); + if (dialog->exec() == QDialog::Rejected) { + delete dialog; + return; + } + + const QString newName = dialog->newName(); + if (newName.isEmpty()) { + emit errorMessage(dialog->errorString()); + delete dialog; + return; + } + delete dialog; + + const KUrl& oldUrl = items.first().url(); + KUrl newUrl = oldUrl; + newUrl.setFileName(newName); + KonqOperations::rename(this, oldUrl, newUrl); + } + + // assure that the current index remains visible when KDirLister + // will notify the view about changed items + m_assureVisibleCurrentIndex = true; +} + +void DolphinView::trashSelectedItems() +{ + const KUrl::List list = simplifiedSelectedUrls(); + KonqOperations::del(this, KonqOperations::TRASH, list); +} + +void DolphinView::deleteSelectedItems() +{ + const KUrl::List list = simplifiedSelectedUrls(); + const bool del = KonqOperations::askDeleteConfirmation(list, + KonqOperations::DEL, + KonqOperations::DEFAULT_CONFIRMATION, + this); + + if (del) { + KIO::Job* job = KIO::del(list); + connect(job, SIGNAL(result(KJob*)), + this, SLOT(slotDeleteFileFinished(KJob*))); + } +} + +void DolphinView::cutSelectedItems() +{ + QMimeData* mimeData = selectionMimeData(); + KonqMimeData::addIsCutSelection(mimeData, true); + QApplication::clipboard()->setMimeData(mimeData); +} + +void DolphinView::copySelectedItems() +{ + QMimeData* mimeData = selectionMimeData(); + QApplication::clipboard()->setMimeData(mimeData); +} + +void DolphinView::paste() +{ + pasteToUrl(url()); +} + +void DolphinView::pasteIntoFolder() +{ + const KFileItemList items = selectedItems(); + if ((items.count() == 1) && items.first().isDir()) { + pasteToUrl(items.first().url()); + } +} + +void DolphinView::setShowPreview(bool show) +{ + if (m_showPreview == show) { + return; + } + + const KUrl viewPropsUrl = rootUrl(); + ViewProperties props(viewPropsUrl); + props.setShowPreview(show); + + m_showPreview = show; + const int oldZoomLevel = m_viewModeController->zoomLevel(); + emit showPreviewChanged(); + + // Enabling or disabling the preview might change the icon size of the view. + // As the view does not emit a signal when the icon size has been changed, + // the used zoom level of the controller must be adjusted manually: + updateZoomLevel(oldZoomLevel); +} + +void DolphinView::setShowHiddenFiles(bool show) +{ + if (m_viewAccessor.dirLister()->showingDotFiles() == show) { + return; + } + + const KUrl viewPropsUrl = rootUrl(); + ViewProperties props(viewPropsUrl); + props.setShowHiddenFiles(show); + + m_viewAccessor.dirLister()->setShowingDotFiles(show); + emit showHiddenFilesChanged(); +} + +void DolphinView::setCategorizedSorting(bool categorized) +{ + if (categorized == categorizedSorting()) { + return; + } + + // setCategorizedSorting(true) may only get invoked + // if the view supports categorized sorting + Q_ASSERT(!categorized || supportsCategorizedSorting()); + + ViewProperties props(rootUrl()); + props.setCategorizedSorting(categorized); + props.save(); + + m_storedCategorizedSorting = categorized; + m_viewAccessor.proxyModel()->setCategorizedModel(categorized); + + emit categorizedSortingChanged(); +} + +void DolphinView::toggleSortOrder() +{ + const Qt::SortOrder order = (sortOrder() == Qt::AscendingOrder) ? + Qt::DescendingOrder : + Qt::AscendingOrder; + setSortOrder(order); +} + +void DolphinView::toggleSortFoldersFirst() +{ + setSortFoldersFirst(!sortFoldersFirst()); +} + +void DolphinView::toggleAdditionalInfo(QAction* action) +{ + const KFileItemDelegate::Information info = + static_cast<KFileItemDelegate::Information>(action->data().toInt()); + + KFileItemDelegate::InformationList list = additionalInfo(); + + const bool show = action->isChecked(); + + const int index = list.indexOf(info); + const bool containsInfo = (index >= 0); + if (show && !containsInfo) { + list.append(info); + setAdditionalInfo(list); + } else if (!show && containsInfo) { + list.removeAt(index); + setAdditionalInfo(list); + Q_ASSERT(list.indexOf(info) < 0); + } +} + +void DolphinView::mouseReleaseEvent(QMouseEvent* event) +{ + QWidget::mouseReleaseEvent(event); + setActive(true); +} + +bool DolphinView::eventFilter(QObject* watched, QEvent* event) +{ + switch (event->type()) { + case QEvent::FocusIn: + if (watched == m_viewAccessor.itemView()) { + m_dolphinViewController->requestActivation(); + } + break; + + case QEvent::DragEnter: + if (watched == m_viewAccessor.itemView()->viewport()) { + setActive(true); + } + break; + + case QEvent::KeyPress: + if (watched == m_viewAccessor.itemView()) { + // clear the selection when Escape has been pressed + QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event); + if (keyEvent->key() == Qt::Key_Escape) { + clearSelection(); + } + } + break; + + case QEvent::Wheel: + if (watched == m_viewAccessor.itemView()->viewport()) { + // Ctrl+wheel events should cause icon zooming, but not if the left mouse button is pressed + // (the user is probably trying to scroll during a selection in that case) + QWheelEvent* wheelEvent = static_cast<QWheelEvent*>(event); + if (wheelEvent->modifiers() & Qt::ControlModifier && !(wheelEvent->buttons() & Qt::LeftButton)) { + const int delta = wheelEvent->delta(); + const int level = zoomLevel(); + if (delta > 0) { + setZoomLevel(level + 1); + } else if (delta < 0) { + setZoomLevel(level - 1); + } + return true; + } + } + break; + + default: + break; + } + + return QWidget::eventFilter(watched, event); +} + +void DolphinView::activate() +{ + setActive(true); +} + +void DolphinView::triggerItem(const KFileItem& item) +{ + const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers(); + if ((modifier & Qt::ShiftModifier) || (modifier & Qt::ControlModifier)) { + // items are selected by the user, hence don't trigger the + // item specified by 'index' + return; + } + + // TODO: the m_isContextMenuOpen check is a workaround for Qt-issue 207192 + if (item.isNull() || m_isContextMenuOpen) { + return; + } + + emit itemTriggered(item); // caught by DolphinViewContainer or DolphinPart +} + +void DolphinView::slotSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected) +{ + const int count = selectedItemsCount(); + const bool selectionStateChanged = ((count > 0) && (selected.count() == count)) || + ((count == 0) && !deselected.isEmpty()); + + // If nothing has been selected before and something got selected (or if something + // was selected before and now nothing is selected) the selectionChangedSignal must + // be emitted asynchronously as fast as possible to update the edit-actions. + m_selectionChangedTimer->setInterval(selectionStateChanged ? 0 : 300); + m_selectionChangedTimer->start(); +} + +void DolphinView::emitSelectionChangedSignal() +{ + emit selectionChanged(DolphinView::selectedItems()); +} + +void DolphinView::openContextMenu(const QPoint& pos, + const QList<QAction*>& customActions) +{ + KFileItem item; + const QModelIndex index = m_viewAccessor.itemView()->indexAt(pos); + if (index.isValid() && (index.column() == DolphinModel::Name)) { + const QModelIndex dolphinModelIndex = m_viewAccessor.proxyModel()->mapToSource(index); + item = m_viewAccessor.dirModel()->itemForIndex(dolphinModelIndex); + } + + m_isContextMenuOpen = true; // TODO: workaround for Qt-issue 207192 + emit requestContextMenu(item, url(), customActions); + m_isContextMenuOpen = false; +} + +void DolphinView::dropUrls(const KFileItem& destItem, + const KUrl& destPath, + QDropEvent* event) +{ + addNewFileNames(event->mimeData()); + DragAndDropHelper::instance().dropUrls(destItem, destPath, event, this); +} + +void DolphinView::updateSorting(DolphinView::Sorting sorting) +{ + ViewProperties props(rootUrl()); + props.setSorting(sorting); + + m_viewAccessor.proxyModel()->setSorting(sorting); + + emit sortingChanged(sorting); +} + +void DolphinView::updateSortOrder(Qt::SortOrder order) +{ + ViewProperties props(rootUrl()); + props.setSortOrder(order); + + m_viewAccessor.proxyModel()->setSortOrder(order); + + emit sortOrderChanged(order); +} + +void DolphinView::updateSortFoldersFirst(bool foldersFirst) +{ + ViewProperties props(rootUrl()); + props.setSortFoldersFirst(foldersFirst); + + m_viewAccessor.proxyModel()->setSortFoldersFirst(foldersFirst); + + emit sortFoldersFirstChanged(foldersFirst); +} + +void DolphinView::updateAdditionalInfo(const KFileItemDelegate::InformationList& info) +{ + ViewProperties props(rootUrl()); + props.setAdditionalInfo(info); + props.save(); + + m_viewAccessor.itemDelegate()->setShowInformation(info); + + emit additionalInfoChanged(); +} + +void DolphinView::updateAdditionalInfoActions(KActionCollection* collection) +{ + const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance(); + + const KFileItemDelegate::InformationList checkedInfos = m_viewAccessor.itemDelegate()->showInformation(); + const KFileItemDelegate::InformationList infos = infoAccessor.keys(); + + const bool enable = (m_mode == DolphinView::DetailsView) || + (m_mode == DolphinView::IconsView); + + foreach (const KFileItemDelegate::Information& info, infos) { + const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::AdditionalInfoType); + QAction* action = collection->action(name); + Q_ASSERT(action != 0); + action->setEnabled(enable); + action->setChecked(checkedInfos.contains(info)); + } +} + +QPair<bool, QString> DolphinView::pasteInfo() const +{ + return KonqOperations::pasteInfo(url()); +} + +void DolphinView::setTabsForFilesEnabled(bool tabsForFiles) +{ + m_tabsForFiles = tabsForFiles; +} + +bool DolphinView::isTabsForFilesEnabled() const +{ + return m_tabsForFiles; +} + +bool DolphinView::itemsExpandable() const +{ + return m_viewAccessor.itemsExpandable(); +} + +void DolphinView::restoreState(QDataStream& stream) +{ + // current item + stream >> m_activeItemUrl; + + // view position + stream >> m_restoredContentsPosition; + + // expanded folders (only relevant for the details view - will be ignored by the view in other view modes) + QSet<KUrl> urlsToExpand; + stream >> urlsToExpand; + const DolphinDetailsViewExpander* expander = m_viewAccessor.setExpandedUrls(urlsToExpand); + if (expander != 0) { + m_expanderActive = true; + connect (expander, SIGNAL(completed()), this, SLOT(slotLoadingCompleted())); + } + else { + m_expanderActive = false; + } +} + +void DolphinView::saveState(QDataStream& stream) +{ + // current item + KFileItem currentItem; + const QAbstractItemView* view = m_viewAccessor.itemView(); + + if (view != 0) { + const QModelIndex proxyIndex = view->currentIndex(); + const QModelIndex dirModelIndex = m_viewAccessor.proxyModel()->mapToSource(proxyIndex); + currentItem = m_viewAccessor.dirModel()->itemForIndex(dirModelIndex); + } + + KUrl currentUrl; + if (!currentItem.isNull()) { + currentUrl = currentItem.url(); + } + + stream << currentUrl; + + // view position + const int x = view->horizontalScrollBar()->value(); + const int y = view->verticalScrollBar()->value(); + stream << QPoint(x, y); + + // expanded folders (only relevant for the details view - the set will be empty in other view modes) + stream << m_viewAccessor.expandedUrls(); +} + +void DolphinView::observeCreatedItem(const KUrl& url) +{ + m_createdItemUrl = url; + connect(m_viewAccessor.dirModel(), SIGNAL(rowsInserted(const QModelIndex&, int, int)), + this, SLOT(selectAndScrollToCreatedItem())); +} + +void DolphinView::selectAndScrollToCreatedItem() +{ + const QModelIndex dirIndex = m_viewAccessor.dirModel()->indexForUrl(m_createdItemUrl); + if (dirIndex.isValid()) { + const QModelIndex proxyIndex = m_viewAccessor.proxyModel()->mapFromSource(dirIndex); + m_viewAccessor.itemView()->setCurrentIndex(proxyIndex); + } + + disconnect(m_viewAccessor.dirModel(), SIGNAL(rowsInserted(const QModelIndex&, int, int)), + this, SLOT(selectAndScrollToCreatedItem())); + m_createdItemUrl = KUrl(); +} + +void DolphinView::showHoverInformation(const KFileItem& item) +{ + emit requestItemInfo(item); +} + +void DolphinView::clearHoverInformation() +{ + emit requestItemInfo(KFileItem()); +} + +void DolphinView::slotDeleteFileFinished(KJob* job) +{ + if (job->error() == 0) { + emit operationCompletedMessage(i18nc("@info:status", "Delete operation completed.")); + } else if (job->error() != KIO::ERR_USER_CANCELED) { + emit errorMessage(job->errorString()); + } +} + +void DolphinView::slotDirListerCompleted() +{ + if (!m_expanderActive) { + slotLoadingCompleted(); + } + + if (!m_newFileNames.isEmpty()) { + // select all newly added items created by a paste operation or + // a drag & drop operation, and clear the previous selection + m_viewAccessor.itemView()->clearSelection(); + const int rowCount = m_viewAccessor.proxyModel()->rowCount(); + QItemSelection selection; + for (int row = 0; row < rowCount; ++row) { + const QModelIndex proxyIndex = m_viewAccessor.proxyModel()->index(row, 0); + const QModelIndex dirIndex = m_viewAccessor.proxyModel()->mapToSource(proxyIndex); + const KUrl url = m_viewAccessor.dirModel()->itemForIndex(dirIndex).url(); + if (m_newFileNames.contains(url.fileName())) { + selection.merge(QItemSelection(proxyIndex, proxyIndex), QItemSelectionModel::Select); + } + } + m_viewAccessor.itemView()->selectionModel()->select(selection, QItemSelectionModel::Select); + + m_newFileNames.clear(); + } +} + +void DolphinView::slotLoadingCompleted() +{ + m_expanderActive = false; + + if (!m_activeItemUrl.isEmpty()) { + // assure that the current item remains visible + const QModelIndex dirIndex = m_viewAccessor.dirModel()->indexForUrl(m_activeItemUrl); + if (dirIndex.isValid()) { + const QModelIndex proxyIndex = m_viewAccessor.proxyModel()->mapFromSource(dirIndex); + QAbstractItemView* view = m_viewAccessor.itemView(); + const bool clearSelection = !hasSelection(); + view->setCurrentIndex(proxyIndex); + if (clearSelection) { + view->clearSelection(); + } + m_activeItemUrl.clear(); + } + } + + if (!m_selectedItems.isEmpty()) { + const KUrl& baseUrl = url(); + KUrl url; + QItemSelection newSelection; + foreach(const KFileItem& item, m_selectedItems) { + url = item.url().upUrl(); + if (baseUrl.equals(url, KUrl::CompareWithoutTrailingSlash)) { + QModelIndex index = m_viewAccessor.proxyModel()->mapFromSource(m_viewAccessor.dirModel()->indexForItem(item)); + newSelection.select(index, index); + } + } + m_viewAccessor.itemView()->selectionModel()->select(newSelection, + QItemSelectionModel::ClearAndSelect + | QItemSelectionModel::Current); + m_selectedItems.clear(); + } + + // Restore the contents position. This has to be done using a Qt::QueuedConnection + // because the view might not be in its final state yet. + QMetaObject::invokeMethod(this, "restoreContentsPosition", Qt::QueuedConnection); +} + +void DolphinView::slotRefreshItems() +{ + if (m_assureVisibleCurrentIndex) { + m_assureVisibleCurrentIndex = false; + m_viewAccessor.itemView()->scrollTo(m_viewAccessor.itemView()->currentIndex()); + } +} + +void DolphinView::loadDirectory(const KUrl& url, bool reload) +{ + if (!url.isValid()) { + const QString location(url.pathOrUrl()); + if (location.isEmpty()) { + emit errorMessage(i18nc("@info:status", "The location is empty.")); + } else { + emit errorMessage(i18nc("@info:status", "The location '%1' is invalid.", location)); + } + return; + } + + KDirLister* dirLister = m_viewAccessor.dirLister(); + dirLister->openUrl(url, reload ? KDirLister::Reload : KDirLister::NoFlags); +} + +void DolphinView::applyViewProperties() +{ + if (m_ignoreViewProperties) { + return; + } + + const ViewProperties props(rootUrl()); + + const Mode mode = props.viewMode(); + if (m_mode != mode) { + const int oldZoomLevel = m_viewModeController->zoomLevel(); + + m_mode = mode; + createView(); + emit modeChanged(); + + updateZoomLevel(oldZoomLevel); + } + if (m_viewAccessor.itemView() == 0) { + createView(); + } + Q_ASSERT(m_viewAccessor.itemView() != 0); + Q_ASSERT(m_viewAccessor.itemDelegate() != 0); + + const bool showHiddenFiles = props.showHiddenFiles(); + if (showHiddenFiles != m_viewAccessor.dirLister()->showingDotFiles()) { + m_viewAccessor.dirLister()->setShowingDotFiles(showHiddenFiles); + emit showHiddenFilesChanged(); + } + + m_storedCategorizedSorting = props.categorizedSorting(); + const bool categorized = m_storedCategorizedSorting && supportsCategorizedSorting(); + if (categorized != m_viewAccessor.proxyModel()->isCategorizedModel()) { + m_viewAccessor.proxyModel()->setCategorizedModel(categorized); + emit categorizedSortingChanged(); + } + + const DolphinView::Sorting sorting = props.sorting(); + if (sorting != m_viewAccessor.proxyModel()->sorting()) { + m_viewAccessor.proxyModel()->setSorting(sorting); + emit sortingChanged(sorting); + } + + const Qt::SortOrder sortOrder = props.sortOrder(); + if (sortOrder != m_viewAccessor.proxyModel()->sortOrder()) { + m_viewAccessor.proxyModel()->setSortOrder(sortOrder); + emit sortOrderChanged(sortOrder); + } + + const bool sortFoldersFirst = props.sortFoldersFirst(); + if (sortFoldersFirst != m_viewAccessor.proxyModel()->sortFoldersFirst()) { + m_viewAccessor.proxyModel()->setSortFoldersFirst(sortFoldersFirst); + emit sortFoldersFirstChanged(sortFoldersFirst); + } + + KFileItemDelegate::InformationList info = props.additionalInfo(); + if (info != m_viewAccessor.itemDelegate()->showInformation()) { + m_viewAccessor.itemDelegate()->setShowInformation(info); + emit additionalInfoChanged(); + } + + const bool showPreview = props.showPreview(); + if (showPreview != m_showPreview) { + m_showPreview = showPreview; + const int oldZoomLevel = m_viewModeController->zoomLevel(); + emit showPreviewChanged(); + + // Enabling or disabling the preview might change the icon size of the view. + // As the view does not emit a signal when the icon size has been changed, + // the used zoom level of the controller must be adjusted manually: + updateZoomLevel(oldZoomLevel); + } + + if (DolphinSettings::instance().generalSettings()->globalViewProps()) { + // During the lifetime of a DolphinView instance the global view properties + // should not be changed. This allows e. g. to split a view and use different + // view properties for each view. + m_ignoreViewProperties = true; + } +} + +void DolphinView::createView() +{ + deleteView(); + + Q_ASSERT(m_viewAccessor.itemView() == 0); + m_viewAccessor.createView(this, m_dolphinViewController, m_viewModeController, m_mode); + + QAbstractItemView* view = m_viewAccessor.itemView(); + Q_ASSERT(view != 0); + view->installEventFilter(this); + view->viewport()->installEventFilter(this); + + m_dolphinViewController->setItemView(view); + + // When changing the view mode, the selection is lost due to reinstantiating + // a new item view with a custom selection model. Pass the ownership of the + // selection model to DolphinView, so that it can be shared by all item views. + if (m_selectionModel != 0) { + view->setSelectionModel(m_selectionModel); + } else { + m_selectionModel = view->selectionModel(); + } + m_selectionModel->setParent(this); + connect(m_selectionModel, SIGNAL(selectionChanged(QItemSelection, QItemSelection)), + this, SLOT(slotSelectionChanged(QItemSelection, QItemSelection))); + + setFocusProxy(m_viewAccessor.layoutTarget()); + m_topLayout->insertWidget(1, m_viewAccessor.layoutTarget()); +} + +void DolphinView::deleteView() +{ + QAbstractItemView* view = m_viewAccessor.itemView(); + if (view != 0) { + // It's important to set the keyboard focus to the parent + // before deleting the view: Otherwise when having a split + // view the other view will get the focus and will request + // an activation (see DolphinView::eventFilter()). + setFocusProxy(0); + setFocus(); + + m_topLayout->removeWidget(view); + view->close(); + + // disconnect all signal/slots + disconnect(view); + m_viewModeController->disconnect(view); + view->disconnect(); + + m_viewAccessor.deleteView(); + } +} + +void DolphinView::pasteToUrl(const KUrl& url) +{ + addNewFileNames(QApplication::clipboard()->mimeData()); + KonqOperations::doPaste(this, url); +} + +void DolphinView::updateZoomLevel(int oldZoomLevel) +{ + const int newZoomLevel = ZoomLevelInfo::zoomLevelForIconSize(m_viewAccessor.itemView()->iconSize()); + if (oldZoomLevel != newZoomLevel) { + m_viewModeController->setZoomLevel(newZoomLevel); + emit zoomLevelChanged(newZoomLevel); + } +} + +KUrl::List DolphinView::simplifiedSelectedUrls() const +{ + KUrl::List list = selectedUrls(); + if (itemsExpandable() ) { + list = KDirModel::simplifiedUrlList(list); + } + return list; +} + +QMimeData* DolphinView::selectionMimeData() const +{ + const QAbstractItemView* view = m_viewAccessor.itemView(); + Q_ASSERT((view != 0) && (view->selectionModel() != 0)); + const QItemSelection selection = m_viewAccessor.proxyModel()->mapSelectionToSource(view->selectionModel()->selection()); + return m_viewAccessor.dirModel()->mimeData(selection.indexes()); +} + +void DolphinView::addNewFileNames(const QMimeData* mimeData) +{ + const KUrl::List urls = KUrl::List::fromMimeData(mimeData); + foreach (const KUrl& url, urls) { + m_newFileNames.insert(url.fileName()); + } +} + +DolphinView::ViewAccessor::ViewAccessor(DolphinSortFilterProxyModel* proxyModel) : + m_iconsView(0), + m_detailsView(0), + m_columnsContainer(0), + m_proxyModel(proxyModel), + m_dragSource(0) +{ +} + +DolphinView::ViewAccessor::~ViewAccessor() +{ + delete m_dragSource; + m_dragSource = 0; +} + +void DolphinView::ViewAccessor::createView(QWidget* parent, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController, + Mode mode) +{ + Q_ASSERT(itemView() == 0); + + switch (mode) { + case IconsView: + m_iconsView = new DolphinIconsView(parent, + dolphinViewController, + viewModeController, + m_proxyModel); + break; + + case DetailsView: + m_detailsView = new DolphinDetailsView(parent, + dolphinViewController, + viewModeController, + m_proxyModel); + break; + + case ColumnView: + m_columnsContainer = new DolphinColumnViewContainer(parent, + dolphinViewController, + viewModeController); + break; + + default: + Q_ASSERT(false); + } +} + +void DolphinView::ViewAccessor::deleteView() +{ + QAbstractItemView* view = itemView(); + if (view != 0) { + if (DragAndDropHelper::instance().isDragSource(view)) { + // The view is a drag source (the feature "Open folders + // during drag operations" is used). Deleting the view + // during an ongoing drag operation is not allowed, so + // this will postponed. + if (m_dragSource != 0) { + // the old stored view is obviously not the drag source anymore + m_dragSource->deleteLater(); + m_dragSource = 0; + } + view->hide(); + m_dragSource = view; + } else { + view->deleteLater(); + } + } + + m_iconsView = 0; + m_detailsView = 0; + + if (m_columnsContainer != 0) { + m_columnsContainer->deleteLater(); + } + m_columnsContainer = 0; +} + + +void DolphinView::ViewAccessor::prepareUrlChange(const KUrl& url) +{ + if (m_columnsContainer != 0) { + m_columnsContainer->showColumn(url); + } +} + +QAbstractItemView* DolphinView::ViewAccessor::itemView() const +{ + if (m_iconsView != 0) { + return m_iconsView; + } + + if (m_detailsView != 0) { + return m_detailsView; + } + + if (m_columnsContainer != 0) { + return m_columnsContainer->activeColumn(); + } + + return 0; +} + +KFileItemDelegate* DolphinView::ViewAccessor::itemDelegate() const +{ + return static_cast<KFileItemDelegate*>(itemView()->itemDelegate()); +} + +QWidget* DolphinView::ViewAccessor::layoutTarget() const +{ + if (m_columnsContainer != 0) { + return m_columnsContainer; + } + return itemView(); +} + +KUrl DolphinView::ViewAccessor::rootUrl() const +{ + return (m_columnsContainer != 0) ? m_columnsContainer->rootUrl() : KUrl(); +} + +bool DolphinView::ViewAccessor::supportsCategorizedSorting() const +{ + return m_iconsView != 0; +} + +bool DolphinView::ViewAccessor::itemsExpandable() const +{ + return (m_detailsView != 0) && m_detailsView->itemsExpandable(); +} + + +QSet<KUrl> DolphinView::ViewAccessor::expandedUrls() const +{ + if (m_detailsView != 0) { + return m_detailsView->expandedUrls(); + } + + return QSet<KUrl>(); +} + +const DolphinDetailsViewExpander* DolphinView::ViewAccessor::setExpandedUrls(const QSet<KUrl>& urlsToExpand) +{ + if ((m_detailsView != 0) && m_detailsView->itemsExpandable() && !urlsToExpand.isEmpty()) { + // Check if another expander is already active and stop it if necessary. + if(!m_detailsViewExpander.isNull()) { + m_detailsViewExpander->stop(); + } + + m_detailsViewExpander = new DolphinDetailsViewExpander(m_detailsView, urlsToExpand); + return m_detailsViewExpander; + } + else { + return 0; + } +} + +bool DolphinView::ViewAccessor::reloadOnAdditionalInfoChange() const +{ + // the details view requires no reloading of the directory, as it maps + // the file item delegate info to its columns internally + return m_detailsView != 0; +} + +DolphinModel* DolphinView::ViewAccessor::dirModel() const +{ + return static_cast<DolphinModel*>(proxyModel()->sourceModel()); +} + +DolphinSortFilterProxyModel* DolphinView::ViewAccessor::proxyModel() const +{ + if (m_columnsContainer != 0) { + return static_cast<DolphinSortFilterProxyModel*>(m_columnsContainer->activeColumn()->model()); + } + return m_proxyModel; +} + +KDirLister* DolphinView::ViewAccessor::dirLister() const +{ + return dirModel()->dirLister(); +} + +void DolphinView::slotRedirection(const KUrl& oldUrl, const KUrl& newUrl) +{ + if (oldUrl.equals(url(), KUrl::CompareWithoutTrailingSlash)) { + emit redirection(oldUrl, newUrl); + m_viewModeController->redirectToUrl(newUrl); // #186947 + } +} + +void DolphinView::restoreContentsPosition() +{ + if (!m_restoredContentsPosition.isNull()) { + const int x = m_restoredContentsPosition.x(); + const int y = m_restoredContentsPosition.y(); + m_restoredContentsPosition = QPoint(); + + QAbstractItemView* view = m_viewAccessor.itemView(); + Q_ASSERT(view != 0); + view->horizontalScrollBar()->setValue(x); + view->verticalScrollBar()->setValue(y); + } +} + +#include "dolphinview.moc" diff --git a/src/views/dolphinview.h b/src/views/dolphinview.h new file mode 100644 index 000000000..dbef511bf --- /dev/null +++ b/src/views/dolphinview.h @@ -0,0 +1,818 @@ +/*************************************************************************** + * Copyright (C) 2006-2009 by Peter Penz <[email protected]> * + * Copyright (C) 2006 by Gregor Kališnik <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + + +#ifndef DOLPHINVIEW_H +#define DOLPHINVIEW_H + +#include <config-nepomuk.h> + +#include "libdolphin_export.h" + +#include <kparts/part.h> +#include <kfileitem.h> +#include <kfileitemdelegate.h> +#include <kio/fileundomanager.h> +#include <kio/job.h> + +#include <QBoxLayout> +#include <QKeyEvent> +#include <QLinkedList> +#include <QListView> +#include <QSet> +#include <QWidget> + +typedef KIO::FileUndoManager::CommandType CommandType; + +class DolphinColumnViewContainer; +class DolphinDetailsView; +class DolphinIconsView; +class DolphinModel; +class DolphinSortFilterProxyModel; +class DolphinViewController; +class KAction; +class KActionCollection; +class KDirLister; +class KUrl; +class ViewModeController; +class ViewProperties; +class DolphinDetailsViewExpander; + +/** + * @short Represents a view for the directory content. + * + * View modes for icons, details and columns are supported. It's + * possible to adjust: + * - sort order + * - sort type + * - show hidden files + * - show previews + * + * @see DolphinIconsView + * @see DolphinDetailsView + * @see DolphinColumnView + */ +class LIBDOLPHINPRIVATE_EXPORT DolphinView : public QWidget +{ + Q_OBJECT + +public: + /** + * Defines the view mode for a directory. The view mode + * can be defined when constructing a DolphinView. The + * view mode is automatically updated if the directory itself + * defines a view mode (see class ViewProperties for details). + */ + enum Mode + { + /** + * The directory items are shown as icons including an + * icon name. + */ + IconsView = 0, + + /** + * The icon, the name and at least the size of the directory + * items are shown in a table. It is possible to add columns + * for date, group and permissions. + */ + DetailsView = 1, + + /** + * Each folder is shown in a separate column. + */ + ColumnView = 2, + MaxModeEnum = ColumnView + }; + + /** Defines the sort order for the items of a directory. */ + enum Sorting + { + SortByName = 0, + SortBySize, + SortByDate, + SortByPermissions, + SortByOwner, + SortByGroup, + SortByType, + SortByDestination, + SortByPath, + MaxSortingEnum = SortByPath + }; + + /** + * @param parent Parent widget of the view. + * @param url Specifies the content which should be shown. + * @param proxyModel Used proxy model which specifies the sorting. The + * model is not owned by the view and won't get + * deleted. + */ + DolphinView(QWidget* parent, + const KUrl& url, + DolphinSortFilterProxyModel* proxyModel); + + virtual ~DolphinView(); + + /** + * Returns the current active URL, where all actions are applied. + * The URL navigator is synchronized with this URL. + */ + KUrl url() const; + + /** + * Returns the root URL of the view, which is defined as the first + * visible path of DolphinView::url(). Usually the root URL is + * equal to DolphinView::url(), but in the case of the column view + * when 2 columns are shown, the root URL might be: + * /home/peter/Documents + * and DolphinView::url() might return + * /home/peter/Documents/Music/ + */ + KUrl rootUrl() const; + + /** + * If \a active is true, the view will marked as active. The active + * view is defined as view where all actions are applied to. + */ + void setActive(bool active); + bool isActive() const; + + /** + * Changes the view mode for the current directory to \a mode. + * If the view properties should be remembered for each directory + * (GeneralSettings::globalViewProps() returns false), then the + * changed view mode will be stored automatically. + */ + void setMode(Mode mode); + Mode mode() const; + + /** See setShowPreview */ + bool showPreview() const; + + /** See setShowHiddenFiles */ + bool showHiddenFiles() const; + + /** See setCategorizedSorting */ + bool categorizedSorting() const; + + /** + * Returns true, if the categorized sorting is supported by the current + * used mode (see DolphinView::setMode()). Currently only DolphinView::IconsView + * supports categorizations. To check whether the categorized + * sorting is set, use DolphinView::categorizedSorting(). + */ + bool supportsCategorizedSorting() const; + + /** + * Marks the items indicated by \p urls to get selected after the + * directory DolphinView::url() has been loaded. Note that nothing + * gets selected if no loading of a directory has been triggered + * by DolphinView::setUrl() or DolphinView::reload(). + */ + void markUrlsAsSelected(const QList<KUrl>& urls); + + /** + * Returns the selected items. The list is empty if no item has been + * selected. + * @see DolphinView::selectedUrls() + */ + KFileItemList selectedItems() const; + + /** + * Returns a list of URLs for all selected items. An empty list + * is returned, if no item is selected. + * @see DolphinView::selectedItems() + */ + KUrl::List selectedUrls() const; + + /** + * Returns the number of selected items (this is faster than + * invoking selectedItems().count()). + */ + int selectedItemsCount() const; + + QItemSelectionModel* selectionModel() const; + + /** + * Sets the zoom level to \a level. It is assured that the used + * level is adjusted to be inside the range ZoomLevelInfo::minimumLevel() and + * ZoomLevelInfo::maximumLevel(). + */ + void setZoomLevel(int level); + int zoomLevel() const; + + /** + * Returns true, if zooming in is possible. If false is returned, + * the maximum zooming level has been reached. + */ + bool isZoomInPossible() const; + + /** + * Returns true, if zooming out is possible. If false is returned, + * the minimum zooming level has been reached. + */ + bool isZoomOutPossible() const; + + /** Sets the sort order of the items inside a directory (see DolphinView::Sorting). */ + void setSorting(Sorting sorting); + + /** Returns the sort order of the items inside a directory (see DolphinView::Sorting). */ + Sorting sorting() const; + + /** Sets the sort order (Qt::Ascending or Qt::Descending) for the items. */ + void setSortOrder(Qt::SortOrder order); + + /** Returns the current used sort order (Qt::Ascending or Qt::Descending). */ + Qt::SortOrder sortOrder() const; + + /** Sets a separate sorting with folders first (true) or a mixed sorting of files and folders (false). */ + void setSortFoldersFirst(bool foldersFirst); + + /** Returns if files and folders are sorted separately or not. */ + bool sortFoldersFirst() const; + + /** Sets the additional information which should be shown for the items. */ + void setAdditionalInfo(KFileItemDelegate::InformationList info); + + /** Returns the additional information which should be shown for the items. */ + KFileItemDelegate::InformationList additionalInfo() const; + + /** Reloads the current directory. */ + void reload(); + + /** + * Refreshes the view to get synchronized with the (updated) Dolphin settings. + * This method only needs to get invoked if the view settings for the Icons View, + * Details View or Columns View have been changed. + */ + void refresh(); + + /** + * Filters the currently shown items by \a nameFilter. All items + * which contain the given filter string will be shown. + */ + void setNameFilter(const QString& nameFilter); + + /** + * Calculates the number of currently shown files into + * \a fileCount and the number of folders into \a folderCount. + * The size of all files is written into \a totalFileSize. + * It is recommend using this method instead of asking the + * directory lister or the model directly, as it takes + * filtering and hierarchical previews into account. + */ + void calculateItemCount(int& fileCount, int& folderCount, KIO::filesize_t& totalFileSize) const; + + /** + * Returns a textual representation of the state of the current + * folder or selected items, suitable for use in the status bar. + */ + QString statusBarText() const; + + /** + * Returns the version control actions that are provided for the items \p items. + * Usually the actions are presented in the context menu. + */ + QList<QAction*> versionControlActions(const KFileItemList& items) const; + + /** + * Updates the state of the 'Additional Information' actions in \a collection. + */ + void updateAdditionalInfoActions(KActionCollection* collection); + + /** + * Returns the state of the paste action: + * first is whether the action should be enabled + * second is the text for the action + */ + QPair<bool, QString> pasteInfo() const; + + /** + * If \a tabsForFiles is true, the signal tabRequested() will also + * emitted also for files. Per default tabs for files is disabled + * and hence the signal tabRequested() will only be emitted for + * directories. + */ + void setTabsForFilesEnabled(bool tabsForFiles); + bool isTabsForFilesEnabled() const; + + /** + * Returns true if the current view allows folders to be expanded, + * i.e. presents a hierarchical view to the user. + */ + bool itemsExpandable() const; + + /** + * Restores the view state (current item, contents position, details view expansion state) + */ + void restoreState(QDataStream& stream); + + /** + * Saves the view state (current item, contents position, details view expansion state) + */ + void saveState(QDataStream& stream); + +public slots: + /** + * Changes the directory to \a url. If the current directory is equal to + * \a url, nothing will be done (use DolphinView::reload() instead). + */ + void setUrl(const KUrl& url); + + /** + * Selects all items. + * @see DolphinView::selectedItems() + */ + void selectAll(); + + /** + * Inverts the current selection: selected items get unselected, + * unselected items get selected. + * @see DolphinView::selectedItems() + */ + void invertSelection(); + + /** Returns true, if at least one item is selected. */ + bool hasSelection() const; + + void clearSelection(); + + /** + * Triggers the renaming of the currently selected items, where + * the user must input a new name for the items. + */ + void renameSelectedItems(); + + /** + * Moves all selected items to the trash. + */ + void trashSelectedItems(); + + /** + * Deletes all selected items. + */ + void deleteSelectedItems(); + + /** + * Copies all selected items to the clipboard and marks + * the items as cut. + */ + void cutSelectedItems(); + + /** Copies all selected items to the clipboard. */ + void copySelectedItems(); + + /** Pastes the clipboard data to this view. */ + void paste(); + + /** + * Pastes the clipboard data into the currently selected + * folder. If the current selection is not exactly one folder, no + * paste operation is done. + */ + void pasteIntoFolder(); + + /** + * Turns on the file preview for the all files of the current directory, + * if \a show is true. + * If the view properties should be remembered for each directory + * (GeneralSettings::globalViewProps() returns false), then the + * preview setting will be stored automatically. + */ + void setShowPreview(bool show); + + /** + * Shows all hidden files of the current directory, + * if \a show is true. + * If the view properties should be remembered for each directory + * (GeneralSettings::globalViewProps() returns false), then the + * show hidden file setting will be stored automatically. + */ + void setShowHiddenFiles(bool show); + + /** + * Summarizes all sorted items by their category \a categorized + * is true. + * If the view properties should be remembered for each directory + * (GeneralSettings::globalViewProps() returns false), then the + * categorized sorting setting will be stored automatically. + */ + void setCategorizedSorting(bool categorized); + + /** Switches between an ascending and descending sorting order. */ + void toggleSortOrder(); + + /** Switches between a separate sorting (with folders first) and a mixed sorting of files and folders. */ + void toggleSortFoldersFirst(); + + /** + * Switches on or off the displaying of additional information + * as specified by \a action. + */ + void toggleAdditionalInfo(QAction* action); + +signals: + /** + * Is emitted if the view has been activated by e. g. a mouse click. + */ + void activated(); + + /** Is emitted if URL of the view has been changed to \a url. */ + void urlChanged(const KUrl& url); + + /** + * Is emitted when clicking on an item with the left mouse button. + */ + void itemTriggered(const KFileItem& item); + + /** + * Is emitted if a new tab should be opened for the URL \a url. + */ + void tabRequested(const KUrl& url); + + /** + * Is emitted if the view mode (IconsView, DetailsView, + * PreviewsView) has been changed. + */ + void modeChanged(); + + /** Is emitted if the 'show preview' property has been changed. */ + void showPreviewChanged(); + + /** Is emitted if the 'show hidden files' property has been changed. */ + void showHiddenFilesChanged(); + + /** Is emitted if the 'categorized sorting' property has been changed. */ + void categorizedSortingChanged(); + + /** Is emitted if the sorting by name, size or date has been changed. */ + void sortingChanged(DolphinView::Sorting sorting); + + /** Is emitted if the sort order (ascending or descending) has been changed. */ + void sortOrderChanged(Qt::SortOrder order); + + /** Is emitted if the sorting of files and folders (separate with folders first or mixed) has been changed. */ + void sortFoldersFirstChanged(bool foldersFirst); + + /** Is emitted if the additional information shown for this view has been changed. */ + void additionalInfoChanged(); + + /** Is emitted if the zoom level has been changed by zooming in or out. */ + void zoomLevelChanged(int level); + + /** + * Is emitted if information of an item is requested to be shown e. g. in the panel. + * If item is null, no item information request is pending. + */ + void requestItemInfo(const KFileItem& item); + + /** + * Is emitted whenever the selection has been changed. + */ + void selectionChanged(const KFileItemList& selection); + + /** + * Is emitted if a context menu is requested for the item \a item, + * which is part of \a url. If the item is null, the context menu + * for the URL should be shown and the custom actions \a customActions + * will be added. + */ + void requestContextMenu(const KFileItem& item, + const KUrl& url, + const QList<QAction*>& customActions); + + /** + * Is emitted if an information message with the content \a msg + * should be shown. + */ + void infoMessage(const QString& msg); + + /** + * Is emitted if an error message with the content \a msg + * should be shown. + */ + void errorMessage(const QString& msg); + + /** + * Is emitted if an "operation completed" message with the content \a msg + * should be shown. + */ + void operationCompletedMessage(const QString& msg); + + /** + * Is emitted after DolphinView::setUrl() has been invoked and + * the path \a url is currently loaded. If this signal is emitted, + * it is assured that the view contains already the correct root + * URL and property settings. + */ + void startedPathLoading(const KUrl& url); + + /** + * Emitted when KDirLister emits redirection. + * Testcase: fish://localhost + */ + void redirection(const KUrl& oldUrl, const KUrl& newUrl); + +protected: + /** @see QWidget::mouseReleaseEvent */ + virtual void mouseReleaseEvent(QMouseEvent* event); + virtual bool eventFilter(QObject* watched, QEvent* event); + +private slots: + /** + * Marks the view as active (DolphinView:isActive() will return true) + * and emits the 'activated' signal if it is not already active. + */ + void activate(); + + /** + * If the item \a item is a directory, then this + * directory will be loaded. If the item is a file, the corresponding + * application will get started. + */ + void triggerItem(const KFileItem& index); + + /** + * Emits the signal \a selectionChanged() with a small delay. This is + * because getting all file items for the signal can be an expensive + * operation. Fast selection changes are collected in this case and + * the signal is emitted only after no selection change has been done + * within a small delay. + */ + void slotSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected); + + /** + * Is called by emitDelayedSelectionChangedSignal() and emits the + * signal \a selectionChanged() with all selected file items as parameter. + */ + void emitSelectionChangedSignal(); + + /** + * Opens the context menu on position \a pos. The position + * is used to check whether the context menu is related to an + * item or to the viewport. + */ + void openContextMenu(const QPoint& pos, const QList<QAction*>& customActions); + + /** + * Drops dragged URLs to the destination path \a destPath. If + * the URLs are dropped above an item inside the destination path, + * the item is indicated by \a destItem. + */ + void dropUrls(const KFileItem& destItem, + const KUrl& destPath, + QDropEvent* event); + + /** + * Updates the view properties of the current URL to the + * sorting given by \a sorting. + */ + void updateSorting(DolphinView::Sorting sorting); + + /** + * Updates the view properties of the current URL to the + * sort order given by \a order. + */ + void updateSortOrder(Qt::SortOrder order); + + /** + * Updates the view properties of the current URL to the + * sorting of files and folders (separate with folders first or mixed) given by \a foldersFirst. + */ + void updateSortFoldersFirst(bool foldersFirst); + + /** + * Updates the view properties of the current URL to the + * additional information given by \a info. + */ + void updateAdditionalInfo(const KFileItemDelegate::InformationList& info); + + /** + * Updates the status bar to show hover information for the + * item \a item. If currently other items are selected, + * no hover information is shown. + * @see DolphinView::clearHoverInformation() + */ + void showHoverInformation(const KFileItem& item); + + /** + * Clears the hover information shown in the status bar. + * @see DolphinView::showHoverInformation(). + */ + void clearHoverInformation(); + + /** + * Indicates in the status bar that the delete operation + * of the job \a job has been finished. + */ + void slotDeleteFileFinished(KJob* job); + + /** + * Invoked when the directory lister has completed the loading of + * items. Assures that pasted items and renamed items get seleced. + */ + void slotDirListerCompleted(); + + /** + * Invoked when the loading of the directory is finished. + * Restores the active item and the scroll position if possible. + */ + void slotLoadingCompleted(); + + /** + * Is invoked when the KDirLister indicates refreshed items. + */ + void slotRefreshItems(); + + /** + * Observes the item with the URL \a url. As soon as the directory + * model indicates that the item is available, the item will + * get selected and it is assure that the item stays visible. + * + * @see selectAndScrollToCreatedItem() + */ + void observeCreatedItem(const KUrl& url); + + /** + * Selects and scrolls to the item that got observed + * by observeCreatedItem(). + */ + void selectAndScrollToCreatedItem(); + + /** + * Called when a redirection happens. + * Testcase: fish://localhost + */ + void slotRedirection(const KUrl& oldUrl, const KUrl& newUrl); + + /** + * Restores the contents position, if history information about the old position is available. + */ + void restoreContentsPosition(); + +private: + void loadDirectory(const KUrl& url, bool reload = false); + + /** + * Applies the view properties which are defined by the current URL + * to the DolphinView properties. + */ + void applyViewProperties(); + + /** + * Creates a new view representing the given view mode (DolphinView::mode()). + * The current view will get deleted. + */ + void createView(); + + void deleteView(); + + /** + * Helper method for DolphinView::paste() and DolphinView::pasteIntoFolder(). + * Pastes the clipboard data into the URL \a url. + */ + void pasteToUrl(const KUrl& url); + + /** + * Checks whether the current item view has the same zoom level + * as \a oldZoomLevel. If this is not the case, the zoom level + * of the controller is updated and a zoomLevelChanged() signal + * is emitted. + */ + void updateZoomLevel(int oldZoomLevel); + + /** + * Returns a list of URLs for all selected items. The list is + * simplified, so that when the URLs are part of different tree + * levels, only the parent is returned. + */ + KUrl::List simplifiedSelectedUrls() const; + + /** + * Returns the MIME data for all selected items. + */ + QMimeData* selectionMimeData() const; + + /** + * Is invoked after a paste operation or a drag & drop + * operation and adds the filenames of all URLs from \a mimeData to + * m_newFileNames. This allows to select all newly added + * items in slotDirListerCompleted(). + */ + void addNewFileNames(const QMimeData* mimeData); + +private: + /** + * Abstracts the access to the different view implementations + * for icons-, details- and column-view. + */ + class ViewAccessor + { + public: + ViewAccessor(DolphinSortFilterProxyModel* proxyModel); + ~ViewAccessor(); + + void createView(QWidget* parent, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController, + Mode mode); + void deleteView(); + + /** + * Must be invoked before the URL has been changed and allows view implementations + * like the column view to create a new column. + */ + void prepareUrlChange(const KUrl& url); + + QAbstractItemView* itemView() const; + KFileItemDelegate* itemDelegate() const; + + /** + * Returns the widget that should be added to the layout as target. Usually + * the item view itself is returned, but in the case of the column view + * a container widget is returned. + */ + QWidget* layoutTarget() const; + + KUrl rootUrl() const; + + bool supportsCategorizedSorting() const; + bool itemsExpandable() const; + QSet<KUrl> expandedUrls() const; + const DolphinDetailsViewExpander* setExpandedUrls(const QSet<KUrl>& urlsToExpand); + + /** + * Returns true, if a reloading of the items is required + * when the additional information properties have been changed + * by the user. + */ + bool reloadOnAdditionalInfoChange() const; + + DolphinModel* dirModel() const; + DolphinSortFilterProxyModel* proxyModel() const; + KDirLister* dirLister() const; + + private: + DolphinIconsView* m_iconsView; + DolphinDetailsView* m_detailsView; + DolphinColumnViewContainer* m_columnsContainer; + DolphinSortFilterProxyModel* m_proxyModel; + QAbstractItemView* m_dragSource; + QPointer<DolphinDetailsViewExpander> m_detailsViewExpander; + }; + + bool m_active : 1; + bool m_showPreview : 1; + bool m_storedCategorizedSorting : 1; + bool m_tabsForFiles : 1; + bool m_isContextMenuOpen : 1; // TODO: workaround for Qt-issue 207192 + bool m_ignoreViewProperties : 1; + bool m_assureVisibleCurrentIndex : 1; + bool m_expanderActive : 1; + + Mode m_mode; + + QVBoxLayout* m_topLayout; + + DolphinViewController* m_dolphinViewController; + ViewModeController* m_viewModeController; + ViewAccessor m_viewAccessor; + + QItemSelectionModel* m_selectionModel; // allow to switch views without losing the selection + QTimer* m_selectionChangedTimer; + + KUrl m_rootUrl; + KUrl m_activeItemUrl; + QPoint m_restoredContentsPosition; + KUrl m_createdItemUrl; // URL for a new item that got created by the "Create New..." menu + KFileItemList m_selectedItems; // this is used for making the View to remember selections after F5 + + /** + * Remembers the filenames that have been added by a paste operation + * or a drag & drop operation. Allows to select the items in + * slotDirListerCompleted(). + */ + QSet<QString> m_newFileNames; +}; + +/// Allow using DolphinView::Mode in QVariant +Q_DECLARE_METATYPE(DolphinView::Mode) + +#endif // DOLPHINVIEW_H diff --git a/src/views/dolphinviewautoscroller.cpp b/src/views/dolphinviewautoscroller.cpp new file mode 100644 index 000000000..45896a5eb --- /dev/null +++ b/src/views/dolphinviewautoscroller.cpp @@ -0,0 +1,223 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "dolphinviewautoscroller.h" + +#include <QAbstractItemView> +#include <QApplication> +#include <QCursor> +#include <QEvent> +#include <QMouseEvent> +#include <QScrollBar> +#include <QTimer> +#include <math.h> + +DolphinViewAutoScroller::DolphinViewAutoScroller(QAbstractItemView* parent) : + QObject(parent), + m_rubberBandSelection(false), + m_keyPressed(false), + m_initializedTimestamp(false), + m_horizontalScrollInc(0), + m_verticalScrollInc(0), + m_itemView(parent), + m_timer(0), + m_timestamp() +{ + m_itemView->setAutoScroll(false); + m_itemView->viewport()->installEventFilter(this); + m_itemView->installEventFilter(this); + + m_timer = new QTimer(this); + m_timer->setSingleShot(false); + m_timer->setInterval(1000 / 25); // 25 frames per second + connect(m_timer, SIGNAL(timeout()), this, SLOT(scrollViewport())); +} + +DolphinViewAutoScroller::~DolphinViewAutoScroller() +{ +} + +bool DolphinViewAutoScroller::isActive() const +{ + return m_timer->isActive(); +} + +void DolphinViewAutoScroller::handleCurrentIndexChange(const QModelIndex& current, + const QModelIndex& previous) +{ + // When the autoscroller is inactive and a key has been pressed, it must be + // assured that the current item stays visible. The check whether the previous + // item is valid is important because of #197951. The keypress check is done + // because of #199833. + if (current.isValid() && (previous.isValid() || m_keyPressed) && !isActive()) { + m_itemView->scrollTo(current); + } +} + +bool DolphinViewAutoScroller::eventFilter(QObject* watched, QEvent* event) +{ + if (watched == m_itemView->viewport()) { + switch (event->type()) { + case QEvent::MouseButtonPress: + if (static_cast<QMouseEvent*>(event)->button() == Qt::LeftButton) { + m_rubberBandSelection = true; + } + break; + + case QEvent::MouseMove: + if (m_rubberBandSelection) { + triggerAutoScroll(); + } + break; + + case QEvent::MouseButtonRelease: + m_rubberBandSelection = false; + stopAutoScroll(); + break; + + case QEvent::DragEnter: + case QEvent::DragMove: + m_rubberBandSelection = false; + triggerAutoScroll(); + break; + + case QEvent::Drop: + case QEvent::DragLeave: + m_rubberBandSelection = false; + stopAutoScroll(); + break; + + default: + break; + } + } else if (watched == m_itemView) { + switch (event->type()) { + case QEvent::KeyPress: + m_keyPressed = true; + break; + + case QEvent::KeyRelease: + m_keyPressed = false; + break; + + default: + break; + } + } + + return QObject::eventFilter(watched, event); +} + +void DolphinViewAutoScroller::scrollViewport() +{ + if (m_timestamp.elapsed() < QApplication::startDragTime()) { + return; + } + + QScrollBar* verticalScrollBar = m_itemView->verticalScrollBar(); + if (verticalScrollBar != 0) { + const int value = verticalScrollBar->value(); + verticalScrollBar->setValue(value + m_verticalScrollInc); + + } + QScrollBar* horizontalScrollBar = m_itemView->horizontalScrollBar(); + if (horizontalScrollBar != 0) { + const int value = horizontalScrollBar->value(); + horizontalScrollBar->setValue(value + m_horizontalScrollInc); + + } + + if (m_rubberBandSelection) { + // The scrolling does not lead to an update of the rubberband + // selection. Fake a mouse move event to let the QAbstractItemView + // update the rubberband. + QWidget* viewport = m_itemView->viewport(); + const QPoint pos = viewport->mapFromGlobal(QCursor::pos()); + QMouseEvent event(QEvent::MouseMove, pos, Qt::LeftButton, Qt::LeftButton, QApplication::keyboardModifiers()); + QCoreApplication::sendEvent(viewport, &event); + } +} + +void DolphinViewAutoScroller::triggerAutoScroll() +{ + const bool verticalScrolling = (m_itemView->verticalScrollBar() != 0) && + m_itemView->verticalScrollBar()->isVisible(); + const bool horizontalScrolling = (m_itemView->horizontalScrollBar() != 0) && + m_itemView->horizontalScrollBar()->isVisible(); + if (!verticalScrolling && !horizontalScrolling) { + // no scrollbars are shown at all, so no autoscrolling is necessary + stopAutoScroll(); + return; + } + + QWidget* viewport = m_itemView->viewport(); + const QPoint pos = viewport->mapFromGlobal(QCursor::pos()); + if (verticalScrolling) { + m_verticalScrollInc = calculateScrollIncrement(pos.y(), viewport->height()); + } + if (horizontalScrolling) { + m_horizontalScrollInc = calculateScrollIncrement(pos.x(), viewport->width()); + } + + if (m_timer->isActive()) { + if ((m_horizontalScrollInc == 0) && (m_verticalScrollInc == 0)) { + stopAutoScroll(); + } + } else if ((m_horizontalScrollInc != 0) || (m_verticalScrollInc != 0)) { + if (!m_initializedTimestamp) { + m_initializedTimestamp = true; + m_timestamp.start(); + } + m_timer->start(); + } +} + +void DolphinViewAutoScroller::stopAutoScroll() +{ + m_timer->stop(); + m_horizontalScrollInc = 0; + m_verticalScrollInc = 0; + m_initializedTimestamp = false; +} + +int DolphinViewAutoScroller::calculateScrollIncrement(int cursorPos, int rangeSize) const +{ + int inc = 0; + + const int minSpeed = 4; + const int maxSpeed = 768; + const int speedLimiter = 48; + const int autoScrollBorder = 64; + + if (cursorPos < autoScrollBorder) { + inc = -minSpeed + qAbs(cursorPos - autoScrollBorder) * (cursorPos - autoScrollBorder) / speedLimiter; + if (inc < -maxSpeed) { + inc = -maxSpeed; + } + } else if (cursorPos > rangeSize - autoScrollBorder) { + inc = minSpeed + qAbs(cursorPos - rangeSize + autoScrollBorder) * (cursorPos - rangeSize + autoScrollBorder) / speedLimiter; + if (inc > maxSpeed) { + inc = maxSpeed; + } + } + + return inc; +} + +#include "dolphinviewautoscroller.moc" diff --git a/src/views/dolphinviewautoscroller.h b/src/views/dolphinviewautoscroller.h new file mode 100644 index 000000000..9fd35d494 --- /dev/null +++ b/src/views/dolphinviewautoscroller.h @@ -0,0 +1,79 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef DOLPHINVIEWAUTOSCROLLER_H +#define DOLPHINVIEWAUTOSCROLLER_H + +#include <QTime> +#include <QObject> + +class QAbstractItemView; +class QModelIndex; +class QTimer; + +/** + * @brief Assures that an autoscrolling is done for item views. + * + * This is a workaround as QAbstractItemView::setAutoScroll() is not usable + * when selecting items (see Qt issue #214542). + */ +class DolphinViewAutoScroller : public QObject +{ + Q_OBJECT + +public: + DolphinViewAutoScroller(QAbstractItemView* parent); + virtual ~DolphinViewAutoScroller(); + bool isActive() const; + + /** + * Must be invoked by the parent item view, when QAbstractItemView::currentChanged() + * has been called. Assures that the current item stays visible when it has been + * changed by the keyboard. + */ + void handleCurrentIndexChange(const QModelIndex& current, const QModelIndex& previous); + +protected: + virtual bool eventFilter(QObject* watched, QEvent* event); + +private slots: + void scrollViewport(); + +private: + void triggerAutoScroll(); + void stopAutoScroll(); + + /** + * Calculates the scroll increment dependent from + * the cursor position \a cursorPos and the range 0 - \a rangeSize - 1. + */ + int calculateScrollIncrement(int cursorPos, int rangeSize) const; + +private: + bool m_rubberBandSelection; + bool m_keyPressed; + bool m_initializedTimestamp; + int m_horizontalScrollInc; + int m_verticalScrollInc; + QAbstractItemView* m_itemView; + QTimer* m_timer; + QTime m_timestamp; +}; + +#endif diff --git a/src/views/dolphinviewcontroller.cpp b/src/views/dolphinviewcontroller.cpp new file mode 100644 index 000000000..6ef32f07f --- /dev/null +++ b/src/views/dolphinviewcontroller.cpp @@ -0,0 +1,249 @@ +/*************************************************************************** + * Copyright (C) 2010 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "dolphinviewcontroller.h" +#include "zoomlevelinfo.h" + +#include <kdirmodel.h> +#include <kfileitemactions.h> +#include <QAbstractProxyModel> +#include <QApplication> +#include <QClipboard> +#include <QDir> + +Qt::MouseButtons DolphinViewController::m_mouseButtons = Qt::NoButton; + +DolphinViewController::DolphinViewController(DolphinView* dolphinView) : + QObject(dolphinView), + m_dolphinView(dolphinView), + m_itemView(0), + m_versionControlActions() +{ +} + +DolphinViewController::~DolphinViewController() +{ +} + +const DolphinView* DolphinViewController::view() const +{ + return m_dolphinView; +} + +void DolphinViewController::requestUrlChange(const KUrl& url) +{ + emit urlChangeRequested(url); +} + +void DolphinViewController::setItemView(QAbstractItemView* view) +{ + if (m_itemView != 0) { + disconnect(m_itemView, SIGNAL(pressed(const QModelIndex&)), + this, SLOT(updateMouseButtonState())); + } + + m_itemView = view; + + if (m_itemView != 0) { + // TODO: this is a workaround until Qt-issue 176832 has been fixed + connect(m_itemView, SIGNAL(pressed(const QModelIndex&)), + this, SLOT(updateMouseButtonState())); + } +} + +QAbstractItemView* DolphinViewController::itemView() const +{ + return m_itemView; +} + +void DolphinViewController::triggerContextMenuRequest(const QPoint& pos, + const QList<QAction*>& customActions) +{ + emit activated(); + emit requestContextMenu(pos, customActions); +} + +void DolphinViewController::requestActivation() +{ + emit activated(); +} + +void DolphinViewController::indicateDroppedUrls(const KFileItem& destItem, + const KUrl& destPath, + QDropEvent* event) +{ + emit urlsDropped(destItem, destPath, event); +} + + +void DolphinViewController::indicateSortingChange(DolphinView::Sorting sorting) +{ + emit sortingChanged(sorting); +} + +void DolphinViewController::indicateSortOrderChange(Qt::SortOrder order) +{ + emit sortOrderChanged(order); +} + +void DolphinViewController::indicateSortFoldersFirstChange(bool foldersFirst) +{ + emit sortFoldersFirstChanged(foldersFirst); +} + +void DolphinViewController::indicateAdditionalInfoChange(const KFileItemDelegate::InformationList& info) +{ + emit additionalInfoChanged(info); +} + +void DolphinViewController::setVersionControlActions(QList<QAction*> actions) +{ + m_versionControlActions = actions; +} + +QList<QAction*> DolphinViewController::versionControlActions(const KFileItemList& items) +{ + emit requestVersionControlActions(items); + // All view implementations are connected with the signal requestVersionControlActions() + // (see ViewExtensionFactory) and will invoke DolphinViewController::setVersionControlActions(), + // so that the context dependent actions can be returned. + return m_versionControlActions; +} + +void DolphinViewController::handleKeyPressEvent(QKeyEvent* event) +{ + Q_ASSERT(m_itemView != 0); + + const QItemSelectionModel* selModel = m_itemView->selectionModel(); + const QModelIndex currentIndex = selModel->currentIndex(); + const bool trigger = currentIndex.isValid() + && ((event->key() == Qt::Key_Return) || (event->key() == Qt::Key_Enter)) + && !selModel->selectedIndexes().isEmpty(); + if (!trigger) { + return; + } + + // Collect the non-directory files into a list and + // call runPreferredApplications for that list. + // Several selected directories are opened in separate tabs, + // one selected directory will get opened in the view. + QModelIndexList dirQueue; + const QModelIndexList indexList = selModel->selectedIndexes(); + KFileItemList fileOpenList; + foreach (const QModelIndex& index, indexList) { + if (itemForIndex(index).isDir()) { + dirQueue << index; + } else { + fileOpenList << itemForIndex(index); + } + } + + KFileItemActions fileItemActions; + fileItemActions.runPreferredApplications(fileOpenList, "DesktopEntryName != 'dolphin'"); + + if (dirQueue.length() == 1) { + // open directory in the view + emit itemTriggered(itemForIndex(dirQueue[0])); + } else { + // open directories in separate tabs + foreach(const QModelIndex& dir, dirQueue) { + emit tabRequested(itemForIndex(dir).url()); + } + } +} + +void DolphinViewController::replaceUrlByClipboard() +{ + const QClipboard* clipboard = QApplication::clipboard(); + QString text; + if (clipboard->mimeData(QClipboard::Selection)->hasText()) { + text = clipboard->mimeData(QClipboard::Selection)->text(); + } else if (clipboard->mimeData(QClipboard::Clipboard)->hasText()) { + text = clipboard->mimeData(QClipboard::Clipboard)->text(); + } + if (!text.isEmpty() && QDir::isAbsolutePath(text)) { + m_dolphinView->setUrl(KUrl(text)); + } +} + +void DolphinViewController::requestToolTipHiding() +{ + emit hideToolTip(); +} + +void DolphinViewController::emitItemTriggered(const KFileItem& item) +{ + emit itemTriggered(item); +} + +KFileItem DolphinViewController::itemForIndex(const QModelIndex& index) const +{ + Q_ASSERT(m_itemView != 0); + + QAbstractProxyModel* proxyModel = static_cast<QAbstractProxyModel*>(m_itemView->model()); + KDirModel* dirModel = static_cast<KDirModel*>(proxyModel->sourceModel()); + const QModelIndex dirIndex = proxyModel->mapToSource(index); + return dirModel->itemForIndex(dirIndex); +} + +void DolphinViewController::triggerItem(const QModelIndex& index) +{ + if (m_mouseButtons & Qt::LeftButton) { + const KFileItem item = itemForIndex(index); + if (index.isValid() && (index.column() == KDirModel::Name)) { + emit itemTriggered(item); + } else { + m_itemView->clearSelection(); + emit itemEntered(KFileItem()); + } + } +} + +void DolphinViewController::requestTab(const QModelIndex& index) +{ + if (m_mouseButtons & Qt::MidButton) { + const KFileItem item = itemForIndex(index); + const bool validRequest = index.isValid() && + (index.column() == KDirModel::Name) && + (item.isDir() || m_dolphinView->isTabsForFilesEnabled()); + if (validRequest) { + emit tabRequested(item.url()); + } + } +} + +void DolphinViewController::emitItemEntered(const QModelIndex& index) +{ + KFileItem item = itemForIndex(index); + if (!item.isNull()) { + emit itemEntered(item); + } +} + +void DolphinViewController::emitViewportEntered() +{ + emit viewportEntered(); +} + +void DolphinViewController::updateMouseButtonState() +{ + m_mouseButtons = QApplication::mouseButtons(); +} + +#include "dolphinviewcontroller.moc" diff --git a/src/views/dolphinviewcontroller.h b/src/views/dolphinviewcontroller.h new file mode 100644 index 000000000..6eed68e1a --- /dev/null +++ b/src/views/dolphinviewcontroller.h @@ -0,0 +1,314 @@ +/*************************************************************************** + * Copyright (C) 2010 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef DOLPHINVIEWCONTROLLER_H +#define DOLPHINVIEWCONTROLLER_H + +#include <views/dolphinview.h> +#include <kurl.h> +#include <QtCore/QObject> +#include <libdolphin_export.h> + +class QAbstractItemView; +class DolphinView; +class KUrl; +class QPoint; + +/** + * @brief Allows the view mode implementations (DolphinIconsView, DolphinDetailsView, DolphinColumnView) + * to do a limited control of the DolphinView. + * + * The DolphinView connects to the signals of DolphinViewController to react on changes + * that have been triggered by the view mode implementations. The view mode implementations + * have read access to the whole DolphinView by DolphinViewController::view(). Limited control of the + * DolphinView by the view mode implementations are defined by the public DolphinController methods. + */ +class LIBDOLPHINPRIVATE_EXPORT DolphinViewController : public QObject +{ + Q_OBJECT + +public: + explicit DolphinViewController(DolphinView* dolphinView); + virtual ~DolphinViewController(); + + /** + * Allows read access for the view mode implementation + * to the DolphinView. + */ + const DolphinView* view() const; + + /** + * Requests the DolphinView to change the URL to \p url. The signal + * urlChangeRequested will be emitted. + */ + void requestUrlChange(const KUrl& url); + + /** + * Changes the current view mode implementation where the controller is working. + * This is only necessary for views like the tree view, where internally + * several QAbstractItemView instances are used. + */ + void setItemView(QAbstractItemView* view); + QAbstractItemView* itemView() const; + + /** + * Requests a context menu for the position \a pos. DolphinView + * takes care itself to get the selected items depending from + * \a pos. It is possible to define a custom list of actions for + * the context menu by \a customActions. + */ + void triggerContextMenuRequest(const QPoint& pos, + const QList<QAction*>& customActions = QList<QAction*>()); + + /** + * Requests an activation of the DolphinView and emits the signal + * activated(). This method should be invoked by the view mode implementation + * if e. g. a mouse click on the view has been done. + */ + void requestActivation(); + + /** + * Indicates that URLs are dropped above a destination. The DolphinView + * will start the corresponding action (copy, move, link). + * @param destItem Item of the destination (can be null, see KFileItem::isNull()). + * @param destPath Path of the destination. + * @param event Drop event + */ + void indicateDroppedUrls(const KFileItem& destItem, + const KUrl& destPath, + QDropEvent* event); + + /** + * Informs the DolphinView about a sorting change done inside + * the view mode implementation. + */ + void indicateSortingChange(DolphinView::Sorting sorting); + + /** + * Informs the DolphinView about a sort order change done inside + * the view mode implementation. + */ + void indicateSortOrderChange(Qt::SortOrder order); + + /** + * Informs the DolphinView about a change between separate sorting + * (with folders first) and mixed sorting of files and folders done inside + * the view mode implementation. + */ + void indicateSortFoldersFirstChange(bool foldersFirst); + + /** + * Informs the DolphinView about an additional information change + * done inside the view mode implementation. + */ + void indicateAdditionalInfoChange(const KFileItemDelegate::InformationList& info); + + /** + * Sets the available version control actions. Is called by the view + * mode implementation as soon as the DolphinView has requested them by the signal + * requestVersionControlActions(). + */ + void setVersionControlActions(QList<QAction*> actions); + + /** + * Emits the signal requestVersionControlActions(). The view mode implementation + * listens to the signal and will invoke a DolphinViewController::setVersionControlActions() + * and the result will be returned. + */ + QList<QAction*> versionControlActions(const KFileItemList& items); + + /** + * Must be be invoked in each view mode implementation whenever a key has been + * pressed. If the selection model of \a view is not empty and + * the return key has been pressed, the selected items will get triggered. + */ + void handleKeyPressEvent(QKeyEvent* event); + + /** + * Replaces the URL of the DolphinView with the content + * of the clipboard as URL. If the clipboard contains no text, + * nothing will be done. + */ + void replaceUrlByClipboard(); + + /** + * Requests the view mode implementation to hide tooltips. + */ + void requestToolTipHiding(); + + /** + * Emits the signal itemTriggered() for the item \a item. + * The method can be used by the view mode implementations to + * trigger an item directly without mouse interaction. + * If the item triggering is done by the mouse, it is recommended + * to use DolphinViewController::triggerItem(), as this will check + * the used mouse buttons to execute the correct action. + */ + void emitItemTriggered(const KFileItem& item); + + /** + * Returns the file item for the proxy index \a index of the DolphinView. + */ + KFileItem itemForIndex(const QModelIndex& index) const; + +public slots: + /** + * Emits the signal itemTriggered() if the file item for the index \a index + * is not null and the left mouse button has been pressed. If the item is + * null, the signal itemEntered() is emitted. + * The method should be invoked by the view mode implementations whenever the + * user has triggered an item with the mouse (see + * QAbstractItemView::clicked() or QAbstractItemView::doubleClicked()). + */ + void triggerItem(const QModelIndex& index); + + /** + * Emits the signal tabRequested(), if the file item for the index \a index + * represents a directory and when the middle mouse button has been pressed. + */ + void requestTab(const QModelIndex& index); + + /** + * Emits the signal itemEntered() if the file item for the index \a index + * is not null. The method should be invoked by the view mode implementation + * whenever the mouse cursor is above an item. + */ + void emitItemEntered(const QModelIndex& index); + + /** + * Emits the signal viewportEntered(). The method should be invoked by + * the view mode implementation whenever the mouse cursor is above the viewport. + */ + void emitViewportEntered(); + +signals: + void urlChangeRequested(const KUrl& url); + + /** + * Is emitted if a context menu should be opened (see triggerContextMenuRequest()). + * @param pos Position relative to the view widget where the + * context menu should be opened. It is recommended + * to get the corresponding model index from + * this position. + * @param customActions List of actions that is added to the context menu when + * the menu is opened above the viewport. + */ + void requestContextMenu(const QPoint& pos, QList<QAction*> customActions); + + /** + * Is emitted if the view has been activated by e. g. a mouse click. + */ + void activated(); + + /** + * Is emitted if URLs have been dropped to the destination + * path \a destPath. If the URLs have been dropped above an item of + * the destination path, the item is indicated by \a destItem + * (can be null, see KFileItem::isNull()). + */ + void urlsDropped(const KFileItem& destItem, + const KUrl& destPath, + QDropEvent* event); + + /** + * Is emitted if the sorting has been changed to \a sorting by + * the view mode implementation (see indicateSortingChanged(). + * The DolphinView connects to + * this signal to update its menu action. + */ + void sortingChanged(DolphinView::Sorting sorting); + + /** + * Is emitted if the sort order has been changed to \a order + * by the view mode implementation (see indicateSortOrderChanged(). + * The DolphinView connects + * to this signal to update its menu actions. + */ + void sortOrderChanged(Qt::SortOrder order); + + /** + * Is emitted if 'sort folders first' has been changed to \a foldersFirst + * by the view mode implementation (see indicateSortOrderChanged(). + * The DolphinView connects + * to this signal to update its menu actions. + */ + void sortFoldersFirstChanged(bool foldersFirst); + + /** + * Is emitted if the additional info has been changed to \a info + * by the view mode implementation. The DolphinView connects + * to this signal to update its menu actions. + */ + void additionalInfoChanged(const KFileItemDelegate::InformationList& info); + + /** + * Is emitted if the item \a item should be triggered. The abstract + * Dolphin view connects to this signal. If the item represents a directory, + * the directory is opened. On a file the corresponding application is opened. + * The item is null (see KFileItem::isNull()), when clicking on the viewport itself. + */ + void itemTriggered(const KFileItem& item); + + /** + * Is emitted if the mouse cursor has entered the item + * given by \a index (see emitItemEntered()). + */ + void itemEntered(const KFileItem& item); + + /** + * Is emitted if a new tab should be opened for the URL \a url. + */ + void tabRequested(const KUrl& url); + + /** + * Is emitted if the mouse cursor has entered + * the viewport (see emitViewportEntered()). + */ + void viewportEntered(); + + /** + * Is emitted, if DolphinViewController::requestToolTipHiding() is invoked + * and requests to hide all tooltips. + */ + void hideToolTip(); + + /** + * Is emitted if pending previews should be canceled (e. g. because of an URL change). + */ + void cancelPreviews(); + + /** + * Requests the view mode implementation to invoke DolphinViewController::setVersionControlActions(), + * so that they can be returned with DolphinViewController::versionControlActions() for + * the DolphinView. + */ + void requestVersionControlActions(const KFileItemList& items); + +private slots: + void updateMouseButtonState(); + +private: + static Qt::MouseButtons m_mouseButtons; // TODO: this is a workaround until Qt-issue 176832 has been fixed + + DolphinView* m_dolphinView; + QAbstractItemView* m_itemView; + QList<QAction*> m_versionControlActions; +}; + +#endif diff --git a/src/views/selectionmanager.cpp b/src/views/selectionmanager.cpp new file mode 100644 index 000000000..0d3efae09 --- /dev/null +++ b/src/views/selectionmanager.cpp @@ -0,0 +1,186 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "selectionmanager.h" + +#include "dolphinmodel.h" +#include "selectiontoggle.h" +#include <kdirmodel.h> +#include <kiconeffect.h> + +#include <QAbstractButton> +#include <QAbstractItemView> +#include <QAbstractProxyModel> +#include <QApplication> +#include <QModelIndex> +#include <QPainter> +#include <QPaintEvent> +#include <QRect> +#include <QTimeLine> + +SelectionManager::SelectionManager(QAbstractItemView* parent) : + QObject(parent), + m_view(parent), + m_toggle(0), + m_connected(false) +{ + connect(parent, SIGNAL(entered(const QModelIndex&)), + this, SLOT(slotEntered(const QModelIndex&))); + connect(parent, SIGNAL(viewportEntered()), + this, SLOT(slotViewportEntered())); + m_toggle = new SelectionToggle(m_view->viewport()); + m_toggle->setCheckable(true); + m_toggle->hide(); + connect(m_toggle, SIGNAL(clicked(bool)), + this, SLOT(setItemSelected(bool))); +} + +SelectionManager::~SelectionManager() +{ +} + +void SelectionManager::reset() +{ + m_toggle->reset(); +} + +void SelectionManager::slotEntered(const QModelIndex& index) +{ + m_toggle->hide(); + const bool showToggle = index.isValid() && + (index.column() == DolphinModel::Name) && + (QApplication::mouseButtons() == Qt::NoButton); + if (showToggle) { + m_toggle->setUrl(urlForIndex(index)); + + if (!m_connected) { + connect(m_view->model(), SIGNAL(rowsRemoved(const QModelIndex&, int, int)), + this, SLOT(slotRowsRemoved(const QModelIndex&, int, int))); + connect(m_view->selectionModel(), + SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), + this, + SLOT(slotSelectionChanged(const QItemSelection&, const QItemSelection&))); + m_connected = true; + } + + // increase the size of the toggle for large items + const int height = m_view->iconSize().height(); + if (height >= KIconLoader::SizeEnormous) { + m_toggle->resize(KIconLoader::SizeMedium, KIconLoader::SizeMedium); + } else if (height >= KIconLoader::SizeLarge) { + m_toggle->resize(KIconLoader::SizeSmallMedium, KIconLoader::SizeSmallMedium); + } else { + m_toggle->resize(KIconLoader::SizeSmall, KIconLoader::SizeSmall); + } + + const QRect rect = m_view->visualRect(index); + int x = rect.left(); + int y = rect.top(); + if (height < KIconLoader::SizeSmallMedium) { + // The height is nearly equal to the smallest toggle height. + // Assure that the toggle is vertically centered instead + // of aligned on the top and gets more horizontal gap. + x += 2; + y += (rect.height() - m_toggle->height()) / 2; + } + m_toggle->move(QPoint(x, y)); + + QItemSelectionModel* selModel = m_view->selectionModel(); + m_toggle->setChecked(selModel->isSelected(index)); + m_toggle->show(); + } else { + m_toggle->setUrl(KUrl()); + disconnect(m_view->model(), SIGNAL(rowsRemoved(const QModelIndex&, int, int)), + this, SLOT(slotRowsRemoved(const QModelIndex&, int, int))); + disconnect(m_view->selectionModel(), + SIGNAL(selectionChanged(const QItemSelection&, const QItemSelection&)), + this, + SLOT(slotSelectionChanged(const QItemSelection&, const QItemSelection&))); + m_connected = false; + } +} + +void SelectionManager::slotViewportEntered() +{ + m_toggle->hide(); +} + +void SelectionManager::setItemSelected(bool selected) +{ + emit selectionChanged(); + + if (!m_toggle->url().isEmpty()) { + const QModelIndex index = indexForUrl(m_toggle->url()); + if (index.isValid()) { + QItemSelectionModel* selModel = m_view->selectionModel(); + if (selected) { + selModel->select(index, QItemSelectionModel::Select); + } else { + selModel->select(index, QItemSelectionModel::Deselect); + } + selModel->setCurrentIndex(index, QItemSelectionModel::Current); + } + } +} + +void SelectionManager::slotRowsRemoved(const QModelIndex& parent, int start, int end) +{ + Q_UNUSED(parent); + Q_UNUSED(start); + Q_UNUSED(end); + m_toggle->hide(); +} + +void SelectionManager::slotSelectionChanged(const QItemSelection& selected, + const QItemSelection& deselected) +{ + // The selection has been changed outside the scope of the selection manager + // (e. g. by the rubberband or the "Select All" action). Take care updating + // the state of the toggle button. + if (!m_toggle->url().isEmpty()) { + const QModelIndex index = indexForUrl(m_toggle->url()); + if (index.isValid()) { + if (selected.contains(index)) { + m_toggle->setChecked(true); + } + + if (deselected.contains(index)) { + m_toggle->setChecked(false); + } + } + } +} + +KUrl SelectionManager::urlForIndex(const QModelIndex& index) const +{ + QAbstractProxyModel* proxyModel = static_cast<QAbstractProxyModel*>(m_view->model()); + KDirModel* dirModel = static_cast<KDirModel*>(proxyModel->sourceModel()); + const QModelIndex dirIndex = proxyModel->mapToSource(index); + return dirModel->itemForIndex(dirIndex).url(); +} + +const QModelIndex SelectionManager::indexForUrl(const KUrl& url) const +{ + QAbstractProxyModel* proxyModel = static_cast<QAbstractProxyModel*>(m_view->model()); + KDirModel* dirModel = static_cast<KDirModel*>(proxyModel->sourceModel()); + const QModelIndex dirIndex = dirModel->indexForUrl(url); + return proxyModel->mapFromSource(dirIndex); +} + +#include "selectionmanager.moc" diff --git a/src/views/selectionmanager.h b/src/views/selectionmanager.h new file mode 100644 index 000000000..c2fcc88b4 --- /dev/null +++ b/src/views/selectionmanager.h @@ -0,0 +1,74 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef SELECTIONMANAGER_H +#define SELECTIONMANAGER_H + +#include <kfileitem.h> + +#include <QObject> + +class QAbstractItemView; +class QModelIndex; +class QItemSelection; +class SelectionToggle; + +/** + * @brief Allows to select and deselect items for item views. + * + * Whenever an item is hovered by the mouse, a toggle button is shown + * which allows to select/deselect the current item. + */ +class SelectionManager : public QObject +{ + Q_OBJECT + +public: + SelectionManager(QAbstractItemView* parent); + virtual ~SelectionManager(); + +public slots: + /** + * Resets the selection manager so that the toggle button gets + * invisible. + */ + void reset(); + +signals: + /** Is emitted if the selection has been changed by the toggle button. */ + void selectionChanged(); + +private slots: + void slotEntered(const QModelIndex& index); + void slotViewportEntered(); + void setItemSelected(bool selected); + void slotRowsRemoved(const QModelIndex& parent, int start, int end); + void slotSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected); + +private: + KUrl urlForIndex(const QModelIndex& index) const; + const QModelIndex indexForUrl(const KUrl& url) const; + +private: + QAbstractItemView* m_view; + SelectionToggle* m_toggle; + bool m_connected; +}; + +#endif diff --git a/src/views/selectiontoggle.cpp b/src/views/selectiontoggle.cpp new file mode 100644 index 000000000..6608b5821 --- /dev/null +++ b/src/views/selectiontoggle.cpp @@ -0,0 +1,233 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "selectiontoggle.h" + +#include <kglobalsettings.h> +#include <kicon.h> +#include <kiconloader.h> +#include <kiconeffect.h> +#include <klocale.h> + +#include <QPainter> +#include <QPaintEvent> +#include <QRect> +#include <QTimer> +#include <QTimeLine> + +SelectionToggle::SelectionToggle(QWidget* parent) : + QAbstractButton(parent), + m_isHovered(false), + m_leftMouseButtonPressed(false), + m_fadingValue(0), + m_icon(), + m_fadingTimeLine(0) +{ + setFocusPolicy(Qt::NoFocus); + parent->installEventFilter(this); + resize(sizeHint()); + setIconOverlay(isChecked()); + connect(this, SIGNAL(toggled(bool)), + this, SLOT(setIconOverlay(bool))); + connect(KGlobalSettings::self(), SIGNAL(iconChanged(int)), + this, SLOT(refreshIcon())); +} + +SelectionToggle::~SelectionToggle() +{ +} + +QSize SelectionToggle::sizeHint() const +{ + return QSize(16, 16); +} + +void SelectionToggle::reset() +{ + m_url = KUrl(); + hide(); +} + +void SelectionToggle::setUrl(const KUrl& url) +{ + m_url = url; + if (!url.isEmpty()) { + startFading(); + } +} + +KUrl SelectionToggle::url() const +{ + return m_url; +} + +void SelectionToggle::setVisible(bool visible) +{ + QAbstractButton::setVisible(visible); + + stopFading(); + if (visible) { + startFading(); + } + +} + +bool SelectionToggle::eventFilter(QObject* obj, QEvent* event) +{ + if (obj == parent()) { + switch (event->type()) { + case QEvent::Leave: + hide(); + break; + + case QEvent::MouseMove: + if (m_leftMouseButtonPressed) { + // Don't forward mouse move events to the viewport, + // otherwise a rubberband selection will be shown when + // clicking on the selection toggle and moving the mouse + // above the viewport. + return true; + } + break; + + default: + break; + } + } + + return QAbstractButton::eventFilter(obj, event); +} + +void SelectionToggle::enterEvent(QEvent* event) +{ + QAbstractButton::enterEvent(event); + + // if the mouse cursor is above the selection toggle, display + // it immediately without fading timer + m_isHovered = true; + if (m_fadingTimeLine != 0) { + m_fadingTimeLine->stop(); + } + m_fadingValue = 255; + setToolTip(isChecked() ? i18nc("@info:tooltip", "Deselect Item") : + i18nc("@info:tooltip", "Select Item")); + update(); +} + +void SelectionToggle::leaveEvent(QEvent* event) +{ + QAbstractButton::leaveEvent(event); + m_isHovered = false; + update(); +} + +void SelectionToggle::mousePressEvent(QMouseEvent* event) +{ + QAbstractButton::mousePressEvent(event); + m_leftMouseButtonPressed = (event->buttons() & Qt::LeftButton); +} + +void SelectionToggle::mouseReleaseEvent(QMouseEvent* event) +{ + QAbstractButton::mouseReleaseEvent(event); + m_leftMouseButtonPressed = (event->buttons() & Qt::LeftButton); +} + +void SelectionToggle::resizeEvent(QResizeEvent* event) +{ + QAbstractButton::resizeEvent(event); + setIconOverlay(isChecked()); +} + +void SelectionToggle::paintEvent(QPaintEvent* event) +{ + QPainter painter(this); + painter.setClipRect(event->rect()); + + // draw the icon overlay + if (m_isHovered) { + KIconEffect iconEffect; + QPixmap activeIcon = iconEffect.apply(m_icon, KIconLoader::Desktop, KIconLoader::ActiveState); + painter.drawPixmap(0, 0, activeIcon); + } else { + if (m_fadingValue < 255) { + // apply an alpha mask respecting the fading value to the icon + QPixmap icon = m_icon; + QPixmap alphaMask(icon.width(), icon.height()); + const QColor color(m_fadingValue, m_fadingValue, m_fadingValue); + alphaMask.fill(color); + icon.setAlphaChannel(alphaMask); + painter.drawPixmap(0, 0, icon); + } else { + // no fading is required + painter.drawPixmap(0, 0, m_icon); + } + } +} + +void SelectionToggle::setFadingValue(int value) +{ + m_fadingValue = value; + if (m_fadingValue >= 255) { + Q_ASSERT(m_fadingTimeLine != 0); + m_fadingTimeLine->stop(); + } + update(); +} + +void SelectionToggle::setIconOverlay(bool checked) +{ + const char* icon = checked ? "list-remove" : "list-add"; + m_icon = KIconLoader::global()->loadIcon(icon, + KIconLoader::NoGroup, + qMin(width(), height())); + update(); +} + +void SelectionToggle::refreshIcon() +{ + setIconOverlay(isChecked()); +} + +void SelectionToggle::startFading() +{ + Q_ASSERT(m_fadingTimeLine == 0); + + const bool animate = KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects; + const int duration = animate ? 600 : 1; + + m_fadingTimeLine = new QTimeLine(duration, this); + connect(m_fadingTimeLine, SIGNAL(frameChanged(int)), + this, SLOT(setFadingValue(int))); + m_fadingTimeLine->setFrameRange(0, 255); + m_fadingTimeLine->start(); + m_fadingValue = 0; +} + +void SelectionToggle::stopFading() +{ + if (m_fadingTimeLine != 0) { + m_fadingTimeLine->stop(); + delete m_fadingTimeLine; + m_fadingTimeLine = 0; + } + m_fadingValue = 0; +} + +#include "selectiontoggle.moc" diff --git a/src/views/selectiontoggle.h b/src/views/selectiontoggle.h new file mode 100644 index 000000000..5519272b3 --- /dev/null +++ b/src/views/selectiontoggle.h @@ -0,0 +1,91 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef SELECTIONTOGGLE_H +#define SELECTIONTOGGLE_H + +#include <kurl.h> + +#include <QAbstractButton> +#include <QPixmap> + +class QTimeLine; + +/** + * @brief Toggle button for changing the selection of an hovered item. + * + * The toggle button is visually invisible until it is displayed at least + * for one second. + * + * @see SelectionManager + */ +class SelectionToggle : public QAbstractButton +{ + Q_OBJECT + +public: + explicit SelectionToggle(QWidget* parent); + virtual ~SelectionToggle(); + virtual QSize sizeHint() const; + + /** + * Resets the selection toggle so that it is hidden and stays + * visually invisible for at least one second after it is shown again. + */ + void reset(); + + void setUrl(const KUrl& url); + KUrl url() const; + +public slots: + virtual void setVisible(bool visible); + +protected: + virtual bool eventFilter(QObject* obj, QEvent* event); + virtual void enterEvent(QEvent* event); + virtual void leaveEvent(QEvent* event); + virtual void mousePressEvent(QMouseEvent* event); + virtual void mouseReleaseEvent(QMouseEvent* event); + virtual void resizeEvent(QResizeEvent* event); + virtual void paintEvent(QPaintEvent* event); + +private slots: + /** + * Sets the alpha value for the fading animation and is + * connected with m_fadingTimeLine. + */ + void setFadingValue(int value); + + void setIconOverlay(bool checked); + void refreshIcon(); + +private: + void startFading(); + void stopFading(); + +private: + bool m_isHovered; + bool m_leftMouseButtonPressed; + int m_fadingValue; + QPixmap m_icon; + QTimeLine* m_fadingTimeLine; + KUrl m_url; +}; + +#endif diff --git a/src/views/viewextensionsfactory.cpp b/src/views/viewextensionsfactory.cpp new file mode 100644 index 000000000..e5638c03e --- /dev/null +++ b/src/views/viewextensionsfactory.cpp @@ -0,0 +1,244 @@ +/*************************************************************************** + * Copyright (C) 2009 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "viewextensionsfactory.h" + +#include "dolphinfileitemdelegate.h" +#include "dolphinsortfilterproxymodel.h" +#include "dolphinview.h" +#include "dolphinviewcontroller.h" +#include "dolphinviewautoscroller.h" +#include "folderexpander.h" +#include "selectionmanager.h" +#include "settings/dolphinsettings.h" +#include "tooltips/tooltipmanager.h" +#include "versioncontrol/versioncontrolobserver.h" +#include "viewmodecontroller.h" + +#include "dolphin_generalsettings.h" + +#include <kdirlister.h> +#include <kdirmodel.h> +#include <kfilepreviewgenerator.h> +#include <QAbstractItemView> + +ViewExtensionsFactory::ViewExtensionsFactory(QAbstractItemView* view, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController) : + QObject(view), + m_view(view), + m_dolphinViewController(dolphinViewController), + m_toolTipManager(0), + m_previewGenerator(0), + m_selectionManager(0), + m_autoScroller(0), + m_fileItemDelegate(0), + m_versionControlObserver(0) +{ + view->setSelectionMode(QAbstractItemView::ExtendedSelection); + + GeneralSettings* settings = DolphinSettings::instance().generalSettings(); + + // initialize tooltips + if (settings->showToolTips()) { + DolphinSortFilterProxyModel* proxyModel = static_cast<DolphinSortFilterProxyModel*>(view->model()); + m_toolTipManager = new ToolTipManager(view, proxyModel); + + connect(dolphinViewController, SIGNAL(hideToolTip()), + m_toolTipManager, SLOT(hideTip())); + } + + // initialize preview generator + Q_ASSERT(view->iconSize().isValid()); + m_previewGenerator = new KFilePreviewGenerator(view); + m_previewGenerator->setPreviewShown(dolphinViewController->view()->showPreview()); + connect(viewModeController, SIGNAL(zoomLevelChanged(int)), + this, SLOT(slotZoomLevelChanged())); + connect(viewModeController, SIGNAL(cancelPreviews()), + this, SLOT(cancelPreviews())); + connect(dolphinViewController->view(), SIGNAL(showPreviewChanged()), + this, SLOT(slotShowPreviewChanged())); + + // initialize selection manager + if (settings->showSelectionToggle()) { + m_selectionManager = new SelectionManager(view); + connect(m_selectionManager, SIGNAL(selectionChanged()), + this, SLOT(requestActivation())); + connect(viewModeController, SIGNAL(urlChanged(const KUrl&)), + m_selectionManager, SLOT(reset())); + } + + // initialize auto scroller + m_autoScroller = new DolphinViewAutoScroller(view); + + // initialize file item delegate + m_fileItemDelegate = new DolphinFileItemDelegate(view); + m_fileItemDelegate->setShowToolTipWhenElided(false); + view->setItemDelegate(m_fileItemDelegate); + + // initialize version control observer + const DolphinView* dolphinView = dolphinViewController->view(); + m_versionControlObserver = new VersionControlObserver(view); + connect(m_versionControlObserver, SIGNAL(infoMessage(const QString&)), + dolphinView, SIGNAL(infoMessage(const QString&))); + connect(m_versionControlObserver, SIGNAL(errorMessage(const QString&)), + dolphinView, SIGNAL(errorMessage(const QString&))); + connect(m_versionControlObserver, SIGNAL(operationCompletedMessage(const QString&)), + dolphinView, SIGNAL(operationCompletedMessage(const QString&))); + connect(dolphinViewController, SIGNAL(requestVersionControlActions(const KFileItemList&)), + this, SLOT(slotRequestVersionControlActions(const KFileItemList&))); + + // react on view property changes + connect(dolphinView, SIGNAL(showHiddenFilesChanged()), + this, SLOT(slotShowHiddenFilesChanged())); + connect(dolphinView, SIGNAL(sortingChanged(DolphinView::Sorting)), + this, SLOT(slotSortingChanged(DolphinView::Sorting))); + connect(dolphinView, SIGNAL(sortOrderChanged(Qt::SortOrder)), + this, SLOT(slotSortOrderChanged(Qt::SortOrder))); + connect(dolphinView, SIGNAL(sortFoldersFirstChanged(bool)), + this, SLOT(slotSortFoldersFirstChanged(bool))); + + // Give the view the ability to auto-expand its directories on hovering + // (the column view takes care about this itself). If the details view + // uses expandable folders, the auto-expanding should be used always. + m_folderExpander = new FolderExpander(view, proxyModel()); + m_folderExpander->setEnabled(settings->autoExpandFolders()); + connect(m_folderExpander, SIGNAL(enterDir(const QModelIndex&)), + dolphinViewController, SLOT(triggerItem(const QModelIndex&))); + + // react on namefilter changes + connect(viewModeController, SIGNAL(nameFilterChanged(const QString&)), + this, SLOT(slotNameFilterChanged(const QString&))); + + view->viewport()->installEventFilter(this); +} + +ViewExtensionsFactory::~ViewExtensionsFactory() +{ +} + +void ViewExtensionsFactory::handleCurrentIndexChange(const QModelIndex& current, const QModelIndex& previous) +{ + m_autoScroller->handleCurrentIndexChange(current, previous); +} + +DolphinFileItemDelegate* ViewExtensionsFactory::fileItemDelegate() const +{ + return m_fileItemDelegate; +} + +void ViewExtensionsFactory::setAutoFolderExpandingEnabled(bool enabled) +{ + m_folderExpander->setEnabled(enabled); +} + +bool ViewExtensionsFactory::autoFolderExpandingEnabled() const +{ + return m_folderExpander->enabled(); +} + +bool ViewExtensionsFactory::eventFilter(QObject* watched, QEvent* event) +{ + Q_UNUSED(watched); + if ((event->type() == QEvent::Wheel) && (m_selectionManager != 0)) { + m_selectionManager->reset(); + } + return false; +} + +void ViewExtensionsFactory::slotZoomLevelChanged() +{ + m_previewGenerator->updateIcons(); + if (m_selectionManager != 0) { + m_selectionManager->reset(); + } +} + +void ViewExtensionsFactory::cancelPreviews() +{ + m_previewGenerator->cancelPreviews(); +} + +void ViewExtensionsFactory::slotShowPreviewChanged() +{ + const bool show = m_dolphinViewController->view()->showPreview(); + m_previewGenerator->setPreviewShown(show); +} + +void ViewExtensionsFactory::slotShowHiddenFilesChanged() +{ + KDirModel* dirModel = static_cast<KDirModel*>(proxyModel()->sourceModel()); + KDirLister* dirLister = dirModel->dirLister(); + + dirLister->stop(); + + const bool show = m_dolphinViewController->view()->showHiddenFiles(); + dirLister->setShowingDotFiles(show); + + const KUrl url = dirLister->url(); + if (url.isValid()) { + dirLister->openUrl(url, KDirLister::NoFlags); + } +} + +void ViewExtensionsFactory::slotSortingChanged(DolphinView::Sorting sorting) +{ + proxyModel()->setSorting(sorting); +} + +void ViewExtensionsFactory::slotSortOrderChanged(Qt::SortOrder order) +{ + proxyModel()->setSortOrder(order); +} + +void ViewExtensionsFactory::slotSortFoldersFirstChanged(bool foldersFirst) +{ + proxyModel()->setSortFoldersFirst(foldersFirst); +} + +void ViewExtensionsFactory::slotNameFilterChanged(const QString& nameFilter) +{ + proxyModel()->setFilterFixedString(nameFilter); +} + +void ViewExtensionsFactory::slotRequestVersionControlActions(const KFileItemList& items) +{ + QList<QAction*> actions; + if (items.isEmpty()) { + const KDirModel* dirModel = static_cast<const KDirModel*>(proxyModel()->sourceModel()); + const KUrl url = dirModel->dirLister()->url(); + actions = m_versionControlObserver->contextMenuActions(url.path(KUrl::AddTrailingSlash)); + } else { + actions = m_versionControlObserver->contextMenuActions(items); + } + m_dolphinViewController->setVersionControlActions(actions); +} + +void ViewExtensionsFactory::requestActivation() +{ + m_dolphinViewController->requestActivation(); +} + +DolphinSortFilterProxyModel* ViewExtensionsFactory::proxyModel() const +{ + return static_cast<DolphinSortFilterProxyModel*>(m_view->model()); +} + +#include "viewextensionsfactory.moc" + diff --git a/src/views/viewextensionsfactory.h b/src/views/viewextensionsfactory.h new file mode 100644 index 000000000..9324932ac --- /dev/null +++ b/src/views/viewextensionsfactory.h @@ -0,0 +1,105 @@ +/*************************************************************************** + * Copyright (C) 2009 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef VIEWEXTENSIONSFACTORY_H +#define VIEWEXTENSIONSFACTORY_H + +#include <QObject> + +#include "dolphinview.h" + +class DolphinFileItemDelegate; +class DolphinSortFilterProxyModel; +class DolphinViewAutoScroller; +class KFilePreviewGenerator; +class FolderExpander; +class QModelIndex; +class SelectionManager; +class ToolTipManager; +class QAbstractItemView; +class VersionControlObserver; +class ViewModeController; + +/** + * @brief Responsible for creating extensions like tooltips and previews + * that are available in all view implementations. + * + * Each view implementation (iconsview, detailsview, columnview) must + * instantiate an instance of this class to assure having + * a common behavior that is independent from the custom functionality of + * a view implementation. + */ +class ViewExtensionsFactory : public QObject +{ + Q_OBJECT + +public: + explicit ViewExtensionsFactory(QAbstractItemView* view, + DolphinViewController* dolphinViewController, + const ViewModeController* viewModeController); + virtual ~ViewExtensionsFactory(); + + /** + * Must be invoked by the item view, when QAbstractItemView::currentChanged() + * has been called. Assures that the current item stays visible when it has been + * changed by the keyboard. + */ + void handleCurrentIndexChange(const QModelIndex& current, const QModelIndex& previous); + + DolphinFileItemDelegate* fileItemDelegate() const; + + /** + * Enables the automatically expanding of a folder when dragging + * items above the folder. + */ + void setAutoFolderExpandingEnabled(bool enabled); + bool autoFolderExpandingEnabled() const; + +protected: + virtual bool eventFilter(QObject* watched, QEvent* event); + +private slots: + void slotZoomLevelChanged(); + void cancelPreviews(); + void slotShowPreviewChanged(); + void slotShowHiddenFilesChanged(); + void slotSortingChanged(DolphinView::Sorting sorting); + void slotSortOrderChanged(Qt::SortOrder order); + void slotSortFoldersFirstChanged(bool foldersFirst); + void slotNameFilterChanged(const QString& nameFilter); + void slotRequestVersionControlActions(const KFileItemList& items); + void requestActivation(); + +private: + DolphinSortFilterProxyModel* proxyModel() const; + +private: + QAbstractItemView* m_view; + DolphinViewController* m_dolphinViewController; + ToolTipManager* m_toolTipManager; + KFilePreviewGenerator* m_previewGenerator; + SelectionManager* m_selectionManager; + DolphinViewAutoScroller* m_autoScroller; + DolphinFileItemDelegate* m_fileItemDelegate; + VersionControlObserver* m_versionControlObserver; + FolderExpander* m_folderExpander; +}; + +#endif + diff --git a/src/views/viewmodecontroller.cpp b/src/views/viewmodecontroller.cpp new file mode 100644 index 000000000..17d0ba61f --- /dev/null +++ b/src/views/viewmodecontroller.cpp @@ -0,0 +1,88 @@ +/*************************************************************************** + * Copyright (C) 2010 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "viewmodecontroller.h" + +#include "zoomlevelinfo.h" + +ViewModeController::ViewModeController(QObject* parent) : + QObject(parent), + m_zoomLevel(0), + m_nameFilter(), + m_url() +{ +} + +ViewModeController::~ViewModeController() +{ +} + +KUrl ViewModeController::url() const +{ + return m_url; +} + +void ViewModeController::redirectToUrl(const KUrl& url) +{ + m_url = url; +} + +void ViewModeController::indicateActivationChange(bool active) +{ + emit activationChanged(active); +} + +void ViewModeController::setNameFilter(const QString& nameFilter) +{ + if (nameFilter != m_nameFilter) { + m_nameFilter = nameFilter; + emit nameFilterChanged(nameFilter); + } +} + +QString ViewModeController::nameFilter() const +{ + return m_nameFilter; +} + +void ViewModeController::setZoomLevel(int level) +{ + Q_ASSERT(level >= ZoomLevelInfo::minimumLevel()); + Q_ASSERT(level <= ZoomLevelInfo::maximumLevel()); + if (level != m_zoomLevel) { + m_zoomLevel = level; + emit zoomLevelChanged(m_zoomLevel); + } +} + +int ViewModeController::zoomLevel() const +{ + return m_zoomLevel; +} + +void ViewModeController::setUrl(const KUrl& url) +{ + if (m_url != url) { + m_url = url; + emit cancelPreviews(); + emit urlChanged(url); + } +} + +#include "viewmodecontroller.moc" diff --git a/src/views/viewmodecontroller.h b/src/views/viewmodecontroller.h new file mode 100644 index 000000000..c7378d59a --- /dev/null +++ b/src/views/viewmodecontroller.h @@ -0,0 +1,124 @@ +/*************************************************************************** + * Copyright (C) 2010 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef VIEWMODECONTROLLER_H +#define VIEWMODECONTROLLER_H + +#include <kurl.h> +#include <QObject> +#include <libdolphin_export.h> +#include <views/dolphinview.h> + +/** + * @brief Allows the DolphinView to control the view implementations for the + * different view modes. + * + * The view implementations (DolphinIconsView, DolphinDetailsView, DolphinColumnView) + * connect to signals of the ViewModeController to react on changes. The view + * implementations get only read-access to the ViewModeController. + */ +class LIBDOLPHINPRIVATE_EXPORT ViewModeController : public QObject +{ + Q_OBJECT + +public: + explicit ViewModeController(QObject* parent = 0); + virtual ~ViewModeController(); + + /** + * @return URL that is shown by the view mode implementation. + */ + KUrl url() const; + + /** + * Sets the URL to \a url and does nothing else. Called when + * a redirection happens. See ViewModeController::setUrl() + */ + void redirectToUrl(const KUrl& url); + + /** + * Informs the view mode implementation about a change of the activation + * state by emitting the signal activationChanged(). + */ + void indicateActivationChange(bool active); + + /** + * Sets the zoom level to \a level and emits the signal zoomLevelChanged(). + * It must be assured that the used level is inside the range + * ViewModeController::zoomLevelMinimum() and + * ViewModeController::zoomLevelMaximum(). + */ + void setZoomLevel(int level); + int zoomLevel() const; + + /** + * Sets the name filter to \a and emits the signal nameFilterChanged(). + */ + void setNameFilter(const QString& nameFilter); + QString nameFilter() const; + + /** + * Requests the view mode implementation to hide tooltips. + */ + void requestToolTipHiding(); + +public slots: + /** + * Sets the URL to \a url and emits the signals cancelPreviews() and + * urlChanged() if \a url is different for the current URL. + */ + void setUrl(const KUrl& url); + +signals: + /** + * Is emitted if the URL has been changed by ViewModeController::setUrl(). + */ + void urlChanged(const KUrl& url); + + /** + * Is emitted, if ViewModeController::indicateActivationChange() has been + * invoked. The view mode implementation may update its visual state + * to represent the activation state. + */ + void activationChanged(bool active); + + /** + * Is emitted if the name filter has been changed by + * ViewModeController::setNameFilter(). + */ + void nameFilterChanged(const QString& nameFilter); + + /** + * Is emitted if the zoom level has been changed by + * ViewModeController::setZoomLevel(). + */ + void zoomLevelChanged(int level); + + /** + * Is emitted if pending previews should be canceled (e. g. because of an URL change). + */ + void cancelPreviews(); + +private: + int m_zoomLevel; + QString m_nameFilter; + KUrl m_url; +}; + +#endif diff --git a/src/views/zoomlevelinfo.cpp b/src/views/zoomlevelinfo.cpp new file mode 100644 index 000000000..08e95e3ca --- /dev/null +++ b/src/views/zoomlevelinfo.cpp @@ -0,0 +1,60 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#include "zoomlevelinfo.h" +#include <kiconloader.h> +#include <QSize> + +int ZoomLevelInfo::minimumLevel() +{ + return 0; +} + +int ZoomLevelInfo::maximumLevel() +{ + return 16; +} + +int ZoomLevelInfo::iconSizeForZoomLevel(int level) +{ + int size = KIconLoader::SizeMedium; + switch (level) { + case 0: size = KIconLoader::SizeSmall; break; + case 1: size = KIconLoader::SizeSmallMedium; break; + case 2: size = KIconLoader::SizeMedium; break; + case 3: size = KIconLoader::SizeLarge; break; + case 4: size = KIconLoader::SizeHuge; break; + default: size = KIconLoader::SizeHuge + ((level - 4) << 4); + } + return size; +} + +int ZoomLevelInfo::zoomLevelForIconSize(const QSize& size) +{ + int level = 0; + switch (size.height()) { + case KIconLoader::SizeSmall: level = 0; break; + case KIconLoader::SizeSmallMedium: level = 1; break; + case KIconLoader::SizeMedium: level = 2; break; + case KIconLoader::SizeLarge: level = 3; break; + case KIconLoader::SizeHuge: level = 4; break; + default: level = 4 + ((size.height() - KIconLoader::SizeHuge) >> 4); + } + return level; +} diff --git a/src/views/zoomlevelinfo.h b/src/views/zoomlevelinfo.h new file mode 100644 index 000000000..a6e92e653 --- /dev/null +++ b/src/views/zoomlevelinfo.h @@ -0,0 +1,51 @@ +/*************************************************************************** + * Copyright (C) 2008 by Peter Penz <[email protected]> * + * * + * 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 * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * 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., * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * + ***************************************************************************/ + +#ifndef ZOOMLEVELINFO_H +#define ZOOMLEVELINFO_H + +class QSize; + +/** + * @short Helper class for getting information about the zooming + * capabilities. + */ +class ZoomLevelInfo { +public: + static int minimumLevel(); + static int maximumLevel(); + + /** + * Helper method for the view implementation to get + * the icon size for the zoom level \a level that + * is between the range ZoomLevelInfo::minimumLevel() and + * ZoomLevelInfo::maximumLevel(). + */ + static int iconSizeForZoomLevel(int level); + + /** + * Helper method for the view implementation to get + * the zoom level for the icon size \a size that + * is between the range ZoomLevelInfo::minimumLevel() and + * ZoomLevelInfo::maximumLevel(). + */ + static int zoomLevelForIconSize(const QSize& size); +}; + +#endif |