#include "viewproperties.h"
#include "dolphinsettings.h"
#include "dolphin_generalsettings.h"
-#include "dolphincategorydrawer.h"
DolphinView::DolphinView(QWidget* parent,
const KUrl& url,
m_active(true),
m_loadingDirectory(false),
m_initializeColumnView(false),
+ m_storedCategorizedSorting(false),
m_mode(DolphinView::IconsView),
m_topLayout(0),
m_controller(0),
m_fileItemDelegate(0),
m_dolphinModel(dolphinModel),
m_dirLister(dirLister),
- m_proxyModel(proxyModel),
- m_rootUrl(url)
+ m_proxyModel(proxyModel)
{
setFocusPolicy(Qt::StrongFocus);
m_topLayout = new QVBoxLayout(this);
connect(m_dirLister, SIGNAL(completed()),
this, SLOT(updateCutItems()));
- connect(m_dirLister, SIGNAL(newItems(const QList<KFileItem>&)),
- this, SLOT(generatePreviews(const QList<KFileItem>&)));
+ connect(m_dirLister, SIGNAL(newItems(const KFileItemList&)),
+ this, SLOT(generatePreviews(const KFileItemList&)));
m_controller = new DolphinController(this);
m_controller->setUrl(url);
return m_controller->url();
}
-void DolphinView::setRootUrl(const KUrl& url)
-{
- m_rootUrl = url;
-}
-
KUrl DolphinView::rootUrl() const
{
return isColumnViewActive() ? m_dirLister->url() : url();
props.setViewMode(m_mode);
createView();
+
+ // Not all view modes support categorized sorting. Adjust the sorting model
+ // if changing the view mode results in a change of the categorized sorting
+ // capabilities.
+ m_storedCategorizedSorting = props.categorizedSorting();
+ const bool categorized = m_storedCategorizedSorting && supportsCategorizedSorting();
+ if (categorized != m_proxyModel->isCategorizedModel()) {
+ m_proxyModel->setCategorizedModel(categorized);
+ m_proxyModel->sort(m_proxyModel->sortColumn(), m_proxyModel->sortOrder());
+ emit categorizedSortingChanged();
+ }
+
startDirLister(viewPropsUrl);
emit modeChanged();
void DolphinView::setCategorizedSorting(bool categorized)
{
- if (!supportsCategorizedSorting() || (categorized == categorizedSorting())) {
+ if (categorized == categorizedSorting()) {
return;
}
- Q_ASSERT(m_iconsView != 0);
+ // setCategorizedSorting(true) may only get invoked
+ // if the view supports categorized sorting
+ Q_ASSERT(!categorized || supportsCategorizedSorting());
ViewProperties props(viewPropertiesUrl());
props.setCategorizedSorting(categorized);
props.save();
+ m_storedCategorizedSorting = categorized;
m_proxyModel->setCategorizedModel(categorized);
m_proxyModel->sort(m_proxyModel->sortColumn(), m_proxyModel->sortOrder());
bool DolphinView::categorizedSorting() const
{
- return m_proxyModel->isCategorizedModel();
+ // If all view modes would support categorized sorting, returning
+ // m_proxyModel->isCategorizedModel() would be the way to go. As
+ // currently only the icons view supports caterized sorting, we remember
+ // the stored view properties state in m_storedCategorizedSorting and
+ // return this state. The application takes care to disable the corresponding
+ // checkbox by checking DolphinView::supportsCategorizedSorting() to indicate
+ // that this setting is not applied to the current view mode.
+ return m_storedCategorizedSorting;
}
bool DolphinView::supportsCategorizedSorting() const
void DolphinView::invertSelection()
{
- QItemSelectionModel* selectionModel = itemView()->selectionModel();
- const QAbstractItemModel* itemModel = selectionModel->model();
+ if (isColumnViewActive()) {
+ // QAbstractItemView does not offer a virtual method invertSelection()
+ // as counterpart to QAbstractItemView::selectAll(). This makes it
+ // necessary to delegate the inverting of the selection to the
+ // column view, as only the selection of the active column should get
+ // inverted.
+ m_columnView->invertSelection();
+ } else {
+ QItemSelectionModel* selectionModel = itemView()->selectionModel();
+ const QAbstractItemModel* itemModel = selectionModel->model();
- const QModelIndex topLeft = itemModel->index(0, 0);
- const QModelIndex bottomRight = itemModel->index(itemModel->rowCount() - 1,
- itemModel->columnCount() - 1);
+ const QModelIndex topLeft = itemModel->index(0, 0);
+ const QModelIndex bottomRight = itemModel->index(itemModel->rowCount() - 1,
+ itemModel->columnCount() - 1);
- QItemSelection selection(topLeft, bottomRight);
- selectionModel->select(selection, QItemSelectionModel::Toggle);
+ const QItemSelection selection(topLeft, bottomRight);
+ selectionModel->select(selection, QItemSelectionModel::Toggle);
+ }
}
bool DolphinView::hasSelection() const
itemView()->selectionModel()->clear();
}
-QList<KFileItem> DolphinView::selectedItems() const
+KFileItemList DolphinView::selectedItems() const
{
const QAbstractItemView* view = itemView();
Q_ASSERT((view != 0) && (view->selectionModel() != 0));
const QItemSelection selection = m_proxyModel->mapSelectionToSource(view->selectionModel()->selection());
- QList<KFileItem> itemList;
+ KFileItemList itemList;
const QModelIndexList indexList = selection.indexes();
foreach (QModelIndex index, indexList) {
KUrl::List DolphinView::selectedUrls() const
{
KUrl::List urls;
- const QList<KFileItem> list = selectedItems();
- for ( QList<KFileItem>::const_iterator it = list.begin(), end = list.end();
- it != end; ++it ) {
- urls.append((*it).url());
+ const KFileItemList list = selectedItems();
+ foreach (KFileItem item, list) {
+ urls.append(item.url());
}
return urls;
}
return m_proxyModel->sortOrder();
}
-void DolphinView::setAdditionalInfo(KFileItemDelegate::AdditionalInformation info)
+void DolphinView::setAdditionalInfo(KFileItemDelegate::InformationList info)
{
const KUrl viewPropsUrl = viewPropertiesUrl();
ViewProperties props(viewPropsUrl);
props.setAdditionalInfo(info);
- m_controller->setShowAdditionalInfo(info != KFileItemDelegate::NoInformation);
- m_fileItemDelegate->setAdditionalInformation(info);
+ m_controller->setShowAdditionalInfo(!info.isEmpty());
+ m_fileItemDelegate->setShowInformation(info);
emit additionalInfoChanged(info);
startDirLister(viewPropsUrl, true);
}
-KFileItemDelegate::AdditionalInformation DolphinView::additionalInfo() const
+void DolphinView::setAdditionalInfo(KFileItemDelegate::Information info)
{
- return m_fileItemDelegate->additionalInformation();
+ KFileItemDelegate::InformationList list;
+ if (info != KFileItemDelegate::NoInformation)
+ list << info;
+
+ setAdditionalInfo(list);
+}
+
+KFileItemDelegate::InformationList DolphinView::additionalInfo() const
+{
+ return m_fileItemDelegate->showInformation();
}
void DolphinView::reload()
updateViewportColor();
}
-void DolphinView::setUrl(const KUrl& url)
+void DolphinView::updateView(const KUrl& url, const KUrl& rootUrl)
{
if (m_controller->url() == url) {
return;
}
- const KUrl oldRootUrl = rootUrl();
+ const bool restoreColumnView = !rootUrl.isEmpty()
+ && !rootUrl.equals(url, KUrl::CompareWithoutTrailingSlash)
+ && rootUrl.isParentOf(url);
+
m_controller->setUrl(url); // emits urlChanged, which we forward
- bool useUrlProperties = true;
- const bool restoreColumnView = !isColumnViewActive()
- && m_rootUrl.isParentOf(url)
- && (m_rootUrl != url);
if (restoreColumnView) {
- applyViewProperties(m_rootUrl);
- if (itemView() == m_columnView) {
- startDirLister(m_rootUrl);
- m_columnView->showColumn(url);
- useUrlProperties = false;
- }
- }
-
- if (useUrlProperties) {
+ applyViewProperties(rootUrl);
+ Q_ASSERT(itemView() == m_columnView);
+ startDirLister(rootUrl);
+ m_columnView->showColumn(url);
+ } else {
applyViewProperties(url);
startDirLister(url);
}
itemView()->setFocus();
- const KUrl newRootUrl = rootUrl();
- if (newRootUrl != oldRootUrl) {
- emit rootUrlChanged(newRootUrl);
- }
+ emit startedPathLoading(url);
+}
+
+void DolphinView::setUrl(const KUrl& url)
+{
+ updateView(url, KUrl());
}
void DolphinView::mouseReleaseEvent(QMouseEvent* event)
emit itemTriggered(item); // caught by DolphinViewContainer or DolphinPart
}
-void DolphinView::generatePreviews(const QList<KFileItem>& items)
+void DolphinView::generatePreviews(const KFileItemList& items)
{
if (m_controller->showPreview()) {
KIO::PreviewJob* job = KIO::filePreview(items, 128);
const QMimeData* mimeData = QApplication::clipboard()->mimeData();
if (KonqMimeData::decodeIsCutSelection(mimeData) && isCutItem(item)) {
KIconEffect iconEffect;
- const QPixmap cutPixmap = iconEffect.apply(pixmap, K3Icon::Desktop, K3Icon::DisabledState);
+ const QPixmap cutPixmap = iconEffect.apply(pixmap, KIconLoader::Desktop, KIconLoader::DisabledState);
m_dolphinModel->setData(idx, QIcon(cutPixmap), Qt::DecorationRole);
} else {
m_dolphinModel->setData(idx, QIcon(pixmap), Qt::DecorationRole);
emit showHiddenFilesChanged();
}
- const bool categorized = props.categorizedSorting();
- if (categorized != categorizedSorting()) {
+ m_storedCategorizedSorting = props.categorizedSorting();
+ const bool categorized = m_storedCategorizedSorting && supportsCategorizedSorting();
+ if (categorized != m_proxyModel->isCategorizedModel()) {
m_proxyModel->setCategorizedModel(categorized);
+ m_proxyModel->sort(m_proxyModel->sortColumn(), m_proxyModel->sortOrder());
emit categorizedSortingChanged();
}
emit sortOrderChanged(sortOrder);
}
- KFileItemDelegate::AdditionalInformation info = props.additionalInfo();
- if (info != m_fileItemDelegate->additionalInformation()) {
- m_controller->setShowAdditionalInfo(info != KFileItemDelegate::NoInformation);
- m_fileItemDelegate->setAdditionalInformation(info);
+ KFileItemDelegate::InformationList info = props.additionalInfo();
+ if (info != m_fileItemDelegate->showInformation()) {
+ m_controller->setShowAdditionalInfo(!info.isEmpty());
+ m_fileItemDelegate->setShowInformation(info);
emit additionalInfoChanged(info);
}
}
}
-void DolphinView::changeSelection(const QList<KFileItem>& selection)
+void DolphinView::changeSelection(const KFileItemList& selection)
{
clearSelection();
if (selection.isEmpty()) {
// ... and recreate it representing the current mode
switch (m_mode) {
- case IconsView:
+ case IconsView: {
m_iconsView = new DolphinIconsView(this, m_controller);
- m_iconsView->setCategoryDrawer(new DolphinCategoryDrawer());
view = m_iconsView;
break;
+ }
case DetailsView:
m_detailsView = new DolphinDetailsView(this, m_controller);
KFileItemList::const_iterator it = items.begin();
const KFileItemList::const_iterator end = items.end();
while (it != end) {
- KFileItem* item = *it;
- if (isCutItem(*item)) {
- const QModelIndex index = m_dolphinModel->indexForItem(*item);
+ const KFileItem item = *it;
+ if (isCutItem(item)) {
+ const QModelIndex index = m_dolphinModel->indexForItem(item);
// Huh? the item is already known
//const KFileItem item = m_dolphinModel->itemForIndex(index);
const QVariant value = m_dolphinModel->data(index, Qt::DecorationRole);
// remember current pixmap for the item to be able
// to restore it when other items get cut
CutItem cutItem;
- cutItem.url = item->url();
+ cutItem.url = item.url();
cutItem.pixmap = pixmap;
m_cutItemsCache.append(cutItem);
// apply icon effect to the cut item
KIconEffect iconEffect;
- pixmap = iconEffect.apply(pixmap, K3Icon::Desktop, K3Icon::DisabledState);
+ pixmap = iconEffect.apply(pixmap, KIconLoader::Desktop, KIconLoader::DisabledState);
m_dolphinModel->setData(index, QIcon(pixmap), Qt::DecorationRole);
}
}
projects / dolphin.git / blobdiff