UIGuestControlFileTable.cpp@ 75662

Last change on this file since 75662 was 75662, checked in by vboxsync, 6 years ago
FE/Qt: bugref:6699. Some translation work
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 48.4 KB

Line
1	/* $Id: UIGuestControlFileTable.cpp 75662 2018-11-22 12:47:42Z vboxsync $ */
2	/** @file
3	* VBox Qt GUI - UIGuestControlFileTable class implementation.
4	*/
5
6	/*
7	* Copyright (C) 2016-2018 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18	#ifdef VBOX_WITH_PRECOMPILED_HEADERS
19	# include <precomp.h>
20	#else /* !VBOX_WITH_PRECOMPILED_HEADERS */
21
22	/* Qt includes: */
23	# include <QAction>
24	# include <QComboBox>
25	# include <QCheckBox>
26	# include <QDateTime>
27	# include <QDir>
28	# include <QHeaderView>
29	# include <QItemDelegate>
30	# include <QGridLayout>
31	# include <QMenu>
32	# include <QSortFilterProxyModel>
33	# include <QTextEdit>
34	# include <QPushButton>
35
36	/* GUI includes: */
37	# include "QIDialog.h"
38	# include "QIDialogButtonBox.h"
39	# include "QILabel.h"
40	# include "QILineEdit.h"
41	# include "QIMessageBox.h"
42	# include "UIActionPool.h"
43	# include "UIErrorString.h"
44	# include "UIGuestFileTable.h"
45	# include "UIIconPool.h"
46	# include "UIGuestControlFileTable.h"
47	# include "UIGuestControlFileManager.h"
48	# include "UIGuestControlFileModel.h"
49	# include "UIToolBar.h"
50
51	/* COM includes: */
52	# include "CFsObjInfo.h"
53	# include "CGuestFsObjInfo.h"
54	# include "CGuestDirectory.h"
55	# include "CProgress.h"
56
57	#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
58
59
60
61	/*********************************************************************************************************************************
62	* UIGuestControlFileView definition. *
63	*********************************************************************************************************************************/
64
65	/** Using QITableView causes the following problem when I click on the table items
66	Qt WARNING: Cannot creat accessible child interface for object: UIGuestControlFileView.....
67	so for now subclass QTableView */
68	class UIGuestControlFileView : public QTableView
69	{
70
71	Q_OBJECT;
72
73	signals:
74
75	void sigSelectionChanged(const QItemSelection & selected, const QItemSelection & deselected);
76
77	public:
78
79	UIGuestControlFileView(QWidget * parent = 0);
80	bool hasSelection() const;
81
82	protected:
83
84	virtual void selectionChanged(const QItemSelection & selected, const QItemSelection & deselected) /override /;
85
86	private:
87
88	void configure();
89	QWidget *m_pParent;
90	};
91
92
93	/*********************************************************************************************************************************
94	* UIFileDelegate definition. *
95	*********************************************************************************************************************************/
96	/** A QItemDelegate child class to disable dashed lines drawn around selected cells in QTableViews */
97	class UIFileDelegate : public QItemDelegate
98	{
99
100	Q_OBJECT;
101
102	protected:
103
104	virtual void drawFocus ( QPainter * /painter/, const QStyleOptionViewItem & /option/, const QRect & /rect/ ) const {}
105
106	};
107
108
109	/*********************************************************************************************************************************
110	* UStringInputDialog definition. *
111	*********************************************************************************************************************************/
112
113	/** A QIDialog child including a line edit whose text exposed when the dialog is accepted */
114	class UIStringInputDialog : public QIDialog
115	{
116
117	Q_OBJECT;
118
119	public:
120
121	UIStringInputDialog(QWidget *pParent = 0, Qt::WindowFlags flags = 0);
122	QString getString() const;
123
124	private:
125
126	QILineEdit *m_pLineEdit;
127
128	};
129
130
131	/*********************************************************************************************************************************
132	* UIFileDeleteConfirmationDialog definition. *
133	*********************************************************************************************************************************/
134
135	/** A QIDialog child including a line edit whose text exposed when the dialog is accepted */
136	class UIFileDeleteConfirmationDialog : public QIDialog
137	{
138
139	Q_OBJECT;
140
141	public:
142
143	UIFileDeleteConfirmationDialog(QWidget *pParent = 0, Qt::WindowFlags flags = 0);
144	/** Returns whether m_pAskNextTimeCheckBox is checked or not. */
145	bool askDeleteConfirmationNextTime() const;
146
147	private:
148
149	QCheckBox *m_pAskNextTimeCheckBox;
150	QLabel *m_pQuestionLabel;
151
152	};
153
154
155	/*********************************************************************************************************************************
156	* UIHostDirectoryDiskUsageComputer implementation. *
157	*********************************************************************************************************************************/
158
159	UIDirectoryDiskUsageComputer::UIDirectoryDiskUsageComputer(QObject *parent, QStringList pathList)
160	:QThread(parent)
161	, m_pathList(pathList)
162	, m_fOkToContinue(true)
163	{
164	}
165
166	void UIDirectoryDiskUsageComputer::run()
167	{
168	for (int i = 0; i < m_pathList.size(); ++i)
169	directoryStatisticsRecursive(m_pathList[i], m_resultStatistics);
170	}
171
172	void UIDirectoryDiskUsageComputer::stopRecursion()
173	{
174	m_mutex.lock();
175	m_fOkToContinue = false;
176	m_mutex.unlock();
177	}
178
179	bool UIDirectoryDiskUsageComputer::isOkToContinue() const
180	{
181	return m_fOkToContinue;
182	}
183
184
185	/*********************************************************************************************************************************
186	* UIPathOperations implementation. *
187	*********************************************************************************************************************************/
188
189	const QChar UIPathOperations::delimiter = QChar('/');
190	const QChar UIPathOperations::dosDelimiter = QChar('\\');
191
192	/* static */ QString UIPathOperations::removeMultipleDelimiters(const QString &path)
193	{
194	QString newPath(path);
195	QString doubleDelimiter(2, delimiter);
196
197	while (newPath.contains(doubleDelimiter) && !newPath.isEmpty())
198	newPath = newPath.replace(doubleDelimiter, delimiter);
199	return newPath;
200	}
201
202	/* static */ QString UIPathOperations::removeTrailingDelimiters(const QString &path)
203	{
204	if (path.isNull() \|\| path.isEmpty())
205	return QString();
206	QString newPath(path);
207	/* Make sure for we dont have any trailing delimiters: */
208	while (newPath.length() > 1 && newPath.at(newPath.length() - 1) == UIPathOperations::delimiter)
209	newPath.chop(1);
210	return newPath;
211	}
212
213	/* static */ QString UIPathOperations::addTrailingDelimiters(const QString &path)
214	{
215	if (path.isNull() \|\| path.isEmpty())
216	return QString();
217	QString newPath(path);
218	while (newPath.length() > 1 && newPath.at(newPath.length() - 1) != UIPathOperations::delimiter)
219	newPath += UIPathOperations::delimiter;
220	return newPath;
221	}
222
223	/* static */ QString UIPathOperations::addStartDelimiter(const QString &path)
224	{
225	if (path.isEmpty())
226	return QString(path);
227	QString newPath(path);
228
229	if (doesPathStartWithDriveLetter(newPath))
230	{
231	if (newPath.at(newPath.length() - 1) != delimiter)
232	newPath += delimiter;
233	return newPath;
234	}
235	if (newPath.at(0) != delimiter)
236	newPath.insert(0, delimiter);
237	return newPath;
238	}
239
240	/* static */ QString UIPathOperations::sanitize(const QString &path)
241	{
242	//return addStartDelimiter(removeTrailingDelimiters(removeMultipleDelimiters(path)));
243	QString newPath = addStartDelimiter(removeTrailingDelimiters(removeMultipleDelimiters(path))).replace(dosDelimiter, delimiter);
244	return newPath;
245	}
246
247	/* static */ QString UIPathOperations::mergePaths(const QString &path, const QString &baseName)
248	{
249	QString newBase(baseName);
250	newBase = newBase.remove(delimiter);
251
252	/* make sure we have one and only one trailing '/': */
253	QString newPath(sanitize(path));
254	if(newPath.isEmpty())
255	newPath = delimiter;
256	if(newPath.at(newPath.length() - 1) != delimiter)
257	newPath += UIPathOperations::delimiter;
258	newPath += newBase;
259	return sanitize(newPath);
260	}
261
262	/* static */ QString UIPathOperations::getObjectName(const QString &path)
263	{
264	if (path.length() <= 1)
265	return QString(path);
266
267	QString strTemp(sanitize(path));
268	if (strTemp.length() < 2)
269	return strTemp;
270	int lastSlashPosition = strTemp.lastIndexOf(UIPathOperations::delimiter);
271	if (lastSlashPosition == -1)
272	return QString();
273	return strTemp.right(strTemp.length() - lastSlashPosition - 1);
274	}
275
276	/* static */ QString UIPathOperations::getPathExceptObjectName(const QString &path)
277	{
278	if (path.length() <= 1)
279	return QString(path);
280
281	QString strTemp(sanitize(path));
282	int lastSlashPosition = strTemp.lastIndexOf(UIPathOperations::delimiter);
283	if (lastSlashPosition == -1)
284	return QString();
285	return strTemp.left(lastSlashPosition + 1);
286	}
287
288	/* static */ QString UIPathOperations::constructNewItemPath(const QString &previousPath, const QString &newBaseName)
289	{
290	if (previousPath.length() <= 1)
291	return QString(previousPath);
292	return sanitize(mergePaths(getPathExceptObjectName(previousPath), newBaseName));
293	}
294
295	/* static */ QStringList UIPathOperations::pathTrail(const QString &path)
296	{
297	QStringList pathList = path.split(UIPathOperations::delimiter, QString::SkipEmptyParts);
298	if (!pathList.isEmpty() && doesPathStartWithDriveLetter(pathList[0]))
299	{
300	pathList[0] = addTrailingDelimiters(pathList[0]);
301	}
302	return pathList;
303	}
304
305	/* static */ bool UIPathOperations::doesPathStartWithDriveLetter(const QString &path)
306	{
307	if (path.length() < 2)
308	return false;
309	/* search for ':' with the path: */
310	if (!path[0].isLetter())
311	return false;
312	if (path[1] != ':')
313	return false;
314	return true;
315	}
316
317
318	/*********************************************************************************************************************************
319	* UIGuestControlFileView implementation. *
320	*********************************************************************************************************************************/
321
322	UIGuestControlFileView::UIGuestControlFileView(QWidget *parent)
323	:QTableView(parent)
324	, m_pParent(parent)
325	{
326	configure();
327	}
328
329	void UIGuestControlFileView::configure()
330	{
331	setContextMenuPolicy(Qt::CustomContextMenu);
332	setShowGrid(false);
333	setSelectionBehavior(QAbstractItemView::SelectRows);
334	verticalHeader()->setVisible(false);
335	setEditTriggers(QAbstractItemView::NoEditTriggers);
336	/* Minimize the row height: */
337	verticalHeader()->setDefaultSectionSize(verticalHeader()->minimumSectionSize());
338	setAlternatingRowColors(true);
339	installEventFilter(m_pParent);
340	}
341
342	bool UIGuestControlFileView::hasSelection() const
343	{
344	QItemSelectionModel *pSelectionModel = selectionModel();
345	if (!pSelectionModel)
346	return false;
347	return pSelectionModel->hasSelection();
348	}
349
350	void UIGuestControlFileView::selectionChanged(const QItemSelection & selected, const QItemSelection & deselected)
351	{
352	emit sigSelectionChanged(selected, deselected);
353	QTableView::selectionChanged(selected, deselected);
354	}
355
356
357	/*********************************************************************************************************************************
358	* UIFileStringInputDialog implementation. *
359	*********************************************************************************************************************************/
360
361	UIStringInputDialog::UIStringInputDialog(QWidget pParent / = 0 /, Qt::WindowFlags flags / = 0 */)
362	:QIDialog(pParent, flags)
363	{
364	QVBoxLayout *layout = new QVBoxLayout(this);
365	m_pLineEdit = new QILineEdit(this);
366	layout->addWidget(m_pLineEdit);
367
368	QIDialogButtonBox *pButtonBox =
369	new QIDialogButtonBox(QDialogButtonBox::Ok \| QDialogButtonBox::Cancel, Qt::Horizontal, this);
370	layout->addWidget(pButtonBox);
371	connect(pButtonBox, &QIDialogButtonBox::accepted, this, &UIStringInputDialog::accept);
372	connect(pButtonBox, &QIDialogButtonBox::rejected, this, &UIStringInputDialog::reject);
373	}
374
375	QString UIStringInputDialog::getString() const
376	{
377	if (!m_pLineEdit)
378	return QString();
379	return m_pLineEdit->text();
380	}
381
382
383	/*********************************************************************************************************************************
384	* UIPropertiesDialog implementation. *
385	*********************************************************************************************************************************/
386
387	UIPropertiesDialog::UIPropertiesDialog(QWidget *pParent, Qt::WindowFlags flags)
388	:QIDialog(pParent, flags)
389	, m_pMainLayout(new QVBoxLayout)
390	, m_pInfoEdit(new QTextEdit)
391	{
392	setLayout(m_pMainLayout);
393
394	if (m_pMainLayout)
395	m_pMainLayout->addWidget(m_pInfoEdit);
396	if (m_pInfoEdit)
397	{
398	m_pInfoEdit->setReadOnly(true);
399	m_pInfoEdit->setFrameStyle(QFrame::NoFrame);
400	}
401	QIDialogButtonBox *pButtonBox =
402	new QIDialogButtonBox(QDialogButtonBox::Ok, Qt::Horizontal, this);
403	m_pMainLayout->addWidget(pButtonBox);
404	connect(pButtonBox, &QIDialogButtonBox::accepted, this, &UIStringInputDialog::accept);
405	}
406
407	void UIPropertiesDialog::setPropertyText(const QString &strProperty)
408	{
409	if (!m_pInfoEdit)
410	return;
411	m_strProperty = strProperty;
412	m_pInfoEdit->setHtml(strProperty);
413	}
414
415	void UIPropertiesDialog::addDirectoryStatistics(UIDirectoryStatistics directoryStatistics)
416	{
417	if (!m_pInfoEdit)
418	return;
419	// QString propertyString = m_pInfoEdit->toHtml();
420	// propertyString += "<b>Total Size:</b> " + QString::number(directoryStatistics.m_totalSize) + QString(" bytes");
421	// if (directoryStatistics.m_totalSize >= UIGuestControlFileTable::m_iKiloByte)
422	// propertyString += " (" + UIGuestControlFileTable::humanReadableSize(directoryStatistics.m_totalSize) + ")";
423	// propertyString += "<br/>";
424	// propertyString += "<b>File Count:</b> " + QString::number(directoryStatistics.m_uFileCount);
425
426	// m_pInfoEdit->setHtml(propertyString);
427
428	QString detailsString(m_strProperty);
429	detailsString += "<br/>";
430	detailsString += "<b>" + UIGuestControlFileManager::tr("Total Size") + "</b> " +
431	QString::number(directoryStatistics.m_totalSize) + UIGuestControlFileManager::tr(" bytes");
432	if (directoryStatistics.m_totalSize >= UIGuestControlFileTable::m_iKiloByte)
433	detailsString += " (" + UIGuestControlFileTable::humanReadableSize(directoryStatistics.m_totalSize) + ")";
434	detailsString += "<br/>";
435
436	detailsString += "<b>" + UIGuestControlFileManager::tr("File Count") + ":</b> " +
437	QString::number(directoryStatistics.m_uFileCount);
438
439	m_pInfoEdit->setHtml(detailsString);
440	}
441
442
443	/*********************************************************************************************************************************
444	* UIDirectoryStatistics implementation. *
445	*********************************************************************************************************************************/
446
447	UIDirectoryStatistics::UIDirectoryStatistics()
448	: m_totalSize(0)
449	, m_uFileCount(0)
450	, m_uDirectoryCount(0)
451	, m_uSymlinkCount(0)
452	{
453	}
454
455
456	/*********************************************************************************************************************************
457	* UIFileTableItem implementation. *
458	*********************************************************************************************************************************/
459
460	UIFileTableItem::UIFileTableItem(const QVector<QVariant> &data,
461	UIFileTableItem *parent, FileObjectType type)
462	: m_itemData(data)
463	, m_parentItem(parent)
464	, m_bIsOpened(false)
465	, m_isTargetADirectory(false)
466	, m_type(type)
467	, m_isDriveItem(false)
468	{
469	}
470
471	UIFileTableItem::~UIFileTableItem()
472	{
473	qDeleteAll(m_childItems);
474	m_childItems.clear();
475	}
476
477	void UIFileTableItem::appendChild(UIFileTableItem *item)
478	{
479	if (!item)
480	return;
481	m_childItems.append(item);
482	m_childMap.insert(item->name(), item);
483	}
484
485	UIFileTableItem *UIFileTableItem::child(int row) const
486	{
487	return m_childItems.value(row);
488	}
489
490	UIFileTableItem *UIFileTableItem::child(const QString &path) const
491	{
492	if (!m_childMap.contains(path))
493	return 0;
494	return m_childMap.value(path);
495	}
496
497	int UIFileTableItem::childCount() const
498	{
499	return m_childItems.count();
500	}
501
502	int UIFileTableItem::columnCount() const
503	{
504	return m_itemData.count();
505	}
506
507	QVariant UIFileTableItem::data(int column) const
508	{
509	return m_itemData.value(column);
510	}
511
512	QString UIFileTableItem::name() const
513	{
514	if (m_itemData.isEmpty() \|\| !m_itemData[0].canConvert(QMetaType::QString))
515	return QString();
516	return m_itemData[0].toString();
517	}
518
519	void UIFileTableItem::setData(const QVariant &data, int index)
520	{
521	if (index >= m_itemData.length())
522	return;
523	m_itemData[index] = data;
524	}
525
526	UIFileTableItem *UIFileTableItem::parentItem()
527	{
528	return m_parentItem;
529	}
530
531	int UIFileTableItem::row() const
532	{
533	if (m_parentItem)
534	return m_parentItem->m_childItems.indexOf(const_cast<UIFileTableItem*>(this));
535	return 0;
536	}
537
538	bool UIFileTableItem::isDirectory() const
539	{
540	return m_type == FileObjectType_Directory;
541	}
542
543	bool UIFileTableItem::isSymLink() const
544	{
545	return m_type == FileObjectType_SymLink;
546	}
547
548	bool UIFileTableItem::isFile() const
549	{
550	return m_type == FileObjectType_File;
551	}
552
553	void UIFileTableItem::clearChildren()
554	{
555	qDeleteAll(m_childItems);
556	m_childItems.clear();
557	m_childMap.clear();
558	}
559
560	bool UIFileTableItem::isOpened() const
561	{
562	return m_bIsOpened;
563	}
564
565	void UIFileTableItem::setIsOpened(bool flag)
566	{
567	m_bIsOpened = flag;
568	}
569
570	const QString &UIFileTableItem::path() const
571	{
572	return m_strPath;
573	}
574
575	void UIFileTableItem::setPath(const QString &path)
576	{
577	if (path.isNull() \|\| path.isEmpty())
578	return;
579	m_strPath = path;
580	UIPathOperations::removeTrailingDelimiters(m_strPath);
581	}
582
583	bool UIFileTableItem::isUpDirectory() const
584	{
585	if (!isDirectory())
586	return false;
587	if (data(0) == UIGuestControlFileModel::strUpDirectoryString)
588	return true;
589	return false;
590	}
591
592	FileObjectType UIFileTableItem::type() const
593	{
594	return m_type;
595	}
596
597	const QString &UIFileTableItem::targetPath() const
598	{
599	return m_strTargetPath;
600	}
601
602	void UIFileTableItem::setTargetPath(const QString &path)
603	{
604	m_strTargetPath = path;
605	}
606
607	bool UIFileTableItem::isTargetADirectory() const
608	{
609	return m_isTargetADirectory;
610	}
611
612	void UIFileTableItem::setIsTargetADirectory(bool flag)
613	{
614	m_isTargetADirectory = flag;
615	}
616
617	void UIFileTableItem::setIsDriveItem(bool flag)
618	{
619	m_isDriveItem = flag;
620	}
621
622	bool UIFileTableItem::isDriveItem() const
623	{
624	return m_isDriveItem;
625	}
626
627	/*********************************************************************************************************************************
628	+* UIFileDeleteConfirmationDialog implementation. *
629	+*********************************************************************************************************************************/
630
631	UIFileDeleteConfirmationDialog::UIFileDeleteConfirmationDialog(QWidget pParent / = 0 /, Qt::WindowFlags flags / = 0 */)
632	:QIDialog(pParent, flags)
633	, m_pAskNextTimeCheckBox(0)
634	, m_pQuestionLabel(0)
635	{
636	QVBoxLayout *pLayout = new QVBoxLayout(this);
637
638	m_pQuestionLabel = new QLabel;
639	if (m_pQuestionLabel)
640	{
641	pLayout->addWidget(m_pQuestionLabel);
642	m_pQuestionLabel->setText(UIGuestControlFileManager::tr("Delete the selected file(s) and/or folder(s)"));
643	}
644
645	QIDialogButtonBox *pButtonBox =
646	new QIDialogButtonBox(QDialogButtonBox::Ok \| QDialogButtonBox::Cancel, Qt::Horizontal, this);
647	if (pButtonBox)
648	{
649	pLayout->addWidget(pButtonBox, 0, Qt::AlignCenter);
650	connect(pButtonBox, &QIDialogButtonBox::accepted, this, &UIStringInputDialog::accept);
651	connect(pButtonBox, &QIDialogButtonBox::rejected, this, &UIStringInputDialog::reject);
652	}
653
654	m_pAskNextTimeCheckBox = new QCheckBox;
655
656	if (m_pAskNextTimeCheckBox)
657	{
658	UIGuestControlFileManagerSettings *pFileManagerSettings = UIGuestControlFileManagerSettings::instance();
659	if (pFileManagerSettings)
660	m_pAskNextTimeCheckBox->setChecked(pFileManagerSettings->bAskDeleteConfirmation);
661
662	pLayout->addWidget(m_pAskNextTimeCheckBox);
663	m_pAskNextTimeCheckBox->setText(UIGuestControlFileManager::tr("Ask for this confirmation next time"));
664	m_pAskNextTimeCheckBox->setToolTip(UIGuestControlFileManager::tr("Delete confirmation can be "
665	"disabled/enabled also from the Options panel."));
666	}
667	}
668
669	bool UIFileDeleteConfirmationDialog::askDeleteConfirmationNextTime() const
670	{
671	if (!m_pAskNextTimeCheckBox)
672	return true;
673	return m_pAskNextTimeCheckBox->isChecked();
674	}
675
676
677	/*********************************************************************************************************************************
678	* UIGuestControlFileTable implementation. *
679	*********************************************************************************************************************************/
680	const unsigned UIGuestControlFileTable::m_iKiloByte = 1000;
681	UIGuestControlFileTable::UIGuestControlFileTable(UIActionPool pActionPool, QWidget pParent /* = 0 */)
682	:QIWithRetranslateUI<QWidget>(pParent)
683	, m_pRootItem(0)
684	, m_pLocationLabel(0)
685	, m_pPropertiesDialog(0)
686	, m_pActionPool(pActionPool)
687	, m_pToolBar(0)
688	, m_pModel(0)
689	, m_pView(0)
690	, m_pProxyModel(0)
691	, m_pMainLayout(0)
692	, m_pLocationComboBox(0)
693	{
694	prepareObjects();
695	}
696
697	UIGuestControlFileTable::~UIGuestControlFileTable()
698	{
699	delete m_pRootItem;
700	}
701
702	void UIGuestControlFileTable::reset()
703	{
704	if (m_pModel)
705	m_pModel->beginReset();
706	delete m_pRootItem;
707	m_pRootItem = 0;
708	if (m_pModel)
709	m_pModel->endReset();
710	if (m_pLocationComboBox)
711	{
712	disconnect(m_pLocationComboBox, static_cast<void(QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged),
713	this, &UIGuestControlFileTable::sltLocationComboCurrentChange);
714	m_pLocationComboBox->clear();
715	connect(m_pLocationComboBox, static_cast<void(QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged),
716	this, &UIGuestControlFileTable::sltLocationComboCurrentChange);
717	}
718	}
719
720	void UIGuestControlFileTable::emitLogOutput(const QString& strOutput, FileManagerLogType eLogType)
721	{
722	emit sigLogOutput(strOutput, eLogType);
723	}
724
725	void UIGuestControlFileTable::prepareObjects()
726	{
727	m_pMainLayout = new QGridLayout();
728	if (!m_pMainLayout)
729	return;
730	m_pMainLayout->setSpacing(0);
731	m_pMainLayout->setContentsMargins(0, 0, 0, 0);
732	setLayout(m_pMainLayout);
733
734	m_pToolBar = new UIToolBar;
735	if (m_pToolBar)
736	{
737	m_pMainLayout->addWidget(m_pToolBar, 0, 0, 1, 5);
738	}
739
740	m_pLocationLabel = new QILabel;
741	if (m_pLocationLabel)
742	{
743	m_pMainLayout->addWidget(m_pLocationLabel, 1, 0, 1, 1);
744	}
745
746	m_pLocationComboBox = new QComboBox;
747	if (m_pLocationComboBox)
748	{
749	m_pMainLayout->addWidget(m_pLocationComboBox, 1, 1, 1, 4);
750	m_pLocationComboBox->setEditable(false);
751	connect(m_pLocationComboBox, static_cast<void(QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged),
752	this, &UIGuestControlFileTable::sltLocationComboCurrentChange);
753	}
754
755
756	m_pModel = new UIGuestControlFileModel(this);
757	if (!m_pModel)
758	return;
759
760	m_pProxyModel = new UIGuestControlFileProxyModel(this);
761	if (!m_pProxyModel)
762	return;
763	m_pProxyModel->setSourceModel(m_pModel);
764
765	m_pView = new UIGuestControlFileView(this);
766	if (m_pView)
767	{
768	m_pMainLayout->addWidget(m_pView, 2, 0, 5, 5);
769	m_pView->setModel(m_pProxyModel);
770	m_pView->setItemDelegate(new UIFileDelegate);
771	m_pView->setSortingEnabled(true);
772	m_pView->sortByColumn(0, Qt::AscendingOrder);
773
774	connect(m_pView, &UIGuestControlFileView::doubleClicked,
775	this, &UIGuestControlFileTable::sltItemDoubleClicked);
776	connect(m_pView, &UIGuestControlFileView::clicked,
777	this, &UIGuestControlFileTable::sltItemClicked);
778	connect(m_pView, &UIGuestControlFileView::sigSelectionChanged,
779	this, &UIGuestControlFileTable::sltSelectionChanged);
780	connect(m_pView, &UIGuestControlFileView::customContextMenuRequested,
781	this, &UIGuestControlFileTable::sltCreateFileViewContextMenu);
782
783	}
784	m_pSearchLineEdit = new QILineEdit;
785	if (m_pSearchLineEdit)
786	{
787	m_pMainLayout->addWidget(m_pSearchLineEdit, 8, 0, 1, 5);
788	m_pSearchLineEdit->hide();
789	m_pSearchLineEdit->setClearButtonEnabled(true);
790	connect(m_pSearchLineEdit, &QLineEdit::textChanged,
791	this, &UIGuestControlFileTable::sltSearchTextChanged);
792	}
793	}
794
795	void UIGuestControlFileTable::updateCurrentLocationEdit(const QString& strLocation)
796	{
797	if (!m_pLocationComboBox)
798	return;
799	int itemIndex = m_pLocationComboBox->findText(strLocation,
800	Qt::MatchExactly \| Qt::MatchCaseSensitive);
801	if (itemIndex == -1)
802	{
803	m_pLocationComboBox->insertItem(m_pLocationComboBox->count(), strLocation);
804	itemIndex = m_pLocationComboBox->count() - 1;
805	}
806	m_pLocationComboBox->setCurrentIndex(itemIndex);
807	}
808
809	void UIGuestControlFileTable::changeLocation(const QModelIndex &index)
810	{
811	if (!index.isValid() \|\| !m_pView)
812	return;
813	m_pView->setRootIndex(m_pProxyModel->mapFromSource(index));
814	m_pView->clearSelection();
815
816	UIFileTableItem item = static_cast<UIFileTableItem>(index.internalPointer());
817	if (item)
818	{
819	updateCurrentLocationEdit(item->path());
820	}
821	/** @todo check if we really need this and if not remove it */
822	//m_pModel->signalUpdate();
823	}
824
825	void UIGuestControlFileTable::initializeFileTree()
826	{
827	if (m_pRootItem)
828	reset();
829
830	/* Root item: */
831	const QString startPath("/");
832	QVector<QVariant> headData;
833	headData.resize(UIGuestControlFileModelColumn_Max);
834	m_pRootItem = new UIFileTableItem(headData, 0, FileObjectType_Directory);
835	UIFileTableItem* startItem = new UIFileTableItem(createTreeItemData(startPath, 4096, QDateTime(),
836	"" /* owner /, "" / permissions */),
837	m_pRootItem, FileObjectType_Directory);
838	startItem->setPath(startPath);
839	m_pRootItem->appendChild(startItem);
840	startItem->setIsOpened(false);
841	populateStartDirectory(startItem);
842
843	m_pModel->signalUpdate();
844	updateCurrentLocationEdit(startPath);
845	m_pView->setRootIndex(m_pProxyModel->mapFromSource(m_pModel->rootIndex()));
846	}
847
848	void UIGuestControlFileTable::populateStartDirectory(UIFileTableItem *startItem)
849	{
850	determineDriveLetters();
851	if (m_driveLetterList.isEmpty())
852	{
853	/* Read the root directory and get the list: */
854	readDirectory(startItem->path(), startItem, true);
855	}
856	else
857	{
858	for (int i = 0; i < m_driveLetterList.size(); ++i)
859	{
860	UIFileTableItem* driveItem = new UIFileTableItem(createTreeItemData(m_driveLetterList[i], 4096,
861	QDateTime(), QString(), QString()),
862	startItem, FileObjectType_Directory);
863	driveItem->setPath(m_driveLetterList[i]);
864	startItem->appendChild(driveItem);
865	driveItem->setIsOpened(false);
866	driveItem->setIsDriveItem(true);
867	startItem->setIsOpened(true);
868	}
869	}
870	}
871
872	void UIGuestControlFileTable::insertItemsToTree(QMap<QString,UIFileTableItem*> &map,
873	UIFileTableItem *parent, bool isDirectoryMap, bool isStartDir)
874	{
875	if (parent)
876
877	/* Make sure we have an item representing up directory, and make sure it is not there for the start dir: */
878	if (isDirectoryMap)
879	{
880	if (!map.contains(UIGuestControlFileModel::strUpDirectoryString) && !isStartDir)
881	{
882	QVector<QVariant> data;
883	UIFileTableItem *item = new UIFileTableItem(createTreeItemData(UIGuestControlFileModel::strUpDirectoryString, 4096,
884	QDateTime(), QString(), QString())
885	, parent, FileObjectType_Directory);
886	item->setIsOpened(false);
887	map.insert(UIGuestControlFileModel::strUpDirectoryString, item);
888	}
889	else if (map.contains(UIGuestControlFileModel::strUpDirectoryString) && isStartDir)
890	{
891	map.remove(UIGuestControlFileModel::strUpDirectoryString);
892	}
893	}
894	for (QMap<QString,UIFileTableItem*>::const_iterator iterator = map.begin();
895	iterator != map.end(); ++iterator)
896	{
897	if (iterator.key() == "." \|\| iterator.key().isEmpty())
898	continue;
899	parent->appendChild(iterator.value());
900	}
901	}
902
903	void UIGuestControlFileTable::sltItemDoubleClicked(const QModelIndex &index)
904	{
905	if (!index.isValid() \|\| !m_pModel \|\| !m_pView)
906	return;
907	QModelIndex nIndex = m_pProxyModel ? m_pProxyModel->mapToSource(index) : index;
908	goIntoDirectory(nIndex);
909	}
910
911	void UIGuestControlFileTable::sltItemClicked(const QModelIndex &index)
912	{
913	Q_UNUSED(index);
914	disableSelectionSearch();
915	}
916
917	void UIGuestControlFileTable::sltGoUp()
918	{
919	if (!m_pView \|\| !m_pModel)
920	return;
921	QModelIndex currentRoot = currentRootIndex();
922
923	if (!currentRoot.isValid())
924	return;
925	if (currentRoot != m_pModel->rootIndex())
926	{
927	QModelIndex parentIndex = currentRoot.parent();
928	if (parentIndex.isValid())
929	{
930	changeLocation(currentRoot.parent());
931	m_pView->selectRow(currentRoot.row());
932	}
933	}
934	}
935
936	void UIGuestControlFileTable::sltGoHome()
937	{
938	goToHomeDirectory();
939	}
940
941	void UIGuestControlFileTable::sltRefresh()
942	{
943	refresh();
944	}
945
946	void UIGuestControlFileTable::goIntoDirectory(const QModelIndex &itemIndex)
947	{
948	if (!m_pModel)
949	return;
950
951	/* Make sure the colum is 0: */
952	QModelIndex index = m_pModel->index(itemIndex.row(), 0, itemIndex.parent());
953	if (!index.isValid())
954	return;
955
956	UIFileTableItem item = static_cast<UIFileTableItem>(index.internalPointer());
957	if (!item)
958	return;
959
960	/* check if we need to go up: */
961	if (item->isUpDirectory())
962	{
963	QModelIndex parentIndex = m_pModel->parent(m_pModel->parent(index));
964	if (parentIndex.isValid())
965	changeLocation(parentIndex);
966	return;
967	}
968
969	if (!item->isDirectory())
970	return;
971	if (!item->isOpened())
972	readDirectory(item->path(),item);
973	changeLocation(index);
974	}
975
976	void UIGuestControlFileTable::goIntoDirectory(const QStringList &pathTrail)
977	{
978	UIFileTableItem *parent = getStartDirectoryItem();
979
980	for(int i = 0; i < pathTrail.size(); ++i)
981	{
982	if (!parent)
983	return;
984	/* Make sure parent is already opened: */
985	if (!parent->isOpened())
986	readDirectory(parent->path(), parent, parent == getStartDirectoryItem());
987	/* search the current path item among the parent's children: */
988	UIFileTableItem *item = parent->child(pathTrail.at(i));
989	if (!item)
990	return;
991	parent = item;
992	}
993	if (!parent)
994	return;
995	if (!parent->isOpened())
996	readDirectory(parent->path(), parent, parent == getStartDirectoryItem());
997	goIntoDirectory(parent);
998	}
999
1000	void UIGuestControlFileTable::goIntoDirectory(UIFileTableItem *item)
1001	{
1002	if (!item \|\| !m_pModel)
1003	return;
1004	goIntoDirectory(m_pModel->index(item));
1005	}
1006
1007	UIFileTableItem* UIGuestControlFileTable::indexData(const QModelIndex &index) const
1008	{
1009	if (!index.isValid())
1010	return 0;
1011	return static_cast<UIFileTableItem*>(index.internalPointer());
1012	}
1013
1014	void UIGuestControlFileTable::refresh()
1015	{
1016	if (!m_pView \|\| !m_pModel)
1017	return;
1018	QModelIndex currentIndex = currentRootIndex();
1019
1020	UIFileTableItem *treeItem = indexData(currentIndex);
1021	if (!treeItem)
1022	return;
1023	bool isRootDir = (m_pModel->rootIndex() == currentIndex);
1024	m_pModel->beginReset();
1025	/* For now we clear the whole subtree (that isrecursively) which is an overkill: */
1026	treeItem->clearChildren();
1027	if (isRootDir)
1028	populateStartDirectory(treeItem);
1029	else
1030	readDirectory(treeItem->path(), treeItem, isRootDir);
1031	m_pModel->endReset();
1032	m_pView->setRootIndex(m_pProxyModel->mapFromSource(currentIndex));
1033	setSelectionDependentActionsEnabled(m_pView->hasSelection());
1034	}
1035
1036	void UIGuestControlFileTable::relist()
1037	{
1038	if (!m_pProxyModel)
1039	return;
1040	m_pProxyModel->invalidate();
1041	}
1042
1043	void UIGuestControlFileTable::sltDelete()
1044	{
1045	if (!checkIfDeleteOK())
1046	return;
1047
1048	if (!m_pView \|\| !m_pModel)
1049	return;
1050
1051	if (!m_pView \|\| !m_pModel)
1052	return;
1053	QItemSelectionModel *selectionModel = m_pView->selectionModel();
1054	if (!selectionModel)
1055	return;
1056
1057	QModelIndexList selectedItemIndices = selectionModel->selectedRows();
1058	for(int i = 0; i < selectedItemIndices.size(); ++i)
1059	{
1060	QModelIndex index =
1061	m_pProxyModel ? m_pProxyModel->mapToSource(selectedItemIndices.at(i)) : selectedItemIndices.at(i);
1062	deleteByIndex(index);
1063	}
1064	/** @todo dont refresh here, just delete the rows and update the table view: */
1065	refresh();
1066	}
1067
1068	void UIGuestControlFileTable::sltRename()
1069	{
1070	if (!m_pView)
1071	return;
1072	QItemSelectionModel *selectionModel = m_pView->selectionModel();
1073	if (!selectionModel)
1074	return;
1075
1076	QModelIndexList selectedItemIndices = selectionModel->selectedRows();
1077	if (selectedItemIndices.size() == 0)
1078	return;
1079	QModelIndex modelIndex =
1080	m_pProxyModel ? m_pProxyModel->mapToSource(selectedItemIndices.at(0)) : selectedItemIndices.at(0);
1081	UIFileTableItem *item = indexData(modelIndex);
1082	if (!item \|\| item->isUpDirectory())
1083	return;
1084	m_pView->edit(selectedItemIndices.at(0));
1085	}
1086
1087	void UIGuestControlFileTable::sltCreateNewDirectory()
1088	{
1089	if (!m_pModel \|\| !m_pView)
1090	return;
1091	QModelIndex currentIndex = currentRootIndex();
1092	if (!currentIndex.isValid())
1093	return;
1094	UIFileTableItem item = static_cast<UIFileTableItem>(currentIndex.internalPointer());
1095	if (!item)
1096	return;
1097
1098	QString newDirectoryName = getNewDirectoryName();
1099	if (newDirectoryName.isEmpty())
1100	return;
1101
1102	if (createDirectory(item->path(), newDirectoryName))
1103	{
1104	/** @todo instead of refreshing here (an overkill) just add the
1105	rows and update the tabel view: */
1106	sltRefresh();
1107	}
1108	}
1109
1110	void UIGuestControlFileTable::sltCopy()
1111	{
1112
1113	m_copyCutBuffer = selectedItemPathList();
1114	// if (!m_copyCutBuffer.isEmpty())
1115	// m_pPaste->setEnabled(true);
1116	// else
1117	// m_pPaste->setEnabled(false);
1118	}
1119
1120	void UIGuestControlFileTable::sltCut()
1121	{
1122	m_copyCutBuffer = selectedItemPathList();
1123	// if (!m_copyCutBuffer.isEmpty())
1124	// m_pPaste->setEnabled(true);
1125	// else
1126	// m_pPaste->setEnabled(false);
1127	}
1128
1129	void UIGuestControlFileTable::sltPaste()
1130	{
1131	// paste them
1132	m_copyCutBuffer.clear();
1133	//m_pPaste->setEnabled(false);
1134	}
1135
1136	void UIGuestControlFileTable::sltShowProperties()
1137	{
1138	showProperties();
1139	}
1140
1141	void UIGuestControlFileTable::sltSelectionChanged(const QItemSelection & selected, const QItemSelection & deselected)
1142	{
1143	Q_UNUSED(selected);
1144	Q_UNUSED(deselected);
1145	setSelectionDependentActionsEnabled(m_pView->hasSelection());
1146	}
1147
1148	void UIGuestControlFileTable::sltLocationComboCurrentChange(const QString &strLocation)
1149	{
1150	QString comboLocation(UIPathOperations::sanitize(strLocation));
1151	if (comboLocation == currentDirectoryPath())
1152	return;
1153	goIntoDirectory(UIPathOperations::pathTrail(comboLocation));
1154	}
1155
1156	void UIGuestControlFileTable::sltSelectAll()
1157	{
1158	if (!m_pModel \|\| !m_pView)
1159	return;
1160	m_pView->selectAll();
1161	deSelectUpDirectoryItem();
1162	}
1163
1164	void UIGuestControlFileTable::sltInvertSelection()
1165	{
1166	setSelectionForAll(QItemSelectionModel::Toggle \| QItemSelectionModel::Rows);
1167	deSelectUpDirectoryItem();
1168	}
1169
1170	void UIGuestControlFileTable::sltSearchTextChanged(const QString &strText)
1171	{
1172	performSelectionSearch(strText);
1173	}
1174
1175	void UIGuestControlFileTable::sltCreateFileViewContextMenu(const QPoint &point)
1176	{
1177	QWidget pSender = qobject_cast<QWidget>(sender());
1178	if (!pSender)
1179	return;
1180	createFileViewContextMenu(pSender, point);
1181	}
1182
1183	void UIGuestControlFileTable::deSelectUpDirectoryItem()
1184	{
1185	if (!m_pView)
1186	return;
1187	QItemSelectionModel *pSelectionModel = m_pView->selectionModel();
1188	if (!pSelectionModel)
1189	return;
1190	QModelIndex currentRoot = currentRootIndex();
1191	if (!currentRoot.isValid())
1192	return;
1193
1194	/* Make sure that "up directory item" (if exists) is deselected: */
1195	for (int i = 0; i < m_pModel->rowCount(currentRoot); ++i)
1196	{
1197	QModelIndex index = m_pModel->index(i, 0, currentRoot);
1198	if (!index.isValid())
1199	continue;
1200
1201	UIFileTableItem item = static_cast<UIFileTableItem>(index.internalPointer());
1202	if (item && item->isUpDirectory())
1203	{
1204	QModelIndex indexToDeselect = m_pProxyModel ? m_pProxyModel->mapFromSource(index) : index;
1205	pSelectionModel->select(indexToDeselect, QItemSelectionModel::Deselect \| QItemSelectionModel::Rows);
1206	}
1207	}
1208	}
1209
1210	void UIGuestControlFileTable::setSelectionForAll(QItemSelectionModel::SelectionFlags flags)
1211	{
1212	if (!m_pView)
1213	return;
1214	QItemSelectionModel *pSelectionModel = m_pView->selectionModel();
1215	if (!pSelectionModel)
1216	return;
1217	QModelIndex currentRoot = currentRootIndex();
1218	if (!currentRoot.isValid())
1219	return;
1220
1221	for (int i = 0; i < m_pModel->rowCount(currentRoot); ++i)
1222	{
1223	QModelIndex index = m_pModel->index(i, 0, currentRoot);
1224	if (!index.isValid())
1225	continue;
1226	QModelIndex indexToSelect = m_pProxyModel ? m_pProxyModel->mapFromSource(index) : index;
1227	pSelectionModel->select(indexToSelect, flags);
1228	}
1229	}
1230
1231	void UIGuestControlFileTable::setSelection(const QModelIndex &indexInProxyModel)
1232	{
1233	if (!m_pView)
1234	return;
1235	QItemSelectionModel *selectionModel = m_pView->selectionModel();
1236	if (!selectionModel)
1237	return;
1238	selectionModel->select(indexInProxyModel, QItemSelectionModel::Current \| QItemSelectionModel::Rows \| QItemSelectionModel::Select);
1239	m_pView->scrollTo(indexInProxyModel, QAbstractItemView::EnsureVisible);
1240	}
1241
1242	void UIGuestControlFileTable::deleteByIndex(const QModelIndex &itemIndex)
1243	{
1244	UIFileTableItem *treeItem = indexData(itemIndex);
1245	if (!treeItem)
1246	return;
1247	deleteByItem(treeItem);
1248	}
1249
1250	void UIGuestControlFileTable::retranslateUi()
1251	{
1252	if (m_pRootItem)
1253	{
1254	m_pRootItem->setData(UIGuestControlFileManager::tr("Name"), UIGuestControlFileModelColumn_Name);
1255	m_pRootItem->setData(UIGuestControlFileManager::tr("Size"), UIGuestControlFileModelColumn_Size);
1256	m_pRootItem->setData(UIGuestControlFileManager::tr("Change Time"), UIGuestControlFileModelColumn_ChangeTime);
1257	m_pRootItem->setData(UIGuestControlFileManager::tr("Owner"), UIGuestControlFileModelColumn_Owner);
1258	m_pRootItem->setData(UIGuestControlFileManager::tr("Permissions"), UIGuestControlFileModelColumn_Permissions);
1259	}
1260	}
1261
1262	bool UIGuestControlFileTable::eventFilter(QObject pObject, QEvent pEvent) /* override */
1263	{
1264	Q_UNUSED(pObject);
1265	if (pEvent->type() == QEvent::KeyPress)
1266	{
1267	QKeyEvent pKeyEvent = dynamic_cast<QKeyEvent>(pEvent);
1268	if (pKeyEvent)
1269	{
1270	if (pKeyEvent->key() == Qt::Key_Enter \|\| pKeyEvent->key() == Qt::Key_Return)
1271	{
1272	if (m_pView && m_pModel)
1273	{
1274	/* Get the selected item. If there are 0 or more than 1 selection do nothing: */
1275	QItemSelectionModel *selectionModel = m_pView->selectionModel();
1276	if (selectionModel)
1277	{
1278	QModelIndexList selectedItemIndices = selectionModel->selectedRows();
1279	if (selectedItemIndices.size() == 1 && m_pModel)
1280	goIntoDirectory( m_pProxyModel->mapToSource(selectedItemIndices.at(0)));
1281	}
1282	}
1283	return true;
1284	}
1285	else if (pKeyEvent->key() == Qt::Key_Delete)
1286	{
1287	sltDelete();
1288	return true;
1289	}
1290	else if (pKeyEvent->key() == Qt::Key_Backspace)
1291	{
1292	sltGoUp();
1293	return true;
1294	}
1295	else if (pKeyEvent->text().length() == 1 && pKeyEvent->text().at(0).unicode() <= 127)
1296	{
1297	if (m_pSearchLineEdit)
1298	{
1299	m_pSearchLineEdit->show();
1300	QString strText = m_pSearchLineEdit->text();
1301	strText.append(pKeyEvent->text());
1302	m_pSearchLineEdit->setText(strText);
1303	}
1304	}
1305	}
1306	}
1307
1308	return false;
1309	}
1310
1311	UIFileTableItem *UIGuestControlFileTable::getStartDirectoryItem()
1312	{
1313	if (!m_pRootItem)
1314	return 0;
1315	if (m_pRootItem->childCount() <= 0)
1316	return 0;
1317	return m_pRootItem->child(0);
1318	}
1319
1320
1321	QString UIGuestControlFileTable::getNewDirectoryName()
1322	{
1323	UIStringInputDialog *dialog = new UIStringInputDialog();
1324	if (dialog->execute())
1325	{
1326	QString strDialog = dialog->getString();
1327	delete dialog;
1328	return strDialog;
1329	}
1330	delete dialog;
1331	return QString();
1332	}
1333
1334	QString UIGuestControlFileTable::currentDirectoryPath() const
1335	{
1336	if (!m_pView)
1337	return QString();
1338	QModelIndex currentRoot = currentRootIndex();
1339	if (!currentRoot.isValid())
1340	return QString();
1341	UIFileTableItem item = static_cast<UIFileTableItem>(currentRoot.internalPointer());
1342	if (!item)
1343	return QString();
1344	/* be paranoid: */
1345	if (!item->isDirectory())
1346	return QString();
1347	return item->path();
1348	}
1349
1350	QStringList UIGuestControlFileTable::selectedItemPathList()
1351	{
1352	QItemSelectionModel *selectionModel = m_pView->selectionModel();
1353	if (!selectionModel)
1354	return QStringList();
1355
1356	QStringList pathList;
1357	QModelIndexList selectedItemIndices = selectionModel->selectedRows();
1358	for(int i = 0; i < selectedItemIndices.size(); ++i)
1359	{
1360	QModelIndex index =
1361	m_pProxyModel ? m_pProxyModel->mapToSource(selectedItemIndices.at(i)) : selectedItemIndices.at(i);
1362	UIFileTableItem item = static_cast<UIFileTableItem>(index.internalPointer());
1363	if (!item)
1364	continue;
1365	pathList.push_back(item->path());
1366	}
1367	return pathList;
1368	}
1369
1370	CGuestFsObjInfo UIGuestControlFileTable::guestFsObjectInfo(const QString& path, CGuestSession &comGuestSession) const
1371	{
1372	if (comGuestSession.isNull())
1373	return CGuestFsObjInfo();
1374	CGuestFsObjInfo comFsObjInfo = comGuestSession.FsObjQueryInfo(path, true /aFollowSymlinks/);
1375	if (!comFsObjInfo.isOk())
1376	return CGuestFsObjInfo();
1377	return comFsObjInfo;
1378	}
1379
1380	void UIGuestControlFileTable::setSelectionDependentActionsEnabled(bool fIsEnabled)
1381	{
1382	foreach (QAction *pAction, m_selectionDependentActions)
1383	{
1384	pAction->setEnabled(fIsEnabled);
1385	}
1386	}
1387
1388
1389	QVector<QVariant> UIGuestControlFileTable::createTreeItemData(const QString &strName, ULONG64 size, const QDateTime &changeTime,
1390	const QString &strOwner, const QString &strPermissions)
1391	{
1392	QVector<QVariant> data;
1393	data.resize(UIGuestControlFileModelColumn_Max);
1394	data[UIGuestControlFileModelColumn_Name] = strName;
1395	data[UIGuestControlFileModelColumn_Size] = (qulonglong)size;
1396	data[UIGuestControlFileModelColumn_ChangeTime] = changeTime;
1397	data[UIGuestControlFileModelColumn_Owner] = strOwner;
1398	data[UIGuestControlFileModelColumn_Permissions] = strPermissions;
1399	return data;
1400	}
1401
1402	QString UIGuestControlFileTable::fileTypeString(FileObjectType type)
1403	{
1404	QString strType = UIGuestControlFileManager::tr("Unknown");
1405	switch(type)
1406	{
1407	case FileObjectType_File:
1408	strType = UIGuestControlFileManager::tr("File");
1409	break;
1410	case FileObjectType_Directory:
1411	strType = UIGuestControlFileManager::tr("Directory");
1412	break;
1413	case FileObjectType_SymLink:
1414	strType = UIGuestControlFileManager::tr("Symbolic Link");
1415	break;
1416	case FileObjectType_Other:
1417	strType = UIGuestControlFileManager::tr("Other");
1418	break;
1419
1420	case FileObjectType_Unknown:
1421	default:
1422	break;
1423	}
1424	return strType;
1425	}
1426
1427	/* static */ QString UIGuestControlFileTable::humanReadableSize(ULONG64 size)
1428	{
1429	int i = 0;
1430	double dSize = size;
1431	const char* units[] = {" B", " kB", " MB", " GB", " TB", " PB", " EB", " ZB", " YB"};
1432	while (size > m_iKiloByte) {
1433	size /= m_iKiloByte;
1434	dSize /= (double) m_iKiloByte;
1435	i++;
1436	}
1437	if (i > 8)
1438	return QString();
1439
1440	QString strResult(QString::number(dSize, 'f', 2));
1441	strResult += units[i];
1442	return strResult;
1443	}
1444
1445	void UIGuestControlFileTable::continueWithMove(const QUuid &progressId)
1446	{
1447	deleteByPath(m_deleteAfterCopyCache.value(progressId, QStringList()));
1448	}
1449
1450	void UIGuestControlFileTable::sltReceiveDirectoryStatistics(UIDirectoryStatistics statistics)
1451	{
1452	if (!m_pPropertiesDialog)
1453	return;
1454	m_pPropertiesDialog->addDirectoryStatistics(statistics);
1455	}
1456
1457	QModelIndex UIGuestControlFileTable::currentRootIndex() const
1458	{
1459	if (!m_pView)
1460	return QModelIndex();
1461	if (!m_pProxyModel)
1462	return m_pView->rootIndex();
1463	return m_pProxyModel->mapToSource(m_pView->rootIndex());
1464	}
1465
1466	void UIGuestControlFileTable::performSelectionSearch(const QString &strSearchText)
1467	{
1468	if (!m_pProxyModel \| !m_pView \|\| strSearchText.isEmpty())
1469	return;
1470
1471	int rowCount = m_pProxyModel->rowCount(m_pView->rootIndex());
1472	UIFileTableItem *pFoundItem = 0;
1473	QModelIndex index;
1474	for (int i = 0; i < rowCount && !pFoundItem; ++i)
1475	{
1476	index = m_pProxyModel->index(i, 0, m_pView->rootIndex());
1477	if (!index.isValid())
1478	continue;
1479	pFoundItem = static_cast<UIFileTableItem*>(m_pProxyModel->mapToSource(index).internalPointer());
1480	if (!pFoundItem)
1481	continue;
1482	const QString &strName = pFoundItem->name();
1483	if (!strName.startsWith(m_pSearchLineEdit->text(), Qt::CaseInsensitive))
1484	pFoundItem = 0;
1485	}
1486	if (pFoundItem)
1487	{
1488	/* Deselect anything that is already selected: */
1489	m_pView->clearSelection();
1490	setSelection(index);
1491	}
1492	}
1493
1494	void UIGuestControlFileTable::disableSelectionSearch()
1495	{
1496	if (!m_pSearchLineEdit)
1497	return;
1498	m_pSearchLineEdit->blockSignals(true);
1499	m_pSearchLineEdit->clear();
1500	m_pSearchLineEdit->hide();
1501	m_pSearchLineEdit->blockSignals(false);
1502	}
1503
1504	bool UIGuestControlFileTable::checkIfDeleteOK()
1505	{
1506	UIGuestControlFileManagerSettings *pFileManagerSettings = UIGuestControlFileManagerSettings::instance();
1507	if (!pFileManagerSettings)
1508	return true;
1509	if (!pFileManagerSettings->bAskDeleteConfirmation)
1510	return true;
1511	UIFileDeleteConfirmationDialog *pDialog =
1512	new UIFileDeleteConfirmationDialog(this);
1513
1514
1515	bool fContinueWithDelete = (pDialog->execute() == QDialog::Accepted);
1516
1517	bool bAskNextTime = pDialog->askDeleteConfirmationNextTime();
1518
1519	/* Update the file manager settings only if it is necessary: */
1520	if (pFileManagerSettings->bAskDeleteConfirmation != bAskNextTime)
1521	{
1522	pFileManagerSettings->bAskDeleteConfirmation = bAskNextTime;
1523	/* Notify file manager settings panel so that the check box there is updated: */
1524	emit sigDeleteConfirmationOptionChanged();
1525	}
1526
1527	delete pDialog;
1528
1529	return fContinueWithDelete;
1530
1531	}
1532
1533	#include "UIGuestControlFileTable.moc"

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Frontends/VirtualBox/src/guestctrl/UIGuestControlFileTable.cpp@ 75662

Download in other formats: