VirtualBox

source: vbox/trunk/src/VBox/Frontends/VirtualBox/src/guestctrl/UIFileManagerTable.cpp

Last change on this file was 104393, checked in by vboxsync, 4 weeks ago

FE/Qt. bugref:10622. Using new UITranslationEventListener in the UIActionPool class.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 45.1 KB
Line 
1/* $Id: UIFileManagerTable.cpp 104393 2024-04-22 13:02:56Z vboxsync $ */
2/** @file
3 * VBox Qt GUI - UIFileManagerTable class implementation.
4 */
5
6/*
7 * Copyright (C) 2016-2023 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28/* Qt includes: */
29#include <QAction>
30#include <QApplication>
31#include <QCheckBox>
32#include <QHBoxLayout>
33#include <QHeaderView>
34#include <QItemDelegate>
35#include <QGridLayout>
36#include <QTextEdit>
37
38/* GUI includes: */
39#include "QIDialog.h"
40#include "QIDialogButtonBox.h"
41#include "QILabel.h"
42#include "QILineEdit.h"
43#include "QIToolBar.h"
44#include "UIActionPool.h"
45#include "UIFileSystemModel.h"
46#include "UIErrorString.h"
47#include "UIFileManager.h"
48#include "UIFileManagerTable.h"
49#include "UIFileTableNavigationWidget.h"
50#include "UIIconPool.h"
51#include "UIPathOperations.h"
52#include "UITranslator.h"
53#include "UITranslationEventListener.h"
54
55/* COM includes: */
56#include "CFsObjInfo.h"
57#include "CGuestFsObjInfo.h"
58#include "CGuestDirectory.h"
59#include "CProgress.h"
60
61
62/*********************************************************************************************************************************
63* UIGuestControlFileView definition. *
64*********************************************************************************************************************************/
65
66/** Using QITableView causes the following problem when I click on the table items
67 Qt WARNING: Cannot creat accessible child interface for object: UIGuestControlFileView.....
68 so for now subclass QTableView */
69class UIGuestControlFileView : public QTableView
70{
71
72 Q_OBJECT;
73
74signals:
75
76 void sigSelectionChanged(const QItemSelection & selected, const QItemSelection & deselected);
77 /* Emitted upon mouse double click while Alt key is pressed. */
78 void sigAltDoubleClick();
79
80public:
81
82 UIGuestControlFileView(QWidget * parent = 0);
83 bool hasSelection() const;
84 bool isInEditState() const;
85
86protected:
87
88 virtual void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) RT_OVERRIDE RT_FINAL;
89 virtual void mouseDoubleClickEvent(QMouseEvent *event) RT_OVERRIDE RT_FINAL;
90 virtual void mousePressEvent(QMouseEvent *event) RT_OVERRIDE RT_FINAL;
91
92private:
93
94 void configure();
95 QWidget *m_pParent;
96};
97
98
99/*********************************************************************************************************************************
100* UIFileDelegate definition. *
101*********************************************************************************************************************************/
102/** A QItemDelegate child class to disable dashed lines drawn around selected cells in QTableViews */
103class UIFileDelegate : public QItemDelegate
104{
105
106 Q_OBJECT;
107
108public:
109
110 UIFileDelegate(QObject *pParent)
111 : QItemDelegate(pParent){}
112
113protected:
114
115 virtual void drawFocus ( QPainter * /*painter*/, const QStyleOptionViewItem & /*option*/, const QRect & /*rect*/ ) const RT_OVERRIDE RT_FINAL{}
116};
117
118
119/*********************************************************************************************************************************
120* UStringInputDialog definition. *
121*********************************************************************************************************************************/
122
123/** A QIDialog child including a line edit whose text exposed when the dialog is accepted */
124class UIStringInputDialog : public QIDialog
125{
126
127 Q_OBJECT;
128
129public:
130
131 UIStringInputDialog(QWidget *pParent = 0, Qt::WindowFlags enmFlags = Qt::WindowFlags());
132 QString getString() const;
133
134private:
135
136 QILineEdit *m_pLineEdit;
137};
138
139
140/*********************************************************************************************************************************
141* UIFileDeleteConfirmationDialog definition. *
142*********************************************************************************************************************************/
143
144/** A QIDialog child including a line edit whose text exposed when the dialog is accepted */
145class UIFileDeleteConfirmationDialog : public QIDialog
146{
147
148 Q_OBJECT;
149
150public:
151
152 UIFileDeleteConfirmationDialog(QWidget *pParent = 0, Qt::WindowFlags enmFlags = Qt::WindowFlags());
153 /** Returns whether m_pAskNextTimeCheckBox is checked or not. */
154 bool askDeleteConfirmationNextTime() const;
155
156private:
157
158 QCheckBox *m_pAskNextTimeCheckBox;
159 QILabel *m_pQuestionLabel;
160};
161
162
163/*********************************************************************************************************************************
164* UIHostDirectoryDiskUsageComputer implementation. *
165*********************************************************************************************************************************/
166
167UIDirectoryDiskUsageComputer::UIDirectoryDiskUsageComputer(QObject *parent, QStringList pathList)
168 :QThread(parent)
169 , m_pathList(pathList)
170 , m_fOkToContinue(true)
171{
172}
173
174void UIDirectoryDiskUsageComputer::run()
175{
176 for (int i = 0; i < m_pathList.size(); ++i)
177 directoryStatisticsRecursive(m_pathList[i], m_resultStatistics);
178}
179
180void UIDirectoryDiskUsageComputer::stopRecursion()
181{
182 m_mutex.lock();
183 m_fOkToContinue = false;
184 m_mutex.unlock();
185}
186
187bool UIDirectoryDiskUsageComputer::isOkToContinue() const
188{
189 return m_fOkToContinue;
190}
191
192
193/*********************************************************************************************************************************
194* UIGuestControlFileView implementation. *
195*********************************************************************************************************************************/
196
197UIGuestControlFileView::UIGuestControlFileView(QWidget *parent)
198 :QTableView(parent)
199 , m_pParent(parent)
200{
201 configure();
202}
203
204void UIGuestControlFileView::configure()
205{
206 setContextMenuPolicy(Qt::CustomContextMenu);
207 setShowGrid(false);
208 setSelectionBehavior(QAbstractItemView::SelectRows);
209 verticalHeader()->setVisible(false);
210 setEditTriggers(QAbstractItemView::NoEditTriggers);
211 /* Minimize the row height: */
212 verticalHeader()->setDefaultSectionSize(verticalHeader()->minimumSectionSize());
213 setAlternatingRowColors(true);
214 installEventFilter(m_pParent);
215}
216
217bool UIGuestControlFileView::hasSelection() const
218{
219 QItemSelectionModel *pSelectionModel = selectionModel();
220 if (!pSelectionModel)
221 return false;
222 return pSelectionModel->hasSelection();
223}
224
225bool UIGuestControlFileView::isInEditState() const
226{
227 return state() == QAbstractItemView::EditingState;
228}
229
230void UIGuestControlFileView::selectionChanged(const QItemSelection & selected, const QItemSelection & deselected)
231{
232 emit sigSelectionChanged(selected, deselected);
233 QTableView::selectionChanged(selected, deselected);
234}
235
236void UIGuestControlFileView::mousePressEvent(QMouseEvent *event)
237{
238 if (qApp->queryKeyboardModifiers() & Qt::AltModifier)
239 return;
240 QTableView::mousePressEvent(event);
241}
242
243void UIGuestControlFileView::mouseDoubleClickEvent(QMouseEvent *event)
244{
245 if (qApp->queryKeyboardModifiers() & Qt::AltModifier)
246 {
247 printf("dou\n");
248 emit sigAltDoubleClick();
249 return;
250 }
251 QTableView::mouseDoubleClickEvent(event);
252}
253
254
255/*********************************************************************************************************************************
256* UIFileStringInputDialog implementation. *
257*********************************************************************************************************************************/
258
259UIStringInputDialog::UIStringInputDialog(QWidget *pParent /* = 0 */, Qt::WindowFlags enmFlags /* = Qt::WindowFlags() */)
260 :QIDialog(pParent, enmFlags)
261{
262 QVBoxLayout *layout = new QVBoxLayout(this);
263 m_pLineEdit = new QILineEdit(this);
264 layout->addWidget(m_pLineEdit);
265
266 QIDialogButtonBox *pButtonBox =
267 new QIDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this);
268 layout->addWidget(pButtonBox);
269 connect(pButtonBox, &QIDialogButtonBox::accepted, this, &UIStringInputDialog::accept);
270 connect(pButtonBox, &QIDialogButtonBox::rejected, this, &UIStringInputDialog::reject);
271}
272
273QString UIStringInputDialog::getString() const
274{
275 if (!m_pLineEdit)
276 return QString();
277 return m_pLineEdit->text();
278}
279
280
281/*********************************************************************************************************************************
282* UIPropertiesDialog implementation. *
283*********************************************************************************************************************************/
284
285UIPropertiesDialog::UIPropertiesDialog(QWidget *pParent, Qt::WindowFlags enmFlags)
286 :QIDialog(pParent, enmFlags)
287 , m_pMainLayout(new QVBoxLayout)
288 , m_pInfoEdit(new QTextEdit)
289{
290 setLayout(m_pMainLayout);
291
292 if (m_pMainLayout)
293 m_pMainLayout->addWidget(m_pInfoEdit);
294 if (m_pInfoEdit)
295 {
296 m_pInfoEdit->setReadOnly(true);
297 m_pInfoEdit->setFrameStyle(QFrame::NoFrame);
298 }
299 QIDialogButtonBox *pButtonBox =
300 new QIDialogButtonBox(QDialogButtonBox::Ok, Qt::Horizontal, this);
301 m_pMainLayout->addWidget(pButtonBox);
302 connect(pButtonBox, &QIDialogButtonBox::accepted, this, &UIStringInputDialog::accept);
303}
304
305void UIPropertiesDialog::setPropertyText(const QString &strProperty)
306{
307 if (!m_pInfoEdit)
308 return;
309 m_strProperty = strProperty;
310 m_pInfoEdit->setHtml(strProperty);
311}
312
313void UIPropertiesDialog::addDirectoryStatistics(UIDirectoryStatistics directoryStatistics)
314{
315 if (!m_pInfoEdit)
316 return;
317 // QString propertyString = m_pInfoEdit->toHtml();
318 // propertyString += "<b>Total Size:</b> " + QString::number(directoryStatistics.m_totalSize) + QString(" bytes");
319 // if (directoryStatistics.m_totalSize >= UIFileManagerTable::m_iKiloByte)
320 // propertyString += " (" + UIFileManagerTable::humanReadableSize(directoryStatistics.m_totalSize) + ")";
321 // propertyString += "<br/>";
322 // propertyString += "<b>File Count:</b> " + QString::number(directoryStatistics.m_uFileCount);
323
324 // m_pInfoEdit->setHtml(propertyString);
325
326 QString detailsString(m_strProperty);
327 detailsString += "<br/>";
328 detailsString += "<b>" + UIFileManager::tr("Total Size") + "</b> " +
329 QString::number(directoryStatistics.m_totalSize) + UIFileManager::tr(" bytes");
330 if (directoryStatistics.m_totalSize >= UIFileManagerTable::m_iKiloByte)
331 detailsString += " (" + UIFileManagerTable::humanReadableSize(directoryStatistics.m_totalSize) + ")";
332 detailsString += "<br/>";
333
334 detailsString += "<b>" + UIFileManager::tr("File Count") + ":</b> " +
335 QString::number(directoryStatistics.m_uFileCount);
336
337 m_pInfoEdit->setHtml(detailsString);
338}
339
340
341/*********************************************************************************************************************************
342* UIDirectoryStatistics implementation. *
343*********************************************************************************************************************************/
344
345UIDirectoryStatistics::UIDirectoryStatistics()
346 : m_totalSize(0)
347 , m_uFileCount(0)
348 , m_uDirectoryCount(0)
349 , m_uSymlinkCount(0)
350{
351}
352
353
354/*********************************************************************************************************************************
355* UIFileDeleteConfirmationDialog implementation. *
356*********************************************************************************************************************************/
357
358UIFileDeleteConfirmationDialog::UIFileDeleteConfirmationDialog(QWidget *pParent /* = 0 */, Qt::WindowFlags enmFlags /* = Qt::WindowFlags() */)
359 :QIDialog(pParent, enmFlags)
360 , m_pAskNextTimeCheckBox(0)
361 , m_pQuestionLabel(0)
362{
363 QVBoxLayout *pLayout = new QVBoxLayout(this);
364
365 m_pQuestionLabel = new QILabel;
366 if (m_pQuestionLabel)
367 {
368 pLayout->addWidget(m_pQuestionLabel);
369 m_pQuestionLabel->setText(UIFileManager::tr("Delete the selected file(s) and/or folder(s)"));
370 }
371
372 QIDialogButtonBox *pButtonBox =
373 new QIDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this);
374 if (pButtonBox)
375 {
376 pLayout->addWidget(pButtonBox, 0, Qt::AlignCenter);
377 connect(pButtonBox, &QIDialogButtonBox::accepted, this, &UIStringInputDialog::accept);
378 connect(pButtonBox, &QIDialogButtonBox::rejected, this, &UIStringInputDialog::reject);
379 }
380
381 m_pAskNextTimeCheckBox = new QCheckBox;
382
383 if (m_pAskNextTimeCheckBox)
384 {
385 UIFileManagerOptions *pFileManagerOptions = UIFileManagerOptions::instance();
386 if (pFileManagerOptions)
387 m_pAskNextTimeCheckBox->setChecked(pFileManagerOptions->fAskDeleteConfirmation);
388
389 pLayout->addWidget(m_pAskNextTimeCheckBox);
390 m_pAskNextTimeCheckBox->setText(UIFileManager::tr("Ask for this confirmation next time"));
391 m_pAskNextTimeCheckBox->setToolTip(UIFileManager::tr("Delete confirmation can be "
392 "disabled/enabled also from the Options panel."));
393 }
394}
395
396bool UIFileDeleteConfirmationDialog::askDeleteConfirmationNextTime() const
397{
398 if (!m_pAskNextTimeCheckBox)
399 return true;
400 return m_pAskNextTimeCheckBox->isChecked();
401}
402
403
404/*********************************************************************************************************************************
405* UIFileManagerTable implementation. *
406*********************************************************************************************************************************/
407const unsigned UIFileManagerTable::m_iKiloByte = 1024; /**< Our kilo bytes are a power of two! (bird) */
408
409UIFileManagerTable::UIFileManagerTable(UIActionPool *pActionPool, QWidget *pParent /* = 0 */)
410 : QWidget(pParent)
411 , m_eFileOperationType(FileOperationType_None)
412 , m_pLocationLabel(0)
413 , m_pPropertiesDialog(0)
414 , m_pActionPool(pActionPool)
415 , m_pToolBar(0)
416 , m_pMainLayout(0)
417 , m_pNavigationWidget(0)
418 , m_pModel(0)
419 , m_pView(0)
420 , m_pProxyModel(0)
421 , m_pathSeparator('/')
422 , m_pToolBarLayout(0)
423{
424 prepareObjects();
425}
426
427UIFileManagerTable::~UIFileManagerTable()
428{
429}
430
431void UIFileManagerTable::reset()
432{
433 if (m_pModel)
434 m_pModel->reset();
435
436 if (m_pNavigationWidget)
437 m_pNavigationWidget->reset();
438}
439
440void UIFileManagerTable::prepareObjects()
441{
442 m_pMainLayout = new QGridLayout();
443 if (!m_pMainLayout)
444 return;
445 m_pMainLayout->setSpacing(0);
446 m_pMainLayout->setContentsMargins(0, 0, 0, 0);
447 setLayout(m_pMainLayout);
448
449 m_pToolBarLayout = new QHBoxLayout;
450 if (m_pToolBarLayout)
451 {
452 m_pToolBarLayout->setSpacing(0);
453 m_pToolBarLayout->setContentsMargins(0, 0, 0, 0);
454
455 m_pToolBar = new QIToolBar;
456 if (m_pToolBar)
457 {
458 m_pToolBarLayout->addWidget(m_pToolBar);
459 m_sessionWidgets << m_pToolBar;
460 }
461
462 m_pMainLayout->addLayout(m_pToolBarLayout, 0, 0, 1, 7);
463 }
464
465 m_pLocationLabel = new QILabel;
466 if (m_pLocationLabel)
467 {
468 m_pMainLayout->addWidget(m_pLocationLabel, 1, 0, 1, 1);
469 m_sessionWidgets << m_pLocationLabel;
470 }
471
472 m_pNavigationWidget = new UIFileTableNavigationWidget;
473 if (m_pNavigationWidget)
474 {
475 m_pNavigationWidget->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Maximum);
476 connect(m_pNavigationWidget, &UIFileTableNavigationWidget::sigPathChanged,
477 this, &UIFileManagerTable::sltHandleNavigationWidgetPathChange);
478 connect(m_pNavigationWidget, &UIFileTableNavigationWidget::sigHistoryListChanged,
479 this, &UIFileManagerTable::sltHandleNavigationWidgetHistoryListChanged);
480 m_pMainLayout->addWidget(m_pNavigationWidget, 1, 1, 1, 6);
481 m_sessionWidgets << m_pNavigationWidget;
482 }
483
484 m_pModel = new UIFileSystemModel(this);
485 if (!m_pModel)
486 return;
487
488 connect(m_pModel, &UIFileSystemModel::sigItemRenamed,
489 this, &UIFileManagerTable::sltHandleItemRenameAttempt);
490
491 m_pProxyModel = new UIFileSystemProxyModel(this);
492 if (!m_pProxyModel)
493 return;
494 m_pProxyModel->setSourceModel(m_pModel);
495
496 m_pView = new UIGuestControlFileView(this);
497 if (m_pView)
498 {
499 m_pView->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::MinimumExpanding);
500 m_pMainLayout->addWidget(m_pView, 2, 0, 5, 7);
501
502 QHeaderView *pHorizontalHeader = m_pView->horizontalHeader();
503 if (pHorizontalHeader)
504 {
505 pHorizontalHeader->setHighlightSections(false);
506 pHorizontalHeader->setSectionResizeMode(QHeaderView::ResizeToContents);
507 pHorizontalHeader->setStretchLastSection(true);
508 }
509
510 m_pView->setModel(m_pProxyModel);
511 m_pView->setItemDelegate(new UIFileDelegate(this));
512 m_pView->setSortingEnabled(true);
513 m_pView->sortByColumn(0, Qt::AscendingOrder);
514
515 connect(m_pView, &UIGuestControlFileView::doubleClicked,
516 this, &UIFileManagerTable::sltItemDoubleClicked);
517 connect(m_pView, &UIGuestControlFileView::sigAltDoubleClick,
518 this, &UIFileManagerTable::sltAltDoubleClick);
519 connect(m_pView, &UIGuestControlFileView::clicked,
520 this, &UIFileManagerTable::sltItemClicked);
521 connect(m_pView, &UIGuestControlFileView::sigSelectionChanged,
522 this, &UIFileManagerTable::sltSelectionChanged);
523 connect(m_pView, &UIGuestControlFileView::customContextMenuRequested,
524 this, &UIFileManagerTable::sltCreateFileViewContextMenu);
525 m_pView->hideColumn(UIFileSystemModelData_LocalPath);
526 m_pView->hideColumn(UIFileSystemModelData_ISOFilePath);
527 m_pView->hideColumn(UIFileSystemModelData_RemovedFromVISO);
528 m_pView->hideColumn(UIFileSystemModelData_DescendantRemovedFromVISO);
529
530 m_sessionWidgets << m_pView;
531 }
532
533 m_pSearchLineEdit = new QILineEdit;
534 if (m_pSearchLineEdit)
535 {
536 m_pMainLayout->addWidget(m_pSearchLineEdit, 8, 0, 1, 7);
537 m_pSearchLineEdit->hide();
538 m_pSearchLineEdit->setClearButtonEnabled(true);
539 m_searchLineUnmarkColor = m_pSearchLineEdit->palette().color(QPalette::Base);
540 m_searchLineMarkColor = QColor(m_searchLineUnmarkColor.green(),
541 0.5 * m_searchLineUnmarkColor.green(),
542 0.5 * m_searchLineUnmarkColor.blue());
543 connect(m_pSearchLineEdit, &QLineEdit::textChanged,
544 this, &UIFileManagerTable::sltSearchTextChanged);
545 }
546
547 connect(&translationEventListener(), &UITranslationEventListener::sigRetranslateUI,
548 this, &UIFileManagerTable::sltRetranslateUI);
549
550 optionsUpdated();
551}
552
553void UIFileManagerTable::updateCurrentLocationEdit(const QString& strLocation)
554{
555 if (m_pNavigationWidget)
556 m_pNavigationWidget->setPath(strLocation);
557}
558
559void UIFileManagerTable::changeLocation(const QModelIndex &index)
560{
561 if (!index.isValid() || !m_pView)
562 return;
563 m_pView->setRootIndex(m_pProxyModel->mapFromSource(index));
564
565 if (m_pView->selectionModel())
566 m_pView->selectionModel()->reset();
567
568 UIFileSystemItem *item = static_cast<UIFileSystemItem*>(index.internalPointer());
569 if (item)
570 {
571 updateCurrentLocationEdit(item->path());
572 }
573 setSelectionDependentActionsEnabled(false);
574
575 m_pView->scrollToTop();
576}
577
578void UIFileManagerTable::initializeFileTree()
579{
580 if (m_pModel)
581 m_pModel->reset();
582 if (!rootItem())
583 return;
584
585 QString startPath("/");
586 /* On Unix-like systems startItem represents the root directory. On Windows it is like "my computer" under which
587 * drives are listed: */
588 UIFileSystemItem* startItem = new UIFileSystemItem(startPath, rootItem(), KFsObjType_Directory);
589
590 startItem->setIsOpened(false);
591 populateStartDirectory(startItem);
592
593 m_pModel->signalUpdate();
594 m_pView->setRootIndex(m_pProxyModel->mapFromSource(m_pModel->rootIndex()));
595 updateCurrentLocationEdit(currentDirectoryPath());
596}
597
598void UIFileManagerTable::populateStartDirectory(UIFileSystemItem *startItem)
599{
600 determineDriveLetters();
601 if (m_driveLetterList.isEmpty())
602 {
603 /* Read the root directory and get the list: */
604 readDirectory(startItem->path(), startItem, true);
605 }
606 else
607 {
608 for (int i = 0; i < m_driveLetterList.size(); ++i)
609 {
610 UIFileSystemItem* driveItem = new UIFileSystemItem(UIPathOperations::removeTrailingDelimiters(m_driveLetterList[i]),
611 startItem, KFsObjType_Directory);
612 driveItem->setIsOpened(false);
613 driveItem->setIsDriveItem(true);
614 startItem->setIsOpened(true);
615 }
616 }
617}
618
619void UIFileManagerTable::checkDotDot(QMap<QString,UIFileSystemItem*> &map,
620 UIFileSystemItem *parent, bool isStartDir)
621{
622 if (!parent)
623 return;
624 /* Make sure we have an item representing up directory, and make sure it is not there for the start dir: */
625 if (!map.contains(UIFileSystemModel::strUpDirectoryString) && !isStartDir)
626 {
627 UIFileSystemItem *item = new UIFileSystemItem(UIFileSystemModel::strUpDirectoryString,
628 parent, KFsObjType_Directory);
629 item->setIsOpened(false);
630 map.insert(UIFileSystemModel::strUpDirectoryString, item);
631 }
632 else if (map.contains(UIFileSystemModel::strUpDirectoryString) && isStartDir)
633 {
634 map.remove(UIFileSystemModel::strUpDirectoryString);
635 }
636}
637
638void UIFileManagerTable::sltItemDoubleClicked(const QModelIndex &index)
639{
640 if (!index.isValid() || !m_pModel || !m_pView)
641 return;
642 QModelIndex nIndex = m_pProxyModel ? m_pProxyModel->mapToSource(index) : index;
643 goIntoDirectory(nIndex);
644}
645
646void UIFileManagerTable::sltAltDoubleClick()
647{
648 emit sigAltDoubleClick();
649}
650
651void UIFileManagerTable::sltItemClicked(const QModelIndex &index)
652{
653 Q_UNUSED(index);
654 disableSelectionSearch();
655}
656
657void UIFileManagerTable::sltGoUp()
658{
659 if (!m_pView || !m_pModel)
660 return;
661 QModelIndex currentRoot = currentRootIndex();
662
663 if (!currentRoot.isValid())
664 return;
665 if (currentRoot != m_pModel->rootIndex())
666 {
667 QModelIndex parentIndex = currentRoot.parent();
668 if (parentIndex.isValid())
669 {
670 changeLocation(currentRoot.parent());
671 m_pView->selectRow(currentRoot.row());
672 }
673 }
674}
675
676void UIFileManagerTable::sltGoHome()
677{
678 goToHomeDirectory();
679}
680
681void UIFileManagerTable::sltGoForward()
682{
683 if (m_pNavigationWidget)
684 m_pNavigationWidget->goForwardInHistory();
685}
686
687void UIFileManagerTable::sltGoBackward()
688{
689 if (m_pNavigationWidget)
690 m_pNavigationWidget->goBackwardInHistory();
691}
692
693void UIFileManagerTable::sltRefresh()
694{
695 refresh();
696}
697
698void UIFileManagerTable::goIntoDirectory(const QModelIndex &itemIndex)
699{
700 if (!m_pModel)
701 return;
702
703 /* Make sure the colum is 0: */
704 QModelIndex index = m_pModel->index(itemIndex.row(), 0, itemIndex.parent());
705 if (!index.isValid())
706 return;
707
708 UIFileSystemItem *item = static_cast<UIFileSystemItem*>(index.internalPointer());
709 if (!item)
710 return;
711
712 /* check if we need to go up: */
713 if (item->isUpDirectory())
714 {
715 QModelIndex parentIndex = m_pModel->parent(m_pModel->parent(index));
716 if (parentIndex.isValid())
717 changeLocation(parentIndex);
718 return;
719 }
720
721 if (item->isDirectory() || item->isSymLinkToADirectory())
722 {
723 if (!item->isOpened())
724 {
725 if (readDirectory(item->path(),item))
726 changeLocation(index);
727 }
728 else
729 changeLocation(index);
730 }
731}
732
733void UIFileManagerTable::goIntoDirectory(const QStringList &pathTrail)
734{
735 UIFileSystemItem *parent = getStartDirectoryItem();
736
737 for(int i = 0; i < pathTrail.size(); ++i)
738 {
739 if (!parent)
740 return;
741 /* Make sure parent is already opened: */
742 if (!parent->isOpened())
743 if (!readDirectory(parent->path(), parent, parent == getStartDirectoryItem()))
744 return;
745 /* search the current path item among the parent's children: */
746 UIFileSystemItem *item = parent->child(pathTrail.at(i));
747
748 if (!item)
749 return;
750 parent = item;
751 }
752 if (!parent)
753 return;
754 if (!parent->isOpened())
755 {
756 if (!readDirectory(parent->path(), parent, parent == getStartDirectoryItem()))
757 return;
758 }
759 goIntoDirectory(parent);
760}
761
762void UIFileManagerTable::goIntoDirectory(UIFileSystemItem *item)
763{
764 if (!item || !m_pModel)
765 return;
766 goIntoDirectory(m_pModel->index(item));
767}
768
769UIFileSystemItem* UIFileManagerTable::indexData(const QModelIndex &index) const
770{
771 if (!index.isValid())
772 return 0;
773 return static_cast<UIFileSystemItem*>(index.internalPointer());
774}
775
776void UIFileManagerTable::refresh()
777{
778 if (!m_pView || !m_pModel)
779 return;
780 QModelIndex currentIndex = currentRootIndex();
781
782 UIFileSystemItem *treeItem = indexData(currentIndex);
783 if (!treeItem)
784 return;
785 bool isRootDir = (m_pModel->rootIndex() == currentIndex);
786 m_pModel->beginReset();
787 /* For now we clear the whole subtree (that isrecursively) which is an overkill: */
788 treeItem->clearChildren();
789 if (isRootDir)
790 populateStartDirectory(treeItem);
791 else
792 readDirectory(treeItem->path(), treeItem, isRootDir);
793 m_pModel->endReset();
794 m_pView->setRootIndex(m_pProxyModel->mapFromSource(currentIndex));
795 setSelectionDependentActionsEnabled(m_pView->hasSelection());
796}
797
798void UIFileManagerTable::relist()
799{
800 if (!m_pProxyModel)
801 return;
802 m_pProxyModel->invalidate();
803}
804
805void UIFileManagerTable::sltDelete()
806{
807 if (!checkIfDeleteOK())
808 return;
809
810 if (!m_pView || !m_pModel)
811 return;
812
813 if (!m_pView || !m_pModel)
814 return;
815 QItemSelectionModel *selectionModel = m_pView->selectionModel();
816 if (!selectionModel)
817 return;
818
819 QModelIndexList selectedItemIndices = selectionModel->selectedRows();
820 for(int i = 0; i < selectedItemIndices.size(); ++i)
821 {
822 QModelIndex index =
823 m_pProxyModel ? m_pProxyModel->mapToSource(selectedItemIndices.at(i)) : selectedItemIndices.at(i);
824 deleteByIndex(index);
825 }
826 /** @todo dont refresh here, just delete the rows and update the table view: */
827 refresh();
828}
829
830void UIFileManagerTable::sltRename()
831{
832 if (!m_pView || !m_pModel)
833 return;
834 QItemSelectionModel *selectionModel = m_pView->selectionModel();
835 if (!selectionModel)
836 return;
837
838 QModelIndexList selectedItemIndices = selectionModel->selectedRows();
839 if (selectedItemIndices.size() == 0)
840 return;
841 QModelIndex modelIndex =
842 m_pProxyModel ? m_pProxyModel->mapToSource(selectedItemIndices.at(0)) : selectedItemIndices.at(0);
843 UIFileSystemItem *item = indexData(modelIndex);
844 if (!item || item->isUpDirectory())
845 return;
846 m_pView->edit(selectedItemIndices.at(0));
847}
848
849void UIFileManagerTable::sltCreateNewDirectory()
850{
851 if (!m_pModel || !m_pView)
852 return;
853 QModelIndex currentIndex = currentRootIndex();
854 if (!currentIndex.isValid())
855 return;
856 UIFileSystemItem *parentFolderItem = static_cast<UIFileSystemItem*>(currentIndex.internalPointer());
857 if (!parentFolderItem)
858 return;
859 QString strBase(UIFileSystemModel::tr("NewDirectory"));
860 QString newDirectoryName(strBase);
861 QStringList nameList = currentDirectoryListing();
862 int iSuffix = 1;
863 while (nameList.contains(newDirectoryName))
864 newDirectoryName = QString("%1_%2").arg(strBase).arg(QString::number(iSuffix++));
865
866 if (!createDirectory(parentFolderItem->path(), newDirectoryName))
867 return;
868
869 /* Refesh the current directory so that we correctly populate the child list of parentFolderItem: */
870 /** @todo instead of refreshing here (an overkill) just add the
871 rows and update the tabel view: */
872 sltRefresh();
873
874 /* Now we try to edit the newly created item thereby enabling the user to rename the new item: */
875 QList<UIFileSystemItem*> content = parentFolderItem->children();
876 UIFileSystemItem* newItem = 0;
877 /* Search the new item: */
878 foreach (UIFileSystemItem* childItem, content)
879 {
880
881 if (childItem && newDirectoryName == childItem->fileObjectName())
882 newItem = childItem;
883 }
884
885 if (!newItem)
886 return;
887 QModelIndex newItemIndex = m_pProxyModel->mapFromSource(m_pModel->index(newItem));
888 if (!newItemIndex.isValid())
889 return;
890 m_pView->edit(newItemIndex);
891}
892
893void UIFileManagerTable::sltCopy()
894{
895 m_copyCutBuffer = selectedItemPathList();
896 m_eFileOperationType = FileOperationType_Copy;
897 setPasteActionEnabled(true);
898}
899
900void UIFileManagerTable::sltCut()
901{
902 m_copyCutBuffer = selectedItemPathList();
903 m_eFileOperationType = FileOperationType_Cut;
904 setPasteActionEnabled(true);
905}
906
907void UIFileManagerTable::sltPaste()
908{
909 m_copyCutBuffer.clear();
910
911 m_eFileOperationType = FileOperationType_None;
912 setPasteActionEnabled(false);
913}
914
915void UIFileManagerTable::sltShowProperties()
916{
917 showProperties();
918}
919
920void UIFileManagerTable::sltSelectionChanged(const QItemSelection & selected, const QItemSelection & deselected)
921{
922 Q_UNUSED(selected);
923 Q_UNUSED(deselected);
924 setSelectionDependentActionsEnabled(m_pView->hasSelection());
925}
926
927void UIFileManagerTable::sltSelectAll()
928{
929 if (!m_pModel || !m_pView)
930 return;
931 m_pView->selectAll();
932 deSelectUpDirectoryItem();
933}
934
935void UIFileManagerTable::sltInvertSelection()
936{
937 setSelectionForAll(QItemSelectionModel::Toggle | QItemSelectionModel::Rows);
938 deSelectUpDirectoryItem();
939}
940
941void UIFileManagerTable::sltSearchTextChanged(const QString &strText)
942{
943 performSelectionSearch(strText);
944}
945
946void UIFileManagerTable::sltHandleItemRenameAttempt(UIFileSystemItem *pItem, const QString &strOldPath,
947 const QString &strOldName, const QString &strNewName)
948{
949 Q_UNUSED(strNewName);
950 if (!pItem)
951 return;
952 /* Attempt to chage item name in the file system: */
953 if (!renameItem(pItem, strOldPath))
954 {
955 /* Restore the previous name. relist the view: */
956 pItem->setData(strOldName, static_cast<int>(UIFileSystemModelData_Name));
957 relist();
958 emit sigLogOutput(QString(pItem->path()).append(" could not be renamed"), QString(), FileManagerLogType_Error);
959 }
960}
961
962void UIFileManagerTable::sltCreateFileViewContextMenu(const QPoint &point)
963{
964 QWidget *pSender = qobject_cast<QWidget*>(sender());
965 if (!pSender)
966 return;
967 createFileViewContextMenu(pSender, point);
968}
969
970void UIFileManagerTable::sltHandleNavigationWidgetPathChange(const QString& strPath)
971{
972 goIntoDirectory(UIPathOperations::pathTrail(strPath));
973}
974
975void UIFileManagerTable::sltHandleNavigationWidgetHistoryListChanged()
976{
977 toggleForwardBackwardActions();
978}
979
980void UIFileManagerTable::deSelectUpDirectoryItem()
981{
982 if (!m_pView)
983 return;
984 QItemSelectionModel *pSelectionModel = m_pView->selectionModel();
985 if (!pSelectionModel)
986 return;
987 QModelIndex currentRoot = currentRootIndex();
988 if (!currentRoot.isValid())
989 return;
990
991 /* Make sure that "up directory item" (if exists) is deselected: */
992 for (int i = 0; i < m_pModel->rowCount(currentRoot); ++i)
993 {
994 QModelIndex index = m_pModel->index(i, 0, currentRoot);
995 if (!index.isValid())
996 continue;
997
998 UIFileSystemItem *item = static_cast<UIFileSystemItem*>(index.internalPointer());
999 if (item && item->isUpDirectory())
1000 {
1001 QModelIndex indexToDeselect = m_pProxyModel ? m_pProxyModel->mapFromSource(index) : index;
1002 pSelectionModel->select(indexToDeselect, QItemSelectionModel::Deselect | QItemSelectionModel::Rows);
1003 }
1004 }
1005}
1006
1007void UIFileManagerTable::setSelectionForAll(QItemSelectionModel::SelectionFlags flags)
1008{
1009 if (!m_pView)
1010 return;
1011 QItemSelectionModel *pSelectionModel = m_pView->selectionModel();
1012 if (!pSelectionModel)
1013 return;
1014 QModelIndex currentRoot = currentRootIndex();
1015 if (!currentRoot.isValid())
1016 return;
1017
1018 for (int i = 0; i < m_pModel->rowCount(currentRoot); ++i)
1019 {
1020 QModelIndex index = m_pModel->index(i, 0, currentRoot);
1021 if (!index.isValid())
1022 continue;
1023 QModelIndex indexToSelect = m_pProxyModel ? m_pProxyModel->mapFromSource(index) : index;
1024 pSelectionModel->select(indexToSelect, flags);
1025 }
1026}
1027
1028void UIFileManagerTable::setSelection(const QModelIndex &indexInProxyModel)
1029{
1030 if (!m_pView)
1031 return;
1032 QItemSelectionModel *selectionModel = m_pView->selectionModel();
1033 if (!selectionModel)
1034 return;
1035 selectionModel->select(indexInProxyModel, QItemSelectionModel::Current | QItemSelectionModel::Rows | QItemSelectionModel::Select);
1036 m_pView->scrollTo(indexInProxyModel, QAbstractItemView::EnsureVisible);
1037}
1038
1039void UIFileManagerTable::deleteByIndex(const QModelIndex &itemIndex)
1040{
1041 UIFileSystemItem *treeItem = indexData(itemIndex);
1042 if (!treeItem)
1043 return;
1044 deleteByItem(treeItem);
1045}
1046
1047void UIFileManagerTable::sltRetranslateUI()
1048{
1049 UIFileSystemItem *pRootItem = rootItem();
1050 if (pRootItem)
1051 {
1052 pRootItem->setData(UIFileManager::tr("Name"), UIFileSystemModelData_Name);
1053 pRootItem->setData(UIFileManager::tr("Size"), UIFileSystemModelData_Size);
1054 pRootItem->setData(UIFileManager::tr("Change Time"), UIFileSystemModelData_ChangeTime);
1055 pRootItem->setData(UIFileManager::tr("Owner"), UIFileSystemModelData_Owner);
1056 pRootItem->setData(UIFileManager::tr("Permissions"), UIFileSystemModelData_Permissions);
1057 }
1058}
1059
1060bool UIFileManagerTable::eventFilter(QObject *pObject, QEvent *pEvent) /* override */
1061{
1062 /* Handle only events sent to m_pView: */
1063 if (pObject != m_pView)
1064 return QWidget::eventFilter(pObject, pEvent);
1065
1066 if (pEvent->type() == QEvent::KeyPress)
1067 {
1068 QKeyEvent *pKeyEvent = dynamic_cast<QKeyEvent*>(pEvent);
1069 if (pKeyEvent)
1070 {
1071 if (pKeyEvent->key() == Qt::Key_Enter || pKeyEvent->key() == Qt::Key_Return)
1072 {
1073 if (m_pView && m_pModel && !m_pView->isInEditState())
1074 {
1075 /* Get the selected item. If there are 0 or more than 1 selection do nothing: */
1076 QItemSelectionModel *selectionModel = m_pView->selectionModel();
1077 if (selectionModel)
1078 {
1079 QModelIndexList selectedItemIndices = selectionModel->selectedRows();
1080 if (selectedItemIndices.size() == 1 && m_pModel)
1081 goIntoDirectory( m_pProxyModel->mapToSource(selectedItemIndices.at(0)));
1082 }
1083 }
1084 return true;
1085 }
1086 else if (pKeyEvent->key() == Qt::Key_Delete)
1087 {
1088 sltDelete();
1089 return true;
1090 }
1091 else if (pKeyEvent->key() == Qt::Key_Backspace)
1092 {
1093 sltGoUp();
1094 return true;
1095 }
1096 else if (pKeyEvent->text().length() == 1 &&
1097 (pKeyEvent->text().at(0).isDigit() ||
1098 pKeyEvent->text().at(0).isLetter()))
1099 {
1100 if (m_pSearchLineEdit)
1101 {
1102 markUnmarkSearchLineEdit(false);
1103 m_pSearchLineEdit->clear();
1104 m_pSearchLineEdit->show();
1105 m_pSearchLineEdit->setFocus();
1106 m_pSearchLineEdit->setText(pKeyEvent->text());
1107 }
1108 }
1109 else if (pKeyEvent->key() == Qt::Key_Tab)
1110 {
1111 return true;
1112 }
1113 }
1114 }
1115 else if (pEvent->type() == QEvent::FocusOut)
1116 {
1117 disableSelectionSearch();
1118 }
1119
1120 /* Call to base-class: */
1121 return QWidget::eventFilter(pObject, pEvent);
1122}
1123
1124UIFileSystemItem *UIFileManagerTable::getStartDirectoryItem()
1125{
1126 UIFileSystemItem* pRootItem = rootItem();
1127 if (!pRootItem)
1128 return 0;
1129 if (pRootItem->childCount() <= 0)
1130 return 0;
1131 return pRootItem->child(0);
1132}
1133
1134QString UIFileManagerTable::currentDirectoryPath() const
1135{
1136 if (!m_pView)
1137 return QString();
1138 QModelIndex currentRoot = currentRootIndex();
1139 if (!currentRoot.isValid())
1140 return QString();
1141 UIFileSystemItem *item = static_cast<UIFileSystemItem*>(currentRoot.internalPointer());
1142 if (!item)
1143 return QString();
1144 /* be paranoid: */
1145 if (!item->isDirectory())
1146 return QString();
1147 return item->path();
1148}
1149
1150QStringList UIFileManagerTable::selectedItemPathList()
1151{
1152 QItemSelectionModel *selectionModel = m_pView->selectionModel();
1153 if (!selectionModel)
1154 return QStringList();
1155
1156 QStringList pathList;
1157 QModelIndexList selectedItemIndices = selectionModel->selectedRows();
1158 for(int i = 0; i < selectedItemIndices.size(); ++i)
1159 {
1160 QModelIndex index =
1161 m_pProxyModel ? m_pProxyModel->mapToSource(selectedItemIndices.at(i)) : selectedItemIndices.at(i);
1162 UIFileSystemItem *item = static_cast<UIFileSystemItem*>(index.internalPointer());
1163 if (!item)
1164 continue;
1165 pathList.push_back(item->path());
1166 }
1167 return pathList;
1168}
1169
1170CGuestFsObjInfo UIFileManagerTable::guestFsObjectInfo(const QString& path, CGuestSession &comGuestSession) const
1171{
1172 if (comGuestSession.isNull())
1173 return CGuestFsObjInfo();
1174 CGuestFsObjInfo comFsObjInfo = comGuestSession.FsObjQueryInfo(path, true /*aFollowSymlinks*/);
1175 if (!comFsObjInfo.isOk())
1176 return CGuestFsObjInfo();
1177 return comFsObjInfo;
1178}
1179
1180void UIFileManagerTable::setSelectionDependentActionsEnabled(bool fIsEnabled)
1181{
1182 foreach (QAction *pAction, m_selectionDependentActions)
1183 pAction->setEnabled(fIsEnabled);
1184 if (m_pView)
1185 emit sigSelectionChanged(m_pView->hasSelection());
1186}
1187
1188UIFileSystemItem* UIFileManagerTable::rootItem()
1189{
1190 if (!m_pModel)
1191 return 0;
1192 return m_pModel->rootItem();
1193}
1194
1195void UIFileManagerTable::setPathSeparator(const QChar &separator)
1196{
1197 m_pathSeparator = separator;
1198 if (m_pNavigationWidget)
1199 m_pNavigationWidget->setPathSeparator(m_pathSeparator);
1200}
1201
1202QHBoxLayout* UIFileManagerTable::toolBarLayout()
1203{
1204 return m_pToolBarLayout;
1205}
1206
1207bool UIFileManagerTable::event(QEvent *pEvent)
1208{
1209 if (pEvent->type() == QEvent::EnabledChange)
1210 sltRetranslateUI();
1211 return QWidget::event(pEvent);
1212}
1213
1214QString UIFileManagerTable::fileTypeString(KFsObjType type)
1215{
1216 QString strType = UIFileManager::tr("Unknown");
1217 switch (type)
1218 {
1219 case KFsObjType_File:
1220 strType = UIFileManager::tr("File");
1221 break;
1222 case KFsObjType_Directory:
1223 strType = UIFileManager::tr("Directory");
1224 break;
1225 case KFsObjType_Symlink:
1226 strType = UIFileManager::tr("Symbolic Link");
1227 break;
1228 case KFsObjType_Unknown:
1229 default:
1230 strType = UIFileManager::tr("Unknown");
1231 break;
1232 }
1233 return strType;
1234}
1235
1236/* static */ QString UIFileManagerTable::humanReadableSize(ULONG64 size)
1237{
1238 return UITranslator::formatSize(size);
1239}
1240
1241void UIFileManagerTable::optionsUpdated()
1242{
1243 UIFileManagerOptions *pOptions = UIFileManagerOptions::instance();
1244 if (pOptions)
1245 {
1246 if (m_pProxyModel)
1247 {
1248 m_pProxyModel->setListDirectoriesOnTop(pOptions->fListDirectoriesOnTop);
1249 m_pProxyModel->setShowHiddenObjects(pOptions->fShowHiddenObjects);
1250 }
1251 if (m_pModel)
1252 m_pModel->setShowHumanReadableSizes(pOptions->fShowHumanReadableSizes);
1253 }
1254 relist();
1255}
1256
1257bool UIFileManagerTable::hasSelection() const
1258{
1259 if (m_pView)
1260 return m_pView->hasSelection();
1261 return false;
1262}
1263
1264void UIFileManagerTable::setDragDropMode(QAbstractItemView::DragDropMode behavior)
1265{
1266 if (m_pView)
1267 m_pView->setDragDropMode(behavior);
1268}
1269
1270void UIFileManagerTable::sltReceiveDirectoryStatistics(UIDirectoryStatistics statistics)
1271{
1272 if (!m_pPropertiesDialog)
1273 return;
1274 m_pPropertiesDialog->addDirectoryStatistics(statistics);
1275}
1276
1277QModelIndex UIFileManagerTable::currentRootIndex() const
1278{
1279 if (!m_pView)
1280 return QModelIndex();
1281 if (!m_pProxyModel)
1282 return m_pView->rootIndex();
1283 return m_pProxyModel->mapToSource(m_pView->rootIndex());
1284}
1285
1286void UIFileManagerTable::performSelectionSearch(const QString &strSearchText)
1287{
1288 if (!m_pProxyModel | !m_pView)
1289 return;
1290
1291 if (strSearchText.isEmpty())
1292 {
1293 markUnmarkSearchLineEdit(false);
1294 return;
1295 }
1296
1297 int rowCount = m_pProxyModel->rowCount(m_pView->rootIndex());
1298 UIFileSystemItem *pFoundItem = 0;
1299 QModelIndex index;
1300 for (int i = 0; i < rowCount && !pFoundItem; ++i)
1301 {
1302 index = m_pProxyModel->index(i, 0, m_pView->rootIndex());
1303 if (!index.isValid())
1304 continue;
1305 pFoundItem = static_cast<UIFileSystemItem*>(m_pProxyModel->mapToSource(index).internalPointer());
1306 if (!pFoundItem)
1307 continue;
1308 const QString &strName = pFoundItem->fileObjectName();
1309 if (!strName.startsWith(m_pSearchLineEdit->text(), Qt::CaseInsensitive))
1310 pFoundItem = 0;
1311 }
1312 if (pFoundItem)
1313 {
1314 /* Deselect anything that is already selected: */
1315 m_pView->clearSelection();
1316 setSelection(index);
1317 }
1318 markUnmarkSearchLineEdit(!pFoundItem);
1319}
1320
1321void UIFileManagerTable::disableSelectionSearch()
1322{
1323 if (!m_pSearchLineEdit)
1324 return;
1325 m_pSearchLineEdit->blockSignals(true);
1326 m_pSearchLineEdit->clear();
1327 m_pSearchLineEdit->hide();
1328 m_pSearchLineEdit->blockSignals(false);
1329}
1330
1331bool UIFileManagerTable::checkIfDeleteOK()
1332{
1333 UIFileManagerOptions *pFileManagerOptions = UIFileManagerOptions::instance();
1334 if (!pFileManagerOptions)
1335 return true;
1336 if (!pFileManagerOptions->fAskDeleteConfirmation)
1337 return true;
1338 UIFileDeleteConfirmationDialog *pDialog =
1339 new UIFileDeleteConfirmationDialog(this);
1340
1341 bool fContinueWithDelete = (pDialog->execute() == QDialog::Accepted);
1342 bool bAskNextTime = pDialog->askDeleteConfirmationNextTime();
1343
1344 /* Update the file manager options only if it is necessary: */
1345 if (pFileManagerOptions->fAskDeleteConfirmation != bAskNextTime)
1346 {
1347 pFileManagerOptions->fAskDeleteConfirmation = bAskNextTime;
1348 /* Notify file manager options panel so that the check box there is updated: */
1349 emit sigDeleteConfirmationOptionChanged();
1350 }
1351
1352 delete pDialog;
1353
1354 return fContinueWithDelete;
1355
1356}
1357
1358void UIFileManagerTable::markUnmarkSearchLineEdit(bool fMark)
1359{
1360 if (!m_pSearchLineEdit)
1361 return;
1362 QPalette palette = m_pSearchLineEdit->palette();
1363
1364 if (fMark)
1365 palette.setColor(QPalette::Base, m_searchLineMarkColor);
1366 else
1367 palette.setColor(QPalette::Base, m_searchLineUnmarkColor);
1368 m_pSearchLineEdit->setPalette(palette);
1369}
1370
1371void UIFileManagerTable::setSessionWidgetsEnabled(bool fEnabled)
1372{
1373 foreach (QWidget *pWidget, m_sessionWidgets)
1374 {
1375 if (pWidget)
1376 pWidget->setEnabled(fEnabled);
1377 }
1378}
1379
1380QStringList UIFileManagerTable::currentDirectoryListing() const
1381{
1382 UIFileSystemItem *pItem = static_cast<UIFileSystemItem*>(currentRootIndex().internalPointer());
1383 if (!pItem)
1384 return QStringList();
1385 QStringList list;
1386 foreach (const UIFileSystemItem *pChild, pItem->children())
1387 {
1388 if (pChild)
1389 list << pChild->fileObjectName();
1390 }
1391 return list;
1392}
1393
1394void UIFileManagerTable::setModelFileSystem(bool fIsWindowsFileSystem)
1395{
1396 if (m_pModel)
1397 m_pModel->setIsWindowsFileSystem(fIsWindowsFileSystem);
1398 /* On Windows it is generally desired to sort file objects case insensitively: */
1399 if (m_pProxyModel)
1400 {
1401 if (fIsWindowsFileSystem)
1402 m_pProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
1403 else
1404 m_pProxyModel->setSortCaseSensitivity(Qt::CaseSensitive);
1405 }
1406}
1407
1408#include "UIFileManagerTable.moc"
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use