• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.10.5 API Reference
  • KDE Home
  • Contact Us
 

KFile

  • kfile
kdiroperator.cpp
Go to the documentation of this file.
1 /* This file is part of the KDE libraries
2  Copyright (C) 1999,2000 Stephan Kulow <coolo@kde.org>
3  1999,2000,2001,2002,2003 Carsten Pfeiffer <pfeiffer@kde.org>
4 
5  This library is free software; you can redistribute it and/or
6  modify it under the terms of the GNU Library General Public
7  License as published by the Free Software Foundation; either
8  version 2 of the License, or (at your option) any later version.
9 
10  This library is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Library General Public License for more details.
14 
15  You should have received a copy of the GNU Library General Public License
16  along with this library; see the file COPYING.LIB. If not, write to
17  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  Boston, MA 02110-1301, USA.
19 */
20 
21 #include "kdiroperator.h"
22 #include <kprotocolmanager.h>
23 #include "kdirmodel.h"
24 #include "kdiroperatordetailview_p.h"
25 #include "kdirsortfilterproxymodel.h"
26 #include "kfileitem.h"
27 #include "kfilemetapreview.h"
28 #include "kpreviewwidgetbase.h"
29 #include "knewfilemenu.h"
30 
31 #include <config-kfile.h>
32 
33 #include <unistd.h>
34 
35 #include <QtCore/QDir>
36 #include <QtCore/QRegExp>
37 #include <QtCore/QTimer>
38 #include <QtCore/QAbstractItemModel>
39 #include <QtGui/QApplication>
40 #include <QtGui/QDialog>
41 #include <QtGui/QHeaderView>
42 #include <QtGui/QLabel>
43 #include <QtGui/QLayout>
44 #include <QtGui/QListView>
45 #include <QtGui/QMouseEvent>
46 #include <QtGui/QTreeView>
47 #include <QtGui/QPushButton>
48 #include <QtGui/QProgressBar>
49 #include <QtGui/QScrollBar>
50 #include <QtGui/QSplitter>
51 #include <QtGui/QWheelEvent>
52 
53 #include <kaction.h>
54 #include <kapplication.h>
55 #include <kdebug.h>
56 #include <kdialog.h>
57 #include <kdirlister.h>
58 #include <kfileitemdelegate.h>
59 #include <kicon.h>
60 #include <kinputdialog.h>
61 #include <klocale.h>
62 #include <kmessagebox.h>
63 #include <kmenu.h>
64 #include <kstandardaction.h>
65 #include <kio/job.h>
66 #include <kio/deletejob.h>
67 #include <kio/copyjob.h>
68 #include <kio/jobuidelegate.h>
69 #include <kio/jobclasses.h>
70 #include <kio/netaccess.h>
71 #include <kio/previewjob.h>
72 #include <kio/renamedialog.h>
73 #include <kfilepreviewgenerator.h>
74 #include <krun.h>
75 #include <kpropertiesdialog.h>
76 #include <kstandardshortcut.h>
77 #include <kde_file.h>
78 #include <kactioncollection.h>
79 #include <ktoggleaction.h>
80 #include <kactionmenu.h>
81 #include <kconfiggroup.h>
82 #include <kdeversion.h>
83 
84 
85 template class QHash<QString, KFileItem>;
86 
87 // QDir::SortByMask is not only undocumented, it also omits QDir::Type which is another
88 // sorting mode.
89 static const int QDirSortMask = QDir::SortByMask | QDir::Type;
90 
95 class KDirOperatorIconView : public QListView
96 {
97 public:
98  KDirOperatorIconView(KDirOperator *dirOperator, QWidget *parent = 0);
99  virtual ~KDirOperatorIconView();
100 
101 protected:
102  virtual QStyleOptionViewItem viewOptions() const;
103  virtual void dragEnterEvent(QDragEnterEvent* event);
104  virtual void mousePressEvent(QMouseEvent *event);
105  virtual void wheelEvent(QWheelEvent *event);
106 
107 private:
108  KDirOperator *ops;
109 };
110 
111 KDirOperatorIconView::KDirOperatorIconView(KDirOperator *dirOperator, QWidget *parent) :
112  QListView(parent),
113  ops(dirOperator)
114 {
115  setViewMode(QListView::IconMode);
116  setFlow(QListView::TopToBottom);
117  setResizeMode(QListView::Adjust);
118  setSpacing(0);
119  setMovement(QListView::Static);
120  setDragDropMode(QListView::DragOnly);
121  setVerticalScrollMode(QListView::ScrollPerPixel);
122  setHorizontalScrollMode(QListView::ScrollPerPixel);
123  setEditTriggers(QAbstractItemView::NoEditTriggers);
124  setWordWrap(true);
125  setIconSize(QSize(KIconLoader::SizeSmall, KIconLoader::SizeSmall));
126 }
127 
128 KDirOperatorIconView::~KDirOperatorIconView()
129 {
130 }
131 
132 QStyleOptionViewItem KDirOperatorIconView::viewOptions() const
133 {
134  QStyleOptionViewItem viewOptions = QListView::viewOptions();
135  viewOptions.showDecorationSelected = true;
136  viewOptions.decorationPosition = ops->decorationPosition();
137  if (viewOptions.decorationPosition == QStyleOptionViewItem::Left) {
138  viewOptions.displayAlignment = Qt::AlignLeft | Qt::AlignVCenter;
139  } else {
140  viewOptions.displayAlignment = Qt::AlignCenter;
141  }
142 
143  return viewOptions;
144 }
145 
146 void KDirOperatorIconView::dragEnterEvent(QDragEnterEvent* event)
147 {
148  if (event->mimeData()->hasUrls()) {
149  event->acceptProposedAction();
150  }
151 }
152 
153 void KDirOperatorIconView::mousePressEvent(QMouseEvent *event)
154 {
155  if (!indexAt(event->pos()).isValid()) {
156  const Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
157  if (!(modifiers & Qt::ShiftModifier) && !(modifiers & Qt::ControlModifier)) {
158  clearSelection();
159  }
160  }
161 
162  QListView::mousePressEvent(event);
163 }
164 
165 void KDirOperatorIconView::wheelEvent(QWheelEvent *event)
166 {
167  QListView::wheelEvent(event);
168 
169  // apply the vertical wheel event to the horizontal scrollbar, as
170  // the items are aligned from left to right
171  if (event->orientation() == Qt::Vertical) {
172  QWheelEvent horizEvent(event->pos(),
173  event->delta(),
174  event->buttons(),
175  event->modifiers(),
176  Qt::Horizontal);
177  QApplication::sendEvent(horizontalScrollBar(), &horizEvent);
178  }
179 }
180 
181 void KDirOperator::keyPressEvent(QKeyEvent *e)
182 {
183  if (!(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter )) {
184  QWidget::keyPressEvent(e);
185  }
186 }
187 
188 class KDirOperator::Private
189 {
190 public:
191  Private( KDirOperator *parent );
192  ~Private();
193 
194  enum InlinePreviewState {
195  ForcedToFalse = 0,
196  ForcedToTrue,
197  NotForced
198  };
199 
200  // private methods
201  bool checkPreviewInternal() const;
202  void checkPath(const QString &txt, bool takeFiles = false);
203  bool openUrl(const KUrl &url, KDirLister::OpenUrlFlags flags = KDirLister::NoFlags);
204  int sortColumn() const;
205  Qt::SortOrder sortOrder() const;
206  void updateSorting(QDir::SortFlags sort);
207 
208  static bool isReadable(const KUrl &url);
209 
210  KFile::FileView allViews();
211 
212  // private slots
213  void _k_slotDetailedView();
214  void _k_slotSimpleView();
215  void _k_slotTreeView();
216  void _k_slotDetailedTreeView();
217  void _k_slotToggleHidden(bool);
218  void _k_togglePreview(bool);
219  void _k_toggleInlinePreviews(bool);
220  void _k_slotOpenFileManager();
221  void _k_slotSortByName();
222  void _k_slotSortBySize();
223  void _k_slotSortByDate();
224  void _k_slotSortByType();
225  void _k_slotSortReversed(bool doReverse);
226  void _k_slotToggleDirsFirst();
227  void _k_slotToggleIgnoreCase();
228  void _k_slotStarted();
229  void _k_slotProgress(int);
230  void _k_slotShowProgress();
231  void _k_slotIOFinished();
232  void _k_slotCanceled();
233  void _k_slotRedirected(const KUrl&);
234  void _k_slotProperties();
235  void _k_slotActivated(const QModelIndex&);
236  void _k_slotSelectionChanged();
237  void _k_openContextMenu(const QPoint&);
238  void _k_triggerPreview(const QModelIndex&);
239  void _k_showPreview();
240  void _k_slotSplitterMoved(int, int);
241  void _k_assureVisibleSelection();
242  void _k_synchronizeSortingState(int, Qt::SortOrder);
243  void _k_slotChangeDecorationPosition();
244  void _k_slotExpandToUrl(const QModelIndex&);
245  void _k_slotItemsChanged();
246  void _k_slotDirectoryCreated(const KUrl&);
247 
248  void updateListViewGrid();
249  int iconSizeForViewType(QAbstractItemView *itemView) const;
250 
251  // private members
252  KDirOperator *parent;
253  QStack<KUrl*> backStack;
254  QStack<KUrl*> forwardStack;
255 
256  QModelIndex lastHoveredIndex;
257 
258  KDirLister *dirLister;
259  KUrl currUrl;
260 
261  KCompletion completion;
262  KCompletion dirCompletion;
263  bool completeListDirty;
264  QDir::SortFlags sorting;
265  QStyleOptionViewItem::Position decorationPosition;
266 
267  QSplitter *splitter;
268 
269  QAbstractItemView *itemView;
270  KDirModel *dirModel;
271  KDirSortFilterProxyModel *proxyModel;
272 
273  KFileItemList pendingMimeTypes;
274 
275  // the enum KFile::FileView as an int
276  int viewKind;
277  int defaultView;
278 
279  KFile::Modes mode;
280  QProgressBar *progressBar;
281 
282  KPreviewWidgetBase *preview;
283  KUrl previewUrl;
284  int previewWidth;
285 
286  bool dirHighlighting;
287  bool onlyDoubleClickSelectsFiles;
288  QString lastURL; // used for highlighting a directory on cdUp
289  QTimer *progressDelayTimer;
290  int dropOptions;
291 
292  KActionMenu *actionMenu;
293  KActionCollection *actionCollection;
294 
295  KNewFileMenu *newFileMenu;
296 
297  KConfigGroup *configGroup;
298 
299  KFilePreviewGenerator *previewGenerator;
300 
301  bool showPreviews;
302  int iconsZoom;
303 
304  bool isSaving;
305 
306  KActionMenu *decorationMenu;
307  KToggleAction *leftAction;
308  KUrl::List itemsToBeSetAsCurrent;
309  bool shouldFetchForItems;
310  InlinePreviewState inlinePreviewState;
311 };
312 
313 KDirOperator::Private::Private(KDirOperator *_parent) :
314  parent(_parent),
315  dirLister(0),
316  decorationPosition(QStyleOptionViewItem::Left),
317  splitter(0),
318  itemView(0),
319  dirModel(0),
320  proxyModel(0),
321  progressBar(0),
322  preview(0),
323  previewUrl(),
324  previewWidth(0),
325  dirHighlighting(false),
326  onlyDoubleClickSelectsFiles(!KGlobalSettings::singleClick()),
327  progressDelayTimer(0),
328  dropOptions(0),
329  actionMenu(0),
330  actionCollection(0),
331  newFileMenu(0),
332  configGroup(0),
333  previewGenerator(0),
334  showPreviews(false),
335  iconsZoom(0),
336  isSaving(false),
337  decorationMenu(0),
338  leftAction(0),
339  shouldFetchForItems(false),
340  inlinePreviewState(NotForced)
341 {
342 }
343 
344 KDirOperator::Private::~Private()
345 {
346  delete itemView;
347  itemView = 0;
348 
349  // TODO:
350  // if (configGroup) {
351  // itemView->writeConfig(configGroup);
352  // }
353 
354  qDeleteAll(backStack);
355  qDeleteAll(forwardStack);
356  delete preview;
357  preview = 0;
358 
359  delete proxyModel;
360  proxyModel = 0;
361  delete dirModel;
362  dirModel = 0;
363  dirLister = 0; // deleted by KDirModel
364  delete configGroup;
365  configGroup = 0;
366 
367  delete progressDelayTimer;
368  progressDelayTimer = 0;
369 }
370 
371 KDirOperator::KDirOperator(const KUrl& _url, QWidget *parent) :
372  QWidget(parent),
373  d(new Private(this))
374 {
375  d->splitter = new QSplitter(this);
376  d->splitter->setChildrenCollapsible(false);
377  connect(d->splitter, SIGNAL(splitterMoved(int,int)),
378  this, SLOT(_k_slotSplitterMoved(int,int)));
379 
380  d->preview = 0;
381 
382  d->mode = KFile::File;
383  d->viewKind = KFile::Simple;
384 
385  if (_url.isEmpty()) { // no dir specified -> current dir
386  QString strPath = QDir::currentPath();
387  strPath.append(QChar('/'));
388  d->currUrl = QUrl::fromLocalFile(strPath);
389  } else {
390  d->currUrl = _url;
391  if (d->currUrl.protocol().isEmpty())
392  d->currUrl.setProtocol(QLatin1String("file"));
393 
394  d->currUrl.addPath("/"); // make sure we have a trailing slash!
395  }
396 
397  // We set the direction of this widget to LTR, since even on RTL desktops
398  // viewing directory listings in RTL mode makes people's head explode.
399  // Is this the correct place? Maybe it should be in some lower level widgets...?
400  setLayoutDirection(Qt::LeftToRight);
401  setDirLister(new KDirLister());
402 
403  connect(&d->completion, SIGNAL(match(QString)),
404  SLOT(slotCompletionMatch(QString)));
405 
406  d->progressBar = new QProgressBar(this);
407  d->progressBar->setObjectName("d->progressBar");
408  d->progressBar->adjustSize();
409  d->progressBar->move(2, height() - d->progressBar->height() - 2);
410 
411  d->progressDelayTimer = new QTimer(this);
412  d->progressDelayTimer->setObjectName(QLatin1String("d->progressBar delay timer"));
413  connect(d->progressDelayTimer, SIGNAL(timeout()),
414  SLOT(_k_slotShowProgress()));
415 
416  d->completeListDirty = false;
417 
418  // action stuff
419  setupActions();
420  setupMenu();
421 
422  d->sorting = QDir::NoSort; //so updateSorting() doesn't think nothing has changed
423  d->updateSorting(QDir::Name | QDir::DirsFirst);
424 
425  setFocusPolicy(Qt::WheelFocus);
426 }
427 
428 KDirOperator::~KDirOperator()
429 {
430  resetCursor();
431  disconnect(d->dirLister, 0, this, 0);
432  delete d;
433 }
434 
435 
436 void KDirOperator::setSorting(QDir::SortFlags spec)
437 {
438  d->updateSorting(spec);
439 }
440 
441 QDir::SortFlags KDirOperator::sorting() const
442 {
443  return d->sorting;
444 }
445 
446 bool KDirOperator::isRoot() const
447 {
448 #ifdef Q_WS_WIN
449  if (url().isLocalFile()) {
450  const QString path = url().toLocalFile();
451  if (path.length() == 3)
452  return (path[0].isLetter() && path[1] == ':' && path[2] == '/');
453  return false;
454  } else
455 #endif
456  return url().path() == QString(QLatin1Char('/'));
457 }
458 
459 KDirLister *KDirOperator::dirLister() const
460 {
461  return d->dirLister;
462 }
463 
464 void KDirOperator::resetCursor()
465 {
466  if (qApp)
467  QApplication::restoreOverrideCursor();
468  d->progressBar->hide();
469 }
470 
471 void KDirOperator::sortByName()
472 {
473  d->updateSorting((d->sorting & ~QDirSortMask) | QDir::Name);
474 }
475 
476 void KDirOperator::sortBySize()
477 {
478  d->updateSorting((d->sorting & ~QDirSortMask) | QDir::Size);
479 }
480 
481 void KDirOperator::sortByDate()
482 {
483  d->updateSorting((d->sorting & ~QDirSortMask) | QDir::Time);
484 }
485 
486 void KDirOperator::sortByType()
487 {
488  d->updateSorting((d->sorting & ~QDirSortMask) | QDir::Type);
489 }
490 
491 void KDirOperator::sortReversed()
492 {
493  // toggle it, hence the inversion of current state
494  d->_k_slotSortReversed(!(d->sorting & QDir::Reversed));
495 }
496 
497 void KDirOperator::toggleDirsFirst()
498 {
499  d->_k_slotToggleDirsFirst();
500 }
501 
502 void KDirOperator::toggleIgnoreCase()
503 {
504  if (d->proxyModel != 0) {
505  Qt::CaseSensitivity cs = d->proxyModel->sortCaseSensitivity();
506  cs = (cs == Qt::CaseSensitive) ? Qt::CaseInsensitive : Qt::CaseSensitive;
507  d->proxyModel->setSortCaseSensitivity(cs);
508  }
509 }
510 
511 void KDirOperator::updateSelectionDependentActions()
512 {
513  const bool hasSelection = (d->itemView != 0) &&
514  d->itemView->selectionModel()->hasSelection();
515  d->actionCollection->action("trash")->setEnabled(hasSelection);
516  d->actionCollection->action("delete")->setEnabled(hasSelection);
517  d->actionCollection->action("properties")->setEnabled(hasSelection);
518 }
519 
520 void KDirOperator::setPreviewWidget(KPreviewWidgetBase *w)
521 {
522  const bool showPreview = (w != 0);
523  if (showPreview) {
524  d->viewKind = (d->viewKind | KFile::PreviewContents);
525  } else {
526  d->viewKind = (d->viewKind & ~KFile::PreviewContents);
527  }
528 
529  delete d->preview;
530  d->preview = w;
531 
532  if (w) {
533  d->splitter->addWidget(w);
534  }
535 
536  KToggleAction *previewAction = static_cast<KToggleAction*>(d->actionCollection->action("preview"));
537  previewAction->setEnabled(showPreview);
538  previewAction->setChecked(showPreview);
539  setView(static_cast<KFile::FileView>(d->viewKind));
540 }
541 
542 KFileItemList KDirOperator::selectedItems() const
543 {
544  KFileItemList itemList;
545  if (d->itemView == 0) {
546  return itemList;
547  }
548 
549  const QItemSelection selection = d->proxyModel->mapSelectionToSource(d->itemView->selectionModel()->selection());
550 
551  const QModelIndexList indexList = selection.indexes();
552  foreach(const QModelIndex &index, indexList) {
553  KFileItem item = d->dirModel->itemForIndex(index);
554  if (!item.isNull()) {
555  itemList.append(item);
556  }
557  }
558 
559  return itemList;
560 }
561 
562 bool KDirOperator::isSelected(const KFileItem &item) const
563 {
564  if ((item.isNull()) || (d->itemView == 0)) {
565  return false;
566  }
567 
568  const QModelIndex dirIndex = d->dirModel->indexForItem(item);
569  const QModelIndex proxyIndex = d->proxyModel->mapFromSource(dirIndex);
570  return d->itemView->selectionModel()->isSelected(proxyIndex);
571 }
572 
573 int KDirOperator::numDirs() const
574 {
575  return (d->dirLister == 0) ? 0 : d->dirLister->directories().count();
576 }
577 
578 int KDirOperator::numFiles() const
579 {
580  return (d->dirLister == 0) ? 0 : d->dirLister->items().count() - numDirs();
581 }
582 
583 KCompletion * KDirOperator::completionObject() const
584 {
585  return const_cast<KCompletion *>(&d->completion);
586 }
587 
588 KCompletion *KDirOperator::dirCompletionObject() const
589 {
590  return const_cast<KCompletion *>(&d->dirCompletion);
591 }
592 
593 KActionCollection * KDirOperator::actionCollection() const
594 {
595  return d->actionCollection;
596 }
597 
598 KFile::FileView KDirOperator::Private::allViews() {
599  return static_cast<KFile::FileView>(KFile::Simple | KFile::Detail | KFile::Tree | KFile::DetailTree);
600 }
601 
602 void KDirOperator::Private::_k_slotDetailedView()
603 {
604  KFile::FileView view = static_cast<KFile::FileView>((viewKind & ~allViews()) | KFile::Detail);
605  parent->setView(view);
606 }
607 
608 void KDirOperator::Private::_k_slotSimpleView()
609 {
610  KFile::FileView view = static_cast<KFile::FileView>((viewKind & ~allViews()) | KFile::Simple);
611  parent->setView(view);
612 }
613 
614 void KDirOperator::Private::_k_slotTreeView()
615 {
616  KFile::FileView view = static_cast<KFile::FileView>((viewKind & ~allViews()) | KFile::Tree);
617  parent->setView(view);
618 }
619 
620 void KDirOperator::Private::_k_slotDetailedTreeView()
621 {
622  KFile::FileView view = static_cast<KFile::FileView>((viewKind & ~allViews()) | KFile::DetailTree);
623  parent->setView(view);
624 }
625 
626 void KDirOperator::Private::_k_slotToggleHidden(bool show)
627 {
628  dirLister->setShowingDotFiles(show);
629  parent->updateDir();
630  _k_assureVisibleSelection();
631 }
632 
633 void KDirOperator::Private::_k_togglePreview(bool on)
634 {
635  if (on) {
636  viewKind = viewKind | KFile::PreviewContents;
637  if (preview == 0) {
638  preview = new KFileMetaPreview(parent);
639  actionCollection->action("preview")->setChecked(true);
640  splitter->addWidget(preview);
641  }
642 
643  preview->show();
644 
645  QMetaObject::invokeMethod(parent, "_k_assureVisibleSelection", Qt::QueuedConnection);
646  if (itemView != 0) {
647  const QModelIndex index = itemView->selectionModel()->currentIndex();
648  if (index.isValid()) {
649  _k_triggerPreview(index);
650  }
651  }
652  } else if (preview != 0) {
653  viewKind = viewKind & ~KFile::PreviewContents;
654  preview->hide();
655  }
656 }
657 
658 void KDirOperator::Private::_k_toggleInlinePreviews(bool show)
659 {
660  if (showPreviews == show) {
661  return;
662  }
663 
664  showPreviews = show;
665 
666  if (!previewGenerator) {
667  return;
668  }
669 
670  previewGenerator->setPreviewShown(show);
671 
672  if (!show) {
673  // remove all generated previews
674  QAbstractItemModel *model = dirModel;
675  for (int i = 0; i < model->rowCount(); ++i) {
676  QModelIndex index = model->index(i, 0);
677  const KFileItem item = dirModel->itemForIndex(index);
678  const_cast<QAbstractItemModel*>(index.model())->setData(index, KIcon(item.iconName()), Qt::DecorationRole);
679  }
680  }
681 }
682 
683 void KDirOperator::Private::_k_slotOpenFileManager()
684 {
685  new KRun(currUrl, parent);
686 }
687 
688 void KDirOperator::Private::_k_slotSortByName()
689 {
690  parent->sortByName();
691 }
692 
693 void KDirOperator::Private::_k_slotSortBySize()
694 {
695  parent->sortBySize();
696 }
697 
698 void KDirOperator::Private::_k_slotSortByDate()
699 {
700  parent->sortByDate();
701 }
702 
703 void KDirOperator::Private::_k_slotSortByType()
704 {
705  parent->sortByType();
706 }
707 
708 void KDirOperator::Private::_k_slotSortReversed(bool doReverse)
709 {
710  QDir::SortFlags s = sorting & ~QDir::Reversed;
711  if (doReverse) {
712  s |= QDir::Reversed;
713  }
714  updateSorting(s);
715 }
716 
717 void KDirOperator::Private::_k_slotToggleDirsFirst()
718 {
719  QDir::SortFlags s = (sorting ^ QDir::DirsFirst);
720  updateSorting(s);
721 }
722 
723 void KDirOperator::Private::_k_slotToggleIgnoreCase()
724 {
725  // TODO: port to Qt4's QAbstractItemView
726  /*if ( !d->fileView )
727  return;
728 
729  QDir::SortFlags sorting = d->fileView->sorting();
730  if ( !KFile::isSortCaseInsensitive( sorting ) )
731  d->fileView->setSorting( sorting | QDir::IgnoreCase );
732  else
733  d->fileView->setSorting( sorting & ~QDir::IgnoreCase );
734  d->sorting = d->fileView->sorting();*/
735 }
736 
737 void KDirOperator::mkdir()
738 {
739  d->newFileMenu->setPopupFiles(url());
740  d->newFileMenu->setViewShowsHiddenFiles(showHiddenFiles());
741  d->newFileMenu->createDirectory();
742 }
743 
744 bool KDirOperator::mkdir(const QString& directory, bool enterDirectory)
745 {
746  // Creates "directory", relative to the current directory (d->currUrl).
747  // The given path may contain any number directories, existent or not.
748  // They will all be created, if possible.
749 
750  bool writeOk = false;
751  bool exists = false;
752  KUrl url(d->currUrl);
753 
754  const QStringList dirs = directory.split('/', QString::SkipEmptyParts);
755  QStringList::ConstIterator it = dirs.begin();
756 
757  for (; it != dirs.end(); ++it) {
758  url.addPath(*it);
759  exists = KIO::NetAccess::exists(url, KIO::NetAccess::DestinationSide, this);
760  writeOk = !exists && KIO::NetAccess::mkdir(url, this);
761  }
762 
763  if (exists) { // url was already existent
764  KMessageBox::sorry(d->itemView, i18n("A file or folder named %1 already exists.", url.pathOrUrl()));
765  } else if (!writeOk) {
766  KMessageBox::sorry(d->itemView, i18n("You do not have permission to "
767  "create that folder."));
768  } else if (enterDirectory) {
769  setUrl(url, true);
770  }
771 
772  return writeOk;
773 }
774 
775 KIO::DeleteJob * KDirOperator::del(const KFileItemList& items,
776  QWidget *parent,
777  bool ask, bool showProgress)
778 {
779  if (items.isEmpty()) {
780  KMessageBox::information(parent,
781  i18n("You did not select a file to delete."),
782  i18n("Nothing to Delete"));
783  return 0L;
784  }
785 
786  if (parent == 0) {
787  parent = this;
788  }
789 
790  KUrl::List urls;
791  QStringList files;
792  foreach (const KFileItem &item, items) {
793  const KUrl url = item.url();
794  urls.append(url);
795  files.append(url.pathOrUrl());
796  }
797 
798  bool doIt = !ask;
799  if (ask) {
800  int ret;
801  if (items.count() == 1) {
802  ret = KMessageBox::warningContinueCancel(parent,
803  i18n("<qt>Do you really want to delete\n <b>'%1'</b>?</qt>" ,
804  files.first()),
805  i18n("Delete File"),
806  KStandardGuiItem::del(),
807  KStandardGuiItem::cancel(), "AskForDelete");
808  } else
809  ret = KMessageBox::warningContinueCancelList(parent,
810  i18np("Do you really want to delete this item?", "Do you really want to delete these %1 items?", items.count()),
811  files,
812  i18n("Delete Files"),
813  KStandardGuiItem::del(),
814  KStandardGuiItem::cancel(), "AskForDelete");
815  doIt = (ret == KMessageBox::Continue);
816  }
817 
818  if (doIt) {
819  KIO::JobFlags flags = showProgress ? KIO::DefaultFlags : KIO::HideProgressInfo;
820  KIO::DeleteJob *job = KIO::del(urls, flags);
821  job->ui()->setWindow(this);
822  job->ui()->setAutoErrorHandlingEnabled(true);
823  return job;
824  }
825 
826  return 0L;
827 }
828 
829 void KDirOperator::deleteSelected()
830 {
831  const KFileItemList list = selectedItems();
832  if (!list.isEmpty()) {
833  del(list, this);
834  }
835 }
836 
837 KIO::CopyJob * KDirOperator::trash(const KFileItemList& items,
838  QWidget *parent,
839  bool ask, bool showProgress)
840 {
841  if (items.isEmpty()) {
842  KMessageBox::information(parent,
843  i18n("You did not select a file to trash."),
844  i18n("Nothing to Trash"));
845  return 0L;
846  }
847 
848  KUrl::List urls;
849  QStringList files;
850  foreach (const KFileItem &item, items) {
851  const KUrl url = item.url();
852  urls.append(url);
853  files.append(url.pathOrUrl());
854  }
855 
856  bool doIt = !ask;
857  if (ask) {
858  int ret;
859  if (items.count() == 1) {
860  ret = KMessageBox::warningContinueCancel(parent,
861  i18n("<qt>Do you really want to trash\n <b>'%1'</b>?</qt>" ,
862  files.first()),
863  i18n("Trash File"),
864  KGuiItem(i18nc("to trash", "&Trash"), "user-trash"),
865  KStandardGuiItem::cancel(), "AskForTrash");
866  } else
867  ret = KMessageBox::warningContinueCancelList(parent,
868  i18np("translators: not called for n == 1", "Do you really want to trash these %1 items?", items.count()),
869  files,
870  i18n("Trash Files"),
871  KGuiItem(i18nc("to trash", "&Trash"), "user-trash"),
872  KStandardGuiItem::cancel(), "AskForTrash");
873  doIt = (ret == KMessageBox::Continue);
874  }
875 
876  if (doIt) {
877  KIO::JobFlags flags = showProgress ? KIO::DefaultFlags : KIO::HideProgressInfo;
878  KIO::CopyJob *job = KIO::trash(urls, flags);
879  job->ui()->setWindow(this);
880  job->ui()->setAutoErrorHandlingEnabled(true);
881  return job;
882  }
883 
884  return 0L;
885 }
886 
887 KFilePreviewGenerator *KDirOperator::previewGenerator() const
888 {
889  return d->previewGenerator;
890 }
891 
892 void KDirOperator::setInlinePreviewShown(bool show)
893 {
894  d->inlinePreviewState = show ? Private::ForcedToTrue : Private::ForcedToFalse;
895 }
896 
897 bool KDirOperator::isInlinePreviewShown() const
898 {
899  return d->showPreviews;
900 }
901 
902 int KDirOperator::iconsZoom() const
903 {
904  return d->iconsZoom;
905 }
906 
907 void KDirOperator::setIsSaving(bool isSaving)
908 {
909  d->isSaving = isSaving;
910 }
911 
912 bool KDirOperator::isSaving() const
913 {
914  return d->isSaving;
915 }
916 
917 void KDirOperator::trashSelected()
918 {
919  if (d->itemView == 0) {
920  return;
921  }
922 
923  if (QApplication::keyboardModifiers() & Qt::ShiftModifier) {
924  deleteSelected();
925  return;
926  }
927 
928  const KFileItemList list = selectedItems();
929  if (!list.isEmpty()) {
930  trash(list, this);
931  }
932 }
933 
934 void KDirOperator::setIconsZoom(int _value)
935 {
936  if (d->iconsZoom == _value) {
937  return;
938  }
939 
940  int value = _value;
941  value = qMin(100, value);
942  value = qMax(0, value);
943 
944  d->iconsZoom = value;
945 
946  if (d->configGroup && d->inlinePreviewState == Private::NotForced) {
947  if (qobject_cast<QListView*>(d->itemView)) {
948  d->configGroup->writeEntry("listViewIconSize", d->iconsZoom);
949  } else {
950  d->configGroup->writeEntry("detailedViewIconSize", d->iconsZoom);
951  }
952  }
953 
954  if (!d->previewGenerator) {
955  return;
956  }
957 
958  const int maxSize = KIconLoader::SizeEnormous - KIconLoader::SizeSmall;
959  const int val = (maxSize * value / 100) + KIconLoader::SizeSmall;
960  d->itemView->setIconSize(QSize(val, val));
961  d->updateListViewGrid();
962  d->previewGenerator->updatePreviews();
963 
964  emit currentIconSizeChanged(value);
965 }
966 
967 void KDirOperator::close()
968 {
969  resetCursor();
970  d->pendingMimeTypes.clear();
971  d->completion.clear();
972  d->dirCompletion.clear();
973  d->completeListDirty = true;
974  d->dirLister->stop();
975 }
976 
977 void KDirOperator::Private::checkPath(const QString &, bool /*takeFiles*/) // SLOT
978 {
979 #if 0
980  // copy the argument in a temporary string
981  QString text = _txt;
982  // it's unlikely to happen, that at the beginning are spaces, but
983  // for the end, it happens quite often, I guess.
984  text = text.trimmed();
985  // if the argument is no URL (the check is quite fragil) and it's
986  // no absolute path, we add the current directory to get a correct url
987  if (text.find(':') < 0 && text[0] != '/')
988  text.insert(0, d->currUrl);
989 
990  // in case we have a selection defined and someone patched the file-
991  // name, we check, if the end of the new name is changed.
992  if (!selection.isNull()) {
993  int position = text.lastIndexOf('/');
994  ASSERT(position >= 0); // we already inserted the current d->dirLister in case
995  QString filename = text.mid(position + 1, text.length());
996  if (filename != selection)
997  selection.clear();
998  }
999 
1000  KUrl u(text); // I have to take care of entered URLs
1001  bool filenameEntered = false;
1002 
1003  if (u.isLocalFile()) {
1004  // the empty path is kind of a hack
1005  KFileItem i("", u.toLocalFile());
1006  if (i.isDir())
1007  setUrl(text, true);
1008  else {
1009  if (takeFiles)
1010  if (acceptOnlyExisting && !i.isFile())
1011  warning("you entered an invalid URL");
1012  else
1013  filenameEntered = true;
1014  }
1015  } else
1016  setUrl(text, true);
1017 
1018  if (filenameEntered) {
1019  filename_ = u.url();
1020  emit fileSelected(filename_);
1021 
1022  QApplication::restoreOverrideCursor();
1023 
1024  accept();
1025  }
1026 #endif
1027  kDebug(kfile_area) << "TODO KDirOperator::checkPath()";
1028 }
1029 
1030 void KDirOperator::setUrl(const KUrl& _newurl, bool clearforward)
1031 {
1032  KUrl newurl;
1033 
1034  if (!_newurl.isValid())
1035  newurl = QUrl::fromLocalFile(QDir::homePath());
1036  else
1037  newurl = _newurl;
1038 
1039  newurl.adjustPath( KUrl::AddTrailingSlash );
1040 
1041  // already set
1042  if (newurl.equals(d->currUrl, KUrl::CompareWithoutTrailingSlash))
1043  return;
1044 
1045  if (!Private::isReadable(newurl)) {
1046  // maybe newurl is a file? check its parent directory
1047  newurl.setPath(newurl.directory(KUrl::ObeyTrailingSlash));
1048  if (newurl.equals(d->currUrl, KUrl::CompareWithoutTrailingSlash))
1049  return; // parent is current dir, nothing to do (fixes #173454, too)
1050  KIO::UDSEntry entry;
1051  bool res = KIO::NetAccess::stat(newurl, entry, this);
1052  KFileItem i(entry, newurl);
1053  if ((!res || !Private::isReadable(newurl)) && i.isDir()) {
1054  resetCursor();
1055  KMessageBox::error(d->itemView,
1056  i18n("The specified folder does not exist "
1057  "or was not readable."));
1058  return;
1059  } else if (!i.isDir()) {
1060  return;
1061  }
1062  }
1063 
1064  if (clearforward) {
1065  // autodelete should remove this one
1066  d->backStack.push(new KUrl(d->currUrl));
1067  qDeleteAll(d->forwardStack);
1068  d->forwardStack.clear();
1069  }
1070 
1071  d->lastURL = d->currUrl.url(KUrl::RemoveTrailingSlash);
1072  d->currUrl = newurl;
1073 
1074  pathChanged();
1075  emit urlEntered(newurl);
1076 
1077  // enable/disable actions
1078  QAction* forwardAction = d->actionCollection->action("forward");
1079  forwardAction->setEnabled(!d->forwardStack.isEmpty());
1080 
1081  QAction* backAction = d->actionCollection->action("back");
1082  backAction->setEnabled(!d->backStack.isEmpty());
1083 
1084  QAction* upAction = d->actionCollection->action("up");
1085  upAction->setEnabled(!isRoot());
1086 
1087  d->openUrl(newurl);
1088 }
1089 
1090 void KDirOperator::updateDir()
1091 {
1092  QApplication::setOverrideCursor(Qt::WaitCursor);
1093  d->dirLister->emitChanges();
1094  QApplication::restoreOverrideCursor();
1095 }
1096 
1097 void KDirOperator::rereadDir()
1098 {
1099  pathChanged();
1100  d->openUrl(d->currUrl, KDirLister::Reload);
1101 }
1102 
1103 
1104 bool KDirOperator::Private::openUrl(const KUrl& url, KDirLister::OpenUrlFlags flags)
1105 {
1106  const bool result = KProtocolManager::supportsListing(url) && dirLister->openUrl(url, flags);
1107  if (!result) // in that case, neither completed() nor canceled() will be emitted by KDL
1108  _k_slotCanceled();
1109 
1110  return result;
1111 }
1112 
1113 int KDirOperator::Private::sortColumn() const
1114 {
1115  int column = KDirModel::Name;
1116  if (KFile::isSortByDate(sorting)) {
1117  column = KDirModel::ModifiedTime;
1118  } else if (KFile::isSortBySize(sorting)) {
1119  column = KDirModel::Size;
1120  } else if (KFile::isSortByType(sorting)) {
1121  column = KDirModel::Type;
1122  } else {
1123  Q_ASSERT(KFile::isSortByName(sorting));
1124  }
1125 
1126  return column;
1127 }
1128 
1129 Qt::SortOrder KDirOperator::Private::sortOrder() const
1130 {
1131  return (sorting & QDir::Reversed) ? Qt::DescendingOrder :
1132  Qt::AscendingOrder;
1133 }
1134 
1135 void KDirOperator::Private::updateSorting(QDir::SortFlags sort)
1136 {
1137  kDebug(kfile_area) << "changing sort flags from" << sorting << "to" << sort;
1138  if (sort == sorting) {
1139  return;
1140  }
1141 
1142  if ((sorting ^ sort) & QDir::DirsFirst) {
1143  // The "Folders First" setting has been changed.
1144  // We need to make sure that the files and folders are really re-sorted.
1145  // Without the following intermediate "fake resorting",
1146  // QSortFilterProxyModel::sort(int column, Qt::SortOrder order)
1147  // would do nothing because neither the column nor the sort order have been changed.
1148  Qt::SortOrder tmpSortOrder = (sortOrder() == Qt::AscendingOrder ? Qt::DescendingOrder : Qt::AscendingOrder);
1149  proxyModel->sort(sortOrder(), tmpSortOrder);
1150  proxyModel->setSortFoldersFirst(sort & QDir::DirsFirst);
1151  }
1152 
1153  sorting = sort;
1154  parent->updateSortActions();
1155  proxyModel->sort(sortColumn(), sortOrder());
1156 
1157  // TODO: The headers from QTreeView don't take care about a sorting
1158  // change of the proxy model hence they must be updated the manually.
1159  // This is done here by a qobject_cast, but it would be nicer to:
1160  // - provide a signal 'sortingChanged()'
1161  // - connect KDirOperatorDetailView() with this signal and update the
1162  // header internally
1163  QTreeView* treeView = qobject_cast<QTreeView*>(itemView);
1164  if (treeView != 0) {
1165  QHeaderView* headerView = treeView->header();
1166  headerView->blockSignals(true);
1167  headerView->setSortIndicator(sortColumn(), sortOrder());
1168  headerView->blockSignals(false);
1169  }
1170 
1171  _k_assureVisibleSelection();
1172 }
1173 
1174 // Protected
1175 void KDirOperator::pathChanged()
1176 {
1177  if (d->itemView == 0)
1178  return;
1179 
1180  d->pendingMimeTypes.clear();
1181  //d->fileView->clear(); TODO
1182  d->completion.clear();
1183  d->dirCompletion.clear();
1184 
1185  // it may be, that we weren't ready at this time
1186  QApplication::restoreOverrideCursor();
1187 
1188  // when KIO::Job emits finished, the slot will restore the cursor
1189  QApplication::setOverrideCursor(Qt::WaitCursor);
1190 
1191  if (!Private::isReadable(d->currUrl)) {
1192  KMessageBox::error(d->itemView,
1193  i18n("The specified folder does not exist "
1194  "or was not readable."));
1195  if (d->backStack.isEmpty())
1196  home();
1197  else
1198  back();
1199  }
1200 }
1201 
1202 void KDirOperator::Private::_k_slotRedirected(const KUrl& newURL)
1203 {
1204  currUrl = newURL;
1205  pendingMimeTypes.clear();
1206  completion.clear();
1207  dirCompletion.clear();
1208  completeListDirty = true;
1209  emit parent->urlEntered(newURL);
1210 }
1211 
1212 // Code pinched from kfm then hacked
1213 void KDirOperator::back()
1214 {
1215  if (d->backStack.isEmpty())
1216  return;
1217 
1218  d->forwardStack.push(new KUrl(d->currUrl));
1219 
1220  KUrl *s = d->backStack.pop();
1221 
1222  setUrl(*s, false);
1223  delete s;
1224 }
1225 
1226 // Code pinched from kfm then hacked
1227 void KDirOperator::forward()
1228 {
1229  if (d->forwardStack.isEmpty())
1230  return;
1231 
1232  d->backStack.push(new KUrl(d->currUrl));
1233 
1234  KUrl *s = d->forwardStack.pop();
1235  setUrl(*s, false);
1236  delete s;
1237 }
1238 
1239 KUrl KDirOperator::url() const
1240 {
1241  return d->currUrl;
1242 }
1243 
1244 void KDirOperator::cdUp()
1245 {
1246  KUrl tmp(d->currUrl);
1247  tmp.cd(QLatin1String(".."));
1248  setUrl(tmp, true);
1249 }
1250 
1251 void KDirOperator::home()
1252 {
1253  KUrl u = QUrl::fromLocalFile(QDir::homePath());
1254  setUrl(u, true);
1255 }
1256 
1257 void KDirOperator::clearFilter()
1258 {
1259  d->dirLister->setNameFilter(QString());
1260  d->dirLister->clearMimeFilter();
1261  checkPreviewSupport();
1262 }
1263 
1264 void KDirOperator::setNameFilter(const QString& filter)
1265 {
1266  d->dirLister->setNameFilter(filter);
1267  checkPreviewSupport();
1268 }
1269 
1270 QString KDirOperator::nameFilter() const
1271 {
1272  return d->dirLister->nameFilter();
1273 }
1274 
1275 void KDirOperator::setMimeFilter(const QStringList& mimetypes)
1276 {
1277  d->dirLister->setMimeFilter(mimetypes);
1278  checkPreviewSupport();
1279 }
1280 
1281 QStringList KDirOperator::mimeFilter() const
1282 {
1283  return d->dirLister->mimeFilters();
1284 }
1285 
1286 void KDirOperator::setNewFileMenuSupportedMimeTypes(const QStringList& mimeTypes)
1287 {
1288  d->newFileMenu->setSupportedMimeTypes(mimeTypes);
1289 }
1290 
1291 QStringList KDirOperator::newFileMenuSupportedMimeTypes() const
1292 {
1293  return d->newFileMenu->supportedMimeTypes();
1294 }
1295 
1296 bool KDirOperator::checkPreviewSupport()
1297 {
1298  KToggleAction *previewAction = static_cast<KToggleAction*>(d->actionCollection->action("preview"));
1299 
1300  bool hasPreviewSupport = false;
1301  KConfigGroup cg(KGlobal::config(), ConfigGroup);
1302  if (cg.readEntry("Show Default Preview", true))
1303  hasPreviewSupport = d->checkPreviewInternal();
1304 
1305  previewAction->setEnabled(hasPreviewSupport);
1306  return hasPreviewSupport;
1307 }
1308 
1309 void KDirOperator::activatedMenu(const KFileItem &item, const QPoint &pos)
1310 {
1311  Q_UNUSED(item);
1312  updateSelectionDependentActions();
1313 
1314  d->newFileMenu->setPopupFiles(url());
1315  d->newFileMenu->setViewShowsHiddenFiles(showHiddenFiles());
1316  d->newFileMenu->checkUpToDate();
1317 
1318  emit contextMenuAboutToShow( item, d->actionMenu->menu() );
1319 
1320  d->actionMenu->menu()->exec(pos);
1321 }
1322 
1323 void KDirOperator::changeEvent(QEvent *event)
1324 {
1325  QWidget::changeEvent(event);
1326 }
1327 
1328 bool KDirOperator::eventFilter(QObject *watched, QEvent *event)
1329 {
1330  Q_UNUSED(watched);
1331 
1332  // If we are not hovering any items, check if there is a current index
1333  // set. In that case, we show the preview of that item.
1334  switch(event->type()) {
1335  case QEvent::MouseMove: {
1336  if (d->preview && !d->preview->isHidden()) {
1337  const QModelIndex hoveredIndex = d->itemView->indexAt(d->itemView->viewport()->mapFromGlobal(QCursor::pos()));
1338 
1339  if (d->lastHoveredIndex == hoveredIndex)
1340  return QWidget::eventFilter(watched, event);
1341 
1342  d->lastHoveredIndex = hoveredIndex;
1343 
1344  const QModelIndex focusedIndex = d->itemView->selectionModel() ? d->itemView->selectionModel()->currentIndex()
1345  : QModelIndex();
1346 
1347  if (!hoveredIndex.isValid() && focusedIndex.isValid() &&
1348  d->itemView->selectionModel()->isSelected(focusedIndex) &&
1349  (d->lastHoveredIndex != focusedIndex)) {
1350  const QModelIndex sourceFocusedIndex = d->proxyModel->mapToSource(focusedIndex);
1351  const KFileItem item = d->dirModel->itemForIndex(sourceFocusedIndex);
1352  if (!item.isNull()) {
1353  d->preview->showPreview(item.url());
1354  }
1355  }
1356  }
1357  }
1358  break;
1359  case QEvent::MouseButtonRelease: {
1360  if (d->preview != 0 && !d->preview->isHidden()) {
1361  const QModelIndex hoveredIndex = d->itemView->indexAt(d->itemView->viewport()->mapFromGlobal(QCursor::pos()));
1362  const QModelIndex focusedIndex = d->itemView->selectionModel() ? d->itemView->selectionModel()->currentIndex()
1363  : QModelIndex();
1364 
1365  if (((!focusedIndex.isValid()) ||
1366  !d->itemView->selectionModel()->isSelected(focusedIndex)) &&
1367  (!hoveredIndex.isValid())) {
1368  d->preview->clearPreview();
1369  }
1370  }
1371  }
1372  break;
1373  case QEvent::Wheel: {
1374  QWheelEvent *evt = static_cast<QWheelEvent*>(event);
1375  if (evt->modifiers() & Qt::ControlModifier) {
1376  if (evt->delta() > 0) {
1377  setIconsZoom(d->iconsZoom + 10);
1378  } else {
1379  setIconsZoom(d->iconsZoom - 10);
1380  }
1381  return true;
1382  }
1383  }
1384  break;
1385  default:
1386  break;
1387  }
1388 
1389  return QWidget::eventFilter(watched, event);
1390 }
1391 
1392 bool KDirOperator::Private::checkPreviewInternal() const
1393 {
1394  const QStringList supported = KIO::PreviewJob::supportedMimeTypes();
1395  // no preview support for directories?
1396  if (parent->dirOnlyMode() && supported.indexOf("inode/directory") == -1)
1397  return false;
1398 
1399  QStringList mimeTypes = dirLister->mimeFilters();
1400  const QStringList nameFilter = dirLister->nameFilter().split(' ', QString::SkipEmptyParts);
1401 
1402  if (mimeTypes.isEmpty() && nameFilter.isEmpty() && !supported.isEmpty())
1403  return true;
1404  else {
1405  QRegExp r;
1406  r.setPatternSyntax(QRegExp::Wildcard); // the "mimetype" can be "image/*"
1407 
1408  if (!mimeTypes.isEmpty()) {
1409  QStringList::ConstIterator it = supported.begin();
1410 
1411  for (; it != supported.end(); ++it) {
1412  r.setPattern(*it);
1413 
1414  QStringList result = mimeTypes.filter(r);
1415  if (!result.isEmpty()) { // matches! -> we want previews
1416  return true;
1417  }
1418  }
1419  }
1420 
1421  if (!nameFilter.isEmpty()) {
1422  // find the mimetypes of all the filter-patterns
1423  QStringList::const_iterator it1 = nameFilter.begin();
1424  for (; it1 != nameFilter.end(); ++it1) {
1425  if ((*it1) == "*") {
1426  return true;
1427  }
1428 
1429  KMimeType::Ptr mt = KMimeType::findByPath(*it1, 0, true /*fast mode, no file contents exist*/);
1430  if (!mt)
1431  continue;
1432  QString mime = mt->name();
1433 
1434  // the "mimetypes" we get from the PreviewJob can be "image/*"
1435  // so we need to check in wildcard mode
1436  QStringList::ConstIterator it2 = supported.begin();
1437  for (; it2 != supported.end(); ++it2) {
1438  r.setPattern(*it2);
1439  if (r.indexIn(mime) != -1) {
1440  return true;
1441  }
1442  }
1443  }
1444  }
1445  }
1446 
1447  return false;
1448 }
1449 
1450 QAbstractItemView* KDirOperator::createView(QWidget* parent, KFile::FileView viewKind)
1451 {
1452  QAbstractItemView *itemView = 0;
1453  if (KFile::isDetailView(viewKind) || KFile::isTreeView(viewKind) || KFile::isDetailTreeView(viewKind)) {
1454  KDirOperatorDetailView *detailView = new KDirOperatorDetailView(parent);
1455  detailView->setViewMode(viewKind);
1456  itemView = detailView;
1457  } else {
1458  itemView = new KDirOperatorIconView(this, parent);
1459  }
1460 
1461  return itemView;
1462 }
1463 
1464 void KDirOperator::setAcceptDrops(bool b)
1465 {
1466  // TODO:
1467  //if (d->fileView)
1468  // d->fileView->widget()->setAcceptDrops(b);
1469  QWidget::setAcceptDrops(b);
1470 }
1471 
1472 void KDirOperator::setDropOptions(int options)
1473 {
1474  d->dropOptions = options;
1475  // TODO:
1476  //if (d->fileView)
1477  // d->fileView->setDropOptions(options);
1478 }
1479 
1480 void KDirOperator::setView(KFile::FileView viewKind)
1481 {
1482  bool preview = (KFile::isPreviewInfo(viewKind) || KFile::isPreviewContents(viewKind));
1483 
1484  if (viewKind == KFile::Default) {
1485  if (KFile::isDetailView((KFile::FileView)d->defaultView)) {
1486  viewKind = KFile::Detail;
1487  } else if (KFile::isTreeView((KFile::FileView)d->defaultView)) {
1488  viewKind = KFile::Tree;
1489  } else if (KFile::isDetailTreeView((KFile::FileView)d->defaultView)) {
1490  viewKind = KFile::DetailTree;
1491  } else {
1492  viewKind = KFile::Simple;
1493  }
1494 
1495  const KFile::FileView defaultViewKind = static_cast<KFile::FileView>(d->defaultView);
1496  preview = (KFile::isPreviewInfo(defaultViewKind) || KFile::isPreviewContents(defaultViewKind))
1497  && d->actionCollection->action("preview")->isEnabled();
1498  }
1499 
1500  d->viewKind = static_cast<int>(viewKind);
1501  viewKind = static_cast<KFile::FileView>(d->viewKind);
1502 
1503  QAbstractItemView *newView = createView(this, viewKind);
1504  setView(newView);
1505 
1506  d->_k_togglePreview(preview);
1507 }
1508 
1509 QAbstractItemView * KDirOperator::view() const
1510 {
1511  return d->itemView;
1512 }
1513 
1514 KFile::Modes KDirOperator::mode() const
1515 {
1516  return d->mode;
1517 }
1518 
1519 void KDirOperator::setMode(KFile::Modes mode)
1520 {
1521  if (d->mode == mode)
1522  return;
1523 
1524  d->mode = mode;
1525 
1526  d->dirLister->setDirOnlyMode(dirOnlyMode());
1527 
1528  // reset the view with the different mode
1529  if (d->itemView != 0)
1530  setView(static_cast<KFile::FileView>(d->viewKind));
1531 }
1532 
1533 void KDirOperator::setView(QAbstractItemView *view)
1534 {
1535  if (view == d->itemView) {
1536  return;
1537  }
1538 
1539  // TODO: do a real timer and restart it after that
1540  d->pendingMimeTypes.clear();
1541  const bool listDir = (d->itemView == 0);
1542 
1543  if (d->mode & KFile::Files) {
1544  view->setSelectionMode(QAbstractItemView::ExtendedSelection);
1545  } else {
1546  view->setSelectionMode(QAbstractItemView::SingleSelection);
1547  }
1548 
1549  QItemSelectionModel *selectionModel = 0;
1550  if ((d->itemView != 0) && d->itemView->selectionModel()->hasSelection()) {
1551  // remember the selection of the current item view and apply this selection
1552  // to the new view later
1553  const QItemSelection selection = d->itemView->selectionModel()->selection();
1554  selectionModel = new QItemSelectionModel(d->proxyModel, this);
1555  selectionModel->select(selection, QItemSelectionModel::Select);
1556  }
1557 
1558  setFocusProxy(0);
1559  delete d->itemView;
1560  d->itemView = view;
1561  d->itemView->setModel(d->proxyModel);
1562  setFocusProxy(d->itemView);
1563 
1564  view->viewport()->installEventFilter(this);
1565 
1566  KFileItemDelegate *delegate = new KFileItemDelegate(d->itemView);
1567  d->itemView->setItemDelegate(delegate);
1568  d->itemView->viewport()->setAttribute(Qt::WA_Hover);
1569  d->itemView->setContextMenuPolicy(Qt::CustomContextMenu);
1570  d->itemView->setMouseTracking(true);
1571  //d->itemView->setDropOptions(d->dropOptions);
1572 
1573  // first push our settings to the view, then listen for changes from the view
1574  QTreeView* treeView = qobject_cast<QTreeView*>(d->itemView);
1575  if (treeView) {
1576  QHeaderView* headerView = treeView->header();
1577  headerView->setSortIndicator(d->sortColumn(), d->sortOrder());
1578  connect(headerView, SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
1579  this, SLOT(_k_synchronizeSortingState(int,Qt::SortOrder)));
1580  }
1581 
1582  connect(d->itemView, SIGNAL(activated(QModelIndex)),
1583  this, SLOT(_k_slotActivated(QModelIndex)));
1584  connect(d->itemView, SIGNAL(customContextMenuRequested(QPoint)),
1585  this, SLOT(_k_openContextMenu(QPoint)));
1586  connect(d->itemView, SIGNAL(entered(QModelIndex)),
1587  this, SLOT(_k_triggerPreview(QModelIndex)));
1588 
1589  updateViewActions();
1590  d->splitter->insertWidget(0, d->itemView);
1591 
1592  d->splitter->resize(size());
1593  d->itemView->show();
1594 
1595  if (listDir) {
1596  QApplication::setOverrideCursor(Qt::WaitCursor);
1597  d->openUrl(d->currUrl);
1598  }
1599 
1600  if (selectionModel != 0) {
1601  d->itemView->setSelectionModel(selectionModel);
1602  QMetaObject::invokeMethod(this, "_k_assureVisibleSelection", Qt::QueuedConnection);
1603  }
1604 
1605  connect(d->itemView->selectionModel(),
1606  SIGNAL(currentChanged(QModelIndex,QModelIndex)),
1607  this, SLOT(_k_triggerPreview(QModelIndex)));
1608  connect(d->itemView->selectionModel(),
1609  SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
1610  this, SLOT(_k_slotSelectionChanged()));
1611 
1612  // if we cannot cast it to a QListView, disable the "Icon Position" menu. Note that this check
1613  // needs to be done here, and not in createView, since we can be set an external view
1614  d->decorationMenu->setEnabled(qobject_cast<QListView*>(d->itemView));
1615 
1616  d->shouldFetchForItems = qobject_cast<QTreeView*>(view);
1617  if (d->shouldFetchForItems) {
1618  connect(d->dirModel, SIGNAL(expand(QModelIndex)), this, SLOT(_k_slotExpandToUrl(QModelIndex)));
1619  } else {
1620  d->itemsToBeSetAsCurrent.clear();
1621  }
1622 
1623  const bool previewForcedToTrue = d->inlinePreviewState == Private::ForcedToTrue;
1624  const bool previewShown = d->inlinePreviewState == Private::NotForced ? d->showPreviews : previewForcedToTrue;
1625  d->previewGenerator = new KFilePreviewGenerator(d->itemView);
1626  const int maxSize = KIconLoader::SizeEnormous - KIconLoader::SizeSmall;
1627  const int val = (maxSize * d->iconsZoom / 100) + KIconLoader::SizeSmall;
1628  d->itemView->setIconSize(previewForcedToTrue ? QSize(KIconLoader::SizeHuge, KIconLoader::SizeHuge) : QSize(val, val));
1629  d->previewGenerator->setPreviewShown(previewShown);
1630  d->actionCollection->action("inline preview")->setChecked(previewShown);
1631 
1632  // ensure we change everything needed
1633  d->_k_slotChangeDecorationPosition();
1634 
1635  emit viewChanged(view);
1636 
1637  const int zoom = previewForcedToTrue ? (KIconLoader::SizeHuge - KIconLoader::SizeSmall + 1) * 100 / maxSize : d->iconSizeForViewType(view);
1638 
1639  // this will make d->iconsZoom be updated, since setIconsZoom slot will be called
1640  emit currentIconSizeChanged(zoom);
1641 }
1642 
1643 void KDirOperator::setDirLister(KDirLister *lister)
1644 {
1645  if (lister == d->dirLister) // sanity check
1646  return;
1647 
1648  delete d->dirModel;
1649  d->dirModel = 0;
1650 
1651  delete d->proxyModel;
1652  d->proxyModel = 0;
1653 
1654  //delete d->dirLister; // deleted by KDirModel already, which took ownership
1655  d->dirLister = lister;
1656 
1657  d->dirModel = new KDirModel();
1658  d->dirModel->setDirLister(d->dirLister);
1659  d->dirModel->setDropsAllowed(KDirModel::DropOnDirectory);
1660 
1661  d->shouldFetchForItems = qobject_cast<QTreeView*>(d->itemView);
1662  if (d->shouldFetchForItems) {
1663  connect(d->dirModel, SIGNAL(expand(QModelIndex)), this, SLOT(_k_slotExpandToUrl(QModelIndex)));
1664  } else {
1665  d->itemsToBeSetAsCurrent.clear();
1666  }
1667 
1668  d->proxyModel = new KDirSortFilterProxyModel(this);
1669  d->proxyModel->setSourceModel(d->dirModel);
1670 
1671  d->dirLister->setAutoUpdate(true);
1672  d->dirLister->setDelayedMimeTypes(true);
1673 
1674  QWidget* mainWidget = topLevelWidget();
1675  d->dirLister->setMainWindow(mainWidget);
1676  kDebug(kfile_area) << "mainWidget=" << mainWidget;
1677 
1678  connect(d->dirLister, SIGNAL(percent(int)),
1679  SLOT(_k_slotProgress(int)));
1680  connect(d->dirLister, SIGNAL(started(KUrl)), SLOT(_k_slotStarted()));
1681  connect(d->dirLister, SIGNAL(completed()), SLOT(_k_slotIOFinished()));
1682  connect(d->dirLister, SIGNAL(canceled()), SLOT(_k_slotCanceled()));
1683  connect(d->dirLister, SIGNAL(redirection(KUrl)),
1684  SLOT(_k_slotRedirected(KUrl)));
1685  connect(d->dirLister, SIGNAL(newItems(KFileItemList)), SLOT(_k_slotItemsChanged()));
1686  connect(d->dirLister, SIGNAL(itemsDeleted(KFileItemList)), SLOT(_k_slotItemsChanged()));
1687  connect(d->dirLister, SIGNAL(itemsFilteredByMime(KFileItemList)), SLOT(_k_slotItemsChanged()));
1688  connect(d->dirLister, SIGNAL(clear()), SLOT(_k_slotItemsChanged()));
1689 }
1690 
1691 void KDirOperator::selectDir(const KFileItem &item)
1692 {
1693  setUrl(item.targetUrl(), true);
1694 }
1695 
1696 void KDirOperator::selectFile(const KFileItem &item)
1697 {
1698  QApplication::restoreOverrideCursor();
1699 
1700  emit fileSelected(item);
1701 }
1702 
1703 void KDirOperator::highlightFile(const KFileItem &item)
1704 {
1705  if ((d->preview != 0 && !d->preview->isHidden()) && !item.isNull()) {
1706  d->preview->showPreview(item.url());
1707  }
1708 
1709  emit fileHighlighted(item);
1710 }
1711 
1712 void KDirOperator::setCurrentItem(const QString& url)
1713 {
1714  kDebug(kfile_area);
1715 
1716  KFileItem item = d->dirLister->findByUrl(url);
1717  if (d->shouldFetchForItems && item.isNull()) {
1718  d->itemsToBeSetAsCurrent << url;
1719  d->dirModel->expandToUrl(url);
1720  return;
1721  }
1722 
1723  setCurrentItem(item);
1724 }
1725 
1726 void KDirOperator::setCurrentItem(const KFileItem& item)
1727 {
1728  kDebug(kfile_area);
1729 
1730  if (!d->itemView) {
1731  return;
1732  }
1733 
1734  QItemSelectionModel *selModel = d->itemView->selectionModel();
1735  if (selModel) {
1736  selModel->clear();
1737  if (!item.isNull()) {
1738  const QModelIndex dirIndex = d->dirModel->indexForItem(item);
1739  const QModelIndex proxyIndex = d->proxyModel->mapFromSource(dirIndex);
1740  selModel->setCurrentIndex(proxyIndex, QItemSelectionModel::Select);
1741  }
1742  }
1743 }
1744 
1745 void KDirOperator::setCurrentItems(const QStringList& urls)
1746 {
1747  kDebug(kfile_area);
1748 
1749  if (!d->itemView) {
1750  return;
1751  }
1752 
1753  KFileItemList itemList;
1754  foreach (const QString &url, urls) {
1755  KFileItem item = d->dirLister->findByUrl(url);
1756  if (d->shouldFetchForItems && item.isNull()) {
1757  d->itemsToBeSetAsCurrent << url;
1758  d->dirModel->expandToUrl(url);
1759  continue;
1760  }
1761  itemList << item;
1762  }
1763 
1764  setCurrentItems(itemList);
1765 }
1766 
1767 void KDirOperator::setCurrentItems(const KFileItemList& items)
1768 {
1769  kDebug(kfile_area);
1770 
1771  if (d->itemView == 0) {
1772  return;
1773  }
1774 
1775  QItemSelectionModel *selModel = d->itemView->selectionModel();
1776  if (selModel) {
1777  selModel->clear();
1778  QModelIndex proxyIndex;
1779  foreach (const KFileItem &item, items) {
1780  if (!item.isNull()) {
1781  const QModelIndex dirIndex = d->dirModel->indexForItem(item);
1782  proxyIndex = d->proxyModel->mapFromSource(dirIndex);
1783  selModel->select(proxyIndex, QItemSelectionModel::Select);
1784  }
1785  }
1786  if (proxyIndex.isValid()) {
1787  selModel->setCurrentIndex(proxyIndex, QItemSelectionModel::NoUpdate);
1788  }
1789  }
1790 }
1791 
1792 QString KDirOperator::makeCompletion(const QString& string)
1793 {
1794  if (string.isEmpty()) {
1795  d->itemView->selectionModel()->clear();
1796  return QString();
1797  }
1798 
1799  prepareCompletionObjects();
1800  return d->completion.makeCompletion(string);
1801 }
1802 
1803 QString KDirOperator::makeDirCompletion(const QString& string)
1804 {
1805  if (string.isEmpty()) {
1806  d->itemView->selectionModel()->clear();
1807  return QString();
1808  }
1809 
1810  prepareCompletionObjects();
1811  return d->dirCompletion.makeCompletion(string);
1812 }
1813 
1814 void KDirOperator::prepareCompletionObjects()
1815 {
1816  if (d->itemView == 0) {
1817  return;
1818  }
1819 
1820  if (d->completeListDirty) { // create the list of all possible completions
1821  const KFileItemList itemList = d->dirLister->items();
1822  foreach (const KFileItem &item, itemList) {
1823  d->completion.addItem(item.name());
1824  if (item.isDir()) {
1825  d->dirCompletion.addItem(item.name());
1826  }
1827  }
1828  d->completeListDirty = false;
1829  }
1830 }
1831 
1832 void KDirOperator::slotCompletionMatch(const QString& match)
1833 {
1834  setCurrentItem(match);
1835  emit completion(match);
1836 }
1837 
1838 void KDirOperator::setupActions()
1839 {
1840  d->actionCollection = new KActionCollection(this);
1841  d->actionCollection->setObjectName("KDirOperator::actionCollection");
1842 
1843  d->actionMenu = new KActionMenu(i18n("Menu"), this);
1844  d->actionCollection->addAction("popupMenu", d->actionMenu);
1845 
1846  QAction* upAction = d->actionCollection->addAction(KStandardAction::Up, "up", this, SLOT(cdUp()));
1847  upAction->setText(i18n("Parent Folder"));
1848 
1849  d->actionCollection->addAction(KStandardAction::Back, "back", this, SLOT(back()));
1850 
1851  d->actionCollection->addAction(KStandardAction::Forward, "forward", this, SLOT(forward()));
1852 
1853  QAction* homeAction = d->actionCollection->addAction(KStandardAction::Home, "home", this, SLOT(home()));
1854  homeAction->setText(i18n("Home Folder"));
1855 
1856  KAction* reloadAction = d->actionCollection->addAction(KStandardAction::Redisplay, "reload", this, SLOT(rereadDir()));
1857  reloadAction->setText(i18n("Reload"));
1858  reloadAction->setShortcuts(KStandardShortcut::shortcut(KStandardShortcut::Reload));
1859 
1860  KAction* mkdirAction = new KAction(i18n("New Folder..."), this);
1861  d->actionCollection->addAction("mkdir", mkdirAction);
1862  mkdirAction->setIcon(KIcon(QLatin1String("folder-new")));
1863  connect(mkdirAction, SIGNAL(triggered(bool)), this, SLOT(mkdir()));
1864 
1865  KAction* trash = new KAction(i18n("Move to Trash"), this);
1866  d->actionCollection->addAction("trash", trash);
1867  trash->setIcon(KIcon("user-trash"));
1868  trash->setShortcuts(KShortcut(Qt::Key_Delete));
1869  connect(trash, SIGNAL(triggered(bool)), SLOT(trashSelected()));
1870 
1871  KAction* action = new KAction(i18n("Delete"), this);
1872  d->actionCollection->addAction("delete", action);
1873  action->setIcon(KIcon("edit-delete"));
1874  action->setShortcuts(KShortcut(Qt::SHIFT + Qt::Key_Delete));
1875  connect(action, SIGNAL(triggered(bool)), this, SLOT(deleteSelected()));
1876 
1877  // the sort menu actions
1878  KActionMenu *sortMenu = new KActionMenu(i18n("Sorting"), this);
1879  d->actionCollection->addAction("sorting menu", sortMenu);
1880 
1881  KToggleAction *byNameAction = new KToggleAction(i18n("By Name"), this);
1882  d->actionCollection->addAction("by name", byNameAction);
1883  connect(byNameAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortByName()));
1884 
1885  KToggleAction *bySizeAction = new KToggleAction(i18n("By Size"), this);
1886  d->actionCollection->addAction("by size", bySizeAction);
1887  connect(bySizeAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortBySize()));
1888 
1889  KToggleAction *byDateAction = new KToggleAction(i18n("By Date"), this);
1890  d->actionCollection->addAction("by date", byDateAction);
1891  connect(byDateAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortByDate()));
1892 
1893  KToggleAction *byTypeAction = new KToggleAction(i18n("By Type"), this);
1894  d->actionCollection->addAction("by type", byTypeAction);
1895  connect(byTypeAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortByType()));
1896 
1897  KToggleAction *descendingAction = new KToggleAction(i18n("Descending"), this);
1898  d->actionCollection->addAction("descending", descendingAction);
1899  connect(descendingAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortReversed(bool)));
1900 
1901  KToggleAction *dirsFirstAction = new KToggleAction(i18n("Folders First"), this);
1902  d->actionCollection->addAction("dirs first", dirsFirstAction);
1903  connect(dirsFirstAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotToggleDirsFirst()));
1904 
1905  QActionGroup* sortGroup = new QActionGroup(this);
1906  byNameAction->setActionGroup(sortGroup);
1907  bySizeAction->setActionGroup(sortGroup);
1908  byDateAction->setActionGroup(sortGroup);
1909  byTypeAction->setActionGroup(sortGroup);
1910 
1911  d->decorationMenu = new KActionMenu(i18n("Icon Position"), this);
1912  d->actionCollection->addAction("decoration menu", d->decorationMenu);
1913 
1914  d->leftAction = new KToggleAction(i18n("Next to File Name"), this);
1915  d->actionCollection->addAction("decorationAtLeft", d->leftAction);
1916  connect(d->leftAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotChangeDecorationPosition()));
1917 
1918  KToggleAction *topAction = new KToggleAction(i18n("Above File Name"), this);
1919  d->actionCollection->addAction("decorationAtTop", topAction);
1920  connect(topAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotChangeDecorationPosition()));
1921 
1922  d->decorationMenu->addAction(d->leftAction);
1923  d->decorationMenu->addAction(topAction);
1924 
1925  QActionGroup* decorationGroup = new QActionGroup(this);
1926  d->leftAction->setActionGroup(decorationGroup);
1927  topAction->setActionGroup(decorationGroup);
1928 
1929  KToggleAction *shortAction = new KToggleAction(i18n("Short View"), this);
1930  d->actionCollection->addAction("short view", shortAction);
1931  shortAction->setIcon(KIcon(QLatin1String("view-list-icons")));
1932  connect(shortAction, SIGNAL(triggered()), SLOT(_k_slotSimpleView()));
1933 
1934  KToggleAction *detailedAction = new KToggleAction(i18n("Detailed View"), this);
1935  d->actionCollection->addAction("detailed view", detailedAction);
1936  detailedAction->setIcon(KIcon(QLatin1String("view-list-details")));
1937  connect(detailedAction, SIGNAL(triggered()), SLOT(_k_slotDetailedView()));
1938 
1939  KToggleAction *treeAction = new KToggleAction(i18n("Tree View"), this);
1940  d->actionCollection->addAction("tree view", treeAction);
1941  treeAction->setIcon(KIcon(QLatin1String("view-list-tree")));
1942  connect(treeAction, SIGNAL(triggered()), SLOT(_k_slotTreeView()));
1943 
1944  KToggleAction *detailedTreeAction = new KToggleAction(i18n("Detailed Tree View"), this);
1945  d->actionCollection->addAction("detailed tree view", detailedTreeAction);
1946  detailedTreeAction->setIcon(KIcon(QLatin1String("view-list-tree")));
1947  connect(detailedTreeAction, SIGNAL(triggered()), SLOT(_k_slotDetailedTreeView()));
1948 
1949  QActionGroup* viewGroup = new QActionGroup(this);
1950  shortAction->setActionGroup(viewGroup);
1951  detailedAction->setActionGroup(viewGroup);
1952  treeAction->setActionGroup(viewGroup);
1953  detailedTreeAction->setActionGroup(viewGroup);
1954 
1955  KToggleAction *showHiddenAction = new KToggleAction(i18n("Show Hidden Files"), this);
1956  d->actionCollection->addAction("show hidden", showHiddenAction);
1957  connect(showHiddenAction, SIGNAL(toggled(bool)), SLOT(_k_slotToggleHidden(bool)));
1958 
1959  KToggleAction *previewAction = new KToggleAction(i18n("Show Aside Preview"), this);
1960  d->actionCollection->addAction("preview", previewAction);
1961  connect(previewAction, SIGNAL(toggled(bool)),
1962  SLOT(_k_togglePreview(bool)));
1963 
1964  KToggleAction *inlinePreview = new KToggleAction(KIcon("view-preview"),
1965  i18n("Show Preview"), this);
1966  d->actionCollection->addAction("inline preview", inlinePreview);
1967  connect(inlinePreview, SIGNAL(toggled(bool)), SLOT(_k_toggleInlinePreviews(bool)));
1968 
1969  KAction *fileManager = new KAction(i18n("Open File Manager"), this);
1970  d->actionCollection->addAction("file manager", fileManager);
1971  fileManager->setIcon(KIcon(QLatin1String("system-file-manager")));
1972  connect(fileManager, SIGNAL(triggered()), SLOT(_k_slotOpenFileManager()));
1973 
1974  action = new KAction(i18n("Properties"), this);
1975  d->actionCollection->addAction("properties", action);
1976  action->setIcon(KIcon("document-properties"));
1977  action->setShortcut(KShortcut(Qt::ALT + Qt::Key_Return));
1978  connect(action, SIGNAL(triggered(bool)), this, SLOT(_k_slotProperties()));
1979 
1980  // the view menu actions
1981  KActionMenu* viewMenu = new KActionMenu(i18n("&View"), this);
1982  d->actionCollection->addAction("view menu", viewMenu);
1983  viewMenu->addAction(shortAction);
1984  viewMenu->addAction(detailedAction);
1985  // Comment following lines to hide the extra two modes
1986  viewMenu->addAction(treeAction);
1987  viewMenu->addAction(detailedTreeAction);
1988  // TODO: QAbstractItemView does not offer an action collection. Provide
1989  // an interface to add a custom action collection.
1990 
1991  d->newFileMenu = new KNewFileMenu(d->actionCollection, "new", this);
1992  connect(d->newFileMenu, SIGNAL(directoryCreated(KUrl)), this, SLOT(_k_slotDirectoryCreated(KUrl)));
1993 
1994  d->actionCollection->addAssociatedWidget(this);
1995  foreach (QAction* action, d->actionCollection->actions())
1996  action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
1997 }
1998 
1999 void KDirOperator::setupMenu()
2000 {
2001  setupMenu(SortActions | ViewActions | FileActions);
2002 }
2003 
2004 void KDirOperator::setupMenu(int whichActions)
2005 {
2006  // first fill the submenus (sort and view)
2007  KActionMenu *sortMenu = static_cast<KActionMenu*>(d->actionCollection->action("sorting menu"));
2008  sortMenu->menu()->clear();
2009  sortMenu->addAction(d->actionCollection->action("by name"));
2010  sortMenu->addAction(d->actionCollection->action("by size"));
2011  sortMenu->addAction(d->actionCollection->action("by date"));
2012  sortMenu->addAction(d->actionCollection->action("by type"));
2013  sortMenu->addSeparator();
2014  sortMenu->addAction(d->actionCollection->action("descending"));
2015  sortMenu->addAction(d->actionCollection->action("dirs first"));
2016 
2017  // now plug everything into the popupmenu
2018  d->actionMenu->menu()->clear();
2019  if (whichActions & NavActions) {
2020  d->actionMenu->addAction(d->actionCollection->action("up"));
2021  d->actionMenu->addAction(d->actionCollection->action("back"));
2022  d->actionMenu->addAction(d->actionCollection->action("forward"));
2023  d->actionMenu->addAction(d->actionCollection->action("home"));
2024  d->actionMenu->addSeparator();
2025  }
2026 
2027  if (whichActions & FileActions) {
2028  d->actionMenu->addAction(d->actionCollection->action("new"));
2029  if (d->currUrl.isLocalFile() && !(QApplication::keyboardModifiers() & Qt::ShiftModifier)) {
2030  d->actionMenu->addAction(d->actionCollection->action("trash"));
2031  }
2032  KConfigGroup cg(KGlobal::config(), QLatin1String("KDE"));
2033  const bool del = !d->currUrl.isLocalFile() ||
2034  (QApplication::keyboardModifiers() & Qt::ShiftModifier) ||
2035  cg.readEntry("ShowDeleteCommand", false);
2036  if (del) {
2037  d->actionMenu->addAction(d->actionCollection->action("delete"));
2038  }
2039  d->actionMenu->addSeparator();
2040  }
2041 
2042  if (whichActions & SortActions) {
2043  d->actionMenu->addAction(sortMenu);
2044  if (!(whichActions & ViewActions)) {
2045  d->actionMenu->addSeparator();
2046  }
2047  }
2048 
2049  if (whichActions & ViewActions) {
2050  d->actionMenu->addAction(d->actionCollection->action("view menu"));
2051  d->actionMenu->addSeparator();
2052  }
2053 
2054  if (whichActions & FileActions) {
2055  d->actionMenu->addAction(d->actionCollection->action("file manager"));
2056  d->actionMenu->addAction(d->actionCollection->action("properties"));
2057  }
2058 }
2059 
2060 void KDirOperator::updateSortActions()
2061 {
2062  if (KFile::isSortByName(d->sorting)) {
2063  d->actionCollection->action("by name")->setChecked(true);
2064  } else if (KFile::isSortByDate(d->sorting)) {
2065  d->actionCollection->action("by date")->setChecked(true);
2066  } else if (KFile::isSortBySize(d->sorting)) {
2067  d->actionCollection->action("by size")->setChecked(true);
2068  } else if (KFile::isSortByType(d->sorting)) {
2069  d->actionCollection->action("by type")->setChecked(true);
2070  }
2071  d->actionCollection->action("descending")->setChecked(d->sorting & QDir::Reversed);
2072  d->actionCollection->action("dirs first")->setChecked(d->sorting & QDir::DirsFirst);
2073 }
2074 
2075 void KDirOperator::updateViewActions()
2076 {
2077  KFile::FileView fv = static_cast<KFile::FileView>(d->viewKind);
2078 
2079  //QAction *separateDirs = d->actionCollection->action("separate dirs");
2080  //separateDirs->setChecked(KFile::isSeparateDirs(fv) &&
2081  // separateDirs->isEnabled());
2082 
2083  d->actionCollection->action("short view")->setChecked(KFile::isSimpleView(fv));
2084  d->actionCollection->action("detailed view")->setChecked(KFile::isDetailView(fv));
2085  d->actionCollection->action("tree view")->setChecked(KFile::isTreeView(fv));
2086  d->actionCollection->action("detailed tree view")->setChecked(KFile::isDetailTreeView(fv));
2087 }
2088 
2089 void KDirOperator::readConfig(const KConfigGroup& configGroup)
2090 {
2091  d->defaultView = 0;
2092  QString viewStyle = configGroup.readEntry("View Style", "Simple");
2093  if (viewStyle == QLatin1String("Detail")) {
2094  d->defaultView |= KFile::Detail;
2095  } else if (viewStyle == QLatin1String("Tree")) {
2096  d->defaultView |= KFile::Tree;
2097  } else if (viewStyle == QLatin1String("DetailTree")) {
2098  d->defaultView |= KFile::DetailTree;
2099  } else {
2100  d->defaultView |= KFile::Simple;
2101  }
2102  //if (configGroup.readEntry(QLatin1String("Separate Directories"),
2103  // DefaultMixDirsAndFiles)) {
2104  // d->defaultView |= KFile::SeparateDirs;
2105  //}
2106  if (configGroup.readEntry(QLatin1String("Show Preview"), false)) {
2107  d->defaultView |= KFile::PreviewContents;
2108  }
2109 
2110  d->previewWidth = configGroup.readEntry(QLatin1String("Preview Width"), 100);
2111 
2112  if (configGroup.readEntry(QLatin1String("Show hidden files"),
2113  DefaultShowHidden)) {
2114  d->actionCollection->action("show hidden")->setChecked(true);
2115  d->dirLister->setShowingDotFiles(true);
2116  }
2117 
2118  QDir::SortFlags sorting = QDir::Name;
2119  if (configGroup.readEntry(QLatin1String("Sort directories first"),
2120  DefaultDirsFirst)) {
2121  sorting |= QDir::DirsFirst;
2122  }
2123  QString name = QLatin1String("Name");
2124  QString sortBy = configGroup.readEntry(QLatin1String("Sort by"), name);
2125  if (sortBy == name) {
2126  sorting |= QDir::Name;
2127  } else if (sortBy == QLatin1String("Size")) {
2128  sorting |= QDir::Size;
2129  } else if (sortBy == QLatin1String("Date")) {
2130  sorting |= QDir::Time;
2131  } else if (sortBy == QLatin1String("Type")) {
2132  sorting |= QDir::Type;
2133  }
2134  if (configGroup.readEntry(QLatin1String("Sort reversed"), DefaultSortReversed)) {
2135  sorting |= QDir::Reversed;
2136  }
2137  d->updateSorting(sorting);
2138 
2139  if (d->inlinePreviewState == Private::NotForced) {
2140  d->showPreviews = configGroup.readEntry(QLatin1String("Previews"), false);
2141  }
2142  QStyleOptionViewItem::Position pos = (QStyleOptionViewItem::Position) configGroup.readEntry(QLatin1String("Decoration position"), (int) QStyleOptionViewItem::Left);
2143  setDecorationPosition(pos);
2144 }
2145 
2146 void KDirOperator::writeConfig(KConfigGroup& configGroup)
2147 {
2148  QString sortBy = QLatin1String("Name");
2149  if (KFile::isSortBySize(d->sorting)) {
2150  sortBy = QLatin1String("Size");
2151  } else if (KFile::isSortByDate(d->sorting)) {
2152  sortBy = QLatin1String("Date");
2153  } else if (KFile::isSortByType(d->sorting)) {
2154  sortBy = QLatin1String("Type");
2155  }
2156 
2157  configGroup.writeEntry(QLatin1String("Sort by"), sortBy);
2158 
2159  configGroup.writeEntry(QLatin1String("Sort reversed"),
2160  d->actionCollection->action("descending")->isChecked());
2161 
2162  configGroup.writeEntry(QLatin1String("Sort directories first"),
2163  d->actionCollection->action("dirs first")->isChecked());
2164 
2165  // don't save the preview when an application specific preview is in use.
2166  bool appSpecificPreview = false;
2167  if (d->preview) {
2168  KFileMetaPreview *tmp = dynamic_cast<KFileMetaPreview*>(d->preview);
2169  appSpecificPreview = (tmp == 0);
2170  }
2171 
2172  if (!appSpecificPreview) {
2173  KToggleAction *previewAction = static_cast<KToggleAction*>(d->actionCollection->action("preview"));
2174  if (previewAction->isEnabled()) {
2175  bool hasPreview = previewAction->isChecked();
2176  configGroup.writeEntry(QLatin1String("Show Preview"), hasPreview);
2177 
2178  if (hasPreview) {
2179  // remember the width of the preview widget
2180  QList<int> sizes = d->splitter->sizes();
2181  Q_ASSERT(sizes.count() == 2);
2182  configGroup.writeEntry(QLatin1String("Preview Width"), sizes[1]);
2183  }
2184  }
2185  }
2186 
2187  configGroup.writeEntry(QLatin1String("Show hidden files"),
2188  d->actionCollection->action("show hidden")->isChecked());
2189 
2190  KFile::FileView fv = static_cast<KFile::FileView>(d->viewKind);
2191  QString style;
2192  if (KFile::isDetailView(fv))
2193  style = QLatin1String("Detail");
2194  else if (KFile::isSimpleView(fv))
2195  style = QLatin1String("Simple");
2196  else if (KFile::isTreeView(fv))
2197  style = QLatin1String("Tree");
2198  else if (KFile::isDetailTreeView(fv))
2199  style = QLatin1String("DetailTree");
2200  configGroup.writeEntry(QLatin1String("View Style"), style);
2201 
2202  if (d->inlinePreviewState == Private::NotForced) {
2203  configGroup.writeEntry(QLatin1String("Previews"), d->showPreviews);
2204  }
2205 
2206  configGroup.writeEntry(QLatin1String("Decoration position"), (int) d->decorationPosition);
2207 }
2208 
2209 void KDirOperator::resizeEvent(QResizeEvent *)
2210 {
2211  // resize the splitter and assure that the width of
2212  // the preview widget is restored
2213  QList<int> sizes = d->splitter->sizes();
2214  const bool hasPreview = (sizes.count() == 2);
2215 
2216  d->splitter->resize(size());
2217  sizes = d->splitter->sizes();
2218 
2219  const bool restorePreviewWidth = hasPreview && (d->previewWidth != sizes[1]);
2220  if (restorePreviewWidth) {
2221  const int availableWidth = sizes[0] + sizes[1];
2222  sizes[0] = availableWidth - d->previewWidth;
2223  sizes[1] = d->previewWidth;
2224  d->splitter->setSizes(sizes);
2225  }
2226  if (hasPreview) {
2227  d->previewWidth = sizes[1];
2228  }
2229 
2230  if (d->progressBar->parent() == this) {
2231  // might be reparented into a statusbar
2232  d->progressBar->move(2, height() - d->progressBar->height() - 2);
2233  }
2234 }
2235 
2236 void KDirOperator::setOnlyDoubleClickSelectsFiles(bool enable)
2237 {
2238  d->onlyDoubleClickSelectsFiles = enable;
2239  // TODO: port to Qt4's QAbstractItemModel
2240  //if (d->itemView != 0) {
2241  // d->itemView->setOnlyDoubleClickSelectsFiles(enable);
2242  //}
2243 }
2244 
2245 bool KDirOperator::onlyDoubleClickSelectsFiles() const
2246 {
2247  return d->onlyDoubleClickSelectsFiles;
2248 }
2249 
2250 void KDirOperator::Private::_k_slotStarted()
2251 {
2252  progressBar->setValue(0);
2253  // delay showing the progressbar for one second
2254  progressDelayTimer->setSingleShot(true);
2255  progressDelayTimer->start(1000);
2256 }
2257 
2258 void KDirOperator::Private::_k_slotShowProgress()
2259 {
2260  progressBar->raise();
2261  progressBar->show();
2262  QApplication::flush();
2263 }
2264 
2265 void KDirOperator::Private::_k_slotProgress(int percent)
2266 {
2267  progressBar->setValue(percent);
2268  // we have to redraw this as fast as possible
2269  if (progressBar->isVisible())
2270  QApplication::flush();
2271 }
2272 
2273 
2274 void KDirOperator::Private::_k_slotIOFinished()
2275 {
2276  progressDelayTimer->stop();
2277  _k_slotProgress(100);
2278  progressBar->hide();
2279  emit parent->finishedLoading();
2280  parent->resetCursor();
2281 
2282  if (preview) {
2283  preview->clearPreview();
2284  }
2285 }
2286 
2287 void KDirOperator::Private::_k_slotCanceled()
2288 {
2289  emit parent->finishedLoading();
2290  parent->resetCursor();
2291 }
2292 
2293 QProgressBar * KDirOperator::progressBar() const
2294 {
2295  return d->progressBar;
2296 }
2297 
2298 void KDirOperator::clearHistory()
2299 {
2300  qDeleteAll(d->backStack);
2301  d->backStack.clear();
2302  d->actionCollection->action("back")->setEnabled(false);
2303 
2304  qDeleteAll(d->forwardStack);
2305  d->forwardStack.clear();
2306  d->actionCollection->action("forward")->setEnabled(false);
2307 }
2308 
2309 void KDirOperator::setEnableDirHighlighting(bool enable)
2310 {
2311  d->dirHighlighting = enable;
2312 }
2313 
2314 bool KDirOperator::dirHighlighting() const
2315 {
2316  return d->dirHighlighting;
2317 }
2318 
2319 bool KDirOperator::dirOnlyMode() const
2320 {
2321  return dirOnlyMode(d->mode);
2322 }
2323 
2324 bool KDirOperator::dirOnlyMode(uint mode)
2325 {
2326  return ((mode & KFile::Directory) &&
2327  (mode & (KFile::File | KFile::Files)) == 0);
2328 }
2329 
2330 void KDirOperator::Private::_k_slotProperties()
2331 {
2332  if (itemView == 0) {
2333  return;
2334  }
2335 
2336  const KFileItemList list = parent->selectedItems();
2337  if (!list.isEmpty()) {
2338  KPropertiesDialog dialog(list, parent);
2339  dialog.exec();
2340  }
2341 }
2342 
2343 void KDirOperator::Private::_k_slotActivated(const QModelIndex& index)
2344 {
2345  const QModelIndex dirIndex = proxyModel->mapToSource(index);
2346  KFileItem item = dirModel->itemForIndex(dirIndex);
2347 
2348  const Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
2349  if (item.isNull() || (modifiers & Qt::ShiftModifier) || (modifiers & Qt::ControlModifier))
2350  return;
2351 
2352  if (item.isDir()) {
2353  parent->selectDir(item);
2354  } else {
2355  parent->selectFile(item);
2356  }
2357 }
2358 
2359 void KDirOperator::Private::_k_slotSelectionChanged()
2360 {
2361  if (itemView == 0) {
2362  return;
2363  }
2364 
2365  // In the multiselection mode each selection change is indicated by
2366  // emitting a null item. Also when the selection has been cleared, a
2367  // null item must be emitted.
2368  const bool multiSelectionMode = (itemView->selectionMode() == QAbstractItemView::ExtendedSelection);
2369  const bool hasSelection = itemView->selectionModel()->hasSelection();
2370  if (multiSelectionMode || !hasSelection) {
2371  KFileItem nullItem;
2372  parent->highlightFile(nullItem);
2373  }
2374  else {
2375  KFileItem selectedItem = parent->selectedItems().first();
2376  parent->highlightFile(selectedItem);
2377  }
2378 }
2379 
2380 void KDirOperator::Private::_k_openContextMenu(const QPoint& pos)
2381 {
2382  const QModelIndex proxyIndex = itemView->indexAt(pos);
2383  const QModelIndex dirIndex = proxyModel->mapToSource(proxyIndex);
2384  KFileItem item = dirModel->itemForIndex(dirIndex);
2385 
2386  if (item.isNull())
2387  return;
2388 
2389  parent->activatedMenu(item, QCursor::pos());
2390 }
2391 
2392 void KDirOperator::Private::_k_triggerPreview(const QModelIndex& index)
2393 {
2394  if ((preview != 0 && !preview->isHidden()) && index.isValid() && (index.column() == KDirModel::Name)) {
2395  const QModelIndex dirIndex = proxyModel->mapToSource(index);
2396  const KFileItem item = dirModel->itemForIndex(dirIndex);
2397 
2398  if (item.isNull())
2399  return;
2400 
2401  if (!item.isDir()) {
2402  previewUrl = item.url();
2403  _k_showPreview();
2404  } else {
2405  preview->clearPreview();
2406  }
2407  }
2408 }
2409 
2410 void KDirOperator::Private::_k_showPreview()
2411 {
2412  if (preview != 0) {
2413  preview->showPreview(previewUrl);
2414  }
2415 }
2416 
2417 void KDirOperator::Private::_k_slotSplitterMoved(int, int)
2418 {
2419  const QList<int> sizes = splitter->sizes();
2420  if (sizes.count() == 2) {
2421  // remember the width of the preview widget (see KDirOperator::resizeEvent())
2422  previewWidth = sizes[1];
2423  }
2424 }
2425 
2426 void KDirOperator::Private::_k_assureVisibleSelection()
2427 {
2428  if (itemView == 0) {
2429  return;
2430  }
2431 
2432  QItemSelectionModel* selModel = itemView->selectionModel();
2433  if (selModel->hasSelection()) {
2434  const QModelIndex index = selModel->currentIndex();
2435  itemView->scrollTo(index, QAbstractItemView::EnsureVisible);
2436  _k_triggerPreview(index);
2437  }
2438 }
2439 
2440 
2441 void KDirOperator::Private::_k_synchronizeSortingState(int logicalIndex, Qt::SortOrder order)
2442 {
2443  QDir::SortFlags newSort = sorting & ~(QDirSortMask | QDir::Reversed);
2444 
2445  switch (logicalIndex) {
2446  case KDirModel::Name:
2447  newSort |= QDir::Name;
2448  break;
2449  case KDirModel::Size:
2450  newSort |= QDir::Size;
2451  break;
2452  case KDirModel::ModifiedTime:
2453  newSort |= QDir::Time;
2454  break;
2455  case KDirModel::Type:
2456  newSort |= QDir::Type;
2457  break;
2458  default:
2459  Q_ASSERT(false);
2460  }
2461 
2462  if (order == Qt::DescendingOrder) {
2463  newSort |= QDir::Reversed;
2464  }
2465 
2466  updateSorting(newSort);
2467 
2468  QMetaObject::invokeMethod(parent, "_k_assureVisibleSelection", Qt::QueuedConnection);
2469 }
2470 
2471 void KDirOperator::Private::_k_slotChangeDecorationPosition()
2472 {
2473  if (!itemView) {
2474  return;
2475  }
2476 
2477  QListView *view = qobject_cast<QListView*>(itemView);
2478 
2479  if (!view) {
2480  return;
2481  }
2482 
2483  const bool leftChecked = actionCollection->action("decorationAtLeft")->isChecked();
2484 
2485  if (leftChecked) {
2486  decorationPosition = QStyleOptionViewItem::Left;
2487  view->setFlow(QListView::TopToBottom);
2488  } else {
2489  decorationPosition = QStyleOptionViewItem::Top;
2490  view->setFlow(QListView::LeftToRight);
2491  }
2492 
2493  updateListViewGrid();
2494 
2495  itemView->update();
2496 }
2497 
2498 void KDirOperator::Private::_k_slotExpandToUrl(const QModelIndex &index)
2499 {
2500  QTreeView *treeView = qobject_cast<QTreeView*>(itemView);
2501 
2502  if (!treeView) {
2503  return;
2504  }
2505 
2506  const KFileItem item = dirModel->itemForIndex(index);
2507 
2508  if (item.isNull()) {
2509  return;
2510  }
2511 
2512  if (!item.isDir()) {
2513  const QModelIndex proxyIndex = proxyModel->mapFromSource(index);
2514 
2515  KUrl::List::Iterator it = itemsToBeSetAsCurrent.begin();
2516  while (it != itemsToBeSetAsCurrent.end()) {
2517  const KUrl url = *it;
2518  if (url.isParentOf(item.url())) {
2519  const KFileItem _item = dirLister->findByUrl(url);
2520  if (!_item.isNull() && _item.isDir()) {
2521  const QModelIndex _index = dirModel->indexForItem(_item);
2522  const QModelIndex _proxyIndex = proxyModel->mapFromSource(_index);
2523  treeView->expand(_proxyIndex);
2524 
2525  // if we have expanded the last parent of this item, select it
2526  if (item.url().directory() == url.path(KUrl::RemoveTrailingSlash)) {
2527  treeView->selectionModel()->select(proxyIndex, QItemSelectionModel::Select);
2528  }
2529  }
2530  it = itemsToBeSetAsCurrent.erase(it);
2531  } else {
2532  ++it;
2533  }
2534  }
2535  } else if (!itemsToBeSetAsCurrent.contains(item.url())) {
2536  itemsToBeSetAsCurrent << item.url();
2537  }
2538 }
2539 
2540 void KDirOperator::Private::_k_slotItemsChanged()
2541 {
2542  completeListDirty = true;
2543 }
2544 
2545 void KDirOperator::Private::updateListViewGrid()
2546 {
2547  if (!itemView) {
2548  return;
2549  }
2550 
2551  QListView *view = qobject_cast<QListView*>(itemView);
2552 
2553  if (!view) {
2554  return;
2555  }
2556 
2557  const bool leftChecked = actionCollection->action("decorationAtLeft")->isChecked();
2558 
2559  if (leftChecked) {
2560  view->setGridSize(QSize());
2561  KFileItemDelegate *delegate = qobject_cast<KFileItemDelegate*>(view->itemDelegate());
2562  if (delegate) {
2563  delegate->setMaximumSize(QSize());
2564  }
2565  } else {
2566  const QFontMetrics metrics(itemView->viewport()->font());
2567  int size = itemView->iconSize().height() + metrics.height() * 2;
2568  // some heuristics for good looking. let's guess width = height * (3 / 2) is nice
2569  view->setGridSize(QSize(size * (3.0 / 2.0), size + metrics.height()));
2570  KFileItemDelegate *delegate = qobject_cast<KFileItemDelegate*>(view->itemDelegate());
2571  if (delegate) {
2572  delegate->setMaximumSize(QSize(size * (3.0 / 2.0), size + metrics.height()));
2573  }
2574  }
2575 }
2576 
2577 int KDirOperator::Private::iconSizeForViewType(QAbstractItemView *itemView) const
2578 {
2579  if (!itemView || !configGroup) {
2580  return 0;
2581  }
2582 
2583  if (qobject_cast<QListView*>(itemView)) {
2584  return configGroup->readEntry("listViewIconSize", 0);
2585  } else {
2586  return configGroup->readEntry("detailedViewIconSize", 0);
2587  }
2588 }
2589 
2590 void KDirOperator::setViewConfig(KConfigGroup& configGroup)
2591 {
2592  delete d->configGroup;
2593  d->configGroup = new KConfigGroup(configGroup);
2594 }
2595 
2596 KConfigGroup* KDirOperator::viewConfigGroup() const
2597 {
2598  return d->configGroup;
2599 }
2600 
2601 void KDirOperator::setShowHiddenFiles(bool s)
2602 {
2603  d->actionCollection->action("show hidden")->setChecked(s);
2604 }
2605 
2606 bool KDirOperator::showHiddenFiles() const
2607 {
2608  return d->actionCollection->action("show hidden")->isChecked();
2609 }
2610 
2611 QStyleOptionViewItem::Position KDirOperator::decorationPosition() const
2612 {
2613  return d->decorationPosition;
2614 }
2615 
2616 void KDirOperator::setDecorationPosition(QStyleOptionViewItem::Position position)
2617 {
2618  d->decorationPosition = position;
2619  const bool decorationAtLeft = d->decorationPosition == QStyleOptionViewItem::Left;
2620  d->actionCollection->action("decorationAtLeft")->setChecked(decorationAtLeft);
2621  d->actionCollection->action("decorationAtTop")->setChecked(!decorationAtLeft);
2622 }
2623 
2624 // ### temporary code
2625 #include <dirent.h>
2626 bool KDirOperator::Private::isReadable(const KUrl& url)
2627 {
2628  if (!url.isLocalFile())
2629  return true; // what else can we say?
2630 
2631  KDE_struct_stat buf;
2632 #ifdef Q_WS_WIN
2633  QString ts = url.toLocalFile();
2634 #else
2635  QString ts = url.path(KUrl::AddTrailingSlash);
2636 #endif
2637  bool readable = (KDE::stat(ts, &buf) == 0);
2638  if (readable) { // further checks
2639  DIR *test;
2640  test = opendir(QFile::encodeName(ts)); // we do it just to test here
2641  readable = (test != 0);
2642  if (test)
2643  closedir(test);
2644  }
2645  return readable;
2646 }
2647 
2648 void KDirOperator::Private::_k_slotDirectoryCreated(const KUrl& url)
2649 {
2650  parent->setUrl(url, true);
2651 }
2652 
2653 #include "kdiroperator.moc"
kdirlister.h
KNewFileMenu
The &#39;Create New&#39; submenu, for creating files using templates (e.g.
Definition: knewfilemenu.h:54
KStandardGuiItem::cancel
KGuiItem cancel()
KDirOperator::onlyDoubleClickSelectsFiles
bool onlyDoubleClickSelectsFiles() const
Definition: kdiroperator.cpp:2245
KIO::NetAccess::stat
static bool stat(const KUrl &url, KIO::UDSEntry &entry, QWidget *window)
KDirOperator::isSelected
bool isSelected(const KFileItem &item) const
Definition: kdiroperator.cpp:562
kdialog.h
KFileItem::targetUrl
KUrl targetUrl() const
i18n
QString i18n(const char *text)
KDirOperator::dirLister
KDirLister * dirLister() const
Definition: kdiroperator.cpp:459
KUrl::adjustPath
void adjustPath(AdjustPathOption trailing)
KActionCollection
KDirOperator::viewConfigGroup
KConfigGroup * viewConfigGroup() const
Definition: kdiroperator.cpp:2596
QItemSelectionModel
KFile::isSortByName
static bool isSortByName(const QDir::SortFlags &sort)
KDirOperator::setupMenu
void setupMenu()
Sets up the context-menu with all the necessary actions.
Definition: kdiroperator.cpp:1999
KFile::isSortByDate
static bool isSortByDate(const QDir::SortFlags &sort)
KAction::setShortcuts
void setShortcuts(const QList< QKeySequence > &shortcuts, ShortcutTypes type=ShortcutTypes(ActiveShortcut|DefaultShortcut))
KUrl::directory
QString directory(const DirectoryOptions &options=IgnoreTrailingSlash) const
netaccess.h
KUrl::RemoveTrailingSlash
Left
KMessageBox::Continue
KDirOperator::viewChanged
void viewChanged(QAbstractItemView *newView)
Emitted whenever the current fileview is changed, either by an explicit call to setView() or by the u...
KFile::isDetailTreeView
static bool isDetailTreeView(const FileView &view)
KDirOperator::selectedItems
KFileItemList selectedItems() const
Definition: kdiroperator.cpp:542
KDirOperator::close
void close()
Stops loading immediately.
Definition: kdiroperator.cpp:967
KDirOperator::FileActions
Definition: kdiroperator.h:114
KFileItem::isDir
bool isDir() const
KDirOperator::actionCollection
KActionCollection * actionCollection() const
an accessor to a collection of all available Actions.
Definition: kdiroperator.cpp:593
kdebug.h
KFile::PreviewContents
KUrl::AddTrailingSlash
kapplication.h
KDirOperator::writeConfig
virtual void writeConfig(KConfigGroup &configGroup)
Saves the current settings like sorting, simple or detailed view.
Definition: kdiroperator.cpp:2146
KDirOperator::changeEvent
virtual void changeEvent(QEvent *event)
Definition: kdiroperator.cpp:1323
KDirOperator::setOnlyDoubleClickSelectsFiles
void setOnlyDoubleClickSelectsFiles(bool enable)
This toggles between double/single click file and directory selection mode.
Definition: kdiroperator.cpp:2236
KFilePreviewGenerator
Generates previews for files of an item view.
Definition: kfilepreviewgenerator.h:50
KDirOperator::sorting
QDir::SortFlags sorting() const
Definition: kdiroperator.cpp:441
KDirOperator::keyPressEvent
virtual void keyPressEvent(QKeyEvent *event)
Definition: kdiroperator.cpp:181
KDirOperator::setCurrentItems
void setCurrentItems(const QStringList &urls)
Clears the current selection and attempts to set urls the current url files.
Definition: kdiroperator.cpp:1745
KStandardAction::Redisplay
KIO::UDSEntry
KFileItemDelegate::setMaximumSize
void setMaximumSize(const QSize &size)
KActionMenu::addAction
void addAction(QAction *action)
KDirOperator::dirCompletionObject
KCompletion * dirCompletionObject() const
Definition: kdiroperator.cpp:588
KDirOperator::forward
virtual void forward()
Goes one step forward in the history and opens that url.
Definition: kdiroperator.cpp:1227
KFile::Directory
KDirOperator::sortBySize
void sortBySize()
Changes sorting to sort by size.
Definition: kdiroperator.cpp:476
i18np
QString i18np(const char *sing, const char *plur, const A1 &a1)
timeout
int timeout
kfilemetapreview.h
KDirOperatorDetailView
Default detail view for KDirOperator using custom resizing options and columns.
Definition: kdiroperatordetailview_p.h:32
KFileItem::isNull
bool isNull() const
kactioncollection.h
KStandardShortcut::shortcut
const KShortcut & shortcut(StandardShortcut id)
KDirSortFilterProxyModel
Acts as proxy model for KDirModel to sort and filter KFileItems.
Definition: kdirsortfilterproxymodel.h:50
KMessageBox::information
static void information(QWidget *parent, const QString &text, const QString &caption=QString(), const QString &dontShowAgainName=QString(), Options options=Notify)
KFile
KFile::isSortBySize
static bool isSortBySize(const QDir::SortFlags &sort)
KIO::HideProgressInfo
QWidget
KDirOperator::setPreviewWidget
virtual void setPreviewWidget(KPreviewWidgetBase *w)
Sets a preview-widget to be shown next to the file-view.
Definition: kdiroperator.cpp:520
dirs
KStandardDirs * dirs()
KDE::stat
int stat(const QString &path, KDE_struct_stat *buf)
name
const char * name(StandardAction id)
KDirOperator::currentIconSizeChanged
void currentIconSizeChanged(int size)
Will notify that the icon size has changed.
KDirOperator::makeCompletion
QString makeCompletion(const QString &)
Tries to complete the given string (only completes files).
Definition: kdiroperator.cpp:1792
kfileitemdelegate.h
KFile::Files
KDirOperator::sortByName
void sortByName()
Changes sorting to sort by name.
Definition: kdiroperator.cpp:471
KUrl::cd
bool cd(const QString &_dir)
KDirOperator::updateSortActions
void updateSortActions()
Updates the sorting-related actions to comply with the current sorting.
Definition: kdiroperator.cpp:2060
KDirOperator::makeDirCompletion
QString makeDirCompletion(const QString &)
Tries to complete the given string (only completes directores).
Definition: kdiroperator.cpp:1803
KFile::Tree
KDirOperator::setAcceptDrops
virtual void setAcceptDrops(bool b)
Reimplemented - allow dropping of files if b is true.
Definition: kdiroperator.cpp:1464
KConfigGroup::writeEntry
void writeEntry(const QString &key, const QVariant &value, WriteConfigFlags pFlags=Normal)
KFile::DetailTree
KUrl::toLocalFile
QString toLocalFile(AdjustPathOption trailing=LeaveTrailingSlash) const
KDirOperator::completion
void completion(const QString &)
QString
KUrl::CompareWithoutTrailingSlash
KIO::NetAccess::mkdir
static bool mkdir(const KUrl &url, QWidget *window, int permissions=-1)
QHash
kpreviewwidgetbase.h
KFile::File
KDirOperator::fileHighlighted
void fileHighlighted(const KFileItem &item)
Emitted when a file is highlighted or generally the selection changes in multiselection mode...
KDirOperator::url
KUrl url() const
Definition: kdiroperator.cpp:1239
QObject
kDebug
static QDebug kDebug(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
KUrl::isParentOf
bool isParentOf(const KUrl &u) const
klocale.h
KDirOperator::updateSelectionDependentActions
void updateSelectionDependentActions()
Enables/disables actions that are selection dependent.
Definition: kdiroperator.cpp:511
KDirOperator::setUrl
virtual void setUrl(const KUrl &url, bool clearforward)
Sets a new url to list.
Definition: kdiroperator.cpp:1030
kdiroperatordetailview_p.h
KUrl
KDirOperator::checkPreviewSupport
bool checkPreviewSupport()
Checks if there support from KIO::PreviewJob for the currently shown files, taking mimeFilter() and n...
Definition: kdiroperator.cpp:1296
KFile::isPreviewInfo
static bool isPreviewInfo(const FileView &view)
KStandardGuiItem::del
KGuiItem del()
KDirOperator::~KDirOperator
virtual ~KDirOperator()
Destroys the KDirOperator.
Definition: kdiroperator.cpp:428
config-kfile.h
i18nc
QString i18nc(const char *ctxt, const char *text)
KRun
KDirOperator::setEnableDirHighlighting
virtual void setEnableDirHighlighting(bool enable)
When going up in the directory hierarchy, KDirOperator can highlight the directory that was just left...
Definition: kdiroperator.cpp:2309
KGlobal::config
KSharedConfigPtr config()
kprotocolmanager.h
KDirOperator::iconsZoom
int iconsZoom() const
Returns the icon zoom.
Definition: kdiroperator.cpp:902
KUrl::setPath
void setPath(const QString &path)
KStandardAction::Home
KShortcut
listDir
ListJob * listDir(const KUrl &url, JobFlags flags=DefaultFlags, bool includeHidden=true)
KIO::DefaultFlags
KDirOperator::showHiddenFiles
bool showHiddenFiles() const
Definition: kdiroperator.cpp:2606
KDirOperator::setDirLister
virtual void setDirLister(KDirLister *lister)
Sets a custom KDirLister to list directories.
Definition: kdiroperator.cpp:1643
KDirOperator::updateViewActions
void updateViewActions()
Updates the view-related actions to comply with the current KFile::FileView.
Definition: kdiroperator.cpp:2075
kpropertiesdialog.h
KIconLoader::SizeEnormous
KFile::isSimpleView
static bool isSimpleView(const FileView &view)
KStandardAction::Up
KDirModel::DropOnDirectory
KUrl::addPath
void addPath(const QString &txt)
KDirLister::Reload
KDirOperator::trashSelected
virtual void trashSelected()
Trashes the currently selected files/directories.
Definition: kdiroperator.cpp:917
KIO::NetAccess::exists
static bool exists(const KUrl &url, bool source, QWidget *window)
KDirOperator::setSorting
void setSorting(QDir::SortFlags)
Sets the way to sort files and directories.
Definition: kdiroperator.cpp:436
KDirOperator::toggleIgnoreCase
void toggleIgnoreCase()
Toggles case sensitive / case insensitive sorting.
Definition: kdiroperator.cpp:502
KDirOperator::sortByType
void sortByType()
Changes sorting to sort by date.
Definition: kdiroperator.cpp:486
KDirOperator::dirHighlighting
bool dirHighlighting() const
Definition: kdiroperator.cpp:2314
KDirOperator::cdUp
virtual void cdUp()
Goes one directory up from the current url.
Definition: kdiroperator.cpp:1244
test
KGuiItem test()
kmenu.h
KDirOperator::setView
virtual void setView(QAbstractItemView *view)
Sets a new view to be used for showing and browsing files.
Definition: kdiroperator.cpp:1533
QTreeView
KDirOperator::view
QAbstractItemView * view() const
Definition: kdiroperator.cpp:1509
KGuiItem
KDirOperator::NavActions
Definition: kdiroperator.h:113
KDirOperator
This widget works as a network transparent filebrowser.
Definition: kdiroperator.h:101
KIO::DeleteJob
KDirOperator::prepareCompletionObjects
void prepareCompletionObjects()
Synchronizes the completion objects with the entries of the currently listed url. ...
Definition: kdiroperator.cpp:1814
KDirOperator::selectFile
void selectFile(const KFileItem &item)
Emits fileSelected( item )
Definition: kdiroperator.cpp:1696
KDirOperator::setupActions
void setupActions()
Sets up all the actions.
Definition: kdiroperator.cpp:1838
QStringList
KMessageBox::sorry
static void sorry(QWidget *parent, const QString &text, const QString &caption=QString(), Options options=Notify)
KDirOperator::fileSelected
void fileSelected(const KFileItem &item)
previewjob.h
KCompletion
KUrl::pathOrUrl
QString pathOrUrl() const
KDirOperator::mode
KFile::Modes mode() const
Definition: kdiroperator.cpp:1514
KFileItemList
KDirOperator::setDropOptions
virtual void setDropOptions(int options)
Sets the options for dropping files.
Definition: kdiroperator.cpp:1472
ConfigGroup
#define ConfigGroup
KDirLister::NoFlags
KIcon
clear
KAction * clear(const QObject *recvr, const char *slot, QObject *parent)
KDirOperator::urlEntered
void urlEntered(const KUrl &)
copyjob.h
QDirSortMask
static const int QDirSortMask
Definition: kdiroperator.cpp:89
KDirOperator::updateDir
void updateDir()
to update the view after changing the settings
Definition: kdiroperator.cpp:1090
kfilepreviewgenerator.h
KDirOperator::setNewFileMenuSupportedMimeTypes
void setNewFileMenuSupportedMimeTypes(const QStringList &mime)
Only show the files in a given set of mimetypes.
Definition: kdiroperator.cpp:1286
KDirOperator::sortByDate
void sortByDate()
Changes sorting to sort by date.
Definition: kdiroperator.cpp:481
kactionmenu.h
KDirOperator::del
virtual KIO::DeleteJob * del(const KFileItemList &items, QWidget *parent=0, bool ask=true, bool showProgress=true)
Starts and returns a KIO::DeleteJob to delete the given items.
Definition: kdiroperator.cpp:775
kstandardaction.h
KDirOperator::home
virtual void home()
Enters the home directory.
Definition: kdiroperator.cpp:1251
KUrl::path
QString path(AdjustPathOption trailing=LeaveTrailingSlash) const
KDirOperator::setMode
virtual void setMode(KFile::Modes m)
Sets the listing/selection mode for the views, an OR&#39;ed combination of.
Definition: kdiroperator.cpp:1519
KFileItem::iconName
QString iconName() const
DefaultDirsFirst
#define DefaultDirsFirst
KFile::isPreviewContents
static bool isPreviewContents(const FileView &view)
mimeTypes
QStringList mimeTypes(Mode mode=Writing)
KActionMenu::menu
KMenu * menu()
KDirOperator::setCurrentItem
void setCurrentItem(const QString &url)
Clears the current selection and attempts to set url the current url file.
Definition: kdiroperator.cpp:1712
KDirOperator::setIconsZoom
void setIconsZoom(int value)
Notifies that the icons size should change.
Definition: kdiroperator.cpp:934
QAbstractItemModel
jobuidelegate.h
KDirOperator::nameFilter
QString nameFilter() const
Definition: kdiroperator.cpp:1270
KStandardAction::Back
KPropertiesDialog
KDirModel::Name
KAction::setShortcut
void setShortcut(const KShortcut &shortcut, ShortcutTypes type=ShortcutTypes(ActiveShortcut|DefaultShortcut))
kaction.h
KDirOperator::previewGenerator
KFilePreviewGenerator * previewGenerator() const
Returns the preview generator for the current view.
Definition: kdiroperator.cpp:887
kstandardshortcut.h
KDirOperator::mkdir
virtual void mkdir()
Opens a dialog to create a new directory.
Definition: kdiroperator.cpp:737
KGlobalSettings
KDirOperator::completionObject
KCompletion * completionObject() const
Definition: kdiroperator.cpp:583
KDirOperator::eventFilter
virtual bool eventFilter(QObject *watched, QEvent *event)
Definition: kdiroperator.cpp:1328
KDirOperator::setShowHiddenFiles
virtual void setShowHiddenFiles(bool s)
Enables/disables showing hidden files.
Definition: kdiroperator.cpp:2601
KDirOperator::isSaving
bool isSaving() const
Returns whether KDirOperator will force a double click to accept.
Definition: kdiroperator.cpp:912
KFile::Default
renamedialog.h
KIconLoader::SizeHuge
Top
zoom
KAction * zoom(const QObject *recvr, const char *slot, QObject *parent)
KStandardAction::Forward
QListView
KFile::isSortByType
static bool isSortByType(const QDir::SortFlags &sort)
kinputdialog.h
job.h
KFileMetaPreview
KConfigGroup
KIO::del
DeleteJob * del(const KUrl &src, JobFlags flags=DefaultFlags)
KDirOperator::setMimeFilter
void setMimeFilter(const QStringList &mimetypes)
Sets a list of mimetypes as filter.
Definition: kdiroperator.cpp:1275
KUrl::List
KDirOperator::KDirOperator
KDirOperator(const KUrl &urlName=KUrl(), QWidget *parent=0)
Constructs the KDirOperator with no initial view.
Definition: kdiroperator.cpp:371
krun.h
KDirOperator::slotCompletionMatch
void slotCompletionMatch(const QString &match)
Tries to make the given match as current item in the view and emits completion( match ) ...
Definition: kdiroperator.cpp:1832
KDirModel::Type
kdirmodel.h
KDirOperator::newFileMenuSupportedMimeTypes
QStringList newFileMenuSupportedMimeTypes() const
Definition: kdiroperator.cpp:1291
KActionMenu
KDirOperator::mimeFilter
QStringList mimeFilter() const
Definition: kdiroperator.cpp:1281
KDirOperator::trash
virtual KIO::CopyJob * trash(const KFileItemList &items, QWidget *parent, bool ask=true, bool showProgress=true)
Starts and returns a KIO::CopyJob to trash the given items.
Definition: kdiroperator.cpp:837
kdirsortfilterproxymodel.h
KFile::isDetailView
static bool isDetailView(const FileView &view)
KDirOperator::isRoot
bool isRoot() const
Definition: kdiroperator.cpp:446
KDirOperator::selectDir
virtual void selectDir(const KFileItem &item)
Enters the directory specified by the given item.
Definition: kdiroperator.cpp:1691
KFile::FileView
FileView
KIconLoader::SizeSmall
KDirOperator::clearFilter
void clearFilter()
Clears both the namefilter and mimetype filter, so that all files and directories will be shown...
Definition: kdiroperator.cpp:1257
KDirOperator::setIsSaving
void setIsSaving(bool isSaving)
If the system is set up to trigger items on single click, if isSaving is true, we will force to doubl...
Definition: kdiroperator.cpp:907
KDirOperator::clearHistory
void clearHistory()
Clears the forward and backward history.
Definition: kdiroperator.cpp:2298
QPoint
KDirOperator::pathChanged
void pathChanged()
Called after setUrl() to load the directory, update the history, etc.
Definition: kdiroperator.cpp:1175
KIO::NetAccess::DestinationSide
jobclasses.h
KDirOperator::sortReversed
void sortReversed()
Changes sorting to reverse sorting.
Definition: kdiroperator.cpp:491
KFileItem::name
QString name(bool lowerCase=false) const
KActionMenu::addSeparator
QAction * addSeparator()
KAction
KDirOperator::resetCursor
void resetCursor()
Restores the normal cursor after showing the busy-cursor.
Definition: kdiroperator.cpp:464
KDirOperator::back
virtual void back()
Goes one step back in the history and opens that url.
Definition: kdiroperator.cpp:1213
KUrl::ObeyTrailingSlash
KDirOperator::progressBar
QProgressBar * progressBar() const
Definition: kdiroperator.cpp:2293
KDirModel::ModifiedTime
KDirOperator::dirOnlyMode
bool dirOnlyMode() const
Definition: kdiroperator.cpp:2319
KPreviewWidgetBase
KFileItemDelegate
KDirOperatorDetailView::setViewMode
virtual bool setViewMode(KFile::FileView viewMode)
Displays either Detail, Tree or DetailTree modes.
Definition: kdiroperatordetailview.cpp:70
KStandardShortcut::Reload
KMessageBox::warningContinueCancelList
static int warningContinueCancelList(QWidget *parent, const QString &text, const QStringList &strlist, const QString &caption=QString(), const KGuiItem &buttonContinue=KStandardGuiItem::cont(), const KGuiItem &buttonCancel=KStandardGuiItem::cancel(), const QString &dontAskAgainName=QString(), Options options=Notify)
KDirOperator::readConfig
virtual void readConfig(const KConfigGroup &configGroup)
Reads the default settings for a view, i.e.
Definition: kdiroperator.cpp:2089
ktoggleaction.h
deletejob.h
KDirOperator::highlightFile
void highlightFile(const KFileItem &item)
Emits fileHighlighted(item)
Definition: kdiroperator.cpp:1703
QSize
KToggleAction
KDirOperator::createView
virtual QAbstractItemView * createView(QWidget *parent, KFile::FileView viewKind)
A view factory for creating predefined fileviews.
Definition: kdiroperator.cpp:1450
KDirOperator::decorationPosition
QStyleOptionViewItem::Position decorationPosition() const
Returns the position where icons are shown relative to the labels of file items in the icon view...
Definition: kdiroperator.cpp:2611
KDirOperator::ViewActions
Definition: kdiroperator.h:112
KDirOperator::contextMenuAboutToShow
void contextMenuAboutToShow(const KFileItem &item, QMenu *menu)
Emitted just before the context menu is shown, allows users to extend the menu with custom actions...
KDirOperator::deleteSelected
virtual void deleteSelected()
Deletes the currently selected files/directories.
Definition: kdiroperator.cpp:829
KProtocolManager::supportsListing
static bool supportsListing(const KUrl &url)
KDirLister
KDirOperator::isInlinePreviewShown
bool isInlinePreviewShown() const
Returns whether the inline previews are shown or not.
Definition: kdiroperator.cpp:897
KIO::PreviewJob::supportedMimeTypes
static QStringList supportedMimeTypes()
DefaultSortReversed
#define DefaultSortReversed
KFile::Simple
kicon.h
KDirOperator::rereadDir
virtual void rereadDir()
Re-reads the current url.
Definition: kdiroperator.cpp:1097
KUrl::isLocalFile
bool isLocalFile() const
kmessagebox.h
kdiroperator.h
KDirOperator::setDecorationPosition
void setDecorationPosition(QStyleOptionViewItem::Position position)
Sets the position where icons shall be shown relative to the labels of file items in the icon view...
Definition: kdiroperator.cpp:2616
KDirOperator::numFiles
int numFiles() const
Definition: kdiroperator.cpp:578
KDirModel::Size
KConfigGroup::readEntry
T readEntry(const QString &key, const T &aDefault) const
KUrl::equals
bool equals(const KUrl &u, const EqualsOptions &options=0) const
KDirOperator::toggleDirsFirst
void toggleDirsFirst()
Toggles showing directories first / having them sorted like files.
Definition: kdiroperator.cpp:497
KFile::isTreeView
static bool isTreeView(const FileView &view)
completion
const KShortcut & completion()
KDirModel
KMessageBox::warningContinueCancel
static int warningContinueCancel(QWidget *parent, const QString &text, const QString &caption=QString(), const KGuiItem &buttonContinue=KStandardGuiItem::cont(), const KGuiItem &buttonCancel=KStandardGuiItem::cancel(), const QString &dontAskAgainName=QString(), Options options=Notify)
kfile_area
const int kfile_area
kfileitem.h
KFile::Detail
QAction
KDirOperator::setNameFilter
void setNameFilter(const QString &filter)
Sets a filter like &quot;*.cpp *.h *.o&quot;.
Definition: kdiroperator.cpp:1264
KIO::trash
CopyJob * trash(const KUrl &src, JobFlags flags=DefaultFlags)
KFileItem::url
KUrl url() const
KMessageBox::error
static void error(QWidget *parent, const QString &text, const QString &caption=QString(), Options options=Notify)
KDirOperator::resizeEvent
virtual void resizeEvent(QResizeEvent *event)
Definition: kdiroperator.cpp:2209
knewfilemenu.h
KFileItem
kconfiggroup.h
DefaultShowHidden
#define DefaultShowHidden
KIO::CopyJob
KDirOperator::setInlinePreviewShown
void setInlinePreviewShown(bool show)
Forces the inline previews to be shown or hidden, depending on show.
Definition: kdiroperator.cpp:892
KDirOperator::setViewConfig
virtual void setViewConfig(KConfigGroup &configGroup)
Sets the config object and the to be used group in KDirOperator.
Definition: kdiroperator.cpp:2590
KDirOperator::numDirs
int numDirs() const
Definition: kdiroperator.cpp:573
QList< int >
KDirOperator::activatedMenu
virtual void activatedMenu(const KFileItem &item, const QPoint &pos)
Called upon right-click to activate the popupmenu.
Definition: kdiroperator.cpp:1309
KDirOperator::SortActions
Definition: kdiroperator.h:111
list
QStringList list(const QString &fileClass)
This file is part of the KDE documentation.
Documentation copyright © 1996-2015 The KDE developers.
Generated on Tue Jul 28 2015 14:01:17 by doxygen 1.8.5 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KFile

Skip menu "KFile"
  • Main Page
  • Namespace List
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.10.5 API Reference

Skip menu "kdelibs-4.10.5 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal