settings/viewmodes/viewmodesettings.cpp
settings/viewpropertiesdialog.cpp
settings/viewpropsprogressinfo.cpp
- views/additionalinfoaccessor.cpp
views/dolphindirlister.cpp
views/dolphinfileitemlistwidget.cpp
views/dolphinitemlistcontainer.cpp
views/dolphinviewactionhandler.cpp
views/draganddrophelper.cpp
views/renamedialog.cpp
+ views/rolesaccessor.cpp
views/tooltips/filemetadatatooltip.cpp
views/tooltips/tooltipmanager.cpp
views/versioncontrol/updateitemstatesthread.cpp
#include <QLabel>
#include <QVBoxLayout>
-#include "views/additionalinfoaccessor.h"
+#include "views/rolesaccessor.h"
AdditionalInfoDialog::AdditionalInfoDialog(QWidget* parent,
- const QList<DolphinView::AdditionalInfo>& infoList) :
+ const QList<QByteArray>& visibleRoles) :
KDialog(parent),
- m_infoList(infoList),
+ m_visibleRoles(visibleRoles),
m_checkBoxes()
{
setCaption(i18nc("@title:window", "Additional Information"));
layout->addWidget(header);
// Add checkboxes
- const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
- const QList<DolphinView::AdditionalInfo> keys = infoAccessor.keys();
- foreach (DolphinView::AdditionalInfo info, keys) {
- QCheckBox* checkBox = new QCheckBox(infoAccessor.translation(info), mainWidget);
- checkBox->setChecked(infoList.contains(info));
+ const RolesAccessor& rolesAccessor = RolesAccessor::instance();
+ const QList<QByteArray> roles = rolesAccessor.roles();
+ foreach (const QByteArray& role, roles) {
+ QCheckBox* checkBox = new QCheckBox(rolesAccessor.translation(role), mainWidget);
+ checkBox->setChecked(visibleRoles.contains(role));
layout->addWidget(checkBox);
m_checkBoxes.append(checkBox);
}
saveDialogSize(dialogConfig, KConfigBase::Persistent);
}
-QList<DolphinView::AdditionalInfo> AdditionalInfoDialog::informationList() const
+QList<QByteArray> AdditionalInfoDialog::visibleRoles() const
{
- return m_infoList;
+ return m_visibleRoles;
}
void AdditionalInfoDialog::slotOk()
{
- m_infoList.clear();
+ m_visibleRoles.clear();
- const QList<DolphinView::AdditionalInfo> keys = AdditionalInfoAccessor::instance().keys();
+ const QList<QByteArray> roles = RolesAccessor::instance().roles();
int index = 0;
- foreach (DolphinView::AdditionalInfo info, keys) {
+ foreach (const QByteArray& role, roles) {
if (m_checkBoxes[index]->isChecked()) {
- m_infoList.append(info);
+ m_visibleRoles.append(role);
}
++index;
}
#ifndef ADDITIONALINFODIALOG_H
#define ADDITIONALINFODIALOG_H
-#include <views/dolphinview.h>
#include <KDialog>
#include <QList>
class QCheckBox;
/**
- * @brief Dialog for changing the additional information properties of a directory.
+ * @brief Dialog for changing the additional information shown in the view.
*/
class AdditionalInfoDialog : public KDialog
{
Q_OBJECT
public:
- AdditionalInfoDialog(QWidget* parent, const QList<DolphinView::AdditionalInfo>& infoList);
+ AdditionalInfoDialog(QWidget* parent, const QList<QByteArray>& visibleRoles);
virtual ~AdditionalInfoDialog();
- QList<DolphinView::AdditionalInfo> informationList() const;
+ QList<QByteArray> visibleRoles() const;
private slots:
void slotOk();
private:
- QList<DolphinView::AdditionalInfo> m_infoList;
+ QList<QByteArray> m_visibleRoles;
QList<QCheckBox*> m_checkBoxes;
};
m_viewProps->setViewMode(viewProps.viewMode());
m_viewProps->setPreviewsShown(viewProps.previewsShown());
m_viewProps->setHiddenFilesShown(viewProps.hiddenFilesShown());
- m_viewProps->setSorting(viewProps.sorting());
+ m_viewProps->setSortRole(viewProps.sortRole());
m_viewProps->setSortOrder(viewProps.sortOrder());
KIO::ListJob* listJob = KIO::listRecursive(dir, KIO::HideProgressInfo);
<default>false</default>
</entry>
- <entry name="Sorting" type="Int" >
+ <entry name="SortRole" type="String" >
<label context="@label">Sort files by</label>
<whatsthis context="@info:whatsthis">This option defines which attribute (name, size, date, etc.) sorting is performed on.</whatsthis>
- <default code="true">DolphinView::SortByName</default>
+ <default code="true">"name"</default>
</entry>
<entry name="SortOrder" type="Int" >
<default>true</default>
</entry>
- <entry name="AdditionalInfo" type="StringList">
- <label context="@label">Additional information</label>
+ <entry name="VisibleRoles" type="StringList">
+ <label context="@label">Visible roles</label>
<default></default>
</entry>
#include "viewpropertiesdialog.h"
#include "additionalinfodialog.h"
+#include "views/rolesaccessor.h"
#include "views/dolphinview.h"
#include "dolphin_generalsettings.h"
#include "dolphin_iconsmodesettings.h"
m_sortOrder->addItem(i18nc("@item:inlistbox Sort", "Ascending"));
m_sortOrder->addItem(i18nc("@item:inlistbox Sort", "Descending"));
- // TODO: Provide a kind of SortingInfoAccessor similar to AdditionalInfoAccessor
- // to assure that adding a sort-role requires to change only one file
m_sorting = new KComboBox(sortingBox);
- m_sorting->addItem(i18nc("@item:inlistbox Sort", "By Name"));
- m_sorting->addItem(i18nc("@item:inlistbox Sort", "By Size"));
- m_sorting->addItem(i18nc("@item:inlistbox Sort", "By Date"));
- m_sorting->addItem(i18nc("@item:inlistbox Sort", "By Permissions"));
- m_sorting->addItem(i18nc("@item:inlistbox Sort", "By Owner"));
- m_sorting->addItem(i18nc("@item:inlistbox Sort", "By Group"));
- m_sorting->addItem(i18nc("@item:inlistbox Sort", "By Type"));
- m_sorting->addItem(i18nc("@item:inlistbox Sort", "By Link Destination"));
- m_sorting->addItem(i18nc("@item:inlistbox Sort", "By Path"));
+ const RolesAccessor& rolesAccessor = RolesAccessor::instance();
+ const QList<QByteArray> roles = rolesAccessor.roles();
+ foreach (const QByteArray& role, roles) {
+ m_sorting->addItem(rolesAccessor.translation(role), role);
+ }
m_sortFoldersFirst = new QCheckBox(i18nc("@option:check", "Show folders first"));
m_previewsShown = new QCheckBox(i18nc("@option:check", "Show preview"));
void ViewPropertiesDialog::slotSortingChanged(int index)
{
- m_viewProps->setSorting(static_cast<DolphinView::Sorting>(index));
+ const QByteArray role = m_sorting->itemData(index).toByteArray();
+ m_viewProps->setSortRole(role);
markAsDirty(true);
}
void ViewPropertiesDialog::configureAdditionalInfo()
{
- QList<DolphinView::AdditionalInfo> infoList = m_viewProps->additionalInfoList();
- const bool useDefaultInfo = (m_viewProps->viewMode() == DolphinView::DetailsView) &&
- (infoList.isEmpty() || infoList.contains(DolphinView::NoInfo));
- if (useDefaultInfo) {
+ QList<QByteArray> visibleRoles = m_viewProps->visibleRoles();
+ const bool useDefaultRoles = (m_viewProps->viewMode() == DolphinView::DetailsView) && visibleRoles.isEmpty();
+ if (useDefaultRoles) {
// Using the details view without any additional information (-> additional column)
// makes no sense and leads to a usability problem as no viewport area is available
// anymore. Hence as fallback provide at least a size and date column.
- infoList.clear();
- infoList.append(DolphinView::SizeInfo);
- infoList.append(DolphinView::DateInfo);
- m_viewProps->setAdditionalInfoList(infoList);
+ visibleRoles.clear();
+ visibleRoles.append("name");
+ visibleRoles.append("size");
+ visibleRoles.append("date");
+ m_viewProps->setVisibleRoles(visibleRoles);
}
- QPointer<AdditionalInfoDialog> dialog = new AdditionalInfoDialog(this, infoList);
+ QPointer<AdditionalInfoDialog> dialog = new AdditionalInfoDialog(this, visibleRoles);
if (dialog->exec() == QDialog::Accepted) {
- m_viewProps->setAdditionalInfoList(dialog->informationList());
+ m_viewProps->setVisibleRoles(dialog->visibleRoles());
markAsDirty(true);
}
delete dialog;
}
m_dolphinView->setMode(m_viewProps->viewMode());
- m_dolphinView->setSorting(m_viewProps->sorting());
+ m_dolphinView->setSortRole(m_viewProps->sortRole());
m_dolphinView->setSortOrder(m_viewProps->sortOrder());
m_dolphinView->setSortFoldersFirst(m_viewProps->sortFoldersFirst());
m_dolphinView->setGroupedSorting(m_viewProps->groupedSorting());
- m_dolphinView->setAdditionalInfoList(m_viewProps->additionalInfoList());
+ m_dolphinView->setVisibleRoles(m_viewProps->visibleRoles());
m_dolphinView->setPreviewsShown(m_viewProps->previewsShown());
m_dolphinView->setHiddenFilesShown(m_viewProps->hiddenFilesShown());
// Load sort order and sorting
const int sortOrderIndex = (m_viewProps->sortOrder() == Qt::AscendingOrder) ? 0 : 1;
m_sortOrder->setCurrentIndex(sortOrderIndex);
- m_sorting->setCurrentIndex(m_viewProps->sorting());
+
+ const QList<QByteArray> roles = RolesAccessor::instance().roles();
+ const int sortRoleIndex = roles.indexOf(m_viewProps->sortRole());
+ m_sorting->setCurrentIndex(sortRoleIndex);
+
m_sortFoldersFirst->setChecked(m_viewProps->sortFoldersFirst());
// Load show preview, show in groups and show hidden files settings
+++ /dev/null
-/***************************************************************************
- * Copyright (C) 2010 by Peter Penz <peter.penz19@gmail.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 "additionalinfoaccessor.h"
-
-#include <KGlobal>
-#include <KLocale>
-
-class AdditionalInfoAccessorSingleton
-{
-public:
- AdditionalInfoAccessor instance;
-};
-K_GLOBAL_STATIC(AdditionalInfoAccessorSingleton, s_additionalInfoManager)
-
-AdditionalInfoAccessor& AdditionalInfoAccessor::instance()
-{
- return s_additionalInfoManager->instance;
-}
-
-QList<DolphinView::AdditionalInfo> AdditionalInfoAccessor::keys() const
-{
- return m_map.keys();
-}
-
-QByteArray AdditionalInfoAccessor::role(DolphinView::AdditionalInfo info) const
-{
- return m_map[info]->role;
-}
-
-DolphinView::AdditionalInfo AdditionalInfoAccessor::additionalInfo(const QByteArray& role) const
-{
- return m_infoForRole.value(role);
-}
-
-QString AdditionalInfoAccessor::actionCollectionName(DolphinView::AdditionalInfo info,
- ActionCollectionType type) const
-{
- QString name;
- switch (type) {
- case SortByType:
- name = QLatin1String("sort_by_") + QLatin1String(m_map[info]->role);
- break;
-
- case AdditionalInfoType:
- name = QLatin1String("show_") + QLatin1String(m_map[info]->role);
- break;
- }
-
- return name;
-}
-
-QString AdditionalInfoAccessor::translation(DolphinView::AdditionalInfo info) const
-{
- return i18nc(m_map[info]->roleTranslationContext, m_map[info]->roleTranslation);
-}
-
-QString AdditionalInfoAccessor::value(DolphinView::AdditionalInfo info) const
-{
- return m_map[info]->value;
-}
-
-DolphinView::Sorting AdditionalInfoAccessor::sorting(DolphinView::AdditionalInfo info) const
-{
- return m_map[info]->sorting;
-}
-
-AdditionalInfoAccessor::AdditionalInfoAccessor() :
- m_map(),
- m_infoForRole()
-{
- static const AdditionalInfoAccessor::AdditionalInfo additionalInfo[] = {
- // role roleTranslationContext roleTranslation value sorting
- { "size", I18N_NOOP2_NOSTRIP("@label", "Size"), "Size", DolphinView::SortBySize},
- { "date", I18N_NOOP2_NOSTRIP("@label", "Date"), "Date", DolphinView::SortByDate},
- { "permissions", I18N_NOOP2_NOSTRIP("@label", "Permissions"), "Permissions", DolphinView::SortByPermissions},
- { "owner", I18N_NOOP2_NOSTRIP("@label", "Owner"), "Owner", DolphinView::SortByOwner},
- { "group", I18N_NOOP2_NOSTRIP("@label", "Group"), "Group", DolphinView::SortByGroup},
- { "type", I18N_NOOP2_NOSTRIP("@label", "Type"), "Type", DolphinView::SortByType},
- { "destination", I18N_NOOP2_NOSTRIP("@label", "Link Destination"), "LinkDestination", DolphinView::SortByDestination},
- { "path", I18N_NOOP2_NOSTRIP("@label", "Path"), "Path", DolphinView::SortByPath}
- };
-
- m_map.insert(DolphinView::SizeInfo, &additionalInfo[0]);
- m_map.insert(DolphinView::DateInfo, &additionalInfo[1]);
- m_map.insert(DolphinView::PermissionsInfo, &additionalInfo[2]);
- m_map.insert(DolphinView::OwnerInfo, &additionalInfo[3]);
- m_map.insert(DolphinView::GroupInfo, &additionalInfo[4]);
- m_map.insert(DolphinView::TypeInfo, &additionalInfo[5]);
- m_map.insert(DolphinView::DestinationInfo, &additionalInfo[6]);
- m_map.insert(DolphinView::PathInfo, &additionalInfo[7]);
-
- QMapIterator<DolphinView::AdditionalInfo, const AdditionalInfo*> it(m_map);
- while (it.hasNext()) {
- it.next();
- m_infoForRole.insert(it.value()->role, it.key());
- }
-}
-
-AdditionalInfoAccessor::~AdditionalInfoAccessor()
-{
-}
+++ /dev/null
-/***************************************************************************
- * Copyright (C) 2010 by Peter Penz <peter.penz19@gmail.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 *
- ***************************************************************************/
-
-#ifndef ADDITIONALINFOACCESSOR_H
-#define ADDITIONALINFOACCESSOR_H
-
-#include <libdolphin_export.h>
-#include <KFileItemDelegate>
-#include <views/dolphinview.h>
-
-#include <QList>
-#include <QMap>
-
-/**
- * @brief Allows to access the information that is available by KFileItemDelegate::Information.
- *
- * The information that is available by KFileItemDelegate::Information will be shown
- * in Dolphin the following way:
- * - As additional columns in the details view
- * - As additional lines in the icons view
- * - As menu entries in the "Sort By" and "Additional Information" groups
- * - As popup menu entries in the details view header popup
- * - As checkable entries in the View Properties dialog
- *
- * The AdditionalInfoAccessor provides a central place to get all available keys,
- * the corresponding translations, action names, etc., so that modifications or
- * extensions in KFileItemDelegate only require adjustments in the implementation
- * of this class.
- */
-class LIBDOLPHINPRIVATE_EXPORT AdditionalInfoAccessor
-{
-public:
- enum ActionCollectionType {
- /// Action collection from "View -> Sort By"
- SortByType,
- /// Action collection from "View -> Additional Information"
- AdditionalInfoType
- };
-
- static AdditionalInfoAccessor& instance();
-
- /**
- * @return List of all available information entries of KFileItemDelegate.
- * All entries of this list are keys for accessing the corresponding
- * data (see actionCollectionName(), translation(), bitValue()).
- */
- QList<DolphinView::AdditionalInfo> keys() const;
-
- QByteArray role(DolphinView::AdditionalInfo info) const;
-
- DolphinView::AdditionalInfo additionalInfo(const QByteArray& role) const;
-
- QString actionCollectionName(DolphinView::AdditionalInfo info, ActionCollectionType type) const;
-
- QString translation(DolphinView::AdditionalInfo info) const;
-
- /**
- * @return String representation of the value that is stored in the .directory
- * by ViewProperties.
- */
- // TODO Dolphin 3.0: Deprecate - just use role() instead.
- QString value(DolphinView::AdditionalInfo info) const;
-
- DolphinView::Sorting sorting(DolphinView::AdditionalInfo info) const;
-
-protected:
- AdditionalInfoAccessor();
- virtual ~AdditionalInfoAccessor();
- friend class AdditionalInfoAccessorSingleton;
-
-private:
- struct AdditionalInfo {
- const char* const role;
- const char* const roleTranslationContext;
- const char* const roleTranslation;
- const char* const value; // TODO Dolphin 3.0: Deprecate and use role instead
- const DolphinView::Sorting sorting;
- };
-
- QMap<DolphinView::AdditionalInfo, const AdditionalInfo*> m_map;
- QHash<QByteArray, DolphinView::AdditionalInfo> m_infoForRole;
-};
-
-#endif
-
#include <KToggleAction>
#include <KUrl>
-#include "additionalinfoaccessor.h"
+#include "rolesaccessor.h"
#include "dolphindirlister.h"
#include "dolphinnewfilemenuobserver.h"
#include "dolphin_detailsmodesettings.h"
namespace {
const int MaxModeEnum = DolphinView::CompactView;
- const int MaxSortingEnum = DolphinView::SortByPath;
};
DolphinView::DolphinView(const KUrl& url, QWidget* parent) :
m_dragging(false),
m_url(url),
m_mode(DolphinView::IconsView),
- m_additionalInfoList(),
+ m_visibleRoles(),
m_topLayout(0),
m_dirLister(0),
m_container(0),
return m_container->zoomLevel();
}
-void DolphinView::setSorting(Sorting sorting)
+void DolphinView::setSortRole(const QByteArray& role)
{
- if (sorting != this->sorting()) {
- updateSorting(sorting);
+ if (role != sortRole()) {
+ updateSortRole(role);
}
}
-DolphinView::Sorting DolphinView::sorting() const
+QByteArray DolphinView::sortRole() const
{
- KItemModelBase* model = m_container->controller()->model();
- return sortingForSortRole(model->sortRole());
+ const KItemModelBase* model = m_container->controller()->model();
+ return model->sortRole();
}
void DolphinView::setSortOrder(Qt::SortOrder order)
return model->sortFoldersFirst();
}
-void DolphinView::setAdditionalInfoList(const QList<AdditionalInfo>& info)
+void DolphinView::setVisibleRoles(const QList<QByteArray>& roles)
{
- const QList<AdditionalInfo> previousList = info;
+ const QList<QByteArray> previousRoles = roles;
ViewProperties props(url());
- props.setAdditionalInfoList(info);
+ props.setVisibleRoles(roles);
- m_additionalInfoList = info;
- applyAdditionalInfoListToView();
+ m_visibleRoles = roles;
+ m_container->setVisibleRoles(roles);
- emit additionalInfoListChanged(m_additionalInfoList, previousList);
+ emit visibleRolesChanged(m_visibleRoles, previousRoles);
}
-QList<DolphinView::AdditionalInfo> DolphinView::additionalInfoList() const
+QList<QByteArray> DolphinView::visibleRoles() const
{
- return m_additionalInfoList;
+ return m_visibleRoles;
}
void DolphinView::reload()
const QSet<QByteArray> visibleRolesSet = view->visibleRoles().toSet();
// Add all roles to the menu that can be shown or hidden by the user
- const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
- const QList<DolphinView::AdditionalInfo> keys = infoAccessor.keys();
- foreach (const DolphinView::AdditionalInfo info, keys) {
- const QByteArray& role = infoAccessor.role(info);
+ const RolesAccessor& rolesAccessor = RolesAccessor::instance();
+ const QList<QByteArray> roles = rolesAccessor.roles();
+ foreach (const QByteArray& role, roles) {
if (role != "name") {
const QString text = fileItemModel()->roleDescription(role);
QAction* action = menu.data()->addAction(text);
action->setCheckable(true);
action->setChecked(visibleRolesSet.contains(role));
- action->setData(info);
+ action->setData(role);
}
}
QAction* action = menu.data()->exec(pos.toPoint());
if (action) {
// Show or hide the selected role
- const DolphinView::AdditionalInfo info =
- static_cast<DolphinView::AdditionalInfo>(action->data().toInt());
+ const QByteArray selectedRole = action->data().toByteArray();
ViewProperties props(url());
- QList<DolphinView::AdditionalInfo> infoList = props.additionalInfoList();
-
- const QByteArray selectedRole = infoAccessor.role(info);
QList<QByteArray> visibleRoles = view->visibleRoles();
-
if (action->isChecked()) {
- const int index = keys.indexOf(info) + 1;
+ const int index = roles.indexOf(selectedRole) + 1;
visibleRoles.insert(index, selectedRole);
- infoList.insert(index, info);
} else {
visibleRoles.removeOne(selectedRole);
- infoList.removeOne(info);
}
view->setVisibleRoles(visibleRoles);
- props.setAdditionalInfoList(infoList);
+ props.setVisibleRoles(visibleRoles);
}
delete menu.data();
emit selectionChanged(selectedItems());
}
-void DolphinView::updateSorting(DolphinView::Sorting sorting)
+void DolphinView::updateSortRole(const QByteArray& role)
{
ViewProperties props(url());
- props.setSorting(sorting);
+ props.setSortRole(role);
KItemModelBase* model = m_container->controller()->model();
- model->setSortRole(sortRoleForSorting(sorting));
+ model->setSortRole(role);
- emit sortingChanged(sorting);
+ emit sortRoleChanged(role);
}
void DolphinView::updateSortOrder(Qt::SortOrder order)
Q_ASSERT(fileItemModel()->sortRole() == current);
ViewProperties props(url());
- const Sorting sorting = sortingForSortRole(current);
- props.setSorting(sorting);
+ props.setSortRole(current);
- emit sortingChanged(sorting);
+ emit sortRoleChanged(current);
}
void DolphinView::slotVisibleRolesChangedByHeader(const QList<QByteArray>& current,
Q_UNUSED(previous);
Q_ASSERT(m_container->controller()->view()->visibleRoles() == current);
- const QList<AdditionalInfo> previousAdditionalInfoList = m_additionalInfoList;
+ const QList<QByteArray> previousVisibleRoles = m_visibleRoles;
- m_additionalInfoList.clear();
- m_additionalInfoList.reserve(current.count());
- const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
- foreach (const QByteArray& role, current) {
- if (role != "name") {
- m_additionalInfoList.append(infoAccessor.additionalInfo(role));
- }
- }
+ m_visibleRoles = current;
ViewProperties props(url());
- props.setAdditionalInfoList(m_additionalInfoList);
+ props.setVisibleRoles(m_visibleRoles);
- emit additionalInfoListChanged(m_additionalInfoList, previousAdditionalInfoList);
+ emit visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
}
KFileItemModel* DolphinView::fileItemModel() const
emit groupedSortingChanged(groupedSorting);
}
- const DolphinView::Sorting sorting = props.sorting();
- const QByteArray newSortRole = sortRoleForSorting(sorting);
- if (newSortRole != model->sortRole()) {
- model->setSortRole(newSortRole);
- emit sortingChanged(sorting);
+ const QByteArray sortRole = props.sortRole();
+ if (sortRole != model->sortRole()) {
+ model->setSortRole(sortRole);
+ emit sortRoleChanged(sortRole);
}
const Qt::SortOrder sortOrder = props.sortOrder();
emit sortFoldersFirstChanged(sortFoldersFirst);
}
- const QList<DolphinView::AdditionalInfo> infoList = props.additionalInfoList();
- if (infoList != m_additionalInfoList) {
- const QList<DolphinView::AdditionalInfo> previousList = m_additionalInfoList;
- m_additionalInfoList = infoList;
- applyAdditionalInfoListToView();
- emit additionalInfoListChanged(m_additionalInfoList, previousList);
+ const QList<QByteArray> visibleRoles = props.visibleRoles();
+ if (visibleRoles != m_visibleRoles) {
+ const QList<QByteArray> previousVisibleRoles = m_visibleRoles;
+ m_visibleRoles = visibleRoles;
+ m_container->setVisibleRoles(visibleRoles);
+ emit visibleRolesChanged(m_visibleRoles, previousVisibleRoles);
}
const bool previewsShown = props.previewsShown();
m_container->endTransaction();
}
-void DolphinView::applyAdditionalInfoListToView()
-{
- const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
-
- QList<QByteArray> visibleRoles;
- visibleRoles.reserve(m_additionalInfoList.count() + 1);
- visibleRoles.append("name");
-
- foreach (AdditionalInfo info, m_additionalInfoList) {
- visibleRoles.append(infoAccessor.role(info));
- }
-
- m_container->setVisibleRoles(visibleRoles);
-}
-
void DolphinView::pasteToUrl(const KUrl& url)
{
markPastedUrlsAsSelected(QApplication::clipboard()->mimeData());
}
}
-QByteArray DolphinView::sortRoleForSorting(Sorting sorting) const
-{
- switch (sorting) {
- case SortByName: return "name";
- case SortBySize: return "size";
- case SortByDate: return "date";
- case SortByPermissions: return "permissions";
- case SortByOwner: return "owner";
- case SortByGroup: return "group";
- case SortByType: return "type";
- case SortByDestination: return "destination";
- case SortByPath: return "path";
- default: break;
- }
-
- return QByteArray();
-}
-
-DolphinView::Sorting DolphinView::sortingForSortRole(const QByteArray& sortRole) const
-{
- static QHash<QByteArray, DolphinView::Sorting> sortHash;
- if (sortHash.isEmpty()) {
- sortHash.insert("name", SortByName);
- sortHash.insert("size", SortBySize);
- sortHash.insert("date", SortByDate);
- sortHash.insert("permissions", SortByPermissions);
- sortHash.insert("owner", SortByOwner);
- sortHash.insert("group", SortByGroup);
- sortHash.insert("type", SortByType);
- sortHash.insert("destination", SortByDestination);
- sortHash.insert("path", SortByPath);
- }
- return sortHash.value(sortRole);
-}
-
QString DolphinView::fileSizeText(KIO::filesize_t fileSize)
{
const KLocale* locale = KGlobal::locale();
CompactView
};
- /** Defines the sort order for the items of a directory. */
- enum Sorting
- {
- SortByName = 0,
- SortBySize,
- SortByDate,
- SortByPermissions,
- SortByOwner,
- SortByGroup,
- SortByType,
- SortByDestination,
- SortByPath
- };
-
- /** Defines the additional information shown for the items of a directory. */
- enum AdditionalInfo
- {
- NoInfo = 0,
- SizeInfo,
- DateInfo,
- PermissionsInfo,
- OwnerInfo,
- GroupInfo,
- TypeInfo,
- DestinationInfo,
- PathInfo
- };
-
/**
* @param url Specifies the content which should be shown.
* @param parent Parent widget of the view.
*/
bool isZoomOutPossible() const;
- /** Sets the sorting criterion (e.g., SortByName, SortBySize,...) of the items inside a directory (see DolphinView::Sorting). */
- void setSorting(Sorting sorting);
-
- /** Returns the sorting criterion (e.g., SortByName, SortBySize,...) of the items inside a directory (see DolphinView::Sorting). */
- Sorting sorting() const;
+ void setSortRole(const QByteArray& role);
+ QByteArray sortRole() const;
- /** Sets the sort order (Qt::Ascending or Qt::Descending) for the items. */
void setSortOrder(Qt::SortOrder order);
-
- /** Returns the currently used sort order (Qt::Ascending or Qt::Descending). */
Qt::SortOrder sortOrder() const;
/** Sets a separate sorting with folders first (true) or a mixed sorting of files and folders (false). */
void setSortFoldersFirst(bool foldersFirst);
-
- /** Returns if files and folders are sorted separately or not. */
bool sortFoldersFirst() const;
/** Sets the additional information which should be shown for the items. */
- void setAdditionalInfoList(const QList<AdditionalInfo>& info);
+ void setVisibleRoles(const QList<QByteArray>& roles);
/** Returns the additional information which should be shown for the items. */
- QList<AdditionalInfo> additionalInfoList() const;
+ QList<QByteArray> visibleRoles() const;
/** Reloads the current directory. */
void reload();
void groupedSortingChanged(bool groupedSorting);
/** Is emitted if the sorting by name, size or date has been changed. */
- void sortingChanged(DolphinView::Sorting sorting);
+ void sortRoleChanged(const QByteArray& role);
/** Is emitted if the sort order (ascending or descending) has been changed. */
void sortOrderChanged(Qt::SortOrder order);
- /** Is emitted if the sorting of files and folders (separate with folders first or mixed) has been changed. */
+ /**
+ * Is emitted if the sorting of files and folders (separate with folders
+ * first or mixed) has been changed.
+ */
void sortFoldersFirstChanged(bool foldersFirst);
/** Is emitted if the additional information shown for this view has been changed. */
- void additionalInfoListChanged(const QList<DolphinView::AdditionalInfo>& current,
- const QList<DolphinView::AdditionalInfo>& previous);
+ void visibleRolesChanged(const QList<QByteArray>& current,
+ const QList<QByteArray>& previous);
/** Is emitted if the zoom level has been changed by zooming in or out. */
void zoomLevelChanged(int current, int previous);
/**
* Updates the view properties of the current URL to the
- * sorting given by \a sorting.
+ * sorting given by \a role.
*/
- void updateSorting(DolphinView::Sorting sorting);
+ void updateSortRole(const QByteArray& role);
/**
* Updates the view properties of the current URL to the
*/
void applyViewProperties();
- void applyAdditionalInfoListToView();
-
/**
* Helper method for DolphinView::paste() and DolphinView::pasteIntoFolder().
* Pastes the clipboard data into the URL \a url.
*/
void updateWritableState();
- QByteArray sortRoleForSorting(Sorting sorting) const;
- Sorting sortingForSortRole(const QByteArray& sortRole) const;
-
/**
* Returns the text for the filesize by converting it to the best fitting
* unit.
KUrl m_url;
Mode m_mode;
- QList<AdditionalInfo> m_additionalInfoList;
+ QList<QByteArray> m_visibleRoles;
QVBoxLayout* m_topLayout;
#include "dolphinviewactionhandler.h"
-#include "additionalinfoaccessor.h"
+#include "rolesaccessor.h"
#include "settings/viewpropertiesdialog.h"
#include "views/dolphinview.h"
#include "views/zoomlevelinfo.h"
this, SLOT(slotSortOrderChanged(Qt::SortOrder)));
connect(view, SIGNAL(sortFoldersFirstChanged(bool)),
this, SLOT(slotSortFoldersFirstChanged(bool)));
- connect(view, SIGNAL(additionalInfoListChanged(QList<DolphinView::AdditionalInfo>,
- QList<DolphinView::AdditionalInfo>)),
- this, SLOT(slotAdditionalInfoListChanged(QList<DolphinView::AdditionalInfo>,
- QList<DolphinView::AdditionalInfo>)));
+ connect(view, SIGNAL(visibleRolesChanged(QList<QByteArray>,QList<QByteArray>)),
+ this, SLOT(slotVisibleRolesChanged(QList<QByteArray>,QList<QByteArray>)));
connect(view, SIGNAL(groupedSortingChanged(bool)),
this, SLOT(slotGroupedSortingChanged(bool)));
connect(view, SIGNAL(hiddenFilesShownChanged(bool)),
this, SLOT(slotHiddenFilesShownChanged(bool)));
- connect(view, SIGNAL(sortingChanged(DolphinView::Sorting)),
- this, SLOT(slotSortingChanged(DolphinView::Sorting)));
+ connect(view, SIGNAL(sortRoleChanged(QByteArray)),
+ this, SLOT(slotSortRoleChanged(QByteArray)));
connect(view, SIGNAL(zoomLevelChanged(int,int)),
this, SLOT(slotZoomLevelChanged(int,int)));
}
showInformationMenu->setText(i18nc("@action:inmenu View", "Additional Information"));
showInformationMenu->setDelayed(false);
- const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+ const RolesAccessor& rolesAccessor = RolesAccessor::instance();
- const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
- foreach (DolphinView::AdditionalInfo info, infoList) {
- const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::AdditionalInfoType);
+ const QList<QByteArray> roles = rolesAccessor.roles();
+ foreach (const QByteArray& role, roles) {
+ if (role == "name") {
+ // It should not be possible to hide the "name" role
+ continue;
+ }
+
+ const QString name = QLatin1String("show_") + role;
KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
- action->setText(infoAccessor.translation(info));
- action->setData(info);
+ action->setText(rolesAccessor.translation(role));
+ action->setData(role);
action->setActionGroup(additionalInfoGroup);
}
return additionalInfoGroup;
}
-Q_DECLARE_METATYPE(DolphinView::Sorting)
-
QActionGroup* DolphinViewActionHandler::createSortByActionGroup()
{
QActionGroup* sortByActionGroup = new QActionGroup(m_actionCollection);
sortByActionGroup->setExclusive(true);
- KToggleAction* sortByName = m_actionCollection->add<KToggleAction>("sort_by_name");
- sortByName->setText(i18nc("@action:inmenu Sort By", "Name"));
- sortByName->setData(QVariant::fromValue(DolphinView::SortByName));
- sortByActionGroup->addAction(sortByName);
-
- const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
- const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
- foreach (DolphinView::AdditionalInfo info, infoList) {
- const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
+ const RolesAccessor& rolesAccessor = RolesAccessor::instance();
+ const QList<QByteArray> roles = rolesAccessor.roles();
+ foreach (const QByteArray& role, roles) {
+ const QString name = QLatin1String("sort_by_") + role;
KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
- action->setText(infoAccessor.translation(info));
- const DolphinView::Sorting sorting = infoAccessor.sorting(info);
- action->setData(QVariant::fromValue(sorting));
+ action->setText(rolesAccessor.translation(role));
+ action->setData(role);
sortByActionGroup->addAction(action);
}
slotSortOrderChanged(m_currentView->sortOrder());
slotSortFoldersFirstChanged(m_currentView->sortFoldersFirst());
- slotAdditionalInfoListChanged(m_currentView->additionalInfoList(), QList<DolphinView::AdditionalInfo>());
+ slotVisibleRolesChanged(m_currentView->visibleRoles(), QList<QByteArray>());
slotGroupedSortingChanged(m_currentView->groupedSorting());
- slotSortingChanged(m_currentView->sorting());
+ slotSortRoleChanged(m_currentView->sortRole());
slotZoomLevelChanged(m_currentView->zoomLevel(), -1);
QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
{
emit actionBeingHandled();
- const DolphinView::AdditionalInfo info =
- static_cast<DolphinView::AdditionalInfo>(action->data().toInt());
+ const QByteArray toggledRole = action->data().toByteArray();
- QList<DolphinView::AdditionalInfo> list = m_currentView->additionalInfoList();
+ QList<QByteArray> roles = m_currentView->visibleRoles();
const bool show = action->isChecked();
- const int index = list.indexOf(info);
+ const int index = roles.indexOf(toggledRole);
const bool containsInfo = (index >= 0);
if (show && !containsInfo) {
- list.append(info);
- m_currentView->setAdditionalInfoList(list);
+ roles.append(toggledRole);
+ m_currentView->setVisibleRoles(roles);
} else if (!show && containsInfo) {
- list.removeAt(index);
- m_currentView->setAdditionalInfoList(list);
- Q_ASSERT(list.indexOf(info) < 0);
+ roles.removeAt(index);
+ m_currentView->setVisibleRoles(roles);
+ Q_ASSERT(roles.indexOf(toggledRole) < 0);
}
}
-void DolphinViewActionHandler::slotAdditionalInfoListChanged(const QList<DolphinView::AdditionalInfo>& current,
- const QList<DolphinView::AdditionalInfo>& previous)
+void DolphinViewActionHandler::slotVisibleRolesChanged(const QList<QByteArray>& current,
+ const QList<QByteArray>& previous)
{
Q_UNUSED(previous);
- const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
+ const RolesAccessor& rolesAccessor = RolesAccessor::instance();
- const QList<DolphinView::AdditionalInfo> checkedInfo = current;
- const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
+ const QSet<QByteArray> checkedRoles = current.toSet();
+ const QList<QByteArray> roles = rolesAccessor.roles();
- foreach (DolphinView::AdditionalInfo info, infoList) {
- const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::AdditionalInfoType);
+ foreach (const QByteArray& role, roles) {
+ const QString name = QLatin1String("show_") + role;
QAction* action = m_actionCollection->action(name);
- Q_ASSERT(action);
- action->setChecked(checkedInfo.contains(info));
+ if (action) {
+ action->setChecked(checkedRoles.contains(role));
+ }
}
}
return detailsView;
}
-void DolphinViewActionHandler::slotSortingChanged(DolphinView::Sorting sorting)
+void DolphinViewActionHandler::slotSortRoleChanged(const QByteArray& role)
{
- QAction* action = 0;
- if (sorting == DolphinView::SortByName) {
- action = m_actionCollection->action("sort_by_name");
- } else {
- const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
- const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
- foreach (DolphinView::AdditionalInfo info, infoList) {
- if (sorting == infoAccessor.sorting(info)) {
- const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
- action = m_actionCollection->action(name);
- break;
- }
- }
- }
-
+ const QString name = QLatin1String("sort_by_") + role;
+ QAction* action = m_actionCollection->action(name);
if (action) {
action->setChecked(true);
void DolphinViewActionHandler::slotSortTriggered(QAction* action)
{
- const DolphinView::Sorting sorting = action->data().value<DolphinView::Sorting>();
- m_currentView->setSorting(sorting);
+ const QByteArray role = action->data().toByteArray();
+ m_currentView->setSortRole(role);
}
void DolphinViewActionHandler::slotAdjustViewProperties()
/**
* Updates the state of the 'Sort by' actions.
*/
- void slotSortingChanged(DolphinView::Sorting sorting);
+ void slotSortRoleChanged(const QByteArray& role);
/**
* Updates the state of the 'Zoom In' and 'Zoom Out' actions.
/**
* Updates the state of the 'Additional Information' actions.
*/
- void slotAdditionalInfoListChanged(const QList<DolphinView::AdditionalInfo>& current,
- const QList<DolphinView::AdditionalInfo>& previous);
+ void slotVisibleRolesChanged(const QList<QByteArray>& current,
+ const QList<QByteArray>& previous);
/**
* Switches between sorting by groups or not.
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2010 by Peter Penz <peter.penz19@gmail.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 "rolesaccessor.h"
+
+#include <KGlobal>
+#include <KLocale>
+
+class RolesAccessorSingleton
+{
+public:
+ RolesAccessor instance;
+};
+K_GLOBAL_STATIC(RolesAccessorSingleton, s_rolesAccessor)
+
+RolesAccessor& RolesAccessor::instance()
+{
+ return s_rolesAccessor->instance;
+}
+
+QList<QByteArray> RolesAccessor::roles() const
+{
+ return m_roles;
+}
+
+QString RolesAccessor::translation(const QByteArray& role) const
+{
+ return i18nc(m_translation[role]->roleTranslationContext, m_translation[role]->roleTranslation);
+}
+
+RolesAccessor::RolesAccessor() :
+ m_roles(),
+ m_translation()
+{
+ static const RolesAccessor::Translation translations[] = {
+ // role roleTranslationContext roleTranslation
+ { "name", I18N_NOOP2_NOSTRIP("@label", "Name") },
+ { "size", I18N_NOOP2_NOSTRIP("@label", "Size") },
+ { "date", I18N_NOOP2_NOSTRIP("@label", "Date") },
+ { "permissions", I18N_NOOP2_NOSTRIP("@label", "Permissions") },
+ { "owner", I18N_NOOP2_NOSTRIP("@label", "Owner") },
+ { "group", I18N_NOOP2_NOSTRIP("@label", "Group") },
+ { "type", I18N_NOOP2_NOSTRIP("@label", "Type") },
+ { "destination", I18N_NOOP2_NOSTRIP("@label", "Link Destination") },
+ { "path", I18N_NOOP2_NOSTRIP("@label", "Path") }
+ };
+
+ for (unsigned int i = 0; i < sizeof(translations) / sizeof(Translation); ++i) {
+ m_translation.insert(translations[i].role, &translations[i]);
+ m_roles.append(translations[i].role);
+ }
+}
+
+RolesAccessor::~RolesAccessor()
+{
+}
--- /dev/null
+/***************************************************************************
+ * Copyright (C) 2010 by Peter Penz <peter.penz19@gmail.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 *
+ ***************************************************************************/
+
+#ifndef ROLESACCESSOR_H
+#define ROLESACCESSOR_H
+
+#include <libdolphin_export.h>
+
+#include <QList>
+#include <QHash>
+
+/**
+ * @brief Allows to access the available roles that can be shown in a view.
+ */
+class LIBDOLPHINPRIVATE_EXPORT RolesAccessor
+{
+public:
+ static RolesAccessor& instance();
+
+ /**
+ * @return List of all available roles.
+ */
+ QList<QByteArray> roles() const;
+
+ /**
+ * @return Translation of the role that can be shown e.g. in the header
+ * of a view or as menu-entry.
+ */
+ QString translation(const QByteArray& role) const;
+
+protected:
+ RolesAccessor();
+ virtual ~RolesAccessor();
+ friend class RolesAccessorSingleton;
+
+private:
+ struct Translation {
+ const char* const role;
+ const char* const roleTranslationContext;
+ const char* const roleTranslation;
+ };
+
+ QList<QByteArray> m_roles;
+ QHash<QByteArray, const Translation*> m_translation;
+};
+
+#endif
+
#include "viewproperties.h"
-#include "additionalinfoaccessor.h"
+#include "rolesaccessor.h"
#include "dolphin_directoryviewpropertysettings.h"
#include "dolphin_generalsettings.h"
namespace {
// String representation to mark the additional properties of
// the details view as customized by the user. See
- // ViewProperties::additionalInfoList() for more information.
+ // ViewProperties::visibleRoles() for more information.
const char* CustomizedDetailsString = "CustomizedDetails";
}
if (useDefaultProps) {
if (useDetailsViewWithPath) {
setViewMode(DolphinView::DetailsView);
- setAdditionalInfoList(QList<DolphinView::AdditionalInfo>() << DolphinView::PathInfo);
+ setVisibleRoles(QList<QByteArray>() << "path");
} else {
// The global view-properties act as default for directories without
// any view-property configuration
return m_node->hiddenFilesShown();
}
-void ViewProperties::setSorting(DolphinView::Sorting sorting)
+void ViewProperties::setSortRole(const QByteArray& role)
{
- if (m_node->sorting() != sorting) {
- m_node->setSorting(sorting);
+ if (m_node->sortRole() != role) {
+ m_node->setSortRole(role);
update();
}
}
-DolphinView::Sorting ViewProperties::sorting() const
+QByteArray ViewProperties::sortRole() const
{
- return static_cast<DolphinView::Sorting>(m_node->sorting());
+ return m_node->sortRole().toLatin1();
}
void ViewProperties::setSortOrder(Qt::SortOrder sortOrder)
return m_node->sortFoldersFirst();
}
-void ViewProperties::setAdditionalInfoList(const QList<DolphinView::AdditionalInfo>& list)
+void ViewProperties::setVisibleRoles(const QList<QByteArray>& roles)
{
- // See ViewProperties::additionalInfoList() for the storage format
+ // See ViewProperties::visibleRoles() for the storage format
// of the additional information.
// Remove the old values stored for the current view-mode
- const QStringList oldInfoStringList = m_node->additionalInfo();
+ const QStringList oldVisibleRoles = m_node->visibleRoles();
const QString prefix = viewModePrefix();
- QStringList newInfoStringList = oldInfoStringList;
- for (int i = newInfoStringList.count() - 1; i >= 0; --i) {
- if (newInfoStringList.at(i).startsWith(prefix)) {
- newInfoStringList.removeAt(i);
+ QStringList newVisibleRoles = oldVisibleRoles;
+ for (int i = newVisibleRoles.count() - 1; i >= 0; --i) {
+ if (newVisibleRoles[i].startsWith(prefix)) {
+ newVisibleRoles.removeAt(i);
}
}
// Add the updated values for the current view-mode
- AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
- foreach (DolphinView::AdditionalInfo info, list) {
- newInfoStringList.append(prefix + infoAccessor.value(info));
+ foreach (const QByteArray& role, roles) {
+ newVisibleRoles.append(prefix + role);
}
- if (oldInfoStringList != newInfoStringList) {
+ if (oldVisibleRoles != newVisibleRoles) {
const bool markCustomizedDetails = (m_node->viewMode() == DolphinView::DetailsView)
- && !newInfoStringList.contains(CustomizedDetailsString);
+ && !newVisibleRoles.contains(CustomizedDetailsString);
if (markCustomizedDetails) {
// The additional information of the details-view has been modified. Set a marker,
- // so that it is allowed to also show no additional information
- // (see fallback in ViewProperties::additionalInfoV2, if no additional information is
- // available).
- newInfoStringList.append(CustomizedDetailsString);
+ // so that it is allowed to also show no additional information without doing the
+ // fallback to show the size and date per default.
+ newVisibleRoles.append(CustomizedDetailsString);
}
- m_node->setAdditionalInfo(newInfoStringList);
+ m_node->setVisibleRoles(newVisibleRoles);
update();
}
}
-QList<DolphinView::AdditionalInfo> ViewProperties::additionalInfoList() const
+QList<QByteArray> ViewProperties::visibleRoles() const
{
// The shown additional information is stored for each view-mode separately as
// string with the view-mode as prefix. Example:
//
- // AdditionalInfo=Details_Size,Details_Date,Details_Owner,Icon_Size
+ // AdditionalInfo=Details_size,Details_date,Details_owner,Icons_size
//
- // To get the representation as QList<DolphinView::AdditionalInfo>, the current
+ // To get the representation as QList<QByteArray>, the current
// view-mode must be checked and the values of this mode added to the list.
//
// For the details-view a special case must be respected: Per default the size
// by "CustomizedDetails"), also a details-view with no additional information
// is accepted.
- QList<DolphinView::AdditionalInfo> usedInfo;
+ QList<QByteArray> roles;
+ roles.append("name");
- // infoHash allows to get the mapped DolphinView::AdditionalInfo value
- // for a stored string-value in a fast way
- static QHash<QString, DolphinView::AdditionalInfo> infoHash;
- if (infoHash.isEmpty()) {
- AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
- const QList<DolphinView::AdditionalInfo> keys = infoAccessor.keys();
- foreach (DolphinView::AdditionalInfo key, keys) {
- infoHash.insert(infoAccessor.value(key), key);
- }
- }
-
- // Iterate through all stored keys stored as strings and map them to
- // the corresponding DolphinView::AdditionalInfo values.
+ // Iterate through all stored keys and append all roles that match to
+ // the curren view mode.
const QString prefix = viewModePrefix();
const int prefixLength = prefix.length();
- const QStringList infoStringList = m_node->additionalInfo();
- foreach (const QString& infoString, infoStringList) {
- if (infoString.startsWith(prefix)) {
- const QString key = infoString.right(infoString.length() - prefixLength);
- if (infoHash.contains(key)) {
- usedInfo.append(infoHash.value(key));
- } else {
- kWarning() << "Did not find the key" << key << "in the information string";
+ const QStringList visibleRoles = m_node->visibleRoles();
+ foreach (const QString& visibleRole, visibleRoles) {
+ if (visibleRole.startsWith(prefix)) {
+ const QByteArray role = visibleRole.right(visibleRole.length() - prefixLength).toLatin1();
+ if (role != "name") {
+ roles.append(role);
}
}
}
// For the details view the size and date should be shown per default
// until the additional information has been explicitly changed by the user
- const bool useDefaultValues = usedInfo.isEmpty()
+ const bool useDefaultValues = roles.count() == 1 // "name"
&& (m_node->viewMode() == DolphinView::DetailsView)
- && !infoStringList.contains(CustomizedDetailsString);
- Q_UNUSED(useDefaultValues);
+ && !visibleRoles.contains(CustomizedDetailsString);
if (useDefaultValues) {
- usedInfo.append(DolphinView::SizeInfo);
- usedInfo.append(DolphinView::DateInfo);
+ roles.append("size");
+ roles.append("date");
}
- return usedInfo;
+ return roles;
}
void ViewProperties::setDirProperties(const ViewProperties& props)
setPreviewsShown(props.previewsShown());
setHiddenFilesShown(props.hiddenFilesShown());
setGroupedSorting(props.groupedSorting());
- setSorting(props.sorting());
+ setSortRole(props.sortRole());
setSortOrder(props.sortOrder());
setSortFoldersFirst(props.sortFoldersFirst());
- setAdditionalInfoList(props.additionalInfoList());
+ setVisibleRoles(props.visibleRoles());
}
void ViewProperties::setAutoSaveEnabled(bool autoSave)
void setGroupedSorting(bool grouped);
bool groupedSorting() const;
- void setSorting(DolphinView::Sorting sorting);
- DolphinView::Sorting sorting() const;
+ void setSortRole(const QByteArray& role);
+ QByteArray sortRole() const;
void setSortOrder(Qt::SortOrder sortOrder);
Qt::SortOrder sortOrder() const;
* Note that the additional-info property is the only property where
* the value is dependent from another property (in this case the view-mode).
*/
- void setAdditionalInfoList(const QList<DolphinView::AdditionalInfo>& info);
+ void setVisibleRoles(const QList<QByteArray>& info);
/**
* Returns the additional information for the current set view-mode.
* Note that the additional-info property is the only property where
* the value is dependent from another property (in this case the view-mode).
*/
- QList<DolphinView::AdditionalInfo> additionalInfoList() const;
+ QList<QByteArray> visibleRoles() const;
/**
* Sets the directory properties view mode, show preview,
projects / dolphin.git / commitdiff