UIMediumSelector.cpp@ 77192

Last change on this file since 77192 was 77192, checked in by vboxsync, 6 years ago

FE/Qt: bugref:9340:

Dont show the match number in the search term line edit if line edit is empty.
Redo the search after creating a new medium or refreshing.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 23.4 KB

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

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

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

Download in other formats: