UIMediumSelector.cpp@ 80926

Last change on this file since 80926 was 80926, checked in by vboxsync, 5 years ago
FE/Qt: bugref:8472: Merge startMediumEnumeration & enumerateAdditionalMedia into one consolidated mechanism which can enumerate all media at once or selected media only.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 24.5 KB

Line
1	/* $Id: UIMediumSelector.cpp 80926 2019-09-20 13:24:33Z vboxsync $ */
2	/** @file
3	* VBox Qt GUI - UIMediumSelector class implementation.
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 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	/* Qt includes: */
19	#include <QAction>
20	#include <QHeaderView>
21	#include <QMenuBar>
22	#include <QVBoxLayout>
23	#include <QPushButton>
24
25	/* GUI includes: */
26	#include "QIDialogButtonBox.h"
27	#include "QIFileDialog.h"
28	#include "QIMessageBox.h"
29	#include "QITabWidget.h"
30	#include "QIToolButton.h"
31	#include "UICommon.h"
32	#include "UIDesktopWidgetWatchdog.h"
33	#include "UIExtraDataManager.h"
34	#include "UIFDCreationDialog.h"
35	#include "UIMediumSearchWidget.h"
36	#include "UIMediumSelector.h"
37	#include "UIMessageCenter.h"
38	#include "UIIconPool.h"
39	#include "UIMedium.h"
40	#include "UIMediumItem.h"
41	#include "UIToolBar.h"
42
43	/* COM includes: */
44	#include "COMEnums.h"
45	#include "CMachine.h"
46	#include "CMediumAttachment.h"
47	#include "CMediumFormat.h"
48	#include "CStorageController.h"
49	#include "CSystemProperties.h"
50
51	#ifdef VBOX_WS_MAC
52	# include "UIWindowMenuManager.h"
53	#endif /* VBOX_WS_MAC */
54
55
56	UIMediumSelector::UIMediumSelector(UIMediumDeviceType enmMediumType, const QString &machineName /* = QString() */,
57	const QString &machineSettingsFilePath /* = QString() */,
58	const QString &strMachineGuestOSTypeId /= QString() /, QWidget pParent / = 0 */)
59	:QIWithRetranslateUI<QIMainDialog>(pParent)
60	, m_pCentralWidget(0)
61	, m_pMainLayout(0)
62	, m_pTreeWidget(0)
63	, m_enmMediumType(enmMediumType)
64	, m_pButtonBox(0)
65	, m_pCancelButton(0)
66	, m_pChooseButton(0)
67	, m_pLeaveEmptyButton(0)
68	, m_pMainMenu(0)
69	, m_pToolBar(0)
70	, m_pActionAdd(0)
71	, m_pActionCreate(0)
72	, m_pActionRefresh(0)
73	, m_pAttachedSubTreeRoot(0)
74	, m_pNotAttachedSubTreeRoot(0)
75	, m_pParent(pParent)
76	, m_pSearchWidget(0)
77	, m_iCurrentShownIndex(0)
78	, m_strMachineFolder(machineSettingsFilePath)
79	, m_strMachineName(machineName)
80	, m_strMachineGuestOSTypeId(strMachineGuestOSTypeId)
81	{
82	/* Start medium-enumeration (if necessary): */
83	if (!uiCommon().isFullMediumEnumerationRequested())
84	uiCommon().enumerateMedia();
85	configure();
86	finalize();
87	}
88
89	void UIMediumSelector::setEnableCreateAction(bool fEnable)
90	{
91	if (!m_pActionCreate)
92	return;
93	m_pActionCreate->setEnabled(fEnable);
94	m_pActionCreate->setVisible(fEnable);
95	}
96
97	QList<QUuid> UIMediumSelector::selectedMediumIds() const
98	{
99	QList<QUuid> selectedIds;
100	if (!m_pTreeWidget)
101	return selectedIds;
102	QList<QTreeWidgetItem*> selectedItems = m_pTreeWidget->selectedItems();
103	for (int i = 0; i < selectedItems.size(); ++i)
104	{
105	UIMediumItem item = dynamic_cast<UIMediumItem>(selectedItems.at(i));
106	if (item)
107	selectedIds.push_back(item->medium().id());
108	}
109	return selectedIds;
110	}
111
112
113	void UIMediumSelector::retranslateUi()
114	{
115	if (m_pMainMenu)
116	m_pMainMenu->setTitle(tr("Medium"));
117
118	if (m_pActionAdd)
119	{
120	m_pActionAdd->setText(tr("&Add..."));
121	m_pActionAdd->setToolTip(tr("Add Disk Image"));
122	m_pActionAdd->setStatusTip(tr("Add existing disk image file"));
123	}
124
125	if (m_pActionCreate)
126	{
127	m_pActionCreate->setText(tr("&Create..."));
128	m_pActionCreate->setToolTip(tr("Create Disk Image"));
129	m_pActionCreate->setStatusTip(tr("Create new disk image file"));
130	}
131
132	if (m_pActionRefresh)
133	{
134	m_pActionRefresh->setText(tr("&Refresh"));
135	m_pActionRefresh->setToolTip(tr("Refresh Disk Image Files (%1)").arg(m_pActionRefresh->shortcut().toString()));
136	m_pActionRefresh->setStatusTip(tr("Refresh the list of disk image files"));
137	}
138
139	if (m_pCancelButton)
140	m_pCancelButton->setText(tr("Cancel"));
141	if (m_pLeaveEmptyButton)
142	m_pLeaveEmptyButton->setText(tr("Leave Empty"));
143	if (m_pChooseButton)
144	m_pChooseButton->setText(tr("Choose"));
145
146	if (m_pTreeWidget)
147	{
148	m_pTreeWidget->headerItem()->setText(0, tr("Name"));
149	m_pTreeWidget->headerItem()->setText(1, tr("Virtual Size"));
150	m_pTreeWidget->headerItem()->setText(2, tr("Actual Size"));
151	}
152	}
153
154	void UIMediumSelector::configure()
155	{
156	/* Apply window icons: */
157	setWindowIcon(UIIconPool::iconSetFull(":/media_manager_32px.png", ":/media_manager_16px.png"));
158	setTitle();
159	prepareWidgets();
160	prepareActions();
161	prepareMenuAndToolBar();
162	prepareConnections();
163	}
164
165	void UIMediumSelector::prepareActions()
166	{
167	QString strPrefix("hd");
168	switch (m_enmMediumType)
169	{
170	case UIMediumDeviceType_DVD:
171	strPrefix = "cd";
172	break;
173	case UIMediumDeviceType_Floppy:
174	strPrefix = "fd";
175	break;
176	case UIMediumDeviceType_HardDisk:
177	case UIMediumDeviceType_All:
178	case UIMediumDeviceType_Invalid:
179	default:
180	strPrefix = "hd";
181	break;
182	}
183
184	m_pActionAdd = new QAction(this);
185	if (m_pActionAdd)
186	{
187	/* Configure add-action: */
188	m_pActionAdd->setShortcut(QKeySequence(""));
189
190	m_pActionAdd->setIcon(UIIconPool::iconSetFull(QString(":/%1_add_32px.png").arg(strPrefix),
191	QString(":/%1_add_16px.png").arg(strPrefix),
192	QString(":/%1_add_disabled_32px.png").arg(strPrefix),
193	QString(":/%1_add_disabled_16px.png").arg(strPrefix)));
194
195	}
196
197	m_pActionCreate = new QAction(this);
198	if (m_pActionCreate)
199	{
200	m_pActionCreate->setShortcut(QKeySequence(""));
201	m_pActionCreate->setIcon(UIIconPool::iconSetFull(QString(":/%1_create_32px.png").arg(strPrefix),
202	QString(":/%1_create_16px.png").arg(strPrefix),
203	QString(":/%1_create_disabled_32px.png").arg(strPrefix),
204	QString(":/%1_create_disabled_16px.png").arg(strPrefix)));
205	}
206
207
208	m_pActionRefresh = new QAction(this);
209	if (m_pActionRefresh)
210	{
211	m_pActionRefresh->setShortcut(QKeySequence());
212	if (m_pActionRefresh && m_pActionRefresh->icon().isNull())
213	m_pActionRefresh->setIcon(UIIconPool::iconSetFull(":/refresh_32px.png", ":/refresh_16px.png",
214	":/refresh_disabled_32px.png", ":/refresh_disabled_16px.png"));
215	}
216	}
217
218	void UIMediumSelector::prepareMenuAndToolBar()
219	{
220	if (!m_pMainMenu \|\| !m_pToolBar)
221	return;
222
223	m_pMainMenu->addAction(m_pActionAdd);
224	m_pMainMenu->addAction(m_pActionCreate);
225	m_pMainMenu->addSeparator();
226	m_pMainMenu->addAction(m_pActionRefresh);
227
228	m_pToolBar->addAction(m_pActionAdd);
229	m_pToolBar->addAction(m_pActionCreate);
230	m_pToolBar->addSeparator();
231	m_pToolBar->addAction(m_pActionRefresh);
232	}
233
234	void UIMediumSelector::prepareConnections()
235	{
236	/* Configure medium-enumeration connections: */
237	connect(&uiCommon(), &UICommon::sigMediumEnumerationStarted,
238	this, &UIMediumSelector::sltHandleMediumEnumerationStart);
239	connect(&uiCommon(), &UICommon::sigMediumEnumerated,
240	this, &UIMediumSelector::sltHandleMediumEnumerated);
241	connect(&uiCommon(), &UICommon::sigMediumEnumerationFinished,
242	this, &UIMediumSelector::sltHandleMediumEnumerationFinish);
243	if (m_pActionAdd)
244	connect(m_pActionAdd, &QAction::triggered, this, &UIMediumSelector::sltAddMedium);
245	if (m_pActionCreate)
246	connect(m_pActionCreate, &QAction::triggered, this, &UIMediumSelector::sltCreateMedium);
247	if (m_pActionRefresh)
248	connect(m_pActionRefresh, &QAction::triggered, this, &UIMediumSelector::sltHandleRefresh);
249
250	if (m_pTreeWidget)
251	{
252	connect(m_pTreeWidget, &QITreeWidget::itemSelectionChanged, this, &UIMediumSelector::sltHandleItemSelectionChanged);
253	connect(m_pTreeWidget, &QITreeWidget::itemDoubleClicked, this, &UIMediumSelector::sltHandleTreeWidgetDoubleClick);
254	connect(m_pTreeWidget, &QITreeWidget::customContextMenuRequested, this, &UIMediumSelector::sltHandleTreeContextMenuRequest);
255	}
256
257	if (m_pCancelButton)
258	connect(m_pCancelButton, &QPushButton::clicked, this, &UIMediumSelector::sltButtonCancel);
259	if (m_pChooseButton)
260	connect(m_pChooseButton, &QPushButton::clicked, this, &UIMediumSelector::sltButtonChoose);
261	if (m_pLeaveEmptyButton)
262	connect(m_pLeaveEmptyButton, &QPushButton::clicked, this, &UIMediumSelector::sltButtonLeaveEmpty);
263
264
265	if (m_pSearchWidget)
266	{
267	connect(m_pSearchWidget, &UIMediumSearchWidget::sigPerformSearch,
268	this, &UIMediumSelector::sltHandlePerformSearch);
269	}
270	}
271
272	UIMediumItem* UIMediumSelector::addTreeItem(const UIMedium &medium, QITreeWidgetItem *pParent)
273	{
274	if (!pParent)
275	return 0;
276	switch (m_enmMediumType)
277	{
278	case UIMediumDeviceType_DVD:
279	return new UIMediumItemCD(medium, pParent);
280	break;
281	case UIMediumDeviceType_Floppy:
282	return new UIMediumItemFD(medium, pParent);
283	break;
284	case UIMediumDeviceType_HardDisk:
285	case UIMediumDeviceType_All:
286	case UIMediumDeviceType_Invalid:
287	default:
288	return createHardDiskItem(medium, pParent);
289	break;
290	}
291	}
292
293	UIMediumItem* UIMediumSelector::createHardDiskItem(const UIMedium &medium, QITreeWidgetItem *pParent)
294	{
295	if (medium.medium().isNull())
296	return 0;
297	if (!m_pTreeWidget)
298	return 0;
299	/* Search the tree to see if we already have the item: */
300	UIMediumItem *pMediumItem = searchItem(0, medium.id());
301	if (pMediumItem)
302	return pMediumItem;
303	/* Check if the corresponding medium has a parent */
304	if (medium.parentID() != UIMedium::nullID())
305	{
306	UIMediumItem *pParentMediumItem = searchItem(0, medium.parentID());
307	/* If parent medium-item was not found we create it: */
308	if (!pParentMediumItem)
309	{
310	/* Make sure corresponding parent medium is already cached! */
311	UIMedium parentMedium = uiCommon().medium(medium.parentID());
312	if (parentMedium.isNull())
313	AssertMsgFailed(("Parent medium with ID={%s} was not found!\n", medium.parentID().toString().toUtf8().constData()));
314	/* Try to create parent medium-item: */
315	else
316	pParentMediumItem = createHardDiskItem(parentMedium, pParent);
317	}
318	if (pParentMediumItem)
319	{
320	pMediumItem = new UIMediumItemHD(medium, pParentMediumItem);
321	LogRel2(("UIMediumManager: Child hard-disk medium-item with ID={%s} created.\n", medium.id().toString().toUtf8().constData()));
322	}
323	else
324	AssertMsgFailed(("Parent medium with ID={%s} could not be created!\n", medium.parentID().toString().toUtf8().constData()));
325	}
326
327	/* No parents, thus just create item as top-level one: */
328	else
329	{
330	pMediumItem = new UIMediumItemHD(medium, pParent);
331	LogRel2(("UIMediumManager: Root hard-disk medium-item with ID={%s} created.\n", medium.id().toString().toUtf8().constData()));
332	}
333	return pMediumItem;
334	}
335
336	void UIMediumSelector::restoreSelection(const QList<QUuid> &selectedMediums, QVector<UIMediumItem*> &mediumList)
337	{
338	if (!m_pTreeWidget)
339	return;
340	if (selectedMediums.isEmpty())
341	{
342	m_pTreeWidget->setCurrentItem(0);
343	return;
344	}
345	bool selected = false;
346	for (int i = 0; i < mediumList.size(); ++i)
347	{
348	if (!mediumList[i])
349	continue;
350	if (selectedMediums.contains(mediumList[i]->medium().id()))
351	{
352	mediumList[i]->setSelected(true);
353	selected = true;
354	}
355	}
356
357	if (!selected)
358	m_pTreeWidget->setCurrentItem(0);
359	return;
360	}
361
362	void UIMediumSelector::prepareWidgets()
363	{
364	m_pCentralWidget = new QWidget;
365	if (!m_pCentralWidget)
366	return;
367	setCentralWidget(m_pCentralWidget);
368
369	m_pMainLayout = new QVBoxLayout;
370	m_pCentralWidget->setLayout(m_pMainLayout);
371
372	if (!m_pMainLayout \|\| !menuBar())
373	return;
374
375	m_pMainMenu = menuBar()->addMenu(tr("Medium"));
376
377	m_pToolBar = new UIToolBar;
378	if (m_pToolBar)
379	{
380	/* Configure toolbar: */
381	const int iIconMetric = (int)(QApplication::style()->pixelMetric(QStyle::PM_LargeIconSize));
382	m_pToolBar->setIconSize(QSize(iIconMetric, iIconMetric));
383	m_pToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
384	m_pMainLayout->addWidget(m_pToolBar);
385	}
386
387	m_pTreeWidget = new QITreeWidget;
388	if (m_pTreeWidget)
389	{
390	m_pTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
391	m_pMainLayout->addWidget(m_pTreeWidget);
392	m_pTreeWidget->setAlternatingRowColors(true);
393	int iColumnCount = (m_enmMediumType == UIMediumDeviceType_HardDisk) ? 3 : 2;
394	m_pTreeWidget->setColumnCount(iColumnCount);
395	m_pTreeWidget->setSortingEnabled(true);
396	m_pTreeWidget->sortItems(0, Qt::AscendingOrder);
397	m_pTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
398	}
399
400	m_pSearchWidget = new UIMediumSearchWidget;
401	if (m_pSearchWidget)
402	{
403	m_pMainLayout->addWidget(m_pSearchWidget);
404	}
405
406	m_pButtonBox = new QIDialogButtonBox;
407	if (m_pButtonBox)
408	{
409	/* Configure button-box: */
410	m_pCancelButton = m_pButtonBox->addButton(tr("Cancel"), QDialogButtonBox::RejectRole);
411
412	/* Only DVDs and Floppies can be left empty: */
413	if (m_enmMediumType == UIMediumDeviceType_DVD \|\| m_enmMediumType == UIMediumDeviceType_Floppy)
414	m_pLeaveEmptyButton = m_pButtonBox->addButton(tr("Leave Empty"), QDialogButtonBox::ActionRole);
415
416	m_pChooseButton = m_pButtonBox->addButton(tr("Choose"), QDialogButtonBox::AcceptRole);
417	m_pCancelButton->setShortcut(Qt::Key_Escape);
418
419	/* Add button-box into main layout: */
420	m_pMainLayout->addWidget(m_pButtonBox);
421	}
422
423	repopulateTreeWidget();
424	}
425
426	void UIMediumSelector::sltButtonChoose()
427	{
428	done(static_cast<int>(ReturnCode_Accepted));
429	}
430
431	void UIMediumSelector::sltButtonCancel()
432	{
433	done(static_cast<int>(ReturnCode_Rejected));
434	}
435
436	void UIMediumSelector::sltButtonLeaveEmpty()
437	{
438	done(static_cast<int>(ReturnCode_LeftEmpty));
439	}
440
441	void UIMediumSelector::sltAddMedium()
442	{
443	QUuid uMediumID = uiCommon().openMediumWithFileOpenDialog(m_enmMediumType, this, m_strMachineFolder);
444	if (uMediumID.isNull())
445	return;
446	repopulateTreeWidget();
447	selectMedium(uMediumID);
448	}
449
450	void UIMediumSelector::sltCreateMedium()
451	{
452	QUuid uMediumId = uiCommon().openMediumCreatorDialog(this, m_enmMediumType, m_strMachineFolder,
453	m_strMachineName, m_strMachineGuestOSTypeId);
454	if (uMediumId.isNull())
455	return;
456	/* Update the tree widget making sure we show the new item: */
457	repopulateTreeWidget();
458	/* Select the new item: */
459	selectMedium(uMediumId);
460	/* Update the search: */
461	m_pSearchWidget->search(m_pTreeWidget);
462	}
463
464	void UIMediumSelector::sltHandleItemSelectionChanged()
465	{
466	updateChooseButton();
467	}
468
469	void UIMediumSelector::sltHandleTreeWidgetDoubleClick(QTreeWidgetItem * item, int column)
470	{
471	Q_UNUSED(column);
472	if (!dynamic_cast<UIMediumItem*>(item))
473	return;
474	accept();
475	}
476
477
478	void UIMediumSelector::sltHandleMediumEnumerationStart()
479	{
480	/* Disable controls. Left Alone button box 'Ok' button. it is handle by tree population: */
481	if (m_pActionRefresh)
482	m_pActionRefresh->setEnabled(false);
483	}
484
485	void UIMediumSelector::sltHandleMediumEnumerated()
486	{
487	}
488
489	void UIMediumSelector::sltHandleMediumEnumerationFinish()
490	{
491	repopulateTreeWidget();
492	if (m_pActionRefresh)
493	m_pActionRefresh->setEnabled(true);
494	}
495
496	void UIMediumSelector::sltHandleRefresh()
497	{
498	/* Initialize media enumation: */
499	uiCommon().enumerateMedia();
500	/* Update the search: */
501	m_pSearchWidget->search(m_pTreeWidget);
502	}
503
504	void UIMediumSelector::sltHandlePerformSearch()
505	{
506	//performMediumSearch();
507	if (!m_pSearchWidget)
508	return;
509	m_pSearchWidget->search(m_pTreeWidget);
510	}
511
512	void UIMediumSelector::sltHandleTreeContextMenuRequest(const QPoint &point)
513	{
514	QWidget pSender = qobject_cast<QWidget>(sender());
515	if (!pSender)
516	return;
517
518	QMenu menu;
519	QAction *pExpandAll = menu.addAction(tr("Expand All"));
520	QAction *pCollapseAll = menu.addAction(tr("Collapse All"));
521	if (!pExpandAll \|\| !pCollapseAll)
522	return;
523
524	pExpandAll->setIcon(UIIconPool::iconSet(":/expand_all_16px.png"));
525	pCollapseAll->setIcon(UIIconPool::iconSet(":/collapse_all_16px.png"));
526
527	connect(pExpandAll, &QAction::triggered, this, &UIMediumSelector::sltHandleTreeExpandAllSignal);
528	connect(pCollapseAll, &QAction::triggered, this, &UIMediumSelector::sltHandleTreeCollapseAllSignal);
529
530	menu.exec(pSender->mapToGlobal(point));
531	}
532
533	void UIMediumSelector::sltHandleTreeExpandAllSignal()
534	{
535	if (m_pTreeWidget)
536	m_pTreeWidget->expandAll();
537	}
538
539	void UIMediumSelector::sltHandleTreeCollapseAllSignal()
540	{
541	if (m_pTreeWidget)
542	m_pTreeWidget->collapseAll();
543
544	if (m_pAttachedSubTreeRoot)
545	m_pTreeWidget->setExpanded(m_pTreeWidget->itemIndex(m_pAttachedSubTreeRoot), true);
546	if (m_pNotAttachedSubTreeRoot)
547	m_pTreeWidget->setExpanded(m_pTreeWidget->itemIndex(m_pNotAttachedSubTreeRoot), true);
548	}
549
550	void UIMediumSelector::selectMedium(const QUuid &uMediumID)
551	{
552	if (!m_pTreeWidget)
553	return;
554	UIMediumItem *pMediumItem = searchItem(0, uMediumID);
555	if (pMediumItem)
556	{
557	m_pTreeWidget->setCurrentItem(pMediumItem);
558
559	}
560	}
561
562	void UIMediumSelector::updateChooseButton()
563	{
564
565	if (!m_pTreeWidget \|\| !m_pChooseButton)
566	return;
567	QList<QTreeWidgetItem*> selectedItems = m_pTreeWidget->selectedItems();
568	if (selectedItems.isEmpty())
569	{
570	m_pChooseButton->setEnabled(false);
571	return;
572	}
573
574	/* check if at least one of the selected items is a UIMediumItem */
575	bool mediumItemSelected = false;
576	for (int i = 0; i < selectedItems.size() && !mediumItemSelected; ++i)
577	{
578	if (dynamic_cast<UIMediumItem*>(selectedItems.at(i)))
579	mediumItemSelected = true;
580	}
581	if (mediumItemSelected)
582	m_pChooseButton->setEnabled(true);
583	else
584	m_pChooseButton->setEnabled(false);
585	}
586
587	void UIMediumSelector::finalize()
588	{
589	/* Apply language settings: */
590	retranslateUi();
591	}
592
593	void UIMediumSelector::showEvent(QShowEvent *pEvent)
594	{
595	Q_UNUSED(pEvent);
596
597	/* Try to determine the initial size: */
598	QSize proposedSize;
599	int iHostScreen = 0;
600	if (m_pParent)
601	iHostScreen = gpDesktop->screenNumber(m_pParent);
602	else
603	iHostScreen = gpDesktop->screenNumber(this);
604	if (iHostScreen >= 0 && iHostScreen < gpDesktop->screenCount())
605	{
606	/* On the basis of current host-screen geometry if possible: */
607	const QRect screenGeometry = gpDesktop->screenGeometry(iHostScreen);
608	if (screenGeometry.isValid())
609	proposedSize = screenGeometry.size() * 5 / 15;
610	}
611	/* Fallback to default size if we failed: */
612	if (proposedSize.isNull())
613	proposedSize = QSize(800, 600);
614	/* Resize to initial size: */
615	resize(proposedSize);
616
617	if (m_pParent)
618	UICommon::centerWidget(this, m_pParent, false);
619
620	}
621
622	void UIMediumSelector::repopulateTreeWidget()
623	{
624	if (!m_pTreeWidget)
625	return;
626	/* Cache the currently selected items: */
627	QList<QTreeWidgetItem*> selectedItems = m_pTreeWidget->selectedItems();
628	QList<QUuid> selectedMedia = selectedMediumIds();
629	/* uuid list of selected items: */
630	/* Reset the related data structure: */
631	m_mediumItemList.clear();
632	m_pTreeWidget->clear();
633	m_pAttachedSubTreeRoot = 0;
634	m_pNotAttachedSubTreeRoot = 0;
635	QVector<UIMediumItem*> menuItemVector;
636
637	foreach (const QUuid &uMediumID, uiCommon().mediumIDs())
638	{
639	UIMedium medium = uiCommon().medium(uMediumID);
640	if (medium.type() == m_enmMediumType)
641	{
642	bool isMediumAttached = !(medium.medium().GetMachineIds().isEmpty());
643	QITreeWidgetItem *pParent = 0;
644	if (isMediumAttached)
645	{
646	if (!m_pAttachedSubTreeRoot)
647	{
648	QStringList strList;
649	strList << "Attached";
650	m_pAttachedSubTreeRoot = new QITreeWidgetItem(m_pTreeWidget, strList);
651	}
652	pParent = m_pAttachedSubTreeRoot;
653
654	}
655	else
656	{
657	if (!m_pNotAttachedSubTreeRoot)
658	{
659	QStringList strList;
660	strList << "Not Attached";
661	m_pNotAttachedSubTreeRoot = new QITreeWidgetItem(m_pTreeWidget, strList);
662	}
663	pParent = m_pNotAttachedSubTreeRoot;
664	}
665	UIMediumItem *treeItem = addTreeItem(medium, pParent);
666	m_mediumItemList.append(treeItem);
667	menuItemVector.push_back(treeItem);
668	}
669	}
670	restoreSelection(selectedMedia, menuItemVector);
671	saveDefaultForeground();
672	updateChooseButton();
673	if (m_pAttachedSubTreeRoot)
674	m_pTreeWidget->expandItem(m_pAttachedSubTreeRoot);
675
676	if (m_pNotAttachedSubTreeRoot)
677	m_pTreeWidget->expandItem(m_pNotAttachedSubTreeRoot);
678
679	m_pTreeWidget->resizeColumnToContents(0);
680	}
681
682	void UIMediumSelector::saveDefaultForeground()
683	{
684	if (!m_pTreeWidget)
685	return;
686	if (m_defaultItemForeground == QBrush() && m_pTreeWidget->topLevelItemCount() >= 1)
687	{
688	QTreeWidgetItem *item = m_pTreeWidget->topLevelItem(0);
689	if (item)
690	{
691	QVariant data = item->data(0, Qt::ForegroundRole);
692	if (data.canConvert<QBrush>())
693	{
694	m_defaultItemForeground = data.value<QBrush>();
695	}
696	}
697	}
698	}
699
700	UIMediumItem* UIMediumSelector::searchItem(const QTreeWidgetItem *pParent, const QUuid &mediumId)
701	{
702	if (!m_pTreeWidget)
703	return 0;
704	if (!pParent)
705	{
706	pParent = m_pTreeWidget->invisibleRootItem();
707	}
708	if (!pParent)
709	return 0;
710
711	for (int i = 0; i < pParent->childCount(); ++i)
712	{
713	QTreeWidgetItem *pChild = pParent->child(i);
714	if (!pChild)
715	continue;
716	UIMediumItem mediumItem = dynamic_cast<UIMediumItem>(pChild);
717	if (mediumItem)
718	{
719	if (mediumItem->id() == mediumId)
720	{
721	return mediumItem;
722	}
723	}
724	UIMediumItem *pResult = searchItem(pChild, mediumId);
725	if (pResult)
726	return pResult;
727	}
728	return 0;
729	}
730
731	void UIMediumSelector::scrollToItem(UIMediumItem* pItem)
732	{
733	if (!pItem)
734	return;
735
736	QModelIndex itemIndex = m_pTreeWidget->itemIndex(pItem);
737	for (int i = 0; i < m_mediumItemList.size(); ++i)
738	{
739	QFont font = m_mediumItemList[i]->font(0);
740	font.setBold(false);
741	m_mediumItemList[i]->setFont(0, font);
742	}
743	QFont font = pItem->font(0);
744	font.setBold(true);
745	pItem->setFont(0, font);
746
747	m_pTreeWidget->scrollTo(itemIndex);
748	}
749
750	void UIMediumSelector::setTitle()
751	{
752	switch (m_enmMediumType)
753	{
754	case UIMediumDeviceType_DVD:
755	if (!m_strMachineName.isEmpty())
756	setWindowTitle(QString("%1 - %2").arg(m_strMachineName).arg(tr("Optical Disk Selector")));
757	else
758	setWindowTitle(QString("%1").arg(tr("Optical Disk Selector")));
759	break;
760	case UIMediumDeviceType_Floppy:
761	if (!m_strMachineName.isEmpty())
762	setWindowTitle(QString("%1 - %2").arg(m_strMachineName).arg(tr("Floppy Disk Selector")));
763	else
764	setWindowTitle(QString("%1").arg(tr("Floppy Disk Selector")));
765	break;
766	case UIMediumDeviceType_HardDisk:
767	if (!m_strMachineName.isEmpty())
768	setWindowTitle(QString("%1 - %2").arg(m_strMachineName).arg(tr("Hard Disk Selector")));
769	else
770	setWindowTitle(QString("%1").arg(tr("Hard Disk Selector")));
771	break;
772	case UIMediumDeviceType_All:
773	case UIMediumDeviceType_Invalid:
774	default:
775	if (!m_strMachineName.isEmpty())
776	setWindowTitle(QString("%1 - %2").arg(m_strMachineName).arg(tr("Virtual Medium Selector")));
777	else
778	setWindowTitle(QString("%1").arg(tr("Virtual Medium Selector")));
779	break;
780	}
781	}

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

source: vbox/trunk/src/VBox/Frontends/VirtualBox/src/medium/UIMediumSelector.cpp@ 80926

Download in other formats: