/***************************************************************************
- * Copyright (C) 2006-2009 by Peter Penz <peter.penz@gmx.at> *
+ * Copyright (C) 2006-2009 by Peter Penz <peter.penz19@gmail.com> *
* Copyright (C) 2006 by Gregor Kališnik <gregor@podnapisi.net> *
* *
* This program is free software; you can redistribute it and/or modify *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
***************************************************************************/
-
#ifndef DOLPHINVIEW_H
#define DOLPHINVIEW_H
#include "libdolphin_export.h"
#include <kparts/part.h>
-#include <kfileitem.h>
-#include <kfileitemdelegate.h>
+#include <KFileItem>
+#include <KFileItemDelegate>
#include <kio/fileundomanager.h>
-#include <kio/job.h>
+#include <KIO/Job>
#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 DolphinItemListView;
class KAction;
class KActionCollection;
-class KDirLister;
+class KFileItemModel;
+class KItemListContainer;
+class KItemModelBase;
class KUrl;
-class ViewModeController;
+class ToolTipManager;
+class VersionControlObserver;
class ViewProperties;
-class DolphinDetailsViewExpander;
+class QGraphicsSceneDragDropEvent;
+class QRegExp;
/**
* @short Represents a view for the directory content.
*
- * View modes for icons, details and columns are supported. It's
+ * View modes for icons, compact and details are supported. It's
* possible to adjust:
* - sort order
* - sort type
* - show hidden files
* - show previews
- *
- * @see DolphinIconsView
- * @see DolphinDetailsView
- * @see DolphinColumnView
+ * - enable grouping
*/
class LIBDOLPHINPRIVATE_EXPORT DolphinView : public QWidget
{
public:
/**
- * Defines the view mode for a directory. The view mode
- * can be defined when constructing a DolphinView. The
+ * Defines the view mode for a directory. 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.
+ * The items are shown as icons with a name-label below.
*/
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.
+ * The icon, the name and the size of the items are
+ * shown per default as a table.
*/
- DetailsView = 1,
+ DetailsView,
/**
- * Each folder is shown in a separate column.
+ * The items are shown as icons with the name-label aligned
+ * to the right side.
*/
- 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
+ CompactView
};
/**
- * @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.
+ * @param parent Parent widget of the view.
*/
- DolphinView(QWidget* parent,
- const KUrl& url,
- DolphinSortFilterProxyModel* proxyModel);
+ DolphinView(const KUrl& url, QWidget* parent);
virtual ~DolphinView();
*/
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 setMode(Mode mode);
Mode mode() const;
- /** See setShowPreview */
- bool showPreview() const;
+ /**
+ * 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 setPreviewsShown(bool show);
+ bool previewsShown() const;
- /** See setShowHiddenFiles */
- bool showHiddenFiles() const;
+ /**
+ * 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 setHiddenFilesShown(bool show);
+ bool hiddenFilesShown() const;
- /** See setCategorizedSorting */
- bool categorizedSorting() const;
+ /**
+ * Turns on sorting by groups if \a enable is true.
+ */
+ void setGroupedSorting(bool grouped);
+ bool groupedSorting() 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().
+ * Returns the items of the view.
*/
- bool supportsCategorizedSorting() const;
+ KFileItemList items() 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().
+ * @return The number of items. itemsCount() is faster in comparison
+ * to items().count().
*/
- void markUrlsAsSelected(const QList<KUrl>& urls);
+ int itemsCount() const;
/**
* 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().
+ * 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 setZoomLevel(int level);
- int zoomLevel() const;
+ void markUrlsAsSelected(const QList<KUrl>& urls);
/**
- * Returns true, if zooming in is possible. If false is returned,
- * the maximum zooming level has been reached.
+ * Marks the item indicated by \p url as the current item after the
+ * directory DolphinView::url() has been loaded.
*/
- bool isZoomInPossible() const;
+ void markUrlAsCurrent(const KUrl& url);
/**
- * Returns true, if zooming out is possible. If false is returned,
- * the minimum zooming level has been reached.
+ * All items that match to the pattern \a pattern will get selected
+ * if \a enabled is true and deselected if \a enabled is false.
*/
- bool isZoomOutPossible() const;
+ void selectItems(const QRegExp& pattern, bool enabled);
- /** Sets the sort order of the items inside a directory (see DolphinView::Sorting). */
- void setSorting(Sorting sorting);
+ /**
+ * 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 the sort order of the items inside a directory (see DolphinView::Sorting). */
- Sorting sorting() const;
+ void setSortRole(const QByteArray& role);
+ QByteArray sortRole() 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);
+ void setVisibleRoles(const QList<QByteArray>& roles);
/** Returns the additional information which should be shown for the items. */
- KFileItemDelegate::InformationList additionalInfo() const;
+ QList<QByteArray> visibleRoles() const;
- /** Reloads the current directory. */
void reload();
-
void stopLoading();
/**
- * 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.
+ * Refreshes the view to get synchronized with the settings (e.g. icons size,
+ * font, ...).
*/
- void refresh();
+ void readSettings();
/**
- * Filters the currently shown items by \a nameFilter. All items
- * which contain the given filter string will be shown.
+ * Saves the current settings (e.g. icons size, font, ..).
*/
- void setNameFilter(const QString& nameFilter);
+ void writeSettings();
/**
- * 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.
+ * Filters the currently shown items by \a nameFilter. All items
+ * which contain the given filter string will be shown.
*/
- void calculateItemCount(int& fileCount, int& folderCount, KIO::filesize_t& totalFileSize) const;
+ void setNameFilter(const QString& nameFilter);
+ QString nameFilter() const;
/**
* Returns a textual representation of the state of the current
*/
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
*/
void saveState(QDataStream& stream);
+ /**
+ * Returns the root item which represents the current URL.
+ */
+ KFileItem rootItem() const;
+
public slots:
/**
* Changes the directory to \a url. If the current directory is equal to
*/
void invertSelection();
- /** Returns true, if at least one item is selected. */
- bool hasSelection() const;
-
void clearSelection();
/**
*/
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);
+ /** Activates the view if the item list container gets focus. */
+ virtual bool eventFilter(QObject* watched, QEvent* event);
+signals:
/**
- * 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.
+ * Is emitted if the view has been activated by e. g. a mouse click.
*/
- void setShowHiddenFiles(bool show);
+ void activated();
/**
- * 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.
+ * Is emitted if the URL of the view will be changed to \a url.
+ * After the URL has been changed the signal urlChanged() will
+ * be emitted.
*/
- void setCategorizedSorting(bool categorized);
-
- /** Switches between an ascending and descending sorting order. */
- void toggleSortOrder();
+ void urlAboutToBeChanged(const KUrl& url);
- /** Switches between a separate sorting (with folders first) and a mixed sorting of files and folders. */
- void toggleSortFoldersFirst();
+ /** Is emitted if the URL of the view has been changed to \a url. */
+ void urlChanged(const KUrl& url);
/**
- * Switches on or off the displaying of additional information
- * as specified by \a action.
+ * Is emitted when clicking on an item with the left mouse button.
*/
- void toggleAdditionalInfo(QAction* action);
+ void itemActivated(const KFileItem& item);
-signals:
/**
- * Is emitted if the view has been activated by e. g. a mouse click.
+ * Is emitted if items have been added or deleted.
*/
- 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);
+ void itemCountChanged();
/**
* Is emitted if a new tab should be opened for the URL \a url.
* Is emitted if the view mode (IconsView, DetailsView,
* PreviewsView) has been changed.
*/
- void modeChanged();
+ void modeChanged(DolphinView::Mode current, DolphinView::Mode previous);
/** Is emitted if the 'show preview' property has been changed. */
- void showPreviewChanged();
+ void previewsShownChanged(bool shown);
/** Is emitted if the 'show hidden files' property has been changed. */
- void showHiddenFilesChanged();
+ void hiddenFilesShownChanged(bool shown);
- /** Is emitted if the 'categorized sorting' property has been changed. */
- void categorizedSortingChanged();
+ /** Is emitted if the 'grouped sorting' property has been changed. */
+ void groupedSortingChanged(bool groupedSorting);
/** Is emitted if the sorting by name, size or date has been changed. */
- void sortingChanged(DolphinView::Sorting sorting);
+ void sortRoleChanged(const QByteArray& role);
/** 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. */
+ /**
+ * 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();
+ void visibleRolesChanged(const QList<QByteArray>& current,
+ const QList<QByteArray>& previous);
/** Is emitted if the zoom level has been changed by zooming in or out. */
- void zoomLevelChanged(int level);
+ void zoomLevelChanged(int current, int previous);
/**
* Is emitted if information of an item is requested to be shown e. g. in the panel.
* for the URL should be shown and the custom actions \a customActions
* will be added.
*/
- void requestContextMenu(const KFileItem& item,
+ void requestContextMenu(const QPoint& pos,
+ const KFileItem& item,
const KUrl& url,
const QList<QAction*>& customActions);
/**
* Is emitted after DolphinView::setUrl() has been invoked and
- * the path \a url is currently loaded. If this signal is emitted,
+ * the current directory is 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);
+ void directoryLoadingStarted();
/**
- * Is emitted after the path triggered by DolphinView::setUrl()
+ * Is emitted after the directory triggered by DolphinView::setUrl()
* has been loaded.
*/
- void finishedPathLoading(const KUrl& url);
+ void directoryLoadingCompleted();
+
+ /**
+ * Is emitted after DolphinView::setUrl() has been invoked and provides
+ * the information how much percent of the current directory have been loaded.
+ */
+ void directoryLoadingProgress(int percent);
/**
- * Emitted when KDirLister emits redirection.
+ * Is emitted if the sorting is done asynchronously and provides the
+ * progress information of the sorting.
+ */
+ void directorySortingProgress(int percent);
+
+ /**
+ * Emitted when the file-item-model emits redirection.
* Testcase: fish://localhost
*/
void redirection(const KUrl& oldUrl, const KUrl& newUrl);
+ /**
+ * Is emitted when the write state of the folder has been changed. The application
+ * should disable all actions like "Create New..." that depend on the write
+ * state.
+ */
+ void writeStateChanged(bool isFolderWritable);
+
+ /**
+ * Is emitted if the URL should be changed to the previous URL of the
+ * history (e.g. because the "back"-mousebutton has been pressed).
+ */
+ void goBackRequested();
+
+ /**
+ * Is emitted if the URL should be changed to the next URL of the
+ * history (e.g. because the "next"-mousebutton has been pressed).
+ */
+ void goForwardRequested();
+
protected:
- /** @see QWidget::mouseReleaseEvent */
- virtual void mouseReleaseEvent(QMouseEvent* event);
- virtual bool eventFilter(QObject* watched, QEvent* event);
+ /** Changes the zoom level if Control is pressed during a wheel event. */
+ virtual void wheelEvent(QWheelEvent* event);
+
+ /** @reimp */
+ virtual void hideEvent(QHideEvent* event);
private slots:
/**
*/
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);
+ void slotItemActivated(int index);
+ void slotItemsActivated(const QSet<int>& indexes);
+ void slotItemMiddleClicked(int index);
+ void slotItemContextMenuRequested(int index, const QPointF& pos);
+ void slotViewContextMenuRequested(const QPointF& pos);
+ void slotHeaderContextMenuRequested(const QPointF& pos);
+ void slotHeaderColumnWidthChanged(const QByteArray& role, qreal current, qreal previous);
+ void slotItemHovered(int index);
+ void slotItemUnhovered(int index);
+ void slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* event);
+ void slotModelChanged(KItemModelBase* current, KItemModelBase* previous);
+ void slotMouseButtonPressed(int itemIndex, Qt::MouseButtons buttons);
/**
* Emits the signal \a selectionChanged() with a small delay. This is
- * because getting all file items for the signal can be an expensive
+ * because getting all file items for the selection 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);
+ void slotSelectionChanged(const QSet<int>& current, const QSet<int>& previous);
/**
* Is called by emitDelayedSelectionChangedSignal() and emits the
*/
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.
+ * sorting given by \a role.
*/
- void updateSorting(DolphinView::Sorting sorting);
+ void updateSortRole(const QByteArray& role);
/**
* Updates the view properties of the current URL to the
*/
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,
void slotDeleteFileFinished(KJob* job);
/**
- * Invoked when the directory lister has completed the loading of
- * items. Assures that pasted items and renamed items get seleced.
+ * Invoked when the file item model has started the loading
+ * of the directory specified by DolphinView::url().
+ */
+ void slotDirectoryLoadingStarted();
+
+ /**
+ * Invoked when the file item model indicates that the loading of a directory has
+ * been completed. Assures that pasted items and renamed items get seleced.
+ */
+ void slotDirectoryLoadingCompleted();
+
+ /**
+ * Is invoked when items of KFileItemModel have been changed.
+ */
+ void slotItemsChanged();
+
+ /**
+ * Is invoked when the sort order has been changed by the user by clicking
+ * on a header item. The view properties of the directory will get updated.
*/
- void slotDirListerCompleted();
+ void slotSortOrderChangedByHeader(Qt::SortOrder current, Qt::SortOrder previous);
/**
- * Invoked when the loading of the directory is finished.
- * Restores the active item and the scroll position if possible.
+ * Is invoked when the sort role has been changed by the user by clicking
+ * on a header item. The view properties of the directory will get updated.
*/
- void slotLoadingCompleted();
+ void slotSortRoleChangedByHeader(const QByteArray& current, const QByteArray& previous);
/**
- * Is invoked when the KDirLister indicates refreshed items.
+ * Is invoked when the visible roles have been changed by the user by dragging
+ * a header item. The view properties of the directory will get updated.
*/
- void slotRefreshItems();
+ void slotVisibleRolesChangedByHeader(const QList<QByteArray>& current,
+ const QList<QByteArray>& previous);
+
+ void slotRoleEditingFinished(int index, const QByteArray& role, const QVariant& value);
/**
* 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.
+ * get selected and it is assured that the item stays visible.
*
* @see selectAndScrollToCreatedItem()
*/
* Called when a redirection happens.
* Testcase: fish://localhost
*/
- void slotRedirection(const KUrl& oldUrl, const KUrl& newUrl);
+ void slotDirectoryRedirection(const KUrl& oldUrl, const KUrl& newUrl);
/**
- * Restores the contents position, if history information about the old position is available.
+ * Applies the state that has been restored by restoreViewState()
+ * to the view.
*/
- void restoreContentsPosition();
+ void updateViewState();
+
+ void hideToolTip();
+
+ /**
+ * 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;
private:
void loadDirectory(const KUrl& url, bool reload = false);
void applyViewProperties();
/**
- * Creates a new view representing the given view mode (DolphinView::mode()).
- * The current view will get deleted.
+ * Applies the m_mode property to the corresponding
+ * itemlayout-property of the KItemListView.
*/
- void createView();
-
- void deleteView();
+ void applyModeToView();
/**
* Helper method for DolphinView::paste() and DolphinView::pasteIntoFolder().
*/
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
/**
* 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().
+ * operation and URLs from \a mimeData as selected.
+ * This allows to select all newly pasted
+ * items in restoreViewState().
*/
- void addNewFileNames(const QMimeData* mimeData);
+ void markPastedUrlsAsSelected(const QMimeData* mimeData);
-private:
/**
- * Abstracts the access to the different view implementations
- * for icons-, details- and column-view.
+ * Updates m_isFolderWritable dependent on whether the folder represented by
+ * the current URL is writable. If the state has changed, the signal
+ * writeableStateChanged() will be emitted.
*/
- 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_assureVisibleCurrentIndex : 1;
- bool m_expanderActive : 1;
+ void updateWritableState();
+private:
+ bool m_active;
+ bool m_tabsForFiles;
+ bool m_assureVisibleCurrentIndex;
+ bool m_isFolderWritable;
+ bool m_dragging; // True if a dragging is done. Required to be able to decide whether a
+ // tooltip may be shown when hovering an item.
+
+ KUrl m_url;
Mode m_mode;
+ QList<QByteArray> m_visibleRoles;
QVBoxLayout* m_topLayout;
- DolphinViewController* m_dolphinViewController;
- ViewModeController* m_viewModeController;
- ViewAccessor m_viewAccessor;
+ KFileItemModel* m_model;
+ DolphinItemListView* m_view;
+ KItemListContainer* m_container;
+
+ ToolTipManager* m_toolTipManager;
QTimer* m_selectionChangedTimer;
- KUrl m_rootUrl;
- KUrl m_activeItemUrl;
+ KUrl m_currentItemUrl; // Used for making the view to remember the current URL after F5
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;
+ QList<KUrl> m_selectedUrls; // Used for making the view to remember selections after F5
+
+ VersionControlObserver* m_versionControlObserver;
+
+ // For unit tests
+ friend class TestBase;
+ friend class DolphinDetailsViewTest;
};
/// Allow using DolphinView::Mode in QVariant
projects / dolphin.git / blobdiff