kfile/kdiroperator.h

   1 // -*- c++ -*-
   2 /* This file is part of the KDE libraries
   3     Copyright (C) 1999 Stephan Kulow <coolo@kde.org>
   4     2000,2001 Carsten Pfeiffer <pfeiffer@kde.org>
   5
   6     This library is free software; you can redistribute it and/or
   7     modify it under the terms of the GNU Library General Public
   8     License as published by the Free Software Foundation; either
   9     version 2 of the License, or (at your option) any later version.
  10
  11     This library is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14     Library General Public License for more details.
  15
  16     You should have received a copy of the GNU Library General Public License
  17     along with this library; see the file COPYING.LIB.  If not, write to
  18     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19     Boston, MA 02110-1301, USA.
  20 */
  21 #ifndef KDIROPERATOR_H_
  22 #define KDIROPERATOR_H_
  23
  24 #include <QtGui/QWidget>
  25 #include <QtCore/QStack>
  26
  27 #include <ktoggleaction.h>
  28 #include <kcompletion.h>
  29 #include <kdirlister.h>
  30 #include <kfileitem.h>
  31 #include <kfile.h>
  32 #include <kfile_export.h>
  33
  34 class QAbstractItemView;
  35 class QModelIndex;
  36 class QProgressBar;
  37
  38 class KAction;
  39 class KActionCollection;
  40 class KActionMenu;
  41 class KDirLister;
  42 class KPreviewWidgetBase;
  43 class KFilePreviewGenerator;
  44
  45 namespace KIO
  46 {
  47 class CopyJob;
  48 class DeleteJob;
  49 }
  50
  51 /**
  52  * This widget works as a network transparent filebrowser. You specify a URL
  53  * to display and this url will be loaded via KDirLister. The user can
  54  * browse through directories, highlight and select files, delete or rename
  55  * files.
  56  *
  57  * It supports different views, e.g. a detailed view (see KFileDetailView),
  58  * a simple icon view (see KFileIconView), a combination of two views,
  59  * separating directories and files ( KCombiView).
  60  *
  61  * Additionally, a preview view is available (see KFilePreview), which can
  62  * show either a simple or detailed view and additionally a preview widget
  63  * (see setPreviewWidget()). KImageFilePreview is one implementation
  64  * of a preview widget, that displays previews for all supported filetypes
  65  * utilizing KIO::PreviewJob.
  66  *
  67  * Currently, those classes don't support Drag&Drop out of the box -- there
  68  * you have to use your own view-classes. You can use some DnD-aware views
  69  * from Björn Sahlström <bjorn@kbear.org> until they will be integrated
  70  * into this library. See http://devel-home.kde.org/~pfeiffer/DnD-classes.tar.gz
  71  *
  72  * This widget is the one used in the KFileDialog.
  73  *
  74  * Basic usage is like this:
  75  * \code
  76  *   KDirOperator *op = new KDirOperator( KUrl( "file:/home/gis" ), this );
  77  *   // some signals you might be interested in
  78  *   connect(op, SIGNAL(urlEntered(const KUrl&)),
  79  *           SLOT(urlEntered(const KUrl&)));
  80  *   connect(op, SIGNAL(fileHighlighted(const KFileItem &)),
  81  *           SLOT(fileHighlighted(const KFileItem &)));
  82  *   connect(op, SIGNAL(fileSelected(const KFileItem &)),
  83  *           SLOT(fileSelected(const KFileItem &)));
  84  *   connect(op, SIGNAL(finishedLoading()),
  85  *           SLOT(slotLoadingFinished()));
  86  *
  87  *   KConfigGroup grp(KGlobal::config(),"Your KDiroperator ConfigGroup" );
  88  *   op->readConfig( &grp);
  89  *   op->setView(KFile::Default);
  90  * \endcode
  91  *
  92  * This will create a childwidget of 'this' showing the directory contents
  93  * of /home/gis in the default-view. The view is determined by the readConfig()
  94  * call, which will read the KDirOperator settings, the user left your program
  95  * with (and which you saved with op->writeConfig()).
  96  *
  97  * @short A widget for displaying files and browsing directories.
  98  * @author Stephan Kulow <coolo@kde.org>, Carsten Pfeiffer <pfeiffer@kde.org>
  99  */
 100 class KFILE_EXPORT KDirOperator : public QWidget
 101 {
 102     Q_OBJECT
 103
 104 public:
 105     /**
 106      * The various action types. These values can be or'd together
 107      */
 108     enum ActionType
 109     {
 110         SortActions =  1,
 111         ViewActions =  2,
 112         NavActions  =  4,
 113         FileActions =  8,
 114         AllActions  = 15
 115     };
 116
 117     /**
 118      * Constructs the KDirOperator with no initial view. As the views are
 119      * configurable, call readConfig() to load the user's configuration
 120      * and then setView to explicitly set a view.
 121      *
 122      * This constructor doesn't start loading the url, setView will do it.
 123      */
 124     explicit KDirOperator(const KUrl& urlName = KUrl(),
 125                           QWidget *parent = 0);
 126     /**
 127      * Destroys the KDirOperator.
 128      */
 129     virtual ~KDirOperator();
 130
 131     /**
 132      * Enables/disables showing hidden files.
 133      */
 134     virtual void setShowHiddenFiles(bool s);
 135
 136     /**
 137      * @returns true when hidden files are shown or false otherwise.
 138      */
 139     bool showHiddenFiles() const;
 140
 141     /**
 142      * Stops loading immediately. You don't need to call this, usually.
 143      */
 144     void close();
 145
 146     /**
 147      * Sets a filter like "*.cpp *.h *.o". Only files matching that filter
 148      * will be shown.
 149      *
 150      * @see KDirLister::setNameFilter
 151      * @see nameFilter
 152      */
 153     void setNameFilter(const QString& filter);
 154
 155     /**
 156      * @returns the current namefilter.
 157      * @see setNameFilter
 158      */
 159     QString nameFilter() const;
 160
 161     /**
 162      * Sets a list of mimetypes as filter. Only files of those mimetypes
 163      * will be shown.
 164      *
 165      * Example:
 166      * \code
 167      * QStringList filter;
 168      * filter << "text/html" << "image/png" << "inode/directory";
 169      * dirOperator->setMimefilter( filter );
 170      * \endcode
 171      *
 172      * Node: Without the mimetype inode/directory, only files would be shown.
 173      * Call updateDir() to apply it.
 174      *
 175      * @see KDirLister::setMimeFilter
 176      * @see mimeFilter
 177      */
 178     void setMimeFilter(const QStringList& mimetypes);
 179
 180     /**
 181      * @returns the current mime filter.
 182      */
 183     QStringList mimeFilter() const;
 184
 185     /**
 186      * Clears both the namefilter and mimetype filter, so that all files and
 187      * directories will be shown. Call updateDir() to apply it.
 188      *
 189      * @see setMimeFilter
 190      * @see setNameFilter
 191      */
 192     void clearFilter();
 193
 194     /**
 195      * @returns the current url
 196      */
 197     KUrl url() const;
 198
 199     /**
 200      * Sets a new url to list.
 201      * @param clearforward specifies whether the "forward" history should be cleared.
 202      * @param url the URL to set
 203      */
 204     virtual void setUrl(const KUrl& url, bool clearforward);
 205
 206     /**
 207      * Clears the current selection and attempts to set @p url
 208      * the current url file. Note that urls can be relative or
 209      * absolute.
 210      */
 211     void setCurrentItem(const QString& url);
 212
 213     /**
 214      * Clears the current selection and attempts to set @p item
 215      * as the current item.
 216      */
 217     void setCurrentItem(const KFileItem& item);
 218
 219     /**
 220      * Clears the current selection and attempts to set @p urls
 221      * the current url files. Note that urls can be relative or
 222      * absolute.
 223      * @since 4.2
 224      */
 225     void setCurrentItems(const QStringList& urls);
 226
 227     /**
 228      * Clears the current selection and attempts to set @p items
 229      * as the current items.
 230      * @since 4.2
 231      */
 232     void setCurrentItems(const KFileItemList& items);
 233
 234     /**
 235      * Sets a new view to be used for showing and browsing files.
 236      * Note: this will read the current url() to fill the view.
 237      *
 238      * @see KFileTreeView
 239      * @see view
 240      */
 241     virtual void setView(QAbstractItemView *view);
 242
 243     /**
 244      * @returns the currently used view.
 245      * @see setView
 246      */
 247     QAbstractItemView* view() const;
 248
 249     /**
 250      * Sets one of the predefined fileviews.
 251      * @see KFile::FileView
 252      */
 253     virtual void setView(KFile::FileView viewKind);
 254
 255     /**
 256      * Sets the way to sort files and directories.
 257      */
 258     void setSorting(QDir::SortFlags);
 259
 260     /**
 261      * @returns the current way of sorting files and directories
 262      */
 263     QDir::SortFlags sorting() const;
 264
 265     /**
 266      * @returns true if we are displaying the root directory of the current url
 267      */
 268     bool isRoot() const;
 269
 270     /**
 271      * @returns the object listing the directory
 272      */
 273     KDirLister* dirLister() const;
 274
 275     /**
 276      * @returns the progress widget, that is shown during directory listing.
 277      * You can for example reparent() it to put it into a statusbar.
 278      */
 279     QProgressBar* progressBar() const;
 280
 281     /**
 282      * Sets the listing/selection mode for the views, an OR'ed combination of
 283      * @li File
 284      * @li Directory
 285      * @li Files
 286      * @li ExistingOnly
 287      * @li LocalOnly
 288      *
 289      * You cannot mix File and Files of course, as the former means
 290      * single-selection mode, the latter multi-selection.
 291      */
 292     virtual void setMode(KFile::Modes m);
 293     /**
 294      * @returns the listing/selection mode.
 295      */
 296     KFile::Modes mode() const;
 297
 298     /**
 299      * Sets a preview-widget to be shown next to the file-view.
 300      * The ownership of @p w is transferred to KDirOperator, so don't
 301      * delete it yourself!
 302      */
 303     virtual void setPreviewWidget(KPreviewWidgetBase *w);
 304
 305     /**
 306      * @returns a list of all currently selected items. If there is no view,
 307      * or there are no selected items, an empty list is returned.
 308      */
 309     KFileItemList selectedItems() const;
 310
 311     /**
 312      * @returns true if @p item is currently selected, or false otherwise.
 313      */
 314     bool isSelected(const KFileItem &item) const;
 315
 316     /**
 317      * @returns the number of directories in the currently listed url.
 318      * Returns 0 if there is no view.
 319      */
 320     int numDirs() const;
 321
 322     /**
 323      * @returns the number of files in the currently listed url.
 324      * Returns 0 if there is no view.
 325      */
 326     int numFiles() const;
 327
 328     /**
 329      * @returns a KCompletion object, containing all filenames and
 330      * directories of the current directory/URL.
 331      * You can use it to insert it into a KLineEdit or KComboBox
 332      * Note: it will only contain files, after prepareCompletionObjects()
 333      * has been called. It will be implicitly called from makeCompletion()
 334      * or makeDirCompletion()
 335      */
 336     KCompletion* completionObject() const;
 337
 338     /**
 339      * @returns a KCompletion object, containing only all directories of the
 340      * current directory/URL.
 341      * You can use it to insert it into a KLineEdit or KComboBox
 342      * Note: it will only contain directories, after
 343      * prepareCompletionObjects() has been called. It will be implicitly
 344      * called from makeCompletion() or makeDirCompletion()
 345      */
 346     KCompletion* dirCompletionObject() const;
 347
 348     /**
 349      * an accessor to a collection of all available Actions. The actions
 350      * are static, they will be there all the time (no need to connect to
 351      * the signals KActionCollection::inserted() or removed().
 352      *
 353      * There are the following actions:
 354      *
 355      * @li popupMenu : an ActionMenu presenting a popupmenu with all actions
 356      * @li up : changes to the parent directory
 357      * @li back : goes back to the previous directory
 358      * @li forward : goes forward in the history
 359      * @li home : changes to the user's home directory
 360      * @li reload : reloads the current directory
 361      * @li mkdir : opens a dialog box to create a directory
 362      * @li delete : deletes the selected files/directories
 363      * @li sorting menu : an ActionMenu containing all sort-options
 364      * @li by name : sorts by name
 365      * @li by size : sorts by size
 366      * @li by date : sorts by date
 367      * @li by type : sorts by type
 368      * @li descending : reverses the sort order
 369      * @li view menu : an ActionMenu containing all actions concerning the view
 370      * @li short view : shows a simple fileview
 371      * @li detailed view : shows a detailed fileview (dates, permissions ,...)
 372      * @li show hidden : shows hidden files
 373      * @li preview  : shows a preview next to the fileview
 374      * @li properties : shows a KPropertiesDialog for the selected files
 375      *
 376      * The short and detailed view are in an exclusive group. The sort-by
 377      * actions are in an exclusive group as well. Also the "separate dirs",
 378      * "preview" and "single" actions are in an exclusive group.
 379      *
 380      * You can e.g. use
 381      * \code
 382      * actionCollection()->action( "up" )->plug( someToolBar );
 383      * \endcode
 384      * to add a button into a toolbar, which makes the dirOperator change to
 385      * its parent directory.
 386      *
 387      * @returns all available Actions
 388      */
 389     KActionCollection* actionCollection() const;
 390
 391     /**
 392      * Sets the config object and the to be used group in KDirOperator. This
 393      * will be used to store the view's configuration.
 394      * If you don't set this, the views cannot save and restore their
 395      * configuration.
 396      *
 397      * Usually you call this right after KDirOperator creation so that the view
 398      * instantiation can make use of it already.
 399      *
 400      * Note that KDirOperator does NOT take ownership of that object (typically
 401      * it's KGlobal::config() anyway.
 402      *
 403      * You must not delete the KConfig or KConfigGroup object (and master config object) before
 404      * either deleting the KDirOperator or  calling setViewConfig(0); or something like that
 405      *
 406      * @see viewConfig
 407      * @see viewConfigGroup
 408      */
 409     virtual void setViewConfig(KConfigGroup& configGroup);
 410
 411     /*
 412      * @returns the group set by setViewConfig configuration.
 413      */
 414     KConfigGroup* viewConfigGroup() const;
 415
 416     /**
 417      * Reads the default settings for a view, i.e. the default KFile::FileView.
 418      * Also reads the sorting and whether hidden files should be shown.
 419      * Note: the default view will not be set - you have to call
 420      * \code
 421      * setView( KFile::Default )
 422      * \endcode
 423      * to apply it.
 424      *
 425      * @see setView
 426      * @see setViewConfig
 427      * @see writeConfig
 428      */
 429     virtual void readConfig(const KConfigGroup& configGroup);
 430
 431     /**
 432      * Saves the current settings like sorting, simple or detailed view.
 433      *
 434      * @see readConfig
 435      * @see setViewConfig
 436      */
 437     virtual void writeConfig(KConfigGroup& configGroup);
 438
 439     /**
 440      * This toggles between double/single click file and directory selection mode.
 441      * When argument is true, files and directories are highlighted with single click and
 442      * selected (executed) with double click.
 443      *
 444      * The default follows the signle/double click system setting.
 445      */
 446     void setOnlyDoubleClickSelectsFiles(bool enable);
 447
 448     /**
 449      * @returns whether files (not directories) should only be select()ed by
 450      * double-clicks.
 451      * @see setOnlyDoubleClickSelectsFiles
 452      */
 453     bool onlyDoubleClickSelectsFiles() const;
 454
 455     /**
 456      * Creates the given directory/url. If it is a relative path,
 457      * it will be completed with the current directory.
 458      * If enterDirectory is true, the directory will be entered after a
 459      * successful operation. If unsuccessful, a messagebox will be presented
 460      * to the user.
 461      * @returns true if the directory could be created.
 462      */
 463     virtual bool mkdir(const QString& directory, bool enterDirectory = true);
 464
 465     /**
 466      * Starts and returns a KIO::DeleteJob to delete the given @p items.
 467      *
 468      * @param items the list of items to be deleted
 469      * @param parent the parent widget used for the confirmation dialog
 470      * @param ask specifies whether a confirmation dialog should be shown
 471      * @param showProgress passed to the DeleteJob to show a progress dialog
 472      */
 473     virtual KIO::DeleteJob* del(const KFileItemList& items, QWidget *parent = 0,
 474                                 bool ask = true, bool showProgress = true);
 475
 476     /**
 477      * Clears the forward and backward history.
 478      */
 479     void clearHistory();
 480
 481     /**
 482      * When going up in the directory hierarchy, KDirOperator can highlight
 483      * the directory that was just left.
 484      *
 485      * I.e. when you go from /home/gis/src to /home/gis, the item "src" will
 486      * be made the current item.
 487      *
 488      * Default is off.
 489      */
 490     virtual void setEnableDirHighlighting(bool enable);
 491
 492     /**
 493      * @returns whether the last directory will be made the current item
 494      * when going up in the directory hierarchy.
 495      *
 496      * Default is false.
 497      */
 498     bool dirHighlighting() const;
 499
 500     /**
 501      * @returns true if we are in directory-only mode, that is, no files are
 502      * shown.
 503      */
 504     bool dirOnlyMode() const;
 505
 506     static bool dirOnlyMode(uint mode);
 507
 508     /**
 509      * Sets up the action menu.
 510      * @param whichActions is an value of OR'd ActionTypes that controls which actions to show in the action menu
 511      */
 512     void setupMenu(int whichActions);
 513
 514     /**
 515      * Reimplemented - allow dropping of files if @p b is true
 516      * @param b true if the widget should allow dropping of files
 517      */
 518     virtual void setAcceptDrops(bool b);
 519
 520     /**
 521      * Sets the options for dropping files.
 522      * CURRENTLY NOT IMPLEMENTED
 523      */
 524     virtual void setDropOptions(int options);
 525
 526     /**
 527      * Starts and returns a KIO::CopyJob to trash the given @p items.
 528      *
 529      * @param items the list of items to be trashed
 530      * @param parent the parent widget used for the confirmation dialog
 531      * @param ask specifies whether a confirmation dialog should be shown
 532      * @param showProgress passed to the CopyJob to show a progress dialog
 533      */
 534     virtual KIO::CopyJob* trash(const KFileItemList& items, QWidget *parent,
 535                                 bool ask = true, bool showProgress = true);
 536
 537     /**
 538       * Returns the preview generator for the current view.
 539       * @since 4.2
 540       */
 541     KFilePreviewGenerator *previewGenerator() const;
 542
 543     /**
 544      * Forces the inline previews to be shown or hidden, depending on @p show.
 545      *
 546      * @param show Whether to show inline previews or not.
 547      * @since 4.2
 548      */
 549     void setInlinePreviewShown(bool show);
 550
 551     /**
 552      * Returns whether the inline previews are shown or not.
 553      * @since 4.2
 554      */
 555     bool isInlinePreviewShown() const;
 556
 557     /**
 558      * Returns the icon zoom.
 559      * @since 4.2
 560      */
 561     int iconsZoom() const;
 562
 563     /**
 564      * If the system is set up to trigger items on single click, if @p isSaving
 565      * is true, we will force to double click to accept.
 566      * @note this is false by default
 567      * @since 4.2
 568      */
 569     void setIsSaving(bool isSaving);
 570
 571     /**
 572      * Returns whether KDirOperator will force a double click to accept.
 573      * @note this is false by default
 574      * @since 4.2
 575      */
 576     bool isSaving() const;
 577
 578 protected:
 579     /**
 580      * A view factory for creating predefined fileviews. Called internally by setView,
 581      * but you can also call it directly. Reimplement this if you depend on self defined fileviews.
 582      * @param parent   is the QWidget to be set as parent
 583      * @param viewKind is the predefined view to be set, note: this can be several ones OR:ed together
 584      * @returns the created view
 585      * @see KFile::FileView
 586      * @see setView
 587      */
 588     virtual QAbstractItemView* createView(QWidget *parent, KFile::FileView viewKind);
 589
 590     /**
 591      * Sets a custom KDirLister to list directories.
 592      * The KDirOperator takes ownership of the given KDirLister.
 593      */
 594     virtual void setDirLister(KDirLister *lister);
 595
 596     virtual void resizeEvent(QResizeEvent *event);
 597
 598     /**
 599      * Sets up all the actions. Called from the constructor, you usually
 600      * better not call this.
 601      */
 602     void setupActions();
 603
 604     /**
 605      * Updates the sorting-related actions to comply with the current sorting
 606      * @see sorting
 607      */
 608     void updateSortActions();
 609
 610     /**
 611      * Updates the view-related actions to comply with the current
 612      * KFile::FileView
 613      */
 614     void updateViewActions();
 615
 616     /**
 617      * Sets up the context-menu with all the necessary actions. Called from the
 618      * constructor, you usually don't need to call this.
 619      */
 620     void setupMenu();
 621
 622     /**
 623      * Synchronizes the completion objects with the entries of the
 624      * currently listed url.
 625      *
 626      * Automatically called from makeCompletion() and
 627      * makeDirCompletion()
 628      */
 629     void prepareCompletionObjects();
 630
 631     /**
 632      * Checks if there support from KIO::PreviewJob for the currently
 633      * shown files, taking mimeFilter() and nameFilter() into account
 634      * Enables/disables the preview-action accordingly.
 635      */
 636     bool checkPreviewSupport();
 637
 638     /**
 639      * Called upon right-click to activate the popupmenu.
 640      */
 641     virtual void activatedMenu(const KFileItem &item, const QPoint &pos);
 642
 643     virtual void changeEvent(QEvent *event);
 644
 645     virtual bool eventFilter(QObject *watched, QEvent *event);
 646
 647 public Q_SLOTS:
 648     /**
 649      * Goes one step back in the history and opens that url.
 650      */
 651     virtual void back();
 652
 653     /**
 654      * Goes one step forward in the history and opens that url.
 655      */
 656     virtual void forward();
 657
 658     /**
 659      * Enters the home directory.
 660      */
 661     virtual void home();
 662
 663     /**
 664      * Goes one directory up from the current url.
 665      */
 666     virtual void cdUp();
 667
 668     /**
 669      * to update the view after changing the settings
 670      */
 671     void updateDir();
 672
 673     /**
 674      * Re-reads the current url.
 675      */
 676     virtual void rereadDir();
 677
 678     /**
 679      * Opens a dialog to create a new directory.
 680      */
 681     virtual void mkdir();
 682
 683     /**
 684      * Deletes the currently selected files/directories.
 685      */
 686     virtual void deleteSelected();
 687
 688     /**
 689      * Enables/disables actions that are selection dependent. Call this e.g.
 690      * when you are about to show a popup menu using some of KDirOperators
 691      * actions.
 692      */
 693     void updateSelectionDependentActions();
 694
 695     /**
 696      * Tries to complete the given string (only completes files).
 697      */
 698     QString makeCompletion(const QString&);
 699
 700     /**
 701      * Tries to complete the given string (only completes directores).
 702      */
 703     QString makeDirCompletion(const QString&);
 704
 705     /**
 706      * Trashes the currently selected files/directories.
 707      *
 708      * This function used to take activation reason and keyboard modifiers,
 709      * in order to call deleteSelected() if the user wanted to delete.
 710      * Instead, call deleteSelected().
 711      *
 712      * FIXME KAction Port: link deleteSelected() up correctly
 713      */
 714     virtual void trashSelected();
 715
 716     /**
 717      * Notifies that the icons size should change. @p value is an int ranged from 0 to 100.
 718      * 100 means KIconLoader::SizeEnormous.
 719      * @since 4.2
 720      */
 721     void setIconsZoom(int value);
 722
 723 protected Q_SLOTS:
 724     /**
 725      * Restores the normal cursor after showing the busy-cursor. Also hides
 726      * the progressbar.
 727      */
 728     void resetCursor();
 729
 730     /**
 731      * Called after setUrl() to load the directory, update the history,
 732      * etc.
 733      */
 734     void pathChanged();
 735
 736     /**
 737      * Enters the directory specified by the given @p item.
 738      */
 739     virtual void selectDir(const KFileItem &item);
 740
 741     /**
 742      * Emits fileSelected( item )
 743      */
 744     void selectFile(const KFileItem &item);
 745
 746     /**
 747      * Emits fileHighlighted(item)
 748      */
 749     void highlightFile(const KFileItem &item);
 750
 751     /**
 752      * Changes sorting to sort by name
 753      */
 754     void sortByName();
 755
 756     /**
 757      * Changes sorting to sort by size
 758      */
 759     void sortBySize();
 760
 761     /**
 762      * Changes sorting to sort by date
 763      */
 764     void sortByDate();
 765
 766     /**
 767      * Changes sorting to sort by date
 768      */
 769     void sortByType();
 770
 771     /**
 772      * Changes sorting to reverse sorting
 773      */
 774     void sortReversed();
 775
 776     /**
 777      * Toggles showing directories first / having them sorted like files.
 778      */
 779     void toggleDirsFirst();
 780
 781     /**
 782      * Toggles case sensitive / case insensitive sorting
 783      */
 784     void toggleIgnoreCase();
 785
 786     /**
 787      * Tries to make the given @p match as current item in the view and emits
 788      * completion( match )
 789      */
 790     void slotCompletionMatch(const QString &match);
 791
 792 Q_SIGNALS:
 793     void urlEntered(const KUrl&);
 794     void updateInformation(int files, int dirs);
 795     void completion(const QString&);
 796     void finishedLoading();
 797
 798     /**
 799      * Emitted whenever the current fileview is changed, either by an explicit
 800      * call to setView() or by the user selecting a different view thru
 801      * the GUI.
 802      */
 803     void viewChanged(QAbstractItemView *newView);
 804
 805     /**
 806      * Emitted when a file is highlighted or generally the selection changes in
 807      * multiselection mode. In the latter case, @p item is 0L. You can access
 808      * the selected items with selectedItems().
 809      */
 810     void fileHighlighted(const KFileItem &item);
 811     void dirActivated(const KFileItem &item);
 812     void fileSelected(const KFileItem &item);
 813     /**
 814      * Emitted when files are dropped. Dropping files is disabled by
 815      * default. You need to enable it with setAcceptDrops()
 816      * @param item the item on which the drop occurred or 0.
 817      * @param event the drop event itself.
 818      * @param urls the urls that where dropped.
 819      */
 820     void dropped(const KFileItem &item, QDropEvent *event, const KUrl::List &urls);
 821
 822     /**
 823      * Emitted just before the context menu is shown, allows users to
 824      * extend the menu with custom actions.
 825      *
 826      * @param item the file on which the context menu was invoked
 827      * @param menu the context menu, pre-populated with the file-management actions
 828      * @since 4.2
 829      */
 830     void contextMenuAboutToShow(const KFileItem& item, QMenu* menu);
 831
 832     /**
 833      * Will notify that the icon size has changed. Since we save the icon size depending
 834      * on the view type (list view or a different kind of view), a call to setView() can
 835      * trigger this signal to be emitted.
 836      * @since 4.2
 837      */
 838     void currentIconSizeChanged(int size);
 839
 840 private:
 841     class Private;
 842     Private* const d;
 843
 844     Q_PRIVATE_SLOT( d, void _k_slotDetailedView() )
 845     Q_PRIVATE_SLOT( d, void _k_slotSimpleView() )
 846     Q_PRIVATE_SLOT( d, void _k_slotTreeView() )
 847     Q_PRIVATE_SLOT( d, void _k_slotDetailedTreeView() )
 848     Q_PRIVATE_SLOT( d, void _k_slotToggleHidden(bool) )
 849     Q_PRIVATE_SLOT( d, void _k_togglePreview(bool) )
 850     Q_PRIVATE_SLOT( d, void _k_toggleInlinePreviews(bool) )
 851     Q_PRIVATE_SLOT( d, void _k_slotSortByName() )
 852     Q_PRIVATE_SLOT( d, void _k_slotSortBySize() )
 853     Q_PRIVATE_SLOT( d, void _k_slotSortByDate() )
 854     Q_PRIVATE_SLOT( d, void _k_slotSortByType() )
 855     Q_PRIVATE_SLOT( d, void _k_slotSortReversed(bool) )
 856     Q_PRIVATE_SLOT( d, void _k_slotToggleDirsFirst() )
 857     Q_PRIVATE_SLOT( d, void _k_slotToggleIgnoreCase() )
 858     Q_PRIVATE_SLOT( d, void _k_slotStarted() )
 859     Q_PRIVATE_SLOT( d, void _k_slotProgress(int) )
 860     Q_PRIVATE_SLOT( d, void _k_slotShowProgress() )
 861     Q_PRIVATE_SLOT( d, void _k_slotIOFinished() )
 862     Q_PRIVATE_SLOT( d, void _k_slotCanceled() )
 863     Q_PRIVATE_SLOT( d, void _k_slotRedirected(const KUrl&) )
 864     Q_PRIVATE_SLOT( d, void _k_slotProperties() )
 865     Q_PRIVATE_SLOT( d, void _k_slotPressed(const QModelIndex&) )
 866     Q_PRIVATE_SLOT( d, void _k_slotActivated(const QModelIndex&) )
 867     Q_PRIVATE_SLOT( d, void _k_slotDoubleClicked(const QModelIndex&) )
 868     Q_PRIVATE_SLOT( d, void _k_slotSelectionChanged() )
 869     Q_PRIVATE_SLOT( d, void _k_openContextMenu(const QPoint&) )
 870     Q_PRIVATE_SLOT( d, void _k_triggerPreview(const QModelIndex&) )
 871     Q_PRIVATE_SLOT( d, void _k_showPreview() )
 872     Q_PRIVATE_SLOT( d, void _k_slotSplitterMoved(int, int) )
 873     Q_PRIVATE_SLOT( d, void _k_assureVisibleSelection() )
 874     Q_PRIVATE_SLOT( d, void _k_synchronizeSortingState(int, Qt::SortOrder) )
 875     Q_PRIVATE_SLOT( d, void _k_slotChangeDecorationPosition() )
 876     Q_PRIVATE_SLOT( d, void _k_slotExpandToUrl(const QModelIndex&) )
 877 };
 878
 879 #endif