src/dolphinviewactionhandler.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by David Faure <faure@kde.org>                     *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA            *
  18  ***************************************************************************/
  19
  20 #include "dolphinviewactionhandler.h"
  21
  22 #include "settings/viewpropertiesdialog.h"
  23 #include "dolphinview.h"
  24 #include "zoomlevelinfo.h"
  25
  26 #include <konq_operations.h>
  27
  28 #include <kaction.h>
  29 #include <kactioncollection.h>
  30 #include <klocale.h>
  31 #include <ktoggleaction.h>
  32 #include <krun.h>
  33 #include <kpropertiesdialog.h>
  34
  35 DolphinViewActionHandler::DolphinViewActionHandler(KActionCollection* collection, QObject* parent)
  36     : QObject(parent),
  37       m_actionCollection(collection),
  38       m_currentView(0)
  39 {
  40     Q_ASSERT(m_actionCollection);
  41     createActions();
  42 }
  43
  44 void DolphinViewActionHandler::setCurrentView(DolphinView* view)
  45 {
  46     Q_ASSERT(view);
  47
  48     if (m_currentView)
  49         disconnect(m_currentView, 0, this, 0);
  50
  51     m_currentView = view;
  52
  53     connect(view, SIGNAL(modeChanged()),
  54             this, SLOT(updateViewActions()));
  55     connect(view, SIGNAL(showPreviewChanged()),
  56             this, SLOT(slotShowPreviewChanged()));
  57     connect(view, SIGNAL(sortOrderChanged(Qt::SortOrder)),
  58             this, SLOT(slotSortOrderChanged(Qt::SortOrder)));
  59     connect(view, SIGNAL(additionalInfoChanged()),
  60             this, SLOT(slotAdditionalInfoChanged()));
  61     connect(view, SIGNAL(categorizedSortingChanged()),
  62             this, SLOT(slotCategorizedSortingChanged()));
  63     connect(view, SIGNAL(showHiddenFilesChanged()),
  64             this, SLOT(slotShowHiddenFilesChanged()));
  65     connect(view, SIGNAL(sortingChanged(DolphinView::Sorting)),
  66             this, SLOT(slotSortingChanged(DolphinView::Sorting)));
  67     connect(view, SIGNAL(zoomLevelChanged(int)),
  68             this, SLOT(slotZoomLevelChanged(int)));
  69 }
  70
  71 void DolphinViewActionHandler::createActions()
  72 {
  73     // This action doesn't appear in the GUI, it's for the shortcut only.
  74     // KNewMenu takes care of the GUI stuff.
  75     KAction* newDirAction = m_actionCollection->addAction("create_dir");
  76     newDirAction->setText(i18nc("@action", "Create Folder..."));
  77     newDirAction->setShortcut(Qt::Key_F10);
  78     newDirAction->setIcon(KIcon("folder-new"));
  79     connect(newDirAction, SIGNAL(triggered()), SLOT(slotCreateDir()));
  80
  81     // Edit menu
  82
  83     KAction* rename = m_actionCollection->addAction("rename");
  84     rename->setText(i18nc("@action:inmenu File", "Rename..."));
  85     rename->setShortcut(Qt::Key_F2);
  86     rename->setIcon(KIcon("edit-rename"));
  87     connect(rename, SIGNAL(triggered()), this, SLOT(slotRename()));
  88
  89     KAction* moveToTrash = m_actionCollection->addAction("move_to_trash");
  90     moveToTrash->setText(i18nc("@action:inmenu File", "Move to Trash"));
  91     moveToTrash->setIcon(KIcon("user-trash"));
  92     moveToTrash->setShortcut(QKeySequence::Delete);
  93     connect(moveToTrash, SIGNAL(triggered(Qt::MouseButtons, Qt::KeyboardModifiers)),
  94             this, SLOT(slotTrashActivated(Qt::MouseButtons, Qt::KeyboardModifiers)));
  95
  96     KAction* deleteAction = m_actionCollection->addAction("delete");
  97     deleteAction->setIcon(KIcon("edit-delete"));
  98     deleteAction->setText(i18nc("@action:inmenu File", "Delete"));
  99     deleteAction->setShortcut(Qt::SHIFT | Qt::Key_Delete);
 100     connect(deleteAction, SIGNAL(triggered()), this, SLOT(slotDeleteItems()));
 101
 102     // This action is useful for being enabled when "move_to_trash" should be
 103     // disabled and "delete" is enabled (e.g. non-local files), so that Key_Del
 104     // can be used for deleting the file (#76016). It needs to be a separate action
 105     // so that the Edit menu isn't affected.
 106     KAction* deleteWithTrashShortcut = m_actionCollection->addAction("delete_shortcut");
 107     // The descriptive text is just for the shortcuts editor.
 108     deleteWithTrashShortcut->setText(i18nc("@action:inmenu File", "Delete (using shortcut for Trash)"));
 109     deleteWithTrashShortcut->setShortcut(QKeySequence::Delete);
 110     deleteWithTrashShortcut->setEnabled(false);
 111     connect(deleteWithTrashShortcut, SIGNAL(triggered()), this, SLOT(slotDeleteItems()));
 112
 113     KAction *propertiesAction = m_actionCollection->addAction( "properties" );
 114     // Well, it's the File menu in dolphinmainwindow and the Edit menu in dolphinpart... :)
 115     propertiesAction->setText( i18nc("@action:inmenu File", "Properties") );
 116     propertiesAction->setIcon(KIcon("document-properties"));
 117     propertiesAction->setShortcut(Qt::ALT | Qt::Key_Return);
 118     connect(propertiesAction, SIGNAL(triggered()), SLOT(slotProperties()));
 119
 120     // View menu
 121
 122     QActionGroup* viewModeActions = new QActionGroup(this);
 123     viewModeActions->addAction(iconsModeAction());
 124     viewModeActions->addAction(detailsModeAction());
 125     viewModeActions->addAction(columnsModeAction());
 126     connect(viewModeActions, SIGNAL(triggered(QAction*)), this, SLOT(slotViewModeActionTriggered(QAction*)));
 127
 128     KStandardAction::zoomIn(this,
 129                             SLOT(zoomIn()),
 130                             m_actionCollection);
 131
 132     KStandardAction::zoomOut(this,
 133                              SLOT(zoomOut()),
 134                              m_actionCollection);
 135
 136     KToggleAction* showPreview = m_actionCollection->add<KToggleAction>("show_preview");
 137     showPreview->setText(i18nc("@action:intoolbar", "Preview"));
 138     showPreview->setIcon(KIcon("view-preview"));
 139     connect(showPreview, SIGNAL(triggered(bool)), this, SLOT(togglePreview(bool)));
 140
 141     KToggleAction* sortDescending = m_actionCollection->add<KToggleAction>("descending");
 142     sortDescending->setText(i18nc("@action:inmenu Sort", "Descending"));
 143     connect(sortDescending, SIGNAL(triggered()), this, SLOT(toggleSortOrder()));
 144
 145     QActionGroup* sortByActionGroup = createSortByActionGroup();
 146     connect(sortByActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(slotSortTriggered(QAction*)));
 147
 148     QActionGroup* showInformationActionGroup = createAdditionalInformationActionGroup();
 149     connect(showInformationActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(toggleAdditionalInfo(QAction*)));
 150
 151     KToggleAction* showInGroups = m_actionCollection->add<KToggleAction>("show_in_groups");
 152     showInGroups->setText(i18nc("@action:inmenu View", "Show in Groups"));
 153     connect(showInGroups, SIGNAL(triggered(bool)), this, SLOT(toggleSortCategorization(bool)));
 154
 155     KToggleAction* showHiddenFiles = m_actionCollection->add<KToggleAction>("show_hidden_files");
 156     showHiddenFiles->setText(i18nc("@action:inmenu View", "Show Hidden Files"));
 157     showHiddenFiles->setShortcuts(QList<QKeySequence>() << Qt::ALT + Qt::Key_Period << Qt::Key_F8);
 158     connect(showHiddenFiles, SIGNAL(triggered(bool)), this, SLOT(toggleShowHiddenFiles(bool)));
 159
 160     KAction* adjustViewProps = m_actionCollection->addAction("view_properties");
 161     adjustViewProps->setText(i18nc("@action:inmenu View", "Adjust View Properties..."));
 162     connect(adjustViewProps, SIGNAL(triggered()), this, SLOT(slotAdjustViewProperties()));
 163
 164     // Tools menu
 165
 166     KAction* findFile = m_actionCollection->addAction("find_file");
 167     findFile->setText(i18nc("@action:inmenu Tools", "Find File..."));
 168     findFile->setShortcut(Qt::CTRL | Qt::Key_F);
 169     findFile->setIcon(KIcon("edit-find"));
 170     connect(findFile, SIGNAL(triggered()), this, SLOT(slotFindFile()));
 171 }
 172
 173 QActionGroup* DolphinViewActionHandler::createAdditionalInformationActionGroup()
 174 {
 175     QActionGroup* showInformationGroup = new QActionGroup(m_actionCollection);
 176     showInformationGroup->setExclusive(false);
 177
 178     KToggleAction* showSizeInfo = m_actionCollection->add<KToggleAction>("show_size_info");
 179     showSizeInfo->setText(i18nc("@action:inmenu Additional information", "Size"));
 180     showSizeInfo->setData(KFileItemDelegate::Size);
 181     showSizeInfo->setActionGroup(showInformationGroup);
 182
 183     KToggleAction* showDateInfo = m_actionCollection->add<KToggleAction>("show_date_info");
 184     showDateInfo->setText(i18nc("@action:inmenu Additional information", "Date"));
 185     showDateInfo->setData(KFileItemDelegate::ModificationTime);
 186     showDateInfo->setActionGroup(showInformationGroup);
 187
 188     KToggleAction* showPermissionsInfo = m_actionCollection->add<KToggleAction>("show_permissions_info");
 189     showPermissionsInfo->setText(i18nc("@action:inmenu Additional information", "Permissions"));
 190     showPermissionsInfo->setData(KFileItemDelegate::Permissions);
 191     showPermissionsInfo->setActionGroup(showInformationGroup);
 192
 193     KToggleAction* showOwnerInfo = m_actionCollection->add<KToggleAction>("show_owner_info");
 194     showOwnerInfo->setText(i18nc("@action:inmenu Additional information", "Owner"));
 195     showOwnerInfo->setData(KFileItemDelegate::Owner);
 196     showOwnerInfo->setActionGroup(showInformationGroup);
 197
 198     KToggleAction* showGroupInfo = m_actionCollection->add<KToggleAction>("show_group_info");
 199     showGroupInfo->setText(i18nc("@action:inmenu Additional information", "Group"));
 200     showGroupInfo->setData(KFileItemDelegate::OwnerAndGroup);
 201     showGroupInfo->setActionGroup(showInformationGroup);
 202
 203     KToggleAction* showMimeInfo = m_actionCollection->add<KToggleAction>("show_mime_info");
 204     showMimeInfo->setText(i18nc("@action:inmenu Additional information", "Type"));
 205     showMimeInfo->setData(KFileItemDelegate::FriendlyMimeType);
 206     showMimeInfo->setActionGroup(showInformationGroup);
 207
 208     return showInformationGroup;
 209 }
 210
 211 Q_DECLARE_METATYPE(DolphinView::Sorting)
 212
 213 QActionGroup* DolphinViewActionHandler::createSortByActionGroup()
 214 {
 215     QActionGroup* sortByActionGroup = new QActionGroup(m_actionCollection);
 216     sortByActionGroup->setExclusive(true);
 217
 218     KToggleAction* sortByName = m_actionCollection->add<KToggleAction>("sort_by_name");
 219     sortByName->setText(i18nc("@action:inmenu Sort By", "Name"));
 220     sortByName->setData(QVariant::fromValue(DolphinView::SortByName));
 221     sortByActionGroup->addAction(sortByName);
 222
 223     KToggleAction* sortBySize = m_actionCollection->add<KToggleAction>("sort_by_size");
 224     sortBySize->setText(i18nc("@action:inmenu Sort By", "Size"));
 225     sortBySize->setData(QVariant::fromValue(DolphinView::SortBySize));
 226     sortByActionGroup->addAction(sortBySize);
 227
 228     KToggleAction* sortByDate = m_actionCollection->add<KToggleAction>("sort_by_date");
 229     sortByDate->setText(i18nc("@action:inmenu Sort By", "Date"));
 230     sortByDate->setData(QVariant::fromValue(DolphinView::SortByDate));
 231     sortByActionGroup->addAction(sortByDate);
 232
 233     KToggleAction* sortByPermissions = m_actionCollection->add<KToggleAction>("sort_by_permissions");
 234     sortByPermissions->setText(i18nc("@action:inmenu Sort By", "Permissions"));
 235     sortByPermissions->setData(QVariant::fromValue(DolphinView::SortByPermissions));
 236     sortByActionGroup->addAction(sortByPermissions);
 237
 238     KToggleAction* sortByOwner = m_actionCollection->add<KToggleAction>("sort_by_owner");
 239     sortByOwner->setText(i18nc("@action:inmenu Sort By", "Owner"));
 240     sortByOwner->setData(QVariant::fromValue(DolphinView::SortByOwner));
 241     sortByActionGroup->addAction(sortByOwner);
 242
 243     KToggleAction* sortByGroup = m_actionCollection->add<KToggleAction>("sort_by_group");
 244     sortByGroup->setText(i18nc("@action:inmenu Sort By", "Group"));
 245     sortByGroup->setData(QVariant::fromValue(DolphinView::SortByGroup));
 246     sortByActionGroup->addAction(sortByGroup);
 247
 248     KToggleAction* sortByType = m_actionCollection->add<KToggleAction>("sort_by_type");
 249     sortByType->setText(i18nc("@action:inmenu Sort By", "Type"));
 250     sortByType->setData(QVariant::fromValue(DolphinView::SortByType));
 251     sortByActionGroup->addAction(sortByType);
 252
 253     // TODO: Hid "sort by rating" and "sort by tags" as without caching the performance
 254     // is too slow currently (Nepomuk will support caching in future releases).
 255     //
 256     // KToggleAction* sortByRating = m_actionCollection->add<KToggleAction>("sort_by_rating");
 257     // sortByRating->setData(QVariant::fromValue(DolphinView::SortByRating));
 258     // sortByRating->setText(i18nc("@action:inmenu Sort By", "Rating"));
 259     // sortByActionGroup->addAction(sortByRating);
 260     //
 261     // KToggleAction* sortByTags = m_actionCollection->add<KToggleAction>("sort_by_tags");
 262     // sortByTags->setData(QVariant::fromValue(DolphinView::SortByTags));
 263     // sortByTags->setText(i18nc("@action:inmenu Sort By", "Tags"));
 264     // sortByActionGroup->addAction(sortByTags);
 265     //
 266 #ifdef HAVE_NEPOMUK
 267     // if (!MetaDataWidget::metaDataAvailable()) {
 268     //     sortByRating->setEnabled(false);
 269     //     sortByTags->setEnabled(false);
 270     // }
 271 #else
 272     // sortByRating->setEnabled(false);
 273     // sortByTags->setEnabled(false);
 274 #endif
 275
 276
 277
 278     return sortByActionGroup;
 279 }
 280
 281 void DolphinViewActionHandler::slotCreateDir()
 282 {
 283     Q_ASSERT(m_currentView);
 284     KonqOperations::newDir(m_currentView, m_currentView->url());
 285 }
 286
 287 void DolphinViewActionHandler::slotViewModeActionTriggered(QAction* action)
 288 {
 289     const DolphinView::Mode mode = action->data().value<DolphinView::Mode>();
 290     m_currentView->setMode(mode);
 291 }
 292
 293 void DolphinViewActionHandler::slotRename()
 294 {
 295     emit actionBeingHandled();
 296     m_currentView->renameSelectedItems();
 297 }
 298
 299 void DolphinViewActionHandler::slotTrashActivated(Qt::MouseButtons, Qt::KeyboardModifiers modifiers)
 300 {
 301     emit actionBeingHandled();
 302     // Note: kde3's konq_mainwindow.cpp used to check
 303     // reason == KAction::PopupMenuActivation && ...
 304     // but this isn't supported anymore
 305     if (modifiers & Qt::ShiftModifier)
 306         m_currentView->deleteSelectedItems();
 307     else
 308         m_currentView->trashSelectedItems();
 309 }
 310
 311 void DolphinViewActionHandler::slotDeleteItems()
 312 {
 313     emit actionBeingHandled();
 314     m_currentView->deleteSelectedItems();
 315 }
 316
 317 void DolphinViewActionHandler::togglePreview(bool show)
 318 {
 319     emit actionBeingHandled();
 320     m_currentView->setShowPreview(show);
 321 }
 322
 323 void DolphinViewActionHandler::slotShowPreviewChanged()
 324 {
 325     // It is not enough to update the 'Show Preview' action, also
 326     // the 'Zoom In' and 'Zoom Out' actions must be adapted.
 327     updateViewActions();
 328 }
 329
 330 QString DolphinViewActionHandler::currentViewModeActionName() const
 331 {
 332     switch (m_currentView->mode()) {
 333     case DolphinView::IconsView:
 334         return "icons";
 335     case DolphinView::DetailsView:
 336         return "details";
 337     case DolphinView::ColumnView:
 338         return "columns";
 339     }
 340     return QString(); // can't happen
 341 }
 342
 343 void DolphinViewActionHandler::updateViewActions()
 344 {
 345     QAction* viewModeAction = m_actionCollection->action(currentViewModeActionName());
 346     if (viewModeAction != 0) {
 347         viewModeAction->setChecked(true);
 348     }
 349
 350     QAction* showPreviewAction = m_actionCollection->action("show_preview");
 351     showPreviewAction->setChecked(m_currentView->showPreview());
 352
 353     slotSortOrderChanged(m_currentView->sortOrder());
 354     slotAdditionalInfoChanged();
 355     slotCategorizedSortingChanged();
 356     slotSortingChanged(m_currentView->sorting());
 357     slotZoomLevelChanged(m_currentView->zoomLevel());
 358
 359     QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
 360     showHiddenFilesAction->setChecked(m_currentView->showHiddenFiles());
 361
 362 }
 363
 364 void DolphinViewActionHandler::zoomIn()
 365 {
 366     const int level = m_currentView->zoomLevel();
 367     m_currentView->setZoomLevel(level + 1);
 368     updateViewActions();
 369 }
 370
 371 void DolphinViewActionHandler::zoomOut()
 372 {
 373     const int level = m_currentView->zoomLevel();
 374     m_currentView->setZoomLevel(level - 1);
 375     updateViewActions();
 376 }
 377
 378 void DolphinViewActionHandler::toggleSortOrder()
 379 {
 380     m_currentView->toggleSortOrder();
 381 }
 382
 383 void DolphinViewActionHandler::slotSortOrderChanged(Qt::SortOrder order)
 384 {
 385     QAction* descending = m_actionCollection->action("descending");
 386     const bool sortDescending = (order == Qt::DescendingOrder);
 387     descending->setChecked(sortDescending);
 388 }
 389
 390 void DolphinViewActionHandler::toggleAdditionalInfo(QAction* action)
 391 {
 392     emit actionBeingHandled();
 393     m_currentView->toggleAdditionalInfo(action);
 394 }
 395
 396 void DolphinViewActionHandler::slotAdditionalInfoChanged()
 397 {
 398     m_currentView->updateAdditionalInfoActions(m_actionCollection);
 399 }
 400
 401 void DolphinViewActionHandler::toggleSortCategorization(bool categorizedSorting)
 402 {
 403     m_currentView->setCategorizedSorting(categorizedSorting);
 404 }
 405
 406 void DolphinViewActionHandler::slotCategorizedSortingChanged()
 407 {
 408     QAction* showInGroupsAction = m_actionCollection->action("show_in_groups");
 409     showInGroupsAction->setChecked(m_currentView->categorizedSorting());
 410     showInGroupsAction->setEnabled(m_currentView->supportsCategorizedSorting());
 411 }
 412
 413 void DolphinViewActionHandler::toggleShowHiddenFiles(bool show)
 414 {
 415     emit actionBeingHandled();
 416     m_currentView->setShowHiddenFiles(show);
 417 }
 418
 419 void DolphinViewActionHandler::slotShowHiddenFilesChanged()
 420 {
 421     QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
 422     showHiddenFilesAction->setChecked(m_currentView->showHiddenFiles());
 423 }
 424
 425
 426 KToggleAction* DolphinViewActionHandler::iconsModeAction()
 427 {
 428     KToggleAction* iconsView = m_actionCollection->add<KToggleAction>("icons");
 429     iconsView->setText(i18nc("@action:inmenu View Mode", "Icons"));
 430     iconsView->setShortcut(Qt::CTRL | Qt::Key_1);
 431     iconsView->setIcon(KIcon("view-list-icons"));
 432     iconsView->setData(QVariant::fromValue(DolphinView::IconsView));
 433     return iconsView;
 434 }
 435
 436 KToggleAction* DolphinViewActionHandler::detailsModeAction()
 437 {
 438     KToggleAction* detailsView = m_actionCollection->add<KToggleAction>("details");
 439     detailsView->setText(i18nc("@action:inmenu View Mode", "Details"));
 440     detailsView->setShortcut(Qt::CTRL | Qt::Key_2);
 441     detailsView->setIcon(KIcon("view-list-details"));
 442     detailsView->setData(QVariant::fromValue(DolphinView::DetailsView));
 443     return detailsView;
 444 }
 445
 446 KToggleAction* DolphinViewActionHandler::columnsModeAction()
 447 {
 448     KToggleAction* columnView = m_actionCollection->add<KToggleAction>("columns");
 449     columnView->setText(i18nc("@action:inmenu View Mode", "Columns"));
 450     columnView->setShortcut(Qt::CTRL | Qt::Key_3);
 451     columnView->setIcon(KIcon("view-file-columns"));
 452     columnView->setData(QVariant::fromValue(DolphinView::ColumnView));
 453     return columnView;
 454 }
 455
 456 void DolphinViewActionHandler::slotSortingChanged(DolphinView::Sorting sorting)
 457 {
 458     QAction* action = 0;
 459     switch (sorting) {
 460     case DolphinView::SortByName:
 461         action = m_actionCollection->action("sort_by_name");
 462         break;
 463     case DolphinView::SortBySize:
 464         action = m_actionCollection->action("sort_by_size");
 465         break;
 466     case DolphinView::SortByDate:
 467         action = m_actionCollection->action("sort_by_date");
 468         break;
 469     case DolphinView::SortByPermissions:
 470         action = m_actionCollection->action("sort_by_permissions");
 471         break;
 472     case DolphinView::SortByOwner:
 473         action = m_actionCollection->action("sort_by_owner");
 474         break;
 475     case DolphinView::SortByGroup:
 476         action = m_actionCollection->action("sort_by_group");
 477         break;
 478     case DolphinView::SortByType:
 479         action = m_actionCollection->action("sort_by_type");
 480         break;
 481 #ifdef HAVE_NEPOMUK
 482     case DolphinView::SortByRating:
 483         action = m_actionCollection->action("sort_by_rating");
 484         break;
 485     case DolphinView::SortByTags:
 486         action = m_actionCollection->action("sort_by_tags");
 487         break;
 488 #endif
 489     default:
 490         break;
 491     }
 492
 493     if (action != 0) {
 494         action->setChecked(true);
 495     }
 496 }
 497
 498 void DolphinViewActionHandler::slotZoomLevelChanged(int level)
 499 {
 500     QAction* zoomInAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomIn));
 501     if (zoomInAction != 0) {
 502         zoomInAction->setEnabled(level < ZoomLevelInfo::maximumLevel());
 503     }
 504
 505     QAction* zoomOutAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomOut));
 506     if (zoomOutAction != 0) {
 507         zoomOutAction->setEnabled(level > ZoomLevelInfo::minimumLevel());
 508     }
 509 }
 510
 511 void DolphinViewActionHandler::slotSortTriggered(QAction* action)
 512 {
 513     const DolphinView::Sorting sorting = action->data().value<DolphinView::Sorting>();
 514     m_currentView->setSorting(sorting);
 515 }
 516
 517 void DolphinViewActionHandler::slotAdjustViewProperties()
 518 {
 519     emit actionBeingHandled();
 520     ViewPropertiesDialog dlg(m_currentView);
 521     dlg.exec();
 522 }
 523
 524 void DolphinViewActionHandler::slotFindFile()
 525 {
 526     KRun::run("kfind %u", m_currentView->url(), m_currentView->window());
 527 }
 528
 529 void DolphinViewActionHandler::slotProperties()
 530 {
 531     KPropertiesDialog* dialog = 0;
 532     const KFileItemList list = m_currentView->selectedItems();
 533     if (list.isEmpty()) {
 534         const KUrl url = m_currentView->url();
 535         dialog = new KPropertiesDialog(url, m_currentView);
 536     } else {
 537         dialog = new KPropertiesDialog(list, m_currentView);
 538     }
 539
 540     dialog->setAttribute(Qt::WA_DeleteOnClose);
 541     dialog->show();
 542     dialog->raise();
 543     dialog->activateWindow();
 544 }