← Back to branch summary

~ubuntu-branches/debian/sid/kde-baseapps/sid

« back to all changes in this revision

Viewing changes to dolphin/src/views/dolphinviewactionhandler.cpp

  • Committer: Package Import Robot
  • Author(s): Modestas Vainius, Eshat Cakar, Pino Toscano
  • Date: 2012-06-09 22:18:08 UTC
  • mfrom: (4.2.1) (6.1.1 experimental)
  • Revision ID: package-import@ubuntu.com-20120609221808-h1l0ekd5qmb8nefr
Tags: 4:4.8.4-1
* New upstream release.

[ Eshat Cakar ]
* Add watch file.
* Bump kde-sc-dev-latest build dependency to version 4:4.8.4.
* Update installed files.

[ Pino Toscano ]
* Move files of the konqueror documentation from kde-baseapps-data to
  konqueror itself.

Show diffs side-by-side

added added

removed removed

Lines of Context:
dolphin/src/views/dolphinviewactionhandler.cpp
36
36
#include <KRun>
37
37
#include <KPropertiesDialog>
38
38
 
 
39
#include <KDebug>
 
40
 
39
41
DolphinViewActionHandler::DolphinViewActionHandler(KActionCollection* collection, QObject* parent)
40
42
    : QObject(parent),
41
43
      m_actionCollection(collection),
49
51
{
50
52
    Q_ASSERT(view);
51
53
 
52
 
    if (m_currentView)
 
54
    if (m_currentView) {
53
55
        disconnect(m_currentView, 0, this, 0);
 
56
    }
54
57
 
55
58
    m_currentView = view;
56
59
 
57
 
    connect(view, SIGNAL(modeChanged()),
 
60
    connect(view, SIGNAL(modeChanged(DolphinView::Mode,DolphinView::Mode)),
58
61
            this, SLOT(updateViewActions()));
59
 
    connect(view, SIGNAL(showPreviewChanged()),
60
 
            this, SLOT(slotShowPreviewChanged()));
 
62
    connect(view, SIGNAL(previewsShownChanged(bool)),
 
63
            this, SLOT(slotPreviewsShownChanged(bool)));
61
64
    connect(view, SIGNAL(sortOrderChanged(Qt::SortOrder)),
62
65
            this, SLOT(slotSortOrderChanged(Qt::SortOrder)));
63
66
    connect(view, SIGNAL(sortFoldersFirstChanged(bool)),
64
67
            this, SLOT(slotSortFoldersFirstChanged(bool)));
65
 
    connect(view, SIGNAL(additionalInfoChanged()),
66
 
            this, SLOT(slotAdditionalInfoChanged()));
67
 
    connect(view, SIGNAL(categorizedSortingChanged()),
68
 
            this, SLOT(slotCategorizedSortingChanged()));
69
 
    connect(view, SIGNAL(showHiddenFilesChanged()),
70
 
            this, SLOT(slotShowHiddenFilesChanged()));
 
68
    connect(view, SIGNAL(additionalInfoListChanged(QList<DolphinView::AdditionalInfo>,
 
69
                                                   QList<DolphinView::AdditionalInfo>)),
 
70
            this, SLOT(slotAdditionalInfoListChanged(QList<DolphinView::AdditionalInfo>,
 
71
                                                     QList<DolphinView::AdditionalInfo>)));
 
72
    connect(view, SIGNAL(groupedSortingChanged(bool)),
 
73
            this, SLOT(slotGroupedSortingChanged(bool)));
 
74
    connect(view, SIGNAL(hiddenFilesShownChanged(bool)),
 
75
            this, SLOT(slotHiddenFilesShownChanged(bool)));
71
76
    connect(view, SIGNAL(sortingChanged(DolphinView::Sorting)),
72
77
            this, SLOT(slotSortingChanged(DolphinView::Sorting)));
73
 
    connect(view, SIGNAL(zoomLevelChanged(int)),
74
 
            this, SLOT(slotZoomLevelChanged(int)));
 
78
    connect(view, SIGNAL(zoomLevelChanged(int,int)),
 
79
            this, SLOT(slotZoomLevelChanged(int,int)));
75
80
}
76
81
 
77
82
DolphinView* DolphinViewActionHandler::currentView()
101
106
    moveToTrash->setText(i18nc("@action:inmenu File", "Move to Trash"));
102
107
    moveToTrash->setIcon(KIcon("user-trash"));
103
108
    moveToTrash->setShortcut(QKeySequence::Delete);
104
 
    connect(moveToTrash, SIGNAL(triggered(Qt::MouseButtons, Qt::KeyboardModifiers)),
105
 
            this, SLOT(slotTrashActivated(Qt::MouseButtons, Qt::KeyboardModifiers)));
 
109
    connect(moveToTrash, SIGNAL(triggered(Qt::MouseButtons,Qt::KeyboardModifiers)),
 
110
            this, SLOT(slotTrashActivated(Qt::MouseButtons,Qt::KeyboardModifiers)));
106
111
 
107
112
    KAction* deleteAction = m_actionCollection->addAction("delete");
108
113
    deleteAction->setIcon(KIcon("edit-delete"));
130
135
 
131
136
    // View menu
132
137
    KToggleAction* iconsAction = iconsModeAction();
 
138
    KToggleAction* compactAction = compactModeAction();
133
139
    KToggleAction* detailsAction = detailsModeAction();
134
 
    KToggleAction* columnsAction = columnsModeAction();
135
140
 
136
141
    KSelectAction* viewModeActions = m_actionCollection->add<KSelectAction>("view_mode");
137
142
    viewModeActions->setText(i18nc("@action:intoolbar", "View Mode"));
138
143
    viewModeActions->addAction(iconsAction);
 
144
    viewModeActions->addAction(compactAction);
139
145
    viewModeActions->addAction(detailsAction);
140
 
    viewModeActions->addAction(columnsAction);
141
146
    viewModeActions->setToolBarMode(KSelectAction::MenuMode);
142
147
    connect(viewModeActions, SIGNAL(triggered(QAction*)), this, SLOT(slotViewModeActionTriggered(QAction*)));
143
148
 
190
195
    }
191
196
 
192
197
    KToggleAction* showInGroups = m_actionCollection->add<KToggleAction>("show_in_groups");
 
198
    showInGroups->setIcon(KIcon("view-group"));
193
199
    showInGroups->setText(i18nc("@action:inmenu View", "Show in Groups"));
194
 
    connect(showInGroups, SIGNAL(triggered(bool)), this, SLOT(toggleSortCategorization(bool)));
 
200
    connect(showInGroups, SIGNAL(triggered(bool)), this, SLOT(toggleGroupedSorting(bool)));
195
201
 
196
202
    KToggleAction* showHiddenFiles = m_actionCollection->add<KToggleAction>("show_hidden_files");
197
203
    showHiddenFiles->setText(i18nc("@action:inmenu View", "Show Hidden Files"));
214
220
 
215
221
    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
216
222
 
217
 
    const KFileItemDelegate::InformationList infoKeys = infoAccessor.keys();
218
 
    foreach (KFileItemDelegate::Information info, infoKeys) {
 
223
    const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
 
224
    foreach (DolphinView::AdditionalInfo info, infoList) {
219
225
        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::AdditionalInfoType);
220
226
        KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
221
227
        action->setText(infoAccessor.translation(info));
239
245
    sortByActionGroup->addAction(sortByName);
240
246
 
241
247
    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
242
 
    const KFileItemDelegate::InformationList infoKeys = infoAccessor.keys();
243
 
    foreach (KFileItemDelegate::Information info, infoKeys) {
 
248
    const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
 
249
    foreach (DolphinView::AdditionalInfo info, infoList) {
244
250
        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
245
251
        KToggleAction* action = m_actionCollection->add<KToggleAction>(name);
246
252
        action->setText(infoAccessor.translation(info));
289
295
void DolphinViewActionHandler::togglePreview(bool show)
290
296
{
291
297
    emit actionBeingHandled();
292
 
    m_currentView->setShowPreview(show);
 
298
    m_currentView->setPreviewsShown(show);
293
299
}
294
300
 
295
 
void DolphinViewActionHandler::slotShowPreviewChanged()
 
301
void DolphinViewActionHandler::slotPreviewsShownChanged(bool shown)
296
302
{
 
303
    Q_UNUSED(shown);
297
304
    // It is not enough to update the 'Show Preview' action, also
298
305
    // the 'Zoom In' and 'Zoom Out' actions must be adapted.
299
306
    updateViewActions();
306
313
        return "icons";
307
314
    case DolphinView::DetailsView:
308
315
        return "details";
309
 
    case DolphinView::ColumnView:
310
 
        return "columns";
 
316
    case DolphinView::CompactView:
 
317
        return "compact";
 
318
    default:
 
319
        Q_ASSERT(false);
 
320
        break;
311
321
    }
312
322
    return QString(); // can't happen
313
323
}
328
338
    }
329
339
 
330
340
    QAction* showPreviewAction = m_actionCollection->action("show_preview");
331
 
    showPreviewAction->setChecked(m_currentView->showPreview());
 
341
    showPreviewAction->setChecked(m_currentView->previewsShown());
332
342
 
333
343
    slotSortOrderChanged(m_currentView->sortOrder());
334
344
    slotSortFoldersFirstChanged(m_currentView->sortFoldersFirst());
335
 
    slotAdditionalInfoChanged();
336
 
    slotCategorizedSortingChanged();
 
345
    slotAdditionalInfoListChanged(m_currentView->additionalInfoList(), QList<DolphinView::AdditionalInfo>());
 
346
    slotGroupedSortingChanged(m_currentView->groupedSorting());
337
347
    slotSortingChanged(m_currentView->sorting());
338
 
    slotZoomLevelChanged(m_currentView->zoomLevel());
 
348
    slotZoomLevelChanged(m_currentView->zoomLevel(), -1);
339
349
 
340
350
    QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
341
 
    showHiddenFilesAction->setChecked(m_currentView->showHiddenFiles());
 
351
    showHiddenFilesAction->setChecked(m_currentView->hiddenFilesShown());
342
352
}
343
353
 
344
354
void DolphinViewActionHandler::zoomIn()
385
395
{
386
396
    emit actionBeingHandled();
387
397
 
388
 
    const KFileItemDelegate::Information info =
389
 
        static_cast<KFileItemDelegate::Information>(action->data().toInt());
 
398
    const DolphinView::AdditionalInfo info =
 
399
        static_cast<DolphinView::AdditionalInfo>(action->data().toInt());
390
400
 
391
 
    KFileItemDelegate::InformationList list = m_currentView->additionalInfo();
 
401
    QList<DolphinView::AdditionalInfo> list = m_currentView->additionalInfoList();
392
402
 
393
403
    const bool show = action->isChecked();
394
404
 
396
406
    const bool containsInfo = (index >= 0);
397
407
    if (show && !containsInfo) {
398
408
        list.append(info);
399
 
        m_currentView->setAdditionalInfo(list);
 
409
        m_currentView->setAdditionalInfoList(list);
400
410
    } else if (!show && containsInfo) {
401
411
        list.removeAt(index);
402
 
        m_currentView->setAdditionalInfo(list);
 
412
        m_currentView->setAdditionalInfoList(list);
403
413
        Q_ASSERT(list.indexOf(info) < 0);
404
414
    }
405
415
}
406
416
 
407
 
void DolphinViewActionHandler::slotAdditionalInfoChanged()
408
 
{
409
 
    m_currentView->updateAdditionalInfoActions(m_actionCollection);
410
 
}
411
 
 
412
 
void DolphinViewActionHandler::toggleSortCategorization(bool categorizedSorting)
413
 
{
414
 
    m_currentView->setCategorizedSorting(categorizedSorting);
415
 
}
416
 
 
417
 
void DolphinViewActionHandler::slotCategorizedSortingChanged()
 
417
void DolphinViewActionHandler::slotAdditionalInfoListChanged(const QList<DolphinView::AdditionalInfo>& current,
 
418
                                                             const QList<DolphinView::AdditionalInfo>& previous)
 
419
{
 
420
    Q_UNUSED(previous);
 
421
 
 
422
    const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
 
423
 
 
424
    const QList<DolphinView::AdditionalInfo> checkedInfo = current;
 
425
    const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
 
426
 
 
427
    foreach (DolphinView::AdditionalInfo info, infoList) {
 
428
        const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::AdditionalInfoType);
 
429
        QAction* action = m_actionCollection->action(name);
 
430
        Q_ASSERT(action);
 
431
        action->setChecked(checkedInfo.contains(info));
 
432
    }
 
433
}
 
434
 
 
435
void DolphinViewActionHandler::toggleGroupedSorting(bool grouped)
 
436
{
 
437
    m_currentView->setGroupedSorting(grouped);
 
438
}
 
439
 
 
440
void DolphinViewActionHandler::slotGroupedSortingChanged(bool groupedSorting)
418
441
{
419
442
    QAction* showInGroupsAction = m_actionCollection->action("show_in_groups");
420
 
    showInGroupsAction->setChecked(m_currentView->categorizedSorting());
421
 
    showInGroupsAction->setEnabled(m_currentView->supportsCategorizedSorting());
 
443
    showInGroupsAction->setChecked(groupedSorting);
422
444
}
423
445
 
424
446
void DolphinViewActionHandler::toggleShowHiddenFiles(bool show)
425
447
{
426
448
    emit actionBeingHandled();
427
 
    m_currentView->setShowHiddenFiles(show);
 
449
    m_currentView->setHiddenFilesShown(show);
428
450
}
429
451
 
430
 
void DolphinViewActionHandler::slotShowHiddenFilesChanged()
 
452
void DolphinViewActionHandler::slotHiddenFilesShownChanged(bool shown)
431
453
{
432
454
    QAction* showHiddenFilesAction = m_actionCollection->action("show_hidden_files");
433
 
    showHiddenFilesAction->setChecked(m_currentView->showHiddenFiles());
 
455
    showHiddenFilesAction->setChecked(shown);
434
456
}
435
457
 
436
 
 
437
458
KToggleAction* DolphinViewActionHandler::iconsModeAction()
438
459
{
439
460
    KToggleAction* iconsView = m_actionCollection->add<KToggleAction>("icons");
445
466
    return iconsView;
446
467
}
447
468
 
 
469
KToggleAction* DolphinViewActionHandler::compactModeAction()
 
470
{
 
471
    KToggleAction* iconsView = m_actionCollection->add<KToggleAction>("compact");
 
472
    iconsView->setText(i18nc("@action:inmenu View Mode", "Compact"));
 
473
    iconsView->setToolTip(i18nc("@info", "Compact view mode"));
 
474
    iconsView->setShortcut(Qt::CTRL | Qt::Key_2);
 
475
    iconsView->setIcon(KIcon("view-list-details")); // TODO: discuss with Oxygen-team the wrong (?) name
 
476
    iconsView->setData(QVariant::fromValue(DolphinView::CompactView));
 
477
    return iconsView;
 
478
}
 
479
 
448
480
KToggleAction* DolphinViewActionHandler::detailsModeAction()
449
481
{
450
482
    KToggleAction* detailsView = m_actionCollection->add<KToggleAction>("details");
451
483
    detailsView->setText(i18nc("@action:inmenu View Mode", "Details"));
452
484
    detailsView->setToolTip(i18nc("@info", "Details view mode"));
453
 
    detailsView->setShortcut(Qt::CTRL | Qt::Key_2);
454
 
    detailsView->setIcon(KIcon("view-list-details"));
 
485
    detailsView->setShortcut(Qt::CTRL | Qt::Key_3);
 
486
    detailsView->setIcon(KIcon("view-list-tree"));
455
487
    detailsView->setData(QVariant::fromValue(DolphinView::DetailsView));
456
488
    return detailsView;
457
489
}
458
490
 
459
 
KToggleAction* DolphinViewActionHandler::columnsModeAction()
460
 
{
461
 
    KToggleAction* columnView = m_actionCollection->add<KToggleAction>("columns");
462
 
    columnView->setText(i18nc("@action:inmenu View Mode", "Columns"));
463
 
    columnView->setToolTip(i18nc("@info", "Columns view mode"));
464
 
    columnView->setShortcut(Qt::CTRL | Qt::Key_3);
465
 
    columnView->setIcon(KIcon("view-file-columns"));
466
 
    columnView->setData(QVariant::fromValue(DolphinView::ColumnView));
467
 
    return columnView;
468
 
}
469
 
 
470
491
void DolphinViewActionHandler::slotSortingChanged(DolphinView::Sorting sorting)
471
492
{
472
493
    QAction* action = 0;
474
495
        action = m_actionCollection->action("sort_by_name");
475
496
    } else {
476
497
        const AdditionalInfoAccessor& infoAccessor = AdditionalInfoAccessor::instance();
477
 
        const KFileItemDelegate::InformationList infoKeys = infoAccessor.keys();
478
 
        foreach (const KFileItemDelegate::Information info, infoKeys) {
 
498
        const QList<DolphinView::AdditionalInfo> infoList = infoAccessor.keys();
 
499
        foreach (DolphinView::AdditionalInfo info, infoList) {
479
500
            if (sorting == infoAccessor.sorting(info)) {
480
501
                const QString name = infoAccessor.actionCollectionName(info, AdditionalInfoAccessor::SortByType);
481
502
                action = m_actionCollection->action(name);
492
513
    }
493
514
}
494
515
 
495
 
void DolphinViewActionHandler::slotZoomLevelChanged(int level)
 
516
void DolphinViewActionHandler::slotZoomLevelChanged(int current, int previous)
496
517
{
 
518
    Q_UNUSED(previous);
 
519
 
497
520
    QAction* zoomInAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomIn));
498
521
    if (zoomInAction) {
499
 
        zoomInAction->setEnabled(level < ZoomLevelInfo::maximumLevel());
 
522
        zoomInAction->setEnabled(current < ZoomLevelInfo::maximumLevel());
500
523
    }
501
524
 
502
525
    QAction* zoomOutAction = m_actionCollection->action(KStandardAction::name(KStandardAction::ZoomOut));
503
526
    if (zoomOutAction) {
504
 
        zoomOutAction->setEnabled(level > ZoomLevelInfo::minimumLevel());
 
527
        zoomOutAction->setEnabled(current > ZoomLevelInfo::minimumLevel());
505
528
    }
506
529
}
507
530