VirtualBox

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

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

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