VirtualBox

source: vbox/trunk/src/VBox/Frontends/VirtualBox/ui/VBoxDiskImageManagerDlg.ui.h@ 253

Last change on this file since 253 was 253, checked in by vboxsync, 18 years ago

FE/Qt: Various VDM fixes.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 64.7 KB
Line 
1/**
2 *
3 * VBox frontends: Qt GUI ("VirtualBox"):
4 * "Virtual Disk Manager" dialog UI include (Qt Designer)
5 */
6
7/*
8 * Copyright (C) 2006 InnoTek Systemberatung GmbH
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License as published by the Free Software Foundation,
14 * in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
15 * distribution. VirtualBox OSE is distributed in the hope that it will
16 * be useful, but WITHOUT ANY WARRANTY of any kind.
17 *
18 * If you received this file as part of a commercial VirtualBox
19 * distribution, then only the terms of your commercial VirtualBox
20 * license agreement apply instead of the previous paragraph.
21 */
22
23/****************************************************************************
24** ui.h extension file, included from the uic-generated form implementation.
25**
26** If you wish to add, delete or rename functions or slots use
27** Qt Designer which will update this file, preserving your code. Create an
28** init() function in place of a constructor, and a destroy() function in
29** place of a destructor.
30*****************************************************************************/
31
32
33class DiskImageItem : public QListViewItem
34{
35public:
36
37 DiskImageItem (DiskImageItem *parent, QString aLabel1,
38 QString aLabel2 = QString::null,
39 QString aLabel3 = QString::null,
40 QString aLabel4 = QString::null,
41 QString aLabel5 = QString::null,
42 QString aLabel6 = QString::null,
43 QString aLabel7 = QString::null,
44 QString aLabel8 = QString::null) :
45 QListViewItem (parent, aLabel1, aLabel2, aLabel3, aLabel4, aLabel5,
46 aLabel6, aLabel7, aLabel8),
47 mName (aLabel1), mStatus (VBoxMedia::Unknown) {}
48
49 DiskImageItem (QListView *parent, QString aLabel1,
50 QString aLabel2 = QString::null,
51 QString aLabel3 = QString::null,
52 QString aLabel4 = QString::null,
53 QString aLabel5 = QString::null,
54 QString aLabel6 = QString::null,
55 QString aLabel7 = QString::null,
56 QString aLabel8 = QString::null) :
57 QListViewItem (parent, aLabel1, aLabel2, aLabel3, aLabel4, aLabel5,
58 aLabel6, aLabel7, aLabel8),
59 mName (aLabel1), mStatus (VBoxMedia::Unknown) {}
60
61 QString getName() { return mName; }
62
63 void setPath (QString aPath) { mPath = aPath; }
64 const QString &getPath() { return mPath; }
65
66 void setUsage (QString aUsage) { mUsage = aUsage; }
67 const QString &getUsage() { return mUsage; }
68
69 void setSnapshotName (QString aSnapshotName) { mSnapshotName = aSnapshotName; }
70 const QString &getSnapshotName() { return mSnapshotName; }
71
72 void setDiskType (QString aDiskType) { mDiskType = aDiskType; }
73 const QString &getDiskType() { return mDiskType; }
74
75 void setStorageType (QString aStorageType) { mStorageType = aStorageType; }
76 const QString &getStorageType() { return mStorageType; }
77
78 void setVirtualSize (QString aVirtualSize) { mVirtualSize = aVirtualSize; }
79 const QString &getVirtualSize() { return mVirtualSize; }
80
81 void setActualSize (QString aActualSize) { mActualSize = aActualSize; }
82 const QString &getActualSize() { return mActualSize; }
83
84
85 void setUuid (QUuid aUuid) { mUuid = aUuid; }
86 const QString &getUuid() { return mUuid; }
87
88 void setMachineId (QString aMachineId) { mMachineId = aMachineId; }
89 const QString &getMachineId() { return mMachineId; }
90
91
92 void setStatus (VBoxMedia::Status aStatus) { mStatus = aStatus; }
93 VBoxMedia::Status getStatus() { return mStatus; }
94
95
96 void setToolTip (QString aToolTip) { mToolTip = aToolTip; }
97 const QString &getToolTip() { return mToolTip; }
98
99 QString getInformation (const QString &aInfo, bool aCompact = true,
100 const QString &aElipsis = "middle")
101 {
102 QString compactString = QString ("<compact elipsis=\"%1\">").arg (aElipsis);
103 QString info = QString ("<nobr>%1%2%3</nobr>")
104 .arg (aCompact ? compactString : "")
105 .arg (aInfo.isEmpty() ? QObject::tr ("--") : aInfo)
106 .arg (aCompact ? "</compact>" : "");
107 return info;
108 }
109
110 int rtti() const { return 1001; }
111
112 int compare (QListViewItem *aItem, int aColumn, bool aAscending) const
113 {
114 ULONG64 thisValue = vboxGlobal().parseSize ( text (aColumn));
115 ULONG64 thatValue = vboxGlobal().parseSize (aItem->text (aColumn));
116 if (thisValue && thatValue)
117 {
118 if (thisValue == thatValue)
119 return 0;
120 else
121 return thisValue > thatValue ? 1 : -1;
122 }
123 else
124 return QListViewItem::compare (aItem, aColumn, aAscending);
125 }
126
127 DiskImageItem* nextSibling() const
128 {
129 return (QListViewItem::nextSibling() &&
130 QListViewItem::nextSibling()->rtti() == 1001) ?
131 static_cast<DiskImageItem*> (QListViewItem::nextSibling()) : 0;
132 }
133
134 void paintCell (QPainter *aPainter, const QColorGroup &aColorGroup,
135 int aColumn, int aWidth, int aSlign)
136 {
137 QColorGroup cGroup (aColorGroup);
138 if (mStatus == VBoxMedia::Unknown)
139 cGroup.setColor (QColorGroup::Text, cGroup.mid());
140 QListViewItem::paintCell (aPainter, cGroup, aColumn, aWidth, aSlign);
141 }
142
143protected:
144
145 QString mName;
146 QString mPath;
147 QString mUsage;
148 QString mSnapshotName;
149 QString mDiskType;
150 QString mStorageType;
151 QString mVirtualSize;
152 QString mActualSize;
153
154 QString mUuid;
155 QString mMachineId;
156
157 QString mToolTip;
158
159 VBoxMedia::Status mStatus;
160};
161
162
163VBoxDiskImageManagerDlg *VBoxDiskImageManagerDlg::mModelessDialog = 0;
164
165
166void VBoxDiskImageManagerDlg::showModeless (const VBoxMediaList *list /* = NULL */)
167{
168 if (!mModelessDialog)
169 {
170 mModelessDialog =
171 new VBoxDiskImageManagerDlg (NULL,
172 "VBoxDiskImageManagerDlg",
173 WType_TopLevel | WDestructiveClose);
174 mModelessDialog->setup (VBoxDefs::HD | VBoxDefs::CD | VBoxDefs::FD,
175 false, NULL, list);
176
177 /* listen to events that may change the media status and refresh
178 * the contents of the modeless dialog */
179 /// @todo refreshAll() may be slow, so it may be better to analyze
180 // event details and update only what is changed */
181 //connect (&vboxGlobal(), SIGNAL (machineDataChanged (const VBoxMachineDataChangeEvent &)),
182 // mModelessDialog, SLOT (refreshAll()));
183 connect (&vboxGlobal(), SIGNAL (machineRegistered (const VBoxMachineRegisteredEvent &)),
184 mModelessDialog, SLOT (refreshAll()));
185 connect (&vboxGlobal(), SIGNAL (snapshotChanged (const VBoxSnapshotEvent &)),
186 mModelessDialog, SLOT (refreshAll()));
187
188 /* listen also to the machine state change because hard disks of running
189 * VMs are inaccessible by the current design */
190 connect (&vboxGlobal(), SIGNAL (machineStateChanged (const VBoxMachineStateChangeEvent &)),
191 mModelessDialog, SLOT (machineStateChanged (const VBoxMachineStateChangeEvent &)));
192 }
193
194 mModelessDialog->show();
195 mModelessDialog->setWindowState (mModelessDialog->windowState() &
196 ~WindowMinimized);
197 mModelessDialog->setActiveWindow();
198}
199
200
201void VBoxDiskImageManagerDlg::init()
202{
203 polished = false;
204
205 mToBeRefreshed = false;
206 mInLoop = false;
207
208 defaultButton = searchDefaultButton();
209
210 vbox = vboxGlobal().virtualBox();
211 Assert (!vbox.isNull());
212
213 setIcon (QPixmap::fromMimeSource ("diskim_16px.png"));
214
215 type = VBoxDefs::InvalidType;
216
217 QImage img =
218 QMessageBox::standardIcon (QMessageBox::Warning).convertToImage();
219 img = img.smoothScale (16, 16);
220 pxInaccessible.convertFromImage (img);
221 Assert (!pxInaccessible.isNull());
222
223 img =
224 QMessageBox::standardIcon (QMessageBox::Critical).convertToImage();
225 img = img.smoothScale (16, 16);
226 pxErroneous.convertFromImage (img);
227 Assert (!pxErroneous.isNull());
228
229
230 /* setup tab widget icons */
231 twImages->setTabIconSet (twImages->page (0),
232 VBoxGlobal::iconSet ("hd_16px.png",
233 "hd_disabled_16px.png"));
234 twImages->setTabIconSet (twImages->page (1),
235 VBoxGlobal::iconSet ("cd_16px.png",
236 "cd_disabled_16px.png"));
237 twImages->setTabIconSet (twImages->page (2),
238 VBoxGlobal::iconSet ("fd_16px.png",
239 "fd_disabled_16px.png"));
240
241
242 /* setup image list views */
243 hdsView->setColumnAlignment (1, Qt::AlignRight);
244 hdsView->setColumnAlignment (2, Qt::AlignRight);
245 hdsView->header()->setStretchEnabled (false);
246 hdsView->header()->setStretchEnabled (true, 0);
247
248 fdsView->setColumnAlignment (1, Qt::AlignRight);
249 fdsView->header()->setStretchEnabled (false);
250 fdsView->header()->setStretchEnabled (true, 0);
251
252 cdsView->setColumnAlignment (1, Qt::AlignRight);
253 cdsView->header()->setStretchEnabled (false);
254 cdsView->header()->setStretchEnabled (true, 0);
255
256
257 /* setup list-view's item tooltip */
258 hdsView->setShowToolTips (false);
259 cdsView->setShowToolTips (false);
260 fdsView->setShowToolTips (false);
261 connect (hdsView, SIGNAL (onItem (QListViewItem*)),
262 this, SLOT (mouseOnItem(QListViewItem*)));
263 connect (cdsView, SIGNAL (onItem (QListViewItem*)),
264 this, SLOT (mouseOnItem(QListViewItem*)));
265 connect (fdsView, SIGNAL (onItem (QListViewItem*)),
266 this, SLOT (mouseOnItem(QListViewItem*)));
267
268
269 /* status-bar currently disabled */
270 statusBar()->setHidden (true);
271
272
273 /* context menu composing */
274 itemMenu = new QPopupMenu (this, "itemMenu");
275
276 imNewAction = new QAction (this, "imNewAction");
277 imAddAction = new QAction (this, "imAddAction");
278 // imEditAction = new QAction (this, "imEditAction");
279 imRemoveAction = new QAction (this, "imRemoveAction");
280 imReleaseAction = new QAction (this, "imReleaseAction");
281 imRefreshAction = new QAction (this, "imRefreshAction");
282
283 connect (imNewAction, SIGNAL (activated()),
284 this, SLOT (newImage()));
285 connect (imAddAction, SIGNAL (activated()),
286 this, SLOT (addImage()));
287 // connect (imEditAction, SIGNAL (activated()),
288 // this, SLOT (editImage()));
289 connect (imRemoveAction, SIGNAL (activated()),
290 this, SLOT (removeImage()));
291 connect (imReleaseAction, SIGNAL (activated()),
292 this, SLOT (releaseImage()));
293 connect (imRefreshAction, SIGNAL (activated()),
294 this, SLOT (refreshAll()));
295
296 imNewAction->setMenuText (tr ("&New..."));
297 imAddAction->setMenuText (tr ("&Add..."));
298 // imEditAction->setMenuText (tr ("&Edit..."));
299 imRemoveAction->setMenuText (tr ("R&emove"));
300 imReleaseAction->setMenuText (tr ("Re&lease"));
301 imRefreshAction->setMenuText (tr ("Re&fresh"));
302
303 imNewAction->setText (tr ("New"));
304 imAddAction->setText (tr ("Add"));
305 // imEditAction->setText (tr ("Edit"));
306 imRemoveAction->setText (tr ("Remove"));
307 imReleaseAction->setText (tr ("Release"));
308 imRefreshAction->setText (tr ("Refresh"));
309
310 imNewAction->setAccel (tr ("Ctrl+N"));
311 imAddAction->setAccel (tr ("Ctrl+A"));
312 // imEditAction->setAccel (tr ("Ctrl+E"));
313 imRemoveAction->setAccel (tr ("Ctrl+D"));
314 imReleaseAction->setAccel (tr ("Ctrl+L"));
315 imRefreshAction->setAccel (tr ("Ctrl+R"));
316
317 imNewAction->setStatusTip (tr ("Create new VDI file and attach it to media list"));
318 imAddAction->setStatusTip (tr ("Add existing media image file to media list"));
319 // imEditAction->setStatusTip (tr ("Edit properties of selected media image file"));
320 imRemoveAction->setStatusTip (tr ("Remove selected media image file from media list"));
321 imReleaseAction->setStatusTip (tr ("Release selected media image file from being using in some VM"));
322 imRefreshAction->setStatusTip (tr ("Refresh media image list"));
323
324 imNewAction->setIconSet (VBoxGlobal::iconSet ("hd_16px.png", "hd_disabled_16px.png"));
325 imAddAction->setIconSet (VBoxGlobal::iconSet ("cd_16px.png", "cd_disabled_16px.png"));
326 // imEditAction->setIconSet (VBoxGlobal::iconSet ("guesttools_16px.png", "guesttools_disabled_16px.png"));
327 imRemoveAction->setIconSet (VBoxGlobal::iconSet ("delete_16px.png", "delete_dis_16px.png"));
328 imReleaseAction->setIconSet (VBoxGlobal::iconSet ("start_16px.png", "start_dis_16px.png"));
329 imRefreshAction->setIconSet (VBoxGlobal::iconSet ("settings_16px.png", "settings_dis_16px.png"));
330
331 // imEditAction->addTo (itemMenu);
332 imRemoveAction->addTo (itemMenu);
333 imReleaseAction->addTo (itemMenu);
334
335
336 /* toolbar composing */
337 toolBar = new VBoxToolBar (this, centralWidget(), "toolBar");
338 toolBar->setSizePolicy (QSizePolicy::Fixed, QSizePolicy::Minimum);
339 ((QVBoxLayout*)centralWidget()->layout())->insertWidget(0, toolBar);
340 setUsesTextLabel (true);
341
342 imNewAction->addTo (toolBar);
343 imAddAction->addTo (toolBar);
344 toolBar->addSeparator();
345 // imEditAction->addTo (toolBar);
346 imRemoveAction->addTo (toolBar);
347 imReleaseAction->addTo (toolBar);
348 toolBar->addSeparator();
349 imRefreshAction->addTo (toolBar);
350
351
352 /* menu bar */
353 QPopupMenu *actionMenu = new QPopupMenu (this, "actionMenu");
354 imNewAction->addTo (actionMenu);
355 imAddAction->addTo (actionMenu);
356 actionMenu->insertSeparator();
357 // imEditAction->addTo (toolBar);
358 imRemoveAction->addTo (actionMenu);
359 imReleaseAction->addTo (actionMenu);
360 actionMenu->insertSeparator();
361 imRefreshAction->addTo (actionMenu);
362 menuBar()->insertItem (QString (tr ("&Actions")), actionMenu, 1);
363
364
365 /* setup size grip */
366 sizeGrip = new QSizeGrip (centralWidget(), "sizeGrip");
367 sizeGrip->resize (sizeGrip->sizeHint());
368 sizeGrip->stackUnder(buttonOk);
369
370 /* setup information pane */
371 QApplication::setGlobalMouseTracking (true);
372 qApp->installEventFilter (this);
373 /* setup information pane layouts */
374 QGridLayout *hdsContainerLayout = new QGridLayout (hdsContainer, 4, 4);
375 hdsContainerLayout->setMargin (10);
376 QGridLayout *cdsContainerLayout = new QGridLayout (cdsContainer, 2, 4);
377 cdsContainerLayout->setMargin (10);
378 QGridLayout *fdsContainerLayout = new QGridLayout (fdsContainer, 2, 4);
379 fdsContainerLayout->setMargin (10);
380 /* create info-pane for hd list-view */
381 hdsPane1 = createInfoString (tr ("Location"), hdsContainer, 0, -1);
382 hdsPane2 = createInfoString (tr ("Disk Type"), hdsContainer, 1, 0);
383 hdsPane3 = createInfoString (tr ("Storage Type"), hdsContainer, 1, 1);
384 hdsPane4 = createInfoString (tr ("Attached to"), hdsContainer, 2, 0);
385 hdsPane5 = createInfoString (tr ("Snapshot"), hdsContainer, 2, 1);
386 /* create info-pane for cd list-view */
387 cdsPane1 = createInfoString (tr ("Location"), cdsContainer, 0, -1);
388 cdsPane2 = createInfoString (tr ("Attached to"), cdsContainer, 1, -1);
389 /* create info-pane for fd list-view */
390 fdsPane1 = createInfoString (tr ("Location"), fdsContainer, 0, -1);
391 fdsPane2 = createInfoString (tr ("Attached to"), fdsContainer, 1, -1);
392
393
394 /* enumeration progressbar creation */
395 mProgressText = new QLabel (tr ("Checking accessibility"), centralWidget());
396 mProgressText->setHidden (true);
397 buttonLayout->insertWidget (2, mProgressText);
398 mProgressBar = new QProgressBar (centralWidget());
399 mProgressBar->setHidden (true);
400 mProgressBar->setFrameShadow (QFrame::Sunken);
401 mProgressBar->setFrameShape (QFrame::Panel);
402 mProgressBar->setPercentageVisible (false);
403 mProgressBar->setMaximumWidth (100);
404 buttonLayout->insertWidget (3, mProgressBar);
405
406 if (!vboxGlobal().isInEnumeratingProcess()) loadListViews();
407}
408
409
410void VBoxDiskImageManagerDlg::loadListViews()
411{
412 /* load hd list */
413 CHardDiskEnumerator hdEnum = vbox.GetHardDisks().Enumerate();
414 while (hdEnum.HasMore())
415 {
416 CHardDisk hd = hdEnum.GetNext();
417 DiskImageItem *item = createHdItem (hdsView, 0, hd, VBoxMedia::Unknown);
418 createHdChildren (item, hd, VBoxMedia::Unknown);
419 }
420
421 /* load cd list */
422 CDVDImageEnumerator cdEnum = vbox.GetDVDImages().Enumerate();
423 while (cdEnum.HasMore())
424 {
425 CDVDImage cd = cdEnum.GetNext();
426 DiskImageItem *item = createCdItem (cdsView, 0, cd, VBoxMedia::Unknown);
427 }
428
429 /* load fd list */
430 CFloppyImageEnumerator fdEnum = vbox.GetFloppyImages().Enumerate();
431 while (fdEnum.HasMore())
432 {
433 CFloppyImage fd = fdEnum.GetNext();
434 DiskImageItem *item = createFdItem (fdsView, 0, fd, VBoxMedia::Unknown);
435 }
436}
437
438
439QIRichLabel *VBoxDiskImageManagerDlg::createInfoString (QString name, QWidget *root, int row, int column)
440{
441 QLabel *nameLabel = new QLabel (name, root, "nameLabel");
442 QIRichLabel *infoLabel = new QIRichLabel (root, "infoPane");
443
444 /* prevent the name columns from being expanded */
445 nameLabel->setSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed);
446
447 if (column == -1)
448 {
449 /* add qt-html tags to prevent wrapping and to have the same initial
450 * height of nameLabel and infoLabel (plain text gets a height smaller
451 * than rich text */
452 nameLabel->setText (QString ("<nobr>%1:</nobr>").arg (name));
453
454 ((QGridLayout *) root->layout())->addWidget (nameLabel, row, 0);
455 ((QGridLayout *) root->layout())->
456 addMultiCellWidget (infoLabel, row, row,
457 1, ((QGridLayout *) root->layout())->numCols() - 1);
458 }
459 else
460 {
461 /* add some spacing to the left of the name field for all columns but
462 * the first one, to separate it from the value field (note that adding
463 * spacing to the right is not necessary since Qt does it anyway for
464 * rich text for whatever stupid reason). */
465 if (column == 0)
466 nameLabel->setText (QString ("<nobr>%1:</nobr>").arg (name));
467 else
468 nameLabel->setText (QString ("<nobr>&nbsp;&nbsp;%1:</nobr>").arg (name));
469
470 ((QGridLayout *) root->layout())->addWidget (nameLabel, row, column * 2);
471 ((QGridLayout *) root->layout())->addWidget (infoLabel, row, column * 2 + 1);
472 }
473
474 return infoLabel;
475}
476
477
478void VBoxDiskImageManagerDlg::showEvent (QShowEvent *e)
479{
480 QMainWindow::showEvent (e);
481
482 /* one may think that QWidget::polish() is the right place to do things
483 * below, but apparently, by the time when QWidget::polish() is called,
484 * the widget style & layout are not fully done, at least the minimum
485 * size hint is not properly calculated. Since this is sometimes necessary,
486 * we provide our own "polish" implementation. */
487
488 if (polished)
489 return;
490
491 polished = true;
492
493 VBoxGlobal::centerWidget (this, parentWidget());
494}
495
496
497void VBoxDiskImageManagerDlg::mouseOnItem (QListViewItem *aItem)
498{
499 QListView *currentList = getCurrentListView();
500 QString tip;
501 switch (aItem->rtti())
502 {
503 case 1001:
504 tip = static_cast<DiskImageItem*> (aItem)->getToolTip();
505 break;
506 default:
507 Assert (0);
508 }
509 QToolTip::add (currentList->viewport(), currentList->itemRect (aItem), tip);
510}
511
512
513void VBoxDiskImageManagerDlg::resizeEvent (QResizeEvent*)
514{
515 sizeGrip->move (centralWidget()->rect().bottomRight() -
516 QPoint(sizeGrip->rect().width() - 1, sizeGrip->rect().height() - 1));
517}
518
519
520void VBoxDiskImageManagerDlg::closeEvent (QCloseEvent *aEvent)
521{
522 mModelessDialog = 0;
523 aEvent->accept();
524}
525
526
527void VBoxDiskImageManagerDlg::keyPressEvent (QKeyEvent *aEvent)
528{
529 if ( aEvent->state() == 0 ||
530 (aEvent->state() & Keypad && aEvent->key() == Key_Enter) )
531 {
532 switch ( aEvent->key() )
533 {
534 case Key_Enter:
535 case Key_Return:
536 {
537 QPushButton *currentDefault = searchDefaultButton();
538 if (currentDefault)
539 currentDefault->animateClick();
540 break;
541 }
542 case Key_Escape:
543 {
544 reject();
545 break;
546 }
547 }
548 }
549 else
550 aEvent->ignore();
551}
552
553
554QPushButton* VBoxDiskImageManagerDlg::searchDefaultButton()
555{
556 QPushButton *defButton = 0;
557 QObjectList *list = queryList ("QPushButton");
558 QObjectListIt it (*list);
559 while ( (defButton = (QPushButton*)it.current()) && !defButton->isDefault() )
560 {
561 ++it;
562 }
563 return defButton;
564}
565
566
567int VBoxDiskImageManagerDlg::result() { return mRescode; }
568void VBoxDiskImageManagerDlg::setResult (int aRescode) { mRescode = aRescode; }
569void VBoxDiskImageManagerDlg::accept() { done( Accepted ); }
570void VBoxDiskImageManagerDlg::reject() { done( Rejected ); }
571
572int VBoxDiskImageManagerDlg::exec()
573{
574 setResult (0);
575
576 if (mInLoop) return result();
577 show();
578 mInLoop = true;
579 qApp->eventLoop()->enterLoop();
580 mInLoop = false;
581
582 return result();
583}
584
585void VBoxDiskImageManagerDlg::done (int aResult)
586{
587 setResult (aResult);
588
589 if (mInLoop)
590 {
591 hide();
592 qApp->eventLoop()->exitLoop();
593 }
594 else
595 {
596 close();
597 }
598}
599
600
601QListView* VBoxDiskImageManagerDlg::getCurrentListView()
602{
603 QListView *clv = static_cast<QListView*>(twImages->currentPage()->
604 queryList("QListView")->getFirst());
605 Assert(clv);
606 return clv;
607}
608
609
610bool VBoxDiskImageManagerDlg::eventFilter (QObject *aObject, QEvent *aEvent)
611{
612 QListView *currentList = getCurrentListView();
613
614 switch (aEvent->type())
615 {
616 case QEvent::DragEnter:
617 {
618 if (aObject == currentList)
619 {
620 QDragEnterEvent *dragEnterEvent =
621 static_cast<QDragEnterEvent*>(aEvent);
622 dragEnterEvent->acceptAction();
623 return true;
624 }
625 break;
626 }
627 case QEvent::Drop:
628 {
629 if (aObject == currentList)
630 {
631 QDropEvent *dropEvent =
632 static_cast<QDropEvent*>(aEvent);
633 QStringList *droppedList = new QStringList();
634 QUriDrag::decodeLocalFiles (dropEvent, *droppedList);
635 QCustomEvent *updateEvent = new QCustomEvent (1001);
636 updateEvent->setData (droppedList);
637 QApplication::postEvent (currentList, updateEvent);
638 dropEvent->acceptAction();
639 return true;
640 }
641 break;
642 }
643 case 1001: /* QCustomEvent 1001 - DnD Update Event */
644 {
645 if (aObject == currentList)
646 {
647 QCustomEvent *updateEvent =
648 static_cast<QCustomEvent*>(aEvent);
649 addDroppedImages ((QStringList*) updateEvent->data());
650 return true;
651 }
652 break;
653 }
654 case QEvent::FocusIn:
655 {
656 if (aObject->inherits ("QPushButton") && aObject->parent() == centralWidget())
657 {
658 ((QPushButton*)aObject)->setDefault (aObject != defaultButton);
659 if (defaultButton)
660 defaultButton->setDefault (aObject == defaultButton);
661 }
662 break;
663 }
664 case QEvent::FocusOut:
665 {
666 if (aObject->inherits ("QPushButton") && aObject->parent() == centralWidget())
667 {
668 if (defaultButton)
669 defaultButton->setDefault (aObject != defaultButton);
670 ((QPushButton*)aObject)->setDefault (aObject == defaultButton);
671 }
672 break;
673 }
674 default:
675 break;
676 }
677 return QMainWindow::eventFilter (aObject, aEvent);
678}
679
680
681void VBoxDiskImageManagerDlg::addDroppedImages (QStringList *aDroppedList)
682{
683 QListView *currentList = getCurrentListView();
684
685 DiskImageItem *item = 0;
686 for (QStringList::Iterator it = (*aDroppedList).begin();
687 it != (*aDroppedList).end(); ++it)
688 {
689 // Checking dropped media type
690 VBoxDefs::DiskType type = VBoxDefs::InvalidType;
691 if ((*it).endsWith ("iso", false))
692 {
693 if (currentList == cdsView) type = VBoxDefs::CD;
694 }
695 else if ((*it).endsWith ("img", false))
696 {
697 if (currentList == fdsView) type = VBoxDefs::FD;
698 }
699 else if ((*it).endsWith ("vdi", false))
700 {
701 if (currentList == hdsView) type = VBoxDefs::HD;
702 }
703 // If media type has been determined - attach this device
704 if (type) item = addImageToList (*it, type);
705 }
706 delete aDroppedList;
707 setCurrentItem (currentList, item);
708}
709
710
711DiskImageItem* VBoxDiskImageManagerDlg::addImageToList (QString aSource, VBoxDefs::DiskType aDiskType)
712{
713 if (aSource.isEmpty())
714 return 0;
715
716 DiskImageItem *item = 0;
717 QUuid uuid;
718 switch (aDiskType)
719 {
720 case VBoxDefs::HD:
721 {
722 CVirtualDiskImage vdi = vbox.OpenVirtualDiskImage (aSource);
723 if (vbox.isOk())
724 {
725 CHardDisk hardDisk = CUnknown (vdi);
726 vbox.RegisterHardDisk (hardDisk);
727 if (vbox.isOk())
728 {
729 VBoxMedia::Status status = hardDisk.GetAccessible() ?
730 VBoxMedia::Ok : VBoxMedia::Inaccessible;
731 item = createHdItem (hdsView, 0, hardDisk, status);
732 /* synchronize modeless dialog if present */
733 if (mModelessDialog && mModelessDialog != this)
734 mModelessDialog->createHdItem (mModelessDialog->hdsView,
735 0, hardDisk, status);
736 }
737 }
738 break;
739 }
740 case VBoxDefs::CD:
741 {
742 CDVDImage dvdImage = vbox.OpenDVDImage (aSource, uuid);
743 if (vbox.isOk())
744 {
745 vbox.RegisterDVDImage (dvdImage);
746 if (vbox.isOk())
747 {
748 VBoxMedia::Status status = dvdImage.GetAccessible() ?
749 VBoxMedia::Ok : VBoxMedia::Inaccessible;
750 item = createCdItem (cdsView, 0, dvdImage, status);
751 /* synchronize modeless dialog if present */
752 if (mModelessDialog && mModelessDialog != this)
753 mModelessDialog->createCdItem (mModelessDialog->cdsView,
754 0, dvdImage, status);
755 }
756 }
757 break;
758 }
759 case VBoxDefs::FD:
760 {
761 CFloppyImage floppyImage = vbox.OpenFloppyImage (aSource, uuid);
762 if (vbox.isOk())
763 {
764 vbox.RegisterFloppyImage (floppyImage);
765 if (vbox.isOk())
766 {
767 VBoxMedia::Status status = floppyImage.GetAccessible() ?
768 VBoxMedia::Ok : VBoxMedia::Inaccessible;
769 item = createFdItem (fdsView, 0, floppyImage, status);
770 /* synchronize modeless dialog if present */
771 if (mModelessDialog && mModelessDialog != this)
772 mModelessDialog->createFdItem (mModelessDialog->fdsView,
773 0, floppyImage, status);
774 }
775 }
776 break;
777 }
778 default:
779 {
780 Assert(0);
781 }
782 }
783 return item;
784}
785
786
787DiskImageItem* VBoxDiskImageManagerDlg::createImageNode (QListView *aList,
788 DiskImageItem *aRoot,
789 QString aName,
790 QString aLabel2,
791 QString aLabel3,
792 QString aLabel4,
793 QString aLabel5,
794 QString aLabel6,
795 QString aLabel7,
796 QString aLabel8)
797{
798 DiskImageItem *item = 0;
799
800 if (aList)
801 item = new DiskImageItem (aList, aName,
802 aLabel2, aLabel3, aLabel4, aLabel5, aLabel6, aLabel7, aLabel8);
803 else if (aRoot)
804 item = new DiskImageItem (aRoot, aName,
805 aLabel2, aLabel3, aLabel4, aLabel5, aLabel6, aLabel7, aLabel8);
806 else
807 Assert(0);
808
809 return item;
810}
811
812
813void VBoxDiskImageManagerDlg::invokePopup (QListViewItem *aItem, const QPoint & aPos, int)
814{
815 if (aItem)
816 itemMenu->popup(aPos);
817}
818
819
820QString VBoxDiskImageManagerDlg::getDVDImageUsage (const QUuid &aId)
821{
822 CVirtualBox vbox = vboxGlobal().virtualBox();
823
824 QStringList permMachines =
825 QStringList::split (' ', vbox.GetDVDImageUsage (aId, CEnums::PermanentUsage));
826 QStringList tempMachines =
827 QStringList::split (' ', vbox.GetDVDImageUsage (aId, CEnums::TemporaryUsage));
828
829 QString usage;
830
831 for (QStringList::Iterator it = permMachines.begin();
832 it != permMachines.end();
833 ++it)
834 {
835 if (usage)
836 usage += ", ";
837 usage += vbox.GetMachine (QUuid (*it)).GetName();
838 }
839
840 for (QStringList::Iterator it = tempMachines.begin();
841 it != tempMachines.end();
842 ++it)
843 {
844 /* skip IDs that are in the permanent list */
845 if (!permMachines.contains (*it))
846 {
847 if (usage)
848 usage += ", [";
849 else
850 usage += "[";
851 usage += vbox.GetMachine (QUuid (*it)).GetName() + "]";
852 }
853 }
854
855 return usage;
856}
857
858QString VBoxDiskImageManagerDlg::getFloppyImageUsage (const QUuid &aId)
859{
860 CVirtualBox vbox = vboxGlobal().virtualBox();
861
862 QStringList permMachines =
863 QStringList::split (' ', vbox.GetFloppyImageUsage (aId, CEnums::PermanentUsage));
864 QStringList tempMachines =
865 QStringList::split (' ', vbox.GetFloppyImageUsage (aId, CEnums::TemporaryUsage));
866
867 QString usage;
868
869 for (QStringList::Iterator it = permMachines.begin();
870 it != permMachines.end();
871 ++it)
872 {
873 if (usage)
874 usage += ", ";
875 usage += vbox.GetMachine (QUuid (*it)).GetName();
876 }
877
878 for (QStringList::Iterator it = tempMachines.begin();
879 it != tempMachines.end();
880 ++it)
881 {
882 /* skip IDs that are in the permanent list */
883 if (!permMachines.contains (*it))
884 {
885 if (usage)
886 usage += ", [";
887 else
888 usage += "[";
889 usage += vbox.GetMachine (QUuid (*it)).GetName() + "]";
890 }
891 }
892
893 return usage;
894}
895
896
897QString VBoxDiskImageManagerDlg::composeHdToolTip (CHardDisk &aHd,
898 VBoxMedia::Status aStatus)
899{
900 CVirtualBox vbox = vboxGlobal().virtualBox();
901 QUuid machineId = aHd.GetMachineId();
902
903 QString src = aHd.GetLocation();
904 QFileInfo fi (src);
905 QString location = aHd.GetStorageType() == CEnums::ISCSIHardDisk ? src :
906 QDir::convertSeparators (fi.absFilePath());
907
908 QString storageType = vboxGlobal().toString (aHd.GetStorageType());
909 QString hardDiskType = vboxGlobal().hardDiskTypeString (aHd);
910
911 QString usage;
912 if (!machineId.isNull())
913 usage = vbox.GetMachine (machineId).GetName();
914
915 QString snapshotName;
916 if (!machineId.isNull() && !aHd.GetSnapshotId().isNull())
917 {
918 CSnapshot snapshot = vbox.GetMachine (machineId).
919 GetSnapshot (aHd.GetSnapshotId());
920 if (!snapshot.isNull())
921 snapshotName = snapshot.GetName();
922 }
923
924 /* compose tool-tip information */
925 QString tip;
926 switch (aStatus)
927 {
928 case VBoxMedia::Unknown:
929 {
930 tip = tr ("<nobr><b>%1</b></nobr><br>"
931 "Checking accessibility...", "HDD")
932 .arg (location);
933 break;
934 }
935 case VBoxMedia::Ok:
936 {
937 tip = tr ("<nobr><b>%1</b></nobr><br>"
938 "<nobr>Disk type:&nbsp;&nbsp;%2</nobr><br>"
939 "<nobr>Storage type:&nbsp;&nbsp;%3</nobr>")
940 .arg (location)
941 .arg (hardDiskType)
942 .arg (storageType);
943
944 if (!usage.isNull())
945 tip += tr ("<br><nobr>Attached to:&nbsp;&nbsp;%1</nobr>", "HDD")
946 .arg (usage);
947 if (!snapshotName.isNull())
948 tip += tr ("<br><nobr>Snapshot:&nbsp;&nbsp;%5</nobr>", "HDD")
949 .arg (snapshotName);
950 break;
951 }
952 case VBoxMedia::Error:
953 {
954 /// @todo (r=dmik) paass a complete VBoxMedia instance here
955 // to get the result of blabla.GetAccessible() call form CUnknown
956 tip = tr ("<nobr><b>%1</b></nobr><br>"
957 "Error checking media accessibility", "HDD")
958 .arg (location);
959 break;
960 }
961 case VBoxMedia::Inaccessible:
962 {
963 tip = tr ("<nobr><b>%1</b></nobr><br>%2", "HDD")
964 .arg (location)
965 .arg (aHd.GetLastAccessError());
966 break;
967 }
968 default:
969 AssertFailed();
970 }
971 return tip;
972}
973
974QString VBoxDiskImageManagerDlg::composeCdToolTip (CDVDImage &aCd,
975 VBoxMedia::Status aStatus)
976{
977 QString src = aCd.GetFilePath();
978 QFileInfo fi (src);
979 QString location = QDir::convertSeparators (fi.absFilePath ());
980 QUuid uuid = aCd.GetId();
981 QString usage = getDVDImageUsage (uuid);
982
983 /* compose tool-tip information */
984 QString tip;
985 switch (aStatus)
986 {
987 case VBoxMedia::Unknown:
988 {
989 tip = tr ("<nobr><b>%1</b></nobr><br>"
990 "Checking accessibility...", "CD/DVD/Floppy")
991 .arg (location);
992 break;
993 }
994 case VBoxMedia::Ok:
995 {
996 tip = tr ("<nobr><b>%1</b></nobr>", "CD/DVD/Floppy")
997 .arg (location);
998
999 if (!usage.isNull())
1000 tip += tr ("<br><nobr>Attached to:&nbsp;&nbsp;%1</nobr>",
1001 "CD/DVD/Floppy")
1002 .arg (usage);
1003 break;
1004 }
1005 case VBoxMedia::Error:
1006 {
1007 /// @todo (r=dmik) paass a complete VBoxMedia instance here
1008 // to get the result of blabla.GetAccessible() call form CUnknown
1009 tip = tr ("<nobr><b>%1</b></nobr><br>"
1010 "Error checking media accessibility", "CD/DVD/Floppy")
1011 .arg (location);
1012 break;
1013 }
1014 case VBoxMedia::Inaccessible:
1015 {
1016 /// @todo (r=dmik) correct this when GetLastAccessError() is
1017 // implemented for IDVDImage
1018 tip = tr ("<nobr><b>%1</b></nobr><br>%2")
1019 .arg (location)
1020 .arg (tr ("The image file is not accessible",
1021 "CD/DVD/Floppy"));
1022 break;
1023 }
1024 default:
1025 AssertFailed();
1026 }
1027 return tip;
1028}
1029
1030QString VBoxDiskImageManagerDlg::composeFdToolTip (CFloppyImage &aFd,
1031 VBoxMedia::Status aStatus)
1032{
1033 QString src = aFd.GetFilePath();
1034 QFileInfo fi (src);
1035 QString location = QDir::convertSeparators (fi.absFilePath ());
1036 QUuid uuid = aFd.GetId();
1037 QString usage = getFloppyImageUsage (uuid);
1038
1039 /* compose tool-tip information */
1040 /* compose tool-tip information */
1041 QString tip;
1042 switch (aStatus)
1043 {
1044 case VBoxMedia::Unknown:
1045 {
1046 tip = tr ("<nobr><b>%1</b></nobr><br>"
1047 "Checking accessibility...", "CD/DVD/Floppy")
1048 .arg (location);
1049 break;
1050 }
1051 case VBoxMedia::Ok:
1052 {
1053 tip = tr ("<nobr><b>%1</b></nobr>", "CD/DVD/Floppy")
1054 .arg (location);
1055
1056 if (!usage.isNull())
1057 tip += tr ("<br><nobr>Attached to:&nbsp;&nbsp;%1</nobr>",
1058 "CD/DVD/Floppy")
1059 .arg (usage);
1060 break;
1061 }
1062 case VBoxMedia::Error:
1063 {
1064 /// @todo (r=dmik) paass a complete VBoxMedia instance here
1065 // to get the result of blabla.GetAccessible() call form CUnknown
1066 tip = tr ("<nobr><b>%1</b></nobr><br>"
1067 "Error checking media accessibility", "CD/DVD/Floppy")
1068 .arg (location);
1069 break;
1070 }
1071 case VBoxMedia::Inaccessible:
1072 {
1073 /// @todo (r=dmik) correct this when GetLastAccessError() is
1074 // implemented for IDVDImage
1075 tip = tr ("<nobr><b>%1</b></nobr><br>%2")
1076 .arg (location)
1077 .arg (tr ("The image file is not accessible",
1078 "CD/DVD/Floppy"));
1079 break;
1080 }
1081 default:
1082 AssertFailed();
1083 }
1084 return tip;
1085}
1086
1087
1088DiskImageItem* VBoxDiskImageManagerDlg::createHdItem (QListView *aList,
1089 DiskImageItem *aRoot,
1090 CHardDisk &aHd,
1091 VBoxMedia::Status aStatus)
1092{
1093 DiskImageItem *item = 0;
1094
1095 QUuid uuid = aHd.GetId();
1096 QString src = aHd.GetLocation();
1097 QUuid machineId = aHd.GetMachineId();
1098
1099 QString usage;
1100 if (!machineId.isNull())
1101 usage = vbox.GetMachine (machineId).GetName();
1102 QString storageType = vboxGlobal().toString (aHd.GetStorageType());
1103 QString hardDiskType = vboxGlobal().hardDiskTypeString (aHd);
1104 QString virtualSize = aStatus == VBoxMedia::Ok ?
1105 vboxGlobal().formatSize ((ULONG64)aHd.GetSize() * _1M) : QString ("--");
1106 QString actualSize = aStatus == VBoxMedia::Ok ?
1107 vboxGlobal().formatSize (aHd.GetActualSize()) : QString ("--");
1108 QString snapshotName;
1109 if (!machineId.isNull() && !aHd.GetSnapshotId().isNull())
1110 {
1111 CSnapshot snapshot = vbox.GetMachine (machineId).
1112 GetSnapshot (aHd.GetSnapshotId());
1113 if (!snapshot.isNull())
1114 snapshotName = QString ("%1").arg (snapshot.GetName());
1115 }
1116 QFileInfo fi (src);
1117
1118 item = createImageNode (aList, aRoot,
1119 fi.fileName(),
1120 virtualSize,
1121 actualSize);
1122 item->setPath (aHd.GetStorageType() == CEnums::ISCSIHardDisk ? src :
1123 QDir::convertSeparators (fi.absFilePath()));
1124 item->setUsage (usage);
1125 item->setSnapshotName (snapshotName);
1126 item->setDiskType (hardDiskType);
1127 item->setStorageType (storageType);
1128 item->setVirtualSize (virtualSize);
1129 item->setActualSize (actualSize);
1130 item->setUuid (uuid);
1131 item->setMachineId (machineId);
1132 item->setToolTip (composeHdToolTip (aHd, aStatus));
1133 item->setStatus (aStatus);
1134
1135 return item;
1136}
1137
1138
1139DiskImageItem* VBoxDiskImageManagerDlg::createCdItem (QListView *aList,
1140 DiskImageItem *aRoot,
1141 CDVDImage &aCd,
1142 VBoxMedia::Status aStatus)
1143{
1144 DiskImageItem *item = 0;
1145
1146 QUuid uuid = aCd.GetId();
1147 QString src = aCd.GetFilePath();
1148 QString usage = getDVDImageUsage (uuid);
1149
1150 QString size = aStatus == VBoxMedia::Ok ?
1151 vboxGlobal().formatSize (aCd.GetSize()) : QString ("--");
1152 QFileInfo fi (src);
1153
1154 item = createImageNode (aList, aRoot,
1155 fi.fileName(),
1156 size);
1157 item->setPath (QDir::convertSeparators (fi.absFilePath ()));
1158 item->setUsage (usage);
1159 item->setActualSize (size);
1160 item->setUuid (uuid);
1161 item->setToolTip (composeCdToolTip (aCd, aStatus));
1162 item->setStatus (aStatus);
1163
1164 return item;
1165}
1166
1167
1168DiskImageItem* VBoxDiskImageManagerDlg::createFdItem (QListView *aList,
1169 DiskImageItem *aRoot,
1170 CFloppyImage &aFd,
1171 VBoxMedia::Status aStatus)
1172{
1173 DiskImageItem *item = 0;
1174
1175 QUuid uuid = aFd.GetId();
1176 QString src = aFd.GetFilePath();
1177 QString usage = getFloppyImageUsage (uuid);
1178
1179 QString size = aStatus == VBoxMedia::Ok ?
1180 vboxGlobal().formatSize (aFd.GetSize()) : QString ("--");
1181 QFileInfo fi (src);
1182
1183 item = createImageNode (aList, aRoot,
1184 fi.fileName(),
1185 size);
1186 item->setPath (QDir::convertSeparators (fi.absFilePath ()));
1187 item->setUsage (usage);
1188 item->setActualSize (size);
1189 item->setUuid (uuid);
1190 item->setToolTip (composeFdToolTip (aFd, aStatus));
1191 item->setStatus (aStatus);
1192
1193 return item;
1194}
1195
1196
1197void VBoxDiskImageManagerDlg::createHdChildren (DiskImageItem *aRoot,
1198 CHardDisk &aHd,
1199 VBoxMedia::Status aStatus)
1200{
1201 CHardDiskEnumerator enumerator = aHd.GetChildren().Enumerate();
1202 while (enumerator.HasMore())
1203 {
1204 CHardDisk subHd = enumerator.GetNext();
1205 DiskImageItem *subItem = createHdItem (0, aRoot, subHd, aStatus);
1206 createHdChildren (subItem, subHd, aStatus);
1207 }
1208}
1209
1210
1211DiskImageItem* VBoxDiskImageManagerDlg::searchItem (QListView *aList, QUuid aId)
1212{
1213 DiskImageItem *item = 0, *iterator = 0;
1214 if (aList->firstChild() && aList->firstChild()->rtti() == 1001)
1215 iterator = static_cast<DiskImageItem*>(aList->firstChild());
1216 while (iterator)
1217 {
1218 if (iterator->getUuid() == aId)
1219 item = iterator;
1220 iterator = iterator->nextSibling();
1221 }
1222 return item;
1223}
1224
1225
1226void VBoxDiskImageManagerDlg::updateMedia (const VBoxMedia &aMedia)
1227{
1228 /* ignore non-updated aMedia */
1229 if (!(type & aMedia.type))
1230 return;
1231
1232 /* search for updated listview item */
1233 DiskImageItem *item = 0;
1234 switch (aMedia.type)
1235 {
1236 case VBoxDefs::HD:
1237 {
1238 CHardDisk hd = aMedia.disk;
1239 item = searchItem (hdsView, hd.GetId());
1240 delete item;
1241 item = createHdItem (hdsView, 0, hd, aMedia.status);
1242 createHdChildren (item, hd, aMedia.status);
1243 break;
1244 }
1245 case VBoxDefs::CD:
1246 {
1247 CDVDImage cd = aMedia.disk;
1248 item = searchItem (cdsView, cd.GetId());
1249 delete item;
1250 item = createCdItem (cdsView, 0, cd, aMedia.status);
1251 break;
1252 }
1253 case VBoxDefs::FD:
1254 {
1255 CFloppyImage fd = aMedia.disk;
1256 item = searchItem (fdsView, fd.GetId());
1257 delete item;
1258 item = createFdItem (fdsView, 0, fd, aMedia.status);
1259 break;
1260 }
1261 default:
1262 {
1263 AssertMsgFailed (("Invalid aMedia type\n"));
1264 break;
1265 }
1266 }
1267
1268 if (aMedia.status == VBoxMedia::Inaccessible)
1269 item->setPixmap (0, pxInaccessible);
1270 else if (aMedia.status == VBoxMedia::Error)
1271 item->setPixmap (0, pxErroneous);
1272
1273 mProgressBar->setProgress (mProgressBar->progress() + 1);
1274}
1275
1276
1277void VBoxDiskImageManagerDlg::setup (int aType, bool aDoSelect,
1278 const QUuid *aTargetVMId,
1279 const VBoxMediaList *mediaList,
1280 CMachine machine)
1281{
1282 cmachine = machine;
1283
1284 type = aType;
1285 twImages->setTabEnabled (twImages->page(0), type & VBoxDefs::HD);
1286 twImages->setTabEnabled (twImages->page(1), type & VBoxDefs::CD);
1287 twImages->setTabEnabled (twImages->page(2), type & VBoxDefs::FD);
1288
1289 doSelect = aDoSelect;
1290 if (aTargetVMId)
1291 targetVMId = aTargetVMId->toString();
1292
1293 if (doSelect)
1294 buttonOk->setText (tr ("&Select"));
1295 else
1296 buttonCancel->setShown (false);
1297
1298 /* listen to "media enumeration" signals */
1299 connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMedia &)),
1300 this, SLOT (mediaEnumerated (const VBoxMedia &)));
1301 /* listen to "media enumeration finished" signals */
1302 connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMediaList &)),
1303 this, SLOT (mediaEnumerated (const VBoxMediaList &)));
1304
1305 /* insert already enumerated media */
1306 VBoxMediaList list;
1307 if (mediaList)
1308 list = *mediaList;
1309 else
1310 list = vboxGlobal().currentMediaList();
1311
1312 VBoxMediaList::const_iterator it;
1313 prepareToRefresh();
1314 for (it = list.begin(); it != list.end(); ++ it)
1315 updateMedia (*it);
1316
1317 if (mediaList)
1318 {
1319 mediaEnumerated (*mediaList);
1320 }
1321 else
1322 {
1323 /* only start enumerating media if we haven't been supplied with a list
1324 * (it's ok if the enumeration has been already started, nothing will
1325 * happen) */
1326 vboxGlobal().startEnumeratingMedia();
1327 }
1328}
1329
1330
1331void VBoxDiskImageManagerDlg::mediaEnumerated (const VBoxMedia &aMedia)
1332{
1333 if (!mToBeRefreshed) return;
1334 updateMedia (aMedia);
1335 processCurrentChanged();
1336}
1337
1338
1339void VBoxDiskImageManagerDlg::mediaEnumerated (const VBoxMediaList & /*aList*/)
1340{
1341 if (!mToBeRefreshed) return;
1342
1343 mProgressBar->setHidden (true);
1344 mProgressText->setHidden (true);
1345
1346 imRefreshAction->setEnabled (true);
1347 unsetCursor();
1348
1349 mToBeRefreshed = false;
1350}
1351
1352
1353void VBoxDiskImageManagerDlg::machineStateChanged (const VBoxMachineStateChangeEvent &e)
1354{
1355 /// @todo (r=dmik) IVirtualBoxCallback::OnMachineStateChange
1356 // must also expose the old state! In this case we won't need to cache
1357 // the state value in every class in GUI that uses this signal.
1358
1359 switch (e.state)
1360 {
1361 case CEnums::PoweredOff:
1362 case CEnums::Aborted:
1363 case CEnums::Saved:
1364 case CEnums::Starting:
1365 case CEnums::Restoring:
1366 {
1367 refreshAll();
1368 break;
1369 }
1370 default:
1371 break;
1372 }
1373}
1374
1375
1376void VBoxDiskImageManagerDlg::prepareToRefresh()
1377{
1378 if (mToBeRefreshed) return;
1379 mToBeRefreshed = true;
1380
1381 /* info panel clearing */
1382 hdsPane1->clear();
1383 hdsPane2->clear(), hdsPane3->clear();
1384 hdsPane4->clear(), hdsPane5->clear();
1385 cdsPane1->clear(), cdsPane2->clear();
1386 fdsPane1->clear(), fdsPane2->clear();
1387
1388 /* prepare progressbar */
1389 if (mProgressBar)
1390 {
1391 int totalSteps = 0;
1392 if (type & VBoxDefs::HD)
1393 totalSteps += vbox.GetHardDisks().GetCount();
1394 if (type & VBoxDefs::CD)
1395 totalSteps += vbox.GetDVDImages().GetCount();
1396 if (type & VBoxDefs::FD)
1397 totalSteps += vbox.GetFloppyImages().GetCount();
1398 mProgressBar->setProgress (0, totalSteps);
1399 mProgressBar->setHidden (false);
1400 mProgressText->setHidden (false);
1401 }
1402
1403 imRefreshAction->setEnabled (false);
1404 setCursor (QCursor (BusyCursor));
1405}
1406
1407
1408void VBoxDiskImageManagerDlg::refreshAll()
1409{
1410 if (mToBeRefreshed) return;
1411 prepareToRefresh();
1412 /* lists clearing */
1413 hdsView->clear(), cdsView->clear(), fdsView->clear();
1414 /* load all lists */
1415 loadListViews();
1416 /* start enumerating media */
1417 vboxGlobal().startEnumeratingMedia();
1418}
1419
1420
1421bool VBoxDiskImageManagerDlg::checkImage (DiskImageItem* aItem)
1422{
1423 QUuid itemId = aItem ? QUuid (aItem->getUuid()) : QUuid();
1424 if (itemId.isNull()) return false;
1425
1426 QListView* parentList = aItem->listView();
1427 if (parentList == hdsView)
1428 {
1429 QUuid machineId = vbox.GetHardDisk (itemId).GetMachineId();
1430 if (machineId.isNull() ||
1431 vbox.GetMachine (machineId).GetState() != CEnums::PoweredOff &&
1432 vbox.GetMachine (machineId).GetState() != CEnums::Aborted)
1433 return false;
1434 }
1435 else if (parentList == cdsView)
1436 {
1437 QString usage = getDVDImageUsage (itemId);
1438 /* check if there is temporary usage: */
1439 QStringList tempMachines =
1440 QStringList::split (' ', vbox.GetDVDImageUsage (itemId,
1441 CEnums::TemporaryUsage));
1442 if (!tempMachines.isEmpty())
1443 return false;
1444 /* only permamently mounted .iso could be released */
1445 QStringList permMachines =
1446 QStringList::split (' ', vbox.GetDVDImageUsage (itemId,
1447 CEnums::PermanentUsage));
1448 for (QStringList::Iterator it = permMachines.begin();
1449 it != permMachines.end(); ++it)
1450 if (vbox.GetMachine(QUuid (*it)).GetState() != CEnums::PoweredOff &&
1451 vbox.GetMachine(QUuid (*it)).GetState() != CEnums::Aborted)
1452 return false;
1453 }
1454 else if (parentList == fdsView)
1455 {
1456 QString usage = getFloppyImageUsage(itemId);
1457 /* check if there is temporary usage: */
1458 QStringList tempMachines =
1459 QStringList::split (' ', vbox.GetFloppyImageUsage (itemId,
1460 CEnums::TemporaryUsage));
1461 if (!tempMachines.isEmpty())
1462 return false;
1463 /* only permamently mounted .iso could be released */
1464 QStringList permMachines =
1465 QStringList::split (' ', vbox.GetFloppyImageUsage (itemId,
1466 CEnums::PermanentUsage));
1467 for (QStringList::Iterator it = permMachines.begin();
1468 it != permMachines.end(); ++it)
1469 if (vbox.GetMachine(QUuid (*it)).GetState() != CEnums::PoweredOff &&
1470 vbox.GetMachine(QUuid (*it)).GetState() != CEnums::Aborted)
1471 return false;
1472 }
1473 else
1474 {
1475 return false;
1476 }
1477 return true;
1478}
1479
1480
1481void VBoxDiskImageManagerDlg::setCurrentItem (QListView *aListView, QListViewItem *aItem)
1482{
1483 aListView->setFocus();
1484 if (aItem)
1485 {
1486 aListView->setCurrentItem (aItem);
1487 aListView->setSelected (aListView->currentItem(), true);
1488 /* it is strange repeat but it works */
1489 aListView->adjustColumn (1);
1490 aListView->adjustColumn (2);
1491 aListView->adjustColumn (1);
1492 }
1493 processCurrentChanged (aListView->currentItem());
1494}
1495
1496
1497void VBoxDiskImageManagerDlg::processCurrentChanged()
1498{
1499 QListView *currentList = getCurrentListView();
1500 currentList->setFocus();
1501
1502 QListViewItem *itemToSelect =
1503 !currentList->isSelected (currentList->currentItem()) ?
1504 currentList->firstChild() : currentList->currentItem();
1505 setCurrentItem (currentList, itemToSelect);
1506
1507 /* tab stop setup */
1508 setTabOrder (hdsView, hdsPane1);
1509 setTabOrder (hdsPane1, hdsPane2);
1510 setTabOrder (hdsPane2, hdsPane3);
1511 setTabOrder (hdsPane3, hdsPane4);
1512 setTabOrder (hdsPane4, hdsPane5);
1513 setTabOrder (hdsPane5, buttonHelp);
1514
1515 setTabOrder (cdsView, cdsPane1);
1516 setTabOrder (cdsPane1, cdsPane2);
1517 setTabOrder (cdsPane2, buttonHelp);
1518
1519 setTabOrder (fdsView, fdsPane1);
1520 setTabOrder (fdsPane1, fdsPane2);
1521 setTabOrder (fdsPane2, buttonHelp);
1522
1523 setTabOrder (buttonHelp, buttonOk);
1524 setTabOrder (buttonOk, twImages);
1525}
1526
1527void VBoxDiskImageManagerDlg::processCurrentChanged (QListViewItem *aItem)
1528{
1529 DiskImageItem *item = aItem && aItem->rtti() == 1001 ?
1530 static_cast<DiskImageItem*> (aItem) : 0;
1531
1532 bool modifyEnabled = item && item->getUsage().isNull() &&
1533 !item->firstChild() && !item->getPath().isNull();
1534 bool releaseEnabled = item && !item->getUsage().isNull() &&
1535 checkImage (item) &&
1536 !item->parent() && !item->firstChild() &&
1537 item->getSnapshotName().isNull();
1538 bool newEnabled = getCurrentListView() == hdsView ? true : false;
1539
1540 // imEditAction->setEnabled (modifyEnabled);
1541 imRemoveAction->setEnabled (modifyEnabled);
1542 imReleaseAction->setEnabled (releaseEnabled);
1543 imNewAction->setEnabled (newEnabled);
1544
1545 // itemMenu->setItemVisible (itemMenu->idAt(0), modifyEnabled);
1546 itemMenu->setItemEnabled (itemMenu->idAt(0), modifyEnabled);
1547 itemMenu->setItemEnabled (itemMenu->idAt(1), releaseEnabled);
1548
1549 if (doSelect)
1550 {
1551 bool selectEnabled = item && !item->parent() &&
1552 (!newEnabled ||
1553 (item->getUsage().isNull() ||
1554 item->getMachineId() == targetVMId));
1555
1556 buttonOk->setEnabled (selectEnabled);
1557 }
1558
1559 if (item)
1560 {
1561 if (getCurrentListView() == hdsView)
1562 {
1563 hdsPane1->setText (item->getInformation (item->getPath(), true, "end"));
1564 hdsPane2->setText (item->getInformation (item->getDiskType(), false));
1565 hdsPane3->setText (item->getInformation (item->getStorageType(), false));
1566 hdsPane4->setText (item->getInformation (item->getUsage()));
1567 hdsPane5->setText (item->getInformation (item->getSnapshotName()));
1568 }
1569 else if (getCurrentListView() == cdsView)
1570 {
1571 cdsPane1->setText (item->getInformation (item->getPath(), true, "end"));
1572 cdsPane2->setText (item->getInformation (item->getUsage()));
1573 }
1574 else if (getCurrentListView() == fdsView)
1575 {
1576 fdsPane1->setText (item->getInformation (item->getPath(), true, "end"));
1577 fdsPane2->setText (item->getInformation (item->getUsage()));
1578 }
1579 }
1580}
1581
1582
1583void VBoxDiskImageManagerDlg::processPressed (QListViewItem * aItem)
1584{
1585 if (!aItem)
1586 {
1587 QListView *currentList = getCurrentListView();
1588 currentList->setSelected (currentList->currentItem(), true);
1589 }
1590 processCurrentChanged();
1591}
1592
1593
1594void VBoxDiskImageManagerDlg::newImage()
1595{
1596 AssertReturnVoid (getCurrentListView() == hdsView);
1597
1598 VBoxNewHDWzd dlg (this, "VBoxNewHDWzd");
1599
1600 if (dlg.exec() == QDialog::Accepted)
1601 {
1602 CHardDisk hd = dlg.hardDisk();
1603 VBoxMedia::Status status = hd.GetAccessible() ?
1604 VBoxMedia::Ok : VBoxMedia::Inaccessible;
1605 DiskImageItem *createdItem = createHdItem (hdsView, 0, hd, status);
1606 setCurrentItem (hdsView, createdItem);
1607 /* synchronize modeless dialog if present */
1608 if (mModelessDialog && mModelessDialog != this)
1609 mModelessDialog->createHdItem (mModelessDialog->hdsView,
1610 0, hd, status);
1611 }
1612}
1613
1614
1615void VBoxDiskImageManagerDlg::addImage()
1616{
1617 QListView *currentList = getCurrentListView();
1618 DiskImageItem *item =
1619 currentList->currentItem() && currentList->currentItem()->rtti() == 1001 ?
1620 static_cast<DiskImageItem*> (currentList->currentItem()) : 0;
1621
1622 QString dir;
1623 if (item && item->getStatus() == VBoxMedia::Ok)
1624 dir = item->getPath().stripWhiteSpace();
1625
1626 if (!dir)
1627 if (currentList == hdsView)
1628 dir = vbox.GetSystemProperties().GetDefaultVDIFolder();
1629 if (!dir || !QFileInfo (dir).exists())
1630 dir = vbox.GetHomeFolder();
1631
1632 QString title;
1633 QString filter;
1634 VBoxDefs::DiskType type = VBoxDefs::InvalidType;
1635
1636 if (currentList == hdsView) {
1637 filter = tr( "Hard disk images (*.vdi)" );
1638 title = tr( "Select a hard disk image file" );
1639 type = VBoxDefs::HD;
1640 } else if (currentList == cdsView) {
1641 filter = tr( "CDROM images (*.iso)" );
1642 title = tr( "Select a DVD/CD-ROM disk image file" );
1643 type = VBoxDefs::CD;
1644 } else if (currentList == fdsView) {
1645 filter = tr( "Floppy images (*.img)" );
1646 title = tr( "Select a floppy disk image file" );
1647 type = VBoxDefs::FD;
1648 } else {
1649 AssertMsgFailed (("Root list should be equal to hdsView, cdsView or fdsView"));
1650 }
1651
1652 QString src = QFileDialog::getOpenFileName (dir, filter,
1653 this, "AddDiskImageDialog",
1654 title);
1655
1656 DiskImageItem *createdItem = addImageToList (src, type);
1657 setCurrentItem (currentList, createdItem);
1658
1659 if (!vbox.isOk())
1660 {
1661 vboxProblem().cannotRegisterMedia (this, vbox, type, src);
1662 }
1663}
1664
1665
1666void VBoxDiskImageManagerDlg::removeImage()
1667{
1668 QListView *currentList = getCurrentListView();
1669 DiskImageItem *item =
1670 currentList->currentItem() && currentList->currentItem()->rtti() == 1001 ?
1671 static_cast<DiskImageItem*> (currentList->currentItem()) : 0;
1672 AssertMsg (item, ("Current item must not be null"));
1673 QString removedItemName = item->getName();
1674
1675 QString src = item->getPath().stripWhiteSpace();
1676 QUuid uuid = QUuid (item->getUuid());
1677 VBoxDefs::DiskType type = VBoxDefs::InvalidType;
1678
1679 if (currentList == hdsView)
1680 {
1681 type = VBoxDefs::HD;
1682 int deleteImage;
1683 if (vbox.GetHardDisk (uuid).GetStorageType() == CEnums::VirtualDiskImage &&
1684 item->getStatus() == VBoxMedia::Ok)
1685 {
1686 deleteImage = vboxProblem().confirmHardDiskImageDeletion (this, src);
1687 }
1688 else
1689 {
1690 deleteImage = vboxProblem().confirmHardDiskUnregister (this, src);
1691 }
1692 if (deleteImage == QIMessageBox::Cancel)
1693 return;
1694 CHardDisk hd = vbox.UnregisterHardDisk (uuid);
1695 if (vbox.isOk() && deleteImage == QIMessageBox::Yes)
1696 {
1697 /// @todo (dmik) later, change wrappers so that converting
1698 // to CUnknown is not necessary for cross-assignments
1699 CVirtualDiskImage vdi = CUnknown (hd);
1700 if (vdi.isOk())
1701 vdi.DeleteImage();
1702 if (!vdi.isOk())
1703 vboxProblem().cannotDeleteHardDiskImage (this, vdi);
1704 }
1705 }
1706 else if (currentList == cdsView)
1707 {
1708 type = VBoxDefs::CD;
1709 vbox.UnregisterDVDImage (uuid);
1710 }
1711 else if (currentList == fdsView)
1712 {
1713 type = VBoxDefs::FD;
1714 vbox.UnregisterFloppyImage (uuid);
1715 }
1716
1717 if (!vbox.isOk())
1718 {
1719 vboxProblem().cannotUnregisterMedia (this, vbox, type, src);
1720 }
1721 else
1722 {
1723 delete item;
1724 setCurrentItem (currentList, currentList->currentItem());
1725 /* synchronize modeless dialog if present */
1726 if (mModelessDialog && mModelessDialog != this)
1727 {
1728 DiskImageItem *itemToRemove = 0;
1729 QListView *modelessView = 0;
1730 if (currentList == hdsView)
1731 modelessView = mModelessDialog->hdsView;
1732 else if (currentList == cdsView)
1733 modelessView = mModelessDialog->cdsView;
1734 else if (currentList == fdsView)
1735 modelessView = mModelessDialog->fdsView;
1736 itemToRemove = static_cast<DiskImageItem*>
1737 (modelessView->findItem (removedItemName, 0));
1738 delete itemToRemove;
1739 if (modelessView->currentItem())
1740 modelessView->setSelected (modelessView->currentItem(), true);
1741 mModelessDialog->processCurrentChanged();
1742 }
1743 }
1744}
1745
1746
1747void VBoxDiskImageManagerDlg::releaseImage()
1748{
1749 QListView *currentList = getCurrentListView();
1750 DiskImageItem *item =
1751 currentList->currentItem() && currentList->currentItem()->rtti() == 1001 ?
1752 static_cast<DiskImageItem*> (currentList->currentItem()) : 0;
1753 AssertMsg (item, ("Current item must not be null"));
1754 QString releasedItemName = item->getName();
1755 QString usageAfterRelease;
1756
1757 QUuid itemId = QUuid (item->getUuid());
1758 AssertMsg (!itemId.isNull(), ("Current item must have uuid"));
1759
1760 QUuid machineId;
1761 /* if it is a hard disk sub-item: */
1762 if (currentList == hdsView)
1763 {
1764 machineId = vbox.GetHardDisk (itemId).GetMachineId();
1765 if (vboxProblem().confirmReleaseImage (this,
1766 vbox.GetMachine(machineId).GetName()))
1767 {
1768 releaseDisk (machineId, itemId, VBoxDefs::HD);
1769
1770 /* re-request current usage */
1771 machineId = vbox.GetHardDisk (itemId).GetMachineId();
1772 usageAfterRelease = machineId.isNull() ? QString::null :
1773 vbox.GetMachine (machineId).GetName();
1774 item->setUsage (usageAfterRelease);
1775 }
1776 }
1777 /* if it is a cd/dvd sub-item: */
1778 else if (currentList == cdsView)
1779 {
1780 QString usage = getDVDImageUsage (itemId);
1781 /* only permamently mounted .iso could be released */
1782 if (vboxProblem().confirmReleaseImage (this, usage))
1783 {
1784 QStringList permMachines =
1785 QStringList::split (' ', vbox.GetDVDImageUsage (itemId,
1786 CEnums::PermanentUsage));
1787 for (QStringList::Iterator it = permMachines.begin();
1788 it != permMachines.end(); ++it)
1789 releaseDisk (QUuid (*it), itemId, VBoxDefs::CD);
1790
1791 /* re-request current usage */
1792 usageAfterRelease = getDVDImageUsage (itemId);
1793 item->setUsage (usageAfterRelease);
1794 }
1795 }
1796 /* if it is a floppy sub-item: */
1797 else if (currentList == fdsView)
1798 {
1799 QString usage = getFloppyImageUsage (itemId);
1800 /* only permamently mounted .img could be released */
1801 if (vboxProblem().confirmReleaseImage (this, usage))
1802 {
1803 QStringList permMachines =
1804 QStringList::split (' ', vbox.GetFloppyImageUsage (itemId,
1805 CEnums::PermanentUsage));
1806 for (QStringList::Iterator it = permMachines.begin();
1807 it != permMachines.end(); ++it)
1808 releaseDisk (QUuid (*it), itemId, VBoxDefs::FD);
1809
1810 /* re-request current usage */
1811 usageAfterRelease = getFloppyImageUsage (itemId);
1812 item->setUsage (usageAfterRelease);
1813 }
1814 }
1815 processCurrentChanged (item);
1816
1817 /* processing modeless dialog */
1818 if (mModelessDialog && mModelessDialog != this)
1819 {
1820 DiskImageItem *itemToRelease = 0;
1821 QListView *modelessView = 0;
1822 if (currentList == hdsView)
1823 modelessView = mModelessDialog->hdsView;
1824 else if (currentList == cdsView)
1825 modelessView = mModelessDialog->cdsView;
1826 else if (currentList == fdsView)
1827 modelessView = mModelessDialog->fdsView;
1828 itemToRelease = static_cast<DiskImageItem*>
1829 (modelessView->findItem (releasedItemName, 0));
1830 itemToRelease->setUsage (usageAfterRelease);
1831 mModelessDialog->processCurrentChanged();
1832 }
1833}
1834
1835
1836void VBoxDiskImageManagerDlg::releaseDisk (QUuid aMachineId,
1837 QUuid aItemId,
1838 VBoxDefs::DiskType aDiskType)
1839{
1840 CSession session;
1841 CMachine machine;
1842 /* is this media image mapped to this VM: */
1843 if (!cmachine.isNull() && cmachine.GetId() == aMachineId)
1844 {
1845 machine = cmachine;
1846 }
1847 /* or some other: */
1848 else
1849 {
1850 session = vboxGlobal().openSession (aMachineId);
1851 if (session.isNull()) return;
1852 machine = session.GetMachine();
1853 }
1854 /* perform disk releasing: */
1855 switch (aDiskType)
1856 {
1857 case VBoxDefs::HD:
1858 {
1859 /* releasing hd: */
1860 CHardDiskAttachmentEnumerator en =
1861 machine.GetHardDiskAttachments().Enumerate();
1862 while (en.HasMore())
1863 {
1864 CHardDiskAttachment hda = en.GetNext();
1865 if (hda.GetHardDisk().GetId() == aItemId)
1866 {
1867 machine.DetachHardDisk (hda.GetController(),
1868 hda.GetDeviceNumber());
1869 if (!machine.isOk())
1870 vboxProblem().cannotDetachHardDisk (this,
1871 machine, hda.GetController(), hda.GetDeviceNumber());
1872 break;
1873 }
1874 }
1875 break;
1876 }
1877 case VBoxDefs::CD:
1878 {
1879 /* releasing cd: */
1880 machine.GetDVDDrive().Unmount();
1881 break;
1882 }
1883 case VBoxDefs::FD:
1884 {
1885 /* releasing fd: */
1886 machine.GetFloppyDrive().Unmount();
1887 break;
1888 }
1889 default:
1890 AssertFailed();
1891 }
1892 /* save all setting changes: */
1893 machine.SaveSettings();
1894 if (!machine.isOk())
1895 vboxProblem().cannotSaveMachineSettings (machine);
1896 /* if local session was opened - close this session: */
1897 if (!session.isNull())
1898 session.Close();
1899}
1900
1901
1902QUuid VBoxDiskImageManagerDlg::getSelectedUuid()
1903{
1904 QListView *currentList = getCurrentListView();
1905 QUuid uuid;
1906
1907 if ( currentList->selectedItem() &&
1908 currentList->selectedItem()->rtti() == 1001 )
1909 uuid = QUuid (static_cast<DiskImageItem *>(currentList->selectedItem())
1910 ->getUuid());
1911
1912 return uuid;
1913}
1914
1915
1916QString VBoxDiskImageManagerDlg::getSelectedPath()
1917{
1918 QListView *currentList = getCurrentListView();
1919 QString path;
1920
1921 if ( currentList->selectedItem() && currentList->selectedItem()->rtti() == 1001 )
1922 path = static_cast<DiskImageItem*> (currentList->selectedItem())
1923 ->getPath().stripWhiteSpace();
1924
1925 return path;
1926}
1927
1928
1929void VBoxDiskImageManagerDlg::processDoubleClick (QListViewItem*)
1930{
1931 QListView *currentList = getCurrentListView();
1932
1933 if (doSelect && currentList->selectedItem() && buttonOk->isEnabled())
1934 accept();
1935}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette