+++ /dev/null
-# the whole file must be valid python code
-# for detail documentation, see http://www.reviewboard.org/docs/manual/dev/users/tools/post-review/
-
-REVIEWBOARD_URL = "https://git.reviewboard.kde.org"
-TARGET_GROUPS = "dolphin"
-REPOSITORY = "dolphin"
-
-GUESS_FIELDS = True
-OPEN_BROWSER = True
cmake_minimum_required(VERSION 3.0)
# KDE Application Version, managed by release script
-set (KDE_APPLICATIONS_VERSION_MAJOR "17")
-set (KDE_APPLICATIONS_VERSION_MINOR "12")
-set (KDE_APPLICATIONS_VERSION_MICRO "1")
+set (KDE_APPLICATIONS_VERSION_MAJOR "18")
+set (KDE_APPLICATIONS_VERSION_MINOR "03")
+set (KDE_APPLICATIONS_VERSION_MICRO "70")
set (KDE_APPLICATIONS_VERSION "${KDE_APPLICATIONS_VERSION_MAJOR}.${KDE_APPLICATIONS_VERSION_MINOR}.${KDE_APPLICATIONS_VERSION_MICRO}")
project(Dolphin VERSION ${KDE_APPLICATIONS_VERSION})
set(QT_MIN_VERSION "5.5.0")
-set(KF5_MIN_VERSION "5.37.0")
+set(KF5_MIN_VERSION "5.43.0")
set(ECM_MIN_VERSION "1.6.0")
# ECM setup
m_mainWindow(parent),
m_fileInfo(fileInfo),
m_baseUrl(baseUrl),
- m_baseFileItem(0),
+ m_baseFileItem(nullptr),
m_selectedItems(),
m_selectedItemsProperties(nullptr),
m_context(NoContext),
m_copyToMenu(parent),
m_customActions(),
m_command(None),
- m_removeAction(0)
+ m_removeAction(nullptr)
{
// The context menu either accesses the URLs of the selected items
// or the items itself. To increase the performance both lists are cached.
if (selectedUrl.isValid()) {
PlacesItemModel model;
const QString text = selectedUrl.fileName();
- PlacesItem* item = model.createPlacesItem(text, selectedUrl, KIO::iconNameForUrl(selectedUrl));
- model.appendItemToGroup(item);
- model.saveBookmarks();
+ model.createPlacesItem(text, selectedUrl, KIO::iconNameForUrl(selectedUrl));
}
} else if (activatedAction == openParentAction) {
m_command = OpenParentFolder;
addAction(m_mainWindow->actionCollection()->action(QStringLiteral("new_tab")));
// Insert 'Add to Places' entry if exactly one item is selected
- QAction* addToPlacesAction = 0;
+ QAction* addToPlacesAction = nullptr;
if (!placeExists(m_mainWindow->activeViewContainer()->url())) {
addToPlacesAction = addAction(QIcon::fromTheme(QStringLiteral("bookmark-new")),
i18nc("@action:inmenu Add current folder to places", "Add to Places"));
} else {
icon = KIO::iconNameForUrl(url);
}
- PlacesItem* item = model.createPlacesItem(container->placesText(), url, icon);
- model.appendItemToGroup(item);
- model.saveBookmarks();
+ model.createPlacesItem(container->placesText(), url, icon);
}
}
}
if (showDeleteAction && showMoveToTrashAction) {
delete m_removeAction;
- m_removeAction = 0;
+ m_removeAction = nullptr;
addAction(m_mainWindow->actionCollection()->action(KStandardAction::name(KStandardAction::MoveToTrash)));
addAction(m_mainWindow->actionCollection()->action(KStandardAction::name(KStandardAction::DeleteFile)));
} else if (showDeleteAction && !showMoveToTrashAction) {
QAction* DolphinContextMenu::createPasteAction()
{
- QAction* action = 0;
+ QAction* action = nullptr;
const bool isDir = !m_fileInfo.isNull() && m_fileInfo.isDir();
if (isDir && (m_selectedItems.count() == 1)) {
const QMimeData *mimeData = QApplication::clipboard()->mimeData();
const KFileItem& fileInfo,
const QUrl& baseUrl);
- virtual ~DolphinContextMenu();
+ ~DolphinContextMenu() override;
void setCustomActions(const QList<QAction*>& actions);
Command open();
protected:
- virtual void keyPressEvent(QKeyEvent *ev) Q_DECL_OVERRIDE;
- virtual void keyReleaseEvent(QKeyEvent *ev) Q_DECL_OVERRIDE;
+ void keyPressEvent(QKeyEvent *ev) override;
+ void keyReleaseEvent(QKeyEvent *ev) override;
private:
void openTrashContextMenu();
public:
explicit DolphinDockTitleBar(QWidget* parent = nullptr) : QWidget(parent) {}
- virtual ~DolphinDockTitleBar() {}
+ ~DolphinDockTitleBar() override {}
- QSize minimumSizeHint() const Q_DECL_OVERRIDE
+ QSize minimumSizeHint() const override
{
const int border = style()->pixelMetric(QStyle::PM_DockWidgetTitleBarButtonMargin);
return QSize(border, border);
}
- QSize sizeHint() const Q_DECL_OVERRIDE
+ QSize sizeHint() const override
{
return minimumSizeHint();
}
Q_OBJECT
public:
- explicit DolphinDockWidget(const QString& title, QWidget* parent = 0, Qt::WindowFlags flags = 0);
- explicit DolphinDockWidget(QWidget* parent = 0, Qt::WindowFlags flags = 0);
- virtual ~DolphinDockWidget();
+ explicit DolphinDockWidget(const QString& title, QWidget* parent = nullptr, Qt::WindowFlags flags = nullptr);
+ explicit DolphinDockWidget(QWidget* parent = nullptr, Qt::WindowFlags flags = nullptr);
+ ~DolphinDockWidget() override;
/**
* @param lock If \a lock is true, the title bar of the dock-widget will get hidden so
}
DolphinMainWindow::DolphinMainWindow() :
- KXmlGuiWindow(0),
- m_newFileMenu(0),
- m_tabWidget(0),
- m_activeViewContainer(0),
- m_actionHandler(0),
- m_remoteEncoding(0),
+ KXmlGuiWindow(nullptr),
+ m_newFileMenu(nullptr),
+ m_tabWidget(nullptr),
+ m_activeViewContainer(nullptr),
+ m_actionHandler(nullptr),
+ m_remoteEncoding(nullptr),
m_settingsDialog(),
- m_controlButton(0),
- m_updateToolBarTimer(0),
- m_lastHandleUrlStatJob(0),
+ m_controlButton(nullptr),
+ m_updateToolBarTimer(nullptr),
+ m_lastHandleUrlStatJob(nullptr),
#ifndef Q_OS_WIN
- m_terminalPanel(0),
+ m_terminalPanel(nullptr),
#endif
- m_placesPanel(0),
+ m_placesPanel(nullptr),
m_tearDownFromPlacesRequested(false)
{
Q_INIT_RESOURCE(dolphin);
GeneralSettings::setLockPanels(newLockState);
}
+void DolphinMainWindow::slotTerminalPanelVisibilityChanged()
+{
+#ifndef Q_OS_WIN
+ if (m_terminalPanel->isHiddenInVisibleWindow()) {
+ m_activeViewContainer->view()->setFocus();
+ }
+#endif
+}
+
void DolphinMainWindow::goBack()
{
KUrlNavigator* urlNavigator = m_activeViewContainer->urlNavigator();
void DolphinMainWindow::handleUrl(const QUrl& url)
{
delete m_lastHandleUrlStatJob;
- m_lastHandleUrlStatJob = 0;
+ m_lastHandleUrlStatJob = nullptr;
if (url.isLocalFile() && QFileInfo(url.toLocalFile()).isDir()) {
activeViewContainer()->setUrl(url);
void DolphinMainWindow::slotHandleUrlStatFinished(KJob* job)
{
- m_lastHandleUrlStatJob = 0;
+ m_lastHandleUrlStatJob = nullptr;
const KIO::UDSEntry entry = static_cast<KIO::StatJob*>(job)->statResult();
const QUrl url = static_cast<KIO::StatJob*>(job)->url();
if (entry.isDir()) {
void DolphinMainWindow::slotControlButtonDeleted()
{
- m_controlButton = 0;
+ m_controlButton = nullptr;
m_updateToolBarTimer->start();
}
fileName = '/';
}
+ if (m_activeViewContainer->isSearchModeEnabled()) {
+ if(m_activeViewContainer->currentSearchText().isEmpty()){
+ setWindowTitle(i18n("Search"));
+ } else {
+ const auto searchText = i18n("Search for %1", m_activeViewContainer->currentSearchText());
+ setWindowTitle(searchText);
+ }
+ return;
+ }
+
setWindowTitle(schemePrefix + fileName);
}
compareFiles->setEnabled(false);
connect(compareFiles, &QAction::triggered, this, &DolphinMainWindow::compareFiles);
+#ifndef Q_OS_WIN
if (KAuthorized::authorize(QStringLiteral("shell_access"))) {
QAction* openTerminal = actionCollection()->addAction(QStringLiteral("open_terminal"));
openTerminal->setText(i18nc("@action:inmenu Tools", "Open Terminal"));
actionCollection()->setDefaultShortcut(openTerminal, Qt::SHIFT | Qt::Key_F4);
connect(openTerminal, &QAction::triggered, this, &DolphinMainWindow::openTerminal);
}
+#endif
// setup 'Settings' menu
- KToggleAction* showMenuBar = KStandardAction::showMenubar(0, 0, actionCollection());
+ KToggleAction* showMenuBar = KStandardAction::showMenubar(nullptr, nullptr, actionCollection());
connect(showMenuBar, &KToggleAction::triggered, // Fixes #286822
this, &DolphinMainWindow::toggleShowMenuBar, Qt::QueuedConnection);
KStandardAction::preferences(this, SLOT(editSettings()), actionCollection());
connect(m_terminalPanel, &TerminalPanel::changeUrl, this, &DolphinMainWindow::slotTerminalDirectoryChanged);
connect(terminalDock, &DolphinDockWidget::visibilityChanged,
m_terminalPanel, &TerminalPanel::dockVisibilityChanged);
+ connect(terminalDock, &DolphinDockWidget::visibilityChanged,
+ this, &DolphinMainWindow::slotTerminalPanelVisibilityChanged);
QAction* terminalAction = terminalDock->toggleViewAction();
createPanelAction(QIcon::fromTheme(QStringLiteral("utilities-terminal")), Qt::Key_F4, terminalAction, QStringLiteral("show_terminal_panel"));
void DolphinMainWindow::deleteControlButton()
{
delete m_controlButton;
- m_controlButton = 0;
+ m_controlButton = nullptr;
delete m_updateToolBarTimer;
- m_updateToolBarTimer = 0;
+ m_updateToolBarTimer = nullptr;
}
bool DolphinMainWindow::addActionToMenu(QAction* action, QMenu* menu)
public:
DolphinMainWindow();
- virtual ~DolphinMainWindow();
+ ~DolphinMainWindow() override;
/**
* Returns the currently active view.
protected:
/** @see QWidget::showEvent() */
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
+ void showEvent(QShowEvent* event) override;
/** @see QMainWindow::closeEvent() */
- virtual void closeEvent(QCloseEvent* event) Q_DECL_OVERRIDE;
+ void closeEvent(QCloseEvent* event) override;
/** @see KMainWindow::saveProperties() */
- virtual void saveProperties(KConfigGroup& group) Q_DECL_OVERRIDE;
+ void saveProperties(KConfigGroup& group) override;
/** @see KMainWindow::readProperties() */
- virtual void readProperties(const KConfigGroup& group) Q_DECL_OVERRIDE;
+ void readProperties(const KConfigGroup& group) override;
private slots:
/**
*/
void togglePanelLockState();
+ /**
+ * Is invoked if the Terminal panel got visible/invisible and takes care
+ * that the active view has the focus if the Terminal panel is invisible.
+ */
+ void slotTerminalPanelVisibilityChanged();
+
/** Goes back one step of the URL history. */
void goBack();
{
public:
UndoUiInterface();
- virtual ~UndoUiInterface();
- virtual void jobError(KIO::Job* job) Q_DECL_OVERRIDE;
+ ~UndoUiInterface() override;
+ void jobError(KIO::Job* job) override;
};
KNewFileMenu* m_newFileMenu;
public:
DolphinNewFileMenu(KActionCollection* collection, QObject* parent);
- virtual ~DolphinNewFileMenu();
+ ~DolphinNewFileMenu() override;
signals:
void errorMessage(const QString& error);
protected slots:
/** @see KNewFileMenu::slotResult() */
- virtual void slotResult(KJob* job) Q_DECL_OVERRIDE;
+ void slotResult(KJob* job) override;
};
#endif
DolphinPart::DolphinPart(QWidget* parentWidget, QObject* parent, const QVariantList& args)
: KParts::ReadOnlyPart(parent)
- ,m_openTerminalAction(0)
- ,m_removeAction(0)
+ ,m_openTerminalAction(nullptr)
+ ,m_removeAction(nullptr)
{
Q_UNUSED(args)
setComponentData(*createAboutData(), false);
m_findFileAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-find")));
connect(m_findFileAction, &QAction::triggered, this, &DolphinPart::slotFindFile);
+#ifndef Q_OS_WIN
if (KAuthorized::authorize(QStringLiteral("shell_access"))) {
m_openTerminalAction = actionCollection()->addAction(QStringLiteral("open_terminal"));
m_openTerminalAction->setIcon(QIcon::fromTheme(QStringLiteral("utilities-terminal")));
connect(m_openTerminalAction, &QAction::triggered, this, &DolphinPart::slotOpenTerminal);
actionCollection()->setDefaultShortcut(m_openTerminalAction, Qt::Key_F4);
}
+#endif
}
void DolphinPart::createGoAction(const char* name, const char* iconName,
QString prettyUrl = visibleUrl.toDisplayString(QUrl::PreferLocalFile);
emit setWindowCaption(prettyUrl);
emit m_extension->setLocationBarUrl(prettyUrl);
- emit started(0); // get the wheel to spin
+ emit started(nullptr); // get the wheel to spin
m_view->setNameFilter(m_nameFilter);
m_view->setUrl(url);
updatePasteAction();
if (showDeleteAction && showMoveToTrashAction) {
delete m_removeAction;
- m_removeAction = 0;
+ m_removeAction = nullptr;
editActions.append(actionCollection()->action(KStandardAction::name(KStandardAction::MoveToTrash)));
editActions.append(actionCollection()->action(KStandardAction::name(KStandardAction::DeleteFile)));
} else if (showDeleteAction && !showMoveToTrashAction) {
Name[nb]=Kompakt
Name[nl]=Compact
Name[nn]=Kompakt
-Name[pa]=ਸੰà¨\96ਿਪਤ
+Name[pa]=ਸੰà¨\96à©\87ਪ
Name[pl]=Kompaktowy
Name[pt]=Compacta
Name[pt_BR]=Compacto
public:
explicit DolphinPart(QWidget* parentWidget, QObject* parent, const QVariantList& args);
- ~DolphinPart();
+ ~DolphinPart() override;
static KAboutData* createAboutData();
* Standard KParts::ReadOnlyPart openUrl method.
* Called by Konqueror to view a directory in DolphinPart.
*/
- virtual bool openUrl(const QUrl& url) Q_DECL_OVERRIDE;
+ bool openUrl(const QUrl& url) override;
/// see the supportsUndo property
bool supportsUndo() const { return true; }
/**
* We reimplement openUrl so no need to implement openFile.
*/
- virtual bool openFile() override { return true; }
+ bool openFile() override { return true; }
Q_SIGNALS:
/**
void setFilesToSelect(const QList<QUrl> &files);
QList<QUrl> filesToSelect() const { return QList<QUrl>(); } // silence moc
- virtual bool eventFilter(QObject*, QEvent*) Q_DECL_OVERRIDE;
+ bool eventFilter(QObject*, QEvent*) override;
private:
void createActions();
Q_OBJECT
public:
DolphinPartBrowserExtension( DolphinPart* part );
- virtual void restoreState(QDataStream &stream) Q_DECL_OVERRIDE;
- virtual void saveState(QDataStream &stream) Q_DECL_OVERRIDE;
+ void restoreState(QDataStream &stream) override;
+ void saveState(QDataStream &stream) override;
public Q_SLOTS:
void cut();
public:
DolphinPartFileInfoExtension(DolphinPart* part);
- virtual QueryModes supportedQueryModes() const Q_DECL_OVERRIDE;
- virtual bool hasSelection() const Q_DECL_OVERRIDE;
+ QueryModes supportedQueryModes() const override;
+ bool hasSelection() const override;
- virtual KFileItemList queryFor(QueryMode mode) const Q_DECL_OVERRIDE;
+ KFileItemList queryFor(QueryMode mode) const override;
private:
DolphinPart* m_part;
public:
DolphinPartListingFilterExtension(DolphinPart* part);
- virtual FilterModes supportedFilterModes() const Q_DECL_OVERRIDE;
- virtual bool supportsMultipleFilters(FilterMode mode) const Q_DECL_OVERRIDE;
- virtual QVariant filter(FilterMode mode) const Q_DECL_OVERRIDE;
- virtual void setFilter(FilterMode mode, const QVariant& filter) Q_DECL_OVERRIDE;
+ FilterModes supportedFilterModes() const override;
+ bool supportsMultipleFilters(FilterMode mode) const override;
+ QVariant filter(FilterMode mode) const override;
+ void setFilter(FilterMode mode, const QVariant& filter) override;
private:
DolphinPart* m_part;
public:
DolphinPartListingNotificationExtension(DolphinPart* part);
- virtual NotificationEventTypes supportedNotificationEventTypes() const Q_DECL_OVERRIDE;
+ NotificationEventTypes supportedNotificationEventTypes() const override;
public Q_SLOTS:
void slotNewItems(const KFileItemList&);
const QByteArray state = action->data().toByteArray();
removeAction(action);
delete action;
- action = 0;
+ action = nullptr;
emit restoreClosedTab(state);
emit closedTabsCountChanged(menu()->actions().size() - 2);
}
void tabDetachRequested(int index);
protected:
- virtual void dragEnterEvent(QDragEnterEvent* event) Q_DECL_OVERRIDE;
- virtual void dragLeaveEvent(QDragLeaveEvent* event) Q_DECL_OVERRIDE;
- virtual void dragMoveEvent(QDragMoveEvent* event) Q_DECL_OVERRIDE;
- virtual void dropEvent(QDropEvent* event) Q_DECL_OVERRIDE;
- virtual void mousePressEvent(QMouseEvent* event) Q_DECL_OVERRIDE;
- virtual void mouseReleaseEvent(QMouseEvent* event) Q_DECL_OVERRIDE;
- virtual void mouseDoubleClickEvent(QMouseEvent* event) Q_DECL_OVERRIDE;
+ void dragEnterEvent(QDragEnterEvent* event) override;
+ void dragLeaveEvent(QDragLeaveEvent* event) override;
+ void dragMoveEvent(QDragMoveEvent* event) override;
+ void dropEvent(QDropEvent* event) override;
+ void mousePressEvent(QMouseEvent* event) override;
+ void mouseReleaseEvent(QMouseEvent* event) override;
+ void mouseDoubleClickEvent(QMouseEvent* event) override;
/**
* Opens a context menu for the tab on the \a event position.
*/
- virtual void contextMenuEvent(QContextMenuEvent* event) Q_DECL_OVERRIDE;
+ void contextMenuEvent(QContextMenuEvent* event) override;
private slots:
void slotAutoActivationTimeout();
Q_OBJECT
public:
- explicit DolphinTabPage(const QUrl& primaryUrl, const QUrl& secondaryUrl = QUrl(), QWidget* parent = 0);
+ explicit DolphinTabPage(const QUrl& primaryUrl, const QUrl& secondaryUrl = QUrl(), QWidget* parent = nullptr);
/**
* @return True if primary view is the active view in this tab.
void currentTabChanged(int index);
protected:
- virtual void tabInserted(int index) Q_DECL_OVERRIDE;
- virtual void tabRemoved(int index) Q_DECL_OVERRIDE;
+ void tabInserted(int index) override;
+ void tabRemoved(int index) override;
private:
/**
DolphinViewContainer::DolphinViewContainer(const QUrl& url, QWidget* parent) :
QWidget(parent),
- m_topLayout(0),
- m_urlNavigator(0),
- m_searchBox(0),
- m_messageWidget(0),
- m_view(0),
- m_filterBar(0),
- m_statusBar(0),
- m_statusBarTimer(0),
+ m_topLayout(nullptr),
+ m_urlNavigator(nullptr),
+ m_searchBox(nullptr),
+ m_messageWidget(nullptr),
+ m_view(nullptr),
+ m_filterBar(nullptr),
+ m_statusBar(nullptr),
+ m_statusBarTimer(nullptr),
m_statusBarTimestamp(),
m_autoGrabFocus(true)
#ifdef KActivities_FOUND
return m_autoGrabFocus;
}
+QString DolphinViewContainer::currentSearchText() const
+{
+ return m_searchBox->text();
+}
+
const DolphinStatusBar* DolphinViewContainer::statusBar() const
{
return m_statusBar;
};
DolphinViewContainer(const QUrl& url, QWidget* parent);
- virtual ~DolphinViewContainer();
+ ~DolphinViewContainer() override;
/**
* Returns the current active URL, where all actions are applied.
void setAutoGrabFocus(bool grab);
bool autoGrabFocus() const;
+ QString currentSearchText() const;
+
const DolphinStatusBar* statusBar() const;
DolphinStatusBar* statusBar();
Q_OBJECT
public:
- explicit FilterBar(QWidget* parent = 0);
- virtual ~FilterBar();
+ explicit FilterBar(QWidget* parent = nullptr);
+ ~FilterBar() override;
/** Called by view container to hide this **/
void closeFilterBar();
void focusViewRequest();
protected:
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
- virtual void keyReleaseEvent(QKeyEvent* event) Q_DECL_OVERRIDE;
+ void showEvent(QShowEvent* event) override;
+ void keyReleaseEvent(QKeyEvent* event) override;
private:
QLineEdit* m_filterInput;
KFileItemListView::KFileItemListView(QGraphicsWidget* parent) :
KStandardItemListView(parent),
- m_modelRolesUpdater(0),
- m_updateVisibleIndexRangeTimer(0),
- m_updateIconSizeTimer(0)
+ m_modelRolesUpdater(nullptr),
+ m_updateVisibleIndexRangeTimer(nullptr),
+ m_updateIconSizeTimer(nullptr)
{
setAcceptDrops(true);
KStandardItemListView::onModelChanged(current, previous);
delete m_modelRolesUpdater;
- m_modelRolesUpdater = 0;
+ m_modelRolesUpdater = nullptr;
if (current) {
m_modelRolesUpdater = new KFileItemModelRolesUpdater(static_cast<KFileItemModel*>(current), this);
Q_OBJECT
public:
- KFileItemListView(QGraphicsWidget* parent = 0);
- virtual ~KFileItemListView();
+ KFileItemListView(QGraphicsWidget* parent = nullptr);
+ ~KFileItemListView() override;
void setPreviewsShown(bool show);
bool previewsShown() const;
*/
QStringList enabledPlugins() const;
- virtual QPixmap createDragPixmap(const KItemSet& indexes) const Q_DECL_OVERRIDE;
+ QPixmap createDragPixmap(const KItemSet& indexes) const override;
protected:
- virtual KItemListWidgetCreatorBase* defaultWidgetCreator() const Q_DECL_OVERRIDE;
- virtual void initializeItemListWidget(KItemListWidget* item) Q_DECL_OVERRIDE;
+ KItemListWidgetCreatorBase* defaultWidgetCreator() const override;
+ void initializeItemListWidget(KItemListWidget* item) override;
virtual void onPreviewsShownChanged(bool shown);
- virtual void onItemLayoutChanged(ItemLayout current, ItemLayout previous) Q_DECL_OVERRIDE;
- virtual void onModelChanged(KItemModelBase* current, KItemModelBase* previous) Q_DECL_OVERRIDE;
- virtual void onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous) Q_DECL_OVERRIDE;
- virtual void onItemSizeChanged(const QSizeF& current, const QSizeF& previous) Q_DECL_OVERRIDE;
- virtual void onScrollOffsetChanged(qreal current, qreal previous) Q_DECL_OVERRIDE;
- virtual void onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous) Q_DECL_OVERRIDE;
- virtual void onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous) Q_DECL_OVERRIDE;
- virtual void onSupportsItemExpandingChanged(bool supportsExpanding) Q_DECL_OVERRIDE;
- virtual void onTransactionBegin() Q_DECL_OVERRIDE;
- virtual void onTransactionEnd() Q_DECL_OVERRIDE;
- virtual void resizeEvent(QGraphicsSceneResizeEvent* event) Q_DECL_OVERRIDE;
+ void onItemLayoutChanged(ItemLayout current, ItemLayout previous) override;
+ void onModelChanged(KItemModelBase* current, KItemModelBase* previous) override;
+ void onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous) override;
+ void onItemSizeChanged(const QSizeF& current, const QSizeF& previous) override;
+ void onScrollOffsetChanged(qreal current, qreal previous) override;
+ void onVisibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous) override;
+ void onStyleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous) override;
+ void onSupportsItemExpandingChanged(bool supportsExpanding) override;
+ void onTransactionBegin() override;
+ void onTransactionEnd() override;
+ void resizeEvent(QGraphicsSceneResizeEvent* event) override;
protected slots:
- virtual void slotItemsRemoved(const KItemRangeList& itemRanges) Q_DECL_OVERRIDE;
- virtual void slotSortRoleChanged(const QByteArray& current, const QByteArray& previous) Q_DECL_OVERRIDE;
+ void slotItemsRemoved(const KItemRangeList& itemRanges) override;
+ void slotSortRoleChanged(const QByteArray& current, const QByteArray& previous) override;
private slots:
void triggerVisibleIndexRangeUpdate();
const KIO::filesize_t size = roleValue.value<KIO::filesize_t>();
text = KFormat().formatByteSize(size);
}
- } else if (role == "modificationtime" || role == "accesstime" || role == "deletiontime") {
+ } else if (role == "modificationtime" || role == "accesstime" || role == "deletiontime" || role == "imageDateTime") {
const QDateTime dateTime = roleValue.toDateTime();
text = QLocale().toString(dateTime, QLocale::ShortFormat);
} else {
{
public:
KFileItemListWidgetInformant();
- virtual ~KFileItemListWidgetInformant();
+ ~KFileItemListWidgetInformant() override;
protected:
- virtual QString itemText(int index, const KItemListView* view) const Q_DECL_OVERRIDE;
- virtual bool itemIsLink(int index, const KItemListView* view) const Q_DECL_OVERRIDE;
- virtual QString roleText(const QByteArray& role, const QHash<QByteArray, QVariant>& values) const Q_DECL_OVERRIDE;
- virtual QFont customizedFontForLinks(const QFont& baseFont) const Q_DECL_OVERRIDE;
+ QString itemText(int index, const KItemListView* view) const override;
+ bool itemIsLink(int index, const KItemListView* view) const override;
+ QString roleText(const QByteArray& role, const QHash<QByteArray, QVariant>& values) const override;
+ QFont customizedFontForLinks(const QFont& baseFont) const override;
};
class DOLPHIN_EXPORT KFileItemListWidget : public KStandardItemListWidget
public:
KFileItemListWidget(KItemListWidgetInformant* informant, QGraphicsItem* parent);
- virtual ~KFileItemListWidget();
+ ~KFileItemListWidget() override;
static KItemListWidgetInformant* createInformant();
protected:
- virtual bool isRoleRightAligned(const QByteArray& role) const Q_DECL_OVERRIDE;
- virtual bool isHidden() const Q_DECL_OVERRIDE;
- virtual QFont customizedFont(const QFont& baseFont) const Q_DECL_OVERRIDE;
+ bool isRoleRightAligned(const QByteArray& role) const override;
+ bool isHidden() const override;
+ QFont customizedFont(const QFont& baseFont) const override;
/**
* @return Selection length without MIME-type extension
*/
- virtual int selectionLength(const QString& text) const Q_DECL_OVERRIDE;
+ int selectionLength(const QString& text) const override;
};
#endif
KFileItemModel::KFileItemModel(QObject* parent) :
KItemModelBase("text", parent),
- m_dirLister(0),
+ m_dirLister(nullptr),
m_sortDirsFirst(true),
m_sortRole(NameRole),
m_sortingProgressPercent(-1),
m_filter(),
m_filteredItems(),
m_requestRole(),
- m_maximumUpdateIntervalTimer(0),
- m_resortAllItemsTimer(0),
+ m_maximumUpdateIntervalTimer(nullptr),
+ m_resortAllItemsTimer(nullptr),
m_pendingItemsToInsert(),
m_groups(),
m_expandedDirs(),
QList<QUrl> urls;
QList<QUrl> mostLocalUrls;
bool canUseMostLocalUrls = true;
- const ItemData* lastAddedItem = 0;
+ const ItemData* lastAddedItem = nullptr;
for (int index : indexes) {
const ItemData* itemData = m_itemData.at(index);
{
static const RoleInfoMap rolesInfoMap[] = {
// | role | roleType | role translation | group translation | requires Baloo | requires indexer
- { 0, NoRole, 0, 0, 0, 0, false, false },
- { "text", NameRole, I18N_NOOP2_NOSTRIP("@label", "Name"), 0, 0, false, false },
- { "size", SizeRole, I18N_NOOP2_NOSTRIP("@label", "Size"), 0, 0, false, false },
- { "modificationtime", ModificationTimeRole, I18N_NOOP2_NOSTRIP("@label", "Modified"), 0, 0, false, false },
- { "creationtime", CreationTimeRole, I18N_NOOP2_NOSTRIP("@label", "Created"), 0, 0, false, false },
- { "accesstime", AccessTimeRole, I18N_NOOP2_NOSTRIP("@label", "Accessed"), 0, 0, false, false },
- { "type", TypeRole, I18N_NOOP2_NOSTRIP("@label", "Type"), 0, 0, false, false },
- { "rating", RatingRole, I18N_NOOP2_NOSTRIP("@label", "Rating"), 0, 0, true, false },
- { "tags", TagsRole, I18N_NOOP2_NOSTRIP("@label", "Tags"), 0, 0, true, false },
- { "comment", CommentRole, I18N_NOOP2_NOSTRIP("@label", "Comment"), 0, 0, true, false },
+ { nullptr, NoRole, nullptr, nullptr, nullptr, nullptr, false, false },
+ { "text", NameRole, I18N_NOOP2_NOSTRIP("@label", "Name"), nullptr, nullptr, false, false },
+ { "size", SizeRole, I18N_NOOP2_NOSTRIP("@label", "Size"), nullptr, nullptr, false, false },
+ { "modificationtime", ModificationTimeRole, I18N_NOOP2_NOSTRIP("@label", "Modified"), nullptr, nullptr, false, false },
+ { "creationtime", CreationTimeRole, I18N_NOOP2_NOSTRIP("@label", "Created"), nullptr, nullptr, false, false },
+ { "accesstime", AccessTimeRole, I18N_NOOP2_NOSTRIP("@label", "Accessed"), nullptr, nullptr, false, false },
+ { "type", TypeRole, I18N_NOOP2_NOSTRIP("@label", "Type"), nullptr, nullptr, false, false },
+ { "rating", RatingRole, I18N_NOOP2_NOSTRIP("@label", "Rating"), nullptr, nullptr, true, false },
+ { "tags", TagsRole, I18N_NOOP2_NOSTRIP("@label", "Tags"), nullptr, nullptr, true, false },
+ { "comment", CommentRole, I18N_NOOP2_NOSTRIP("@label", "Comment"), nullptr, nullptr, true, false },
{ "title", TitleRole, I18N_NOOP2_NOSTRIP("@label", "Title"), I18N_NOOP2_NOSTRIP("@label", "Document"), true, true },
{ "wordCount", WordCountRole, I18N_NOOP2_NOSTRIP("@label", "Word Count"), I18N_NOOP2_NOSTRIP("@label", "Document"), true, true },
{ "lineCount", LineCountRole, I18N_NOOP2_NOSTRIP("@label", "Line Count"), I18N_NOOP2_NOSTRIP("@label", "Document"), true, true },
+ { "imageDateTime", ImageDateTimeRole, I18N_NOOP2_NOSTRIP("@label", "Date Photographed"), I18N_NOOP2_NOSTRIP("@label", "Image"), true, true },
{ "imageSize", ImageSizeRole, I18N_NOOP2_NOSTRIP("@label", "Image Size"), I18N_NOOP2_NOSTRIP("@label", "Image"), true, true },
{ "orientation", OrientationRole, I18N_NOOP2_NOSTRIP("@label", "Orientation"), I18N_NOOP2_NOSTRIP("@label", "Image"), true, true },
{ "artist", ArtistRole, I18N_NOOP2_NOSTRIP("@label", "Artist"), I18N_NOOP2_NOSTRIP("@label", "Audio"), true, true },
return false;
}
- for (int i = 0; i < count(); ++i) {
+ for (int i = 0, iMax = count(); i < iMax; ++i) {
// Check if m_items and m_itemData are consistent.
const KFileItem item = fileItem(i);
if (item.isNull()) {
Q_OBJECT
public:
- explicit KFileItemModel(QObject* parent = 0);
- virtual ~KFileItemModel();
+ explicit KFileItemModel(QObject* parent = nullptr);
+ ~KFileItemModel() override;
/**
* Loads the directory specified by \a url. The signals
* the root-parent of all items.
* @see rootItem()
*/
- QUrl directory() const Q_DECL_OVERRIDE;
+ QUrl directory() const override;
/**
* Cancels the loading of a directory which has been started by either
*/
void cancelDirectoryLoading();
- virtual int count() const Q_DECL_OVERRIDE;
- virtual QHash<QByteArray, QVariant> data(int index) const Q_DECL_OVERRIDE;
- virtual bool setData(int index, const QHash<QByteArray, QVariant>& values) Q_DECL_OVERRIDE;
+ int count() const override;
+ QHash<QByteArray, QVariant> data(int index) const override;
+ bool setData(int index, const QHash<QByteArray, QVariant>& values) override;
/**
* Sets a separate sorting with directories first (true) or a mixed
void setShowDirectoriesOnly(bool enabled);
bool showDirectoriesOnly() const;
- virtual QMimeData* createMimeData(const KItemSet& indexes) const Q_DECL_OVERRIDE;
+ QMimeData* createMimeData(const KItemSet& indexes) const override;
- virtual int indexForKeyboardSearch(const QString& text, int startFromIndex = 0) const Q_DECL_OVERRIDE;
+ int indexForKeyboardSearch(const QString& text, int startFromIndex = 0) const override;
- virtual bool supportsDropping(int index) const Q_DECL_OVERRIDE;
+ bool supportsDropping(int index) const override;
- virtual QString roleDescription(const QByteArray& role) const Q_DECL_OVERRIDE;
+ QString roleDescription(const QByteArray& role) const override;
- virtual QList<QPair<int, QVariant> > groups() const Q_DECL_OVERRIDE;
+ QList<QPair<int, QVariant> > groups() const override;
/**
* @return The file-item for the index \a index. If the index is in a valid
void setRoles(const QSet<QByteArray>& roles);
QSet<QByteArray> roles() const;
- virtual bool setExpanded(int index, bool expanded) Q_DECL_OVERRIDE;
- virtual bool isExpanded(int index) const Q_DECL_OVERRIDE;
- virtual bool isExpandable(int index) const Q_DECL_OVERRIDE;
- virtual int expandedParentsCount(int index) const Q_DECL_OVERRIDE;
+ bool setExpanded(int index, bool expanded) override;
+ bool isExpanded(int index) const override;
+ bool isExpandable(int index) const override;
+ int expandedParentsCount(int index) const override;
QSet<QUrl> expandedDirectories() const;
void urlIsFileError(const QUrl& url);
protected:
- virtual void onGroupedSortingChanged(bool current) Q_DECL_OVERRIDE;
- virtual void onSortRoleChanged(const QByteArray& current, const QByteArray& previous) Q_DECL_OVERRIDE;
- virtual void onSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous) Q_DECL_OVERRIDE;
+ void onGroupedSortingChanged(bool current) override;
+ void onSortRoleChanged(const QByteArray& current, const QByteArray& previous) override;
+ void onSortOrderChanged(Qt::SortOrder current, Qt::SortOrder previous) override;
private slots:
/**
NoRole, NameRole, SizeRole, ModificationTimeRole, CreationTimeRole, AccessTimeRole, PermissionsRole, OwnerRole,
GroupRole, TypeRole, DestinationRole, PathRole, DeletionTimeRole,
// User visible roles available with Baloo:
- CommentRole, TagsRole, RatingRole, ImageSizeRole, OrientationRole,
+ CommentRole, TagsRole, RatingRole, ImageSizeRole, ImageDateTimeRole, OrientationRole,
WordCountRole, TitleRole, LineCountRole, ArtistRole, GenreRole, AlbumRole, DurationRole, TrackRole, ReleaseYearRole,
BitrateRole, OriginUrlRole,
// Non-visible roles:
m_pendingIndexes(),
m_pendingPreviewItems(),
m_previewJob(),
- m_recentlyChangedItemsTimer(0),
+ m_recentlyChangedItemsTimer(nullptr),
m_recentlyChangedItems(),
m_changedItems(),
- m_directoryContentsCounter(0)
+ m_directoryContentsCounter(nullptr)
#ifdef HAVE_BALOO
- , m_balooFileMonitor(0)
+ , m_balooFileMonitor(nullptr)
#endif
{
Q_ASSERT(model);
const KConfigGroup globalConfig(KSharedConfig::openConfig(), "PreviewSettings");
- m_enabledPlugins = globalConfig.readEntry("Plugins", QStringList()
- << QStringLiteral("directorythumbnail")
- << QStringLiteral("imagethumbnail")
- << QStringLiteral("jpegthumbnail"));
+ m_enabledPlugins = globalConfig.readEntry("Plugins", KIO::PreviewJob::defaultPlugins());
connect(m_model, &KFileItemModel::itemsInserted,
this, &KFileItemModelRolesUpdater::slotItemsInserted);
this, &KFileItemModelRolesUpdater::applyChangedBalooRoles);
} else if (!hasBalooRole && m_balooFileMonitor) {
delete m_balooFileMonitor;
- m_balooFileMonitor = 0;
+ m_balooFileMonitor = nullptr;
}
#endif
void KFileItemModelRolesUpdater::slotPreviewJobFinished()
{
- m_previewJob = 0;
+ m_previewJob = nullptr;
if (m_state != PreviewJobRunning) {
return;
disconnect(m_previewJob, &KIO::PreviewJob::finished,
this, &KFileItemModelRolesUpdater::slotPreviewJobFinished);
m_previewJob->kill();
- m_previewJob = 0;
+ m_previewJob = nullptr;
m_pendingPreviewItems.clear();
}
}
Q_OBJECT
public:
- explicit KFileItemModelRolesUpdater(KFileItemModel* model, QObject* parent = 0);
- virtual ~KFileItemModelRolesUpdater();
+ explicit KFileItemModelRolesUpdater(KFileItemModel* model, QObject* parent = nullptr);
+ ~KFileItemModelRolesUpdater() override;
void setIconSize(const QSize& size);
QSize iconSize() const;
#include <QStyle>
#include <QStyleOption>
-
/**
* Replaces the default viewport of KItemListContainer by a
* non-scrollable viewport. The scrolling is done in an optimized
public:
KItemListContainerViewport(QGraphicsScene* scene, QWidget* parent);
protected:
- void wheelEvent(QWheelEvent* event) Q_DECL_OVERRIDE;
+ void wheelEvent(QWheelEvent* event) override;
};
KItemListContainerViewport::KItemListContainerViewport(QGraphicsScene* scene, QWidget* parent) :
KItemListContainer::KItemListContainer(KItemListController* controller, QWidget* parent) :
QAbstractScrollArea(parent),
m_controller(controller),
- m_horizontalSmoothScroller(0),
- m_verticalSmoothScroller(0)
+ m_horizontalSmoothScroller(nullptr),
+ m_verticalSmoothScroller(nullptr)
{
Q_ASSERT(controller);
controller->setParent(this);
m_verticalSmoothScroller = new KItemListSmoothScroller(verticalScrollBar(), this);
if (controller->model()) {
- slotModelChanged(controller->model(), 0);
+ slotModelChanged(controller->model(), nullptr);
}
if (controller->view()) {
- slotViewChanged(controller->view(), 0);
+ slotViewChanged(controller->view(), nullptr);
}
connect(controller, &KItemListController::modelChanged,
// Don't rely on the QObject-order to delete the controller, otherwise
// the QGraphicsScene might get deleted before the view.
delete m_controller;
- m_controller = 0;
+ m_controller = nullptr;
}
KItemListController* KItemListContainer::controller() const
disconnect(previous, &KItemListView::maximumItemOffsetChanged,
this, &KItemListContainer::updateItemOffsetScrollBar);
disconnect(previous, &KItemListView::scrollTo, this, &KItemListContainer::scrollTo);
- m_horizontalSmoothScroller->setTargetObject(0);
- m_verticalSmoothScroller->setTargetObject(0);
+ m_horizontalSmoothScroller->setTargetObject(nullptr);
+ m_verticalSmoothScroller->setTargetObject(nullptr);
}
if (current) {
scene->addItem(current);
return;
}
- KItemListSmoothScroller* smoothScroller = 0;
- QScrollBar* scrollOffsetScrollBar = 0;
+ KItemListSmoothScroller* smoothScroller = nullptr;
+ QScrollBar* scrollOffsetScrollBar = nullptr;
int singleStep = 0;
int pageStep = 0;
int maximum = 0;
return;
}
- KItemListSmoothScroller* smoothScroller = 0;
- QScrollBar* itemOffsetScrollBar = 0;
+ KItemListSmoothScroller* smoothScroller = nullptr;
+ QScrollBar* itemOffsetScrollBar = nullptr;
int singleStep = 0;
int pageStep = 0;
if (view->scrollOrientation() == Qt::Vertical) {
* (the parent will be set to the KItemListContainer).
* @param parent Optional parent widget.
*/
- explicit KItemListContainer(KItemListController* controller, QWidget* parent = 0);
- virtual ~KItemListContainer();
+ explicit KItemListContainer(KItemListController* controller, QWidget* parent = nullptr);
+ ~KItemListContainer() override;
KItemListController* controller() const;
void setEnabledFrame(bool enable);
bool enabledFrame() const;
protected:
- virtual void keyPressEvent(QKeyEvent* event) Q_DECL_OVERRIDE;
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
- virtual void resizeEvent(QResizeEvent* event) Q_DECL_OVERRIDE;
- virtual void scrollContentsBy(int dx, int dy) Q_DECL_OVERRIDE;
- virtual void wheelEvent(QWheelEvent* event) Q_DECL_OVERRIDE;
+ void keyPressEvent(QKeyEvent* event) override;
+ void showEvent(QShowEvent* event) override;
+ void resizeEvent(QResizeEvent* event) override;
+ void scrollContentsBy(int dx, int dy) override;
+ void wheelEvent(QWheelEvent* event) override;
private slots:
void slotScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous);
m_selectionBehavior(NoSelection),
m_autoActivationBehavior(ActivationAndExpansion),
m_mouseDoubleClickAction(ActivateItemOnly),
- m_model(0),
- m_view(0),
+ m_model(nullptr),
+ m_view(nullptr),
m_selectionManager(new KItemListSelectionManager(this)),
m_keyboardManager(new KItemListKeyboardSearchManager(this)),
m_pressedIndex(-1),
m_pressedMousePos(),
- m_autoActivationTimer(0),
+ m_autoActivationTimer(nullptr),
m_oldSelection(),
m_keyboardAnchorIndex(-1),
m_keyboardAnchorPos(0)
KItemListController::~KItemListController()
{
- setView(0);
+ setView(nullptr);
Q_ASSERT(!m_view);
- setModel(0);
+ setModel(nullptr);
Q_ASSERT(!m_model);
}
return m_mouseDoubleClickAction;
}
+int KItemListController::indexCloseToMousePressedPosition() const
+{
+ QHashIterator<KItemListWidget*, KItemListGroupHeader*> it(m_view->m_visibleGroups);
+ while (it.hasNext()) {
+ it.next();
+ KItemListGroupHeader *groupHeader = it.value();
+ const QPointF mappedToGroup = groupHeader->mapFromItem(nullptr, m_pressedMousePos);
+ if (groupHeader->contains(mappedToGroup)) {
+ return it.key()->index();
+ }
+ }
+ return -1;
+}
+
void KItemListController::setAutoActivationDelay(int delay)
{
m_autoActivationTimer->setInterval(delay);
}
}
- return 0;
+ return nullptr;
}
KItemListWidget* KItemListController::widgetForPos(const QPointF& pos) const
}
}
- return 0;
+ return nullptr;
}
void KItemListController::updateKeyboardAnchor()
* @param view View of the controller. The ownership is passed to the controller.
* @param parent Optional parent object.
*/
- KItemListController(KItemModelBase* model, KItemListView* view, QObject* parent = 0);
- virtual ~KItemListController();
+ KItemListController(KItemModelBase* model, KItemListView* view, QObject* parent = nullptr);
+ ~KItemListController() override;
void setModel(KItemModelBase* model);
KItemModelBase* model() const;
void setMouseDoubleClickAction(MouseDoubleClickAction action);
MouseDoubleClickAction mouseDoubleClickAction() const;
+ int indexCloseToMousePressedPosition() const;
+
/**
* Sets the delay in milliseconds when dragging an object above an item
* until the item gets activated automatically. A value of -1 indicates
#include <QStyleOptionGraphicsItem>
KItemListGroupHeader::KItemListGroupHeader(QGraphicsWidget* parent) :
- QGraphicsWidget(parent, 0),
+ QGraphicsWidget(parent, nullptr),
m_dirtyCache(true),
m_role(),
m_data(),
Q_OBJECT
public:
- KItemListGroupHeader(QGraphicsWidget* parent = 0);
- virtual ~KItemListGroupHeader();
+ KItemListGroupHeader(QGraphicsWidget* parent = nullptr);
+ ~KItemListGroupHeader() override;
void setRole(const QByteArray& role);
QByteArray role() const;
void setItemIndex(int index);
int itemIndex() const;
- virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0) Q_DECL_OVERRIDE;
+ void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
protected:
virtual void paintRole(QPainter* painter, const QRectF& roleBounds, const QColor& color) = 0;
*/
virtual void itemIndexChanged(int current, int previous);
- virtual void resizeEvent(QGraphicsSceneResizeEvent* event) Q_DECL_OVERRIDE;
+ void resizeEvent(QGraphicsSceneResizeEvent* event) override;
virtual QPalette::ColorRole normalTextColorRole() const;
virtual QPalette::ColorRole normalBaseColorRole() const;
Q_OBJECT
public:
- virtual ~KItemListHeader();
+ ~KItemListHeader() override;
/**
* If set to true, KItemListView will automatically adjust the
m_anchorItem(-1),
m_selectedItems(),
m_isAnchoredSelectionActive(false),
- m_model(0)
+ m_model(nullptr)
{
}
Toggle
};
- KItemListSelectionManager(QObject* parent = 0);
- virtual ~KItemListSelectionManager();
+ KItemListSelectionManager(QObject* parent = nullptr);
+ ~KItemListSelectionManager() override;
void setCurrentItem(int current);
int currentItem() const;
return new KItemListViewAccessible(view);
}
- return 0;
+ return nullptr;
}
#endif
m_activeTransactions(0),
m_endTransactionAnimationHint(Animation),
m_itemSize(),
- m_controller(0),
- m_model(0),
+ m_controller(nullptr),
+ m_model(nullptr),
m_visibleRoles(),
- m_widgetCreator(0),
- m_groupHeaderCreator(0),
+ m_widgetCreator(nullptr),
+ m_groupHeaderCreator(nullptr),
m_styleOption(),
m_visibleItems(),
m_visibleGroups(),
m_visibleCells(),
- m_sizeHintResolver(0),
- m_layouter(0),
- m_animation(0),
- m_layoutTimer(0),
+ m_sizeHintResolver(nullptr),
+ m_layouter(nullptr),
+ m_animation(nullptr),
+ m_layoutTimer(nullptr),
m_oldScrollOffset(0),
m_oldMaximumScrollOffset(0),
m_oldItemOffset(0),
m_oldMaximumItemOffset(0),
m_skipAutoScrollForRubberBand(false),
- m_rubberBand(0),
+ m_rubberBand(nullptr),
m_mousePos(),
m_autoScrollIncrement(0),
- m_autoScrollTimer(0),
- m_header(0),
- m_headerWidget(0),
+ m_autoScrollTimer(nullptr),
+ m_header(nullptr),
+ m_headerWidget(nullptr),
m_dropIndicator()
{
setAcceptHoverEvents(true);
// widgetCreator(). So it is mandatory to delete the group headers
// first.
delete m_groupHeaderCreator;
- m_groupHeaderCreator = 0;
+ m_groupHeaderCreator = nullptr;
delete m_widgetCreator;
- m_widgetCreator = 0;
+ m_widgetCreator = nullptr;
delete m_sizeHintResolver;
- m_sizeHintResolver = 0;
+ m_sizeHintResolver = nullptr;
}
void KItemListView::setScrollOffset(qreal offset)
m_autoScrollTimer->start(InitialAutoScrollDelay);
} else if (!enabled && m_autoScrollTimer) {
delete m_autoScrollTimer;
- m_autoScrollTimer = 0;
+ m_autoScrollTimer = nullptr;
}
}
bool KItemListView::autoScroll() const
{
- return m_autoScrollTimer != 0;
+ return m_autoScrollTimer != nullptr;
}
void KItemListView::setEnabledSelectionToggles(bool enabled)
QSizeF KItemListView::itemSizeHint() const
{
- return m_sizeHintResolver->maxSizeHint();
+ return m_sizeHintResolver->minSizeHint();
}
const KItemListStyleOption& KItemListView::styleOption() const
KItemListWidget* item = m_visibleItems.value(indexes.first());
QGraphicsView* graphicsView = scene()->views()[0];
if (item && graphicsView) {
- pixmap = item->createDragPixmap(0, graphicsView);
+ pixmap = item->createDragPixmap(nullptr, graphicsView);
}
} else {
// TODO: Not implemented yet. Probably extend the interface
KItemListWidgetCreatorBase* KItemListView::defaultWidgetCreator() const
{
- return 0;
+ return nullptr;
}
KItemListGroupHeaderCreatorBase* KItemListView::defaultGroupHeaderCreator() const
{
- return 0;
+ return nullptr;
}
void KItemListView::initializeItemListWidget(KItemListWidget* item)
{
KItemListGroupHeader* header = m_visibleGroups.value(widget);
if (header) {
- header->setParentItem(0);
+ header->setParentItem(nullptr);
groupHeaderCreator()->recycle(header);
m_visibleGroups.remove(widget);
disconnect(widget, &KItemListWidget::geometryChanged, this, &KItemListView::slotGeometryOfGroupHeaderParentChanged);
const int parents = m_model->expandedParentsCount(lastIndex + 1);
for (int i = lastIndex; i >= firstIndex; --i) {
if (m_model->expandedParentsCount(i) != parents) {
- widget = 0;
+ widget = nullptr;
break;
}
}
QGraphicsWidget* KItemListCreatorBase::popRecycleableWidget()
{
if (m_recycleableWidgets.isEmpty()) {
- return 0;
+ return nullptr;
}
QGraphicsWidget* widget = m_recycleableWidgets.takeLast();
void KItemListWidgetCreatorBase::recycle(KItemListWidget* widget)
{
- widget->setParentItem(0);
+ widget->setParentItem(nullptr);
widget->setOpacity(1.0);
pushRecycleableWidget(widget);
}
Q_PROPERTY(qreal itemOffset READ itemOffset WRITE setItemOffset)
public:
- KItemListView(QGraphicsWidget* parent = 0);
- virtual ~KItemListView();
+ KItemListView(QGraphicsWidget* parent = nullptr);
+ ~KItemListView() override;
/**
* Offset of the scrollbar that represents the scroll-orientation
const KItemListStyleOption& styleOption() const;
- virtual void setGeometry(const QRectF& rect) Q_DECL_OVERRIDE;
+ void setGeometry(const QRectF& rect) override;
/**
* @return The page step which should be used by the vertical scroll bar.
*/
void editRole(int index, const QByteArray& role);
- virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0) Q_DECL_OVERRIDE;
+ void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
signals:
void scrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous);
void roleEditingFinished(int index, const QByteArray& role, const QVariant& value);
protected:
- virtual QVariant itemChange(GraphicsItemChange change, const QVariant &value) Q_DECL_OVERRIDE;
+ QVariant itemChange(GraphicsItemChange change, const QVariant &value) override;
void setItemSize(const QSizeF& size);
void setStyleOption(const KItemListStyleOption& option);
virtual void onTransactionBegin();
virtual void onTransactionEnd();
- virtual bool event(QEvent* event) Q_DECL_OVERRIDE;
- virtual void mousePressEvent(QGraphicsSceneMouseEvent* event) Q_DECL_OVERRIDE;
- virtual void mouseMoveEvent(QGraphicsSceneMouseEvent* event) Q_DECL_OVERRIDE;
- virtual void dragEnterEvent(QGraphicsSceneDragDropEvent* event) Q_DECL_OVERRIDE;
- virtual void dragMoveEvent(QGraphicsSceneDragDropEvent* event) Q_DECL_OVERRIDE;
- virtual void dragLeaveEvent(QGraphicsSceneDragDropEvent* event) Q_DECL_OVERRIDE;
- virtual void dropEvent(QGraphicsSceneDragDropEvent* event) Q_DECL_OVERRIDE;
+ bool event(QEvent* event) override;
+ void mousePressEvent(QGraphicsSceneMouseEvent* event) override;
+ void mouseMoveEvent(QGraphicsSceneMouseEvent* event) override;
+ void dragEnterEvent(QGraphicsSceneDragDropEvent* event) override;
+ void dragMoveEvent(QGraphicsSceneDragDropEvent* event) override;
+ void dragLeaveEvent(QGraphicsSceneDragDropEvent* event) override;
+ void dropEvent(QGraphicsSceneDragDropEvent* event) override;
QList<KItemListWidget*> visibleItemListWidgets() const;
class DOLPHIN_EXPORT KItemListWidgetCreatorBase : public KItemListCreatorBase
{
public:
- virtual ~KItemListWidgetCreatorBase();
+ ~KItemListWidgetCreatorBase() override;
virtual KItemListWidget* create(KItemListView* view) = 0;
{
public:
KItemListWidgetCreator();
- virtual ~KItemListWidgetCreator();
+ ~KItemListWidgetCreator() override;
- virtual KItemListWidget* create(KItemListView* view) Q_DECL_OVERRIDE;
+ KItemListWidget* create(KItemListView* view) override;
- virtual void calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint, const KItemListView* view) const Q_DECL_OVERRIDE;
+ void calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint, const KItemListView* view) const override;
- virtual qreal preferredRoleColumnWidth(const QByteArray& role,
+ qreal preferredRoleColumnWidth(const QByteArray& role,
int index,
- const KItemListView* view) const Q_DECL_OVERRIDE;
+ const KItemListView* view) const override;
private:
KItemListWidgetInformant* m_informant;
};
class DOLPHIN_EXPORT KItemListGroupHeaderCreatorBase : public KItemListCreatorBase
{
public:
- virtual ~KItemListGroupHeaderCreatorBase();
+ ~KItemListGroupHeaderCreatorBase() override;
virtual KItemListGroupHeader* create(KItemListView* view) = 0;
virtual void recycle(KItemListGroupHeader* header);
};
class KItemListGroupHeaderCreator : public KItemListGroupHeaderCreatorBase
{
public:
- virtual ~KItemListGroupHeaderCreator();
- virtual KItemListGroupHeader* create(KItemListView* view) Q_DECL_OVERRIDE;
+ ~KItemListGroupHeaderCreator() override;
+ KItemListGroupHeader* create(KItemListView* view) override;
};
template <class T>
if (type == QAccessible::TableInterface) {
return static_cast<QAccessibleTableInterface*>(this);
}
- return Q_NULLPTR;
+ return nullptr;
}
void KItemListViewAccessible::modelReset()
QAccessibleInterface* KItemListViewAccessible::cell(int index) const
{
if (index < 0 || index >= view()->model()->count()) {
- return 0;
+ return nullptr;
}
if (m_cells.size() <= index) {
QAccessibleInterface* KItemListViewAccessible::caption() const
{
- return 0;
+ return nullptr;
}
QString KItemListViewAccessible::columnDescription(int) const
QAccessibleInterface* KItemListViewAccessible::summary() const
{
- return 0;
+ return nullptr;
}
bool KItemListViewAccessible::isColumnSelected(int) const
QAccessibleInterface* KItemListViewAccessible::parent() const
{
// FIXME: return KItemListContainerAccessible here
- return Q_NULLPTR;
+ return nullptr;
}
int KItemListViewAccessible::childCount() const
if (index >= 0 && index < childCount()) {
return cell(index);
}
- return Q_NULLPTR;
+ return nullptr;
}
// Table Cell
if (type == QAccessible::TableCellInterface) {
return static_cast<QAccessibleTableCellInterface*>(this);
}
- return Q_NULLPTR;
+ return nullptr;
}
int KItemListAccessibleCell::columnExtent() const
QAccessibleInterface* KItemListAccessibleCell::child(int) const
{
- return Q_NULLPTR;
+ return nullptr;
}
bool KItemListAccessibleCell::isValid() const
QAccessibleInterface* KItemListAccessibleCell::childAt(int, int) const
{
- return Q_NULLPTR;
+ return nullptr;
}
int KItemListAccessibleCell::childCount() const
QObject* KItemListAccessibleCell::object() const
{
- return 0;
+ return nullptr;
}
// Container Interface
if (index == 0) {
return QAccessible::queryAccessibleInterface(container()->controller()->view());
}
- return Q_NULLPTR;
+ return nullptr;
}
const KItemListContainer* KItemListContainerAccessible::container() const
{
public:
explicit KItemListViewAccessible(KItemListView* view);
- ~KItemListViewAccessible();
+ ~KItemListViewAccessible() override;
- void* interface_cast(QAccessible::InterfaceType type) Q_DECL_OVERRIDE;
+ void* interface_cast(QAccessible::InterfaceType type) override;
- QAccessible::Role role() const Q_DECL_OVERRIDE;
- QAccessible::State state() const Q_DECL_OVERRIDE;
- QString text(QAccessible::Text t) const Q_DECL_OVERRIDE;
- QRect rect() const Q_DECL_OVERRIDE;
+ QAccessible::Role role() const override;
+ QAccessible::State state() const override;
+ QString text(QAccessible::Text t) const override;
+ QRect rect() const override;
- QAccessibleInterface* child(int index) const Q_DECL_OVERRIDE;
- int childCount() const Q_DECL_OVERRIDE;
- int indexOfChild(const QAccessibleInterface*) const Q_DECL_OVERRIDE;
- QAccessibleInterface* childAt(int x, int y) const Q_DECL_OVERRIDE;
- QAccessibleInterface* parent() const Q_DECL_OVERRIDE;
+ QAccessibleInterface* child(int index) const override;
+ int childCount() const override;
+ int indexOfChild(const QAccessibleInterface*) const override;
+ QAccessibleInterface* childAt(int x, int y) const override;
+ QAccessibleInterface* parent() const override;
// Table interface
- virtual QAccessibleInterface* cellAt(int row, int column) const Q_DECL_OVERRIDE;
- virtual QAccessibleInterface* caption() const Q_DECL_OVERRIDE;
- virtual QAccessibleInterface* summary() const Q_DECL_OVERRIDE;
- virtual QString columnDescription(int column) const Q_DECL_OVERRIDE;
- virtual QString rowDescription(int row) const Q_DECL_OVERRIDE;
- virtual int columnCount() const Q_DECL_OVERRIDE;
- virtual int rowCount() const Q_DECL_OVERRIDE;
+ QAccessibleInterface* cellAt(int row, int column) const override;
+ QAccessibleInterface* caption() const override;
+ QAccessibleInterface* summary() const override;
+ QString columnDescription(int column) const override;
+ QString rowDescription(int row) const override;
+ int columnCount() const override;
+ int rowCount() const override;
// Selection
- virtual int selectedCellCount() const Q_DECL_OVERRIDE;
- virtual int selectedColumnCount() const Q_DECL_OVERRIDE;
- virtual int selectedRowCount() const Q_DECL_OVERRIDE;
- virtual QList<QAccessibleInterface*> selectedCells() const Q_DECL_OVERRIDE;
- virtual QList<int> selectedColumns() const Q_DECL_OVERRIDE;
- virtual QList<int> selectedRows() const Q_DECL_OVERRIDE;
- virtual bool isColumnSelected(int column) const Q_DECL_OVERRIDE;
- virtual bool isRowSelected(int row) const Q_DECL_OVERRIDE;
- virtual bool selectRow(int row) Q_DECL_OVERRIDE;
- virtual bool selectColumn(int column) Q_DECL_OVERRIDE;
- virtual bool unselectRow(int row) Q_DECL_OVERRIDE;
- virtual bool unselectColumn(int column) Q_DECL_OVERRIDE;
- virtual void modelChange(QAccessibleTableModelChangeEvent*) Q_DECL_OVERRIDE;
+ int selectedCellCount() const override;
+ int selectedColumnCount() const override;
+ int selectedRowCount() const override;
+ QList<QAccessibleInterface*> selectedCells() const override;
+ QList<int> selectedColumns() const override;
+ QList<int> selectedRows() const override;
+ bool isColumnSelected(int column) const override;
+ bool isRowSelected(int row) const override;
+ bool selectRow(int row) override;
+ bool selectColumn(int column) override;
+ bool unselectRow(int row) override;
+ bool unselectColumn(int column) override;
+ void modelChange(QAccessibleTableModelChangeEvent*) override;
KItemListView* view() const;
public:
KItemListAccessibleCell(KItemListView* view, int m_index);
- void* interface_cast(QAccessible::InterfaceType type) Q_DECL_OVERRIDE;
- QObject* object() const Q_DECL_OVERRIDE;
- bool isValid() const Q_DECL_OVERRIDE;
- QAccessible::Role role() const Q_DECL_OVERRIDE;
- QAccessible::State state() const Q_DECL_OVERRIDE;
- QRect rect() const Q_DECL_OVERRIDE;
- QString text(QAccessible::Text t) const Q_DECL_OVERRIDE;
- void setText(QAccessible::Text t, const QString& text) Q_DECL_OVERRIDE;
-
- QAccessibleInterface* child(int index) const Q_DECL_OVERRIDE;
- int childCount() const Q_DECL_OVERRIDE;
- QAccessibleInterface* childAt(int x, int y) const Q_DECL_OVERRIDE;
- int indexOfChild(const QAccessibleInterface*) const Q_DECL_OVERRIDE;
-
- QAccessibleInterface* parent() const Q_DECL_OVERRIDE;
+ void* interface_cast(QAccessible::InterfaceType type) override;
+ QObject* object() const override;
+ bool isValid() const override;
+ QAccessible::Role role() const override;
+ QAccessible::State state() const override;
+ QRect rect() const override;
+ QString text(QAccessible::Text t) const override;
+ void setText(QAccessible::Text t, const QString& text) override;
+
+ QAccessibleInterface* child(int index) const override;
+ int childCount() const override;
+ QAccessibleInterface* childAt(int x, int y) const override;
+ int indexOfChild(const QAccessibleInterface*) const override;
+
+ QAccessibleInterface* parent() const override;
bool isExpandable() const;
// Cell Interface
- virtual int columnExtent() const Q_DECL_OVERRIDE;
- virtual QList<QAccessibleInterface*> columnHeaderCells() const Q_DECL_OVERRIDE;
- virtual int columnIndex() const Q_DECL_OVERRIDE;
- virtual int rowExtent() const Q_DECL_OVERRIDE;
- virtual QList<QAccessibleInterface*> rowHeaderCells() const Q_DECL_OVERRIDE;
- virtual int rowIndex() const Q_DECL_OVERRIDE;
- virtual bool isSelected() const Q_DECL_OVERRIDE;
- virtual QAccessibleInterface* table() const Q_DECL_OVERRIDE;
+ int columnExtent() const override;
+ QList<QAccessibleInterface*> columnHeaderCells() const override;
+ int columnIndex() const override;
+ int rowExtent() const override;
+ QList<QAccessibleInterface*> rowHeaderCells() const override;
+ int rowIndex() const override;
+ bool isSelected() const override;
+ QAccessibleInterface* table() const override;
inline int index() const;
{
public:
explicit KItemListContainerAccessible(KItemListContainer* container);
- virtual ~KItemListContainerAccessible();
+ ~KItemListContainerAccessible() override;
- QAccessibleInterface* child(int index) const Q_DECL_OVERRIDE;
- int childCount() const Q_DECL_OVERRIDE;
- int indexOfChild(const QAccessibleInterface* child) const Q_DECL_OVERRIDE;
+ QAccessibleInterface* child(int index) const override;
+ int childCount() const override;
+ int indexOfChild(const QAccessibleInterface* child) const override;
private:
const KItemListContainer* container() const;
}
KItemListWidget::KItemListWidget(KItemListWidgetInformant* informant, QGraphicsItem* parent) :
- QGraphicsWidget(parent, 0),
+ QGraphicsWidget(parent, nullptr),
m_informant(informant),
m_index(-1),
m_selected(false),
m_styleOption(),
m_siblingsInfo(),
m_hoverOpacity(0),
- m_hoverCache(0),
- m_hoverAnimation(0),
- m_selectionToggle(0),
+ m_hoverCache(nullptr),
+ m_hoverAnimation(nullptr),
+ m_selectionToggle(nullptr),
m_editedRole()
{
}
{
if (m_index != index) {
delete m_selectionToggle;
- m_selectionToggle = 0;
+ m_selectionToggle = nullptr;
if (m_hoverAnimation) {
m_hoverAnimation->stop();
{
if (!m_hovered && m_selectionToggle) {
m_selectionToggle->deleteLater();
- m_selectionToggle = 0;
+ m_selectionToggle = nullptr;
}
}
if (m_hoverOpacity <= 0.0) {
delete m_hoverCache;
- m_hoverCache = 0;
+ m_hoverCache = nullptr;
}
update();
void KItemListWidget::clearHoverCache()
{
delete m_hoverCache;
- m_hoverCache = 0;
+ m_hoverCache = nullptr;
}
void KItemListWidget::drawItemStyleOption(QPainter* painter, QWidget* widget, QStyle::State styleState)
public:
KItemListWidget(KItemListWidgetInformant* informant, QGraphicsItem* parent);
- virtual ~KItemListWidget();
+ ~KItemListWidget() override;
void setIndex(int index);
int index() const;
* to show the data of the custom model provided by KItemListWidget::data().
* @reimp
*/
- virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0) Q_DECL_OVERRIDE;
+ void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
void setVisibleRoles(const QList<QByteArray>& roles);
QList<QByteArray> visibleRoles() const;
* or KItemListWidget::expansionToggleRect().
* @reimp
*/
- virtual bool contains(const QPointF& point) const override;
+ bool contains(const QPointF& point) const override;
/**
* @return Rectangle for the area that shows the icon.
* @return Pixmap that is used when dragging an item. Per default the current state of the
* widget is returned as pixmap.
*/
- virtual QPixmap createDragPixmap(const QStyleOptionGraphicsItem* option, QWidget* widget = 0);
+ virtual QPixmap createDragPixmap(const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr);
signals:
void roleEditingCanceled(int index, const QByteArray& role, const QVariant& value);
virtual void alternateBackgroundChanged(bool enabled);
virtual void siblingsInformationChanged(const QBitArray& current, const QBitArray& previous);
virtual void editedRoleChanged(const QByteArray& current, const QByteArray& previous);
- virtual void resizeEvent(QGraphicsSceneResizeEvent* event) Q_DECL_OVERRIDE;
+ void resizeEvent(QGraphicsSceneResizeEvent* event) override;
/**
* @return The current opacity of the hover-animation. When implementing a custom painting-code for a hover-state
QMimeData* KItemModelBase::createMimeData(const KItemSet& indexes) const
{
Q_UNUSED(indexes);
- return 0;
+ return nullptr;
}
int KItemModelBase::indexForKeyboardSearch(const QString& text, int startFromIndex) const
Q_OBJECT
public:
- KItemModelBase(QObject* parent = 0);
- explicit KItemModelBase(const QByteArray& sortRole, QObject* parent = 0);
- virtual ~KItemModelBase();
+ KItemModelBase(QObject* parent = nullptr);
+ explicit KItemModelBase(const QByteArray& sortRole, QObject* parent = nullptr);
+ ~KItemModelBase() override;
/** @return The number of items. */
virtual int count() const = 0;
KStandardItem::KStandardItem(KStandardItem* parent) :
m_parent(parent),
m_children(),
- m_model(0),
+ m_model(nullptr),
m_data()
{
}
KStandardItem::KStandardItem(const QString& text, KStandardItem* parent) :
m_parent(parent),
m_children(),
- m_model(0),
+ m_model(nullptr),
m_data()
{
setText(text);
KStandardItem::KStandardItem(const QString& icon, const QString& text, KStandardItem* parent) :
m_parent(parent),
m_children(),
- m_model(0),
+ m_model(nullptr),
m_data()
{
setIcon(icon);
{
public:
- explicit KStandardItem(KStandardItem* parent = 0);
- explicit KStandardItem(const QString& text, KStandardItem* parent = 0);
- KStandardItem(const QString& icon, const QString& text, KStandardItem* parent = 0);
+ explicit KStandardItem(KStandardItem* parent = nullptr);
+ explicit KStandardItem(const QString& text, KStandardItem* parent = nullptr);
+ KStandardItem(const QString& icon, const QString& text, KStandardItem* parent = nullptr);
KStandardItem(const KStandardItem& item);
virtual ~KStandardItem();
Q_OBJECT
public:
- KStandardItemListGroupHeader(QGraphicsWidget* parent = 0);
- virtual ~KStandardItemListGroupHeader();
+ KStandardItemListGroupHeader(QGraphicsWidget* parent = nullptr);
+ ~KStandardItemListGroupHeader() override;
- virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0) Q_DECL_OVERRIDE;
+ void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
protected:
- virtual void paintRole(QPainter* painter, const QRectF& roleBounds, const QColor& color) Q_DECL_OVERRIDE;
- virtual void paintSeparator(QPainter* painter, const QColor& color) Q_DECL_OVERRIDE;
- virtual void roleChanged(const QByteArray ¤t, const QByteArray &previous) Q_DECL_OVERRIDE;
- virtual void dataChanged(const QVariant& current, const QVariant& previous) Q_DECL_OVERRIDE;
- virtual void resizeEvent(QGraphicsSceneResizeEvent* event) Q_DECL_OVERRIDE;
+ void paintRole(QPainter* painter, const QRectF& roleBounds, const QColor& color) override;
+ void paintSeparator(QPainter* painter, const QColor& color) override;
+ void roleChanged(const QByteArray ¤t, const QByteArray &previous) override;
+ void dataChanged(const QVariant& current, const QVariant& previous) override;
+ void resizeEvent(QGraphicsSceneResizeEvent* event) override;
private:
void updateCache();
DetailsLayout
};
- KStandardItemListView(QGraphicsWidget* parent = 0);
- virtual ~KStandardItemListView();
+ KStandardItemListView(QGraphicsWidget* parent = nullptr);
+ ~KStandardItemListView() override;
void setItemLayout(ItemLayout layout);
ItemLayout itemLayout() const;
protected:
- virtual KItemListWidgetCreatorBase* defaultWidgetCreator() const Q_DECL_OVERRIDE;
- virtual KItemListGroupHeaderCreatorBase* defaultGroupHeaderCreator() const Q_DECL_OVERRIDE;
- virtual void initializeItemListWidget(KItemListWidget* item) Q_DECL_OVERRIDE;
- virtual bool itemSizeHintUpdateRequired(const QSet<QByteArray>& changedRoles) const Q_DECL_OVERRIDE;
+ KItemListWidgetCreatorBase* defaultWidgetCreator() const override;
+ KItemListGroupHeaderCreatorBase* defaultGroupHeaderCreator() const override;
+ void initializeItemListWidget(KItemListWidget* item) override;
+ bool itemSizeHintUpdateRequired(const QSet<QByteArray>& changedRoles) const override;
virtual bool itemLayoutSupportsItemExpanding(ItemLayout layout) const;
virtual void onItemLayoutChanged(ItemLayout current, ItemLayout previous);
- virtual void onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous) Q_DECL_OVERRIDE;
- virtual void onSupportsItemExpandingChanged(bool supportsExpanding) Q_DECL_OVERRIDE;
- virtual void polishEvent() Q_DECL_OVERRIDE;
+ void onScrollOrientationChanged(Qt::Orientation current, Qt::Orientation previous) override;
+ void onSupportsItemExpandingChanged(bool supportsExpanding) override;
+ void polishEvent() override;
private:
void applyDefaultStyleOption(int iconSize, int padding, int horizontalMargin, int verticalMargin);
m_additionalInfoTextColor(),
m_overlay(),
m_rating(),
- m_roleEditor(0),
- m_oldRoleEditor(0)
+ m_roleEditor(nullptr),
+ m_oldRoleEditor(nullptr)
{
}
}
m_oldRoleEditor = m_roleEditor;
m_roleEditor->hide();
- m_roleEditor = 0;
+ m_roleEditor = nullptr;
}
return;
}
if (!m_overlay.isNull()) {
QPainter painter(&m_pixmap);
- painter.drawPixmap(0, m_pixmap.height() - m_overlay.height(), m_overlay);
+ painter.drawPixmap(0, (m_pixmap.height() - m_overlay.height()) / m_pixmap.devicePixelRatio(), m_overlay);
}
int scaledIconSize = 0;
}
m_oldRoleEditor = m_roleEditor;
m_roleEditor->hide();
- m_roleEditor = 0;
+ m_roleEditor = nullptr;
}
QPixmap KStandardItemListWidget::pixmapForIcon(const QString& name, const QStringList& overlays, int size, QIcon::Mode mode)
{
public:
KStandardItemListWidgetInformant();
- virtual ~KStandardItemListWidgetInformant();
+ ~KStandardItemListWidgetInformant() override;
- virtual void calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint, const KItemListView* view) const Q_DECL_OVERRIDE;
+ void calculateItemSizeHints(QVector<qreal>& logicalHeightHints, qreal& logicalWidthHint, const KItemListView* view) const override;
- virtual qreal preferredRoleColumnWidth(const QByteArray& role,
+ qreal preferredRoleColumnWidth(const QByteArray& role,
int index,
- const KItemListView* view) const Q_DECL_OVERRIDE;
+ const KItemListView* view) const override;
protected:
/**
* @return The value of the "text" role. The default implementation returns
};
KStandardItemListWidget(KItemListWidgetInformant* informant, QGraphicsItem* parent);
- virtual ~KStandardItemListWidget();
+ ~KStandardItemListWidget() override;
void setLayout(Layout layout);
Layout layout() const;
void setSupportsItemExpanding(bool supportsItemExpanding);
bool supportsItemExpanding() const;
- virtual void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0) override;
+ void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
- virtual QRectF iconRect() const Q_DECL_OVERRIDE;
- virtual QRectF textRect() const Q_DECL_OVERRIDE;
- virtual QRectF textFocusRect() const Q_DECL_OVERRIDE;
- virtual QRectF selectionRect() const Q_DECL_OVERRIDE;
- virtual QRectF expansionToggleRect() const Q_DECL_OVERRIDE;
- virtual QRectF selectionToggleRect() const Q_DECL_OVERRIDE;
- virtual QPixmap createDragPixmap(const QStyleOptionGraphicsItem* option, QWidget* widget = 0) Q_DECL_OVERRIDE;
+ QRectF iconRect() const override;
+ QRectF textRect() const override;
+ QRectF textFocusRect() const override;
+ QRectF selectionRect() const override;
+ QRectF expansionToggleRect() const override;
+ QRectF selectionToggleRect() const override;
+ QPixmap createDragPixmap(const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
static KItemListWidgetInformant* createInformant();
*/
virtual int selectionLength(const QString& text) const;
- virtual void dataChanged(const QHash<QByteArray, QVariant>& current, const QSet<QByteArray>& roles = QSet<QByteArray>()) Q_DECL_OVERRIDE;
- virtual void visibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous) Q_DECL_OVERRIDE;
- virtual void columnWidthChanged(const QByteArray& role, qreal current, qreal previous) Q_DECL_OVERRIDE;
- virtual void styleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous) Q_DECL_OVERRIDE;
- virtual void hoveredChanged(bool hovered) Q_DECL_OVERRIDE;
- virtual void selectedChanged(bool selected) Q_DECL_OVERRIDE;
- virtual void siblingsInformationChanged(const QBitArray& current, const QBitArray& previous) Q_DECL_OVERRIDE;
- virtual void editedRoleChanged(const QByteArray& current, const QByteArray& previous) Q_DECL_OVERRIDE;
- virtual void resizeEvent(QGraphicsSceneResizeEvent* event) Q_DECL_OVERRIDE;
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
- virtual void hideEvent(QHideEvent* event) Q_DECL_OVERRIDE;
- bool event(QEvent *event) Q_DECL_OVERRIDE;
+ void dataChanged(const QHash<QByteArray, QVariant>& current, const QSet<QByteArray>& roles = QSet<QByteArray>()) override;
+ void visibleRolesChanged(const QList<QByteArray>& current, const QList<QByteArray>& previous) override;
+ void columnWidthChanged(const QByteArray& role, qreal current, qreal previous) override;
+ void styleOptionChanged(const KItemListStyleOption& current, const KItemListStyleOption& previous) override;
+ void hoveredChanged(bool hovered) override;
+ void selectedChanged(bool selected) override;
+ void siblingsInformationChanged(const QBitArray& current, const QBitArray& previous) override;
+ void editedRoleChanged(const QByteArray& current, const QByteArray& previous) override;
+ void resizeEvent(QGraphicsSceneResizeEvent* event) override;
+ void showEvent(QShowEvent* event) override;
+ void hideEvent(QHideEvent* event) override;
+ bool event(QEvent *event) override;
public slots:
void finishRoleEditing();
m_indexesForItems.remove(oldItem);
delete oldItem;
- oldItem = 0;
+ oldItem = nullptr;
m_items[index] = item;
m_indexesForItems.insert(item, index);
onItemRemoved(index, item);
delete item;
- item = 0;
+ item = nullptr;
emit itemsRemoved(KItemRangeList() << KItemRange(index, 1));
KStandardItem* KStandardItemModel::item(int index) const
{
if (index < 0 || index >= m_items.count()) {
- return 0;
+ return nullptr;
}
return m_items[index];
}
QMimeData* KStandardItemModel::createMimeData(const KItemSet& indexes) const
{
Q_UNUSED(indexes);
- return 0;
+ return nullptr;
}
int KStandardItemModel::indexForKeyboardSearch(const QString& text, int startFromIndex) const
Q_OBJECT
public:
- explicit KStandardItemModel(QObject* parent = 0);
- virtual ~KStandardItemModel();
+ explicit KStandardItemModel(QObject* parent = nullptr);
+ ~KStandardItemModel() override;
/**
* Inserts the item \a item at the index \a index. If the index
*/
void appendItem(KStandardItem* item);
- virtual int count() const Q_DECL_OVERRIDE;
- virtual QHash<QByteArray, QVariant> data(int index) const Q_DECL_OVERRIDE;
- virtual bool setData(int index, const QHash<QByteArray, QVariant>& values) Q_DECL_OVERRIDE;
- virtual QMimeData* createMimeData(const KItemSet& indexes) const Q_DECL_OVERRIDE;
- virtual int indexForKeyboardSearch(const QString& text, int startFromIndex = 0) const Q_DECL_OVERRIDE;
- virtual bool supportsDropping(int index) const Q_DECL_OVERRIDE;
- virtual QString roleDescription(const QByteArray& role) const Q_DECL_OVERRIDE;
- virtual QList<QPair<int, QVariant> > groups() const Q_DECL_OVERRIDE;
+ int count() const override;
+ QHash<QByteArray, QVariant> data(int index) const override;
+ bool setData(int index, const QHash<QByteArray, QVariant>& values) override;
+ QMimeData* createMimeData(const KItemSet& indexes) const override;
+ int indexForKeyboardSearch(const QString& text, int startFromIndex = 0) const override;
+ bool supportsDropping(int index) const override;
+ QString roleDescription(const QByteArray& role) const override;
+ QList<QPair<int, QVariant> > groups() const override;
virtual void clear();
protected:
{ "lineCount", "lineCount" },
{ "width", "imageSize" },
{ "height", "imageSize" },
+ { "imageDateTime", "imageDateTime"},
{ "nexif.orientation", "orientation", },
{ "artist", "artist" },
{ "genre", "genre" },
QObject(parent),
m_model(model),
m_queue(),
- m_worker(0),
+ m_worker(nullptr),
m_workerIsBusy(false),
- m_dirWatcher(0),
+ m_dirWatcher(nullptr),
m_watchedDirs()
{
connect(m_model, &KFileItemModel::itemsRemoved,
m_workerThread->quit();
m_workerThread->wait();
delete m_workerThread;
- m_workerThread = 0;
+ m_workerThread = nullptr;
// The worker thread has finished running now, so it's safe to delete
// m_worker. deleteLater() would not work at all because the event loop
}
}
-QThread* KDirectoryContentsCounter::m_workerThread = 0;
+QThread* KDirectoryContentsCounter::m_workerThread = nullptr;
int KDirectoryContentsCounter::m_workersCount = 0;
Q_OBJECT
public:
- explicit KDirectoryContentsCounter(KFileItemModel* model, QObject* parent = 0);
- ~KDirectoryContentsCounter();
+ explicit KDirectoryContentsCounter(KFileItemModel* model, QObject* parent = nullptr);
+ ~KDirectoryContentsCounter() override;
/**
* Requests the number of items inside the directory \a path. The actual
DIR* dir = ::opendir(QFile::encodeName(path));
if (dir) { // krazy:exclude=syscalls
count = 0;
- struct dirent *dirEntry = 0;
+ struct dirent *dirEntry = nullptr;
while ((dirEntry = ::readdir(dir))) {
if (dirEntry->d_name[0] == '.') {
if (dirEntry->d_name[1] == '\0' || !countHiddenFiles) {
};
Q_DECLARE_FLAGS(Options, Option)
- explicit KDirectoryContentsCounterWorker(QObject* parent = 0);
+ explicit KDirectoryContentsCounterWorker(QObject* parent = nullptr);
/**
* Counts the items inside the directory \a path using the options
}
KFileItemClipboard::KFileItemClipboard() :
- QObject(0),
+ QObject(nullptr),
m_cutItems()
{
updateCutItems();
void cutItemsChanged();
protected:
- virtual ~KFileItemClipboard();
+ ~KFileItemClipboard() override;
private slots:
void updateCutItems();
KFileItemModelDirLister::KFileItemModelDirLister(QObject* parent) :
KDirLister(parent)
{
- setAutoErrorHandlingEnabled(false, 0);
+ setAutoErrorHandlingEnabled(false, nullptr);
}
KFileItemModelDirLister::~KFileItemModelDirLister()
Q_OBJECT
public:
- KFileItemModelDirLister(QObject* parent = 0);
- virtual ~KFileItemModelDirLister();
+ KFileItemModelDirLister(QObject* parent = nullptr);
+ ~KFileItemModelDirLister() override;
signals:
/** Is emitted whenever an error has occurred. */
void urlIsFileError(const QUrl& url);
protected:
- void handleError(KIO::Job* job) Q_DECL_OVERRIDE;
+ void handleError(KIO::Job* job) override;
};
#endif
KFileItemModelFilter::KFileItemModelFilter() :
m_useRegExp(false),
- m_regExp(0),
+ m_regExp(nullptr),
m_lowerCasePattern(),
m_pattern()
{
KFileItemModelFilter::~KFileItemModelFilter()
{
delete m_regExp;
- m_regExp = 0;
+ m_regExp = nullptr;
}
void KFileItemModelFilter::setPattern(const QString& filter)
KItemListHeaderWidget::KItemListHeaderWidget(QGraphicsWidget* parent) :
QGraphicsWidget(parent),
m_automaticColumnResizing(true),
- m_model(0),
+ m_model(nullptr),
m_offset(0),
m_columns(),
m_columnWidths(),
Q_OBJECT
public:
- KItemListHeaderWidget(QGraphicsWidget* parent = 0);
- virtual ~KItemListHeaderWidget();
+ KItemListHeaderWidget(QGraphicsWidget* parent = nullptr);
+ ~KItemListHeaderWidget() override;
void setModel(KItemModelBase* model);
KItemModelBase* model() const;
qreal minimumColumnWidth() const;
- void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0) Q_DECL_OVERRIDE;
+ void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
signals:
/**
void sortRoleChanged(const QByteArray& current, const QByteArray& previous);
protected:
- void mousePressEvent(QGraphicsSceneMouseEvent* event) Q_DECL_OVERRIDE;
- void mouseReleaseEvent(QGraphicsSceneMouseEvent* event) Q_DECL_OVERRIDE;
- void mouseMoveEvent(QGraphicsSceneMouseEvent* event) Q_DECL_OVERRIDE;
- void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event) Q_DECL_OVERRIDE;
- void hoverEnterEvent(QGraphicsSceneHoverEvent* event) Q_DECL_OVERRIDE;
- void hoverLeaveEvent(QGraphicsSceneHoverEvent* event) Q_DECL_OVERRIDE;
- void hoverMoveEvent(QGraphicsSceneHoverEvent* event) Q_DECL_OVERRIDE;
+ void mousePressEvent(QGraphicsSceneMouseEvent* event) override;
+ void mouseReleaseEvent(QGraphicsSceneMouseEvent* event) override;
+ void mouseMoveEvent(QGraphicsSceneMouseEvent* event) override;
+ void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event) override;
+ void hoverEnterEvent(QGraphicsSceneHoverEvent* event) override;
+ void hoverLeaveEvent(QGraphicsSceneHoverEvent* event) override;
+ void hoverMoveEvent(QGraphicsSceneHoverEvent* event) override;
private slots:
void slotSortRoleChanged(const QByteArray& current, const QByteArray& previous);
const QByteArray& role,
const QRectF& rect,
int orderIndex,
- QWidget* widget = 0) const;
+ QWidget* widget = nullptr) const;
void updatePressedRoleIndex(const QPointF& pos);
void updateHoveredRoleIndex(const QPointF& pos);
public:
- KItemListKeyboardSearchManager(QObject* parent = 0);
- virtual ~KItemListKeyboardSearchManager();
+ KItemListKeyboardSearchManager(QObject* parent = nullptr);
+ ~KItemListKeyboardSearchManager() override;
/**
* Add \a keys to the text buffer used for searching.
public:
explicit KItemListRoleEditor(QWidget* parent);
- virtual ~KItemListRoleEditor();
+ ~KItemListRoleEditor() override;
void setRole(const QByteArray& role);
QByteArray role() const;
- bool eventFilter(QObject* watched, QEvent* event) Q_DECL_OVERRIDE;
+ bool eventFilter(QObject* watched, QEvent* event) override;
signals:
void roleEditingFinished(const QByteArray& role, const QVariant& value);
void roleEditingCanceled(const QByteArray& role, const QVariant& value);
protected:
- bool event(QEvent* event) Q_DECL_OVERRIDE;
- void keyPressEvent(QKeyEvent* event) Q_DECL_OVERRIDE;
+ bool event(QEvent* event) override;
+ void keyPressEvent(QKeyEvent* event) override;
private slots:
/**
Q_OBJECT
public:
- explicit KItemListRubberBand(QObject* parent = 0);
- virtual ~KItemListRubberBand();
+ explicit KItemListRubberBand(QObject* parent = nullptr);
+ ~KItemListRubberBand() override;
void setStartPosition(const QPointF& pos);
QPointF startPosition() const;
KItemListSelectionToggle::KItemListSelectionToggle(QGraphicsItem* parent) :
- QGraphicsWidget(parent, 0),
+ QGraphicsWidget(parent, nullptr),
m_checked(false),
m_hovered(false)
{
public:
KItemListSelectionToggle(QGraphicsItem* parent);
- virtual ~KItemListSelectionToggle();
+ ~KItemListSelectionToggle() override;
void setChecked(bool checked);
bool isChecked() const;
void setHovered(bool hovered);
- void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = 0) Q_DECL_OVERRIDE;
+ void paint(QPainter* painter, const QStyleOptionGraphicsItem* option, QWidget* widget = nullptr) override;
protected:
- void resizeEvent(QGraphicsSceneResizeEvent* event) Q_DECL_OVERRIDE;
+ void resizeEvent(QGraphicsSceneResizeEvent* event) override;
private:
void updatePixmap();
m_logicalHeightHintCache(),
m_logicalWidthHint(0.0),
m_logicalHeightHint(0.0),
+ m_minHeightHint(0.0),
m_needsResolving(false)
{
}
return QSizeF(m_logicalWidthHint, m_logicalHeightHint);
}
+QSizeF KItemListSizeHintResolver::minSizeHint()
+{
+ updateCache();
+ return QSizeF(m_logicalWidthHint, m_minHeightHint);
+}
+
QSizeF KItemListSizeHintResolver::sizeHint(int index)
{
updateCache();
m_logicalHeightHint = 0.0;
} else {
m_logicalHeightHint = *std::max_element(m_logicalHeightHintCache.begin(), m_logicalHeightHintCache.end());
+ m_minHeightHint = *std::min_element(m_logicalHeightHintCache.begin(), m_logicalHeightHintCache.end());
}
m_needsResolving = false;
}
KItemListSizeHintResolver(const KItemListView* itemListView);
virtual ~KItemListSizeHintResolver();
QSizeF maxSizeHint();
+ QSizeF minSizeHint();
QSizeF sizeHint(int index);
void itemsInserted(const KItemRangeList& itemRanges);
mutable QVector<qreal> m_logicalHeightHintCache;
mutable qreal m_logicalWidthHint;
mutable qreal m_logicalHeightHint;
+ mutable qreal m_minHeightHint;
bool m_needsResolving;
};
m_scrollBarPressed(false),
m_smoothScrolling(true),
m_scrollBar(scrollBar),
- m_animation(0)
+ m_animation(nullptr)
{
m_animation = new QPropertyAnimation(this);
- const int duration = m_scrollBar->style()->styleHint(QStyle::SH_Widget_Animate, nullptr, m_scrollBar) ? 100 : 1;
- m_animation->setDuration(duration);
+#if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
+ const int animationDuration = m_scrollBar->style()->styleHint(QStyle::SH_Widget_Animation_Duration, nullptr, m_scrollBar);
+ const bool animationEnabled = (animationDuration > 0);
+ #else
+ const int animationDuration = 100;
+ const bool animationEnabled = m_scrollBar->style()->styleHint(QStyle::SH_Widget_Animate, nullptr, m_scrollBar);
+#endif
+ m_animation->setDuration(animationEnabled ? animationDuration : 1);
connect(m_animation, &QPropertyAnimation::stateChanged,
this, &KItemListSmoothScroller::slotAnimationStateChanged);
public:
explicit KItemListSmoothScroller(QScrollBar* scrollBar,
- QObject* parent = 0);
- virtual ~KItemListSmoothScroller();
+ QObject* parent = nullptr);
+ ~KItemListSmoothScroller() override;
void setScrollBar(QScrollBar* scrollBar);
QScrollBar* scrollBar() const;
void handleWheelEvent(QWheelEvent* event);
protected:
- bool eventFilter(QObject* obj, QEvent* event) Q_DECL_OVERRIDE;
+ bool eventFilter(QObject* obj, QEvent* event) override;
private slots:
void slotAnimationStateChanged(QAbstractAnimation::State newState,
{
stop(widget, type);
- QPropertyAnimation* propertyAnim = 0;
+ QPropertyAnimation* propertyAnim = nullptr;
const int animationDuration = widget->style()->styleHint(QStyle::SH_Widget_Animate) ? 200 : 1;
switch (type) {
ResizeAnimation
};
- KItemListViewAnimation(QObject* parent = 0);
- virtual ~KItemListViewAnimation();
+ KItemListViewAnimation(QObject* parent = nullptr);
+ ~KItemListViewAnimation() override;
void setScrollOrientation(Qt::Orientation orientation);
Qt::Orientation scrollOrientation() const;
m_itemSize(128, 128),
m_itemMargin(),
m_headerHeight(0),
- m_model(0),
+ m_model(nullptr),
m_sizeHintResolver(sizeHintResolver),
m_scrollOffset(0),
m_maximumScrollOffset(0),
Q_OBJECT
public:
- KItemListViewLayouter(KItemListSizeHintResolver* sizeHintResolver, QObject* parent = 0);
- virtual ~KItemListViewLayouter();
+ KItemListViewLayouter(KItemListSizeHintResolver* sizeHintResolver, QObject* parent = nullptr);
+ ~KItemListViewLayouter() override;
void setScrollOrientation(Qt::Orientation orientation);
Qt::Orientation scrollOrientation() const;
public:
FoldersItemListWidget(KItemListWidgetInformant* informant, QGraphicsItem* parent);
- virtual ~FoldersItemListWidget();
+ ~FoldersItemListWidget() override;
protected:
- virtual QPalette::ColorRole normalTextColorRole() const Q_DECL_OVERRIDE;
+ QPalette::ColorRole normalTextColorRole() const override;
};
#endif
public:
explicit FoldersPanel(QWidget* parent = nullptr);
- virtual ~FoldersPanel();
+ ~FoldersPanel() override;
void setShowHiddenFiles(bool show);
void setLimitFoldersPanelToHome(bool enable);
protected:
/** @see Panel::urlChanged() */
- virtual bool urlChanged() Q_DECL_OVERRIDE;
+ bool urlChanged() override;
/** @see QWidget::showEvent() */
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
+ void showEvent(QShowEvent* event) override;
/** @see QWidget::keyPressEvent() */
- virtual void keyPressEvent(QKeyEvent* event) Q_DECL_OVERRIDE;
+ void keyPressEvent(QKeyEvent* event) override;
private slots:
void slotItemActivated(int index);
TreeViewContextMenu(FoldersPanel* parent,
const KFileItem& fileInfo);
- virtual ~TreeViewContextMenu();
+ ~TreeViewContextMenu() override;
/** Opens the context menu modal. */
void open();
Q_OBJECT
public:
- explicit FileMetaDataConfigurationDialog(QWidget* parent = 0);
- virtual ~FileMetaDataConfigurationDialog();
+ explicit FileMetaDataConfigurationDialog(QWidget* parent = nullptr);
+ ~FileMetaDataConfigurationDialog() override;
/**
* Sets the items, for which the visibility of the meta data should
void InformationPanel::slotFolderStatFinished(KJob* job)
{
- m_folderStatJob = 0;
+ m_folderStatJob = nullptr;
const KIO::UDSEntry entry = static_cast<KIO::StatJob*>(job)->statResult();
m_content->showItem(KFileItem(entry, m_shownUrl));
}
void InformationPanel::cancelRequest()
{
delete m_folderStatJob;
- m_folderStatJob = 0;
+ m_folderStatJob = nullptr;
m_infoTimer->stop();
m_resetUrlTimer->stop();
public:
explicit InformationPanel(QWidget* parent = nullptr);
- virtual ~InformationPanel();
+ ~InformationPanel() override;
signals:
void urlActivated(const QUrl& url);
protected:
/** @see Panel::urlChanged() */
- virtual bool urlChanged() Q_DECL_OVERRIDE;
+ bool urlChanged() override;
/** @see QWidget::showEvent() */
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
+ void showEvent(QShowEvent* event) override;
/** @see QWidget::resizeEvent() */
- virtual void resizeEvent(QResizeEvent* event) Q_DECL_OVERRIDE;
+ void resizeEvent(QResizeEvent* event) override;
/** @see QWidget::contextMenuEvent() */
- virtual void contextMenuEvent(QContextMenuEvent* event) Q_DECL_OVERRIDE;
+ void contextMenuEvent(QContextMenuEvent* event) override;
private slots:
/**
InformationPanelContent::InformationPanelContent(QWidget* parent) :
QWidget(parent),
m_item(),
- m_previewJob(0),
- m_outdatedPreviewTimer(0),
- m_preview(0),
- m_phononWidget(0),
- m_nameLabel(0),
- m_metaDataWidget(0),
- m_metaDataArea(0),
- m_placesItemModel(0)
+ m_previewJob(nullptr),
+ m_outdatedPreviewTimer(nullptr),
+ m_preview(nullptr),
+ m_phononWidget(nullptr),
+ m_nameLabel(nullptr),
+ m_metaDataWidget(nullptr),
+ m_metaDataArea(nullptr),
+ m_placesItemModel(nullptr)
{
parent->installEventFilter(this);
Q_OBJECT
public:
- explicit InformationPanelContent(QWidget* parent = 0);
- virtual ~InformationPanelContent();
+ explicit InformationPanelContent(QWidget* parent = nullptr);
+ ~InformationPanelContent() override;
/**
* Shows the meta information for the item \p item.
protected:
/** @see QObject::eventFilter() */
- virtual bool eventFilter(QObject* obj, QEvent* event) Q_DECL_OVERRIDE;
+ bool eventFilter(QObject* obj, QEvent* event) override;
private slots:
/**
updateGeometry();
}
- QSize sizeHint() const Q_DECL_OVERRIDE
+ QSize sizeHint() const override
{
return m_sizeHint.isValid() ? m_sizeHint : Phonon::VideoWidget::sizeHint();
}
{
Q_OBJECT
public:
- PhononWidget(QWidget *parent = 0);
+ PhononWidget(QWidget *parent = nullptr);
void setUrl(const QUrl &url);
QUrl url() const;
void hasVideoChanged(bool hasVideo);
protected:
- virtual void showEvent(QShowEvent *event) Q_DECL_OVERRIDE;
- virtual void hideEvent(QHideEvent *event) Q_DECL_OVERRIDE;
+ void showEvent(QShowEvent *event) override;
+ void hideEvent(QHideEvent *event) override;
private slots:
void stateChanged(Phonon::State);
explicit PixmapViewer(QWidget* parent,
Transition transition = DefaultTransition);
- virtual ~PixmapViewer();
+ ~PixmapViewer() override;
void setPixmap(const QPixmap& pixmap);
QPixmap pixmap() const;
* of the parent widget. Per default no size hint is given.
*/
void setSizeHint(const QSize& size);
- virtual QSize sizeHint() const Q_DECL_OVERRIDE;
+ QSize sizeHint() const override;
protected:
- virtual void paintEvent(QPaintEvent* event) Q_DECL_OVERRIDE;
+ void paintEvent(QPaintEvent* event) override;
private Q_SLOTS:
void checkPendingPixmaps();
Q_OBJECT
public:
- explicit Panel(QWidget* parent = 0);
- virtual ~Panel();
+ explicit Panel(QWidget* parent = nullptr);
+ ~Panel() override;
/** Returns the current set URL of the active Dolphin view. */
QUrl url() const;
void setCustomContextMenuActions(const QList<QAction*>& actions);
QList<QAction*> customContextMenuActions() const;
- virtual QSize sizeHint() const Q_DECL_OVERRIDE;
+ QSize sizeHint() const override;
public slots:
/**
// watches for changes if the number of items has been changed.
// The update of the icon is handled in onTrashDirListerCompleted().
m_trashDirLister = new KDirLister();
- m_trashDirLister->setAutoErrorHandlingEnabled(false, 0);
+ m_trashDirLister->setAutoErrorHandlingEnabled(false, nullptr);
m_trashDirLister->setDelayedMimeTypes(true);
QObject::connect(m_trashDirLister.data(), static_cast<void(KDirLister::*)()>(&KDirLister::completed),
m_signalHandler.data(), &PlacesItemSignalHandler::onTrashDirListerCompleted);
return dataValue("isHidden").toBool();
}
+bool PlacesItem::isGroupHidden() const
+{
+ return dataValue("isGroupHidden").toBool();
+}
+
+void PlacesItem::setGroupHidden(bool hidden)
+{
+ setDataValue("isGroupHidden", hidden);
+}
+
void PlacesItem::setSystemItem(bool isSystemItem)
{
setDataValue("isSystemItem", isSystemItem);
void PlacesItem::setBookmark(const KBookmark& bookmark)
{
- if (bookmark == m_bookmark) {
- return;
- }
+ const bool bookmarkDataChanged = !(bookmark == m_bookmark);
+ // bookmark object must be updated to keep in sync with source model
m_bookmark = bookmark;
+ if (!bookmarkDataChanged) {
+ return;
+ }
+
delete m_access;
delete m_volume;
delete m_disc;
delete m_mtp;
-
const QString udi = bookmark.metaDataItem(QStringLiteral("UDI"));
if (udi.isEmpty()) {
setIcon(bookmark.icon());
setText(i18nc("KFile System Bookmarks", bookmark.text().toUtf8().constData()));
setUrl(bookmark.url());
+ setSystemItem(bookmark.metaDataItem(QStringLiteral("isSystemItem")) == QLatin1String("true"));
} else {
initializeDevice(udi);
}
- const GroupType type = groupType();
- if (icon().isEmpty()) {
- switch (type) {
- case RecentlySavedType: setIcon(QStringLiteral("chronometer")); break;
- case SearchForType: setIcon(QStringLiteral("system-search")); break;
- case PlacesType:
- default: setIcon(QStringLiteral("folder"));
- }
-
- }
-
- switch (type) {
- case PlacesType: setGroup(i18nc("@item", "Places")); break;
- case RecentlySavedType: setGroup(i18nc("@item", "Recently Saved")); break;
- case SearchForType: setGroup(i18nc("@item", "Search For")); break;
- case DevicesType: setGroup(i18nc("@item", "Devices")); break;
- default: Q_ASSERT(false); break;
- }
-
setHidden(bookmark.metaDataItem(QStringLiteral("IsHidden")) == QLatin1String("true"));
}
return m_bookmark;
}
-PlacesItem::GroupType PlacesItem::groupType() const
-{
- if (udi().isEmpty()) {
- const QString protocol = url().scheme();
- if (protocol == QLatin1String("timeline")) {
- return RecentlySavedType;
- }
-
- if (protocol.contains(QLatin1String("search"))) {
- return SearchForType;
- }
-
- if (protocol == QLatin1String("bluetooth") || protocol == QLatin1String("obexftp") || protocol == QLatin1String("kdeconnect")) {
- return DevicesType;
- }
-
- return PlacesType;
- }
-
- return DevicesType;
-}
-
bool PlacesItem::storageSetupNeeded() const
{
return m_access ? !m_access->isAccessible() : false;
}
-KBookmark PlacesItem::createBookmark(KBookmarkManager* manager,
- const QString& text,
- const QUrl& url,
- const QString& iconName)
+bool PlacesItem::isSearchOrTimelineUrl() const
{
- KBookmarkGroup root = manager->root();
- if (root.isNull()) {
- return KBookmark();
- }
-
- KBookmark bookmark = root.addBookmark(text, url, iconName);
- bookmark.setFullText(text);
- bookmark.setMetaDataItem(QStringLiteral("ID"), generateNewId());
-
- return bookmark;
-}
-
-KBookmark PlacesItem::createDeviceBookmark(KBookmarkManager* manager,
- const QString& udi)
-{
- KBookmarkGroup root = manager->root();
- if (root.isNull()) {
- return KBookmark();
- }
-
- KBookmark bookmark = root.createNewSeparator();
- bookmark.setMetaDataItem(QStringLiteral("UDI"), udi);
- bookmark.setMetaDataItem(QStringLiteral("isSystemItem"), QStringLiteral("true"));
- return bookmark;
+ const QString urlScheme = url().scheme();
+ return (urlScheme.contains("search") || urlScheme.contains("timeline"));
}
void PlacesItem::onDataValueChanged(const QByteArray& role,
{
public:
- enum GroupType
- {
- PlacesType,
- SearchForType,
- RecentlySavedType,
- DevicesType
- };
-
- explicit PlacesItem(const KBookmark& bookmark, PlacesItem* parent = 0);
- virtual ~PlacesItem();
+ explicit PlacesItem(const KBookmark& bookmark, PlacesItem* parent = nullptr);
+ ~PlacesItem() override;
void setUrl(const QUrl& url);
QUrl url() const;
void setHidden(bool hidden);
bool isHidden() const;
+ void setGroupHidden(bool hidden);
+ bool isGroupHidden() const;
+
void setSystemItem(bool isSystemItem);
bool isSystemItem() const;
void setBookmark(const KBookmark& bookmark);
KBookmark bookmark() const;
- GroupType groupType() const;
-
bool storageSetupNeeded() const;
- static KBookmark createBookmark(KBookmarkManager* manager,
- const QString& text,
- const QUrl& url,
- const QString& iconName);
- static KBookmark createDeviceBookmark(KBookmarkManager* manager,
- const QString& udi);
+ bool isSearchOrTimelineUrl() const;
PlacesItemSignalHandler* signalHandler() const;
protected:
- virtual void onDataValueChanged(const QByteArray& role,
+ void onDataValueChanged(const QByteArray& role,
const QVariant& current,
- const QVariant& previous) Q_DECL_OVERRIDE;
+ const QVariant& previous) override;
- virtual void onDataChanged(const QHash<QByteArray, QVariant>& current,
- const QHash<QByteArray, QVariant>& previous) Q_DECL_OVERRIDE;
+ void onDataChanged(const QHash<QByteArray, QVariant>& current,
+ const QHash<QByteArray, QVariant>& previous) override;
private:
PlacesItem(const PlacesItem& item);
m_text(),
m_url(),
m_allowGlobal(false),
- m_urlEdit(0),
- m_textEdit(0),
- m_iconButton(0),
- m_appLocal(0),
+ m_urlEdit(nullptr),
+ m_textEdit(nullptr),
+ m_iconButton(nullptr),
+ m_appLocal(nullptr),
m_buttonBox(nullptr)
{
}
Q_OBJECT
public:
- explicit PlacesItemEditDialog(QWidget* parent = 0);
- virtual ~PlacesItemEditDialog();
+ explicit PlacesItemEditDialog(QWidget* parent = nullptr);
+ ~PlacesItemEditDialog() override;
void setIcon(const QString& icon);
QString icon() const;
bool allowGlobal() const;
protected:
- virtual bool event(QEvent* event) Q_DECL_OVERRIDE;
+ bool event(QEvent* event) override;
private slots:
void slotUrlChanged(const QString& text);
Q_OBJECT
public:
- PlacesItemListGroupHeader(QGraphicsWidget* parent = 0);
- virtual ~PlacesItemListGroupHeader();
+ PlacesItemListGroupHeader(QGraphicsWidget* parent = nullptr);
+ ~PlacesItemListGroupHeader() override;
protected:
- virtual void paintSeparator(QPainter* painter, const QColor& color) Q_DECL_OVERRIDE;
+ void paintSeparator(QPainter* painter, const QColor& color) override;
- virtual QPalette::ColorRole normalTextColorRole() const Q_DECL_OVERRIDE;
+ QPalette::ColorRole normalTextColorRole() const override;
};
#endif
bool PlacesItemListWidget::isHidden() const
{
- return data().value("isHidden").toBool();
+ return data().value("isHidden").toBool() ||
+ data().value("isGroupHidden").toBool();
}
QPalette::ColorRole PlacesItemListWidget::normalTextColorRole() const
public:
PlacesItemListWidget(KItemListWidgetInformant* informant, QGraphicsItem* parent);
- virtual ~PlacesItemListWidget();
+ ~PlacesItemListWidget() override;
protected:
- virtual bool isHidden() const Q_DECL_OVERRIDE;
- virtual QPalette::ColorRole normalTextColorRole() const Q_DECL_OVERRIDE;
+ bool isHidden() const override;
+ QPalette::ColorRole normalTextColorRole() const override;
};
#endif
#include <QMimeData>
#include <QTimer>
#include <KUrlMimeData>
+#include <KFilePlacesModel>
#include <Solid/Device>
#include <Solid/DeviceNotifier>
#include <views/dolphinview.h>
#include <views/viewproperties.h>
-#ifdef HAVE_BALOO
- #include <Baloo/Query>
- #include <Baloo/IndexerConfig>
-#endif
-
namespace {
- // As long as KFilePlacesView from kdelibs is available in parallel, the
- // system-bookmarks for "Recently Saved" and "Search For" should be
- // shown only inside the Places Panel. This is necessary as the stored
- // URLs needs to get translated to a Baloo-search-URL on-the-fly to
- // be independent from changes in the Baloo-search-URL-syntax.
- // Hence a prefix to the application-name of the stored bookmarks is
+ // A suffix to the application-name of the stored bookmarks is
// added, which is only read by PlacesItemModel.
- const char AppNamePrefix[] = "-places-panel";
-
+ const QString AppNameSuffix = QStringLiteral("-places-panel");
static QList<QUrl> balooURLs = {
QUrl(QStringLiteral("timeline:/today")),
QUrl(QStringLiteral("timeline:/yesterday")),
PlacesItemModel::PlacesItemModel(QObject* parent) :
KStandardItemModel(parent),
- m_fileIndexingEnabled(false),
m_hiddenItemsShown(false),
- m_availableDevices(),
- m_predicate(),
- m_bookmarkManager(0),
- m_systemBookmarks(),
- m_systemBookmarksIndexes(),
- m_bookmarkedItems(),
- m_hiddenItemToRemove(-1),
- m_deviceToTearDown(0),
- m_updateBookmarksTimer(0),
- m_storageSetupInProgress()
+ m_deviceToTearDown(nullptr),
+ m_storageSetupInProgress(),
+ m_sourceModel(new KFilePlacesModel(KAboutData::applicationData().componentName() + AppNameSuffix, this))
{
-#ifdef HAVE_BALOO
- Baloo::IndexerConfig config;
- m_fileIndexingEnabled = config.fileIndexingEnabled();
-#endif
- const QString file = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/user-places.xbel";
- m_bookmarkManager = KBookmarkManager::managerForExternalFile(file);
-
- createSystemBookmarks();
- initializeAvailableDevices();
+ cleanupBookmarks();
loadBookmarks();
+ initializeDefaultViewProperties();
- const int syncBookmarksTimeout = 100;
-
- m_updateBookmarksTimer = new QTimer(this);
- m_updateBookmarksTimer->setInterval(syncBookmarksTimeout);
- m_updateBookmarksTimer->setSingleShot(true);
- connect(m_updateBookmarksTimer, &QTimer::timeout, this, &PlacesItemModel::updateBookmarks);
-
- connect(m_bookmarkManager, &KBookmarkManager::changed,
- m_updateBookmarksTimer, static_cast<void(QTimer::*)()>(&QTimer::start));
+ connect(m_sourceModel.data(), &KFilePlacesModel::rowsInserted, this, &PlacesItemModel::onSourceModelRowsInserted);
+ connect(m_sourceModel.data(), &KFilePlacesModel::rowsAboutToBeRemoved, this, &PlacesItemModel::onSourceModelRowsAboutToBeRemoved);
+ connect(m_sourceModel.data(), &KFilePlacesModel::dataChanged, this, &PlacesItemModel::onSourceModelDataChanged);
+ connect(m_sourceModel.data(), &KFilePlacesModel::rowsAboutToBeMoved, this, &PlacesItemModel::onSourceModelRowsAboutToBeMoved);
+ connect(m_sourceModel.data(), &KFilePlacesModel::rowsMoved, this, &PlacesItemModel::onSourceModelRowsMoved);
+ connect(m_sourceModel.data(), &KFilePlacesModel::groupHiddenChanged, this, &PlacesItemModel::onSourceModelGroupHiddenChanged);
}
PlacesItemModel::~PlacesItemModel()
{
- qDeleteAll(m_bookmarkedItems);
- m_bookmarkedItems.clear();
}
-PlacesItem* PlacesItemModel::createPlacesItem(const QString& text,
- const QUrl& url,
- const QString& iconName)
+void PlacesItemModel::createPlacesItem(const QString& text,
+ const QUrl& url,
+ const QString& iconName,
+ int after)
{
- const KBookmark bookmark = PlacesItem::createBookmark(m_bookmarkManager, text, url, iconName);
- return new PlacesItem(bookmark);
+ m_sourceModel->addPlace(text, url, iconName, {}, mapToSource(after));
}
PlacesItem* PlacesItemModel::placesItem(int index) const
int PlacesItemModel::hiddenCount() const
{
- int modelIndex = 0;
- int hiddenItemCount = 0;
- foreach (const PlacesItem* item, m_bookmarkedItems) {
- if (item) {
- ++hiddenItemCount;
- } else {
- if (placesItem(modelIndex)->isHidden()) {
- ++hiddenItemCount;
- }
- ++modelIndex;
- }
- }
-
- return hiddenItemCount;
+ return m_sourceModel->hiddenCount();
}
void PlacesItemModel::setHiddenItemsShown(bool show)
m_hiddenItemsShown = show;
if (show) {
- // Move all items that are part of m_bookmarkedItems to the model.
- QList<PlacesItem*> itemsToInsert;
- QList<int> insertPos;
- int modelIndex = 0;
- for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
- if (m_bookmarkedItems[i]) {
- itemsToInsert.append(m_bookmarkedItems[i]);
- m_bookmarkedItems[i] = 0;
- insertPos.append(modelIndex);
+ for (int r = 0, rMax = m_sourceModel->rowCount(); r < rMax; r++) {
+ const QModelIndex index = m_sourceModel->index(r, 0);
+ if (!m_sourceModel->isHidden(index)) {
+ continue;
}
- ++modelIndex;
- }
-
- // Inserting the items will automatically insert an item
- // to m_bookmarkedItems in PlacesItemModel::onItemsInserted().
- // The items are temporary saved in itemsToInsert, so
- // m_bookmarkedItems can be shrinked now.
- m_bookmarkedItems.erase(m_bookmarkedItems.begin(),
- m_bookmarkedItems.begin() + itemsToInsert.count());
-
- for (int i = 0; i < itemsToInsert.count(); ++i) {
- insertItem(insertPos[i], itemsToInsert[i]);
+ addItemFromSourceModel(index);
}
-
- Q_ASSERT(m_bookmarkedItems.count() == count());
} else {
- // Move all items of the model, where the "isHidden" property is true, to
- // m_bookmarkedItems.
- Q_ASSERT(m_bookmarkedItems.count() == count());
- for (int i = count() - 1; i >= 0; --i) {
- if (placesItem(i)->isHidden()) {
- hideItem(i);
+ for (int r = 0, rMax = m_sourceModel->rowCount(); r < rMax; r++) {
+ const QModelIndex index = m_sourceModel->index(r, 0);
+ if (m_sourceModel->isHidden(index)) {
+ removeItemByIndex(index);
}
}
}
int PlacesItemModel::closestItem(const QUrl& url) const
{
- int foundIndex = -1;
- int maxLength = 0;
-
- for (int i = 0; i < count(); ++i) {
- const QUrl itemUrl = placesItem(i)->url();
- if (url == itemUrl) {
- // We can't find a closer one, so stop here.
- foundIndex = i;
- break;
- } else if (itemUrl.isParentOf(url)) {
- const int length = itemUrl.path().length();
- if (length > maxLength) {
- foundIndex = i;
- maxLength = length;
- }
- }
- }
-
- return foundIndex;
+ return mapFromSource(m_sourceModel->closestItem(url));
}
-void PlacesItemModel::appendItemToGroup(PlacesItem* item)
+// look for the correct position for the item based on source model
+void PlacesItemModel::insertSortedItem(PlacesItem* item)
{
if (!item) {
return;
}
- int i = 0;
- while (i < count() && placesItem(i)->group() != item->group()) {
- ++i;
- }
+ const KBookmark iBookmark = item->bookmark();
+ const QString iBookmarkId = bookmarkId(iBookmark);
+ QModelIndex sourceIndex;
+ int pos = 0;
+
+ for(int r = 0, rMax = m_sourceModel->rowCount(); r < rMax; r++) {
+ sourceIndex = m_sourceModel->index(r, 0);
+ const KBookmark sourceBookmark = m_sourceModel->bookmarkForIndex(sourceIndex);
- bool inserted = false;
- while (!inserted && i < count()) {
- if (placesItem(i)->group() != item->group()) {
- insertItem(i, item);
- inserted = true;
+ if (bookmarkId(sourceBookmark) == iBookmarkId) {
+ break;
}
- ++i;
- }
- if (!inserted) {
- appendItem(item);
+ if (m_hiddenItemsShown || !m_sourceModel->isHidden(sourceIndex)) {
+ pos++;
+ }
}
+
+ m_indexMap.insert(pos, sourceIndex);
+ insertItem(pos, item);
+}
+
+void PlacesItemModel::onItemInserted(int index)
+{
+ KStandardItemModel::onItemInserted(index);
+#ifdef PLACESITEMMODEL_DEBUG
+ qCDebug(DolphinDebug) << "Inserted item" << index;
+ showModelState();
+#endif
+}
+
+void PlacesItemModel::onItemRemoved(int index, KStandardItem* removedItem)
+{
+ m_indexMap.removeAt(index);
+
+ KStandardItemModel::onItemRemoved(index, removedItem);
+#ifdef PLACESITEMMODEL_DEBUG
+ qCDebug(DolphinDebug) << "Removed item" << index;
+ showModelState();
+#endif
}
+void PlacesItemModel::onItemChanged(int index, const QSet<QByteArray>& changedRoles)
+{
+ const QModelIndex sourceIndex = mapToSource(index);
+ const PlacesItem *changedItem = placesItem(mapFromSource(sourceIndex));
+
+ if (!changedItem || !sourceIndex.isValid()) {
+ qWarning() << "invalid item changed signal";
+ return;
+ }
+ if (changedRoles.contains("isHidden")) {
+ if (m_sourceModel->isHidden(sourceIndex) != changedItem->isHidden()) {
+ m_sourceModel->setPlaceHidden(sourceIndex, changedItem->isHidden());
+ } else {
+ m_sourceModel->refresh();
+ }
+ }
+ KStandardItemModel::onItemChanged(index, changedRoles);
+}
QAction* PlacesItemModel::ejectAction(int index) const
{
const PlacesItem* item = placesItem(index);
if (item && item->device().is<Solid::OpticalDisc>()) {
- return new QAction(QIcon::fromTheme(QStringLiteral("media-eject")), i18nc("@item", "Eject"), 0);
+ return new QAction(QIcon::fromTheme(QStringLiteral("media-eject")), i18nc("@item", "Eject"), nullptr);
}
- return 0;
+ return nullptr;
}
QAction* PlacesItemModel::teardownAction(int index) const
{
const PlacesItem* item = placesItem(index);
if (!item) {
- return 0;
+ return nullptr;
}
Solid::Device device = item->device();
const bool providesTearDown = device.is<Solid::StorageAccess>() &&
device.as<Solid::StorageAccess>()->isAccessible();
if (!providesTearDown) {
- return 0;
+ return nullptr;
}
Solid::StorageDrive* drive = device.as<Solid::StorageDrive>();
}
if (iconName.isEmpty()) {
- return new QAction(text, 0);
+ return new QAction(text, nullptr);
}
- return new QAction(QIcon::fromTheme(iconName), text, 0);
+ return new QAction(QIcon::fromTheme(iconName), text, nullptr);
}
void PlacesItemModel::requestEject(int index)
QDataStream stream(&itemData, QIODevice::ReadOnly);
int oldIndex;
stream >> oldIndex;
- if (oldIndex == index || oldIndex == index - 1) {
- // No moving has been done
- return;
- }
- PlacesItem* oldItem = placesItem(oldIndex);
- if (!oldItem) {
- return;
- }
-
- PlacesItem* newItem = new PlacesItem(oldItem->bookmark());
- removeItem(oldIndex);
-
- if (oldIndex < index) {
- --index;
- }
-
- const int dropIndex = groupedDropIndex(index, newItem);
- insertItem(dropIndex, newItem);
+ m_sourceModel->movePlace(oldIndex, index);
} else if (mimeData->hasFormat(QStringLiteral("text/uri-list"))) {
// One or more items must be added to the model
const QList<QUrl> urls = KUrlMimeData::urlsFromMimeData(mimeData);
continue;
}
- PlacesItem* newItem = createPlacesItem(text, url);
- const int dropIndex = groupedDropIndex(index, newItem);
- insertItem(dropIndex, newItem);
+ createPlacesItem(text, url, KIO::iconNameForUrl(url), qMax(0, index - 1));
}
}
+ // will save bookmark alteration and fix sort if that is broken by the drag/drop operation
+ refresh();
}
-QUrl PlacesItemModel::convertedUrl(const QUrl& url)
+void PlacesItemModel::addItemFromSourceModel(const QModelIndex &index)
{
- QUrl newUrl = url;
- if (url.scheme() == QLatin1String("timeline")) {
- newUrl = createTimelineUrl(url);
- } else if (url.scheme() == QLatin1String("search")) {
- newUrl = createSearchUrl(url);
+ if (!m_hiddenItemsShown && m_sourceModel->isHidden(index)) {
+ return;
}
- return newUrl;
-}
-
-void PlacesItemModel::onItemInserted(int index)
-{
- const PlacesItem* insertedItem = placesItem(index);
- if (insertedItem) {
- // Take care to apply the PlacesItemModel-order of the inserted item
- // also to the bookmark-manager.
- const KBookmark insertedBookmark = insertedItem->bookmark();
-
- const PlacesItem* previousItem = placesItem(index - 1);
- KBookmark previousBookmark;
- if (previousItem) {
- previousBookmark = previousItem->bookmark();
- }
-
- m_bookmarkManager->root().moveBookmark(insertedBookmark, previousBookmark);
+ const KBookmark bookmark = m_sourceModel->bookmarkForIndex(index);
+ Q_ASSERT(!bookmark.isNull());
+ PlacesItem *item = itemFromBookmark(bookmark);
+ if (!item) {
+ item = new PlacesItem(bookmark);
}
+ updateItem(item, index);
+ insertSortedItem(item);
- if (index == count() - 1) {
- // The item has been appended as last item to the list. In this
- // case assure that it is also appended after the hidden items and
- // not before (like done otherwise).
- m_bookmarkedItems.append(0);
- } else {
-
- int modelIndex = -1;
- int bookmarkIndex = 0;
- while (bookmarkIndex < m_bookmarkedItems.count()) {
- if (!m_bookmarkedItems[bookmarkIndex]) {
- ++modelIndex;
- if (modelIndex + 1 == index) {
- break;
- }
- }
- ++bookmarkIndex;
- }
- m_bookmarkedItems.insert(bookmarkIndex, 0);
+ if (m_sourceModel->isDevice(index)) {
+ connect(item->signalHandler(), &PlacesItemSignalHandler::tearDownExternallyRequested,
+ this, &PlacesItemModel::storageTearDownExternallyRequested);
}
-
-#ifdef PLACESITEMMODEL_DEBUG
- qCDebug(DolphinDebug) << "Inserted item" << index;
- showModelState();
-#endif
}
-void PlacesItemModel::onItemRemoved(int index, KStandardItem* removedItem)
+void PlacesItemModel::removeItemByIndex(const QModelIndex &sourceIndex)
{
- PlacesItem* placesItem = dynamic_cast<PlacesItem*>(removedItem);
- if (placesItem) {
- const KBookmark bookmark = placesItem->bookmark();
- m_bookmarkManager->root().deleteBookmark(bookmark);
- }
-
- const int boomarkIndex = bookmarkIndex(index);
- Q_ASSERT(!m_bookmarkedItems[boomarkIndex]);
- m_bookmarkedItems.removeAt(boomarkIndex);
-
-#ifdef PLACESITEMMODEL_DEBUG
- qCDebug(DolphinDebug) << "Removed item" << index;
- showModelState();
-#endif
-}
+ QString id = bookmarkId(m_sourceModel->bookmarkForIndex(sourceIndex));
-void PlacesItemModel::onItemChanged(int index, const QSet<QByteArray>& changedRoles)
-{
- const PlacesItem* changedItem = placesItem(index);
- if (changedItem) {
- // Take care to apply the PlacesItemModel-order of the changed item
- // also to the bookmark-manager.
- const KBookmark insertedBookmark = changedItem->bookmark();
-
- const PlacesItem* previousItem = placesItem(index - 1);
- KBookmark previousBookmark;
- if (previousItem) {
- previousBookmark = previousItem->bookmark();
+ for (int i = 0, iMax = count(); i < iMax; ++i) {
+ if (bookmarkId(placesItem(i)->bookmark()) == id) {
+ removeItem(i);
+ return;
}
-
- m_bookmarkManager->root().moveBookmark(insertedBookmark, previousBookmark);
}
+}
- if (changedRoles.contains("isHidden")) {
- if (!m_hiddenItemsShown && changedItem->isHidden()) {
- m_hiddenItemToRemove = index;
- QTimer::singleShot(0, this, static_cast<void (PlacesItemModel::*)()>(&PlacesItemModel::hideItem));
+QString PlacesItemModel::bookmarkId(const KBookmark &bookmark) const
+{
+ QString id = bookmark.metaDataItem(QStringLiteral("UDI"));
+ if (id.isEmpty()) {
+ id = bookmark.metaDataItem(QStringLiteral("ID"));
+ }
+ return id;
+}
+
+void PlacesItemModel::initializeDefaultViewProperties() const
+{
+ for(int i = 0, iMax = m_sourceModel->rowCount(); i < iMax; i++) {
+ const QModelIndex index = m_sourceModel->index(i, 0);
+ const PlacesItem *item = placesItem(mapFromSource(index));
+ if (!item) {
+ continue;
+ }
+
+ // Create default view-properties for all "Search For" and "Recently Saved" bookmarks
+ // in case the user has not already created custom view-properties for a corresponding
+ // query yet.
+ const bool createDefaultViewProperties = item->isSearchOrTimelineUrl() && !GeneralSettings::self()->globalViewProps();
+ if (createDefaultViewProperties) {
+ const QUrl itemUrl = item->url();
+ ViewProperties props(KFilePlacesModel::convertedUrl(itemUrl));
+ if (!props.exist()) {
+ const QString path = itemUrl.path();
+ if (path == QLatin1String("/documents")) {
+ props.setViewMode(DolphinView::DetailsView);
+ props.setPreviewsShown(false);
+ props.setVisibleRoles({"text", "path"});
+ } else if (path == QLatin1String("/images")) {
+ props.setViewMode(DolphinView::IconsView);
+ props.setPreviewsShown(true);
+ props.setVisibleRoles({"text", "imageSize"});
+ } else if (path == QLatin1String("/audio")) {
+ props.setViewMode(DolphinView::DetailsView);
+ props.setPreviewsShown(false);
+ props.setVisibleRoles({"text", "artist", "album"});
+ } else if (path == QLatin1String("/videos")) {
+ props.setViewMode(DolphinView::IconsView);
+ props.setPreviewsShown(true);
+ props.setVisibleRoles({"text"});
+ } else if (itemUrl.scheme() == QLatin1String("timeline")) {
+ props.setViewMode(DolphinView::DetailsView);
+ props.setVisibleRoles({"text", "modificationtime"});
+ }
+ props.save();
+ }
}
}
}
-void PlacesItemModel::slotDeviceAdded(const QString& udi)
+void PlacesItemModel::updateItem(PlacesItem *item, const QModelIndex &index)
{
- const Solid::Device device(udi);
-
- if (!m_predicate.matches(device)) {
- return;
- }
-
- m_availableDevices << udi;
- const KBookmark bookmark = PlacesItem::createDeviceBookmark(m_bookmarkManager, udi);
-
- PlacesItem *item = new PlacesItem(bookmark);
- appendItem(item);
- connect(item->signalHandler(), &PlacesItemSignalHandler::tearDownExternallyRequested,
- this, &PlacesItemModel::storageTearDownExternallyRequested);
-}
-
-void PlacesItemModel::slotDeviceRemoved(const QString& udi)
-{
- if (!m_availableDevices.contains(udi)) {
- return;
- }
-
- for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
- PlacesItem* item = m_bookmarkedItems[i];
- if (item && item->udi() == udi) {
- m_bookmarkedItems.removeAt(i);
- delete item;
- return;
- }
- }
-
- for (int i = 0; i < count(); ++i) {
- if (placesItem(i)->udi() == udi) {
- removeItem(i);
- return;
- }
- }
+ item->setGroup(index.data(KFilePlacesModel::GroupRole).toString());
+ item->setIcon(index.data(KFilePlacesModel::IconNameRole).toString());
+ item->setGroupHidden(index.data(KFilePlacesModel::GroupHiddenRole).toBool());
}
void PlacesItemModel::slotStorageTearDownDone(Solid::ErrorType error, const QVariant& errorData)
}
}
-void PlacesItemModel::hideItem()
+void PlacesItemModel::onSourceModelRowsInserted(const QModelIndex &parent, int first, int last)
{
- hideItem(m_hiddenItemToRemove);
- m_hiddenItemToRemove = -1;
+ for (int i = first; i <= last; i++) {
+ const QModelIndex index = m_sourceModel->index(i, 0, parent);
+ addItemFromSourceModel(index);
+ }
}
-void PlacesItemModel::updateBookmarks()
+void PlacesItemModel::onSourceModelRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
{
- // Verify whether new bookmarks have been added or existing
- // bookmarks have been changed.
- KBookmarkGroup root = m_bookmarkManager->root();
- KBookmark newBookmark = root.first();
- while (!newBookmark.isNull()) {
- if (acceptBookmark(newBookmark, m_availableDevices)) {
- bool found = false;
- int modelIndex = 0;
- for (int i = 0; i < m_bookmarkedItems.count(); ++i) {
- PlacesItem* item = m_bookmarkedItems[i];
- if (!item) {
- item = placesItem(modelIndex);
- ++modelIndex;
- }
-
- const KBookmark oldBookmark = item->bookmark();
- if (equalBookmarkIdentifiers(newBookmark, oldBookmark)) {
- // The bookmark has been found in the model or as
- // a hidden item. The content of the bookmark might
- // have been changed, so an update is done.
- found = true;
- if (newBookmark.metaDataItem(QStringLiteral("UDI")).isEmpty()) {
- item->setBookmark(newBookmark);
- item->setText(i18nc("KFile System Bookmarks", newBookmark.text().toUtf8().constData()));
- }
- break;
- }
- }
-
- if (!found) {
- const QString udi = newBookmark.metaDataItem(QStringLiteral("UDI"));
-
- /*
- * See Bug 304878
- * Only add a new places item, if the item text is not empty
- * and if the device is available. Fixes the strange behaviour -
- * add a places item without text in the Places section - when you
- * remove a device (e.g. a usb stick) without unmounting.
- */
- if (udi.isEmpty() || Solid::Device(udi).isValid()) {
- PlacesItem* item = new PlacesItem(newBookmark);
- if (item->isHidden() && !m_hiddenItemsShown) {
- m_bookmarkedItems.append(item);
- } else {
- appendItemToGroup(item);
- }
- }
- }
+ for(int r = first; r <= last; r++) {
+ const QModelIndex index = m_sourceModel->index(r, 0, parent);
+ int oldIndex = mapFromSource(index);
+ if (oldIndex != -1) {
+ removeItem(oldIndex);
}
-
- newBookmark = root.next(newBookmark);
}
+}
- // Remove items that are not part of the bookmark-manager anymore
- int modelIndex = 0;
- for (int i = m_bookmarkedItems.count() - 1; i >= 0; --i) {
- PlacesItem* item = m_bookmarkedItems[i];
- const bool itemIsPartOfModel = (item == 0);
- if (itemIsPartOfModel) {
- item = placesItem(modelIndex);
- }
-
- bool hasBeenRemoved = true;
- const KBookmark oldBookmark = item->bookmark();
- KBookmark newBookmark = root.first();
- while (!newBookmark.isNull()) {
- if (equalBookmarkIdentifiers(newBookmark, oldBookmark)) {
- hasBeenRemoved = false;
- break;
- }
- newBookmark = root.next(newBookmark);
- }
-
- if (hasBeenRemoved) {
- if (m_bookmarkedItems[i]) {
- delete m_bookmarkedItems[i];
- m_bookmarkedItems.removeAt(i);
- } else {
- removeItem(modelIndex);
- --modelIndex;
- }
- }
+void PlacesItemModel::onSourceModelRowsAboutToBeMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row)
+{
+ Q_UNUSED(destination);
+ Q_UNUSED(row);
- if (itemIsPartOfModel) {
- ++modelIndex;
- }
+ for(int r = start; r <= end; r++) {
+ const QModelIndex sourceIndex = m_sourceModel->index(r, 0, parent);
+ // remove moved item
+ removeItem(mapFromSource(sourceIndex));
}
}
-void PlacesItemModel::saveBookmarks()
+void PlacesItemModel::onSourceModelRowsMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row)
{
- m_bookmarkManager->emitChanged(m_bookmarkManager->root());
-}
+ Q_UNUSED(destination);
+ Q_UNUSED(parent);
-void PlacesItemModel::loadBookmarks()
-{
- KBookmarkGroup root = m_bookmarkManager->root();
- KBookmark bookmark = root.first();
- QSet<QString> devices = m_availableDevices;
+ const int blockSize = (end - start) + 1;
- QSet<QUrl> missingSystemBookmarks;
- foreach (const SystemBookmarkData& data, m_systemBookmarks) {
- missingSystemBookmarks.insert(data.url);
+ for (int r = start; r <= end; r++) {
+ // insert the moved item in the new position
+ const int targetRow = row + (start - r) - (r < row ? blockSize : 0);
+ const QModelIndex targetIndex = m_sourceModel->index(targetRow, 0, destination);
+
+ addItemFromSourceModel(targetIndex);
}
+}
- // The bookmarks might have a mixed order of places, devices and search-groups due
- // to the compatibility with the KFilePlacesPanel. In Dolphin's places panel the
- // items should always be collected in one group so the items are collected first
- // in separate lists before inserting them.
- QList<PlacesItem*> placesItems;
- QList<PlacesItem*> recentlySavedItems;
- QList<PlacesItem*> searchForItems;
- QList<PlacesItem*> devicesItems;
+void PlacesItemModel::onSourceModelDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
+{
+ Q_UNUSED(roles);
- while (!bookmark.isNull()) {
- if (acceptBookmark(bookmark, devices)) {
- PlacesItem* item = new PlacesItem(bookmark);
- if (item->groupType() == PlacesItem::DevicesType) {
- devices.remove(item->udi());
- devicesItems.append(item);
- } else {
- const QUrl url = bookmark.url();
- if (missingSystemBookmarks.contains(url)) {
- missingSystemBookmarks.remove(url);
-
- // Try to retranslate the text of system bookmarks to have translated
- // items when changing the language. In case if the user has applied a custom
- // text, the retranslation will fail and the users custom text is still used.
- // It is important to use "KFile System Bookmarks" as context (see
- // createSystemBookmarks()).
- item->setText(i18nc("KFile System Bookmarks", bookmark.text().toUtf8().constData()));
- item->setSystemItem(true);
- }
+ for (int r = topLeft.row(); r <= bottomRight.row(); r++) {
+ const QModelIndex sourceIndex = m_sourceModel->index(r, 0);
+ const KBookmark bookmark = m_sourceModel->bookmarkForIndex(sourceIndex);
+ PlacesItem *placeItem = itemFromBookmark(bookmark);
- switch (item->groupType()) {
- case PlacesItem::PlacesType: placesItems.append(item); break;
- case PlacesItem::RecentlySavedType: recentlySavedItems.append(item); break;
- case PlacesItem::SearchForType: searchForItems.append(item); break;
- case PlacesItem::DevicesType:
- default: Q_ASSERT(false); break;
- }
- }
+ if (placeItem && (!m_hiddenItemsShown && m_sourceModel->isHidden(sourceIndex))) {
+ //hide item if it became invisible
+ removeItem(index(placeItem));
+ return;
}
- bookmark = root.next(bookmark);
- }
-
- if (!missingSystemBookmarks.isEmpty()) {
- // The current bookmarks don't contain all system-bookmarks. Add the missing
- // bookmarks.
- foreach (const SystemBookmarkData& data, m_systemBookmarks) {
- if (missingSystemBookmarks.contains(data.url)) {
- PlacesItem* item = createSystemPlacesItem(data);
- switch (item->groupType()) {
- case PlacesItem::PlacesType: placesItems.append(item); break;
- case PlacesItem::RecentlySavedType: recentlySavedItems.append(item); break;
- case PlacesItem::SearchForType: searchForItems.append(item); break;
- case PlacesItem::DevicesType:
- default: Q_ASSERT(false); break;
- }
- }
+ if (!placeItem && (m_hiddenItemsShown || !m_sourceModel->isHidden(sourceIndex))) {
+ //show item if it became visible
+ addItemFromSourceModel(sourceIndex);
+ return;
}
- }
-
- // Create items for devices that have not been stored as bookmark yet
- devicesItems.reserve(devicesItems.count() + devices.count());
- foreach (const QString& udi, devices) {
- const KBookmark bookmark = PlacesItem::createDeviceBookmark(m_bookmarkManager, udi);
- PlacesItem *item = new PlacesItem(bookmark);
- devicesItems.append(item);
- connect(item->signalHandler(), &PlacesItemSignalHandler::tearDownExternallyRequested,
- this, &PlacesItemModel::storageTearDownExternallyRequested);
- }
-
- QList<PlacesItem*> items;
- items.append(placesItems);
- items.append(recentlySavedItems);
- items.append(searchForItems);
- items.append(devicesItems);
- foreach (PlacesItem* item, items) {
- if (!m_hiddenItemsShown && item->isHidden()) {
- m_bookmarkedItems.append(item);
- } else {
- appendItem(item);
+ if (placeItem && !m_sourceModel->isDevice(sourceIndex)) {
+ placeItem->setText(bookmark.text());
+ placeItem->setIcon(sourceIndex.data(KFilePlacesModel::IconNameRole).toString());
+ placeItem->setUrl(m_sourceModel->url(sourceIndex));
+ placeItem->bookmark().setMetaDataItem(QStringLiteral("OnlyInApp"),
+ bookmark.metaDataItem(QStringLiteral("OnlyInApp")));
+ // must update the bookmark object
+ placeItem->setBookmark(bookmark);
}
}
-
-#ifdef PLACESITEMMODEL_DEBUG
- qCDebug(DolphinDebug) << "Loaded bookmarks";
- showModelState();
-#endif
}
-bool PlacesItemModel::acceptBookmark(const KBookmark& bookmark,
- const QSet<QString>& availableDevices) const
+void PlacesItemModel::onSourceModelGroupHiddenChanged(KFilePlacesModel::GroupType group, bool hidden)
{
- const QString udi = bookmark.metaDataItem(QStringLiteral("UDI"));
- const QUrl url = bookmark.url();
- const QString appName = bookmark.metaDataItem(QStringLiteral("OnlyInApp"));
- const bool deviceAvailable = availableDevices.contains(udi);
-
- if (balooURLs.contains(url) && appName.isEmpty()) {
- // Does not accept baloo URLS with empty appName, this came from new KIO model and will cause duplications
- qCWarning(DolphinDebug) << "Ignore KIO url:" << url;
- return false;
+ for(const QModelIndex &sourceIndex : m_sourceModel->groupIndexes(group)) {
+ PlacesItem *item = placesItem(mapFromSource(sourceIndex));
+ if (item) {
+ item->setGroupHidden(hidden);
+ }
}
-
- const bool allowedHere = (appName.isEmpty()
- || appName == KAboutData::applicationData().componentName()
- || appName == KAboutData::applicationData().componentName() + AppNamePrefix)
- && (m_fileIndexingEnabled || (url.scheme() != QLatin1String("timeline") &&
- url.scheme() != QLatin1String("search")));
-
- return (udi.isEmpty() && allowedHere) || deviceAvailable;
}
-PlacesItem* PlacesItemModel::createSystemPlacesItem(const SystemBookmarkData& data)
+void PlacesItemModel::cleanupBookmarks()
{
- KBookmark bookmark = PlacesItem::createBookmark(m_bookmarkManager,
- data.text,
- data.url,
- data.icon);
-
- const QString protocol = data.url.scheme();
- if (protocol == QLatin1String("timeline") || protocol == QLatin1String("search")) {
- // As long as the KFilePlacesView from kdelibs is available, the system-bookmarks
- // for "Recently Saved" and "Search For" should be a setting available only
- // in the Places Panel (see description of AppNamePrefix for more details).
- const QString appName = KAboutData::applicationData().componentName() + AppNamePrefix;
- bookmark.setMetaDataItem(QStringLiteral("OnlyInApp"), appName);
- }
+ // KIO model now provides support for baloo urls, and because of that we
+ // need to remove old URLs that were visible only in Dolphin to avoid duplication
+ int row = 0;
+ do {
+ const QModelIndex sourceIndex = m_sourceModel->index(row, 0);
+ const KBookmark bookmark = m_sourceModel->bookmarkForIndex(sourceIndex);
+ const QUrl url = bookmark.url();
+ const QString appName = bookmark.metaDataItem(QStringLiteral("OnlyInApp"));
- PlacesItem* item = new PlacesItem(bookmark);
- item->setSystemItem(true);
-
- // Create default view-properties for all "Search For" and "Recently Saved" bookmarks
- // in case if the user has not already created custom view-properties for a corresponding
- // query yet.
- const bool createDefaultViewProperties = (item->groupType() == PlacesItem::SearchForType ||
- item->groupType() == PlacesItem::RecentlySavedType) &&
- !GeneralSettings::self()->globalViewProps();
- if (createDefaultViewProperties) {
- ViewProperties props(convertedUrl(data.url));
- if (!props.exist()) {
- const QString path = data.url.path();
- if (path == QLatin1String("/documents")) {
- props.setViewMode(DolphinView::DetailsView);
- props.setPreviewsShown(false);
- props.setVisibleRoles({"text", "path"});
- } else if (path == QLatin1String("/images")) {
- props.setViewMode(DolphinView::IconsView);
- props.setPreviewsShown(true);
- props.setVisibleRoles({"text", "imageSize"});
- } else if (path == QLatin1String("/audio")) {
- props.setViewMode(DolphinView::DetailsView);
- props.setPreviewsShown(false);
- props.setVisibleRoles({"text", "artist", "album"});
- } else if (path == QLatin1String("/videos")) {
- props.setViewMode(DolphinView::IconsView);
- props.setPreviewsShown(true);
- props.setVisibleRoles({"text"});
- } else if (data.url.scheme() == QLatin1String("timeline")) {
- props.setViewMode(DolphinView::DetailsView);
- props.setVisibleRoles({"text", "modificationtime"});
- }
+ if ((appName == KAboutData::applicationData().componentName() ||
+ appName == KAboutData::applicationData().componentName() + AppNameSuffix) && balooURLs.contains(url)) {
+ qCDebug(DolphinDebug) << "Removing old baloo url:" << url;
+ m_sourceModel->removePlace(sourceIndex);
+ } else {
+ row++;
}
- }
-
- return item;
+ } while (row < m_sourceModel->rowCount());
}
-void PlacesItemModel::createSystemBookmarks()
+void PlacesItemModel::loadBookmarks()
{
- Q_ASSERT(m_systemBookmarks.isEmpty());
- Q_ASSERT(m_systemBookmarksIndexes.isEmpty());
-
- // Note: The context of the I18N_NOOP2 must be "KFile System Bookmarks". The real
- // i18nc call is done after reading the bookmark. The reason why the i18nc call is not
- // done here is because otherwise switching the language would not result in retranslating the
- // bookmarks.
- m_systemBookmarks.append(SystemBookmarkData(QUrl::fromLocalFile(QDir::homePath()),
- QStringLiteral("user-home"),
- I18N_NOOP2("KFile System Bookmarks", "Home")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("remote:/")),
- QStringLiteral("network-workgroup"),
- I18N_NOOP2("KFile System Bookmarks", "Network")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl::fromLocalFile(QStringLiteral("/")),
- QStringLiteral("folder-red"),
- I18N_NOOP2("KFile System Bookmarks", "Root")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("trash:/")),
- QStringLiteral("user-trash"),
- I18N_NOOP2("KFile System Bookmarks", "Trash")));
-
- if (m_fileIndexingEnabled) {
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("timeline:/today")),
- QStringLiteral("go-jump-today"),
- I18N_NOOP2("KFile System Bookmarks", "Today")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("timeline:/yesterday")),
- QStringLiteral("view-calendar-day"),
- I18N_NOOP2("KFile System Bookmarks", "Yesterday")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("timeline:/thismonth")),
- QStringLiteral("view-calendar-month"),
- I18N_NOOP2("KFile System Bookmarks", "This Month")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("timeline:/lastmonth")),
- QStringLiteral("view-calendar-month"),
- I18N_NOOP2("KFile System Bookmarks", "Last Month")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("search:/documents")),
- QStringLiteral("folder-text"),
- I18N_NOOP2("KFile System Bookmarks", "Documents")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("search:/images")),
- QStringLiteral("folder-images"),
- I18N_NOOP2("KFile System Bookmarks", "Images")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("search:/audio")),
- QStringLiteral("folder-sound"),
- I18N_NOOP2("KFile System Bookmarks", "Audio Files")));
- m_systemBookmarks.append(SystemBookmarkData(QUrl(QStringLiteral("search:/videos")),
- QStringLiteral("folder-videos"),
- I18N_NOOP2("KFile System Bookmarks", "Videos")));
+ for(int r = 0, rMax = m_sourceModel->rowCount(); r < rMax; r++) {
+ const QModelIndex sourceIndex = m_sourceModel->index(r, 0);
+ if (m_hiddenItemsShown || !m_sourceModel->isHidden(sourceIndex)) {
+ addItemFromSourceModel(sourceIndex);
+ }
}
- for (int i = 0; i < m_systemBookmarks.count(); ++i) {
- m_systemBookmarksIndexes.insert(m_systemBookmarks[i].url, i);
- }
+#ifdef PLACESITEMMODEL_DEBUG
+ qCDebug(DolphinDebug) << "Loaded bookmarks";
+ showModelState();
+#endif
}
void PlacesItemModel::clear() {
- m_bookmarkedItems.clear();
KStandardItemModel::clear();
}
m_deviceToTearDown->teardown();
}
-void PlacesItemModel::initializeAvailableDevices()
+void PlacesItemModel::deleteItem(int index)
{
- QString predicate(QStringLiteral("[[[[ StorageVolume.ignored == false AND [ StorageVolume.usage == 'FileSystem' OR StorageVolume.usage == 'Encrypted' ]]"
- " OR "
- "[ IS StorageAccess AND StorageDrive.driveType == 'Floppy' ]]"
- " OR "
- "OpticalDisc.availableContent & 'Audio' ]"
- " OR "
- "StorageAccess.ignored == false ]"));
-
-
- if (KProtocolInfo::isKnownProtocol(QStringLiteral("mtp"))) {
- predicate.prepend("[");
- predicate.append(" OR PortableMediaPlayer.supportedProtocols == 'mtp']");
- }
-
- m_predicate = Solid::Predicate::fromString(predicate);
- Q_ASSERT(m_predicate.isValid());
-
- Solid::DeviceNotifier* notifier = Solid::DeviceNotifier::instance();
- connect(notifier, &Solid::DeviceNotifier::deviceAdded, this, &PlacesItemModel::slotDeviceAdded);
- connect(notifier, &Solid::DeviceNotifier::deviceRemoved, this, &PlacesItemModel::slotDeviceRemoved);
-
- const QList<Solid::Device>& deviceList = Solid::Device::listFromQuery(m_predicate);
- foreach (const Solid::Device& device, deviceList) {
- m_availableDevices << device.udi();
- }
+ QModelIndex sourceIndex = mapToSource(index);
+ Q_ASSERT(sourceIndex.isValid());
+ m_sourceModel->removePlace(sourceIndex);
}
-int PlacesItemModel::bookmarkIndex(int index) const
+void PlacesItemModel::refresh()
{
- int bookmarkIndex = 0;
- int modelIndex = 0;
- while (bookmarkIndex < m_bookmarkedItems.count()) {
- if (!m_bookmarkedItems[bookmarkIndex]) {
- if (modelIndex == index) {
- break;
- }
- ++modelIndex;
- }
- ++bookmarkIndex;
- }
-
- return bookmarkIndex >= m_bookmarkedItems.count() ? -1 : bookmarkIndex;
+ m_sourceModel->refresh();
}
void PlacesItemModel::hideItem(int index)
}
shownItem->setHidden(true);
- if (m_hiddenItemsShown) {
- // Removing items from the model is not allowed if all hidden
- // items should be shown.
- return;
- }
-
- const int newIndex = bookmarkIndex(index);
- if (newIndex >= 0) {
- const KBookmark hiddenBookmark = shownItem->bookmark();
- PlacesItem* hiddenItem = new PlacesItem(hiddenBookmark);
-
- const PlacesItem* previousItem = placesItem(index - 1);
- KBookmark previousBookmark;
- if (previousItem) {
- previousBookmark = previousItem->bookmark();
- }
-
- const bool updateBookmark = (m_bookmarkManager->root().indexOf(hiddenBookmark) >= 0);
- removeItem(index);
-
- if (updateBookmark) {
- // removeItem() also removed the bookmark from m_bookmarkManager in
- // PlacesItemModel::onItemRemoved(). However for hidden items the
- // bookmark should still be remembered, so readd it again:
- m_bookmarkManager->root().addBookmark(hiddenBookmark);
- m_bookmarkManager->root().moveBookmark(hiddenBookmark, previousBookmark);
- }
-
- m_bookmarkedItems.insert(newIndex, hiddenItem);
- }
}
QString PlacesItemModel::internalMimeType() const
Q_ASSERT(item);
int dropIndex = index;
- const PlacesItem::GroupType type = item->groupType();
+ const QString group = item->group();
const int itemCount = count();
if (index < 0) {
// Search nearest previous item with the same group
int previousIndex = -1;
for (int i = dropIndex - 1; i >= 0; --i) {
- if (placesItem(i)->groupType() == type) {
+ if (placesItem(i)->group() == group) {
previousIndex = i;
break;
}
// Search nearest next item with the same group
int nextIndex = -1;
for (int i = dropIndex; i < count(); ++i) {
- if (placesItem(i)->groupType() == type) {
+ if (placesItem(i)->group() == group) {
nextIndex = i;
break;
}
}
}
-QUrl PlacesItemModel::createTimelineUrl(const QUrl& url)
+int PlacesItemModel::mapFromSource(const QModelIndex &index) const
{
- // TODO: Clarify with the Baloo-team whether it makes sense
- // provide default-timeline-URLs like 'yesterday', 'this month'
- // and 'last month'.
- QUrl timelineUrl;
-
- const QString path = url.toDisplayString(QUrl::PreferLocalFile);
- if (path.endsWith(QLatin1String("yesterday"))) {
- const QDate date = QDate::currentDate().addDays(-1);
- const int year = date.year();
- const int month = date.month();
- const int day = date.day();
- timelineUrl = QUrl("timeline:/" + timelineDateString(year, month) +
- '/' + timelineDateString(year, month, day));
- } else if (path.endsWith(QLatin1String("thismonth"))) {
- const QDate date = QDate::currentDate();
- timelineUrl = QUrl("timeline:/" + timelineDateString(date.year(), date.month()));
- } else if (path.endsWith(QLatin1String("lastmonth"))) {
- const QDate date = QDate::currentDate().addMonths(-1);
- timelineUrl = QUrl("timeline:/" + timelineDateString(date.year(), date.month()));
- } else {
- Q_ASSERT(path.endsWith(QLatin1String("today")));
- timelineUrl = url;
- }
-
- return timelineUrl;
-}
-
-QString PlacesItemModel::timelineDateString(int year, int month, int day)
-{
- QString date = QString::number(year) + '-';
- if (month < 10) {
- date += '0';
- }
- date += QString::number(month);
-
- if (day >= 1) {
- date += '-';
- if (day < 10) {
- date += '0';
- }
- date += QString::number(day);
+ if (!index.isValid()) {
+ return -1;
}
- return date;
+ return m_indexMap.indexOf(index);
}
bool PlacesItemModel::isDir(int index) const
return true;
}
-QUrl PlacesItemModel::createSearchUrl(const QUrl& url)
+KFilePlacesModel::GroupType PlacesItemModel::groupType(int row) const
{
- QUrl searchUrl;
-
-#ifdef HAVE_BALOO
- const QString path = url.toDisplayString(QUrl::PreferLocalFile);
- if (path.endsWith(QLatin1String("documents"))) {
- searchUrl = searchUrlForType(QStringLiteral("Document"));
- } else if (path.endsWith(QLatin1String("images"))) {
- searchUrl = searchUrlForType(QStringLiteral("Image"));
- } else if (path.endsWith(QLatin1String("audio"))) {
- searchUrl = searchUrlForType(QStringLiteral("Audio"));
- } else if (path.endsWith(QLatin1String("videos"))) {
- searchUrl = searchUrlForType(QStringLiteral("Video"));
- } else {
- Q_ASSERT(false);
- }
-#else
- Q_UNUSED(url);
-#endif
+ return m_sourceModel->groupType(mapToSource(row));
+}
- return searchUrl;
+bool PlacesItemModel::isGroupHidden(KFilePlacesModel::GroupType type) const
+{
+ return m_sourceModel->isGroupHidden(type);
}
-#ifdef HAVE_BALOO
-QUrl PlacesItemModel::searchUrlForType(const QString& type)
+void PlacesItemModel::setGroupHidden(KFilePlacesModel::GroupType type, bool hidden)
{
- Baloo::Query query;
- query.addType(type);
+ return m_sourceModel->setGroupHidden(type, hidden);
+}
- return query.toSearchUrl();
+QModelIndex PlacesItemModel::mapToSource(int row) const
+{
+ return m_indexMap.value(row);
+}
+
+PlacesItem *PlacesItemModel::itemFromBookmark(const KBookmark &bookmark) const
+{
+ const QString id = bookmarkId(bookmark);
+ for (int i = 0, iMax = count(); i < iMax; i++) {
+ PlacesItem *item = placesItem(i);
+ const KBookmark itemBookmark = item->bookmark();
+ if (bookmarkId(itemBookmark) == id) {
+ return item;
+ }
+ }
+ return nullptr;
}
-#endif
#ifdef PLACESITEMMODEL_DEBUG
void PlacesItemModel::showModelState()
#ifndef PLACESITEMMODEL_H
#define PLACESITEMMODEL_H
-#include <config-baloo.h>
-
#include <kitemviews/kstandarditemmodel.h>
+#include <KFilePlacesModel>
#include <QUrl>
#include <QHash>
class KBookmarkManager;
class PlacesItem;
class QAction;
-class QTimer;
// #define PLACESITEMMODEL_DEBUG
Q_OBJECT
public:
- explicit PlacesItemModel(QObject* parent = 0);
- virtual ~PlacesItemModel();
+ explicit PlacesItemModel(QObject* parent = nullptr);
+ ~PlacesItemModel() override;
/**
- * @return A new instance of a places item with the given
- * attributes.
+ * @brief Create a new place entry in the bookmark file
+ * and add it to the model
*/
- PlacesItem* createPlacesItem(const QString& text,
- const QUrl& url,
- const QString& iconName = QString());
+ void createPlacesItem(const QString& text,
+ const QUrl& url,
+ const QString& iconName = QString(),
+ int after = -1);
PlacesItem* placesItem(int index) const;
+ /**
+ * @brief Mark an item as hiden
+ * @param index of the item to be hidden
+ */
+ void hideItem(int index);
+
/**
* If set to true, all items that are marked as hidden
* will be shown in the view. The items will
*/
int closestItem(const QUrl& url) const;
- /**
- * Appends the item \a item as last element of the group
- * the item belongs to. If no item with the same group is
- * present, the item gets appended as last element of the
- * model. PlacesItemModel takes the ownership
- * of the item.
- */
- void appendItemToGroup(PlacesItem* item);
-
QAction* ejectAction(int index) const;
QAction* teardownAction(int index) const;
bool storageSetupNeeded(int index) const;
void requestStorageSetup(int index);
- virtual QMimeData* createMimeData(const KItemSet& indexes) const Q_DECL_OVERRIDE;
+ QMimeData* createMimeData(const KItemSet& indexes) const override;
- virtual bool supportsDropping(int index) const Q_DECL_OVERRIDE;
+ bool supportsDropping(int index) const override;
void dropMimeDataBefore(int index, const QMimeData* mimeData);
*/
static QUrl convertedUrl(const QUrl& url);
- virtual void clear() Q_DECL_OVERRIDE;
+ void clear() override;
void proceedWithTearDown();
/**
- * Saves the bookmarks and indicates to other applications that the
- * state of the bookmarks has been changed. Is only called by the
- * timeout of m_saveBookmarksTimer to prevent unnecessary savings.
+ * @brief Remove item from bookmark
+ *
+ * This function remove the index from bookmark file permanently
+ *
+ * @param index - the item to be removed
*/
- void saveBookmarks();
+ void deleteItem(int index);
+
+ /**
+ * Force a sync on the bookmarks and indicates to other applications that the
+ * state of the bookmarks has been changed.
+ */
+ void refresh();
+
+ bool isDir(int index) const override;
+
+
+ KFilePlacesModel::GroupType groupType(int row) const;
+ bool isGroupHidden(KFilePlacesModel::GroupType type) const;
+ void setGroupHidden(KFilePlacesModel::GroupType type, bool hidden);
- bool isDir(int index) const Q_DECL_OVERRIDE;
signals:
void errorMessage(const QString& message);
void storageSetupDone(int index, bool success);
void storageTearDownExternallyRequested(const QString& mountPath);
protected:
- virtual void onItemInserted(int index) Q_DECL_OVERRIDE;
- virtual void onItemRemoved(int index, KStandardItem* removedItem) Q_DECL_OVERRIDE;
- virtual void onItemChanged(int index, const QSet<QByteArray>& changedRoles) Q_DECL_OVERRIDE;
+ void onItemInserted(int index) override;
+ void onItemRemoved(int index, KStandardItem* removedItem) override;
+ void onItemChanged(int index, const QSet<QByteArray>& changedRoles) override;
private slots:
- void slotDeviceAdded(const QString& udi);
- void slotDeviceRemoved(const QString& udi);
void slotStorageTearDownDone(Solid::ErrorType error, const QVariant& errorData);
void slotStorageSetupDone(Solid::ErrorType error, const QVariant& errorData, const QString& udi);
- void hideItem();
- /**
- * Updates the bookmarks from the model corresponding to the changed
- * bookmarks stored by the bookmark-manager. Is called whenever the bookmarks
- * have been changed by another application.
- */
- void updateBookmarks();
+ // source model control
+ void onSourceModelRowsInserted(const QModelIndex &parent, int first, int last);
+ void onSourceModelRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last);
+ void onSourceModelRowsAboutToBeMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row);
+ void onSourceModelRowsMoved(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row);
+ void onSourceModelDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles);
+ void onSourceModelGroupHiddenChanged(KFilePlacesModel::GroupType group, bool hidden);
private:
- struct SystemBookmarkData;
+ /**
+ * Remove bookmarks created by the previous version of dolphin that are
+ * not valid anymore
+ */
+ void cleanupBookmarks();
/**
* Loads the bookmarks from the bookmark-manager and creates items for
*/
void loadBookmarks();
- /**
- * @return True, if the bookmark can be accepted in the context of the
- * current application (e.g. bookmarks from other applications
- * will be ignored).
- */
- bool acceptBookmark(const KBookmark& bookmark,
- const QSet<QString>& availableDevices) const;
-
- /**
- * Creates a PlacesItem for a system-bookmark:
- * - PlacesItem::isSystemItem() will return true
- * - Default view-properties will be created for "Search For" items
- * The item is not inserted to the model yet.
- */
- PlacesItem* createSystemPlacesItem(const SystemBookmarkData& data);
-
- /**
- * Creates system bookmarks that are shown per default and can
- * only be hidden but not removed. The result will be stored
- * in m_systemBookmarks.
- */
- void createSystemBookmarks();
-
- void initializeAvailableDevices();
-
- /**
- * @param index Item index related to the model.
- * @return Corresponding index related to m_bookmarkedItems.
- */
- int bookmarkIndex(int index) const;
-
- /**
- * Marks the item with the index \a index as hidden and
- * removes it from the model so that it gets invisible.
- */
- void hideItem(int index);
-
QString internalMimeType() const;
/**
static bool equalBookmarkIdentifiers(const KBookmark& b1, const KBookmark& b2);
/**
- * @return URL using the timeline-protocol for searching (see convertedUrl()).
- */
- static QUrl createTimelineUrl(const QUrl& url);
-
- /**
- * Helper method for createTimelineUrl().
- * @return String that represents a date-path in the format that
- * the timeline-protocol expects.
- */
- static QString timelineDateString(int year, int month, int day = 0);
-
- /**
- * @return URL that can be listed by KIO and results in searching
- * for a given term. The URL \a url represents a places-internal
- * URL like e.g. "search:/documents" (see convertedUrl()).
- */
- static QUrl createSearchUrl(const QUrl& url);
-
-#ifdef HAVE_BALOO
- /**
- * Helper method for createSearchUrl()
- * @return URL that can be listed by KIO and results in searching
- * for the given type
+ * Appends the item \a item as last element of the group
+ * the item belongs to. If no item with the same group is
+ * present, the item gets appended as last element of the
+ * model. PlacesItemModel takes the ownership
+ * of the item.
*/
- static QUrl searchUrlForType(const QString& type);
-#endif
+ void insertSortedItem(PlacesItem* item);
#ifdef PLACESITEMMODEL_DEBUG
void showModelState();
#endif
+ PlacesItem *itemFromBookmark(const KBookmark &bookmark) const;
+
+ void addItemFromSourceModel(const QModelIndex &index);
+ void removeItemByIndex(const QModelIndex &mapToSource);
+
+ QString bookmarkId(const KBookmark &bookmark) const;
+ void initializeDefaultViewProperties() const;
+
+ int mapFromSource(const QModelIndex &index) const;
+ QModelIndex mapToSource(int row) const;
+
+ static void updateItem(PlacesItem *item, const QModelIndex &index);
+
private:
- bool m_fileIndexingEnabled;
bool m_hiddenItemsShown;
- QSet<QString> m_availableDevices;
- Solid::Predicate m_predicate;
- KBookmarkManager* m_bookmarkManager;
-
- struct SystemBookmarkData
- {
- SystemBookmarkData(const QUrl& url,
- const QString& icon,
- const QString& text) :
- url(url), icon(icon), text(text) {}
- QUrl url;
- QString icon;
- QString text;
- };
-
- QList<SystemBookmarkData> m_systemBookmarks;
- QHash<QUrl, int> m_systemBookmarksIndexes;
-
- // Contains hidden and unhidden items that are stored as
- // bookmark (the model itself only contains items that
- // are shown in the view). If an entry is 0, then the
- // places-item is part of the model. If an entry is not
- // 0, the item is hidden and not part of the model.
- QList<PlacesItem*> m_bookmarkedItems;
-
- // Index of the hidden item that should be removed in
- // removeHiddenItem(). The removing must be done
- // asynchronously as in the scope of onItemChanged()
- // removing an item is not allowed.
- int m_hiddenItemToRemove;
-
Solid::StorageAccess *m_deviceToTearDown;
- QTimer* m_updateBookmarksTimer;
-
QHash<QObject*, int> m_storageSetupInProgress;
+
+ QScopedPointer<KFilePlacesModel> m_sourceModel;
+
+ QVector<QPersistentModelIndex> m_indexMap;
};
#endif
public:
explicit PlacesItemSignalHandler(PlacesItem* item, QObject* parent = nullptr);
- virtual ~PlacesItemSignalHandler();
+ ~PlacesItemSignalHandler() override;
public slots:
/**
#include <KIO/DropJob>
#include <KIO/EmptyTrashJob>
#include <KIO/JobUiDelegate>
+#include <KFilePlacesModel>
#include <KJobWidgets>
#include <KLocalizedString>
#include <KIconLoader>
QMenu menu(this);
- QAction* emptyTrashAction = 0;
- QAction* editAction = 0;
- QAction* teardownAction = 0;
- QAction* ejectAction = 0;
+ QAction* emptyTrashAction = nullptr;
+ QAction* editAction = nullptr;
+ QAction* teardownAction = nullptr;
+ QAction* ejectAction = nullptr;
const QString label = item->text();
editAction = menu.addAction(QIcon::fromTheme("document-properties"), i18nc("@item:inmenu", "Edit..."));
}
- QAction* removeAction = 0;
+ QAction* removeAction = nullptr;
if (!isDevice && !item->isSystemItem()) {
removeAction = menu.addAction(QIcon::fromTheme(QStringLiteral("edit-delete")), i18nc("@item:inmenu", "Remove"));
}
hideAction->setCheckable(true);
hideAction->setChecked(item->isHidden());
+ buildGroupContextMenu(&menu, index);
+
QAction* action = menu.exec(pos.toPoint());
if (action) {
if (action == emptyTrashAction) {
if (action == editAction) {
editEntry(index);
} else if (action == removeAction) {
- m_model->removeItem(index);
- m_model->saveBookmarks();
+ m_model->deleteItem(index);
} else if (action == hideAction) {
item->setHidden(hideAction->isChecked());
- m_model->saveBookmarks();
} else if (action == openInNewWindowAction) {
- Dolphin::openNewWindow({PlacesItemModel::convertedUrl(m_model->data(index).value("url").toUrl())}, this);
+ Dolphin::openNewWindow({KFilePlacesModel::convertedUrl(m_model->data(index).value("url").toUrl())}, this);
} else if (action == openInNewTabAction) {
// TriggerItem does set up the storage first and then it will
// emit the slotItemMiddleClicked signal, because of Qt::MiddleButton.
QAction* addAction = menu.addAction(QIcon::fromTheme(QStringLiteral("document-new")), i18nc("@item:inmenu", "Add Entry..."));
- QAction* showAllAction = 0;
+ QAction* showAllAction = nullptr;
if (m_model->hiddenCount() > 0) {
showAllAction = menu.addAction(i18nc("@item:inmenu", "Show All Entries"));
showAllAction->setCheckable(true);
showAllAction->setChecked(m_model->hiddenItemsShown());
}
+ buildGroupContextMenu(&menu, m_controller->indexCloseToMousePressedPosition());
+
QMenu* iconSizeSubMenu = new QMenu(i18nc("@item:inmenu", "Icon Size"), &menu);
struct IconSizeInfo
selectClosestItem();
}
+QAction *PlacesPanel::buildGroupContextMenu(QMenu *menu, int index)
+{
+ if (index == -1) {
+ return nullptr;
+ }
+
+ KFilePlacesModel::GroupType groupType = m_model->groupType(index);
+ QAction *hideGroupAction = menu->addAction(i18nc("@item:inmenu", "Hide Section '%1'", m_model->item(index)->group()));
+ hideGroupAction->setCheckable(true);
+ hideGroupAction->setChecked(m_model->isGroupHidden(groupType));
+
+ connect(hideGroupAction, &QAction::triggered, this, [this, groupType, hideGroupAction]{
+ m_model->setGroupHidden(groupType, hideGroupAction->isChecked());
+ });
+
+ return hideGroupAction;
+}
+
void PlacesPanel::slotItemDropEvent(int index, QGraphicsSceneDragDropEvent* event)
{
if (index < 0) {
}
const PlacesItem* destItem = m_model->placesItem(index);
- const PlacesItem::GroupType group = destItem->groupType();
- if (group == PlacesItem::SearchForType || group == PlacesItem::RecentlySavedType) {
+
+ if (destItem->isSearchOrTimelineUrl()) {
return;
}
delete m_itemDropEvent;
m_itemDropEventIndex = -1;
- m_itemDropEventMimeData = 0;
- m_itemDropEvent = 0;
+ m_itemDropEventMimeData = nullptr;
+ m_itemDropEvent = nullptr;
}
}
void PlacesPanel::slotAboveItemDropEvent(int index, QGraphicsSceneDragDropEvent* event)
{
m_model->dropMimeDataBefore(index, event->mimeData());
- m_model->saveBookmarks();
}
void PlacesPanel::slotUrlsDropped(const QUrl& dest, QDropEvent* event, QWidget* parent)
emit errorMessage(job->errorString());
}
// as long as KIO doesn't do this, do it ourselves
- KNotification::event(QStringLiteral("Trash: emptied"), QString(), QPixmap(), 0, KNotification::DefaultEvent);
+ KNotification::event(QStringLiteral("Trash: emptied"), QString(), QPixmap(), nullptr, KNotification::DefaultEvent);
}
void PlacesPanel::slotStorageSetupDone(int index, bool success)
dialog->setAllowGlobal(true);
dialog->setUrl(url);
if (dialog->exec() == QDialog::Accepted) {
- PlacesItem* item = m_model->createPlacesItem(dialog->text(), dialog->url(), dialog->icon());
- m_model->appendItemToGroup(item);
- m_model->saveBookmarks();
+ m_model->createPlacesItem(dialog->text(), dialog->url(), dialog->icon());
}
delete dialog;
oldItem->setText(dialog->text());
oldItem->setUrl(dialog->url());
oldItem->setIcon(dialog->icon());
- m_model->saveBookmarks();
+ m_model->refresh();
}
}
const QUrl url = m_model->data(index).value("url").toUrl();
if (!url.isEmpty()) {
if (button == Qt::MiddleButton) {
- emit placeMiddleClicked(PlacesItemModel::convertedUrl(url));
+ emit placeMiddleClicked(KFilePlacesModel::convertedUrl(url));
} else {
- emit placeActivated(PlacesItemModel::convertedUrl(url));
+ emit placeActivated(KFilePlacesModel::convertedUrl(url));
}
}
}
class PlacesView;
class QGraphicsSceneDragDropEvent;
class KJob;
+class QMenu;
/**
* @brief Combines bookmarks and mounted devices as list.
*/
public:
explicit PlacesPanel(QWidget* parent);
- virtual ~PlacesPanel();
+ ~PlacesPanel() override;
void proceedWithTearDown();
signals:
void storageTearDownExternallyRequested(const QString& mountPath);
protected:
- virtual bool urlChanged() Q_DECL_OVERRIDE;
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
+ bool urlChanged() override;
+ void showEvent(QShowEvent* event) override;
public slots:
- virtual void readSettings() Q_DECL_OVERRIDE;
+ void readSettings() override;
private slots:
void slotItemActivated(int index);
void triggerItem(int index, Qt::MouseButton button);
+ QAction* buildGroupContextMenu(QMenu* menu, int index);
+
private:
KItemListController* m_controller;
PlacesItemModel* m_model;
TerminalPanel::TerminalPanel(QWidget* parent) :
Panel(parent),
m_clearTerminal(true),
- m_mostLocalUrlJob(0),
- m_layout(0),
- m_terminal(0),
- m_terminalWidget(0),
- m_konsolePart(0),
+ m_mostLocalUrlJob(nullptr),
+ m_layout(nullptr),
+ m_terminal(nullptr),
+ m_terminalWidget(nullptr),
+ m_konsolePart(nullptr),
m_konsolePartCurrentDirectory(),
m_sendCdToTerminalHistory()
{
void TerminalPanel::terminalExited()
{
- m_terminal = 0;
+ m_terminal = nullptr;
emit hideTerminalPanel();
}
+bool TerminalPanel::isHiddenInVisibleWindow()
+{
+ return parentWidget()
+ && parentWidget()->isHidden()
+ && m_terminal
+ && (m_terminal->foregroundProcessId() == -1);
+}
+
void TerminalPanel::dockVisibilityChanged()
{
// Only react when the DockWidget itself (not some parent) is hidden. This way we don't
// respond when e.g. Dolphin is minimized.
- if (parentWidget() && parentWidget()->isHidden() &&
- m_terminal && (m_terminal->foregroundProcessId() == -1)) {
+ if (isHiddenInVisibleWindow()) {
// Make sure that the following "cd /" command will not affect the view.
disconnect(m_konsolePart, SIGNAL(currentDirectoryChanged(QString)),
this, SLOT(slotKonsolePartCurrentDirectoryChanged(QString)));
if (!m_terminal) {
m_clearTerminal = true;
- KPluginFactory* factory = 0;
+ KPluginFactory* factory = nullptr;
KService::Ptr service = KService::serviceByDesktopName(QStringLiteral("konsolepart"));
if (service) {
factory = KPluginLoader(service->library()).factory();
}
- m_konsolePart = factory ? (factory->create<KParts::ReadOnlyPart>(this)) : 0;
+ m_konsolePart = factory ? (factory->create<KParts::ReadOnlyPart>(this)) : nullptr;
if (m_konsolePart) {
connect(m_konsolePart, &KParts::ReadOnlyPart::destroyed, this, &TerminalPanel::terminalExited);
m_terminalWidget = m_konsolePart->widget();
void TerminalPanel::changeDir(const QUrl& url)
{
delete m_mostLocalUrlJob;
- m_mostLocalUrlJob = 0;
+ m_mostLocalUrlJob = nullptr;
if (url.isLocalFile()) {
sendCdToTerminal(url.toLocalFile());
sendCdToTerminal(url.toLocalFile());
}
- m_mostLocalUrlJob = 0;
+ m_mostLocalUrlJob = nullptr;
}
void TerminalPanel::slotKonsolePartCurrentDirectoryChanged(const QString& dir)
public:
explicit TerminalPanel(QWidget* parent = nullptr);
- virtual ~TerminalPanel();
+ ~TerminalPanel() override;
/**
* @brief This function is used to set the terminal panels's cwd to
*/
void goHome();
QString currentWorkingDirectory();
+ bool isHiddenInVisibleWindow();
public slots:
void terminalExited();
void changeUrl(const QUrl& url);
protected:
- virtual bool urlChanged() Q_DECL_OVERRIDE;
+ bool urlChanged() override;
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
+ void showEvent(QShowEvent* event) override;
private slots:
void slotMostLocalUrlResult(KJob* job);
public:
explicit DolphinFacetsWidget(QWidget* parent = nullptr);
- virtual ~DolphinFacetsWidget();
+ ~DolphinFacetsWidget() override;
QString ratingTerm() const;
QString facetType() const;
QWidget(parent),
m_startedSearching(false),
m_active(true),
- m_topLayout(0),
- m_searchLabel(0),
- m_searchInput(0),
- m_saveSearchAction(0),
- m_optionsScrollArea(0),
- m_fileNameButton(0),
- m_contentButton(0),
- m_separator(0),
- m_fromHereButton(0),
- m_everywhereButton(0),
- m_facetsToggleButton(0),
- m_facetsWidget(0),
+ m_topLayout(nullptr),
+ m_searchLabel(nullptr),
+ m_searchInput(nullptr),
+ m_saveSearchAction(nullptr),
+ m_optionsScrollArea(nullptr),
+ m_fileNameButton(nullptr),
+ m_contentButton(nullptr),
+ m_separator(nullptr),
+ m_fromHereButton(nullptr),
+ m_everywhereButton(nullptr),
+ m_facetsToggleButton(nullptr),
+ m_facetsWidget(nullptr),
m_searchPath(),
- m_startSearchTimer(0)
+ m_startSearchTimer(nullptr)
{
}
if (searchURL.isValid()) {
PlacesItemModel model;
const QString label = i18n("Search for %1 in %2", text(), searchPath().fileName());
- PlacesItem* item = model.createPlacesItem(label,
- searchURL,
- QStringLiteral("folder-saved-search-symbolic"));
- model.appendItemToGroup(item);
- model.saveBookmarks();
+ model.createPlacesItem(label,
+ searchURL,
+ QStringLiteral("folder-saved-search-symbolic"));
}
}
Q_OBJECT
public:
- explicit DolphinSearchBox(QWidget* parent = 0);
- virtual ~DolphinSearchBox();
+ explicit DolphinSearchBox(QWidget* parent = nullptr);
+ ~DolphinSearchBox() override;
/**
* Sets the text that should be used as input for
bool isActive() const;
protected:
- virtual bool event(QEvent* event) Q_DECL_OVERRIDE;
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
- virtual void hideEvent(QHideEvent* event) Q_DECL_OVERRIDE;
- virtual void keyReleaseEvent(QKeyEvent* event) Q_DECL_OVERRIDE;
- virtual bool eventFilter(QObject* obj, QEvent* event) Q_DECL_OVERRIDE;
+ bool event(QEvent* event) override;
+ void showEvent(QShowEvent* event) override;
+ void hideEvent(QHideEvent* event) override;
+ void keyReleaseEvent(QKeyEvent* event) override;
+ bool eventFilter(QObject* obj, QEvent* event) override;
signals:
/**
const QList<QByteArray>& visibleRoles) :
QDialog(parent),
m_visibleRoles(visibleRoles),
- m_listWidget(0)
+ m_listWidget(nullptr)
{
setWindowTitle(i18nc("@title:window", "Additional Information"));
setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
public:
AdditionalInfoDialog(QWidget* parent, const QList<QByteArray>& visibleRoles);
- virtual ~AdditionalInfoDialog();
+ ~AdditionalInfoDialog() override;
QList<QByteArray> visibleRoles() const;
public slots:
- void accept() Q_DECL_OVERRIDE;
+ void accept() override;
private:
QList<QByteArray> m_visibleRoles;
ApplyViewPropsJob::ApplyViewPropsJob(const QUrl& dir,
const ViewProperties& viewProps) :
KIO::Job(),
- m_viewProps(0),
+ m_viewProps(nullptr),
m_progress(0),
m_dir(dir)
{
ApplyViewPropsJob::~ApplyViewPropsJob()
{
delete m_viewProps; // the properties are written by the destructor
- m_viewProps = 0;
+ m_viewProps = nullptr;
}
void ApplyViewPropsJob::slotEntries(KIO::Job*, const KIO::UDSEntryList& list)
* sub directories.
*/
ApplyViewPropsJob(const QUrl& dir, const ViewProperties& viewProps);
- virtual ~ApplyViewPropsJob();
+ ~ApplyViewPropsJob() override;
int progress() const;
private slots:
- virtual void slotResult(KJob* job) Q_DECL_OVERRIDE;
+ void slotResult(KJob* job) override;
void slotEntries(KIO::Job*, const KIO::UDSEntryList&);
private:
<entry name="PreviewsShown" type="Bool" >
<label context="@label">Previews shown</label>
<whatsthis context="@info:whatsthis">When this option is enabled, a preview of the file content is shown as an icon.</whatsthis>
- <default>false</default>
+ <default>true</default>
</entry>
<entry name="GroupedSorting" type="Bool" >
Q_OBJECT
public:
- explicit DolphinSettingsDialog(const QUrl& url, QWidget* parent = 0);
- virtual ~DolphinSettingsDialog();
+ explicit DolphinSettingsDialog(const QUrl& url, QWidget* parent = nullptr);
+ ~DolphinSettingsDialog() override;
signals:
void settingsChanged();
public:
BehaviorSettingsPage(const QUrl &url, QWidget* parent);
- virtual ~BehaviorSettingsPage();
+ ~BehaviorSettingsPage() override;
/** @see SettingsPageBase::applySettings() */
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** @see SettingsPageBase::restoreDefaults() */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
private:
void loadSettings();
ConfigurePreviewPluginDialog(const QString& pluginName,
const QString& desktopEntryName,
QWidget* parent);
- virtual ~ConfigurePreviewPluginDialog() = default;
+ ~ConfigurePreviewPluginDialog() override = default;
};
#endif
ConfirmationsSettingsPage::ConfirmationsSettingsPage(QWidget* parent) :
SettingsPageBase(parent),
- m_confirmMoveToTrash(0),
- m_confirmDelete(0),
- m_confirmClosingMultipleTabs(0)
+ m_confirmMoveToTrash(nullptr),
+ m_confirmDelete(nullptr),
+ m_confirmClosingMultipleTabs(nullptr)
{
QVBoxLayout* topLayout = new QVBoxLayout(this);
public:
ConfirmationsSettingsPage(QWidget* parent);
- virtual ~ConfirmationsSettingsPage();
+ ~ConfirmationsSettingsPage() override;
/** @see SettingsPageBase::applySettings() */
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** @see SettingsPageBase::restoreDefaults() */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
private:
void loadSettings();
m_pages.append(confirmationsPage);
m_pages.append(statusBarPage);
- topLayout->addWidget(tabWidget, 0, 0);
+ topLayout->addWidget(tabWidget, 0, nullptr);
}
GeneralSettingsPage::~GeneralSettingsPage()
public:
GeneralSettingsPage(const QUrl& url, QWidget* parent);
- virtual ~GeneralSettingsPage();
+ ~GeneralSettingsPage() override;
/** @see SettingsPageBase::applySettings() */
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** @see SettingsPageBase::restoreDefaults() */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
private:
QList<SettingsPageBase*> m_pages;
#include <KLocalizedString>
#include <KServiceTypeTrader>
#include <KService>
+#include <KIO/PreviewJob>
#include <settings/serviceitemdelegate.h>
#include <settings/servicemodel.h>
PreviewsSettingsPage::PreviewsSettingsPage(QWidget* parent) :
SettingsPageBase(parent),
m_initialized(false),
- m_listView(0),
+ m_listView(nullptr),
m_enabledPreviewPlugins(),
- m_remoteFileSizeBox(0)
+ m_remoteFileSizeBox(nullptr)
{
QVBoxLayout* topLayout = new QVBoxLayout(this);
void PreviewsSettingsPage::loadSettings()
{
- KConfigGroup globalConfig(KSharedConfig::openConfig(), "PreviewSettings");
- m_enabledPreviewPlugins = globalConfig.readEntry("Plugins", QStringList()
- << QStringLiteral("directorythumbnail")
- << QStringLiteral("imagethumbnail")
- << QStringLiteral("jpegthumbnail"));
+ const KConfigGroup globalConfig(KSharedConfig::openConfig(), QStringLiteral("PreviewSettings"));
+ m_enabledPreviewPlugins = globalConfig.readEntry("Plugins", KIO::PreviewJob::defaultPlugins());
const qulonglong defaultRemotePreview = static_cast<qulonglong>(MaxRemotePreviewSize) * 1024 * 1024;
const qulonglong maxRemoteByteSize = globalConfig.readEntry("MaximumRemoteSize", defaultRemotePreview);
public:
PreviewsSettingsPage(QWidget* parent);
- virtual ~PreviewsSettingsPage();
+ ~PreviewsSettingsPage() override;
/**
* Applies the general settings for the view modes
* The settings are persisted automatically when
* closing Dolphin.
*/
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** Restores the settings to default values. */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
protected:
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
+ void showEvent(QShowEvent* event) override;
private slots:
void configureService(const QModelIndex& index);
public:
StatusBarSettingsPage(QWidget* parent);
- virtual ~StatusBarSettingsPage();
+ ~StatusBarSettingsPage() override;
/** @see SettingsPageBase::applySettings() */
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** @see SettingsPageBase::restoreDefaults() */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
private:
void loadSettings();
m_pages.append(previewsPage);
m_pages.append(confirmationsPage);
- topLayout->addWidget(tabWidget, 0, 0);
+ topLayout->addWidget(tabWidget, 0, nullptr);
}
DolphinGeneralConfigModule::~DolphinGeneralConfigModule()
public:
DolphinGeneralConfigModule(QWidget* parent, const QVariantList& args);
- virtual ~DolphinGeneralConfigModule();
+ ~DolphinGeneralConfigModule() override;
- virtual void save() Q_DECL_OVERRIDE;
- virtual void defaults() Q_DECL_OVERRIDE;
+ void save() override;
+ void defaults() override;
private:
QList<SettingsPageBase*> m_pages;
DolphinNavigationConfigModule::DolphinNavigationConfigModule(QWidget* parent, const QVariantList& args) :
KCModule(parent),
- m_navigation(0)
+ m_navigation(nullptr)
{
Q_UNUSED(args);
m_navigation = new NavigationSettingsPage(this);
connect(m_navigation, &NavigationSettingsPage::changed, this, static_cast<void(DolphinNavigationConfigModule::*)()>(&DolphinNavigationConfigModule::changed));
- topLayout->addWidget(m_navigation, 0, 0);
+ topLayout->addWidget(m_navigation, 0, nullptr);
}
DolphinNavigationConfigModule::~DolphinNavigationConfigModule()
public:
DolphinNavigationConfigModule(QWidget* parent, const QVariantList& args);
- virtual ~DolphinNavigationConfigModule();
+ ~DolphinNavigationConfigModule() override;
- virtual void save() Q_DECL_OVERRIDE;
- virtual void defaults() Q_DECL_OVERRIDE;
+ void save() override;
+ void defaults() override;
private:
NavigationSettingsPage* m_navigation;
DolphinServicesConfigModule::DolphinServicesConfigModule(QWidget* parent, const QVariantList& args) :
KCModule(parent),
- m_services(0)
+ m_services(nullptr)
{
Q_UNUSED(args);
m_services = new ServicesSettingsPage(this);
connect(m_services, &ServicesSettingsPage::changed, this, static_cast<void(DolphinServicesConfigModule::*)()>(&DolphinServicesConfigModule::changed));
- topLayout->addWidget(m_services, 0, 0);
+ topLayout->addWidget(m_services, 0, nullptr);
}
DolphinServicesConfigModule::~DolphinServicesConfigModule()
public:
DolphinServicesConfigModule(QWidget* parent, const QVariantList& args);
- virtual ~DolphinServicesConfigModule();
+ ~DolphinServicesConfigModule() override;
- virtual void save() Q_DECL_OVERRIDE;
- virtual void defaults() Q_DECL_OVERRIDE;
+ void save() override;
+ void defaults() override;
private:
ServicesSettingsPage* m_services;
m_tabs.append(compactTab);
m_tabs.append(detailsTab);
- topLayout->addWidget(tabWidget, 0, 0);
+ topLayout->addWidget(tabWidget, 0, nullptr);
}
DolphinViewModesConfigModule::~DolphinViewModesConfigModule()
public:
DolphinViewModesConfigModule(QWidget* parent, const QVariantList& args);
- virtual ~DolphinViewModesConfigModule();
+ ~DolphinViewModesConfigModule() override;
- virtual void save() Q_DECL_OVERRIDE;
- virtual void defaults() Q_DECL_OVERRIDE;
+ void save() override;
+ void defaults() override;
private:
void reparseConfiguration();
NavigationSettingsPage::NavigationSettingsPage(QWidget* parent) :
SettingsPageBase(parent),
- m_openArchivesAsFolder(0),
- m_autoExpandFolders(0)
+ m_openArchivesAsFolder(nullptr),
+ m_autoExpandFolders(nullptr)
{
QVBoxLayout* topLayout = new QVBoxLayout(this);
QWidget* vBox = new QWidget(this);
public:
NavigationSettingsPage(QWidget* parent);
- virtual ~NavigationSettingsPage();
+ ~NavigationSettingsPage() override;
/** @see SettingsPageBase::applySettings() */
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** @see SettingsPageBase::restoreDefaults() */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
private:
void loadSettings();
Q_OBJECT
public:
- explicit ServiceItemDelegate(QAbstractItemView* itemView, QObject* parent = 0);
- virtual ~ServiceItemDelegate();
+ explicit ServiceItemDelegate(QAbstractItemView* itemView, QObject* parent = nullptr);
+ ~ServiceItemDelegate() override;
- virtual QSize sizeHint(const QStyleOptionViewItem &option,
- const QModelIndex &index) const Q_DECL_OVERRIDE;
+ QSize sizeHint(const QStyleOptionViewItem &option,
+ const QModelIndex &index) const override;
- virtual void paint(QPainter* painter, const QStyleOptionViewItem& option,
- const QModelIndex& index) const Q_DECL_OVERRIDE;
+ void paint(QPainter* painter, const QStyleOptionViewItem& option,
+ const QModelIndex& index) const override;
- virtual QList<QWidget*> createItemWidgets(const QModelIndex&) const Q_DECL_OVERRIDE;
+ QList<QWidget*> createItemWidgets(const QModelIndex&) const override;
- virtual void updateItemWidgets(const QList<QWidget*> widgets,
+ void updateItemWidgets(const QList<QWidget*> widgets,
const QStyleOptionViewItem& option,
- const QPersistentModelIndex& index) const Q_DECL_OVERRIDE;
+ const QPersistentModelIndex& index) const override;
signals:
void requestServiceConfiguration(const QModelIndex& index);
ConfigurableRole
};
- explicit ServiceModel(QObject* parent = 0);
- virtual ~ServiceModel();
+ explicit ServiceModel(QObject* parent = nullptr);
+ ~ServiceModel() override;
- virtual bool insertRows(int row, int count, const QModelIndex & parent = QModelIndex()) Q_DECL_OVERRIDE;
- virtual bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) Q_DECL_OVERRIDE;
- virtual QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const Q_DECL_OVERRIDE;
- virtual int rowCount(const QModelIndex& parent = QModelIndex()) const Q_DECL_OVERRIDE;
+ bool insertRows(int row, int count, const QModelIndex & parent = QModelIndex()) override;
+ bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override;
+ QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
+ int rowCount(const QModelIndex& parent = QModelIndex()) const override;
private:
struct ServiceItem
ServicesSettingsPage::ServicesSettingsPage(QWidget* parent) :
SettingsPageBase(parent),
m_initialized(false),
- m_serviceModel(0),
- m_sortModel(0),
- m_listView(0),
+ m_serviceModel(nullptr),
+ m_sortModel(nullptr),
+ m_listView(nullptr),
m_enabledVcsPlugins()
{
QVBoxLayout* topLayout = new QVBoxLayout(this);
public:
ServicesSettingsPage(QWidget* parent);
- virtual ~ServicesSettingsPage();
+ ~ServicesSettingsPage() override;
/** @see SettingsPageBase::applySettings() */
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** @see SettingsPageBase::restoreDefaults() */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
protected:
- virtual void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
+ void showEvent(QShowEvent* event) override;
private slots:
/**
Q_OBJECT
public:
- explicit SettingsPageBase(QWidget* parent = 0);
- virtual ~SettingsPageBase();
+ explicit SettingsPageBase(QWidget* parent = nullptr);
+ ~SettingsPageBase() override;
/**
* Must be implemented by a derived class to
public:
StartupSettingsPage(const QUrl& url, QWidget* parent);
- virtual ~StartupSettingsPage();
+ ~StartupSettingsPage() override;
/** @see SettingsPageBase::applySettings() */
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** @see SettingsPageBase::restoreDefaults() */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
private slots:
void slotSettingsChanged();
public:
TrashSettingsPage(QWidget* parent);
- virtual ~TrashSettingsPage();
+ ~TrashSettingsPage() override;
/** @see SettingsPageBase::applySettings() */
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** @see SettingsPageBase::restoreDefaults() */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
private:
void loadSettings();
DolphinFontRequester::DolphinFontRequester(QWidget* parent) :
QWidget(parent),
- m_modeCombo(0),
- m_chooseFontButton(0),
+ m_modeCombo(nullptr),
+ m_chooseFontButton(nullptr),
m_mode(SystemFont),
m_customFont()
{
};
DolphinFontRequester(QWidget* parent);
- virtual ~DolphinFontRequester();
+ ~DolphinFontRequester() override;
void setMode(Mode mode);
Mode mode() const;
m_tabs.append(compactTab);
m_tabs.append(detailsTab);
- topLayout->addWidget(tabWidget, 0, 0);
+ topLayout->addWidget(tabWidget, 0, nullptr);
}
ViewSettingsPage::~ViewSettingsPage()
public:
ViewSettingsPage(QWidget* parent);
- virtual ~ViewSettingsPage();
+ ~ViewSettingsPage() override;
/** @see SettingsPageBase::applySettings() */
- virtual void applySettings() Q_DECL_OVERRIDE;
+ void applySettings() override;
/** @see SettingsPageBase::restoreDefaults() */
- virtual void restoreDefaults() Q_DECL_OVERRIDE;
+ void restoreDefaults() override;
private:
QList<ViewSettingsTab*> m_tabs;
ViewSettingsTab::ViewSettingsTab(Mode mode, QWidget* parent) :
QWidget(parent),
m_mode(mode),
- m_defaultSizeSlider(0),
- m_previewSizeSlider(0),
- m_fontRequester(0),
- m_widthBox(0),
- m_maxLinesBox(0),
- m_expandableFolders(0)
+ m_defaultSizeSlider(nullptr),
+ m_previewSizeSlider(nullptr),
+ m_fontRequester(nullptr),
+ m_widthBox(nullptr),
+ m_maxLinesBox(nullptr),
+ m_expandableFolders(nullptr)
{
QVBoxLayout* topLayout = new QVBoxLayout(this);
void ViewSettingsTab::restoreDefaultSettings()
{
- KConfigSkeleton* settings = 0;
+ KConfigSkeleton* settings = nullptr;
switch (m_mode) {
case IconsMode: settings = IconsModeSettings::self(); break;
case CompactMode: settings = CompactModeSettings::self(); break;
DetailsMode
};
- explicit ViewSettingsTab(Mode mode, QWidget* parent = 0);
- virtual ~ViewSettingsTab();
+ explicit ViewSettingsTab(Mode mode, QWidget* parent = nullptr);
+ ~ViewSettingsTab() override;
void applySettings();
void restoreDefaultSettings();
QDialog(dolphinView),
m_isDirty(false),
m_dolphinView(dolphinView),
- m_viewProps(0),
- m_viewMode(0),
- m_sortOrder(0),
- m_sorting(0),
- m_sortFoldersFirst(0),
- m_previewsShown(0),
- m_showInGroups(0),
- m_showHiddenFiles(0),
- m_additionalInfo(0),
- m_applyToCurrentFolder(0),
- m_applyToSubFolders(0),
- m_applyToAllFolders(0),
- m_useAsDefault(0)
+ m_viewProps(nullptr),
+ m_viewMode(nullptr),
+ m_sortOrder(nullptr),
+ m_sorting(nullptr),
+ m_sortFoldersFirst(nullptr),
+ m_previewsShown(nullptr),
+ m_showInGroups(nullptr),
+ m_showHiddenFiles(nullptr),
+ m_additionalInfo(nullptr),
+ m_applyToCurrentFolder(nullptr),
+ m_applyToSubFolders(nullptr),
+ m_applyToAllFolders(nullptr),
+ m_useAsDefault(nullptr)
{
Q_ASSERT(dolphinView);
const bool useGlobalViewProps = GeneralSettings::globalViewProps();
{
m_isDirty = false;
delete m_viewProps;
- m_viewProps = 0;
+ m_viewProps = nullptr;
KConfigGroup dialogConfig(KSharedConfig::openConfig(QStringLiteral("dolphinrc")), "ViewPropertiesDialog");
KWindowConfig::saveWindowSize(windowHandle(), dialogConfig);
public:
explicit ViewPropertiesDialog(DolphinView* dolphinView);
- virtual ~ViewPropertiesDialog();
+ ~ViewPropertiesDialog() override;
public slots:
- void accept() Q_DECL_OVERRIDE;
+ void accept() override;
private slots:
void slotApply();
const ViewProperties& viewProps) :
QDialog(parent),
m_dir(dir),
- m_viewProps(0),
- m_label(0),
- m_progressBar(0),
- m_dirSizeJob(0),
- m_applyViewPropsJob(0),
- m_timer(0)
+ m_viewProps(nullptr),
+ m_label(nullptr),
+ m_progressBar(nullptr),
+ m_dirSizeJob(nullptr),
+ m_applyViewPropsJob(nullptr),
+ m_timer(nullptr)
{
const QSize minSize = minimumSize();
setMinimumSize(QSize(320, minSize.height()));
ViewPropsProgressInfo::~ViewPropsProgressInfo()
{
delete m_viewProps;
- m_viewProps = 0;
+ m_viewProps = nullptr;
}
void ViewPropsProgressInfo::closeEvent(QCloseEvent* event)
{
m_timer->stop();
- m_applyViewPropsJob = 0;
+ m_applyViewPropsJob = nullptr;
QDialog::closeEvent(event);
}
{
if (m_dirSizeJob) {
m_dirSizeJob->kill();
- m_dirSizeJob = 0;
+ m_dirSizeJob = nullptr;
}
if (m_applyViewPropsJob) {
m_applyViewPropsJob->kill();
- m_applyViewPropsJob = 0;
+ m_applyViewPropsJob = nullptr;
}
QDialog::reject();
m_label->setText(i18nc("@info:progress", "Folders: %1", subdirs));
m_progressBar->setMaximum(subdirs);
- m_dirSizeJob = 0;
+ m_dirSizeJob = nullptr;
m_applyViewPropsJob = new ApplyViewPropsJob(m_dir, *m_viewProps);
connect(m_applyViewPropsJob, &ApplyViewPropsJob::result,
const QUrl& dir,
const ViewProperties& viewProps);
- virtual ~ViewPropsProgressInfo();
+ ~ViewPropsProgressInfo() override;
protected:
- virtual void closeEvent(QCloseEvent* event) Q_DECL_OVERRIDE;
+ void closeEvent(QCloseEvent* event) override;
public slots:
- void reject() Q_DECL_OVERRIDE;
+ void reject() override;
private slots:
void updateProgress();
#include <QIcon>
#include <KLocalizedString>
+#include <KSqueezedTextLabel>
#include <QMenu>
#include "statusbarspaceinfo.h"
QWidget(parent),
m_text(),
m_defaultText(),
- m_label(0),
- m_spaceInfo(0),
- m_zoomSlider(0),
- m_progressBar(0),
- m_stopButton(0),
+ m_label(nullptr),
+ m_spaceInfo(nullptr),
+ m_zoomSlider(nullptr),
+ m_progressBar(nullptr),
+ m_stopButton(nullptr),
m_progress(100),
- m_showProgressBarTimer(0),
- m_resetToDefaultTextTimer(0),
+ m_showProgressBarTimer(nullptr),
+ m_resetToDefaultTextTimer(nullptr),
m_textTimestamp()
{
// Initialize text label
- m_label = new QLabel(this);
+ m_label = new KSqueezedTextLabel(m_text, this);
m_label->setWordWrap(true);
m_label->setTextFormat(Qt::PlainText);
- m_label->installEventFilter(this);
// Initialize zoom widget
m_zoomSlider = new QSlider(Qt::Horizontal, this);
QHBoxLayout* topLayout = new QHBoxLayout(this);
topLayout->setContentsMargins(2, 0, 2, 0);
topLayout->setSpacing(4);
- topLayout->addWidget(m_label);
- topLayout->addWidget(m_zoomSlider);
- topLayout->addWidget(m_spaceInfo);
+ topLayout->addWidget(m_label, 1);
+ topLayout->addWidget(m_zoomSlider, 1);
+ topLayout->addWidget(m_spaceInfo, 1);
topLayout->addWidget(m_stopButton);
topLayout->addWidget(m_progressTextLabel);
topLayout->addWidget(m_progressBar);
}
}
-bool DolphinStatusBar::eventFilter(QObject* obj, QEvent* event)
-{
- if (obj == m_label && event->type() == QEvent::Resize) {
- updateLabelText();
- }
- return QWidget::eventFilter(obj, event);
-}
-
void DolphinStatusBar::showZoomSliderToolTip(int zoomLevel)
{
updateZoomSliderToolTip(zoomLevel);
void DolphinStatusBar::updateLabelText()
{
const QString text = m_text.isEmpty() ? m_defaultText : m_text;
-
- // Set status bar text and elide it if too long
- QFontMetrics fontMetrics(m_label->font());
- const QString elidedText = fontMetrics.elidedText(text, Qt::ElideRight, m_label->width());
- m_label->setText(elidedText);
-
- // If the text has been elided, set the original text as tooltip
- if (text != elidedText) {
- m_label->setToolTip(Qt::convertFromPlainText(text));
- } else {
- m_label->setToolTip(QString());
- }
+ m_label->setText(text);
}
void DolphinStatusBar::slotResetToDefaultText()
class QToolButton;
class QSlider;
class QTimer;
+class KSqueezedTextLabel;
/**
* @brief Represents the statusbar of a Dolphin view.
public:
DolphinStatusBar(QWidget* parent);
- virtual ~DolphinStatusBar();
+ ~DolphinStatusBar() override;
QString text() const;
void zoomLevelChanged(int zoomLevel);
protected:
- virtual void contextMenuEvent(QContextMenuEvent* event) Q_DECL_OVERRIDE;
- virtual bool eventFilter(QObject* obj, QEvent* event) Q_DECL_OVERRIDE;
+ void contextMenuEvent(QContextMenuEvent* event) override;
private slots:
void showZoomSliderToolTip(int zoomLevel);
private:
QString m_text;
QString m_defaultText;
- QLabel* m_label;
+ KSqueezedTextLabel* m_label;
StatusBarSpaceInfo* m_spaceInfo;
QSlider* m_zoomSlider;
{
Q_OBJECT
- explicit MountPointObserver(const QUrl& url, QObject* parent = 0);
- virtual ~MountPointObserver() {}
+ explicit MountPointObserver(const QUrl& url, QObject* parent = nullptr);
+ ~MountPointObserver() override {}
public:
/**
MountPointObserverCache::MountPointObserverCache() :
m_observerForMountPoint(),
m_mountPointForObserver(),
- m_updateTimer(0)
+ m_updateTimer(nullptr)
{
m_updateTimer = new QTimer(this);
}
Q_OBJECT
MountPointObserverCache();
- virtual ~MountPointObserverCache();
+ ~MountPointObserverCache() override;
public:
static MountPointObserverCache* instance();
SpaceInfoObserver::SpaceInfoObserver(const QUrl& url, QObject* parent) :
QObject(parent),
- m_mountPointObserver(0),
+ m_mountPointObserver(nullptr),
m_dataSize(0),
m_dataAvailable(0)
{
{
if (m_mountPointObserver) {
m_mountPointObserver->deref();
- m_mountPointObserver = 0;
+ m_mountPointObserver = nullptr;
}
}
if (m_mountPointObserver) {
disconnect(m_mountPointObserver, &MountPointObserver::spaceInfoChanged, this, &SpaceInfoObserver::spaceInfoChanged);
m_mountPointObserver->deref();
- m_mountPointObserver = 0;
+ m_mountPointObserver = nullptr;
}
m_mountPointObserver = newObserver;
Q_OBJECT
public:
- explicit SpaceInfoObserver(const QUrl& url, QObject* parent = 0);
- virtual ~SpaceInfoObserver();
+ explicit SpaceInfoObserver(const QUrl& url, QObject* parent = nullptr);
+ ~SpaceInfoObserver() override;
quint64 size() const;
quint64 available() const;
StatusBarSpaceInfo::StatusBarSpaceInfo(QWidget* parent) :
KCapacityBar(KCapacityBar::DrawTextInline, parent),
- m_observer(0)
+ m_observer(nullptr)
{
setCursor(Qt::PointingHandCursor);
}
Q_OBJECT
public:
- explicit StatusBarSpaceInfo(QWidget* parent = 0);
- virtual ~StatusBarSpaceInfo();
+ explicit StatusBarSpaceInfo(QWidget* parent = nullptr);
+ ~StatusBarSpaceInfo() override;
void setUrl(const QUrl& url);
QUrl url() const;
protected:
- void showEvent(QShowEvent* event) Q_DECL_OVERRIDE;
- void hideEvent(QHideEvent* event) Q_DECL_OVERRIDE;
- void mousePressEvent(QMouseEvent* event) Q_DECL_OVERRIDE;
+ void showEvent(QShowEvent* event) override;
+ void hideEvent(QHideEvent* event) override;
+ void mousePressEvent(QMouseEvent* event) override;
private slots:
void slotValuesChanged();
TEST_NAME dolphinmainwindowtest
LINK_LIBRARIES dolphinprivate dolphinstatic Qt5::Test)
-ecm_add_test(draganddrophelpertest.cpp LINK_LIBRARIES dolphinprivate Qt5::Test)
\ No newline at end of file
+ecm_add_test(draganddrophelpertest.cpp LINK_LIBRARIES dolphinprivate Qt5::Test)
+
+# PlacesItemModelTest
+ecm_add_test(placesitemmodeltest.cpp
+TEST_NAME placesitemmodeltest
+LINK_LIBRARIES dolphinprivate dolphinstatic Qt5::Test)
+
--- /dev/null
+<!-- Please note that in this file we indent more than necessary so that the
+ device tree is visible -->
+
+<machine>
+ <!-- This is a computer -->
+ <device udi="/org/kde/solid/fakehw/computer">
+ <property key="name">Computer</property>
+ <property key="vendor">Solid</property>
+ </device>
+
+ <!-- Two CPUs -->
+ <device udi="/org/kde/solid/fakehw/acpi_CPU0">
+ <property key="name">Solid Processor #0</property>
+ <property key="interfaces">Processor</property>
+ <property key="vendor">Acme Corporation</property>
+ <property key="parent">/org/kde/solid/fakehw/computer</property>
+ <property key="number">0</property>
+ <property key="maxSpeed">3200</property>
+ <property key="canChangeFrequency">true</property>
+ <property key="instructionSets">mmx,sse</property>
+ </device>
+ <device udi="/org/kde/solid/fakehw/acpi_CPU1">
+ <property key="name">Solid Processor #1</property>
+ <property key="interfaces">Processor</property>
+ <property key="vendor">Acme Corporation</property>
+ <property key="parent">/org/kde/solid/fakehw/computer</property>
+ <property key="number">1</property>
+ <property key="maxSpeed">3200</property>
+ <property key="canChangeFrequency">true</property>
+ </device>
+
+ <!-- Platform Device for a floppy drive -->
+ <device udi="/org/kde/solid/fakehw/platform_floppy_0">
+ <property key="name">Platform Device (floppy)</property>
+ <property key="parent">/org/kde/solid/fakehw/computer</property>
+ </device>
+ <!-- The actual floppy device -->
+ <device udi="/org/kde/solid/fakehw/platform_floppy_0_storage">
+ <property key="name">PC Floppy Drive</property>
+ <property key="interfaces">StorageDrive,Block</property>
+ <property key="parent">/org/kde/solid/fakehw/platform_floppy_0</property>
+
+ <property key="minor">0</property>
+ <property key="major">2</property>
+ <property key="device">/dev/fd0</property>
+
+ <property key="bus">platform</property>
+ <property key="driveType">floppy</property>
+ <property key="isRemovable">true</property>
+ <property key="isEjectRequired">false</property>
+ <property key="isHotpluggable">false</property>
+ <property key="isMediaCheckEnabled">false</property>
+ </device>
+ <!-- A (generally) virtual volume tracking the floppy drive state -->
+ <device udi="/org/kde/solid/fakehw/platform_floppy_0_storage_virt_volume">
+ <property key="name">Floppy Disk</property>
+ <property key="interfaces">Block,StorageVolume,StorageAccess</property>
+ <property key="parent">/org/kde/solid/fakehw/platform_floppy_0_storage</property>
+
+ <property key="minor">0</property>
+ <property key="major">2</property>
+ <property key="device">/dev/fd0</property>
+
+ <property key="isIgnored">false</property>
+ <property key="isMounted">true</property>
+ <property key="mountPoint">/media/floppy0</property>
+ <property key="usage">filesystem</property>
+ </device>
+
+
+
+ <!-- Primary IDE controller -->
+ <device udi="/org/kde/solid/fakehw/pci_001">
+ <property key="name">99021 IDE Controller #1</property>
+ <property key="vendor">Acme Corporation</property>
+ <property key="parent">/org/kde/solid/fakehw/computer</property>
+ </device>
+
+ <!-- Master device... -->
+ <device udi="/org/kde/solid/fakehw/pci_001_ide_0_0">
+ <property key="name">IDE device (master)</property>
+ <property key="parent">/org/kde/solid/fakehw/pci_001</property>
+ </device>
+ <!-- ... is a 250GB disk... -->
+ <device udi="/org/kde/solid/fakehw/storage_serial_HD56890I">
+ <property key="name">HD250GB</property>
+ <property key="vendor">Acme Corporation</property>
+ <property key="interfaces">StorageDrive,Block</property>
+ <property key="parent">/org/kde/solid/fakehw/pci_001_ide_0_0</property>
+
+ <property key="minor">0</property>
+ <property key="major">3</property>
+ <property key="device">/dev/hda</property>
+
+ <property key="bus">scsi</property>
+ <property key="driveType">disk</property>
+ <property key="isRemovable">false</property>
+ <property key="isEjectRequired">false</property>
+ <property key="isHotpluggable">false</property>
+ <property key="isMediaCheckEnabled">false</property>
+ <property key="product">HD250GBSATA</property>
+ </device>
+ <!-- ... with five partitions:
+ - one physical partition (the root /, ext3, 20GB)
+ - one extended containing three logical volumes:
+ - a swap volume (2GB)
+ - /home volume (xfs, 208GB)
+ - /foreign volume (ntfs, 20GB)
+ -->
+ <device udi="/org/kde/solid/fakehw/volume_uuid_feedface">
+ <property key="name">/</property>
+ <property key="interfaces">Block,StorageVolume,StorageAccess</property>
+ <property key="parent">/org/kde/solid/fakehw/storage_serial_HD56890I</property>
+
+ <property key="minor">1</property>
+ <property key="major">3</property>
+ <property key="device">/dev/hda1</property>
+
+ <property key="isIgnored">true</property>
+ <property key="isMounted">true</property>
+ <property key="mountPoint">/</property>
+ <property key="usage">filesystem</property>
+ <property key="fsType">ext3</property>
+ <property key="label">Root</property>
+ <property key="uuid">feedface</property>
+ <property key="size">21474836480</property>
+ </device>
+ <device udi="/org/kde/solid/fakehw/volume_uuid_c0ffee">
+ <property key="name">/home</property>
+ <property key="interfaces">Block,StorageVolume,StorageAccess</property>
+ <property key="parent">/org/kde/solid/fakehw/storage_serial_HD56890I</property>
+
+ <property key="minor">6</property>
+ <property key="major">3</property>
+ <property key="device">/dev/hda6</property>
+
+ <property key="isIgnored">true</property>
+ <property key="isMounted">true</property>
+ <property key="mountPoint">/home</property>
+ <property key="usage">filesystem</property>
+ <property key="fsType">xfs</property>
+ <property key="label">Home</property>
+ <property key="uuid">c0ffee</property>
+ <property key="size">223338299392</property>
+ </device>
+ <device udi="/org/kde/solid/fakehw/volume_uuid_f00ba7">
+ <property key="name">/foreign</property>
+ <property key="interfaces">Block,StorageVolume,StorageAccess</property>
+ <property key="parent">/org/kde/solid/fakehw/storage_serial_HD56890I</property>
+
+ <property key="minor">7</property>
+ <property key="major">3</property>
+ <property key="device">/dev/hda7</property>
+
+ <property key="isIgnored">false</property>
+ <property key="isMounted">true</property>
+ <property key="mountPoint">/foreign</property>
+ <property key="usage">filesystem</property>
+ <property key="fsType">ntfs</property>
+ <property key="label">Foreign</property>
+ <property key="uuid">f00ba7</property>
+ <property key="size">21474836480</property>
+ </device>
+ <device udi="/org/kde/solid/fakehw/volume_part2_size_1024">
+ <property key="name">StorageVolume</property>
+ <property key="interfaces">Block,StorageVolume,StorageAccess</property>
+ <property key="parent">/org/kde/solid/fakehw/storage_serial_HD56890I</property>
+
+ <property key="minor">2</property>
+ <property key="major">3</property>
+ <property key="device">/dev/hda2</property>
+
+ <property key="isIgnored">true</property>
+ <property key="isMounted">false</property>
+ <property key="usage">other</property>
+ <property key="size">1024</property>
+ </device>
+ <device udi="/org/kde/solid/fakehw/volume_part5_size_1048576">
+ <property key="name">StorageVolume (swap)</property>
+ <property key="interfaces">Block,StorageVolume,StorageAccess</property>
+ <property key="parent">/org/kde/solid/fakehw/storage_serial_HD56890I</property>
+
+ <property key="minor">5</property>
+ <property key="major">3</property>
+ <property key="device">/dev/hda5</property>
+
+ <property key="isIgnored">true</property>
+ <property key="isMounted">false</property>
+ <property key="usage">other</property>
+ <property key="fsType">swap</property>
+ <property key="size">2147483648</property>
+ </device>
+
+
+ <!-- Secondary IDE controller -->
+ <device udi="/org/kde/solid/fakehw/pci_002">
+ <property key="name">99021 IDE Controller #2</property>
+ <property key="vendor">Acme Corporation</property>
+ <property key="parent">/org/kde/solid/fakehw/computer</property>
+ </device>
+
+ <!-- Master device... -->
+ <device udi="/org/kde/solid/fakehw/pci_002_ide_1_0">
+ <property key="name">IDE device (master)</property>
+ <property key="parent">/org/kde/solid/fakehw/pci_002</property>
+ </device>
+ <!-- ... is a DVD writer... -->
+ <device udi="/org/kde/solid/fakehw/storage_model_solid_writer">
+ <property key="name">Solid IDE DVD Writer</property>
+ <property key="vendor">Acme Corporation</property>
+ <property key="interfaces">Block,StorageDrive,OpticalDrive</property>
+ <property key="parent">/org/kde/solid/fakehw/pci_002_ide_1_0</property>
+
+ <property key="minor">0</property>
+ <property key="major">22</property>
+ <property key="device">/dev/hdc</property>
+
+ <property key="bus">ide</property>
+ <property key="driveType">cdrom</property>
+ <property key="isRemovable">true</property>
+ <property key="isEjectRequired">true</property>
+ <property key="isHotpluggable">false</property>
+ <property key="isMediaCheckEnabled">true</property>
+ <property key="product">Solid DVD Writer</property>
+
+ <property key="supportedMedia">cdr,cdrw,dvd,dvdr,dvdrw</property>
+ <property key="readSpeed">4234</property>
+ <property key="writeSpeed">4234</property>
+ <property key="writeSpeeds">4234,2822,2117,1411,706</property>
+ </device>
+ <!-- ... with a cd-r in it -->
+ <device udi="/org/kde/solid/fakehw/volume_uuid_5011">
+ <property key="name">FooDistro i386</property>
+ <property key="interfaces">Block,StorageVolume,OpticalDisc,StorageAccess</property>
+ <property key="parent">/org/kde/solid/fakehw/storage_model_solid_writer</property>
+
+ <property key="discType">cd_rw</property>
+ <property key="isAppendable">false</property>
+ <property key="isRewritable">true</property>
+ <property key="isBlank">false</property>
+ <property key="availableContent">data</property>
+ <property key="mountPoint">/media/cdrom</property>
+
+ <property key="uuid">5011</property>
+ <property key="size">731047936</property>
+ <property key="label">FooDistro i386</property>
+ </device>
+
+ <!-- Slave device... -->
+ <device udi="/org/kde/solid/fakehw/pci_002_ide_1_1">
+ <property key="name">IDE device (slave)</property>
+ <property key="parent">/org/kde/solid/fakehw/pci_002</property>
+ </device>
+ <!-- ... is a DVD reader... -->
+ <device udi="/org/kde/solid/fakehw/storage_model_solid_reader">
+ <property key="name">Solid IDE DVD Reader</property>
+ <property key="vendor">Acme Corporation</property>
+ <property key="interfaces">Block,StorageDrive,OpticalDrive</property>
+ <property key="parent">/org/kde/solid/fakehw/pci_002_ide_1_1</property>
+
+ <property key="minor">0</property>
+ <property key="major">22</property>
+ <property key="device">/dev/hdc</property>
+
+ <property key="bus">ide</property>
+ <property key="driveType">cdrom</property>
+ <property key="isRemovable">true</property>
+ <property key="isEjectRequired">true</property>
+ <property key="isHotpluggable">false</property>
+ <property key="isMediaCheckEnabled">true</property>
+ <property key="product">Solid DVD Reader</property>
+
+ <property key="supportedMedia">cdr,cdrw,dvd,dvdr,dvdrw,dvdram,dvdplusr,dvdplusrw</property>
+ <property key="readSpeed">4234</property>
+ </device>
+ <!-- ... with a DVD Video in it -->
+ <device udi="/org/kde/solid/fakehw/volume_label_SOLIDMAN_BEGINS">
+ <property key="name">SolidMan Begins</property>
+ <property key="interfaces">Block,StorageVolume,OpticalDisc</property>
+ <property key="parent">/org/kde/solid/fakehw/storage_model_solid_reader</property>
+
+ <property key="discType">dvd_rom</property>
+ <property key="isAppendable">false</property>
+ <property key="isRewritable">false</property>
+ <property key="isBlank">false</property>
+ <property key="availableContent">dvdvideo</property>
+
+ <property key="uuid">5012</property>
+ <property key="size">8033075200</property>
+ <property key="label">SolidMan Begins</property>
+ </device>
+
+
+
+ <!-- First USB Controller -->
+ <device udi="/org/kde/solid/fakehw/pci_8086_265c">
+ <property key="name">99021 USB2 EHCI Controller #1</property>
+ <property key="vendor">Acme Corporation</property>
+ <property key="parent">/org/kde/solid/fakehw/computer</property>
+ </device>
+ <!-- Host Controller -->
+ <device udi="/org/kde/solid/fakehw/usb_device_0_0_1d_7">
+ <property key="name">EHCI Host Controller</property>
+ <property key="vendor">Kernel ehci_hcd</property>
+ <property key="parent">/org/kde/solid/fakehw/pci_8086_265c</property>
+ </device>
+ <!-- USB Device -->
+ <device udi="/org/kde/solid/fakehw/usb_device_4e8_5041">
+ <property key="name">Acme XO-Y4</property>
+ <property key="parent">/org/kde/solid/fakehw/usb_device_0_0_1d_7</property>
+ </device>
+ <!-- Mass Storage Interface -->
+ <device udi="/org/kde/solid/fakehw/usb_device_4e8_5041_if0">
+ <property key="name">USB Mass Storage Inferface</property>
+ <property key="parent">/org/kde/solid/fakehw/usb_device_4e8_5041</property>
+ </device>
+ <!-- SCSI Adapter -->
+ <device udi="/org/kde/solid/fakehw/usb_device_4e8_5041_if0_scsi_host">
+ <property key="name">SCSI Host Adapter</property>
+ <property key="parent">/org/kde/solid/fakehw/usb_device_4e8_5041_if0</property>
+ </device>
+ <!-- SCSI Device -->
+ <device udi="/org/kde/solid/fakehw/usb_device_4e8_5041_if0_scsi_host_scsi_device_lun0">
+ <property key="name">SCSI Device</property>
+ <property key="parent">/org/kde/solid/fakehw/usb_device_4e8_5041_if0_scsi_host</property>
+ </device>
+ <!-- We finally find the storage device, which is a portable media player... -->
+ <device udi="/org/kde/solid/fakehw/storage_serial_XOY4_5206">
+ <property key="name">XO-Y4</property>
+ <property key="vendor">Acme Electronics</property>
+ <property key="interfaces">StorageDrive,Block,PortableMediaPlayer</property>
+ <property key="parent">/org/kde/solid/fakehw/usb_device_4e8_5041_if0_scsi_host_scsi_device_lun0</property>
+
+ <property key="minor">0</property>
+ <property key="major">8</property>
+ <property key="device">/dev/sda</property>
+
+ <property key="bus">usb</property>
+ <property key="driveType">disk</property>
+ <property key="isRemovable">true</property>
+ <property key="isEjectRequired">true</property>
+ <property key="isHotpluggable">true</property>
+ <property key="isMediaCheckEnabled">true</property>
+ <property key="product">XO-Y4</property>
+
+ <property key="accessMethod">MassStorage</property>
+ <property key="outputFormats">audio/x-mp3</property>
+ <property key="inputFormats">audio/x-wav,audio/x-mp3,audio/vorbis</property>
+ <property key="playlistFormats">audio/x-mpegurl</property>
+ </device>
+ <!-- ... with a partition since it's a USB Mass Storage device -->
+ <device udi="/org/kde/solid/fakehw/volume_part1_size_993284096">
+ <property key="name">StorageVolume (vfat)</property>
+ <property key="interfaces">Block,StorageVolume,StorageAccess</property>
+ <property key="parent">/org/kde/solid/fakehw/storage_serial_XOY4_5206</property>
+
+ <property key="minor">1</property>
+ <property key="major">8</property>
+ <property key="device">/dev/sda1</property>
+
+ <property key="isIgnored">false</property>
+ <property key="isMounted">true</property>
+ <property key="mountPoint">/media/XO-Y4</property>
+ <property key="usage">filesystem</property>
+ <property key="fsType">vfat</property>
+ <property key="size">993284096</property>
+ </device>
+
+ <device udi="/org/kde/solid/fakehw/fstab">
+ <property key="name">Network Shares</property>
+ <property key="product">Network Shares</property>
+ <property key="vendor">KDE</property>
+ <property key="parent">/org/kde/solid/fakehw/computer</property>
+ </device>
+ <device udi="/org/kde/solid/fakehw/fstab/thehost/solidpath">
+ <property key="parent">/org/kde/solid/fstab</property>
+ <property key="interfaces">NetworkShare,StorageAccess</property>
+ <property key="vendor">/solidpath</property>
+ <property key="product">thehost</property>
+ <property key="type">nfs</property>
+ <property key="url">nfs://thehost/solid-path</property>
+ <property key="filePath">/media/nfs</property>
+ <property key="isIgnored">false</property>
+ <property key="isMounted">true</property>
+ <property key="mountPoint">/media/nfs</property>
+ </device>
+</machine>
m_model->m_dirLister->setAutoUpdate(false);
m_listView = new KFileItemListView();
- m_listView->onModelChanged(m_model, 0);
+ m_listView->onModelChanged(m_model, nullptr);
m_graphicsView = new QGraphicsView();
m_graphicsView->show();
void KFileItemListViewTest::cleanup()
{
delete m_graphicsView;
- m_graphicsView = 0;
+ m_graphicsView = nullptr;
delete m_listView;
- m_listView = 0;
+ m_listView = nullptr;
delete m_model;
- m_model = 0;
+ m_model = nullptr;
delete m_testDir;
- m_testDir = 0;
+ m_testDir = nullptr;
}
/**
void KFileItemModelTest::cleanup()
{
delete m_model;
- m_model = 0;
+ m_model = nullptr;
delete m_testDir;
- m_testDir = 0;
+ m_testDir = nullptr;
}
void KFileItemModelTest::testDefaultRoles()
int styleHint(StyleHint hint,
const QStyleOption* option = nullptr,
const QWidget* widget = nullptr,
- QStyleHintReturn* returnData = nullptr) const Q_DECL_OVERRIDE
+ QStyleHintReturn* returnData = nullptr) const override
{
switch (hint) {
case QStyle::SH_ItemView_ActivateItemOnSingleClick:
void KItemListControllerTest::cleanupTestCase()
{
delete m_container;
- m_container = 0;
+ m_container = nullptr;
delete m_testDir;
- m_testDir = 0;
+ m_testDir = nullptr;
}
/** Before each test, the current item, selection, and item size are reset to the defaults. */
public:
DummyModel();
void setCount(int count);
- int count() const Q_DECL_OVERRIDE;
- QHash<QByteArray, QVariant> data(int index) const Q_DECL_OVERRIDE;
+ int count() const override;
+ QHash<QByteArray, QVariant> data(int index) const override;
private:
int m_count;
void KItemListSelectionManagerTest::cleanup()
{
delete m_selectionManager;
- m_selectionManager = 0;
+ m_selectionManager = nullptr;
delete m_model;
- m_model = 0;
+ m_model = nullptr;
}
void KItemListSelectionManagerTest::testConstructor()
void KStandardItemModelTest::cleanup()
{
delete m_model;
- m_model = 0;
+ m_model = nullptr;
}
void KStandardItemModelTest::testNewItems()
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2017 by Renato Araujo Oliveira <renato.araujo@kdab.com> *
+ * *
+ * 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 <QTest>
+#include <QSignalSpy>
+#include <QDebug>
+#include <QList>
+#include <QByteArray>
+#include <QStandardPaths>
+#include <QAction>
+#include <QDBusInterface>
+#include <QUrlQuery>
+
+#include <KBookmarkManager>
+#include <KConfig>
+#include <KConfigGroup>
+#include <KAboutData>
+#include <KFilePlacesModel>
+
+#include "panels/places/placesitemmodel.h"
+#include "panels/places/placesitem.h"
+#include "views/viewproperties.h"
+#include "kitemviews/kitemrange.h"
+
+Q_DECLARE_METATYPE(KItemRangeList)
+Q_DECLARE_METATYPE(KItemRange)
+
+#ifdef Q_OS_WIN
+//c:\ as root for windows
+#define KDE_ROOT_PATH "C:\\"
+#else
+#define KDE_ROOT_PATH "/"
+#endif
+
+static QString bookmarksFile()
+{
+ return QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/user-places.xbel";
+}
+
+class PlacesItemModelTest : public QObject
+{
+ Q_OBJECT
+
+private slots:
+ void init();
+ void cleanup();
+
+ void initTestCase();
+ void cleanupTestCase();
+
+ void testModelSort();
+ void testGroups();
+ void testDeletePlace();
+ void testPlaceItem_data();
+ void testPlaceItem();
+ void testTearDownDevice();
+ void testDefaultViewProperties_data();
+ void testDefaultViewProperties();
+ void testClear();
+ void testHideItem();
+ void testSystemItems();
+ void testEditBookmark();
+ void testEditAfterCreation();
+ void testEditMetadata();
+ void testRefresh();
+ void testIcons_data();
+ void testIcons();
+ void testDragAndDrop();
+ void testHideDevices();
+ void testDuplicatedEntries();
+ void renameAfterCreation();
+
+private:
+ PlacesItemModel* m_model;
+ QSet<int> m_tobeRemoved;
+ QMap<QString, QDBusInterface *> m_interfacesMap;
+
+ void setBalooEnabled(bool enabled);
+ int indexOf(const QUrl &url);
+ QDBusInterface *fakeManager();
+ QDBusInterface *fakeDevice(const QString &udi);
+ QStringList placesUrls(PlacesItemModel *model = nullptr) const;
+ QStringList initialUrls() const;
+ void createPlaceItem(const QString &text, const QUrl &url, const QString &icon);
+ void removePlaceAfter(int index);
+ void cancelPlaceRemoval(int index);
+ void removeTestUserData();
+ QMimeData *createMimeData(const QList<int> &indexes) const;
+};
+
+#define CHECK_PLACES_URLS(urls) \
+ { \
+ QStringList places = placesUrls(); \
+ if (places != urls) { \
+ qWarning() << "Expected:" << urls; \
+ qWarning() << "Got:" << places; \
+ QCOMPARE(places, urls); \
+ } \
+ }
+
+void PlacesItemModelTest::setBalooEnabled(bool enabled)
+{
+ KConfig config(QStringLiteral("baloofilerc"));
+ KConfigGroup basicSettings = config.group("Basic Settings");
+ basicSettings.writeEntry("Indexing-Enabled", enabled);
+ config.sync();
+}
+
+int PlacesItemModelTest::indexOf(const QUrl &url)
+{
+ for (int r = 0; r < m_model->count(); r++) {
+ if (m_model->placesItem(r)->url() == url) {
+ return r;
+ }
+ }
+ return -1;
+}
+
+QDBusInterface *PlacesItemModelTest::fakeManager()
+{
+ return fakeDevice(QStringLiteral("/org/kde/solid/fakehw"));
+}
+
+QDBusInterface *PlacesItemModelTest::fakeDevice(const QString &udi)
+{
+ if (m_interfacesMap.contains(udi)) {
+ return m_interfacesMap[udi];
+ }
+
+ QDBusInterface *iface = new QDBusInterface(QDBusConnection::sessionBus().baseService(), udi);
+ m_interfacesMap[udi] = iface;
+
+ return iface;
+}
+
+QStringList PlacesItemModelTest::placesUrls(PlacesItemModel *model) const
+{
+ QStringList urls;
+ if (!model) {
+ model = m_model;
+ }
+
+ for (int row = 0; row < model->count(); ++row) {
+ urls << model->placesItem(row)->url().toDisplayString(QUrl::PreferLocalFile);
+ }
+ return urls;
+}
+
+QStringList PlacesItemModelTest::initialUrls() const
+{
+ static QStringList urls;
+ if (urls.isEmpty()) {
+ urls << QDir::homePath() << QStringLiteral(KDE_ROOT_PATH) << QStringLiteral("trash:/")
+ << QStringLiteral("remote:/")
+ << QStringLiteral("timeline:/today") << QStringLiteral("timeline:/yesterday") << QStringLiteral("timeline:/thismonth") << QStringLiteral("timeline:/lastmonth")
+ << QStringLiteral("search:/documents") << QStringLiteral("search:/images") << QStringLiteral("search:/audio") << QStringLiteral("search:/videos")
+ << QStringLiteral("/media/nfs") << QStringLiteral("/foreign")
+ << QStringLiteral("/media/floppy0") << QStringLiteral("/media/XO-Y4") << QStringLiteral("/media/cdrom");
+ }
+ return urls;
+}
+
+void PlacesItemModelTest::createPlaceItem(const QString &text, const QUrl &url, const QString &icon)
+{
+ m_model->createPlacesItem(text, url, icon);
+}
+
+void PlacesItemModelTest::removePlaceAfter(int index)
+{
+ m_tobeRemoved.insert(index);
+}
+
+void PlacesItemModelTest::cancelPlaceRemoval(int index)
+{
+ m_tobeRemoved.remove(index);
+}
+
+void PlacesItemModelTest::removeTestUserData()
+{
+ // user hardcoded path to avoid removal of any user personal data
+ QDir dir(QStringLiteral("/home/renato/.qttest/share/placesitemmodeltest"));
+ if (dir.exists()) {
+ QVERIFY(dir.removeRecursively());
+ }
+}
+
+QMimeData *PlacesItemModelTest::createMimeData(const QList<int> &indexes) const
+{
+ QByteArray itemData;
+ QDataStream stream(&itemData, QIODevice::WriteOnly);
+ QList<QUrl> urls;
+
+ for (int index : indexes) {
+ const QUrl itemUrl = m_model->placesItem(index)->url();
+ if (itemUrl.isValid()) {
+ urls << itemUrl;
+ }
+ stream << index;
+ }
+
+ QMimeData* mimeData = new QMimeData();
+ mimeData->setUrls(urls);
+ // copied from PlacesItemModel::internalMimeType()
+ const QString internalMimeType = "application/x-dolphinplacesmodel-" +
+ QString::number((qptrdiff)m_model);
+ mimeData->setData(internalMimeType, itemData);
+ return mimeData;
+}
+
+void PlacesItemModelTest::init()
+{
+ m_model = new PlacesItemModel();
+ // WORKAROUND: need to wait for bookmark to load, check: PlacesItemModel::updateBookmarks
+ QTest::qWait(300);
+ QCOMPARE(m_model->count(), 17);
+}
+
+void PlacesItemModelTest::cleanup()
+{
+ for (int i : m_tobeRemoved) {
+ int before = m_model->count();
+ m_model->deleteItem(i);
+ QTRY_COMPARE(m_model->count(), before - 1);
+ }
+ m_tobeRemoved.clear();
+ delete m_model;
+ m_model = nullptr;
+ removeTestUserData();
+}
+
+void PlacesItemModelTest::initTestCase()
+{
+ QStandardPaths::setTestModeEnabled(true);
+ // remove test user data
+ removeTestUserData();
+
+ const QString fakeHw = QFINDTESTDATA("data/fakecomputer.xml");
+ QVERIFY(!fakeHw.isEmpty());
+ qputenv("SOLID_FAKEHW", QFile::encodeName(fakeHw));
+
+ setBalooEnabled(true);
+ const QString bookmarsFileName = bookmarksFile();
+ if (QFileInfo::exists(bookmarsFileName)) {
+ // Ensure we'll have a clean bookmark file to start
+ QVERIFY(QFile::remove(bookmarsFileName));
+ }
+
+ qRegisterMetaType<KItemRangeList>();
+ qRegisterMetaType<KItemRange>();
+}
+
+void PlacesItemModelTest::cleanupTestCase()
+{
+ qDeleteAll(m_interfacesMap);
+ QFile::remove(bookmarksFile());
+
+ // Remove any previous properties file
+ removeTestUserData();
+}
+
+void PlacesItemModelTest::testModelSort()
+{
+ CHECK_PLACES_URLS(initialUrls());
+}
+
+void PlacesItemModelTest::testGroups()
+{
+ const auto groups = m_model->groups();
+
+ QCOMPARE(groups.size(), 6);
+
+ QCOMPARE(groups.at(0).first, 0);
+ QCOMPARE(groups.at(0).second.toString(), QStringLiteral("Places"));
+
+ QCOMPARE(groups.at(1).first, 3);
+ QCOMPARE(groups.at(1).second.toString(), QStringLiteral("Remote"));
+
+ QCOMPARE(groups.at(2).first, 4);
+ QCOMPARE(groups.at(2).second.toString(), QStringLiteral("Recently Saved"));
+
+ QCOMPARE(groups.at(3).first, 8);
+ QCOMPARE(groups.at(3).second.toString(), QStringLiteral("Search For"));
+
+ QCOMPARE(groups.at(4).first, 12);
+ QCOMPARE(groups.at(4).second.toString(), QStringLiteral("Devices"));
+
+ QCOMPARE(groups.at(5).first, 14);
+ QCOMPARE(groups.at(5).second.toString(), QStringLiteral("Removable Devices"));
+}
+
+void PlacesItemModelTest::testPlaceItem_data()
+{
+ QTest::addColumn<QUrl>("url");
+ QTest::addColumn<bool>("expectedIsHidden");
+ QTest::addColumn<bool>("expectedIsSystemItem");
+ QTest::addColumn<QString>("expectedGroup");
+ QTest::addColumn<bool>("expectedStorageSetupNeeded");
+
+ // places
+ QTest::newRow("Places - Home") << QUrl::fromLocalFile(QDir::homePath()) << false << true << QStringLiteral("Places") << false;
+
+ // baloo -search
+ QTest::newRow("Baloo - Documents") << QUrl("search:/documents") << false << true << QStringLiteral("Search For") << false;
+
+ // baloo - timeline
+ QTest::newRow("Baloo - Last Month") << QUrl("timeline:/lastmonth") << false << true << QStringLiteral("Recently Saved") << false;
+
+ // devices
+ QTest::newRow("Devices - Floppy") << QUrl("file:///media/floppy0") << false << false << QStringLiteral("Removable Devices") << false;
+}
+
+void PlacesItemModelTest::testPlaceItem()
+{
+ QFETCH(QUrl, url);
+ QFETCH(bool, expectedIsHidden);
+ QFETCH(bool, expectedIsSystemItem);
+ QFETCH(QString, expectedGroup);
+ QFETCH(bool, expectedStorageSetupNeeded);
+
+ const int index = indexOf(url);
+ PlacesItem *item = m_model->placesItem(index);
+ QCOMPARE(item->url(), url);
+ QCOMPARE(item->isHidden(), expectedIsHidden);
+ QCOMPARE(item->isSystemItem(), expectedIsSystemItem);
+ QCOMPARE(item->group(), expectedGroup);
+ QCOMPARE(item->storageSetupNeeded(), expectedStorageSetupNeeded);
+}
+
+void PlacesItemModelTest::testDeletePlace()
+{
+ const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
+ QStringList urls = initialUrls();
+ QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted);
+ QSignalSpy itemsRemovedSpy(m_model, &PlacesItemModel::itemsRemoved);
+
+ PlacesItemModel *model = new PlacesItemModel();
+
+ // create a new place
+ createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString());
+ urls.insert(3, tempUrl.toLocalFile());
+
+ // check if the new entry was created
+ QTRY_COMPARE(itemsInsertedSpy.count(), 1);
+ CHECK_PLACES_URLS(urls);
+ QTRY_COMPARE(model->count(), m_model->count());
+
+ // delete item
+ m_model->deleteItem(3);
+
+ // make sure that the new item is removed
+ QTRY_COMPARE(itemsRemovedSpy.count(), 1);
+ QTRY_COMPARE(m_model->count(), 17);
+ CHECK_PLACES_URLS(initialUrls());
+ QTRY_COMPARE(model->count(), m_model->count());
+}
+
+void PlacesItemModelTest::testTearDownDevice()
+{
+ const QUrl mediaUrl = QUrl::fromLocalFile(QStringLiteral("/media/XO-Y4"));
+ int index = indexOf(mediaUrl);
+ QVERIFY(index != -1);
+
+ auto ejectAction = m_model->ejectAction(index);
+ QVERIFY(!ejectAction);
+
+ auto teardownAction = m_model->teardownAction(index);
+ QVERIFY(teardownAction);
+
+ QCOMPARE(m_model->count(), 17);
+
+ QSignalSpy spyItemsRemoved(m_model, &PlacesItemModel::itemsRemoved);
+ fakeManager()->call(QStringLiteral("unplug"), "/org/kde/solid/fakehw/volume_part1_size_993284096");
+ QTRY_COMPARE(m_model->count(), 16);
+ QCOMPARE(spyItemsRemoved.count(), 1);
+ const QList<QVariant> spyItemsRemovedArgs = spyItemsRemoved.takeFirst();
+ const KItemRangeList removedRange = spyItemsRemovedArgs.at(0).value<KItemRangeList>();
+ QCOMPARE(removedRange.size(), 1);
+ QCOMPARE(removedRange.first().index, index);
+ QCOMPARE(removedRange.first().count, 1);
+
+ QCOMPARE(indexOf(mediaUrl), -1);
+
+ QSignalSpy spyItemsInserted(m_model, &PlacesItemModel::itemsInserted);
+ fakeManager()->call(QStringLiteral("plug"), "/org/kde/solid/fakehw/volume_part1_size_993284096");
+ QTRY_COMPARE(m_model->count(), 17);
+ QCOMPARE(spyItemsInserted.count(), 1);
+ index = indexOf(mediaUrl);
+
+ const QList<QVariant> args = spyItemsInserted.takeFirst();
+ const KItemRangeList insertedRange = args.at(0).value<KItemRangeList>();
+ QCOMPARE(insertedRange.size(), 1);
+ QCOMPARE(insertedRange.first().index, index);
+ QCOMPARE(insertedRange.first().count, 1);
+}
+
+void PlacesItemModelTest::testDefaultViewProperties_data()
+{
+ QTest::addColumn<QUrl>("url");
+ QTest::addColumn<DolphinView::Mode>("expectedViewMode");
+ QTest::addColumn<bool>("expectedPreviewShow");
+ QTest::addColumn<QList<QByteArray> >("expectedVisibleRole");
+
+ // places
+ QTest::newRow("Places - Home") << QUrl::fromLocalFile(QDir::homePath()) << DolphinView::IconsView << true << QList<QByteArray>({"text"});
+
+ // baloo -search
+ QTest::newRow("Baloo - Documents") << QUrl("search:/documents") << DolphinView::DetailsView << false << QList<QByteArray>({"text", "path"});
+
+ // audio files
+ QTest::newRow("Places - Audio") << QUrl("search:/audio") << DolphinView::DetailsView << false << QList<QByteArray>({"text", "artist", "album"});
+
+ // baloo - timeline
+ QTest::newRow("Baloo - Last Month") << QUrl("timeline:/lastmonth") << DolphinView::DetailsView << true << QList<QByteArray>({"text", "modificationtime"});
+
+ // devices
+ QTest::newRow("Devices - Floppy") << QUrl("file:///media/floppy0") << DolphinView::IconsView << true << QList<QByteArray>({"text"});
+
+}
+
+void PlacesItemModelTest::testDefaultViewProperties()
+{
+ QFETCH(QUrl, url);
+ QFETCH(DolphinView::Mode, expectedViewMode);
+ QFETCH(bool, expectedPreviewShow);
+ QFETCH(QList<QByteArray>, expectedVisibleRole);
+
+ ViewProperties properties(KFilePlacesModel::convertedUrl(url));
+ QCOMPARE(properties.viewMode(), expectedViewMode);
+ QCOMPARE(properties.previewsShown(), expectedPreviewShow);
+ QCOMPARE(properties.visibleRoles(), expectedVisibleRole);
+}
+
+void PlacesItemModelTest::testClear()
+{
+ QCOMPARE(m_model->count(), 17);
+ m_model->clear();
+ QCOMPARE(m_model->count(), 0);
+ QCOMPARE(m_model->hiddenCount(), 0);
+ m_model->refresh();
+ QTRY_COMPARE(m_model->count(), 17);
+}
+
+void PlacesItemModelTest::testHideItem()
+{
+ const QUrl mediaUrl = QUrl::fromLocalFile(QStringLiteral("/media/XO-Y4"));
+ const int index = indexOf(mediaUrl);
+
+ PlacesItem *item = m_model->placesItem(index);
+
+ QSignalSpy spyItemsRemoved(m_model, &PlacesItemModel::itemsRemoved);
+ QList<QVariant> spyItemsRemovedArgs;
+ KItemRangeList removedRange;
+
+ QSignalSpy spyItemsInserted(m_model, &PlacesItemModel::itemsInserted);
+ QList<QVariant> spyItemsInsertedArgs;
+ KItemRangeList insertedRange;
+ QVERIFY(item);
+
+ // hide an item
+ item->setHidden(true);
+
+ // check if items removed was fired
+ QTRY_COMPARE(m_model->count(), 16);
+ QCOMPARE(spyItemsRemoved.count(), 1);
+ spyItemsRemovedArgs = spyItemsRemoved.takeFirst();
+ removedRange = spyItemsRemovedArgs.at(0).value<KItemRangeList>();
+ QCOMPARE(removedRange.size(), 1);
+ QCOMPARE(removedRange.first().index, index);
+ QCOMPARE(removedRange.first().count, 1);
+
+ // allow model to show hidden items
+ m_model->setHiddenItemsShown(true);
+
+ // check if the items inserted was fired
+ spyItemsInsertedArgs = spyItemsInserted.takeFirst();
+ insertedRange = spyItemsInsertedArgs.at(0).value<KItemRangeList>();
+ QCOMPARE(insertedRange.size(), 1);
+ QCOMPARE(insertedRange.first().index, index);
+ QCOMPARE(insertedRange.first().count, 1);
+
+ // mark item as visible
+ item = m_model->placesItem(index);
+ item->setHidden(false);
+
+ // mark model to hide invisible items
+ m_model->setHiddenItemsShown(true);
+
+ QTRY_COMPARE(m_model->count(), 17);
+}
+
+void PlacesItemModelTest::testSystemItems()
+{
+ QCOMPARE(m_model->count(), 17);
+ for (int r = 0; r < m_model->count(); r++) {
+ QCOMPARE(m_model->placesItem(r)->isSystemItem(), !m_model->placesItem(r)->device().isValid());
+ }
+
+ QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted);
+
+ // create a new entry (non system item)
+ createPlaceItem(QStringLiteral("Temporary Dir"), QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)), QString());
+
+ // check if the new entry was created
+ QTRY_COMPARE(itemsInsertedSpy.count(), 1);
+
+ // make sure the new place get removed
+ removePlaceAfter(3);
+
+ QList<QVariant> args = itemsInsertedSpy.takeFirst();
+ KItemRangeList range = args.at(0).value<KItemRangeList>();
+ QCOMPARE(range.first().index, 3);
+ QCOMPARE(range.first().count, 1);
+ QVERIFY(!m_model->placesItem(3)->isSystemItem());
+ QCOMPARE(m_model->count(), 18);
+
+ QTest::qWait(300);
+ // check if the removal signal is correct
+ QSignalSpy itemsRemovedSpy(m_model, &PlacesItemModel::itemsRemoved);
+ m_model->deleteItem(3);
+ QTRY_COMPARE(itemsRemovedSpy.count(), 1);
+ args = itemsRemovedSpy.takeFirst();
+ range = args.at(0).value<KItemRangeList>();
+ QCOMPARE(range.first().index, 3);
+ QCOMPARE(range.first().count, 1);
+ QTRY_COMPARE(m_model->count(), 17);
+
+ //cancel removal (it was removed above)
+ cancelPlaceRemoval(3);
+}
+
+void PlacesItemModelTest::testEditBookmark()
+{
+ const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
+ QScopedPointer<PlacesItemModel> other(new PlacesItemModel());
+
+ createPlaceItem(QStringLiteral("Temporary Dir"), QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation)), QString());
+
+ // make sure that the new item will be removed later
+ removePlaceAfter(3);
+
+ QSignalSpy itemsChangedSply(m_model, &PlacesItemModel::itemsChanged);
+
+ // modify place text
+ m_model->item(3)->setText(QStringLiteral("Renamed place"));
+ m_model->refresh();
+
+ // check if the correct signal was fired
+ QTRY_COMPARE(itemsChangedSply.count(), 1);
+ QList<QVariant> args = itemsChangedSply.takeFirst();
+ KItemRangeList range = args.at(0).value<KItemRangeList>();
+ QCOMPARE(range.first().index, 3);
+ QCOMPARE(range.first().count, 1);
+ QSet<QByteArray> roles = args.at(1).value<QSet<QByteArray> >();
+ QCOMPARE(roles.size(), 1);
+ QCOMPARE(*roles.begin(), QByteArrayLiteral("text"));
+ QCOMPARE(m_model->item(3)->text(), QStringLiteral("Renamed place"));
+
+ // check if the item was updated in the other model
+ QTRY_COMPARE(other->item(3)->text(), QStringLiteral("Renamed place"));
+}
+
+void PlacesItemModelTest::testEditAfterCreation()
+{
+ const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
+ QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted);
+
+ // create a new place
+ createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString());
+ QTRY_COMPARE(itemsInsertedSpy.count(), 1);
+
+ PlacesItemModel *model = new PlacesItemModel();
+ QTRY_COMPARE(model->count(), m_model->count());
+
+ // make sure that the new item will be removed later
+ removePlaceAfter(3);
+
+ // modify place text
+ PlacesItem *item = m_model->placesItem(3);
+ item->setText(QStringLiteral("Renamed place"));
+ m_model->refresh();
+
+ // check if the second model got the changes
+ QTRY_COMPARE(model->count(), m_model->count());
+ QTRY_COMPARE(model->placesItem(3)->text(), m_model->placesItem(3)->text());
+ QTRY_COMPARE(model->placesItem(3)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")),
+ m_model->placesItem(3)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")));
+ QTRY_COMPARE(model->placesItem(3)->icon(), m_model->placesItem(3)->icon());
+ QTRY_COMPARE(model->placesItem(3)->url(), m_model->placesItem(3)->url());
+}
+
+void PlacesItemModelTest::testEditMetadata()
+{
+ const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
+ QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted);
+
+ // create a new place
+ createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString());
+ QTRY_COMPARE(itemsInsertedSpy.count(), 1);
+
+ // check if the new entry was created
+ PlacesItemModel *model = new PlacesItemModel();
+ QTRY_COMPARE(model->count(), m_model->count());
+
+ // make sure that the new item will be removed later
+ removePlaceAfter(3);
+
+ // modify place metadata
+ PlacesItem *item = m_model->placesItem(3);
+ item->bookmark().setMetaDataItem(QStringLiteral("OnlyInApp"), KAboutData::applicationData().componentName());
+ m_model->refresh();
+
+ // check if the place was modified in both models
+ QTRY_COMPARE(model->placesItem(3)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")),
+ KAboutData::applicationData().componentName());
+ QTRY_COMPARE(model->placesItem(3)->text(), m_model->placesItem(3)->text());
+ QTRY_COMPARE(model->placesItem(3)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")),
+ m_model->placesItem(3)->bookmark().metaDataItem(QStringLiteral("OnlyInApp")));
+ QTRY_COMPARE(model->placesItem(3)->icon(), m_model->placesItem(3)->icon());
+ QTRY_COMPARE(model->placesItem(3)->url(), m_model->placesItem(3)->url());
+}
+
+void PlacesItemModelTest::testRefresh()
+{
+ const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
+ QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted);
+
+ // create a new place
+ createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString());
+ QTRY_COMPARE(itemsInsertedSpy.count(), 1);
+
+ PlacesItemModel *model = new PlacesItemModel();
+ QTRY_COMPARE(model->count(), m_model->count());
+
+ // make sure that the new item will be removed later
+ removePlaceAfter(3);
+
+ PlacesItem *item = m_model->placesItem(3);
+ PlacesItem *sameItem = model->placesItem(3);
+ QCOMPARE(item->text(), sameItem->text());
+
+ // modify place text
+ item->setText(QStringLiteral("Renamed place"));
+
+ // item from another model is not affected at the moment
+ QVERIFY(item->text() != sameItem->text());
+
+ // propagate change
+ m_model->refresh();
+
+ // item must be equal
+ QTRY_COMPARE(item->text(), sameItem->text());
+}
+
+void PlacesItemModelTest::testIcons_data()
+{
+ QTest::addColumn<QUrl>("url");
+ QTest::addColumn<QString>("expectedIconName");
+
+ // places
+ QTest::newRow("Places - Home") << QUrl::fromLocalFile(QDir::homePath()) << QStringLiteral("user-home");
+
+ // baloo -search
+ QTest::newRow("Baloo - Documents") << QUrl("search:/documents") << QStringLiteral("folder-text");
+
+ // baloo - timeline
+ QTest::newRow("Baloo - Last Month") << QUrl("timeline:/lastmonth") << QStringLiteral("view-calendar-month");
+
+ // devices
+ QTest::newRow("Devices - Floppy") << QUrl("file:///media/floppy0") << QStringLiteral("blockdevice");
+}
+
+void PlacesItemModelTest::testIcons()
+{
+ QFETCH(QUrl, url);
+ QFETCH(QString, expectedIconName);
+
+ PlacesItem *item = m_model->placesItem(indexOf(url));
+ QCOMPARE(item->icon(), expectedIconName);
+
+ for (int r = 0; r < m_model->count(); r++) {
+ QVERIFY(!m_model->placesItem(r)->icon().isEmpty());
+ }
+}
+
+void PlacesItemModelTest::testDragAndDrop()
+{
+ QList<QVariant> args;
+ KItemRangeList range;
+ QStringList urls = initialUrls();
+ QSignalSpy itemsInsertedSpy(m_model, &PlacesItemModel::itemsInserted);
+ QSignalSpy itemsRemovedSpy(m_model, &PlacesItemModel::itemsRemoved);
+
+ CHECK_PLACES_URLS(initialUrls());
+ // Move the KDE_ROOT_PATH at the end of the places list will case it to be moved to the end of the places group
+ QMimeData *dropData = createMimeData(QList<int>() << 1);
+ m_model->dropMimeDataBefore(m_model->count() - 1, dropData);
+ urls.move(1, 2);
+ delete dropData;
+
+ QTRY_COMPARE(itemsInsertedSpy.count(), 1);
+ QTRY_COMPARE(itemsRemovedSpy.count(), 1);
+
+ // remove item from actual position
+ args = itemsRemovedSpy.takeFirst();
+ range = args.at(0).value<KItemRangeList>();
+ QCOMPARE(range.size(), 1);
+ QCOMPARE(range.at(0).count, 1);
+ QCOMPARE(range.at(0).index, 1);
+
+ // insert intem in his group
+ args = itemsInsertedSpy.takeFirst();
+ range = args.at(0).value<KItemRangeList>();
+ QCOMPARE(range.size(), 1);
+ QCOMPARE(range.at(0).count, 1);
+ QCOMPARE(range.at(0).index, 2);
+
+ CHECK_PLACES_URLS(urls);
+
+ itemsInsertedSpy.clear();
+ itemsRemovedSpy.clear();
+
+ // Move the KDE_ROOT_PATH to his original position
+ dropData = createMimeData(QList<int>() << 2);
+ m_model->dropMimeDataBefore(1, dropData);
+ urls.move(2, 1);
+ delete dropData;
+
+ QTRY_COMPARE(itemsInsertedSpy.count(), 1);
+ QTRY_COMPARE(itemsRemovedSpy.count(), 1);
+
+ // remove item from actual position
+ args = itemsRemovedSpy.takeFirst();
+ range = args.at(0).value<KItemRangeList>();
+ QCOMPARE(range.size(), 1);
+ QCOMPARE(range.at(0).count, 1);
+ QCOMPARE(range.at(0).index, 2);
+
+ // insert intem in the requested position
+ args = itemsInsertedSpy.takeFirst();
+ range = args.at(0).value<KItemRangeList>();
+ QCOMPARE(range.size(), 1);
+ QCOMPARE(range.at(0).count, 1);
+ QCOMPARE(range.at(0).index, 1);
+
+ CHECK_PLACES_URLS(urls);
+}
+
+void PlacesItemModelTest::testHideDevices()
+{
+ QSignalSpy itemsRemoved(m_model, &PlacesItemModel::itemsRemoved);
+ QStringList urls = initialUrls();
+
+ m_model->setGroupHidden(KFilePlacesModel::RemovableDevicesType, true);
+ QTRY_VERIFY(m_model->isGroupHidden(KFilePlacesModel::RemovableDevicesType));
+ QTRY_COMPARE(itemsRemoved.count(), 3);
+
+ // remove removable-devices
+ urls.removeOne(QStringLiteral("/media/floppy0"));
+ urls.removeOne(QStringLiteral("/media/XO-Y4"));
+ urls.removeOne(QStringLiteral("/media/cdrom"));
+
+ // check if the correct urls was removed
+ CHECK_PLACES_URLS(urls);
+
+ delete m_model;
+ m_model = new PlacesItemModel();
+ QTRY_COMPARE(m_model->count(), urls.count());
+ CHECK_PLACES_URLS(urls);
+
+ // revert changes
+ m_model->setGroupHidden(KFilePlacesModel::RemovableDevicesType, false);
+ urls = initialUrls();
+ QTRY_COMPARE(m_model->count(), urls.count());
+ CHECK_PLACES_URLS(urls);
+}
+
+void PlacesItemModelTest::testDuplicatedEntries()
+{
+ QStringList urls = initialUrls();
+ // create a duplicated entry on bookmark
+ KBookmarkManager *bookmarkManager = KBookmarkManager::managerForFile(bookmarksFile(), QStringLiteral("kfilePlaces"));
+ KBookmarkGroup root = bookmarkManager->root();
+ KBookmark bookmark = root.addBookmark(QStringLiteral("Duplicated Search Videos"), QUrl("search:/videos"), {});
+
+ const QString id = QUuid::createUuid().toString();
+ bookmark.setMetaDataItem(QStringLiteral("ID"), id);
+ bookmark.setMetaDataItem(QStringLiteral("OnlyInApp"), KAboutData::applicationData().componentName());
+ bookmarkManager->emitChanged(bookmarkManager->root());
+
+ PlacesItemModel *newModel = new PlacesItemModel();
+ QTRY_COMPARE(placesUrls(newModel).count(QStringLiteral("search:/videos")), 1);
+ QTRY_COMPARE(urls, placesUrls(newModel));
+ delete newModel;
+}
+
+void PlacesItemModelTest::renameAfterCreation()
+{
+ const QUrl tempUrl = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
+ QStringList urls = initialUrls();
+ PlacesItemModel *model = new PlacesItemModel();
+
+ CHECK_PLACES_URLS(urls);
+ QTRY_COMPARE(model->count(), m_model->count());
+
+ // create a new place
+ createPlaceItem(QStringLiteral("Temporary Dir"), tempUrl, QString());
+ urls.insert(3, tempUrl.toLocalFile());
+
+ // make sure that the new item will be removed later
+ removePlaceAfter(3);
+
+ CHECK_PLACES_URLS(urls);
+ QCOMPARE(model->count(), m_model->count());
+
+
+ // modify place text
+ QSignalSpy changedSpy(m_model, &PlacesItemModel::itemsChanged);
+
+ PlacesItem *item = m_model->placesItem(3);
+ item->setText(QStringLiteral("New Temporary Dir"));
+ item->setUrl(item->url());
+ item->setIcon(item->icon());
+ m_model->refresh();
+
+ QTRY_COMPARE(changedSpy.count(), 1);
+
+ // check if the place was modified in both models
+ QTRY_COMPARE(m_model->placesItem(3)->text(), QStringLiteral("New Temporary Dir"));
+ QTRY_COMPARE(model->placesItem(3)->text(), QStringLiteral("New Temporary Dir"));
+}
+
+QTEST_MAIN(PlacesItemModelTest)
+
+#include "placesitemmodeltest.moc"
void ViewPropertiesTest::cleanup()
{
delete m_testDir;
- m_testDir = 0;
+ m_testDir = nullptr;
GeneralSettings::self()->setGlobalViewProps(m_globalViewProps);
GeneralSettings::self()->save();
public:
DolphinFileItemListWidget(KItemListWidgetInformant* informant, QGraphicsItem* parent);
- virtual ~DolphinFileItemListWidget();
+ ~DolphinFileItemListWidget() override;
protected:
- virtual void refreshCache() Q_DECL_OVERRIDE;
+ void refreshCache() override;
private:
static QPixmap overlayForState(KVersionControlPlugin::ItemVersion version, int size);
#include <kitemviews/kitemlistcontroller.h>
#include <kitemviews/kitemliststyleoption.h>
+#include <KIO/PreviewJob>
#include <views/viewmodecontroller.h>
updateGridSize();
const KConfigGroup globalConfig(KSharedConfig::openConfig(), "PreviewSettings");
- const QStringList plugins = globalConfig.readEntry("Plugins", QStringList()
- << QStringLiteral("directorythumbnail")
- << QStringLiteral("imagethumbnail")
- << QStringLiteral("jpegthumbnail"));
- setEnabledPlugins(plugins);
+ setEnabledPlugins(globalConfig.readEntry("Plugins", KIO::PreviewJob::defaultPlugins()));
endTransaction();
}
Q_OBJECT
public:
- explicit DolphinItemListView(QGraphicsWidget* parent = 0);
- virtual ~DolphinItemListView();
+ explicit DolphinItemListView(QGraphicsWidget* parent = nullptr);
+ ~DolphinItemListView() override;
void setZoomLevel(int level);
int zoomLevel() const;
void writeSettings();
protected:
- virtual KItemListWidgetCreatorBase* defaultWidgetCreator() const Q_DECL_OVERRIDE;
- virtual bool itemLayoutSupportsItemExpanding(ItemLayout layout) const Q_DECL_OVERRIDE;
- virtual void onItemLayoutChanged(ItemLayout current, ItemLayout previous) Q_DECL_OVERRIDE;
- virtual void onPreviewsShownChanged(bool shown) Q_DECL_OVERRIDE;
- virtual void onVisibleRolesChanged(const QList<QByteArray>& current,
- const QList<QByteArray>& previous) Q_DECL_OVERRIDE;
+ KItemListWidgetCreatorBase* defaultWidgetCreator() const override;
+ bool itemLayoutSupportsItemExpanding(ItemLayout layout) const override;
+ void onItemLayoutChanged(ItemLayout current, ItemLayout previous) override;
+ void onPreviewsShownChanged(bool shown) override;
+ void onVisibleRolesChanged(const QList<QByteArray>& current,
+ const QList<QByteArray>& previous) override;
- virtual void updateFont() Q_DECL_OVERRIDE;
+ void updateFont() override;
private:
void updateGridSize();
}
DolphinNewFileMenuObserver::DolphinNewFileMenuObserver() :
- QObject(0)
+ QObject(nullptr)
{
}
private:
DolphinNewFileMenuObserver();
- virtual ~DolphinNewFileMenuObserver();
+ ~DolphinNewFileMenuObserver() override;
friend class DolphinNewFileMenuObserverSingleton;
};
Q_OBJECT
public:
DolphinRemoteEncoding(QObject* parent, DolphinViewActionHandler* actionHandler);
- ~DolphinRemoteEncoding();
+ ~DolphinRemoteEncoding() override;
public Q_SLOTS:
void slotAboutToOpenUrl();
m_viewPropertiesContext(),
m_mode(DolphinView::IconsView),
m_visibleRoles(),
- m_topLayout(0),
- m_model(0),
- m_view(0),
- m_container(0),
- m_toolTipManager(0),
- m_selectionChangedTimer(0),
+ m_topLayout(nullptr),
+ m_model(nullptr),
+ m_view(nullptr),
+ m_container(nullptr),
+ m_toolTipManager(nullptr),
+ m_selectionChangedTimer(nullptr),
m_currentItemUrl(),
m_scrollToCurrentItem(false),
m_restoredContentsPosition(),
m_selectedUrls(),
m_clearSelectionBeforeSelectingNewItems(false),
m_markFirstNewlySelectedItemAsCurrent(false),
- m_versionControlObserver(0),
+ m_versionControlObserver(nullptr),
m_twoClicksRenamingTimer(nullptr)
{
m_topLayout = new QVBoxLayout(this);
#endif
QString groupName;
- QMenu* groupMenu = 0;
+ QMenu* groupMenu = nullptr;
// Add all roles to the menu that can be shown or hidden by the user
const QList<KFileItemModel::RoleInfo> rolesInfo = KFileItemModel::rolesInformation();
}
const QString text = m_model->roleDescription(info.role);
- QAction* action = 0;
+ QAction* action = nullptr;
if (info.group.isEmpty()) {
action = menu->addAction(text);
} else {
void DolphinView::slotModelChanged(KItemModelBase* current, KItemModelBase* previous)
{
- if (previous != 0) {
+ if (previous != nullptr) {
Q_ASSERT(qobject_cast<KFileItemModel*>(previous));
KFileItemModel* fileItemModel = static_cast<KFileItemModel*>(previous);
disconnect(fileItemModel, &KFileItemModel::directoryLoadingCompleted, this, &DolphinView::slotDirectoryLoadingCompleted);
- m_versionControlObserver->setModel(0);
+ m_versionControlObserver->setModel(nullptr);
}
if (current) {
{
if (m_currentItemUrl != QUrl()) {
KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
- const int currentIndex = m_model->index(m_currentItemUrl);
- if (currentIndex != -1) {
- selectionManager->setCurrentItem(currentIndex);
-
- // scroll to current item and reset the state
- if (m_scrollToCurrentItem) {
- m_view->scrollToItem(currentIndex);
- m_scrollToCurrentItem = false;
+
+ // if there is a selection already, leave it that way
+ if (!selectionManager->hasSelection()) {
+ const int currentIndex = m_model->index(m_currentItemUrl);
+ if (currentIndex != -1) {
+ selectionManager->setCurrentItem(currentIndex);
+
+ // scroll to current item and reset the state
+ if (m_scrollToCurrentItem) {
+ m_view->scrollToItem(currentIndex);
+ m_scrollToCurrentItem = false;
+ }
+ } else {
+ selectionManager->setCurrentItem(0);
}
- } else {
- selectionManager->setCurrentItem(0);
}
m_currentItemUrl = QUrl();
if (!m_selectedUrls.isEmpty()) {
KItemListSelectionManager* selectionManager = m_container->controller()->selectionManager();
- if (m_clearSelectionBeforeSelectingNewItems) {
- selectionManager->clearSelection();
- m_clearSelectionBeforeSelectingNewItems = false;
- }
+ // if there is a selection already, leave it that way
+ if (!selectionManager->hasSelection()) {
+ if (m_clearSelectionBeforeSelectingNewItems) {
+ selectionManager->clearSelection();
+ m_clearSelectionBeforeSelectingNewItems = false;
+ }
- KItemSet selectedItems = selectionManager->selectedItems();
+ KItemSet selectedItems = selectionManager->selectedItems();
- QList<QUrl>::iterator it = m_selectedUrls.begin();
- while (it != m_selectedUrls.end()) {
- const int index = m_model->index(*it);
- if (index >= 0) {
- selectedItems.insert(index);
- it = m_selectedUrls.erase(it);
- } else {
- ++it;
+ QList<QUrl>::iterator it = m_selectedUrls.begin();
+ while (it != m_selectedUrls.end()) {
+ const int index = m_model->index(*it);
+ if (index >= 0) {
+ selectedItems.insert(index);
+ it = m_selectedUrls.erase(it);
+ } else {
+ ++it;
+ }
}
- }
- selectionManager->beginAnchoredSelection(selectionManager->currentItem());
- selectionManager->setSelectedItems(selectedItems);
+ selectionManager->beginAnchoredSelection(selectionManager->currentItem());
+ selectionManager->setSelectedItems(selectedItems);
+ }
}
}
*/
DolphinView(const QUrl& url, QWidget* parent);
- virtual ~DolphinView();
+ ~DolphinView() override;
/**
* Returns the current active URL, where all actions are applied.
void stopLoading();
/** Activates the view if the item list container gets focus. */
- virtual bool eventFilter(QObject* watched, QEvent* event) Q_DECL_OVERRIDE;
+ bool eventFilter(QObject* watched, QEvent* event) override;
signals:
/**
protected:
/** Changes the zoom level if Control is pressed during a wheel event. */
- virtual void wheelEvent(QWheelEvent* event) Q_DECL_OVERRIDE;
+ void wheelEvent(QWheelEvent* event) override;
- virtual void hideEvent(QHideEvent* event) Q_DECL_OVERRIDE;
- virtual bool event(QEvent* event) Q_DECL_OVERRIDE;
+ void hideEvent(QHideEvent* event) override;
+ bool event(QEvent* event) override;
private slots:
/**
DolphinViewActionHandler::DolphinViewActionHandler(KActionCollection* collection, QObject* parent) :
QObject(parent),
m_actionCollection(collection),
- m_currentView(0),
+ m_currentView(nullptr),
m_sortByActions(),
m_visibleRoles()
{
Q_ASSERT(view);
if (m_currentView) {
- disconnect(m_currentView, 0, this, 0);
+ disconnect(m_currentView, nullptr, this, nullptr);
}
m_currentView = view;
}
QString groupName;
- KActionMenu* groupMenu = 0;
- QActionGroup* groupMenuGroup = 0;
+ KActionMenu* groupMenu = nullptr;
+ QActionGroup* groupMenuGroup = nullptr;
bool indexingEnabled = false;
#ifdef HAVE_BALOO
continue;
}
- KToggleAction* action = 0;
+ KToggleAction* action = nullptr;
const QString name = groupPrefix + info.role;
if (info.group.isEmpty()) {
action = m_actionCollection->add<KToggleAction>(name);
void DolphinViewActionHandler::slotProperties()
{
- KPropertiesDialog* dialog = 0;
+ KPropertiesDialog* dialog = nullptr;
const KFileItemList list = m_currentView->selectedItems();
if (list.isEmpty()) {
const QUrl url = m_currentView->url();
return job;
}
- return 0;
+ return nullptr;
}
#include <KIO/CopyJob>
#include <KIO/FileUndoManager>
#include <KJobUiDelegate>
+#include <KIO/BatchRenameJob>
#include <QHBoxLayout>
#include <QLabel>
QDialog(parent),
m_renameOneItem(false),
m_newName(),
- m_lineEdit(0),
+ m_lineEdit(nullptr),
m_items(items),
m_allExtensionsDifferent(true),
- m_spinBox(0)
+ m_spinBox(nullptr)
{
const QSize minSize = minimumSize();
setMinimumSize(QSize(320, minSize.height()));
QVBoxLayout* topLayout = new QVBoxLayout(page);
- QLabel* editLabel = 0;
+ QLabel* editLabel = nullptr;
if (m_renameOneItem) {
m_newName = items.first().name();
editLabel = new QLabel(xi18nc("@label:textbox", "Rename the item <filename>%1</filename> to:", m_newName),
{
}
-void RenameDialog::renameItem(const KFileItem &item, const QString& newName)
+void RenameDialog::slotAccepted()
{
- const QUrl oldUrl = item.url();
- QUrl newUrl = oldUrl.adjusted(QUrl::RemoveFilename);
- newUrl.setPath(newUrl.path() + KIO::encodeFileName(newName));
-
QWidget* widget = parentWidget();
if (!widget) {
widget = this;
}
- KIO::Job * job = KIO::moveAs(oldUrl, newUrl, KIO::HideProgressInfo);
+ KIO::FileUndoManager::CommandType cmdType;
+ if (m_renameOneItem) {
+ Q_ASSERT(m_items.count() == 1);
+ cmdType = KIO::FileUndoManager::Rename;
+ } else {
+ cmdType = KIO::FileUndoManager::BatchRename;
+ }
+
+ const QList<QUrl> srcList = m_items.urlList();
+ KIO::BatchRenameJob* job = KIO::batchRename(srcList, m_lineEdit->text(), m_spinBox->value(), QLatin1Char('#'));
KJobWidgets::setWindow(job, widget);
- KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Rename, {oldUrl}, newUrl, job);
+ const QUrl parentUrl = srcList.first().adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
+ KIO::FileUndoManager::self()->recordJob(cmdType, srcList, parentUrl, job);
- if (!job->error()) {
- m_renamedItems << newUrl;
- }
+ connect(job, &KIO::BatchRenameJob::fileRenamed, this, &RenameDialog::slotFileRenamed);
+ connect(job, &KIO::BatchRenameJob::result, this, &RenameDialog::slotResult);
job->uiDelegate()->setAutoErrorHandlingEnabled(true);
-}
-void RenameDialog::slotAccepted()
-{
- m_newName = m_lineEdit->text();
-
- if (m_renameOneItem) {
- Q_ASSERT(m_items.count() == 1);
- renameItem(m_items.first(), m_newName);
- } else {
- renameItems();
- }
accept();
}
m_okButton->setEnabled(enable);
}
-void RenameDialog::showEvent(QShowEvent* event)
+void RenameDialog::slotFileRenamed(const QUrl &oldUrl, const QUrl &newUrl)
{
- m_lineEdit->setFocus();
-
- QDialog::showEvent(event);
+ Q_UNUSED(oldUrl)
+ m_renamedItems << newUrl;
}
-void RenameDialog::renameItems()
+void RenameDialog::slotResult(KJob *job)
{
- // Iterate through all items and rename them...
- int index = m_spinBox->value();
- foreach (const KFileItem& item, m_items) {
- QString newName = indexedName(m_newName, index, QLatin1Char('#'));
- ++index;
-
- const QUrl oldUrl = item.url();
- QMimeDatabase db;
- const QString extension = db.suffixForFileName(oldUrl.path().toLower());
- if (!extension.isEmpty()) {
- newName.append(QLatin1Char('.'));
- newName.append(extension);
- }
-
- if (oldUrl.fileName() != newName) {
- renameItem(item, newName);
- }
- }
-
- if (!m_items.empty()) {
+ if (!job->error()) {
emit renamingFinished(m_renamedItems);
}
}
-QString RenameDialog::indexedName(const QString& name, int index, const QChar& indexPlaceHolder)
+void RenameDialog::showEvent(QShowEvent* event)
{
- QString newName = name;
-
- QString indexString = QString::number(index);
-
- // Insert leading zeros if necessary
- const int minIndexLength = name.count(indexPlaceHolder);
- while (indexString.length() < minIndexLength) {
- indexString.prepend(QLatin1Char('0'));
- }
-
- // Replace the index placeholders by the indexString
- const int placeHolderStart = newName.indexOf(indexPlaceHolder);
- newName.replace(placeHolderStart, minIndexLength, indexString);
+ m_lineEdit->setFocus();
- return newName;
+ QDialog::showEvent(event);
}
-
class QLineEdit;
class QSpinBox;
class QPushButton;
-
+class KJob;
/**
* @brief Dialog for renaming a variable number of files.
*/
public:
explicit RenameDialog(QWidget* parent, const KFileItemList& items);
- virtual ~RenameDialog();
+ ~RenameDialog() override;
signals:
void renamingFinished(const QList<QUrl>& urls);
private slots:
void slotAccepted();
void slotTextChanged(const QString& newName);
+ void slotFileRenamed(const QUrl& oldUrl, const QUrl& newUrl);
+ void slotResult(KJob* job);
protected:
void showEvent(QShowEvent* event) override;
-private:
- void renameItems();
- void renameItem(const KFileItem &item, const QString& newName);
-
- /**
- * @return Returns the string \p name, where the characters represented by
- * \p indexPlaceHolder get replaced by the index \p index.
- * E. g. Calling indexedName("Test #.jpg", 12, '#') returns "Test 12.jpg".
- * A connected sequence of placeholders results in leading zeros:
- * indexedName("Test ####.jpg", 12, '#') returns "Test 0012.jpg".
- */
- static QString indexedName(const QString& name, int index, const QChar& indexPlaceHolder);
-
private:
bool m_renameOneItem;
QList<QUrl> m_renamedItems;
DolphinFileMetaDataWidget::DolphinFileMetaDataWidget(QWidget* parent) :
QWidget(parent),
- m_preview(0),
- m_name(0),
- m_fileMetaDataWidget(0)
+ m_preview(nullptr),
+ m_name(nullptr),
+ m_fileMetaDataWidget(nullptr)
{
// Create widget for file preview
m_preview = new QLabel(this);
Q_OBJECT
public:
- DolphinFileMetaDataWidget(QWidget* parent = 0);
- virtual ~DolphinFileMetaDataWidget();
+ DolphinFileMetaDataWidget(QWidget* parent = nullptr);
+ ~DolphinFileMetaDataWidget() override;
void setPreview(const QPixmap& pixmap);
QPixmap preview() const;
ToolTipManager::ToolTipManager(QWidget* parent) :
QObject(parent),
- m_showToolTipTimer(0),
- m_contentRetrievalTimer(0),
- m_transientParent(0),
- m_fileMetaDataWidget(0),
+ m_showToolTipTimer(nullptr),
+ m_contentRetrievalTimer(nullptr),
+ m_transientParent(nullptr),
+ m_fileMetaDataWidget(nullptr),
m_toolTipRequested(false),
m_metaDataRequested(false),
m_appliedWaitCursor(false),
public:
explicit ToolTipManager(QWidget* parent);
- virtual ~ToolTipManager();
+ ~ToolTipManager() override;
/**
* Triggers the showing of the tooltip for the item \p item
MissingVersion
};
- KVersionControlPlugin(QObject* parent = 0);
- virtual ~KVersionControlPlugin();
+ KVersionControlPlugin(QObject* parent = nullptr);
+ ~KVersionControlPlugin() override;
/**
* Returns the name of the file which stores
UpdateItemStatesThread::UpdateItemStatesThread(KVersionControlPlugin* plugin,
const QMap<QString, QVector<VersionControlObserver::ItemState> >& itemStates) :
QThread(),
- m_globalPluginMutex(0),
+ m_globalPluginMutex(nullptr),
m_plugin(plugin),
m_itemStates(itemStates)
{
*/
UpdateItemStatesThread(KVersionControlPlugin* plugin,
const QMap<QString, QVector<VersionControlObserver::ItemState> >& itemStates);
- virtual ~UpdateItemStatesThread();
+ ~UpdateItemStatesThread() override;
QMap<QString, QVector<VersionControlObserver::ItemState> > itemStates() const;
protected:
- virtual void run() Q_DECL_OVERRIDE;
+ void run() override;
private:
QMutex* m_globalPluginMutex; // Protects the m_plugin globally
m_pendingItemStatesUpdate(false),
m_versionedDirectory(false),
m_silentUpdate(false),
- m_model(0),
- m_dirVerificationTimer(0),
- m_plugin(0),
- m_updateItemStatesThread(0)
+ m_model(nullptr),
+ m_dirVerificationTimer(nullptr),
+ m_plugin(nullptr),
+ m_updateItemStatesThread(nullptr)
{
// The verification timer specifies the timeout until the shown directory
// is checked whether it is versioned. Per default it is assumed that users
{
if (m_plugin) {
m_plugin->disconnect(this);
- m_plugin = 0;
+ m_plugin = nullptr;
}
}
void VersionControlObserver::slotThreadFinished()
{
UpdateItemStatesThread* thread = m_updateItemStatesThread;
- m_updateItemStatesThread = 0; // The thread deletes itself automatically (see updateItemStates())
+ m_updateItemStatesThread = nullptr; // The thread deletes itself automatically (see updateItemStates())
if (!m_plugin || !thread) {
return;
if (!pluginsAvailable) {
// A searching for plugins has already been done, but no
// plugins are installed
- return 0;
+ return nullptr;
}
if (plugins.isEmpty()) {
}
if (plugins.isEmpty()) {
pluginsAvailable = false;
- return 0;
+ return nullptr;
}
}
// We use the number of upUrl() calls to find the best matching plugin
// for the given directory. The smaller value, the better it is (0 is best).
- KVersionControlPlugin* bestPlugin = 0;
+ KVersionControlPlugin* bestPlugin = nullptr;
int bestScore = INT_MAX;
// Verify whether the current directory contains revision information
Q_OBJECT
public:
- explicit VersionControlObserver(QObject* parent = 0);
- virtual ~VersionControlObserver();
+ explicit VersionControlObserver(QObject* parent = nullptr);
+ ~VersionControlObserver() override;
void setModel(KFileItemModel* model);
KFileItemModel* model() const;
Q_OBJECT
public:
- explicit ViewModeController(QObject* parent = 0);
- virtual ~ViewModeController();
+ explicit ViewModeController(QObject* parent = nullptr);
+ ~ViewModeController() override;
/**
* @return URL that is shown by the view mode implementation.
ViewProperties::ViewProperties(const QUrl& url) :
m_changedProps(false),
m_autoSave(true),
- m_node(0)
+ m_node(nullptr)
{
GeneralSettings* settings = GeneralSettings::self();
const bool useGlobalViewProps = settings->globalViewProps() || url.isEmpty();
}
delete m_node;
- m_node = 0;
+ m_node = nullptr;
}
void ViewProperties::setViewMode(DolphinView::Mode mode)
projects / dolphin.git / commitdiff