+void DolphinView::pasteIntoFolder()
+{
+ const KFileItemList items = selectedItems();
+ if ((items.count() == 1) && items.first().isDir()) {
+ pasteToUrl(items.first().url());
+ }
+}
+
+void DolphinView::setShowPreview(bool show)
+{
+ if (m_showPreview == show) {
+ return;
+ }
+
+ const KUrl viewPropsUrl = viewPropertiesUrl();
+ ViewProperties props(viewPropsUrl);
+ props.setShowPreview(show);
+
+ m_showPreview = show;
+ m_previewGenerator->setPreviewShown(show);
+
+ const int oldZoomLevel = m_controller->zoomLevel();
+ emit showPreviewChanged();
+
+ // Enabling or disabling the preview might change the icon size of the view.
+ // As the view does not emit a signal when the icon size has been changed,
+ // the used zoom level of the controller must be adjusted manually:
+ updateZoomLevel(oldZoomLevel);
+
+ loadDirectory(viewPropsUrl);
+}
+
+void DolphinView::setShowHiddenFiles(bool show)
+{
+ if (m_dirLister->showingDotFiles() == show) {
+ return;
+ }
+
+ const KUrl viewPropsUrl = viewPropertiesUrl();
+ ViewProperties props(viewPropsUrl);
+ props.setShowHiddenFiles(show);
+
+ m_dirLister->setShowingDotFiles(show);
+ emit showHiddenFilesChanged();
+
+ loadDirectory(viewPropsUrl);
+}
+
+void DolphinView::setCategorizedSorting(bool categorized)
+{
+ if (categorized == categorizedSorting()) {
+ return;
+ }
+
+ // setCategorizedSorting(true) may only get invoked
+ // if the view supports categorized sorting
+ Q_ASSERT(!categorized || supportsCategorizedSorting());
+
+ ViewProperties props(viewPropertiesUrl());
+ props.setCategorizedSorting(categorized);
+ props.save();
+
+ m_storedCategorizedSorting = categorized;
+ m_proxyModel->setCategorizedModel(categorized);
+
+ emit categorizedSortingChanged();
+}
+
+void DolphinView::toggleSortOrder()
+{
+ const Qt::SortOrder order = (sortOrder() == Qt::AscendingOrder) ?
+ Qt::DescendingOrder :
+ Qt::AscendingOrder;
+ setSortOrder(order);
+}
+
+void DolphinView::toggleAdditionalInfo(QAction* action)
+{
+ const KFileItemDelegate::Information info =
+ static_cast<KFileItemDelegate::Information>(action->data().toInt());
+
+ KFileItemDelegate::InformationList list = additionalInfo();
+
+ const bool show = action->isChecked();
+
+ const int index = list.indexOf(info);
+ const bool containsInfo = (index >= 0);
+ if (show && !containsInfo) {
+ list.append(info);
+ setAdditionalInfo(list);
+ } else if (!show && containsInfo) {
+ list.removeAt(index);
+ setAdditionalInfo(list);
+ Q_ASSERT(list.indexOf(info) < 0);
+ }
+}
+
+void DolphinView::mouseReleaseEvent(QMouseEvent* event)
+{
+ QWidget::mouseReleaseEvent(event);
+ setActive(true);
+}
+
+void DolphinView::wheelEvent(QWheelEvent* event)
+{
+ if (event->modifiers() & Qt::ControlModifier) {
+ const int delta = event->delta();
+ const int level = zoomLevel();
+ if (delta > 0) {
+ setZoomLevel(level + 1);
+ } else if (delta < 0) {
+ setZoomLevel(level - 1);
+ }
+ event->accept();
+ }
+}
+
+bool DolphinView::eventFilter(QObject* watched, QEvent* event)
+{
+ switch (event->type()) {
+ case QEvent::FocusIn:
+ if (watched == itemView()) {
+ m_controller->requestActivation();
+ }
+ break;
+
+ case QEvent::MouseButtonPress:
+ kDebug() << "m_expandedDragSource = " << m_expandedDragSource;
+ if ((watched == itemView()->viewport()) && (m_expandedDragSource != 0)) {
+ // Listening to a mousebutton press event to delete expanded views is a
+ // workaround, as it seems impossible for the FolderExpander to know when
+ // a dragging outside a view has been finished. However it works quite well:
+ // A mousebutton press event indicates that a drag operation must be
+ // finished already.
+ kDebug() << "Deleted view " << m_expandedDragSource;
+ m_expandedDragSource->deleteLater();
+ m_expandedDragSource = 0;
+ }
+ break;
+
+ case QEvent::DragEnter:
+ if (watched == itemView()->viewport()) {
+ setActive(true);
+ }
+ break;
+
+ case QEvent::KeyPress:
+ if ((watched == itemView()) && (m_toolTipManager != 0)) {
+ m_toolTipManager->hideTip();
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return QWidget::eventFilter(watched, event);
+}
+
+void DolphinView::activate()
+{
+ setActive(true);
+}
+
+void DolphinView::triggerItem(const KFileItem& item)
+{
+ const Qt::KeyboardModifiers modifier = QApplication::keyboardModifiers();
+ if ((modifier & Qt::ShiftModifier) || (modifier & Qt::ControlModifier)) {
+ // items are selected by the user, hence don't trigger the
+ // item specified by 'index'
+ return;
+ }
+
+ // TODO: the m_isContextMenuOpen check is a workaround for Qt-issue 207192
+ if (item.isNull() || m_isContextMenuOpen) {
+ return;
+ }
+
+ if (m_toolTipManager != 0) {
+ m_toolTipManager->hideTip();
+ }
+ emit itemTriggered(item); // caught by DolphinViewContainer or DolphinPart
+}
+
+void DolphinView::emitSelectionChangedSignal()
+{
+ emit selectionChanged(DolphinView::selectedItems());
+}
+
+void DolphinView::openContextMenu(const QPoint& pos,
+ const QList<QAction*>& customActions)
+{
+ KFileItem item;
+ if (isColumnViewActive()) {
+ item = m_columnView->itemAt(pos);
+ } else {
+ const QModelIndex index = itemView()->indexAt(pos);
+ if (index.isValid() && (index.column() == DolphinModel::Name)) {
+ const QModelIndex dolphinModelIndex = m_proxyModel->mapToSource(index);
+ item = m_dolphinModel->itemForIndex(dolphinModelIndex);
+ }
+ }
+
+ if (m_toolTipManager != 0) {
+ m_toolTipManager->hideTip();
+ }
+
+ m_isContextMenuOpen = true; // TODO: workaround for Qt-issue 207192
+ emit requestContextMenu(item, url(), customActions);
+ m_isContextMenuOpen = false;
+}
+
+void DolphinView::dropUrls(const KFileItem& destItem,
+ const KUrl& destPath,
+ QDropEvent* event)
+{
+ DragAndDropHelper::instance().dropUrls(destItem, destPath, event, this);
+}
+
+void DolphinView::updateSorting(DolphinView::Sorting sorting)
+{
+ ViewProperties props(viewPropertiesUrl());
+ props.setSorting(sorting);
+
+ m_proxyModel->setSorting(sorting);
+
+ emit sortingChanged(sorting);
+}
+
+void DolphinView::updateSortOrder(Qt::SortOrder order)
+{
+ ViewProperties props(viewPropertiesUrl());
+ props.setSortOrder(order);
+
+ m_proxyModel->setSortOrder(order);
+
+ emit sortOrderChanged(order);
+}
+
+void DolphinView::updateAdditionalInfo(const KFileItemDelegate::InformationList& info)
+{
+ ViewProperties props(viewPropertiesUrl());
+ props.setAdditionalInfo(info);
+ props.save();
+
+ m_fileItemDelegate->setShowInformation(info);
+
+ emit additionalInfoChanged();
+}
+
+void DolphinView::updateAdditionalInfoActions(KActionCollection* collection)
+{
+ const bool enable = (m_mode == DolphinView::DetailsView) ||
+ (m_mode == DolphinView::IconsView);
+
+ QAction* showSizeInfo = collection->action("show_size_info");
+ QAction* showDateInfo = collection->action("show_date_info");
+ QAction* showPermissionsInfo = collection->action("show_permissions_info");
+ QAction* showOwnerInfo = collection->action("show_owner_info");
+ QAction* showGroupInfo = collection->action("show_group_info");
+ QAction* showMimeInfo = collection->action("show_mime_info");
+
+ showSizeInfo->setChecked(false);
+ showDateInfo->setChecked(false);
+ showPermissionsInfo->setChecked(false);
+ showOwnerInfo->setChecked(false);
+ showGroupInfo->setChecked(false);
+ showMimeInfo->setChecked(false);
+
+ showSizeInfo->setEnabled(enable);
+ showDateInfo->setEnabled(enable);
+ showPermissionsInfo->setEnabled(enable);
+ showOwnerInfo->setEnabled(enable);
+ showGroupInfo->setEnabled(enable);
+ showMimeInfo->setEnabled(enable);
+
+ foreach (KFileItemDelegate::Information info, m_fileItemDelegate->showInformation()) {
+ switch (info) {
+ case KFileItemDelegate::Size:
+ showSizeInfo->setChecked(true);
+ break;
+ case KFileItemDelegate::ModificationTime:
+ showDateInfo->setChecked(true);
+ break;
+ case KFileItemDelegate::Permissions:
+ showPermissionsInfo->setChecked(true);
+ break;
+ case KFileItemDelegate::Owner:
+ showOwnerInfo->setChecked(true);
+ break;
+ case KFileItemDelegate::OwnerAndGroup:
+ showGroupInfo->setChecked(true);
+ break;
+ case KFileItemDelegate::FriendlyMimeType:
+ showMimeInfo->setChecked(true);
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+QPair<bool, QString> DolphinView::pasteInfo() const
+{
+ QPair<bool, QString> ret;
+ QClipboard* clipboard = QApplication::clipboard();
+ const QMimeData* mimeData = clipboard->mimeData();
+
+ KUrl::List urls = KUrl::List::fromMimeData(mimeData);
+ if (!urls.isEmpty()) {
+ // disable the paste action if no writing is supported
+ KFileItem item(KFileItem::Unknown, KFileItem::Unknown, url());
+ ret.first = KonqFileItemCapabilities(KFileItemList() << item).supportsWriting();
+
+ if (urls.count() == 1) {
+ const KFileItem item(KFileItem::Unknown, KFileItem::Unknown, urls.first(), true);
+ ret.second = item.isDir() ? i18nc("@action:inmenu", "Paste One Folder") :
+ i18nc("@action:inmenu", "Paste One File");
+
+ } else {
+ ret.second = i18ncp("@action:inmenu", "Paste One Item", "Paste %1 Items", urls.count());
+ }
+ } else {
+ ret.first = false;
+ ret.second = i18nc("@action:inmenu", "Paste");
+ }
+
+ return ret;
+}
+
+void DolphinView::setTabsForFilesEnabled(bool tabsForFiles)
+{
+ m_tabsForFiles = tabsForFiles;
+}
+
+bool DolphinView::isTabsForFilesEnabled() const
+{
+ return m_tabsForFiles;
+}
+
+bool DolphinView::itemsExpandable() const
+{
+ return (m_detailsView != 0) && m_detailsView->itemsExpandable();
+}
+
+void DolphinView::deleteWhenNotDragSource(QAbstractItemView *view)
+{
+ if (view == 0)
+ return;
+
+ if (DragAndDropHelper::instance().isDragSource(view)) {
+ kDebug() << "Is current drag source";
+ // We must store for later deletion.
+ if (m_expandedDragSource != 0) {
+ // The old stored view is obviously not the drag source anymore.
+ kDebug() << "Deleted old view " << m_expandedDragSource;
+ m_expandedDragSource->deleteLater();
+ m_expandedDragSource = 0;
+ }
+ view->hide();
+ m_expandedDragSource = view;
+ }
+ else {
+ kDebug() << "Deleted new view " << view;
+ view->deleteLater();
+ }
+}
+
+void DolphinView::emitContentsMoved()
projects / dolphin.git / blobdiff