VirtualBox

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

Last change on this file since 82781 was 81612, checked in by vboxsync, 5 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use