Index: /trunk/src/VBox/Frontends/VirtualBox4/Makefile.kmk =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/Makefile.kmk (revision 9213) +++ /trunk/src/VBox/Frontends/VirtualBox4/Makefile.kmk (revision 9214) @@ -291,4 +291,7 @@ VirtualBox_QT_UISRCS4 += ui/VBoxVMLogViewer.ui +VirtualBox_QT_UISRCS3 := $(filter-out ui/VBoxDiskImageManagerDlg.ui,$(VirtualBox_QT_UISRCS3)) +VirtualBox_QT_UISRCS4 += ui/VBoxDiskImageManagerDlg.ui + VirtualBox_QT_UISRCS3 := $(filter-out ui/VBoxVMSettingsGeneral.ui,$(VirtualBox_QT_UISRCS3)) VirtualBox_QT_UISRCS4 += ui/VBoxVMSettingsGeneral.ui @@ -434,4 +437,5 @@ include/QIAbstractDialog.h \ include/QIListView.h \ + include/QITreeWidget.h \ include/VBoxGlobalSettings.h \ include/VBoxUtils.h \ @@ -457,4 +461,5 @@ include/VBoxSnapshotsWgt.h \ include/VBoxVMLogViewer.h \ + include/VBoxDiskImageManagerDlg.h \ include/VBoxVMSettingsUtils.h \ include/VBoxVMSettingsGeneral.h \ @@ -514,4 +519,5 @@ src/QIDialogButtonBox.cpp \ src/QIListView.cpp \ + src/QITreeWidget.cpp \ src/QILineEdit.cpp \ src/VBoxDefs.cpp \ @@ -540,4 +546,5 @@ src/VBoxSnapshotsWgt.cpp \ src/VBoxVMLogViewer.cpp \ + src/VBoxDiskImageManagerDlg.cpp \ src/VBoxVMSettingsGeneral.cpp \ src/VBoxVMSettingsCD.cpp \ Index: /trunk/src/VBox/Frontends/VirtualBox4/include/QITreeWidget.h =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/include/QITreeWidget.h (revision 9214) +++ /trunk/src/VBox/Frontends/VirtualBox4/include/QITreeWidget.h (revision 9214) @@ -0,0 +1,53 @@ +/** @file + * + * VBox frontends: Qt GUI ("VirtualBox"): + * VirtualBox Qt extensions: QITreeWidget class implementation + */ + +/* + * Copyright (C) 2008 Sun Microsystems, Inc. + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, CA 95054 USA or visit http://www.sun.com if you need + * additional information or have any questions. + */ + +#ifndef __QITreeWidget_h__ +#define __QITreeWidget_h__ + +/* Qt includes */ +#include + +class QITreeWidget: public QTreeWidget +{ + Q_OBJECT; + +public: + + QITreeWidget (QWidget *aParent = 0); + + void setSupportedDropActions (Qt::DropActions aAction); + +signals: + + void itemRightClicked (const QPoint &aPos, QTreeWidgetItem *aItem, int aColumn); + +protected: + + void mousePressEvent (QMouseEvent *aEvent); + virtual Qt::DropActions supportedDropActions () const; + + /* Protected member vars */ + Qt::DropActions mSupportedDropActions; +}; + +#endif /* __QITreeWidget_h__ */ + Index: /trunk/src/VBox/Frontends/VirtualBox4/include/VBoxDefs.h =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/include/VBoxDefs.h (revision 9213) +++ /trunk/src/VBox/Frontends/VirtualBox4/include/VBoxDefs.h (revision 9214) @@ -151,4 +151,5 @@ #endif ChangeGUILanguageEventType, + AddVDMUrlsEventType }; Index: /trunk/src/VBox/Frontends/VirtualBox4/include/VBoxDiskImageManagerDlg.h =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/include/VBoxDiskImageManagerDlg.h (revision 9214) +++ /trunk/src/VBox/Frontends/VirtualBox4/include/VBoxDiskImageManagerDlg.h (revision 9214) @@ -0,0 +1,201 @@ +/** @file + * + * VBox frontends: Qt4 GUI ("VirtualBox"): + * VBoxDiskImageManagerDlg class declaration + */ + +/* + * Copyright (C) 2006-2008 Sun Microsystems, Inc. + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, CA 95054 USA or visit http://www.sun.com if you need + * additional information or have any questions. + */ + +#ifndef __VBoxDiskImageManagerDlg_h__ +#define __VBoxDiskImageManagerDlg_h__ + +#include "VBoxDiskImageManagerDlg.gen.h" +#include "QIWithRetranslateUI.h" +#include "COMDefs.h" +#include "VBoxDefs.h" +#include "VBoxMediaComboBox.h" + +/* Qt includes */ +#include + +class DiskImageItem; +class VBoxToolBar; +class InfoPaneLabel; + +class VBoxDiskImageManagerDlg : public QIWithRetranslateUI2, + public Ui::VBoxDiskImageManagerDlg +{ + Q_OBJECT; + + enum TabIndex { HDTab = 0, + CDTab, + FDTab }; + +public: + + enum ResultCode { Rejected, + Accepted }; + + VBoxDiskImageManagerDlg (QWidget *aParent = NULL, Qt::WindowFlags aFlags = Qt::Dialog); + + void setup (int aType, bool aDoSelect, const QUuid *aTargetVMId = NULL, bool aRefresh = true, CMachine aMachine = NULL, const QUuid & aHdId = QUuid(), const QUuid & aCdId = QUuid(), const QUuid & aFdId = QUuid()); + + static void showModeless (bool aRefresh = true); + int exec(); + int result() const; + + QUuid selectedUuid() const; + QString selectedPath() const; + + static QString composeHdToolTip (CHardDisk &aHd, VBoxMedia::Status aStatus, DiskImageItem *aItem = NULL); + static QString composeCdToolTip (CDVDImage &aCd, VBoxMedia::Status aStatus, DiskImageItem *aItem = NULL); + static QString composeFdToolTip (CFloppyImage &aFd, VBoxMedia::Status aStatus, DiskImageItem *aItem = NULL); + +public slots: + + void refreshAll(); + virtual void setVisible (bool aVisible); + +protected: + + void retranslateUi(); + virtual void closeEvent (QCloseEvent *aEvent); + virtual void keyPressEvent (QKeyEvent *aEvent); + virtual bool eventFilter (QObject *aObject, QEvent *aEvent); + /* @todo: Currently not used (Ported from Qt3): */ + virtual void machineStateChanged (const VBoxMachineStateChangeEvent &aEvent); + +private slots: + + void mediaAdded (const VBoxMedia &aMedia); + void mediaUpdated (const VBoxMedia &aMedia); + void mediaRemoved (VBoxDefs::DiskType aType, const QUuid &aId); + + void mediaEnumStarted(); + void mediaEnumerated (const VBoxMedia &aMedia, int aIndex); + void mediaEnumFinished (const VBoxMediaList &aList); + + void newImage(); + void addImage(); + void removeImage(); + void releaseImage(); + + void releaseDisk (const QUuid &aMachineId, const QUuid &aItemId, VBoxDefs::DiskType aDiskType); + + void processCurrentChanged (int index = -1); + void processCurrentChanged (QTreeWidgetItem *aItem, QTreeWidgetItem *aPrevItem = NULL); + void processDoubleClick (QTreeWidgetItem *aItem, int aColumn); + void processRightClick (const QPoint &aPos, QTreeWidgetItem *aItem, int aColumn); + + void accept(); + void reject(); + void done (int aRescode); + + void setResult (int aRescode); + +private: + + QTreeWidget* treeWidget (VBoxDefs::DiskType aType) const; + VBoxDefs::DiskType currentTreeWidgetType() const; + QTreeWidget* currentTreeWidget() const; + + QTreeWidgetItem *selectedItem (const QTreeWidget *aTree) const; + DiskImageItem *toDiskImageItem (QTreeWidgetItem *aItem) const; + + void setCurrentItem (QTreeWidget *aTree, QTreeWidgetItem *aItem); + + void addImageToList (const QString &aSource, VBoxDefs::DiskType aDiskType); + DiskImageItem* createImageNode (QTreeWidget *aTree, DiskImageItem *aRoot, const VBoxMedia &aMedia) const; + + DiskImageItem* createHdItem (QTreeWidget *aTree, const VBoxMedia &aMedia) const; + DiskImageItem* createCdItem (QTreeWidget *aTree, const VBoxMedia &aMedia) const; + DiskImageItem* createFdItem (QTreeWidget *aTree, const VBoxMedia &aMedia) const; + + void updateHdItem (DiskImageItem *aItem, const VBoxMedia &aMedia) const; + void updateCdItem (DiskImageItem *aItem, const VBoxMedia &aMedia) const; + void updateFdItem (DiskImageItem *aItem, const VBoxMedia &aMedia) const; + + DiskImageItem* searchItem (QTreeWidget *aTree, const QUuid &aId) const; + DiskImageItem* searchItem (QTreeWidget *aTree, VBoxMedia::Status aStatus) const; + + bool checkImage (DiskImageItem *aItem); + + bool checkDndUrls (const QList &aUrls) const; + void addDndUrls (const QList &aUrls); + + void clearInfoPanes(); + void prepareToRefresh (int aTotal = 0); + void createInfoString (InfoPaneLabel *&aInfo, QWidget* aRoot, int aRow, int aCol, int aRowSpan = 1, int aColSpan = 1) const; + + void makeWarningMark (DiskImageItem *aItem, VBoxMedia::Status aStatus, VBoxDefs::DiskType aType) const; + + static QString DVDImageUsage (const QUuid &aId, QString &aSnapshotUsage); + static QString FloppyImageUsage (const QUuid &aId, QString &aSnapshotUsage); + static void DVDImageSnapshotUsage (const QUuid &aId, const CSnapshot &aSnapshot, QString &aUsage); + static void FloppyImageSnapshotUsage (const QUuid &aId, const CSnapshot &aSnapshot, QString &aUsage); + + /* Private member vars */ + /* Window status */ + bool mDoSelect; + int mRescode; + static VBoxDiskImageManagerDlg *mModelessDialog; + QPointer mEventLoop; + + /* Type if we are in the select modus */ + int mType; + + /* Icon definitions */ + QIcon mIconInaccessible; + QIcon mIconErroneous; + QIcon mIconHD; + QIcon mIconCD; + QIcon mIconFD; + + /* Menu & Toolbar */ + QMenu *mActionsContextMenu; + QMenu *mActionsMenu; + VBoxToolBar *mActionsToolBar; + QAction *mNewAction; + QAction *mAddAction; + QAction *mEditAction; + QAction *mRemoveAction; + QAction *mReleaseAction; + QAction *mRefreshAction; + + /* The grid entries in the various information panels */ + InfoPaneLabel *mHdsPane1; + InfoPaneLabel *mHdsPane2; + InfoPaneLabel *mHdsPane3; + InfoPaneLabel *mHdsPane4; + InfoPaneLabel *mHdsPane5; + InfoPaneLabel *mHdsPane6; + InfoPaneLabel *mHdsPane7; + InfoPaneLabel *mCdsPane1; + InfoPaneLabel *mCdsPane2; + InfoPaneLabel *mFdsPane1; + InfoPaneLabel *mFdsPane2; + + /* Machine */ + CMachine mMachine; + QUuid mTargetVMId; + QUuid mHdSelectedId; + QUuid mCdSelectedId; + QUuid mFdSelectedId; +}; + +#endif /* __VBoxDiskImageManagerDlg_h__ */ + Index: /trunk/src/VBox/Frontends/VirtualBox4/src/QITreeWidget.cpp =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/src/QITreeWidget.cpp (revision 9214) +++ /trunk/src/VBox/Frontends/VirtualBox4/src/QITreeWidget.cpp (revision 9214) @@ -0,0 +1,52 @@ +/** @file + * + * VBox frontends: Qt GUI ("VirtualBox"): + * VirtualBox Qt extensions: QITreeWidget class implementation + */ + +/* + * Copyright (C) 2008 Sun Microsystems, Inc. + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, CA 95054 USA or visit http://www.sun.com if you need + * additional information or have any questions. + */ + +#include "QITreeWidget.h" + +/* Qt includes */ +#include + +QITreeWidget::QITreeWidget (QWidget *aParent) + : QTreeWidget (aParent) +{ +} + +void QITreeWidget::setSupportedDropActions (Qt::DropActions aAction) +{ + mSupportedDropActions = aAction; +} + +void QITreeWidget::mousePressEvent (QMouseEvent *aEvent) +{ + if (aEvent->button() == Qt::RightButton) + { + emit itemRightClicked (aEvent->globalPos(), itemAt (aEvent->pos()), columnAt (aEvent->pos().x())); + aEvent->accept(); + }else + QTreeWidget::mousePressEvent (aEvent); +} + +Qt::DropActions QITreeWidget::supportedDropActions () const +{ + return mSupportedDropActions; +} + Index: /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxConsoleWnd.cpp =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxConsoleWnd.cpp (revision 9213) +++ /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxConsoleWnd.cpp (revision 9214) @@ -31,4 +31,5 @@ #include "VBoxDownloaderWgt.h" #include "VBoxGlobal.h" +#include "VBoxProblemReporter.h" #include "QIStateIndicator.h" @@ -2528,5 +2529,5 @@ if (!console) return; - VBoxDiskImageManagerDlg dlg (this, "VBoxDiskImageManagerDlg", Qt::WType_Dialog | Qt::WShowModal); + VBoxDiskImageManagerDlg dlg (this); QUuid id = csession.GetMachine().GetId(); dlg.setup (VBoxDefs::FD, true, &id); @@ -2535,5 +2536,5 @@ { CFloppyDrive drv = csession.GetMachine().GetFloppyDrive(); - drv.MountImage (dlg.getSelectedUuid()); + drv.MountImage (dlg.selectedUuid()); AssertWrapperOk (drv); if (drv.isOk()) @@ -2572,5 +2573,5 @@ if (!console) return; - VBoxDiskImageManagerDlg dlg (this, "VBoxDiskImageManagerDlg", Qt::WType_Dialog | Qt::WShowModal); + VBoxDiskImageManagerDlg dlg (this); QUuid id = csession.GetMachine().GetId(); dlg.setup (VBoxDefs::CD, true, &id); @@ -2579,5 +2580,5 @@ { CDVDDrive drv = csession.GetMachine().GetDVDDrive(); - drv.MountImage (dlg.getSelectedUuid()); + drv.MountImage (dlg.selectedUuid()); AssertWrapperOk (drv); if (drv.isOk()) Index: /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxDiskImageManagerDlg.cpp =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxDiskImageManagerDlg.cpp (revision 9214) +++ /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxDiskImageManagerDlg.cpp (revision 9214) @@ -0,0 +1,2215 @@ +/** @file + * + * VBox frontends: Qt4 GUI ("VirtualBox"): + * VBoxDiskImageManagerDlg class implementation + */ + +/* + * Copyright (C) 2006-2008 Sun Microsystems, Inc. + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa + * Clara, CA 95054 USA or visit http://www.sun.com if you need + * additional information or have any questions. + */ + +#include "VBoxDiskImageManagerDlg.h" +#include "VBoxToolBar.h" +#include "QIRichLabel.h" +#include "VBoxNewHDWzd.h" +#include "VBoxProblemReporter.h" + +/* Qt includes */ +#include +#include +#include +#include +#include +#include +#include + +class AddVDMUrlsEvent: public QEvent +{ +public: + + AddVDMUrlsEvent (const QList &aUrls) + : QEvent (static_cast (VBoxDefs::AddVDMUrlsEventType)) + , mUrls (aUrls) + {} + + const QList &urls() const { return mUrls; } + +private: + + const QList mUrls; +}; + +class DiskImageItem : public QTreeWidgetItem +{ +public: + + enum { TypeId = QTreeWidgetItem::UserType + 1 }; + + DiskImageItem (DiskImageItem *aParent) : + QTreeWidgetItem (aParent, TypeId), mStatus (VBoxMedia::Unknown) {} + + DiskImageItem (QTreeWidget *aParent) : + QTreeWidgetItem (aParent, TypeId), mStatus (VBoxMedia::Unknown) {} + + void setMedia (const VBoxMedia &aMedia) { mMedia = aMedia; } + const VBoxMedia &getMedia() const { return mMedia; } + + void setPath (const QString &aPath) { mPath = aPath; } + const QString &getPath() const { return mPath; } + + void setUsage (const QString &aUsage) { mUsage = aUsage; } + const QString &getUsage() const { return mUsage; } + + void setSnapshotUsage (const QString &aSnapshotUsage) { mSnapshotUsage = aSnapshotUsage; } + const QString &getSnapshotUsage() const { return mSnapshotUsage; } + + QString getTotalUsage() const + { + /* should correlate with VBoxDiskImageManagerDlg::compose[Cd/Fd]Tooltip */ + return mSnapshotUsage.isNull() ? mUsage : + QString ("%1 (%2)").arg (mUsage, mSnapshotUsage); + } + + void setSnapshotName (const QString &aSnapshotName) { mSnapshotName = aSnapshotName; } + const QString &getSnapshotName() const { return mSnapshotName; } + + void setDiskType (const QString &aDiskType) { mDiskType = aDiskType; } + const QString &getDiskType() const { return mDiskType; } + + void setStorageType (const QString &aStorageType) { mStorageType = aStorageType; } + const QString &getStorageType() const { return mStorageType; } + + void setVirtualSize (const QString &aVirtualSize) { mVirtualSize = aVirtualSize; } + const QString &getVirtualSize() const { return mVirtualSize; } + + void setActualSize (const QString &aActualSize) { mActualSize = aActualSize; } + const QString &getActualSize() const { return mActualSize; } + + void setUuid (const QUuid &aUuid) { mUuid = aUuid; } + const QUuid &getUuid() const { return mUuid; } + + void setMachineId (const QUuid &aMachineId) { mMachineId = aMachineId; } + const QUuid &getMachineId() const { return mMachineId; } + + void setStatus (VBoxMedia::Status aStatus) { mStatus = aStatus; } + VBoxMedia::Status getStatus() const { return mStatus; } + + void setToolTip (const QString& aToolTip) + { + mToolTip = aToolTip; + for (int i=0; i < treeWidget()->columnCount(); ++i) + QTreeWidgetItem::setToolTip (i, mToolTip); + } + const QString &getToolTip() const { return mToolTip; } + + QString getInformation (const QString &aInfo, bool aCompact = true, + const QString &aElipsis = "middle") + { + QString compactString = QString ("").arg (aElipsis); + QString info = QString ("%1%2%3") + .arg (aCompact ? compactString : "") + .arg (aInfo.isEmpty() ? + QApplication::translate ("VBoxDiskImageManagerDlg", "--", "no info") : + aInfo) + .arg (aCompact ? "" : ""); + return info; + } + + bool operator< (const QTreeWidgetItem &aOther) const + { + int column = treeWidget()->sortColumn(); + ULONG64 thisValue = vboxGlobal().parseSize ( text (column)); + ULONG64 thatValue = vboxGlobal().parseSize (aOther.text (column)); + if (thisValue && thatValue) + return thisValue < thatValue; + else + return QTreeWidgetItem::operator< (aOther); + } + +// void paintCell (QPainter *aPainter, const QColorGroup &aColorGroup, +// int aColumn, int aWidth, int aSlign) +// { +// QColorGroup cGroup (aColorGroup); +// if (mStatus == VBoxMedia::Unknown) +// cGroup.setColor (QColorGroup::Text, cGroup.mid()); +// Q3ListViewItem::paintCell (aPainter, cGroup, aColumn, aWidth, aSlign); +// } + +protected: + + VBoxMedia mMedia; + + QString mName; + QString mPath; + QString mUsage; + QString mSnapshotUsage; + QString mSnapshotName; + QString mDiskType; + QString mStorageType; + QString mVirtualSize; + QString mActualSize; + + QUuid mUuid; + QUuid mMachineId; + + QString mToolTip; + + VBoxMedia::Status mStatus; +}; + +class DiskImageItemIterator : public QTreeWidgetItemIterator +{ +public: + + DiskImageItemIterator (QTreeWidget* aTree) + : QTreeWidgetItemIterator (aTree) {} + + DiskImageItem* operator*() + { + QTreeWidgetItem *item = QTreeWidgetItemIterator::operator*(); + return item && item->type() == DiskImageItem::TypeId ? + static_cast (item) : NULL; + } + + DiskImageItemIterator& operator++() + { + return (DiskImageItemIterator&) QTreeWidgetItemIterator::operator++(); + } +}; + +class InfoPaneLabel : public QIRichLabel +{ +public: + + InfoPaneLabel (QWidget *aParent, QLabel *aLabel = 0) + : QIRichLabel (aParent), mLabel (aLabel) {} + + QLabel* label() { return mLabel; } + +private: + + QLabel *mLabel; +}; + +VBoxDiskImageManagerDlg *VBoxDiskImageManagerDlg::mModelessDialog = NULL; + +VBoxDiskImageManagerDlg::VBoxDiskImageManagerDlg (QWidget *aParent /* = NULL */, Qt::WindowFlags aFlags /* = 0 */) + : QIWithRetranslateUI2 (aParent, aFlags) + , mRescode (Rejected) + , mType (VBoxDefs::InvalidType) +{ + /* Apply UI decorations */ + Ui::VBoxDiskImageManagerDlg::setupUi (this); + +// defaultButton = searchDefaultButton(); + + mType = VBoxDefs::InvalidType; + + mIconInaccessible = style()->standardIcon (QStyle::SP_MessageBoxWarning); + mIconErroneous = style()->standardIcon (QStyle::SP_MessageBoxCritical); + mIconHD = VBoxGlobal::iconSet (":/hd_16px.png", ":/hd_disabled_16px.png"); + mIconCD = VBoxGlobal::iconSet (":/cd_16px.png", ":/cd_disabled_16px.png"); + mIconFD = VBoxGlobal::iconSet (":/fd_16px.png", ":/fd_disabled_16px.png"); + + /* Setup tab widget icons */ + twImages->setTabIcon (HDTab, mIconHD); + twImages->setTabIcon (CDTab, mIconCD); + twImages->setTabIcon (FDTab, mIconFD); + + connect (twImages, SIGNAL (currentChanged (int)), + this, SLOT (processCurrentChanged (int))); + + /* Setup the tree view widgets */ + mHdsTree->header()->setResizeMode (0, QHeaderView::Stretch); + mHdsTree->header()->setResizeMode (1, QHeaderView::ResizeToContents); + mHdsTree->header()->setResizeMode (2, QHeaderView::ResizeToContents); + mHdsTree->setSortingEnabled(true); + mHdsTree->setSupportedDropActions (Qt::LinkAction); + mHdsTree->installEventFilter (this); + connect (mHdsTree, SIGNAL (currentItemChanged (QTreeWidgetItem *, QTreeWidgetItem *)), + this, SLOT (processCurrentChanged (QTreeWidgetItem *, QTreeWidgetItem *))); + connect (mHdsTree, SIGNAL (itemDoubleClicked (QTreeWidgetItem *, int)), + this, SLOT (processDoubleClick (QTreeWidgetItem *, int))); + connect (mHdsTree, SIGNAL (itemRightClicked (const QPoint &, QTreeWidgetItem *, int)), + this, SLOT (processRightClick (const QPoint &, QTreeWidgetItem *, int))); + + mCdsTree->header()->setResizeMode (0, QHeaderView::Stretch); + mCdsTree->header()->setResizeMode (1, QHeaderView::ResizeToContents); + mCdsTree->setSortingEnabled(true); + mCdsTree->setSupportedDropActions (Qt::LinkAction); + mCdsTree->installEventFilter (this); + connect (mCdsTree, SIGNAL (currentItemChanged (QTreeWidgetItem *, QTreeWidgetItem *)), + this, SLOT (processCurrentChanged (QTreeWidgetItem *, QTreeWidgetItem *))); + connect (mCdsTree, SIGNAL (itemDoubleClicked (QTreeWidgetItem *, int)), + this, SLOT (processDoubleClick (QTreeWidgetItem *, int))); + connect (mCdsTree, SIGNAL (itemRightClicked (const QPoint &, QTreeWidgetItem *, int)), + this, SLOT (processRightClick (const QPoint &, QTreeWidgetItem *, int))); + + mFdsTree->header()->setResizeMode (0, QHeaderView::Stretch); + mFdsTree->header()->setResizeMode (1, QHeaderView::ResizeToContents); + mFdsTree->setSortingEnabled(true); + mFdsTree->setSupportedDropActions (Qt::LinkAction); + mFdsTree->installEventFilter (this); + connect (mFdsTree, SIGNAL (currentItemChanged (QTreeWidgetItem *, QTreeWidgetItem *)), + this, SLOT (processCurrentChanged (QTreeWidgetItem *, QTreeWidgetItem *))); + connect (mFdsTree, SIGNAL (itemDoubleClicked (QTreeWidgetItem *, int)), + this, SLOT (processDoubleClick (QTreeWidgetItem *, int))); + connect (mFdsTree, SIGNAL (itemRightClicked (const QPoint &, QTreeWidgetItem *, int)), + this, SLOT (processRightClick (const QPoint &, QTreeWidgetItem *, int))); + + /* Context menu composing */ + mActionsContextMenu = new QMenu (this); + + mNewAction = new QAction (this); + mAddAction = new QAction (this); + // mEditAction = new QAction (this); + mRemoveAction = new QAction (this); + mReleaseAction = new QAction (this); + mRefreshAction = new QAction (this); + + connect (mNewAction, SIGNAL (activated()), + this, SLOT (newImage())); + connect (mAddAction, SIGNAL (activated()), + this, SLOT (addImage())); + // connect (mEditAction, SIGNAL (activated()), + // this, SLOT (editImage())); + connect (mRemoveAction, SIGNAL (activated()), + this, SLOT (removeImage())); + connect (mReleaseAction, SIGNAL (activated()), + this, SLOT (releaseImage())); + connect (mRefreshAction, SIGNAL (activated()), + this, SLOT (refreshAll())); + + mNewAction->setIcon (VBoxGlobal::iconSetEx ( + ":/vdm_new_22px.png", ":/vdm_new_16px.png", + ":/vdm_new_disabled_22px.png", ":/vdm_new_disabled_16px.png")); + mAddAction->setIcon (VBoxGlobal::iconSetEx ( + ":/vdm_add_22px.png", ":/vdm_add_16px.png", + ":/vdm_add_disabled_22px.png", ":/vdm_add_disabled_16px.png")); + // mEditAction->setIcon (VBoxGlobal::iconSet (":/guesttools_16px.png", ":/guesttools_disabled_16px.png")); + mRemoveAction->setIcon (VBoxGlobal::iconSetEx ( + ":/vdm_remove_22px.png", ":/vdm_remove_16px.png", + ":/vdm_remove_disabled_22px.png", ":/vdm_remove_disabled_16px.png")); + mReleaseAction->setIcon (VBoxGlobal::iconSetEx ( + ":/vdm_release_22px.png", ":/vdm_release_16px.png", + ":/vdm_release_disabled_22px.png", ":/vdm_release_disabled_16px.png")); + mRefreshAction->setIcon (VBoxGlobal::iconSetEx ( + ":/refresh_22px.png", ":/refresh_16px.png", + ":/refresh_disabled_22px.png", ":/refresh_disabled_16px.png")); + +// mActionsMenu->addAction (mEditAction); + mActionsContextMenu->addAction (mRemoveAction); + mActionsContextMenu->addAction (mReleaseAction); + + /* Toolbar composing */ + mActionsToolBar = new VBoxToolBar (this); + mActionsToolBar->setIconSize (QSize (32, 32)); + mActionsToolBar->setToolButtonStyle (Qt::ToolButtonTextUnderIcon); + mActionsToolBar->setSizePolicy (QSizePolicy::Fixed, QSizePolicy::Preferred); + + /* Really messy what the uic produce here: a vbox layout in an hbox layout */ + QHBoxLayout *centralLayout = qobject_cast (centralWidget()->layout()); + Assert (VALID_PTR (centralLayout)); + QVBoxLayout *mainLayout = static_cast (centralLayout->itemAt(0)); + Assert (VALID_PTR (mainLayout)); +#if MAC_LEOPARD_STYLE + /* Enable unified toolbars on Mac OS X. Available on Qt >= 4.3 */ + setUnifiedTitleAndToolBarOnMac (true); + addToolBar (mActionsToolBar); + /* No spacing/margin on the mac */ + VBoxGlobal::setLayoutMargin (centralLayout, 0); + VBoxGlobal::setLayoutMargin (mainLayout, 0); +#else /* MAC_LEOPARD_STYLE */ + /* Add the toolbar */ + mainLayout->insertWidget (0, mActionsToolBar); + /* Set spacing/margin like in the selector window */ + centralLayout->setSpacing (0); + VBoxGlobal::setLayoutMargin (centralLayout, 0); + mainLayout->setSpacing (9); + VBoxGlobal::setLayoutMargin (mainLayout, 5); +#endif /* MAC_LEOPARD_STYLE */ + + mActionsToolBar->addAction (mNewAction); + mActionsToolBar->addAction (mAddAction); + mActionsToolBar->addSeparator(); +// mActionsToolBar->addAction (mEditAction); + mActionsToolBar->addAction (mRemoveAction); + mActionsToolBar->addAction (mReleaseAction); + mActionsToolBar->addSeparator(); + mActionsToolBar->addAction (mRefreshAction); + + /* Menu bar */ + mActionsMenu = menuBar()->addMenu (QString::null); + mActionsMenu->addAction (mNewAction); + mActionsMenu->addAction (mAddAction); + mActionsMenu->addSeparator(); +// mActionsMenu->addAction (mEditAction); + mActionsMenu->addAction (mRemoveAction); + mActionsMenu->addAction (mReleaseAction); + mActionsMenu->addSeparator(); + mActionsMenu->addAction (mRefreshAction); + +// qApp->installEventFilter (this); + + /* Setup information pane layouts */ + QGridLayout *hdsContainerLayout = new QGridLayout (mHdsContainer); + VBoxGlobal::setLayoutMargin (hdsContainerLayout, 5); + hdsContainerLayout->setSpacing (0); + QGridLayout *cdsContainerLayout = new QGridLayout (mCdsContainer); + VBoxGlobal::setLayoutMargin (cdsContainerLayout, 5); + cdsContainerLayout->setSpacing (0); + QGridLayout *fdsContainerLayout = new QGridLayout (mFdsContainer); + VBoxGlobal::setLayoutMargin (fdsContainerLayout, 5); + fdsContainerLayout->setSpacing (0); + /* Create info-pane for hd list-view */ + createInfoString (mHdsPane1, mHdsContainer, 0, 0, 1, 3); + createInfoString (mHdsPane2, mHdsContainer, 1, 0); + createInfoString (mHdsPane3, mHdsContainer, 1, 2); + createInfoString (mHdsPane4, mHdsContainer, 2, 0); + createInfoString (mHdsPane5, mHdsContainer, 2, 2); + /* Create info-pane for cd list-view */ + createInfoString (mCdsPane1, mCdsContainer, 0, 0); + createInfoString (mCdsPane2, mCdsContainer, 1, 0); + /* Create info-pane for fd list-view */ + createInfoString (mFdsPane1, mFdsContainer, 0, 0); + createInfoString (mFdsPane2, mFdsContainer, 1, 0); + + /* enumeration progressbar creation */ +// mProgressText = new QLabel (centralWidget()); +// mProgressText->setHidden (true); +#warning port me +// buttonLayout->insertWidget (2, mProgressText); +// mProgressBar = new Q3ProgressBar (centralWidget()); +// mProgressBar->setHidden (true); +// mProgressBar->setFrameShadow (Q3Frame::Sunken); +// mProgressBar->setFrameShape (Q3Frame::Panel); +// mProgressBar->setPercentageVisible (false); +// mProgressBar->setMaximumWidth (100); +#warning port me +// buttonLayout->insertWidget (3, mProgressBar); + + /* Connects for the button box */ + connect (mButtonBox, SIGNAL (accepted()), + this, SLOT (accept())); + connect (mButtonBox, SIGNAL (rejected()), + this, SLOT (reject())); + connect (mButtonBox, SIGNAL (helpRequested()), + &vboxProblem(), SLOT (showHelpHelpDialog())); + + + /* Applying language settings */ + retranslateUi(); +} + + +void VBoxDiskImageManagerDlg::setup (int aType, bool aDoSelect, + const QUuid *aTargetVMId /* = NULL */, + bool aRefresh /* = true */, + CMachine aMachine /* = NULL */, + const QUuid &aHdId, + const QUuid &aCdId, + const QUuid &aFdId) +{ + mMachine = aMachine; + mHdSelectedId = aHdId; + mCdSelectedId = aCdId; + mFdSelectedId = aFdId; + + mType = aType; + twImages->setTabEnabled (HDTab, mType & VBoxDefs::HD); + twImages->setTabEnabled (CDTab, mType & VBoxDefs::CD); + twImages->setTabEnabled (FDTab, mType & VBoxDefs::FD); + + mDoSelect = aDoSelect; + if (aTargetVMId) + mTargetVMId = *aTargetVMId; + + if (mDoSelect) + mButtonBox->button (QDialogButtonBox::Ok)->setText (tr ("&Select")); + else + mButtonBox->button (QDialogButtonBox::Cancel)->setVisible (false); + + /* Listen to "media enumeration started" signals */ + connect (&vboxGlobal(), SIGNAL (mediaEnumStarted()), + this, SLOT (mediaEnumStarted())); + /* Listen to "media enumeration" signals */ + connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMedia &, int)), + this, SLOT (mediaEnumerated (const VBoxMedia &, int))); + /* Listen to "media enumeration finished" signals */ + connect (&vboxGlobal(), SIGNAL (mediaEnumFinished (const VBoxMediaList &)), + this, SLOT (mediaEnumFinished (const VBoxMediaList &))); + + /* Listen to "media add" signals */ + connect (&vboxGlobal(), SIGNAL (mediaAdded (const VBoxMedia &)), + this, SLOT (mediaAdded (const VBoxMedia &))); + /* Listen to "media update" signals */ + connect (&vboxGlobal(), SIGNAL (mediaUpdated (const VBoxMedia &)), + this, SLOT (mediaUpdated (const VBoxMedia &))); + /* Listen to "media remove" signals */ + connect (&vboxGlobal(), SIGNAL (mediaRemoved (VBoxDefs::DiskType, const QUuid &)), + this, SLOT (mediaRemoved (VBoxDefs::DiskType, const QUuid &))); + + if (aRefresh && !vboxGlobal().isMediaEnumerationStarted()) + vboxGlobal().startEnumeratingMedia(); + else + { + /* Insert already enumerated media */ + const VBoxMediaList &list = vboxGlobal().currentMediaList(); + prepareToRefresh (list.size()); + VBoxMediaList::const_iterator it; + int index = 0; + for (it = list.begin(); it != list.end(); ++ it) + { + mediaAdded (*it); +// if ((*it).status != VBoxMedia::Unknown) +// mProgressBar->setProgress (++ index); + } + + /* Emulate the finished signal to reuse the code */ + if (!vboxGlobal().isMediaEnumerationStarted()) + mediaEnumFinished (list); + } + + /* For a newly opened dialog, select the first item */ + if (!mHdsTree->selectedItems().isEmpty()) + if (QTreeWidgetItem *item = mHdsTree->topLevelItem (0)) + setCurrentItem (mHdsTree, item); + if (!mCdsTree->selectedItems().isEmpty()) + if (QTreeWidgetItem *item = mCdsTree->topLevelItem (0)) + setCurrentItem (mCdsTree, item); + if (!mFdsTree->selectedItems().isEmpty()) + if (QTreeWidgetItem *item = mFdsTree->topLevelItem (0)) + setCurrentItem (mFdsTree, item); +} + +void VBoxDiskImageManagerDlg::showModeless (bool aRefresh /* = true */) +{ + if (!mModelessDialog) + { + mModelessDialog = + new VBoxDiskImageManagerDlg (NULL, Qt::Window); + mModelessDialog->setAttribute (Qt::WA_DeleteOnClose); + mModelessDialog->setup (VBoxDefs::HD | VBoxDefs::CD | VBoxDefs::FD, + false, NULL, aRefresh); + + /* listen to events that may change the media status and refresh + * the contents of the modeless dialog */ + /// @todo refreshAll() may be slow, so it may be better to analyze + // event details and update only what is changed */ + connect (&vboxGlobal(), SIGNAL (machineDataChanged (const VBoxMachineDataChangeEvent &)), + mModelessDialog, SLOT (refreshAll())); + connect (&vboxGlobal(), SIGNAL (machineRegistered (const VBoxMachineRegisteredEvent &)), + mModelessDialog, SLOT (refreshAll())); + connect (&vboxGlobal(), SIGNAL (snapshotChanged (const VBoxSnapshotEvent &)), + mModelessDialog, SLOT (refreshAll())); + } + + mModelessDialog->show(); + mModelessDialog->setWindowState (mModelessDialog->windowState() & + ~Qt::WindowMinimized); + mModelessDialog->activateWindow(); +} + +int VBoxDiskImageManagerDlg::exec() +{ + AssertMsg (!mEventLoop, ("exec is called recursively")); + + /* Reset the result code */ + setResult (Rejected); + bool deleteOnClose = testAttribute(Qt::WA_DeleteOnClose); + setAttribute(Qt::WA_DeleteOnClose, false); + /* Create a local event loop */ + mEventLoop = new QEventLoop(); + /* Show the window */ + show(); + /* A guard to ourself for the case we destroy ourself. */ + QPointer guard = this; + /* Start the event loop. This blocks. */ + mEventLoop->exec(); + /* Delete the event loop */ + delete mEventLoop; + /* Are we valid anymore? */ + if (guard.isNull()) + return Rejected; + int res = result(); + if (deleteOnClose) + delete this; + /* Return the final result */ + return res; +} + +QUuid VBoxDiskImageManagerDlg::selectedUuid() const +{ + QTreeWidget *tree = currentTreeWidget(); + QUuid uuid; + + DiskImageItem *item = toDiskImageItem (selectedItem (tree)); + if (item) + uuid = item->getUuid(); + + return uuid; +} + +QString VBoxDiskImageManagerDlg::selectedPath() const +{ + QTreeWidget *tree = currentTreeWidget(); + QString path; + + DiskImageItem *item = toDiskImageItem (selectedItem (tree)); + if (item) + path = item->getPath().trimmed(); + + return path; +} + +QString VBoxDiskImageManagerDlg::composeHdToolTip (CHardDisk &aHd, + VBoxMedia::Status aStatus, + DiskImageItem *aItem) +{ + CVirtualBox vbox = vboxGlobal().virtualBox(); + QUuid machineId = aItem ? aItem->getMachineId() : aHd.GetMachineId(); + + QString src = aItem ? aItem->getPath() : aHd.GetLocation(); + QString location = aItem || aHd.GetStorageType() == KHardDiskStorageType_ISCSIHardDisk ? src : + QDir::convertSeparators (QFileInfo (src).absoluteFilePath()); + + QString storageType = aItem ? aItem->getStorageType() : + vboxGlobal().toString (aHd.GetStorageType()); + QString hardDiskType = aItem ? aItem->getDiskType() : + vboxGlobal().hardDiskTypeString (aHd); + + QString usage; + if (aItem) + usage = aItem->getUsage(); + else if (!machineId.isNull()) + usage = vbox.GetMachine (machineId).GetName(); + + QUuid snapshotId = aItem ? aItem->getUuid() : aHd.GetSnapshotId(); + QString snapshotName; + if (aItem) + snapshotName = aItem->getSnapshotName(); + else if (!machineId.isNull() && !snapshotId.isNull()) + { + CSnapshot snapshot = vbox.GetMachine (machineId). + GetSnapshot (aHd.GetSnapshotId()); + if (!snapshot.isNull()) + snapshotName = snapshot.GetName(); + } + + /* Compose tool-tip information */ + QString tip; + switch (aStatus) + { + case VBoxMedia::Unknown: + { + tip = tr ("%1
" + "Checking accessibility...", "HDD") + .arg (location); + break; + } + case VBoxMedia::Ok: + { + tip = tr ("%1
" + "Disk type:  %2
" + "Storage type:  %3") + .arg (location) + .arg (hardDiskType) + .arg (storageType); + + if (!usage.isNull()) + tip += tr ("
Attached to:  %1", "HDD") + .arg (usage); + if (!snapshotName.isNull()) + tip += tr ("
Snapshot:  %5", "HDD") + .arg (snapshotName); + break; + } + case VBoxMedia::Error: + { + /// @todo (r=dmik) paass a complete VBoxMedia instance here + // to get the result of blabla.GetAccessible() call form CUnknown + tip = tr ("%1
" + "Error checking media accessibility", "HDD") + .arg (location); + break; + } + case VBoxMedia::Inaccessible: + { + tip = tr ("%1
%2", "HDD") + .arg (location) + .arg (VBoxGlobal::highlight (aHd.GetLastAccessError(), + true /* aToolTip */)); + break; + } + default: + AssertFailed(); + } + return tip; +} + +QString VBoxDiskImageManagerDlg::composeCdToolTip (CDVDImage &aCd, + VBoxMedia::Status aStatus, + DiskImageItem *aItem) +{ + QString location = aItem ? aItem->getPath() : + QDir::convertSeparators (QFileInfo (aCd.GetFilePath()).absoluteFilePath()); + QUuid uuid = aItem ? aItem->getUuid() : aCd.GetId(); + QString usage; + if (aItem) + usage = aItem->getTotalUsage(); + else + { + QString snapshotUsage; + usage = DVDImageUsage (uuid, snapshotUsage); + /* Should correlate with DiskImageItem::getTotalUsage() */ + if (!snapshotUsage.isNull()) + usage = QString ("%1 (%2)").arg (usage, snapshotUsage); + } + + /* Compose tool-tip information */ + QString tip; + switch (aStatus) + { + case VBoxMedia::Unknown: + { + tip = tr ("%1
" + "Checking accessibility...", "CD/DVD/Floppy") + .arg (location); + break; + } + case VBoxMedia::Ok: + { + tip = tr ("%1", "CD/DVD/Floppy") + .arg (location); + + if (!usage.isNull()) + tip += tr ("
Attached to:  %1", + "CD/DVD/Floppy") + .arg (usage); + break; + } + case VBoxMedia::Error: + { + /// @todo (r=dmik) paass a complete VBoxMedia instance here + // to get the result of blabla.GetAccessible() call form CUnknown + tip = tr ("%1
" + "Error checking media accessibility", "CD/DVD/Floppy") + .arg (location); + break; + } + case VBoxMedia::Inaccessible: + { + /// @todo (r=dmik) correct this when GetLastAccessError() is + // implemented for IDVDImage + tip = tr ("%1
%2") + .arg (location) + .arg (tr ("The image file is not accessible", + "CD/DVD/Floppy")); + break; + } + default: + AssertFailed(); + } + return tip; +} + +QString VBoxDiskImageManagerDlg::composeFdToolTip (CFloppyImage &aFd, + VBoxMedia::Status aStatus, + DiskImageItem *aItem) +{ + QString location = aItem ? aItem->getPath() : + QDir::convertSeparators (QFileInfo (aFd.GetFilePath()).absoluteFilePath()); + QUuid uuid = aItem ? aItem->getUuid() : aFd.GetId(); + QString usage; + if (aItem) + usage = aItem->getTotalUsage(); + else + { + QString snapshotUsage; + usage = FloppyImageUsage (uuid, snapshotUsage); + /* Should correlate with DiskImageItem::getTotalUsage() */ + if (!snapshotUsage.isNull()) + usage = QString ("%1 (%2)").arg (usage, snapshotUsage); + } + + /* Compose tool-tip information */ + QString tip; + switch (aStatus) + { + case VBoxMedia::Unknown: + { + tip = tr ("%1
" + "Checking accessibility...", "CD/DVD/Floppy") + .arg (location); + break; + } + case VBoxMedia::Ok: + { + tip = tr ("%1", "CD/DVD/Floppy") + .arg (location); + + if (!usage.isNull()) + tip += tr ("
Attached to:  %1", + "CD/DVD/Floppy") + .arg (usage); + break; + } + case VBoxMedia::Error: + { + /// @todo (r=dmik) paass a complete VBoxMedia instance here + // to get the result of blabla.GetAccessible() call form CUnknown + tip = tr ("%1
" + "Error checking media accessibility", "CD/DVD/Floppy") + .arg (location); + break; + } + case VBoxMedia::Inaccessible: + { + /// @todo (r=dmik) correct this when GetLastAccessError() is + // implemented for IDVDImage + tip = tr ("%1
%2") + .arg (location) + .arg (tr ("The image file is not accessible", + "CD/DVD/Floppy")); + break; + } + default: + AssertFailed(); + } + return tip; +} + +void VBoxDiskImageManagerDlg::refreshAll() +{ + /* Start enumerating media */ + vboxGlobal().startEnumeratingMedia(); +} + +void VBoxDiskImageManagerDlg::setVisible (bool aVisible) +{ + QMainWindow::setVisible (aVisible); + /* Exit from the event loop if there is any and we are changing our state + * from visible to invisible. */ + if(mEventLoop && !aVisible) + mEventLoop->exit(); +} + +void VBoxDiskImageManagerDlg::retranslateUi() +{ + /* Translate uic generated strings */ + Ui::VBoxDiskImageManagerDlg::retranslateUi (this); + + mActionsMenu->setTitle (tr ("&Actions")); + + mNewAction->setText (tr ("&New")); + mAddAction->setText (tr ("&Add")); + // mEditAction->setText (tr ("&Edit")); + mRemoveAction->setText (tr ("R&emove")); + mReleaseAction->setText (tr ("Re&lease")); + mRefreshAction->setText (tr ("Re&fresh")); + + mNewAction->setShortcut (tr ("Ctrl+N")); + mAddAction->setShortcut (tr ("Ctrl+A")); + // mEditAction->setShortcut (tr ("Ctrl+E")); + mRemoveAction->setShortcut (tr ("Ctrl+D")); + mReleaseAction->setShortcut (tr ("Ctrl+L")); + mRefreshAction->setShortcut (tr ("Ctrl+R")); + + mNewAction->setStatusTip (tr ("Create a new virtual hard disk")); + mAddAction->setStatusTip (tr ("Add (register) an existing image file")); + // mEditAction->setStatusTip (tr ("Edit the properties of the selected item")); + mRemoveAction->setStatusTip (tr ("Remove (unregister) the selected media")); + mReleaseAction->setStatusTip (tr ("Release the selected media by detaching it from the machine")); + mRefreshAction->setStatusTip (tr ("Refresh the media list")); + + mHdsPane1->label()->setText (QString ("%1:").arg (tr ("Location"))); + mHdsPane2->label()->setText (QString ("%1:").arg (tr ("Disk Type"))); + mHdsPane3->label()->setText (QString ("  %1:").arg (tr ("Storage Type"))); + mHdsPane4->label()->setText (QString ("%1:").arg (tr ("Attached to"))); + mHdsPane5->label()->setText (QString ("  %1:").arg (tr ("Snapshot"))); + mCdsPane1->label()->setText (QString ("%1:").arg (tr ("Location"))); + mCdsPane2->label()->setText (QString ("%1:").arg (tr ("Attached to"))); + mFdsPane1->label()->setText (QString ("%1:").arg (tr ("Location"))); + mFdsPane2->label()->setText (QString ("%1:").arg (tr ("Attached to"))); + +// mProgressText->setText (tr ("Checking accessibility")); +// + if (mHdsTree->model()->rowCount() || mCdsTree->model()->rowCount() || mFdsTree->model()->rowCount()) + refreshAll(); +} + +void VBoxDiskImageManagerDlg::closeEvent (QCloseEvent *aEvent) +{ + mModelessDialog = NULL; + aEvent->accept(); +} + +void VBoxDiskImageManagerDlg::keyPressEvent (QKeyEvent *aEvent) +{ + if (aEvent->modifiers() == Qt::NoModifier || + (aEvent->modifiers() != Qt::NoModifier && aEvent->key() == Qt::Key_Enter)) + { + switch (aEvent->key()) + { + case Qt::Key_Enter: + case Qt::Key_Return: + { + accept(); + break; + } + case Qt::Key_Escape: + { + reject(); + break; + } + } + } + else + aEvent->ignore(); +} + +bool VBoxDiskImageManagerDlg::eventFilter (QObject *aObject, QEvent *aEvent) +{ + switch (aEvent->type()) + { + case QEvent::DragEnter: + { + QDragEnterEvent *deEvent = static_cast (aEvent); + if (deEvent->mimeData()->hasUrls()) + { + if (checkDndUrls (deEvent->mimeData()->urls())) + { + deEvent->setDropAction (Qt::LinkAction); + deEvent->acceptProposedAction(); + } + } + return true; + break; + } + case QEvent::Drop: + { + QDropEvent *dEvent = static_cast (aEvent); + if (dEvent->mimeData()->hasUrls()) + { + AddVDMUrlsEvent *event = new AddVDMUrlsEvent (dEvent->mimeData()->urls()); + QApplication::postEvent (currentTreeWidget(), event); + dEvent->acceptProposedAction(); + } + return true; + break; + } + case VBoxDefs::AddVDMUrlsEventType: + { + if (aObject == currentTreeWidget()) + { + AddVDMUrlsEvent *addEvent = static_cast (aEvent); + addDndUrls (addEvent->urls()); + return true; + } + break; + } + default: + break; + } + return QMainWindow::eventFilter (aObject, aEvent); +} + +/* @todo: Currently not used (Ported from Qt3): */ +void VBoxDiskImageManagerDlg::machineStateChanged (const VBoxMachineStateChangeEvent &aEvent) +{ + /// @todo (r=dmik) IVirtualBoxCallback::OnMachineStateChange + // must also expose the old state! In this case we won't need to cache + // the state value in every class in GUI that uses this signal. + + switch (aEvent.state) + { + case KMachineState_PoweredOff: + case KMachineState_Aborted: + case KMachineState_Saved: + case KMachineState_Starting: + case KMachineState_Restoring: + { + refreshAll(); + break; + } + default: + break; + } +} + +void VBoxDiskImageManagerDlg::mediaAdded (const VBoxMedia &aMedia) +{ + /* Ignore non-interesting aMedia */ + if (!(mType & aMedia.type)) + return; + + DiskImageItem *item = NULL; + switch (aMedia.type) + { + case VBoxDefs::HD: + item = createHdItem (mHdsTree, aMedia); + if (item->getUuid() == mHdSelectedId) + { + setCurrentItem (mHdsTree, item); + mHdSelectedId = QUuid(); + } + break; + case VBoxDefs::CD: + item = createCdItem (mCdsTree, aMedia); + if (item->getUuid() == mCdSelectedId) + { + setCurrentItem (mCdsTree, item); + mCdSelectedId = QUuid(); + } + break; + case VBoxDefs::FD: + item = createFdItem (mFdsTree, aMedia); + if (item->getUuid() == mFdSelectedId) + { + setCurrentItem (mFdsTree, item); + mFdSelectedId = QUuid(); + } + break; + default: + AssertMsgFailed (("Invalid aMedia type\n")); + } + + if (!item) + return; + + if (!vboxGlobal().isMediaEnumerationStarted()) + setCurrentItem (treeWidget (aMedia.type), item); + if (item == currentTreeWidget()->currentItem()) + processCurrentChanged (item); +} + +void VBoxDiskImageManagerDlg::mediaUpdated (const VBoxMedia &aMedia) +{ + /* Ignore non-interesting aMedia */ + if (!(mType & aMedia.type)) + return; + + DiskImageItem *item = NULL; + switch (aMedia.type) + { + case VBoxDefs::HD: + { + CHardDisk hd = aMedia.disk; + item = searchItem (mHdsTree, hd.GetId()); + updateHdItem (item, aMedia); + break; + } + case VBoxDefs::CD: + { + CDVDImage cd = aMedia.disk; + item = searchItem (mCdsTree, cd.GetId()); + updateCdItem (item, aMedia); + break; + } + case VBoxDefs::FD: + { + CFloppyImage fd = aMedia.disk; + item = searchItem (mFdsTree, fd.GetId()); + updateFdItem (item, aMedia); + break; + } + default: + AssertMsgFailed (("Invalid aMedia type\n")); + } + + if (!item) + return; + + /* Note: current items on invisible tabs are not updated because + * it is always done in processCurrentChanged() when the user switches + * to an invisible tab */ + if (item == currentTreeWidget()->currentItem()) + processCurrentChanged (item); +} + +void VBoxDiskImageManagerDlg::mediaRemoved (VBoxDefs::DiskType aType, + const QUuid &aId) +{ + QTreeWidget *tree = treeWidget (aType); + DiskImageItem *item = searchItem (tree, aId); + delete item; + setCurrentItem (tree, tree->currentItem()); + /* Search the list for inaccessible media */ + if (!searchItem (tree, VBoxMedia::Inaccessible) && + !searchItem (tree, VBoxMedia::Error)) + { + int index = aType == VBoxDefs::HD ? HDTab : + aType == VBoxDefs::CD ? CDTab : + aType == VBoxDefs::FD ? FDTab : -1; + const QIcon &set = aType == VBoxDefs::HD ? mIconHD : + aType == VBoxDefs::CD ? mIconCD : + aType == VBoxDefs::FD ? mIconFD : QIcon(); + Assert (index != -1 && !set.isNull()); /* atype should be the correct one */ + twImages->setTabIcon (index, set); + } +} + +void VBoxDiskImageManagerDlg::mediaEnumStarted() +{ + /* Load default tab icons */ + twImages->setTabIcon (HDTab, mIconHD); + twImages->setTabIcon (CDTab, mIconCD); + twImages->setTabIcon (FDTab, mIconFD); + + /* Load current media list */ + const VBoxMediaList &list = vboxGlobal().currentMediaList(); + prepareToRefresh (list.size()); + VBoxMediaList::const_iterator it; + for (it = list.begin(); it != list.end(); ++ it) + mediaAdded (*it); + + /* Select the first item if the previous saved item is not found or no + * current item at all */ + if (!mHdsTree->currentItem() || !mHdSelectedId.isNull()) + if (QTreeWidgetItem *item = mHdsTree->topLevelItem (0)) + setCurrentItem (mHdsTree, item); + if (!mCdsTree->currentItem() || !mCdSelectedId.isNull()) + if (QTreeWidgetItem *item = mCdsTree->topLevelItem (0)) + setCurrentItem (mCdsTree, item); + if (!mFdsTree->currentItem() || !mFdSelectedId.isNull()) + if (QTreeWidgetItem *item = mFdsTree->topLevelItem (0)) + setCurrentItem (mFdsTree, item); + + processCurrentChanged(); +} + +void VBoxDiskImageManagerDlg::mediaEnumerated (const VBoxMedia &aMedia, + int aIndex) +{ + mediaUpdated (aMedia); + Assert (aMedia.status != VBoxMedia::Unknown); +// if (aMedia.status != VBoxMedia::Unknown) +// mProgressBar->setProgress (aIndex + 1); +} + +void VBoxDiskImageManagerDlg::mediaEnumFinished (const VBoxMediaList &/* aList */) +{ +// mProgressBar->setHidden (true); +// mProgressText->setHidden (true); + + mRefreshAction->setEnabled (true); + unsetCursor(); + + processCurrentChanged(); +} + +void VBoxDiskImageManagerDlg::newImage() +{ + AssertReturnVoid (currentTreeWidgetType() == VBoxDefs::HD); + + VBoxNewHDWzd dlg (this); + + if (dlg.exec() == QDialog::Accepted) + { + CHardDisk hd = dlg.hardDisk(); + VBoxMedia::Status status = + hd.GetAccessible() ? VBoxMedia::Ok : + hd.isOk() ? VBoxMedia::Inaccessible : + VBoxMedia::Error; + vboxGlobal().addMedia (VBoxMedia (CUnknown (hd), VBoxDefs::HD, status)); + } +} + +void VBoxDiskImageManagerDlg::addImage() +{ + QTreeWidget *tree = currentTreeWidget(); + DiskImageItem *item = toDiskImageItem (tree->currentItem()); + + CVirtualBox vbox = vboxGlobal().virtualBox(); + + QString title; + QString filter; + VBoxDefs::DiskType type = currentTreeWidgetType(); + + QString dir; + if (item && item->getStatus() == VBoxMedia::Ok) + dir = QFileInfo (item->getPath().trimmed()).absolutePath (); + + if (dir.isEmpty()) + if (type == VBoxDefs::HD) + dir = vbox.GetSystemProperties().GetDefaultVDIFolder(); + + if (dir.isEmpty() || !QFileInfo (dir).exists()) + dir = vbox.GetHomeFolder(); + + switch (type) + { + case VBoxDefs::HD: + { + filter = tr ("All hard disk images (*.vdi *.vmdk);;" + "Virtual Disk images (*.vdi);;" + "VMDK images (*.vmdk);;" + "All files (*)"); + title = tr ("Select a hard disk image file"); + break; + } + case VBoxDefs::CD: + { + filter = tr ("CD/DVD-ROM images (*.iso);;" + "All files (*)"); + title = tr ("Select a CD/DVD-ROM disk image file"); + break; + } + case VBoxDefs::FD: + { + filter = tr ("Floppy images (*.img);;" + "All files (*)"); + title = tr ("Select a floppy disk image file"); + break; + } + default: + AssertMsgFailed (("Selected tree should be equal to one item in VBoxDefs::DiskType.\n")); + break; + } + + QString src = VBoxGlobal::getOpenFileName (dir, filter, this, title); + src = QDir::convertSeparators (src); + + addImageToList (src, type); + if (!vbox.isOk()) + vboxProblem().cannotRegisterMedia (this, vbox, type, src); +} + +void VBoxDiskImageManagerDlg::removeImage() +{ + QTreeWidget *tree = currentTreeWidget(); + DiskImageItem *item = toDiskImageItem (tree->currentItem()); + AssertMsg (item, ("Current item must not be null\n")); + + CVirtualBox vbox = vboxGlobal().virtualBox(); + + QUuid uuid = item->getUuid(); + AssertMsg (!uuid.isNull(), ("Current item must have uuid\n")); + + QString src = item->getPath().trimmed(); + VBoxDefs::DiskType type = currentTreeWidgetType(); + + switch (type) + { + case VBoxDefs::HD: + { + bool deleteImage = false; + + /// @todo When creation of VMDK is implemented, we should + /// enable image deletion for them as well (use + /// GetStorageType() to define the correct cast). + CHardDisk disk = item->getMedia().disk; + if (disk.GetStorageType() == KHardDiskStorageType_VirtualDiskImage && + disk.GetParent().isNull() && /* must not be differencing (see below) */ + item->getStatus() == VBoxMedia::Ok) + { + int rc = vboxProblem().confirmHardDiskImageDeletion (this, src); + if (rc == QIMessageBox::Cancel) + return; + deleteImage = rc == QIMessageBox::Yes; + } + else + { + /// @todo note that differencing images are always automatically + /// deleted when unregistered, but the following message box + /// doesn't mention it. I keep it as is for now because + /// implementing the portability feature will most likely change + /// this behavior (we'll update the message afterwards). + if (!vboxProblem().confirmHardDiskUnregister (this, src)) + return; + } + + CHardDisk hd = vbox.UnregisterHardDisk (uuid); + if (!vbox.isOk()) + vboxProblem().cannotUnregisterMedia (this, vbox, type, src); + else if (deleteImage) + { + /// @todo When creation of VMDK is implemented, we should + /// enable image deletion for them as well (use + /// GetStorageType() to define the correct cast). + CVirtualDiskImage vdi = CUnknown (hd); + if (vdi.isOk()) + vdi.DeleteImage(); + if (!vdi.isOk()) + vboxProblem().cannotDeleteHardDiskImage (this, vdi); + } + break; + } + case VBoxDefs::CD: + vbox.UnregisterDVDImage (uuid); + break; + case VBoxDefs::FD: + vbox.UnregisterFloppyImage (uuid); + break; + default: + AssertMsgFailed (("Selected tree should be equal to one item in VBoxDefs::DiskType.\n")); + break; + } + + if (vbox.isOk()) + vboxGlobal().removeMedia (type, uuid); + else + vboxProblem().cannotUnregisterMedia (this, vbox, type, src); +} + +void VBoxDiskImageManagerDlg::releaseImage() +{ + QTreeWidget *tree = currentTreeWidget(); + DiskImageItem *item = toDiskImageItem (tree->currentItem()); + AssertMsg (item, ("Current item must not be null\n")); + + CVirtualBox vbox = vboxGlobal().virtualBox(); + + QUuid itemId = item->getUuid(); + AssertMsg (!itemId.isNull(), ("Current item must have uuid\n")); + + switch (currentTreeWidgetType()) + { + /* If it is a hard disk sub-item: */ + case VBoxDefs::HD: + { + CHardDisk hd = item->getMedia().disk; + QUuid machineId = hd.GetMachineId(); + if (vboxProblem().confirmReleaseImage (this, + vbox.GetMachine (machineId).GetName())) + { + releaseDisk (machineId, itemId, VBoxDefs::HD); + VBoxMedia media (item->getMedia()); + media.status = hd.GetAccessible() ? VBoxMedia::Ok : + hd.isOk() ? VBoxMedia::Inaccessible : + VBoxMedia::Error; + vboxGlobal().updateMedia (media); + } + break; + } + /* If it is a cd/dvd sub-item: */ + case VBoxDefs::CD: + { + QString usage = item->getTotalUsage(); + if (vboxProblem().confirmReleaseImage (this, usage)) + { + QStringList permMachines = + vbox.GetDVDImageUsage (itemId, + KResourceUsage_Permanent).split (' ', QString::SkipEmptyParts); + for (QStringList::Iterator it = permMachines.begin(); + it != permMachines.end(); ++it) + releaseDisk (QUuid (*it), itemId, VBoxDefs::CD); + + CDVDImage cd = vbox.GetDVDImage (itemId); + VBoxMedia media (item->getMedia()); + media.status = cd.GetAccessible() ? VBoxMedia::Ok : + cd.isOk() ? VBoxMedia::Inaccessible : + VBoxMedia::Error; + vboxGlobal().updateMedia (media); + } + } + /* If it is a floppy sub-item: */ + case VBoxDefs::FD: + { + QString usage = item->getTotalUsage(); + if (vboxProblem().confirmReleaseImage (this, usage)) + { + QStringList permMachines = + vbox.GetFloppyImageUsage (itemId, + KResourceUsage_Permanent).split (' ', QString::SkipEmptyParts); + for (QStringList::Iterator it = permMachines.begin(); + it != permMachines.end(); ++it) + releaseDisk (QUuid (*it), itemId, VBoxDefs::FD); + + CFloppyImage fd = vbox.GetFloppyImage (itemId); + VBoxMedia media (item->getMedia()); + media.status = fd.GetAccessible() ? VBoxMedia::Ok : + fd.isOk() ? VBoxMedia::Inaccessible : + VBoxMedia::Error; + vboxGlobal().updateMedia (media); + } + } + default: + AssertMsgFailed (("Selected tree should be equal to one item in VBoxDefs::DiskType.\n")); + break; + } +} + +void VBoxDiskImageManagerDlg::releaseDisk (const QUuid &aMachineId, + const QUuid &aItemId, + VBoxDefs::DiskType aDiskType) +{ + CSession session; + CMachine machine; + /* Is this media image mapped to this VM: */ + if (!mMachine.isNull() && mMachine.GetId() == aMachineId) + machine = mMachine; + /* Or some other: */ + else + { + session = vboxGlobal().openSession (aMachineId); + if (session.isNull()) return; + machine = session.GetMachine(); + } + /* Perform disk releasing: */ + switch (aDiskType) + { + case VBoxDefs::HD: + { + /* Releasing hd: */ + CHardDiskAttachmentEnumerator en = + machine.GetHardDiskAttachments().Enumerate(); + while (en.HasMore()) + { + CHardDiskAttachment hda = en.GetNext(); + if (hda.GetHardDisk().GetId() == aItemId) + { + machine.DetachHardDisk (hda.GetBus(), + hda.GetChannel(), + hda.GetDevice()); + if (!machine.isOk()) + vboxProblem().cannotDetachHardDisk (this, + machine, hda.GetBus(), hda.GetChannel(), hda.GetDevice()); + break; + } + } + break; + } + case VBoxDefs::CD: + { + /* Releasing cd: */ + machine.GetDVDDrive().Unmount(); + break; + } + case VBoxDefs::FD: + { + /* Releasing fd: */ + machine.GetFloppyDrive().Unmount(); + break; + } + default: + AssertMsgFailed (("Incorrect disk type.")); + } + /* Save all setting changes: */ + machine.SaveSettings(); + if (!machine.isOk()) + vboxProblem().cannotSaveMachineSettings (machine); + /* If local session was opened - close this session: */ + if (!session.isNull()) + session.Close(); +} + +void VBoxDiskImageManagerDlg::accept() +{ + done (Accepted); +} + +void VBoxDiskImageManagerDlg::reject() +{ + done (Rejected); +} + +void VBoxDiskImageManagerDlg::done (int aResult) +{ + /* Set the final result */ + setResult (aResult); + /* Hide this window */ + hide(); + /* And close the window */ + close(); +} + +int VBoxDiskImageManagerDlg::result() const +{ + return mRescode; +} + +void VBoxDiskImageManagerDlg::setResult (int aRescode) +{ + mRescode = aRescode; +} + +QTreeWidget* VBoxDiskImageManagerDlg::treeWidget (VBoxDefs::DiskType aType) const +{ + QTreeWidget* tree = NULL; + switch (aType) + { + case VBoxDefs::HD: + tree = mHdsTree; + break; + case VBoxDefs::CD: + tree = mCdsTree; + break; + case VBoxDefs::FD: + tree = mFdsTree; + break; + default: + AssertMsgFailed (("Disk type %d unknown!\n", aType)); + break; + } + return tree; +} + +VBoxDefs::DiskType VBoxDiskImageManagerDlg::currentTreeWidgetType() const +{ + VBoxDefs::DiskType type = VBoxDefs::InvalidType; + switch (twImages->currentIndex ()) + { + case HDTab: + type = VBoxDefs::HD; + break; + case CDTab: + type = VBoxDefs::CD; + break; + case FDTab: + type = VBoxDefs::FD; + break; + default: + AssertMsgFailed (("Page type %d unknown!\n", twImages->currentIndex ())); + break; + } + return type; +} + +QTreeWidget* VBoxDiskImageManagerDlg::currentTreeWidget() const +{ + return treeWidget (currentTreeWidgetType()); +} + + +QTreeWidgetItem *VBoxDiskImageManagerDlg::selectedItem (const QTreeWidget *aTree) const +{ + /* Return the current selected item. The user can select one item at the + * time only, so return the first element always. */ + QList selItems = aTree->selectedItems(); + if (!selItems.isEmpty()) + return selItems.first(); + else + return NULL; +} + + +DiskImageItem *VBoxDiskImageManagerDlg::toDiskImageItem (QTreeWidgetItem *aItem) const +{ + /* Convert the QTreeWidgetItem to a DiskImageItem if it is valid. */ + DiskImageItem *item = NULL; + if (aItem && + aItem->type() == DiskImageItem::TypeId) + item = static_cast (aItem); + + return item; +} + +void VBoxDiskImageManagerDlg::setCurrentItem (QTreeWidget *aTree, + QTreeWidgetItem *aItem) +{ + if (aTree && aItem) + { + aItem->setSelected (true); + aTree->setCurrentItem (aItem); + aTree->scrollToItem (aItem, QAbstractItemView::EnsureVisible); + } +} + +void VBoxDiskImageManagerDlg::processCurrentChanged (int /* index = -1 */) +{ + QTreeWidget *tree = currentTreeWidget(); + tree->setFocus(); + + /* Tab stop setup */ + setTabOrder (mHdsTree, mHdsPane1); + setTabOrder (mHdsPane1, mHdsPane2); + setTabOrder (mHdsPane2, mHdsPane3); + setTabOrder (mHdsPane3, mHdsPane4); + setTabOrder (mHdsPane4, mHdsPane5); + + setTabOrder (mCdsTree, mCdsPane1); + setTabOrder (mCdsPane1, mCdsPane2); + + setTabOrder (mFdsTree, mFdsPane1); + setTabOrder (mFdsPane1, mFdsPane2); + + processCurrentChanged (tree->currentItem()); +} + +void VBoxDiskImageManagerDlg::processCurrentChanged (QTreeWidgetItem *aItem, QTreeWidgetItem *aPrevItem /* = NULL */) +{ + DiskImageItem *item = toDiskImageItem (aItem); + + if (!item) + { + DiskImageItem *itemOld = toDiskImageItem (aPrevItem); + /* We have to make sure that one item is selected always. If the new + * item is 0, set the old item again. */ + setCurrentItem (currentTreeWidget(), itemOld); + return; + } + + /* Ensures current item visible every time we are switching page */ + item->treeWidget()->scrollToItem (item, QAbstractItemView::EnsureVisible); + + bool notInEnum = !vboxGlobal().isMediaEnumerationStarted(); + bool modifyEnabled = notInEnum && + item && item->getUsage().isNull() && + (item->childCount() == 0) && !item->getPath().isNull(); + bool releaseEnabled = item && !item->getUsage().isNull() && + item->getSnapshotUsage().isNull() && + checkImage (item) && + !item->parent() && (item->childCount() == 0) && + item->getSnapshotName().isNull(); + bool newEnabled = notInEnum && + currentTreeWidget() == mHdsTree ? true : false; + bool addEnabled = notInEnum; + + // mEditAction->setEnabled (modifyEnabled); + mRemoveAction->setEnabled (modifyEnabled); + mReleaseAction->setEnabled (releaseEnabled); + mNewAction->setEnabled (newEnabled); + mAddAction->setEnabled (addEnabled); + + if (mDoSelect) + { + bool selectEnabled = item && !item->parent() && + (!newEnabled || + (item->getUsage().isNull() || + item->getMachineId() == mTargetVMId)); + + mButtonBox->button (QDialogButtonBox::Ok)->setEnabled (selectEnabled); + } + + if (item) + { + if (item->treeWidget() == mHdsTree) + { + mHdsPane1->setText (item->getInformation (item->getPath(), true, "end")); + mHdsPane2->setText (item->getInformation (item->getDiskType(), false)); + mHdsPane3->setText (item->getInformation (item->getStorageType(), false)); + mHdsPane4->setText (item->getInformation (item->getUsage())); + mHdsPane5->setText (item->getInformation (item->getSnapshotName())); + } + else if (item->treeWidget() == mCdsTree) + { + mCdsPane1->setText (item->getInformation (item->getPath(), true, "end")); + mCdsPane2->setText (item->getInformation (item->getTotalUsage())); + } + else if (item->treeWidget() == mFdsTree) + { + mFdsPane1->setText (item->getInformation (item->getPath(), true, "end")); + mFdsPane2->setText (item->getInformation (item->getTotalUsage())); + } + } + else + clearInfoPanes(); +} + +void VBoxDiskImageManagerDlg::processDoubleClick (QTreeWidgetItem * /* aItem */, int /* aColumn */) +{ + QTreeWidget *tree = currentTreeWidget(); + + if (mDoSelect && selectedItem (tree) && mButtonBox->button (QDialogButtonBox::Ok)->isEnabled()) + accept(); +} + +void VBoxDiskImageManagerDlg::processRightClick (const QPoint &aPos, QTreeWidgetItem *aItem, int /* aColumn */) +{ + if (aItem) + { + /* Make sure the item is selected and current */ + setCurrentItem (currentTreeWidget(), aItem); + mActionsContextMenu->exec (aPos); + } +} + +void VBoxDiskImageManagerDlg::addImageToList (const QString &aSource, + VBoxDefs::DiskType aDiskType) +{ + if (aSource.isEmpty()) + return; + + CVirtualBox vbox = vboxGlobal().virtualBox(); + + QUuid uuid; + VBoxMedia media; + switch (aDiskType) + { + case VBoxDefs::HD: + { + CHardDisk hd = vbox.OpenHardDisk (aSource); + if (vbox.isOk()) + { + vbox.RegisterHardDisk (hd); + if (vbox.isOk()) + { + VBoxMedia::Status status = + hd.GetAccessible() ? VBoxMedia::Ok : + hd.isOk() ? VBoxMedia::Inaccessible : + VBoxMedia::Error; + media = VBoxMedia (CUnknown (hd), VBoxDefs::HD, status); + } + } + break; + } + case VBoxDefs::CD: + { + CDVDImage cd = vbox.OpenDVDImage (aSource, uuid); + if (vbox.isOk()) + { + vbox.RegisterDVDImage (cd); + if (vbox.isOk()) + { + VBoxMedia::Status status = + cd.GetAccessible() ? VBoxMedia::Ok : + cd.isOk() ? VBoxMedia::Inaccessible : + VBoxMedia::Error; + media = VBoxMedia (CUnknown (cd), VBoxDefs::CD, status); + } + } + break; + } + case VBoxDefs::FD: + { + CFloppyImage fd = vbox.OpenFloppyImage (aSource, uuid); + if (vbox.isOk()) + { + vbox.RegisterFloppyImage (fd); + if (vbox.isOk()) + { + VBoxMedia::Status status = + fd.GetAccessible() ? VBoxMedia::Ok : + fd.isOk() ? VBoxMedia::Inaccessible : + VBoxMedia::Error; + media = VBoxMedia (CUnknown (fd), VBoxDefs::FD, status); + } + } + break; + } + default: + AssertMsgFailed (("Invalid aDiskType type\n")); + } + if (media.type != VBoxDefs::InvalidType) + vboxGlobal().addMedia (media); +} + +DiskImageItem* VBoxDiskImageManagerDlg::createImageNode (QTreeWidget *aTree, + DiskImageItem *aRoot, + const VBoxMedia &aMedia) const +{ + Assert (!(aTree == NULL && aRoot == NULL)); + + DiskImageItem *item = NULL; + + if (aRoot) + item = new DiskImageItem (aRoot); + else if (aTree) + item = new DiskImageItem (aTree); + + item->setMedia (aMedia); + + return item; +} + +DiskImageItem* VBoxDiskImageManagerDlg::createHdItem (QTreeWidget *aTree, + const VBoxMedia &aMedia) const +{ + CHardDisk hd = aMedia.disk; + QUuid rootId = hd.GetParent().isNull() ? QUuid() : hd.GetParent().GetId(); + DiskImageItem *root = searchItem (aTree, rootId); + DiskImageItem *item = createImageNode (aTree, root, aMedia); + updateHdItem (item, aMedia); + return item; +} + +DiskImageItem* VBoxDiskImageManagerDlg::createCdItem (QTreeWidget *aTree, + const VBoxMedia &aMedia) const +{ + DiskImageItem *item = createImageNode (aTree, 0, aMedia); + updateCdItem (item, aMedia); + return item; +} + +DiskImageItem* VBoxDiskImageManagerDlg::createFdItem (QTreeWidget *aTree, + const VBoxMedia &aMedia) const +{ + DiskImageItem *item = createImageNode (aTree, 0, aMedia); + updateFdItem (item, aMedia); + return item; +} + +void VBoxDiskImageManagerDlg::updateHdItem (DiskImageItem *aItem, + const VBoxMedia &aMedia) const +{ + if (!aItem) + return; + + CHardDisk hd = aMedia.disk; + VBoxMedia::Status status = aMedia.status; + + QUuid uuid = hd.GetId(); + QString src = hd.GetLocation(); + QUuid machineId = hd.GetMachineId(); + QString usage; + if (!machineId.isNull()) + usage = vboxGlobal().virtualBox().GetMachine (machineId).GetName(); + QString storageType = vboxGlobal().toString (hd.GetStorageType()); + QString hardDiskType = vboxGlobal().hardDiskTypeString (hd); + QString virtualSize = status == VBoxMedia::Ok ? + vboxGlobal().formatSize ((ULONG64)hd.GetSize() * _1M) : QString ("--"); + QString actualSize = status == VBoxMedia::Ok ? + vboxGlobal().formatSize (hd.GetActualSize()) : QString ("--"); + QString snapshotName; + if (!machineId.isNull() && !hd.GetSnapshotId().isNull()) + { + CSnapshot snapshot = vboxGlobal().virtualBox().GetMachine (machineId). + GetSnapshot (hd.GetSnapshotId()); + if (!snapshot.isNull()) + snapshotName = QString ("%1").arg (snapshot.GetName()); + } + QFileInfo fi (src); + + aItem->setText (0, fi.fileName()); + aItem->setText (1, virtualSize); + aItem->setTextAlignment (1, Qt::AlignRight); + aItem->setText (2, actualSize); + aItem->setTextAlignment (2, Qt::AlignRight); + aItem->setPath (hd.GetStorageType() == KHardDiskStorageType_ISCSIHardDisk ? src : + QDir::convertSeparators (fi.absoluteFilePath())); + aItem->setUsage (usage); + aItem->setSnapshotName (snapshotName); + aItem->setDiskType (hardDiskType); + aItem->setStorageType (storageType); + aItem->setVirtualSize (virtualSize); + aItem->setActualSize (actualSize); + aItem->setUuid (uuid); + aItem->setMachineId (machineId); + aItem->setToolTip (composeHdToolTip (hd, status, aItem)); + aItem->setStatus (status); + + makeWarningMark (aItem, aMedia.status, VBoxDefs::HD); +} + +void VBoxDiskImageManagerDlg::updateCdItem (DiskImageItem *aItem, + const VBoxMedia &aMedia) const +{ + if (!aItem) + return; + + CDVDImage cd = aMedia.disk; + VBoxMedia::Status status = aMedia.status; + + QUuid uuid = cd.GetId(); + QString src = cd.GetFilePath(); + QString snapshotUsage; + QString usage = DVDImageUsage (uuid, snapshotUsage); + QString size = status == VBoxMedia::Ok ? + vboxGlobal().formatSize (cd.GetSize()) : QString ("--"); + QFileInfo fi (src); + + aItem->setText (0, fi.fileName()); + aItem->setText (1, size); + aItem->setTextAlignment (1, Qt::AlignRight); + aItem->setPath (QDir::convertSeparators (fi.absoluteFilePath ())); + aItem->setUsage (usage); + aItem->setSnapshotUsage (snapshotUsage); + aItem->setActualSize (size); + aItem->setUuid (uuid); + aItem->setToolTip (composeCdToolTip (cd, status, aItem)); + aItem->setStatus (status); + + makeWarningMark (aItem, aMedia.status, VBoxDefs::CD); +} + +void VBoxDiskImageManagerDlg::updateFdItem (DiskImageItem *aItem, + const VBoxMedia &aMedia) const +{ + if (!aItem) + return; + + CFloppyImage fd = aMedia.disk; + VBoxMedia::Status status = aMedia.status; + + QUuid uuid = fd.GetId(); + QString src = fd.GetFilePath(); + QString snapshotUsage; + QString usage = FloppyImageUsage (uuid, snapshotUsage); + QString size = status == VBoxMedia::Ok ? + vboxGlobal().formatSize (fd.GetSize()) : QString ("--"); + QFileInfo fi (src); + + aItem->setText (0, fi.fileName()); + aItem->setText (1, size); + aItem->setTextAlignment (1, Qt::AlignRight); + aItem->setPath (QDir::convertSeparators (fi.absoluteFilePath ())); + aItem->setUsage (usage); + aItem->setSnapshotUsage (snapshotUsage); + aItem->setActualSize (size); + aItem->setUuid (uuid); + aItem->setToolTip (composeFdToolTip (fd, status, aItem)); + aItem->setStatus (status); + + makeWarningMark (aItem, aMedia.status, VBoxDefs::FD); +} + +DiskImageItem* VBoxDiskImageManagerDlg::searchItem (QTreeWidget *aTree, + const QUuid &aId) const +{ + if (aId.isNull()) + return NULL; + + DiskImageItemIterator iterator (aTree); + while (*iterator) + { + if ((*iterator)->getUuid() == aId) + return *iterator; + ++iterator; + } + return NULL; +} + +DiskImageItem* VBoxDiskImageManagerDlg::searchItem (QTreeWidget *aTree, + VBoxMedia::Status aStatus) const +{ + DiskImageItemIterator iterator (aTree); + while (*iterator) + { + if ((*iterator)->getStatus() == aStatus) + return *iterator; + ++iterator; + } + return NULL; +} + +bool VBoxDiskImageManagerDlg::checkImage (DiskImageItem *aItem) +{ + QUuid itemId = aItem ? aItem->getUuid() : QUuid(); + if (itemId.isNull()) + return false; + + CVirtualBox vbox = vboxGlobal().virtualBox(); + + switch (currentTreeWidgetType()) + { + case VBoxDefs::HD: + { + CHardDisk hd = aItem->getMedia().disk; + QUuid machineId = hd.GetMachineId(); + if (machineId.isNull() || + (vbox.GetMachine (machineId).GetState() != KMachineState_PoweredOff && + vbox.GetMachine (machineId).GetState() != KMachineState_Aborted)) + return false; + break; + } + case VBoxDefs::CD: + { + /* Check if there is temporary usage: */ + QStringList tempMachines = + vbox.GetDVDImageUsage (itemId, + KResourceUsage_Temporary).split (' ', QString::SkipEmptyParts); + if (!tempMachines.isEmpty()) + return false; + /* Only permanently mounted .iso could be released */ + QStringList permMachines = + vbox.GetDVDImageUsage (itemId, + KResourceUsage_Permanent).split (' ', QString::SkipEmptyParts); + for (QStringList::Iterator it = permMachines.begin(); + it != permMachines.end(); ++it) + if (vbox.GetMachine(QUuid (*it)).GetState() != KMachineState_PoweredOff && + vbox.GetMachine(QUuid (*it)).GetState() != KMachineState_Aborted) + return false; + break; + } + case VBoxDefs::FD: + { + /* Check if there is temporary usage: */ + QStringList tempMachines = + vbox.GetFloppyImageUsage (itemId, + KResourceUsage_Temporary).split (' ', QString::SkipEmptyParts); + if (!tempMachines.isEmpty()) + return false; + /* Only permanently mounted floppies could be released */ + QStringList permMachines = + vbox.GetFloppyImageUsage (itemId, + KResourceUsage_Permanent).split (' ', QString::SkipEmptyParts); + for (QStringList::Iterator it = permMachines.begin(); + it != permMachines.end(); ++it) + if (vbox.GetMachine(QUuid (*it)).GetState() != KMachineState_PoweredOff && + vbox.GetMachine(QUuid (*it)).GetState() != KMachineState_Aborted) + return false; + break; + } + default: + { + return false; + break; + } + } + return true; +} + +bool VBoxDiskImageManagerDlg::checkDndUrls (const QList &aUrls) const +{ + bool err = false; + /* Check that all file extensions fit to the current + * selected tree view and the files are valid. */ + foreach (QUrl u, aUrls) + { + QFileInfo fi (u.toLocalFile()); + /* Check dropped media type */ + /// @todo On OS/2 and windows (and mac?) extension checks should be case + /// insensitive, as OPPOSED to linux and the rest where case matters. + QString suffix = fi.suffix().toLower(); + switch (currentTreeWidgetType()) + { + case VBoxDefs::HD: + err |= (!(suffix == "vdi" || suffix == "vmdk")); + break; + case VBoxDefs::CD: + err |= (suffix != "iso"); + break; + case VBoxDefs::FD: + err |= (suffix != "img"); + break; + default: + AssertMsgFailed (("Selected tree should be equal to one item in VBoxDefs::DiskType.\n")); + break; + } + } + return !err; +} + +void VBoxDiskImageManagerDlg::addDndUrls (const QList &aUrls) +{ + CVirtualBox vbox = vboxGlobal().virtualBox(); + foreach (QUrl u, aUrls) + { + QString file = u.toLocalFile(); + VBoxDefs::DiskType type = currentTreeWidgetType(); + addImageToList (file, type); + if (!vbox.isOk()) + vboxProblem().cannotRegisterMedia (this, vbox, type, file); + } +} + +void VBoxDiskImageManagerDlg::clearInfoPanes() +{ + mHdsPane1->clear(); + mHdsPane2->clear(); mHdsPane3->clear(); + mHdsPane4->clear(); mHdsPane5->clear(); + mCdsPane1->clear(); mCdsPane2->clear(); + mFdsPane1->clear(); mFdsPane2->clear(); +} + +void VBoxDiskImageManagerDlg::prepareToRefresh (int aTotal) +{ + /* Info panel clearing */ + clearInfoPanes(); + + /* Prepare progressbar */ +// if (mProgressBar) +// { +// mProgressBar->setProgress (0, aTotal); +// mProgressBar->setHidden (false); +// mProgressText->setHidden (false); +// } + + mRefreshAction->setEnabled (false); + setCursor (QCursor (Qt::BusyCursor)); + + /* Store the current list selections */ + DiskImageItem *di; + + di = toDiskImageItem (mHdsTree->currentItem()); + if (mHdSelectedId.isNull()) + mHdSelectedId = di ? di->getUuid() : QUuid(); + + di = toDiskImageItem (mCdsTree->currentItem()); + if (mCdSelectedId.isNull()) + mCdSelectedId = di ? di->getUuid() : QUuid(); + + di = toDiskImageItem (mFdsTree->currentItem()); + if (mFdSelectedId.isNull()) + mFdSelectedId = di ? di->getUuid() : QUuid(); + + /* Finally, clear all lists */ + mHdsTree->clear(); + mCdsTree->clear(); + mFdsTree->clear(); +} + +void VBoxDiskImageManagerDlg::createInfoString (InfoPaneLabel *&aInfo, + QWidget *aRoot, + int aRow, int aCol, + int aRowSpan /* = 1 */, int aColSpan /* = 1 */) const +{ + /* Create the label & the info pane itself */ + QLabel *nameLabel = new QLabel (aRoot); + aInfo = new InfoPaneLabel (aRoot, nameLabel); + + /* Setup focus policy default for info pane */ + aInfo->setFocusPolicy (Qt::StrongFocus); + + /* Prevent the name columns from being expanded */ + nameLabel->setSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed); + + QGridLayout *rootLayout = qobject_cast (aRoot->layout()); + Assert (VALID_PTR (rootLayout)); + + /* Add the two widgets */ + rootLayout->addWidget (nameLabel, aRow, aCol, 1, 1); + rootLayout->addWidget (aInfo, aRow, aCol + 1, aRowSpan, aColSpan); +} + +void VBoxDiskImageManagerDlg::makeWarningMark (DiskImageItem *aItem, + VBoxMedia::Status aStatus, + VBoxDefs::DiskType aType) const +{ + const QIcon &icon = aStatus == VBoxMedia::Inaccessible ? mIconInaccessible : + aStatus == VBoxMedia::Error ? mIconErroneous : QIcon(); + + if (!icon.isNull()) + { + aItem->setIcon (0, icon); + treeWidget (aType); + int index = aType == VBoxDefs::HD ? HDTab : + aType == VBoxDefs::CD ? CDTab : + aType == VBoxDefs::FD ? FDTab : -1; + Assert (index != -1); /* aType should be correct */ + twImages->setTabIcon (index, icon); + aItem->treeWidget()->scrollToItem (aItem, QAbstractItemView::EnsureVisible); + } +} + +QString VBoxDiskImageManagerDlg::DVDImageUsage (const QUuid &aId, QString &aSnapshotUsage) +{ + CVirtualBox vbox = vboxGlobal().virtualBox(); + + QStringList permMachines = + vbox.GetDVDImageUsage (aId, KResourceUsage_Permanent).split (' ', QString::SkipEmptyParts); + QStringList tempMachines = + vbox.GetDVDImageUsage (aId, KResourceUsage_Temporary).split (' ', QString::SkipEmptyParts); + + QString usage; + + for (QStringList::Iterator it = permMachines.begin(); + it != permMachines.end(); + ++it) + { + if (!usage.isEmpty()) + usage += ", "; + CMachine machine = vbox.GetMachine (QUuid (*it)); + usage += machine.GetName(); + + DVDImageSnapshotUsage (aId, machine.GetSnapshot (QUuid()), + aSnapshotUsage); + } + + for (QStringList::Iterator it = tempMachines.begin(); + it != tempMachines.end(); + ++it) + { + /* Skip IDs that are in the permanent list */ + if (!permMachines.contains (*it)) + { + if (!usage.isEmpty()) + usage += ", ["; + else + usage += "["; + CMachine machine = vbox.GetMachine (QUuid (*it)); + usage += machine.GetName() + "]"; + + DVDImageSnapshotUsage (aId, machine.GetSnapshot (QUuid()), + aSnapshotUsage); + } + } + + return usage; +} + +QString VBoxDiskImageManagerDlg::FloppyImageUsage (const QUuid &aId, QString &aSnapshotUsage) +{ + CVirtualBox vbox = vboxGlobal().virtualBox(); + + QStringList permMachines = + vbox.GetFloppyImageUsage (aId, KResourceUsage_Permanent).split (' ', QString::SkipEmptyParts); + QStringList tempMachines = + vbox.GetFloppyImageUsage (aId, KResourceUsage_Temporary).split (' ', QString::SkipEmptyParts); + + QString usage; + + for (QStringList::Iterator it = permMachines.begin(); + it != permMachines.end(); + ++it) + { + if (!usage.isEmpty()) + usage += ", "; + CMachine machine = vbox.GetMachine (QUuid (*it)); + usage += machine.GetName(); + + FloppyImageSnapshotUsage (aId, machine.GetSnapshot (QUuid()), + aSnapshotUsage); + } + + for (QStringList::Iterator it = tempMachines.begin(); + it != tempMachines.end(); + ++it) + { + /* Skip IDs that are in the permanent list */ + if (!permMachines.contains (*it)) + { + if (!usage.isEmpty()) + usage += ", ["; + else + usage += "["; + CMachine machine = vbox.GetMachine (QUuid (*it)); + usage += machine.GetName() + "]"; + + FloppyImageSnapshotUsage (aId, machine.GetSnapshot (QUuid()), + aSnapshotUsage); + } + } + + return usage; +} + +void VBoxDiskImageManagerDlg::DVDImageSnapshotUsage (const QUuid &aId, const CSnapshot &aSnapshot, QString &aUsage) +{ + if (aSnapshot.isNull()) + return; + + if (!aSnapshot.GetMachine().GetDVDDrive().GetImage().isNull() && + aSnapshot.GetMachine().GetDVDDrive().GetImage().GetId() == aId) + { + if (!aUsage.isEmpty()) + aUsage += ", "; + aUsage += aSnapshot.GetName(); + } + + CSnapshotEnumerator en = aSnapshot.GetChildren().Enumerate(); + while (en.HasMore()) + DVDImageSnapshotUsage (aId, en.GetNext(), aUsage); +} + +void VBoxDiskImageManagerDlg::FloppyImageSnapshotUsage (const QUuid &aId, const CSnapshot &aSnapshot, QString &aUsage) +{ + if (aSnapshot.isNull()) + return; + + if (!aSnapshot.GetMachine().GetFloppyDrive().GetImage().isNull() && + aSnapshot.GetMachine().GetFloppyDrive().GetImage().GetId() == aId) + { + if (!aUsage.isEmpty()) + aUsage += ", "; + aUsage += aSnapshot.GetName(); + } + + CSnapshotEnumerator en = aSnapshot.GetChildren().Enumerate(); + while (en.HasMore()) + FloppyImageSnapshotUsage (aId, en.GetNext(), aUsage); +} + Index: /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxMediaComboBox.cpp =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxMediaComboBox.cpp (revision 9213) +++ /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxMediaComboBox.cpp (revision 9214) @@ -32,4 +32,5 @@ //Added by qt3to4: #include +#include VBoxMediaComboBox::VBoxMediaComboBox (QWidget *aParent, int aType /* = -1 */, Index: /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxNewVMWzd.cpp =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxNewVMWzd.cpp (revision 9213) +++ /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxNewVMWzd.cpp (revision 9214) @@ -195,8 +195,8 @@ void VBoxNewVMWzd::showVDIManager() { - VBoxDiskImageManagerDlg dlg (this, "VBoxDiskImageManagerDlg", Qt::WType_Dialog | Qt::WShowModal); + VBoxDiskImageManagerDlg dlg (this); dlg.setup (VBoxDefs::HD, true); QUuid newId = dlg.exec() == VBoxDiskImageManagerDlg::Accepted ? - dlg.getSelectedUuid() : mMediaCombo->getId(); + dlg.selectedUuid() : mMediaCombo->getId(); if (uuidHD != newId) Index: /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxVMFirstRunWzd.cpp =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxVMFirstRunWzd.cpp (revision 9213) +++ /trunk/src/VBox/Frontends/VirtualBox4/src/VBoxVMFirstRunWzd.cpp (revision 9214) @@ -241,6 +241,5 @@ void VBoxVMFirstRunWzd::openVdm() { - VBoxDiskImageManagerDlg vdm (this, "VBoxDiskImageManagerDlg", - Qt::WType_Dialog | Qt::WShowModal); + VBoxDiskImageManagerDlg vdm (this); QUuid machineId = mMachine.GetId(); VBoxDefs::DiskType type = mRbCdType->isChecked() ? VBoxDefs::CD : @@ -249,5 +248,5 @@ if (vdm.exec() == VBoxDiskImageManagerDlg::Accepted) { - mCbImage->setCurrentItem (vdm.getSelectedUuid()); + mCbImage->setCurrentItem (vdm.selectedUuid()); /* Revalidate updated page */ Index: /trunk/src/VBox/Frontends/VirtualBox4/ui/VBoxDiskImageManagerDlg.ui =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/ui/VBoxDiskImageManagerDlg.ui (revision 9213) +++ /trunk/src/VBox/Frontends/VirtualBox4/ui/VBoxDiskImageManagerDlg.ui (revision 9214) @@ -1,641 +1,221 @@ - -VBoxDiskImageManagerDlg - -:mode=html:tabSize=4:indentSize=4:noTabs=true: -:folding=explicit:collapseFolds=1: + + + VBox frontends: Qt4 GUI ("VirtualBox"): - Copyright (C) 2006-2007 Sun Microsystems, Inc. - - This file is part of VirtualBox Open Source Edition (OSE), as - available from http://www.virtualbox.org. This file is free software; - you can redistribute it and/or modify it under the terms of the GNU - General Public License (GPL) as published by the Free Software - Foundation, in version 2 as it comes in the "COPYING" file of the - VirtualBox OSE distribution. VirtualBox OSE is distributed in the - hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. - - Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa - Clara, CA 95054 USA or visit http://www.sun.com if you need - additional information or have any questions. - - - - VBoxDiskImageManagerDlg - - - - 0 - 0 - 620 - 460 - - - - - 289 - 178 - - - - Virtual Disk Manager - - - - unnamed + Copyright (C) 2008 Sun Microsystems, Inc. + + This file is part of VirtualBox Open Source Edition (OSE), as + available from http://www.virtualbox.org. This file is free software; + you can redistribute it and/or modify it under the terms of the GNU + General Public License (GPL) as published by the Free Software + Foundation, in version 2 as it comes in the "COPYING" file of the + VirtualBox OSE distribution. VirtualBox OSE is distributed in the + hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + + Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa + Clara, CA 95054 USA or visit http://www.sun.com if you need + additional information or have any questions. + + VBoxDiskImageManagerDlg + + + + 0 + 0 + 620 + 460 + + + + + 283 + 190 + + + + Virtual Disk Manager + + + :/diskim_16px.png + + + + + + + + + + 0 + 0 + - - 3 + + 0 - - 5 + + + &Hard Disks + + + + + + true + + + Qt::ScrollBarAlwaysOff + + + true + + + true + + + + Name + + + + + Virtual Size + + + + + Actual Size + + + + + + + + QFrame::Box + + + QFrame::Sunken + + + + + + + + &CD/DVD Images + + + + + + true + + + Qt::ScrollBarAlwaysOff + + + true + + + true + + + + Name + + + + + Size + + + + + + + + QFrame::Box + + + QFrame::Sunken + + + + + + + + &Floppy Images + + + + + + true + + + Qt::ScrollBarAlwaysOff + + + true + + + true + + + + Name + + + + + Size + + + + + + + + QFrame::Box + + + QFrame::Sunken + + + + + + + + + + + QDialogButtonBox::Cancel|QDialogButtonBox::Help|QDialogButtonBox::NoButton|QDialogButtonBox::Ok - - - layout2 - - - - unnamed - - - 7 - - - - twImages - - - - 5 - 7 - 0 - 0 - - - - - tab - - - &Hard Disks - - - - unnamed - - - - - Name - - - true - - - true - - - - - Virtual Size - - - true - - - true - - - - - Actual Size - - - true - - - true - - - - hdsView - - - true - - - AlwaysOff - - - false - - - true - - - true - - - AllColumns - - - - - - - - hdsContainer - - - Box - - - Sunken - - - - - - - tab - - - &CD/DVD Images - - - - unnamed - - - - - Name - - - true - - - true - - - - - Size - - - true - - - true - - - - cdsView - - - true - - - AlwaysOff - - - false - - - true - - - true - - - AllColumns - - - - - - - - cdsContainer - - - Box - - - Sunken - - - - - - - TabPage - - - &Floppy Images - - - - unnamed - - - - - Name - - - true - - - true - - - - - Size - - - true - - - true - - - - fdsView - - - true - - - AlwaysOff - - - false - - - true - - - true - - - AllColumns - - - - - - - - fdsContainer - - - Box - - - Sunken - - - - - - - - buttonLayout - - - - unnamed - - - - buttonHelp - - - Help - - - F1 - - - true - - - Invoke dialog's help - - - - - Spacer1 - - - Horizontal - - - Expanding - - - - 214 - 16 - - - - - - Spacer2 - - - Horizontal - - - Expanding - - - - 214 - 16 - - - - - - buttonOk - - - &OK - - - true - - - true - - - Accept dialog - - - - - buttonCancel - - - Cancel - - - true - - - Cancel dialog - - - - - - - - - - - - - buttonOk - clicked() - VBoxDiskImageManagerDlg - accept() - - - buttonCancel - clicked() - VBoxDiskImageManagerDlg - reject() - - - hdsView - currentChanged(QListViewItem*) - VBoxDiskImageManagerDlg - processCurrentChanged(QListViewItem*) - - - cdsView - currentChanged(QListViewItem*) - VBoxDiskImageManagerDlg - processCurrentChanged(QListViewItem*) - - - fdsView - currentChanged(QListViewItem*) - VBoxDiskImageManagerDlg - processCurrentChanged(QListViewItem*) - - - hdsView - pressed(QListViewItem*) - VBoxDiskImageManagerDlg - processPressed(QListViewItem*) - - - cdsView - pressed(QListViewItem*) - VBoxDiskImageManagerDlg - processPressed(QListViewItem*) - - - fdsView - pressed(QListViewItem*) - VBoxDiskImageManagerDlg - processPressed(QListViewItem*) - - - hdsView - doubleClicked(QListViewItem*) - VBoxDiskImageManagerDlg - processDoubleClick(QListViewItem*) - - - cdsView - doubleClicked(QListViewItem*) - VBoxDiskImageManagerDlg - processDoubleClick(QListViewItem*) - - - fdsView - doubleClicked(QListViewItem*) - VBoxDiskImageManagerDlg - processDoubleClick(QListViewItem*) - - - hdsView - contextMenuRequested(QListViewItem*,const QPoint&,int) - VBoxDiskImageManagerDlg - invokePopup(QListViewItem*,const QPoint&,int) - - - cdsView - contextMenuRequested(QListViewItem*,const QPoint&,int) - VBoxDiskImageManagerDlg - invokePopup(QListViewItem*,const QPoint&,int) - - - fdsView - contextMenuRequested(QListViewItem*,const QPoint&,int) - VBoxDiskImageManagerDlg - invokePopup(QListViewItem*,const QPoint&,int) - - - twImages - currentChanged(QWidget*) - VBoxDiskImageManagerDlg - processCurrentChanged() - - - buttonHelp - clicked() - &vboxProblem() - showHelpHelpDialog() - - - - qapplication.h - qprogressdialog.h - qobjectlist.h - qdragobject.h - qaction.h - qpopupmenu.h - qeventloop.h - qstatusbar.h - qsizegrip.h - qlocale.h - qregexp.h - qpainter.h - qprogressbar.h - qvaluelist.h - COMDefs.h - VBoxGlobal.h - VBoxProblemReporter.h - VBoxDefs.h - VBoxNewHDWzd.h - VBoxToolBar.h - QIRichLabel.h - - - class DiskImageItem - class VBoxToolBar - class QSizeGrip - class InfoPaneLabel - class QProgressBar - - - enum ResultCode { Rejected, Accepted }; - bool polished; - CVirtualBox vbox; - int type; - bool doSelect; - QUuid targetVMId; - QPixmap pxInaccessible; - QPixmap pxErroneous; - QIconSet pxHD; - QIconSet pxCD; - QIconSet pxFD; - CMachine cmachine; - QPopupMenu *itemMenu; - VBoxToolBar *toolBar; - int mRescode; - bool mInLoop; - QAction *imNewAction; - QAction *imAddAction; - QAction *imEditAction; - QAction *imRemoveAction; - QAction *imReleaseAction; - QAction *imRefreshAction; - InfoPaneLabel *hdsPane1; - InfoPaneLabel *hdsPane2; - InfoPaneLabel *hdsPane3; - InfoPaneLabel *hdsPane4; - InfoPaneLabel *hdsPane5; - InfoPaneLabel *hdsPane6; - InfoPaneLabel *hdsPane7; - InfoPaneLabel *cdsPane1; - InfoPaneLabel *cdsPane2; - InfoPaneLabel *fdsPane1; - InfoPaneLabel *fdsPane2; - QSizeGrip *sizeGrip; - QPushButton *defaultButton; - static VBoxDiskImageManagerDlg *mModelessDialog; - QProgressBar *mProgressBar; - QLabel *mProgressText; - QUuid hdSelectedId; - QUuid cdSelectedId; - QUuid fdSelectedId; - - - mediaEnumStarted() - mediaEnumerated( const VBoxMedia &, int ) - mediaEnumFinished( const VBoxMediaList & ) - mediaAdded( const VBoxMedia & ) - mediaUpdated( const VBoxMedia & ) - mediaRemoved( VBoxDefs::DiskType, const QUuid & ) - machineStateChanged( const VBoxMachineStateChangeEvent & ) - refreshAll() - processCurrentChanged( QListViewItem * item ) - processPressed( QListViewItem * item ) - newImage() - addImage() - removeImage() - processDoubleClick( QListViewItem * item ) - releaseImage() - invokePopup( QListViewItem * item, const QPoint & pos, int col ) - processCurrentChanged() - accept() - reject() - mouseOnItem( QListViewItem *item ) - - - init() - result() - setResult( int ) - exec() - done( int ) - searchItem( QListView*, const QUuid & ) - searchItem( QListView*, VBoxMedia::Status ) - getDVDImageUsage( const QUuid & aId, QString & aSnapshotUsage ) - getFloppyImageUsage( const QUuid & aId, QString & aSnapshotUsage ) - getDVDImageSnapshotUsage( const QUuid & aImageId, const CSnapshot & aSnapshot, QString & aUsage ) - getFloppyImageSnapshotUsage( const QUuid & aImageId, const CSnapshot & aSnapshot, QString & aUsage ) - checkImage( DiskImageItem* item ) - releaseDisk( QUuid machineId, QUuid itemId, VBoxDefs::DiskType diskType ) - getSelectedUuid() - getSelectedPath() - setup( int aType, bool aDoSelect, const QUuid *aTargetVMId = NULL, bool aRefresh = true, CMachine machine = NULL, const QUuid & aHdId = QUuid(), const QUuid & aCdId = QUuid(), const QUuid & aFdId = QUuid() ) - getCurrentListView() - getListView( VBoxDefs::DiskType ) - eventFilter( QObject *, QEvent * ) - addDroppedImages( QStringList* ) - addImageToList( const QString & aSource, VBoxDefs::DiskType aDiskType ) - createImageNode( QListView *aList, DiskImageItem *aRoot, const VBoxMedia & ) - updateHdItem( DiskImageItem*, const VBoxMedia & ) - updateCdItem( DiskImageItem*, const VBoxMedia & ) - updateFdItem( DiskImageItem*, const VBoxMedia & ) - createHdItem( QListView*, const VBoxMedia & ) - createCdItem( QListView*, const VBoxMedia & ) - createFdItem( QListView*, const VBoxMedia & ) - event( QEvent* ) - showEvent( QShowEvent * ) - resizeEvent( QResizeEvent* ) - keyPressEvent( QKeyEvent* ) - closeEvent( QCloseEvent* ) - createInfoString( InfoPaneLabel *&, QWidget*, int, int ) - searchDefaultButton() - setCurrentItem( QListView*, QListViewItem* ) - showModeless( bool aRefresh = true ) - composeHdToolTip( CHardDisk &, VBoxMedia::Status = VBoxMedia::Ok, DiskImageItem *aItem = NULL ) - composeCdToolTip( CDVDImage &, VBoxMedia::Status = VBoxMedia::Ok, DiskImageItem *aItem = NULL ) - composeFdToolTip( CFloppyImage &, VBoxMedia::Status = VBoxMedia::Ok, DiskImageItem *aItem = NULL ) - clearInfoPanes() - prepareToRefresh( int aTotal = 0 ) - makeWarningMark( DiskImageItem*, VBoxMedia::Status, VBoxDefs::DiskType ) - languageChangeImp() - - - + + + + + + + + + + + QIDialogButtonBox + QDialogButtonBox +
QIDialogButtonBox.h
+ + + QITreeWidget + QTreeWidget +
QITreeWidget.h
+ + + + + + + Index: unk/src/VBox/Frontends/VirtualBox4/ui/VBoxDiskImageManagerDlg.ui.h =================================================================== --- /trunk/src/VBox/Frontends/VirtualBox4/ui/VBoxDiskImageManagerDlg.ui.h (revision 9213) +++ (revision ) @@ -1,2286 +1,0 @@ -//Added by qt3to4: -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -/** - * - * VBox frontends: Qt GUI ("VirtualBox"): - * "Virtual Disk Manager" dialog UI include (Qt Designer) - */ - -/* - * Copyright (C) 2006-2007 Sun Microsystems, Inc. - * - * This file is part of VirtualBox Open Source Edition (OSE), as - * available from http://www.virtualbox.org. This file is free software; - * you can redistribute it and/or modify it under the terms of the GNU - * General Public License (GPL) as published by the Free Software - * Foundation, in version 2 as it comes in the "COPYING" file of the - * VirtualBox OSE distribution. VirtualBox OSE is distributed in the - * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa - * Clara, CA 95054 USA or visit http://www.sun.com if you need - * additional information or have any questions. - */ - -/**************************************************************************** -** ui.h extension file, included from the uic-generated form implementation. -** -** If you wish to add, delete or rename functions or slots use -** Qt Designer which will update this file, preserving your code. Create an -** init() function in place of a constructor, and a destroy() function in -** place of a destructor. -*****************************************************************************/ - - -class DiskImageItem : public Q3ListViewItem -{ -public: - - enum { TypeId = 1001 }; - - DiskImageItem (DiskImageItem *parent) : - Q3ListViewItem (parent), mStatus (VBoxMedia::Unknown) {} - - DiskImageItem (Q3ListView *parent) : - Q3ListViewItem (parent), mStatus (VBoxMedia::Unknown) {} - - void setMedia (const VBoxMedia &aMedia) { mMedia = aMedia; } - const VBoxMedia &getMedia() const { return mMedia; } - - void setPath (const QString &aPath) { mPath = aPath; } - const QString &getPath() const { return mPath; } - - void setUsage (const QString &aUsage) { mUsage = aUsage; } - const QString &getUsage() const { return mUsage; } - - void setSnapshotUsage (const QString &aSnapshotUsage) { mSnapshotUsage = aSnapshotUsage; } - const QString &getSnapshotUsage() const { return mSnapshotUsage; } - - QString getTotalUsage() const - { - /* should correlate with VBoxDiskImageManagerDlg::compose[Cd/Fd]Tooltip */ - return mSnapshotUsage.isNull() ? mUsage : - QString ("%1 (%2)").arg (mUsage, mSnapshotUsage); - } - - void setSnapshotName (const QString &aSnapshotName) { mSnapshotName = aSnapshotName; } - const QString &getSnapshotName() const { return mSnapshotName; } - - void setDiskType (const QString &aDiskType) { mDiskType = aDiskType; } - const QString &getDiskType() const { return mDiskType; } - - void setStorageType (const QString &aStorageType) { mStorageType = aStorageType; } - const QString &getStorageType() const { return mStorageType; } - - void setVirtualSize (const QString &aVirtualSize) { mVirtualSize = aVirtualSize; } - const QString &getVirtualSize() const { return mVirtualSize; } - - void setActualSize (const QString &aActualSize) { mActualSize = aActualSize; } - const QString &getActualSize() const { return mActualSize; } - - void setUuid (const QUuid &aUuid) { mUuid = aUuid; } - const QUuid &getUuid() const { return mUuid; } - - void setMachineId (const QUuid &aMachineId) { mMachineId = aMachineId; } - const QUuid &getMachineId() const { return mMachineId; } - - void setStatus (VBoxMedia::Status aStatus) { mStatus = aStatus; } - VBoxMedia::Status getStatus() const { return mStatus; } - - void setToolTip (QString aToolTip) { mToolTip = aToolTip; } - const QString &getToolTip() const { return mToolTip; } - - QString getInformation (const QString &aInfo, bool aCompact = true, - const QString &aElipsis = "middle") - { - QString compactString = QString ("").arg (aElipsis); - QString info = QString ("%1%2%3") - .arg (aCompact ? compactString : "") - .arg (aInfo.isEmpty() ? - VBoxDiskImageManagerDlg::tr ("--", "no info") : - aInfo) - .arg (aCompact ? "" : ""); - return info; - } - - int rtti() const { return TypeId; } - - int compare (Q3ListViewItem *aItem, int aColumn, bool aAscending) const - { - ULONG64 thisValue = vboxGlobal().parseSize ( text (aColumn)); - ULONG64 thatValue = vboxGlobal().parseSize (aItem->text (aColumn)); - if (thisValue && thatValue) - { - if (thisValue == thatValue) - return 0; - else - return thisValue > thatValue ? 1 : -1; - } - else - return Q3ListViewItem::compare (aItem, aColumn, aAscending); - } - - DiskImageItem* nextSibling() const - { - return (Q3ListViewItem::nextSibling() && - Q3ListViewItem::nextSibling()->rtti() == DiskImageItem::TypeId) ? - static_cast (Q3ListViewItem::nextSibling()) : 0; - } - - void paintCell (QPainter *aPainter, const QColorGroup &aColorGroup, - int aColumn, int aWidth, int aSlign) - { - QColorGroup cGroup (aColorGroup); - if (mStatus == VBoxMedia::Unknown) - cGroup.setColor (QColorGroup::Text, cGroup.mid()); - Q3ListViewItem::paintCell (aPainter, cGroup, aColumn, aWidth, aSlign); - } - -protected: - - VBoxMedia mMedia; - - QString mName; - QString mPath; - QString mUsage; - QString mSnapshotUsage; - QString mSnapshotName; - QString mDiskType; - QString mStorageType; - QString mVirtualSize; - QString mActualSize; - - QUuid mUuid; - QUuid mMachineId; - - QString mToolTip; - - VBoxMedia::Status mStatus; -}; - - -class DiskImageItemIterator : public Q3ListViewItemIterator -{ -public: - - DiskImageItemIterator (Q3ListView* aList) - : Q3ListViewItemIterator (aList) {} - - DiskImageItem* operator*() - { - Q3ListViewItem *item = Q3ListViewItemIterator::operator*(); - return item && item->rtti() == DiskImageItem::TypeId ? - static_cast (item) : 0; - } - - DiskImageItemIterator& operator++() - { - return (DiskImageItemIterator&) Q3ListViewItemIterator::operator++(); - } -}; - - -class InfoPaneLabel : public QIRichLabel -{ -public: - - InfoPaneLabel (QWidget *aParent, QLabel *aLabel = 0) - : QIRichLabel (aParent, "infoLabel"), mLabel (aLabel) {} - - QLabel* label() { return mLabel; } - -private: - - QLabel *mLabel; -}; - - -VBoxDiskImageManagerDlg *VBoxDiskImageManagerDlg::mModelessDialog = 0; - - -void VBoxDiskImageManagerDlg::showModeless (bool aRefresh /* = true */) -{ - if (!mModelessDialog) - { - mModelessDialog = - new VBoxDiskImageManagerDlg (NULL, - "VBoxDiskImageManagerDlg", - Qt::WType_TopLevel | Qt::WDestructiveClose); - mModelessDialog->setup (VBoxDefs::HD | VBoxDefs::CD | VBoxDefs::FD, - false, NULL, aRefresh); - - /* listen to events that may change the media status and refresh - * the contents of the modeless dialog */ - /// @todo refreshAll() may be slow, so it may be better to analyze - // event details and update only what is changed */ - connect (&vboxGlobal(), SIGNAL (machineDataChanged (const VBoxMachineDataChangeEvent &)), - mModelessDialog, SLOT (refreshAll())); - connect (&vboxGlobal(), SIGNAL (machineRegistered (const VBoxMachineRegisteredEvent &)), - mModelessDialog, SLOT (refreshAll())); - connect (&vboxGlobal(), SIGNAL (snapshotChanged (const VBoxSnapshotEvent &)), - mModelessDialog, SLOT (refreshAll())); - } - - mModelessDialog->show(); - mModelessDialog->setWindowState (mModelessDialog->windowState() & - ~Qt::WindowMinimized); - mModelessDialog->setActiveWindow(); -} - - -void VBoxDiskImageManagerDlg::init() -{ - polished = false; - - mInLoop = false; - - defaultButton = searchDefaultButton(); - - vbox = vboxGlobal().virtualBox(); - Assert (!vbox.isNull()); - - setIcon (QPixmap (":/diskim_16px.png")); - - type = VBoxDefs::InvalidType; - - QImage img = - QMessageBox::standardIcon (QMessageBox::Warning).convertToImage(); - img = img.smoothScale (16, 16); - pxInaccessible.convertFromImage (img); - Assert (!pxInaccessible.isNull()); - - img = - QMessageBox::standardIcon (QMessageBox::Critical).convertToImage(); - img = img.smoothScale (16, 16); - pxErroneous.convertFromImage (img); - Assert (!pxErroneous.isNull()); - - pxHD = VBoxGlobal::iconSet (":/hd_16px.png", ":/hd_disabled_16px.png"); - pxCD = VBoxGlobal::iconSet (":/cd_16px.png", ":/cd_disabled_16px.png"); - pxFD = VBoxGlobal::iconSet (":/fd_16px.png", ":/fd_disabled_16px.png"); - - /* setup tab widget icons */ - twImages->setTabIconSet (twImages->page (0), pxHD); - twImages->setTabIconSet (twImages->page (1), pxCD); - twImages->setTabIconSet (twImages->page (2), pxFD); - - /* setup image list views */ - hdsView->setColumnAlignment (1, Qt::AlignRight); - hdsView->setColumnAlignment (2, Qt::AlignRight); - hdsView->header()->setStretchEnabled (false); - hdsView->header()->setStretchEnabled (true, 0); - - fdsView->setColumnAlignment (1, Qt::AlignRight); - fdsView->header()->setStretchEnabled (false); - fdsView->header()->setStretchEnabled (true, 0); - - cdsView->setColumnAlignment (1, Qt::AlignRight); - cdsView->header()->setStretchEnabled (false); - cdsView->header()->setStretchEnabled (true, 0); - - - /* setup list-view's item tooltip */ - hdsView->setShowToolTips (false); - cdsView->setShowToolTips (false); - fdsView->setShowToolTips (false); - connect (hdsView, SIGNAL (onItem (Q3ListViewItem*)), - this, SLOT (mouseOnItem(Q3ListViewItem*))); - connect (cdsView, SIGNAL (onItem (Q3ListViewItem*)), - this, SLOT (mouseOnItem(Q3ListViewItem*))); - connect (fdsView, SIGNAL (onItem (Q3ListViewItem*)), - this, SLOT (mouseOnItem(Q3ListViewItem*))); - - - /* status-bar currently disabled */ - /// @todo we must enable it and disable our size grip hack! - /// (at least, to have action help text showh) - statusBar()->setHidden (true); - - - /* context menu composing */ - itemMenu = new Q3PopupMenu (this, "itemMenu"); - - imNewAction = new QAction (this, "imNewAction"); - imAddAction = new QAction (this, "imAddAction"); - // imEditAction = new QAction (this, "imEditAction"); - imRemoveAction = new QAction (this, "imRemoveAction"); - imReleaseAction = new QAction (this, "imReleaseAction"); - imRefreshAction = new QAction (this, "imRefreshAction"); - - connect (imNewAction, SIGNAL (activated()), - this, SLOT (newImage())); - connect (imAddAction, SIGNAL (activated()), - this, SLOT (addImage())); - // connect (imEditAction, SIGNAL (activated()), - // this, SLOT (editImage())); - connect (imRemoveAction, SIGNAL (activated()), - this, SLOT (removeImage())); - connect (imReleaseAction, SIGNAL (activated()), - this, SLOT (releaseImage())); - connect (imRefreshAction, SIGNAL (activated()), - this, SLOT (refreshAll())); - - imNewAction->setIconSet (VBoxGlobal::iconSetEx ( - ":/vdm_new_22px.png", ":/vdm_new_16px.png", - ":/vdm_new_disabled_22px.png", ":/vdm_new_disabled_16px.png")); - imAddAction->setIconSet (VBoxGlobal::iconSetEx ( - ":/vdm_add_22px.png", ":/vdm_add_16px.png", - ":/vdm_add_disabled_22px.png", ":/vdm_add_disabled_16px.png")); - // imEditAction->setIconSet (VBoxGlobal::iconSet (":/guesttools_16px.png", ":/guesttools_disabled_16px.png")); - imRemoveAction->setIconSet (VBoxGlobal::iconSetEx ( - ":/vdm_remove_22px.png", ":/vdm_remove_16px.png", - ":/vdm_remove_disabled_22px.png", ":/vdm_remove_disabled_16px.png")); - imReleaseAction->setIconSet (VBoxGlobal::iconSetEx ( - ":/vdm_release_22px.png", ":/vdm_release_16px.png", - ":/vdm_release_disabled_22px.png", ":/vdm_release_disabled_16px.png")); - imRefreshAction->setIconSet (VBoxGlobal::iconSetEx ( - ":/refresh_22px.png", ":/refresh_16px.png", - ":/refresh_disabled_22px.png", ":/refresh_disabled_16px.png")); - - // imEditAction->addTo (itemMenu); - imRemoveAction->addTo (itemMenu); - imReleaseAction->addTo (itemMenu); - - - /* toolbar composing */ -#warning port me -// toolBar = new VBoxToolBar (this, centralWidget()); - toolBar->setSizePolicy (QSizePolicy::Fixed, QSizePolicy::Minimum); - ((Q3VBoxLayout*)centralWidget()->layout())->insertWidget(0, toolBar); - - toolBar->setUsesTextLabel (true); - toolBar->setUsesBigPixmaps (true); - - imNewAction->addTo (toolBar); - imAddAction->addTo (toolBar); - toolBar->addSeparator(); - // imEditAction->addTo (toolBar); - imRemoveAction->addTo (toolBar); - imReleaseAction->addTo (toolBar); - toolBar->addSeparator(); - imRefreshAction->addTo (toolBar); -#ifdef Q_WS_MAC - toolBar->setMacStyle(); -#endif - - - /* menu bar */ - Q3PopupMenu *actionMenu = new Q3PopupMenu (this, "actionMenu"); - imNewAction->addTo (actionMenu); - imAddAction->addTo (actionMenu); - actionMenu->insertSeparator(); - // imEditAction->addTo (toolBar); - imRemoveAction->addTo (actionMenu); - imReleaseAction->addTo (actionMenu); - actionMenu->insertSeparator(); - imRefreshAction->addTo (actionMenu); - menuBar()->insertItem (QString::null, actionMenu, 1); - - - /* setup size grip */ - sizeGrip = new QSizeGrip (centralWidget(), "sizeGrip"); - sizeGrip->resize (sizeGrip->sizeHint()); - sizeGrip->stackUnder(buttonOk); - - /* setup information pane */ - QApplication::setGlobalMouseTracking (true); - qApp->installEventFilter (this); - /* setup information pane layouts */ - Q3GridLayout *hdsContainerLayout = new Q3GridLayout (hdsContainer, 4, 4); - hdsContainerLayout->setMargin (10); - Q3GridLayout *cdsContainerLayout = new Q3GridLayout (cdsContainer, 2, 4); - cdsContainerLayout->setMargin (10); - Q3GridLayout *fdsContainerLayout = new Q3GridLayout (fdsContainer, 2, 4); - fdsContainerLayout->setMargin (10); - /* create info-pane for hd list-view */ - createInfoString (hdsPane1, hdsContainer, 0, -1); - createInfoString (hdsPane2, hdsContainer, 1, 0); - createInfoString (hdsPane3, hdsContainer, 1, 1); - createInfoString (hdsPane4, hdsContainer, 2, 0); - createInfoString (hdsPane5, hdsContainer, 2, 1); - /* create info-pane for cd list-view */ - createInfoString (cdsPane1, cdsContainer, 0, -1); - createInfoString (cdsPane2, cdsContainer, 1, -1); - /* create info-pane for fd list-view */ - createInfoString (fdsPane1, fdsContainer, 0, -1); - createInfoString (fdsPane2, fdsContainer, 1, -1); - - - /* enumeration progressbar creation */ - mProgressText = new QLabel (centralWidget()); - mProgressText->setHidden (true); -#warning port me -// buttonLayout->insertWidget (2, mProgressText); - mProgressBar = new Q3ProgressBar (centralWidget()); - mProgressBar->setHidden (true); - mProgressBar->setFrameShadow (Q3Frame::Sunken); - mProgressBar->setFrameShape (Q3Frame::Panel); - mProgressBar->setPercentageVisible (false); - mProgressBar->setMaximumWidth (100); -#warning port me -// buttonLayout->insertWidget (3, mProgressBar); - - - /* applying language settings */ - languageChangeImp(); -} - - -void VBoxDiskImageManagerDlg::languageChangeImp() -{ - imNewAction->setMenuText (tr ("&New...")); - imAddAction->setMenuText (tr ("&Add...")); - // imEditAction->setMenuText (tr ("&Edit...")); - imRemoveAction->setMenuText (tr ("R&emove")); - imReleaseAction->setMenuText (tr ("Re&lease")); - imRefreshAction->setMenuText (tr ("Re&fresh")); - - imNewAction->setText (tr ("New")); - imAddAction->setText (tr ("Add")); - // imEditAction->setText (tr ("Edit")); - imRemoveAction->setText (tr ("Remove")); - imReleaseAction->setText (tr ("Release")); - imRefreshAction->setText (tr ("Refresh")); - - imNewAction->setAccel (tr ("Ctrl+N")); - imAddAction->setAccel (tr ("Ctrl+A")); - // imEditAction->setAccel (tr ("Ctrl+E")); - imRemoveAction->setAccel (tr ("Ctrl+D")); - imReleaseAction->setAccel (tr ("Ctrl+L")); - imRefreshAction->setAccel (tr ("Ctrl+R")); - - imNewAction->setStatusTip (tr ("Create a new virtual hard disk")); - imAddAction->setStatusTip (tr ("Add (register) an existing image file")); - // imEditAction->setStatusTip (tr ("Edit the properties of the selected item")); - imRemoveAction->setStatusTip (tr ("Remove (unregister) the selected media")); - imReleaseAction->setStatusTip (tr ("Release the selected media by detaching it from the machine")); - imRefreshAction->setStatusTip (tr ("Refresh the media list")); - - if (menuBar()->findItem(1)) - menuBar()->findItem(1)->setText (tr ("&Actions")); - - hdsPane1->label()->setText (QString ("%1:").arg (tr ("Location"))); - hdsPane2->label()->setText (QString ("%1:").arg (tr ("Disk Type"))); - hdsPane3->label()->setText (QString ("  %1:").arg (tr ("Storage Type"))); - hdsPane4->label()->setText (QString ("%1:").arg (tr ("Attached to"))); - hdsPane5->label()->setText (QString ("  %1:").arg (tr ("Snapshot"))); - cdsPane1->label()->setText (QString ("%1:").arg (tr ("Location"))); - cdsPane2->label()->setText (QString ("%1:").arg (tr ("Attached to"))); - fdsPane1->label()->setText (QString ("%1:").arg (tr ("Location"))); - fdsPane2->label()->setText (QString ("%1:").arg (tr ("Attached to"))); - - mProgressText->setText (tr ("Checking accessibility")); - - if (hdsView->childCount() || cdsView->childCount() || fdsView->childCount()) - refreshAll(); -} - - -void VBoxDiskImageManagerDlg::createInfoString (InfoPaneLabel *&aInfo, - QWidget *aRoot, - int aRow, int aColumn) -{ - QLabel *nameLabel = new QLabel (aRoot); - aInfo = new InfoPaneLabel (aRoot, nameLabel); - - /* Setup focus policy default for info pane */ - aInfo->setFocusPolicy (Qt::StrongFocus); - - /* prevent the name columns from being expanded */ - nameLabel->setSizePolicy (QSizePolicy::Fixed, QSizePolicy::Fixed); - - if (aColumn == -1) - { - ((Q3GridLayout *) aRoot->layout())->addWidget (nameLabel, aRow, 0); - ((Q3GridLayout *) aRoot->layout())-> - addMultiCellWidget (aInfo, aRow, aRow, - 1, ((Q3GridLayout *) aRoot->layout())->numCols() - 1); - } - else - { - ((Q3GridLayout *) aRoot->layout())->addWidget (nameLabel, aRow, aColumn * 2); - ((Q3GridLayout *) aRoot->layout())->addWidget (aInfo, aRow, aColumn * 2 + 1); - } -} - - -void VBoxDiskImageManagerDlg::showEvent (QShowEvent *e) -{ - Q3MainWindow::showEvent (e); - - /* one may think that QWidget::polish() is the right place to do things - * below, but apparently, by the time when QWidget::polish() is called, - * the widget style & layout are not fully done, at least the minimum - * size hint is not properly calculated. Since this is sometimes necessary, - * we provide our own "polish" implementation. */ - - if (polished) - return; - - polished = true; - - VBoxGlobal::centerWidget (this, parentWidget()); -} - - -void VBoxDiskImageManagerDlg::mouseOnItem (Q3ListViewItem *aItem) -{ - Q3ListView *currentList = getCurrentListView(); - QString tip; - switch (aItem->rtti()) - { - case DiskImageItem::TypeId: - tip = static_cast (aItem)->getToolTip(); - break; - default: - Assert (0); - } - QToolTip::add (currentList->viewport(), currentList->itemRect (aItem), tip); -} - - -void VBoxDiskImageManagerDlg::resizeEvent (QResizeEvent*) -{ - sizeGrip->move (centralWidget()->rect().bottomRight() - - QPoint(sizeGrip->rect().width() - 1, sizeGrip->rect().height() - 1)); -} - - -void VBoxDiskImageManagerDlg::closeEvent (QCloseEvent *aEvent) -{ - mModelessDialog = 0; - aEvent->accept(); -} - - -void VBoxDiskImageManagerDlg::keyPressEvent (QKeyEvent *aEvent) -{ - if ( aEvent->state() == 0 || - (aEvent->state() & Qt::KeypadModifier && aEvent->key() == Qt::Key_Enter) ) - { - switch ( aEvent->key() ) - { - case Qt::Key_Enter: - case Qt::Key_Return: - { - QPushButton *currentDefault = searchDefaultButton(); - if (currentDefault) - currentDefault->animateClick(); - break; - } - case Qt::Key_Escape: - { - reject(); - break; - } - } - } - else - aEvent->ignore(); -} - - -QPushButton* VBoxDiskImageManagerDlg::searchDefaultButton() -{ - QPushButton *defButton = 0; - QObjectList list = queryList ("QPushButton"); - QListIterator it (list); - foreach(QObject *o, list) - { - defButton = qobject_cast (o); - if(defButton->isDefault()) - break; - } - return defButton; -} - - -int VBoxDiskImageManagerDlg::result() { return mRescode; } -void VBoxDiskImageManagerDlg::setResult (int aRescode) { mRescode = aRescode; } -void VBoxDiskImageManagerDlg::accept() { done( Accepted ); } -void VBoxDiskImageManagerDlg::reject() { done( Rejected ); } - -int VBoxDiskImageManagerDlg::exec() -{ - setResult (0); - - if (mInLoop) return result(); - show(); - mInLoop = true; -#warning port me -// qApp->eventLoop()->enterLoop(); - mInLoop = false; - - return result(); -} - -void VBoxDiskImageManagerDlg::done (int aResult) -{ - setResult (aResult); - - if (mInLoop) - { - hide(); -#warning port me -// qApp->eventLoop()->exitLoop(); - } - else - { - close(); - } -} - - -Q3ListView* VBoxDiskImageManagerDlg::getCurrentListView() -{ - Q3ListView *clv = static_cast(twImages->currentPage()-> - queryList("QListView").first()); - Assert(clv); - return clv; -} - -Q3ListView* VBoxDiskImageManagerDlg::getListView (VBoxDefs::DiskType aType) -{ - switch (aType) - { - case VBoxDefs::HD: - return hdsView; - case VBoxDefs::CD: - return cdsView; - case VBoxDefs::FD: - return fdsView; - default: - return 0; - } -} - - -bool VBoxDiskImageManagerDlg::eventFilter (QObject *aObject, QEvent *aEvent) -{ - Q3ListView *currentList = getCurrentListView(); - - switch (aEvent->type()) - { - case QEvent::DragEnter: - { - if (aObject == currentList) - { - QDragEnterEvent *dragEnterEvent = - static_cast(aEvent); - dragEnterEvent->acceptAction(); - return true; - } - break; - } - case QEvent::Drop: - { - if (aObject == currentList) - { - QDropEvent *dropEvent = - static_cast(aEvent); - QStringList *droppedList = new QStringList(); - Q3UriDrag::decodeLocalFiles (dropEvent, *droppedList); - QCustomEvent *updateEvent = new QCustomEvent (1001); - updateEvent->setData (droppedList); - QApplication::postEvent (currentList, updateEvent); - dropEvent->acceptAction(); - return true; - } - break; - } - case 1001: /* QCustomEvent 1001 - DnD Update Event */ - { - if (aObject == currentList) - { - QCustomEvent *updateEvent = - static_cast(aEvent); - addDroppedImages ((QStringList*) updateEvent->data()); - return true; - } - break; - } - case QEvent::FocusIn: - { - if (aObject->inherits ("QPushButton") && aObject->parent() == centralWidget()) - { - ((QPushButton*)aObject)->setDefault (aObject != defaultButton); - if (defaultButton) - defaultButton->setDefault (aObject == defaultButton); - } - break; - } - case QEvent::FocusOut: - { - if (aObject->inherits ("QPushButton") && aObject->parent() == centralWidget()) - { - if (defaultButton) - defaultButton->setDefault (aObject != defaultButton); - ((QPushButton*)aObject)->setDefault (aObject == defaultButton); - } - break; - } - default: - break; - } - return Q3MainWindow::eventFilter (aObject, aEvent); -} - - -bool VBoxDiskImageManagerDlg::event (QEvent *aEvent) -{ - bool result = Q3MainWindow::event (aEvent); - switch (aEvent->type()) - { - case QEvent::LanguageChange: - { - languageChangeImp(); - break; - } - default: - break; - } - return result; -} - - -void VBoxDiskImageManagerDlg::addDroppedImages (QStringList *aDroppedList) -{ - Q3ListView *currentList = getCurrentListView(); - - for (QStringList::Iterator it = (*aDroppedList).begin(); - it != (*aDroppedList).end(); ++it) - { - QString src = *it; - /* Check dropped media type */ - /// @todo On OS/2 and windows (and mac?) extension checks should be case - /// insensitive, as OPPOSED to linux and the rest where case matters. - VBoxDefs::DiskType type = VBoxDefs::InvalidType; - if (src.endsWith (".iso", false)) - { - if (currentList == cdsView) type = VBoxDefs::CD; - } - else if (src.endsWith (".img", false)) - { - if (currentList == fdsView) type = VBoxDefs::FD; - } - else if (src.endsWith (".vdi", false) || - src.endsWith (".vmdk", false)) - { - if (currentList == hdsView) type = VBoxDefs::HD; - } - /* If media type has been determined - attach this device */ - if (type) - { - addImageToList (*it, type); - if (!vbox.isOk()) - vboxProblem().cannotRegisterMedia (this, vbox, type, src); - } - } - delete aDroppedList; -} - - -void VBoxDiskImageManagerDlg::addImageToList (const QString &aSource, - VBoxDefs::DiskType aDiskType) -{ - if (aSource.isEmpty()) - return; - - QUuid uuid; - VBoxMedia media; - switch (aDiskType) - { - case VBoxDefs::HD: - { - CHardDisk hd = vbox.OpenHardDisk (aSource); - if (vbox.isOk()) - { - vbox.RegisterHardDisk (hd); - if (vbox.isOk()) - { - VBoxMedia::Status status = - hd.GetAccessible() ? VBoxMedia::Ok : - hd.isOk() ? VBoxMedia::Inaccessible : - VBoxMedia::Error; - media = VBoxMedia (CUnknown (hd), VBoxDefs::HD, status); - } - } - break; - } - case VBoxDefs::CD: - { - CDVDImage cd = vbox.OpenDVDImage (aSource, uuid); - if (vbox.isOk()) - { - vbox.RegisterDVDImage (cd); - if (vbox.isOk()) - { - VBoxMedia::Status status = - cd.GetAccessible() ? VBoxMedia::Ok : - cd.isOk() ? VBoxMedia::Inaccessible : - VBoxMedia::Error; - media = VBoxMedia (CUnknown (cd), VBoxDefs::CD, status); - } - } - break; - } - case VBoxDefs::FD: - { - CFloppyImage fd = vbox.OpenFloppyImage (aSource, uuid); - if (vbox.isOk()) - { - vbox.RegisterFloppyImage (fd); - if (vbox.isOk()) - { - VBoxMedia::Status status = - fd.GetAccessible() ? VBoxMedia::Ok : - fd.isOk() ? VBoxMedia::Inaccessible : - VBoxMedia::Error; - media = VBoxMedia (CUnknown (fd), VBoxDefs::FD, status); - } - } - break; - } - default: - AssertMsgFailed (("Invalid aDiskType type\n")); - } - if (media.type != VBoxDefs::InvalidType) - vboxGlobal().addMedia (media); -} - - -DiskImageItem* VBoxDiskImageManagerDlg::createImageNode (Q3ListView *aList, - DiskImageItem *aRoot, - const VBoxMedia &aMedia) -{ - DiskImageItem *item = 0; - - if (aRoot) - item = new DiskImageItem (aRoot); - else if (aList) - item = new DiskImageItem (aList); - else - Assert (0); - - item->setMedia (aMedia); - - return item; -} - - -void VBoxDiskImageManagerDlg::invokePopup (Q3ListViewItem *aItem, const QPoint & aPos, int) -{ - if (aItem) - itemMenu->popup(aPos); -} - - -QString VBoxDiskImageManagerDlg::getDVDImageUsage (const QUuid &aId, - QString &aSnapshotUsage) -{ - CVirtualBox vbox = vboxGlobal().virtualBox(); - - QStringList permMachines = - QStringList::split (' ', vbox.GetDVDImageUsage (aId, KResourceUsage_Permanent)); - QStringList tempMachines = - QStringList::split (' ', vbox.GetDVDImageUsage (aId, KResourceUsage_Temporary)); - - QString usage; - - for (QStringList::Iterator it = permMachines.begin(); - it != permMachines.end(); - ++it) - { - if (!usage.isEmpty()) - usage += ", "; - CMachine machine = vbox.GetMachine (QUuid (*it)); - usage += machine.GetName(); - - getDVDImageSnapshotUsage (aId, machine.GetSnapshot (QUuid()), - aSnapshotUsage); - } - - for (QStringList::Iterator it = tempMachines.begin(); - it != tempMachines.end(); - ++it) - { - /* skip IDs that are in the permanent list */ - if (!permMachines.contains (*it)) - { - if (!usage.isEmpty()) - usage += ", ["; - else - usage += "["; - CMachine machine = vbox.GetMachine (QUuid (*it)); - usage += machine.GetName() + "]"; - - getDVDImageSnapshotUsage (aId, machine.GetSnapshot (QUuid()), - aSnapshotUsage); - } - } - - return usage; -} - -QString VBoxDiskImageManagerDlg::getFloppyImageUsage (const QUuid &aId, - QString &aSnapshotUsage) -{ - CVirtualBox vbox = vboxGlobal().virtualBox(); - - QStringList permMachines = - QStringList::split (' ', vbox.GetFloppyImageUsage (aId, KResourceUsage_Permanent)); - QStringList tempMachines = - QStringList::split (' ', vbox.GetFloppyImageUsage (aId, KResourceUsage_Temporary)); - - QString usage; - - for (QStringList::Iterator it = permMachines.begin(); - it != permMachines.end(); - ++it) - { - if (!usage.isEmpty()) - usage += ", "; - CMachine machine = vbox.GetMachine (QUuid (*it)); - usage += machine.GetName(); - - getFloppyImageSnapshotUsage (aId, machine.GetSnapshot (QUuid()), - aSnapshotUsage); - } - - for (QStringList::Iterator it = tempMachines.begin(); - it != tempMachines.end(); - ++it) - { - /* skip IDs that are in the permanent list */ - if (!permMachines.contains (*it)) - { - if (!usage.isEmpty()) - usage += ", ["; - else - usage += "["; - CMachine machine = vbox.GetMachine (QUuid (*it)); - usage += machine.GetName() + "]"; - - getFloppyImageSnapshotUsage (aId, machine.GetSnapshot (QUuid()), - aSnapshotUsage); - } - } - - return usage; -} - - -void VBoxDiskImageManagerDlg::getDVDImageSnapshotUsage (const QUuid &aImageId, - const CSnapshot &aSnapshot, - QString &aUsage) -{ - if (aSnapshot.isNull()) - return; - - if (!aSnapshot.GetMachine().GetDVDDrive().GetImage().isNull() && - aSnapshot.GetMachine().GetDVDDrive().GetImage().GetId() == aImageId) - { - if (!aUsage.isEmpty()) - aUsage += ", "; - aUsage += aSnapshot.GetName(); - } - - CSnapshotEnumerator en = aSnapshot.GetChildren().Enumerate(); - while (en.HasMore()) - getDVDImageSnapshotUsage (aImageId, en.GetNext(), aUsage); -} - -void VBoxDiskImageManagerDlg::getFloppyImageSnapshotUsage (const QUuid &aImageId, - const CSnapshot &aSnapshot, - QString &aUsage) -{ - if (aSnapshot.isNull()) - return; - - if (!aSnapshot.GetMachine().GetFloppyDrive().GetImage().isNull() && - aSnapshot.GetMachine().GetFloppyDrive().GetImage().GetId() == aImageId) - { - if (!aUsage.isEmpty()) - aUsage += ", "; - aUsage += aSnapshot.GetName(); - } - - CSnapshotEnumerator en = aSnapshot.GetChildren().Enumerate(); - while (en.HasMore()) - getFloppyImageSnapshotUsage (aImageId, en.GetNext(), aUsage); -} - - -QString VBoxDiskImageManagerDlg::composeHdToolTip (CHardDisk &aHd, - VBoxMedia::Status aStatus, - DiskImageItem *aItem) -{ - CVirtualBox vbox = vboxGlobal().virtualBox(); - QUuid machineId = aItem ? aItem->getMachineId() : aHd.GetMachineId(); - - QString src = aItem ? aItem->getPath() : aHd.GetLocation(); - QString location = aItem || aHd.GetStorageType() == KHardDiskStorageType_ISCSIHardDisk ? src : - QDir::convertSeparators (QFileInfo (src).absFilePath()); - - QString storageType = aItem ? aItem->getStorageType() : - vboxGlobal().toString (aHd.GetStorageType()); - QString hardDiskType = aItem ? aItem->getDiskType() : - vboxGlobal().hardDiskTypeString (aHd); - - QString usage; - if (aItem) - usage = aItem->getUsage(); - else if (!machineId.isNull()) - usage = vbox.GetMachine (machineId).GetName(); - - QUuid snapshotId = aItem ? aItem->getUuid() : aHd.GetSnapshotId(); - QString snapshotName; - if (aItem) - snapshotName = aItem->getSnapshotName(); - else if (!machineId.isNull() && !snapshotId.isNull()) - { - CSnapshot snapshot = vbox.GetMachine (machineId). - GetSnapshot (aHd.GetSnapshotId()); - if (!snapshot.isNull()) - snapshotName = snapshot.GetName(); - } - - /* compose tool-tip information */ - QString tip; - switch (aStatus) - { - case VBoxMedia::Unknown: - { - tip = tr ("%1
" - "Checking accessibility...", "HDD") - .arg (location); - break; - } - case VBoxMedia::Ok: - { - tip = tr ("%1
" - "Disk type:  %2
" - "Storage type:  %3") - .arg (location) - .arg (hardDiskType) - .arg (storageType); - - if (!usage.isNull()) - tip += tr ("
Attached to:  %1", "HDD") - .arg (usage); - if (!snapshotName.isNull()) - tip += tr ("
Snapshot:  %5", "HDD") - .arg (snapshotName); - break; - } - case VBoxMedia::Error: - { - /// @todo (r=dmik) paass a complete VBoxMedia instance here - // to get the result of blabla.GetAccessible() call form CUnknown - tip = tr ("%1
" - "Error checking media accessibility", "HDD") - .arg (location); - break; - } - case VBoxMedia::Inaccessible: - { - tip = tr ("%1
%2", "HDD") - .arg (location) - .arg (VBoxGlobal::highlight (aHd.GetLastAccessError(), - true /* aToolTip */)); - break; - } - default: - AssertFailed(); - } - return tip; -} - -QString VBoxDiskImageManagerDlg::composeCdToolTip (CDVDImage &aCd, - VBoxMedia::Status aStatus, - DiskImageItem *aItem) -{ - QString location = aItem ? aItem->getPath() : - QDir::convertSeparators (QFileInfo (aCd.GetFilePath()).absFilePath()); - QUuid uuid = aItem ? aItem->getUuid() : aCd.GetId(); - QString usage; - if (aItem) - usage = aItem->getTotalUsage(); - else - { - QString snapshotUsage; - usage = getDVDImageUsage (uuid, snapshotUsage); - /* should correlate with DiskImageItem::getTotalUsage() */ - if (!snapshotUsage.isNull()) - usage = QString ("%1 (%2)").arg (usage, snapshotUsage); - } - - /* compose tool-tip information */ - QString tip; - switch (aStatus) - { - case VBoxMedia::Unknown: - { - tip = tr ("%1
" - "Checking accessibility...", "CD/DVD/Floppy") - .arg (location); - break; - } - case VBoxMedia::Ok: - { - tip = tr ("%1", "CD/DVD/Floppy") - .arg (location); - - if (!usage.isNull()) - tip += tr ("
Attached to:  %1", - "CD/DVD/Floppy") - .arg (usage); - break; - } - case VBoxMedia::Error: - { - /// @todo (r=dmik) paass a complete VBoxMedia instance here - // to get the result of blabla.GetAccessible() call form CUnknown - tip = tr ("%1
" - "Error checking media accessibility", "CD/DVD/Floppy") - .arg (location); - break; - } - case VBoxMedia::Inaccessible: - { - /// @todo (r=dmik) correct this when GetLastAccessError() is - // implemented for IDVDImage - tip = tr ("%1
%2") - .arg (location) - .arg (tr ("The image file is not accessible", - "CD/DVD/Floppy")); - break; - } - default: - AssertFailed(); - } - return tip; -} - -QString VBoxDiskImageManagerDlg::composeFdToolTip (CFloppyImage &aFd, - VBoxMedia::Status aStatus, - DiskImageItem *aItem) -{ - QString location = aItem ? aItem->getPath() : - QDir::convertSeparators (QFileInfo (aFd.GetFilePath()).absFilePath()); - QUuid uuid = aItem ? aItem->getUuid() : aFd.GetId(); - QString usage; - if (aItem) - usage = aItem->getTotalUsage(); - else - { - QString snapshotUsage; - usage = getFloppyImageUsage (uuid, snapshotUsage); - /* should correlate with DiskImageItem::getTotalUsage() */ - if (!snapshotUsage.isNull()) - usage = QString ("%1 (%2)").arg (usage, snapshotUsage); - } - - /* compose tool-tip information */ - QString tip; - switch (aStatus) - { - case VBoxMedia::Unknown: - { - tip = tr ("%1
" - "Checking accessibility...", "CD/DVD/Floppy") - .arg (location); - break; - } - case VBoxMedia::Ok: - { - tip = tr ("%1", "CD/DVD/Floppy") - .arg (location); - - if (!usage.isNull()) - tip += tr ("
Attached to:  %1", - "CD/DVD/Floppy") - .arg (usage); - break; - } - case VBoxMedia::Error: - { - /// @todo (r=dmik) paass a complete VBoxMedia instance here - // to get the result of blabla.GetAccessible() call form CUnknown - tip = tr ("%1
" - "Error checking media accessibility", "CD/DVD/Floppy") - .arg (location); - break; - } - case VBoxMedia::Inaccessible: - { - /// @todo (r=dmik) correct this when GetLastAccessError() is - // implemented for IDVDImage - tip = tr ("%1
%2") - .arg (location) - .arg (tr ("The image file is not accessible", - "CD/DVD/Floppy")); - break; - } - default: - AssertFailed(); - } - return tip; -} - - -void VBoxDiskImageManagerDlg::updateHdItem (DiskImageItem *aItem, - const VBoxMedia &aMedia) -{ - if (!aItem) - return; - - CHardDisk hd = aMedia.disk; - VBoxMedia::Status status = aMedia.status; - - QUuid uuid = hd.GetId(); - QString src = hd.GetLocation(); - QUuid machineId = hd.GetMachineId(); - QString usage; - if (!machineId.isNull()) - usage = vbox.GetMachine (machineId).GetName(); - QString storageType = vboxGlobal().toString (hd.GetStorageType()); - QString hardDiskType = vboxGlobal().hardDiskTypeString (hd); - QString virtualSize = status == VBoxMedia::Ok ? - vboxGlobal().formatSize ((ULONG64)hd.GetSize() * _1M) : QString ("--"); - QString actualSize = status == VBoxMedia::Ok ? - vboxGlobal().formatSize (hd.GetActualSize()) : QString ("--"); - QString snapshotName; - if (!machineId.isNull() && !hd.GetSnapshotId().isNull()) - { - CSnapshot snapshot = vbox.GetMachine (machineId). - GetSnapshot (hd.GetSnapshotId()); - if (!snapshot.isNull()) - snapshotName = QString ("%1").arg (snapshot.GetName()); - } - QFileInfo fi (src); - - aItem->setText (0, fi.fileName()); - aItem->setText (1, virtualSize); - aItem->setText (2, actualSize); - aItem->setPath (hd.GetStorageType() == KHardDiskStorageType_ISCSIHardDisk ? src : - QDir::convertSeparators (fi.absFilePath())); - aItem->setUsage (usage); - aItem->setSnapshotName (snapshotName); - aItem->setDiskType (hardDiskType); - aItem->setStorageType (storageType); - aItem->setVirtualSize (virtualSize); - aItem->setActualSize (actualSize); - aItem->setUuid (uuid); - aItem->setMachineId (machineId); - aItem->setToolTip (composeHdToolTip (hd, status, aItem)); - aItem->setStatus (status); - - makeWarningMark (aItem, aMedia.status, VBoxDefs::HD); -} - -void VBoxDiskImageManagerDlg::updateCdItem (DiskImageItem *aItem, - const VBoxMedia &aMedia) -{ - if (!aItem) - return; - - CDVDImage cd = aMedia.disk; - VBoxMedia::Status status = aMedia.status; - - QUuid uuid = cd.GetId(); - QString src = cd.GetFilePath(); - QString snapshotUsage; - QString usage = getDVDImageUsage (uuid, snapshotUsage); - QString size = status == VBoxMedia::Ok ? - vboxGlobal().formatSize (cd.GetSize()) : QString ("--"); - QFileInfo fi (src); - - aItem->setText (0, fi.fileName()); - aItem->setText (1, size); - aItem->setPath (QDir::convertSeparators (fi.absFilePath ())); - aItem->setUsage (usage); - aItem->setSnapshotUsage (snapshotUsage); - aItem->setActualSize (size); - aItem->setUuid (uuid); - aItem->setToolTip (composeCdToolTip (cd, status, aItem)); - aItem->setStatus (status); - - makeWarningMark (aItem, aMedia.status, VBoxDefs::CD); -} - -void VBoxDiskImageManagerDlg::updateFdItem (DiskImageItem *aItem, - const VBoxMedia &aMedia) -{ - if (!aItem) - return; - - CFloppyImage fd = aMedia.disk; - VBoxMedia::Status status = aMedia.status; - - QUuid uuid = fd.GetId(); - QString src = fd.GetFilePath(); - QString snapshotUsage; - QString usage = getFloppyImageUsage (uuid, snapshotUsage); - QString size = status == VBoxMedia::Ok ? - vboxGlobal().formatSize (fd.GetSize()) : QString ("--"); - QFileInfo fi (src); - - aItem->setText (0, fi.fileName()); - aItem->setText (1, size); - aItem->setPath (QDir::convertSeparators (fi.absFilePath ())); - aItem->setUsage (usage); - aItem->setSnapshotUsage (snapshotUsage); - aItem->setActualSize (size); - aItem->setUuid (uuid); - aItem->setToolTip (composeFdToolTip (fd, status, aItem)); - aItem->setStatus (status); - - makeWarningMark (aItem, aMedia.status, VBoxDefs::FD); -} - - -DiskImageItem* VBoxDiskImageManagerDlg::createHdItem (Q3ListView *aList, - const VBoxMedia &aMedia) -{ - CHardDisk hd = aMedia.disk; - QUuid rootId = hd.GetParent().isNull() ? QUuid() : hd.GetParent().GetId(); - DiskImageItem *root = searchItem (aList, rootId); - DiskImageItem *item = createImageNode (aList, root, aMedia); - updateHdItem (item, aMedia); - return item; -} - -DiskImageItem* VBoxDiskImageManagerDlg::createCdItem (Q3ListView *aList, - const VBoxMedia &aMedia) -{ - DiskImageItem *item = createImageNode (aList, 0, aMedia); - updateCdItem (item, aMedia); - return item; -} - -DiskImageItem* VBoxDiskImageManagerDlg::createFdItem (Q3ListView *aList, - const VBoxMedia &aMedia) -{ - DiskImageItem *item = createImageNode (aList, 0, aMedia); - updateFdItem (item, aMedia); - return item; -} - - -void VBoxDiskImageManagerDlg::makeWarningMark (DiskImageItem *aItem, - VBoxMedia::Status aStatus, - VBoxDefs::DiskType aType) -{ - const QPixmap &pm = aStatus == VBoxMedia::Inaccessible ? pxInaccessible : - aStatus == VBoxMedia::Error ? pxErroneous : QPixmap(); - - if (!pm.isNull()) - { - aItem->setPixmap (0, pm); - QIcon iconSet (pm); - QWidget *wt = aType == VBoxDefs::HD ? twImages->page (0) : - aType == VBoxDefs::CD ? twImages->page (1) : - aType == VBoxDefs::FD ? twImages->page (2) : 0; - Assert (wt); /* aType should be correct */ - twImages->changeTab (wt, iconSet, twImages->tabLabel (wt)); - aItem->listView()->ensureItemVisible (aItem); - } -} - - -DiskImageItem* VBoxDiskImageManagerDlg::searchItem (Q3ListView *aList, - const QUuid &aId) -{ - if (aId.isNull()) return 0; - DiskImageItemIterator iterator (aList); - while (*iterator) - { - if ((*iterator)->getUuid() == aId) - return *iterator; - ++iterator; - } - return 0; -} - - -DiskImageItem* VBoxDiskImageManagerDlg::searchItem (Q3ListView *aList, - VBoxMedia::Status aStatus) -{ - DiskImageItemIterator iterator (aList); - while (*iterator) - { - if ((*iterator)->getStatus() == aStatus) - return *iterator; - ++iterator; - } - return 0; -} - - -void VBoxDiskImageManagerDlg::setup (int aType, bool aDoSelect, - const QUuid *aTargetVMId /* = NULL */, - bool aRefresh /* = true */, - CMachine machine /* = NULL */, - const QUuid &aHdId, - const QUuid &aCdId, - const QUuid &aFdId) -{ - cmachine = machine; - hdSelectedId = aHdId; - cdSelectedId = aCdId; - fdSelectedId = aFdId; - - type = aType; - twImages->setTabEnabled (twImages->page(0), type & VBoxDefs::HD); - twImages->setTabEnabled (twImages->page(1), type & VBoxDefs::CD); - twImages->setTabEnabled (twImages->page(2), type & VBoxDefs::FD); - - doSelect = aDoSelect; - if (aTargetVMId) - targetVMId = *aTargetVMId; - - if (doSelect) - buttonOk->setText (tr ("&Select")); - else - buttonCancel->setShown (false); - - /* listen to "media enumeration started" signals */ - connect (&vboxGlobal(), SIGNAL (mediaEnumStarted()), - this, SLOT (mediaEnumStarted())); - /* listen to "media enumeration" signals */ - connect (&vboxGlobal(), SIGNAL (mediaEnumerated (const VBoxMedia &, int)), - this, SLOT (mediaEnumerated (const VBoxMedia &, int))); - /* listen to "media enumeration finished" signals */ - connect (&vboxGlobal(), SIGNAL (mediaEnumFinished (const VBoxMediaList &)), - this, SLOT (mediaEnumFinished (const VBoxMediaList &))); - - /* listen to "media add" signals */ - connect (&vboxGlobal(), SIGNAL (mediaAdded (const VBoxMedia &)), - this, SLOT (mediaAdded (const VBoxMedia &))); - /* listen to "media update" signals */ - connect (&vboxGlobal(), SIGNAL (mediaUpdated (const VBoxMedia &)), - this, SLOT (mediaUpdated (const VBoxMedia &))); - /* listen to "media remove" signals */ - connect (&vboxGlobal(), SIGNAL (mediaRemoved (VBoxDefs::DiskType, const QUuid &)), - this, SLOT (mediaRemoved (VBoxDefs::DiskType, const QUuid &))); - - if (aRefresh && !vboxGlobal().isMediaEnumerationStarted()) - { - vboxGlobal().startEnumeratingMedia(); - } - else - { - /* insert already enumerated media */ - const VBoxMediaList &list = vboxGlobal().currentMediaList(); - prepareToRefresh (list.size()); - VBoxMediaList::const_iterator it; - int index = 0; - for (it = list.begin(); it != list.end(); ++ it) - { - mediaAdded (*it); - if ((*it).status != VBoxMedia::Unknown) - mProgressBar->setProgress (++ index); - } - - /* emulate the finished signal to reuse the code */ - if (!vboxGlobal().isMediaEnumerationStarted()) - mediaEnumFinished (list); - } - - /* for a newly opened dialog, select the first item */ - if (!hdsView->selectedItem()) - setCurrentItem (hdsView, hdsView->firstChild()); - if (!cdsView->selectedItem()) - setCurrentItem (cdsView, cdsView->firstChild()); - if (!fdsView->selectedItem()) - setCurrentItem (fdsView, fdsView->firstChild()); -} - - -void VBoxDiskImageManagerDlg::mediaEnumStarted() -{ - /* load default tab icons */ - twImages->changeTab (twImages->page (0), pxHD, - twImages->tabLabel (twImages->page (0))); - twImages->changeTab (twImages->page (1), pxCD, - twImages->tabLabel (twImages->page (1))); - twImages->changeTab (twImages->page (2), pxFD, - twImages->tabLabel (twImages->page (2))); - - /* load current media list */ - const VBoxMediaList &list = vboxGlobal().currentMediaList(); - prepareToRefresh (list.size()); - VBoxMediaList::const_iterator it; - for (it = list.begin(); it != list.end(); ++ it) - mediaAdded (*it); - - /* select the first item if the previous saved item is not found - * or no current item at all */ - if (!hdsView->currentItem() || !hdSelectedId.isNull()) - setCurrentItem (hdsView, hdsView->firstChild()); - if (!cdsView->currentItem() || !cdSelectedId.isNull()) - setCurrentItem (cdsView, cdsView->firstChild()); - if (!fdsView->currentItem() || !fdSelectedId.isNull()) - setCurrentItem (fdsView, fdsView->firstChild()); - - processCurrentChanged(); -} - -void VBoxDiskImageManagerDlg::mediaEnumerated (const VBoxMedia &aMedia, - int aIndex) -{ - mediaUpdated (aMedia); - Assert (aMedia.status != VBoxMedia::Unknown); - if (aMedia.status != VBoxMedia::Unknown) - mProgressBar->setProgress (aIndex + 1); -} - -void VBoxDiskImageManagerDlg::mediaEnumFinished (const VBoxMediaList &/* aList */) -{ - mProgressBar->setHidden (true); - mProgressText->setHidden (true); - - imRefreshAction->setEnabled (true); - unsetCursor(); - - /* adjust columns (it is strange to repeat but it works) */ - - hdsView->adjustColumn (1); - hdsView->adjustColumn (2); - hdsView->adjustColumn (1); - - cdsView->adjustColumn (1); - cdsView->adjustColumn (2); - cdsView->adjustColumn (1); - - fdsView->adjustColumn (1); - fdsView->adjustColumn (2); - fdsView->adjustColumn (1); - - processCurrentChanged(); -} - - -void VBoxDiskImageManagerDlg::mediaAdded (const VBoxMedia &aMedia) -{ - /* ignore non-interesting aMedia */ - if (!(type & aMedia.type)) - return; - - DiskImageItem *item = 0; - switch (aMedia.type) - { - case VBoxDefs::HD: - item = createHdItem (hdsView, aMedia); - if (item->getUuid() == hdSelectedId) - { - setCurrentItem (hdsView, item); - hdSelectedId = QUuid(); - } - break; - case VBoxDefs::CD: - item = createCdItem (cdsView, aMedia); - if (item->getUuid() == cdSelectedId) - { - setCurrentItem (cdsView, item); - cdSelectedId = QUuid(); - } - break; - case VBoxDefs::FD: - item = createFdItem (fdsView, aMedia); - if (item->getUuid() == fdSelectedId) - { - setCurrentItem (fdsView, item); - fdSelectedId = QUuid(); - } - break; - default: - AssertMsgFailed (("Invalid aMedia type\n")); - } - - if (!item) - return; - - if (!vboxGlobal().isMediaEnumerationStarted()) - setCurrentItem (getListView (aMedia.type), item); - if (item == getCurrentListView()->currentItem()) - processCurrentChanged (item); -} - -void VBoxDiskImageManagerDlg::mediaUpdated (const VBoxMedia &aMedia) -{ - /* ignore non-interesting aMedia */ - if (!(type & aMedia.type)) - return; - - DiskImageItem *item = 0; - switch (aMedia.type) - { - case VBoxDefs::HD: - { - CHardDisk hd = aMedia.disk; - item = searchItem (hdsView, hd.GetId()); - updateHdItem (item, aMedia); - break; - } - case VBoxDefs::CD: - { - CDVDImage cd = aMedia.disk; - item = searchItem (cdsView, cd.GetId()); - updateCdItem (item, aMedia); - break; - } - case VBoxDefs::FD: - { - CFloppyImage fd = aMedia.disk; - item = searchItem (fdsView, fd.GetId()); - updateFdItem (item, aMedia); - break; - } - default: - AssertMsgFailed (("Invalid aMedia type\n")); - } - - if (!item) - return; - - /* note: current items on invisible tabs are not updated because - * it is always done in processCurrentChanged() when the user switches - * to an invisible tab */ - if (item == getCurrentListView()->currentItem()) - processCurrentChanged (item); -} - -void VBoxDiskImageManagerDlg::mediaRemoved (VBoxDefs::DiskType aType, - const QUuid &aId) -{ - Q3ListView *listView = getListView (aType); - DiskImageItem *item = searchItem (listView, aId); - delete item; - setCurrentItem (listView, listView->currentItem()); - /* search the list for inaccessible media */ - if (!searchItem (listView, VBoxMedia::Inaccessible) && - !searchItem (listView, VBoxMedia::Error)) - { - QWidget *wt = aType == VBoxDefs::HD ? twImages->page (0) : - aType == VBoxDefs::CD ? twImages->page (1) : - aType == VBoxDefs::FD ? twImages->page (2) : 0; - const QIcon &set = aType == VBoxDefs::HD ? pxHD : - aType == VBoxDefs::CD ? pxCD : - aType == VBoxDefs::FD ? pxFD : QIcon(); - Assert (wt && !set.isNull()); /* atype should be the correct one */ - twImages->changeTab (wt, set, twImages->tabLabel (wt)); - } -} - - -void VBoxDiskImageManagerDlg::machineStateChanged (const VBoxMachineStateChangeEvent &e) -{ - /// @todo (r=dmik) IVirtualBoxCallback::OnMachineStateChange - // must also expose the old state! In this case we won't need to cache - // the state value in every class in GUI that uses this signal. - - switch (e.state) - { - case KMachineState_PoweredOff: - case KMachineState_Aborted: - case KMachineState_Saved: - case KMachineState_Starting: - case KMachineState_Restoring: - { - refreshAll(); - break; - } - default: - break; - } -} - - -void VBoxDiskImageManagerDlg::clearInfoPanes() -{ - hdsPane1->clear(); - hdsPane2->clear(), hdsPane3->clear(); - hdsPane4->clear(), hdsPane5->clear(); - cdsPane1->clear(), cdsPane2->clear(); - fdsPane1->clear(), fdsPane2->clear(); -} - - -void VBoxDiskImageManagerDlg::prepareToRefresh (int aTotal) -{ - /* info panel clearing */ - clearInfoPanes(); - - /* prepare progressbar */ - if (mProgressBar) - { - mProgressBar->setProgress (0, aTotal); - mProgressBar->setHidden (false); - mProgressText->setHidden (false); - } - - imRefreshAction->setEnabled (false); - setCursor (QCursor (Qt::BusyCursor)); - - /* store the current list selections */ - - Q3ListViewItem *item; - DiskImageItem *di; - - item = hdsView->currentItem(); - di = (item && item->rtti() == DiskImageItem::TypeId) ? - static_cast (item) : 0; - if (hdSelectedId.isNull()) - hdSelectedId = di ? di->getUuid() : QUuid(); - - item = cdsView->currentItem(); - di = (item && item->rtti() == DiskImageItem::TypeId) ? - static_cast (item) : 0; - if (cdSelectedId.isNull()) - cdSelectedId = di ? di->getUuid() : QUuid(); - - item = fdsView->currentItem(); - di = (item && item->rtti() == DiskImageItem::TypeId) ? - static_cast (item) : 0; - if (fdSelectedId.isNull()) - fdSelectedId = di ? di->getUuid() : QUuid(); - - /* finally, clear all lists */ - hdsView->clear(); - cdsView->clear(); - fdsView->clear(); -} - - -void VBoxDiskImageManagerDlg::refreshAll() -{ - /* start enumerating media */ - vboxGlobal().startEnumeratingMedia(); -} - - -bool VBoxDiskImageManagerDlg::checkImage (DiskImageItem* aItem) -{ - QUuid itemId = aItem ? aItem->getUuid() : QUuid(); - if (itemId.isNull()) return false; - - Q3ListView* parentList = aItem->listView(); - if (parentList == hdsView) - { - CHardDisk hd = aItem->getMedia().disk; - QUuid machineId = hd.GetMachineId(); - if (machineId.isNull() || - (vbox.GetMachine (machineId).GetState() != KMachineState_PoweredOff && - vbox.GetMachine (machineId).GetState() != KMachineState_Aborted)) - return false; - } - else if (parentList == cdsView) - { - /* check if there is temporary usage: */ - QStringList tempMachines = - QStringList::split (' ', vbox.GetDVDImageUsage (itemId, - KResourceUsage_Temporary)); - if (!tempMachines.isEmpty()) - return false; - /* only permamently mounted .iso could be released */ - QStringList permMachines = - QStringList::split (' ', vbox.GetDVDImageUsage (itemId, - KResourceUsage_Permanent)); - for (QStringList::Iterator it = permMachines.begin(); - it != permMachines.end(); ++it) - if (vbox.GetMachine(QUuid (*it)).GetState() != KMachineState_PoweredOff && - vbox.GetMachine(QUuid (*it)).GetState() != KMachineState_Aborted) - return false; - } - else if (parentList == fdsView) - { - /* check if there is temporary usage: */ - QStringList tempMachines = - QStringList::split (' ', vbox.GetFloppyImageUsage (itemId, - KResourceUsage_Temporary)); - if (!tempMachines.isEmpty()) - return false; - /* only permamently mounted floppies could be released */ - QStringList permMachines = - QStringList::split (' ', vbox.GetFloppyImageUsage (itemId, - KResourceUsage_Permanent)); - for (QStringList::Iterator it = permMachines.begin(); - it != permMachines.end(); ++it) - if (vbox.GetMachine(QUuid (*it)).GetState() != KMachineState_PoweredOff && - vbox.GetMachine(QUuid (*it)).GetState() != KMachineState_Aborted) - return false; - } - else - { - return false; - } - return true; -} - - -void VBoxDiskImageManagerDlg::setCurrentItem (Q3ListView *aListView, - Q3ListViewItem *aItem) -{ - if (!aItem) - return; - - aListView->setCurrentItem (aItem); - aListView->setSelected (aListView->currentItem(), true); - aListView->ensureItemVisible (aListView->currentItem()); -} - - -void VBoxDiskImageManagerDlg::processCurrentChanged() -{ - Q3ListView *currentList = getCurrentListView(); - currentList->setFocus(); - - /* tab stop setup */ - setTabOrder (hdsView, hdsPane1); - setTabOrder (hdsPane1, hdsPane2); - setTabOrder (hdsPane2, hdsPane3); - setTabOrder (hdsPane3, hdsPane4); - setTabOrder (hdsPane4, hdsPane5); - setTabOrder (hdsPane5, buttonHelp); - - setTabOrder (cdsView, cdsPane1); - setTabOrder (cdsPane1, cdsPane2); - setTabOrder (cdsPane2, buttonHelp); - - setTabOrder (fdsView, fdsPane1); - setTabOrder (fdsPane1, fdsPane2); - setTabOrder (fdsPane2, buttonHelp); - - setTabOrder (buttonHelp, buttonOk); - setTabOrder (buttonOk, twImages); - - processCurrentChanged (currentList->currentItem()); -} - -void VBoxDiskImageManagerDlg::processCurrentChanged (Q3ListViewItem *aItem) -{ - DiskImageItem *item = aItem && aItem->rtti() == DiskImageItem::TypeId ? - static_cast (aItem) : 0; - - /* Ensures current item visible every time we are switching page */ - item->listView()->ensureItemVisible (item); - - bool notInEnum = !vboxGlobal().isMediaEnumerationStarted(); - bool modifyEnabled = notInEnum && - item && item->getUsage().isNull() && - !item->firstChild() && !item->getPath().isNull(); - bool releaseEnabled = item && !item->getUsage().isNull() && - item->getSnapshotUsage().isNull() && - checkImage (item) && - !item->parent() && !item->firstChild() && - item->getSnapshotName().isNull(); - bool newEnabled = notInEnum && - getCurrentListView() == hdsView ? true : false; - bool addEnabled = notInEnum; - - // imEditAction->setEnabled (modifyEnabled); - imRemoveAction->setEnabled (modifyEnabled); - imReleaseAction->setEnabled (releaseEnabled); - imNewAction->setEnabled (newEnabled); - imAddAction->setEnabled (addEnabled); - - // itemMenu->setItemVisible (itemMenu->idAt(0), modifyEnabled); - itemMenu->setItemEnabled (itemMenu->idAt(0), modifyEnabled); - itemMenu->setItemEnabled (itemMenu->idAt(1), releaseEnabled); - - if (doSelect) - { - bool selectEnabled = item && !item->parent() && - (!newEnabled || - (item->getUsage().isNull() || - item->getMachineId() == targetVMId)); - - buttonOk->setEnabled (selectEnabled); - } - - if (item) - { - if (item->listView() == hdsView) - { - hdsPane1->setText (item->getInformation (item->getPath(), true, "end")); - hdsPane2->setText (item->getInformation (item->getDiskType(), false)); - hdsPane3->setText (item->getInformation (item->getStorageType(), false)); - hdsPane4->setText (item->getInformation (item->getUsage())); - hdsPane5->setText (item->getInformation (item->getSnapshotName())); - } - else if (item->listView() == cdsView) - { - cdsPane1->setText (item->getInformation (item->getPath(), true, "end")); - cdsPane2->setText (item->getInformation (item->getTotalUsage())); - } - else if (item->listView() == fdsView) - { - fdsPane1->setText (item->getInformation (item->getPath(), true, "end")); - fdsPane2->setText (item->getInformation (item->getTotalUsage())); - } - } - else - clearInfoPanes(); -} - - -void VBoxDiskImageManagerDlg::processPressed (Q3ListViewItem * aItem) -{ - if (!aItem) - { - Q3ListView *currentList = getCurrentListView(); - currentList->setSelected (currentList->currentItem(), true); - } -} - - -void VBoxDiskImageManagerDlg::newImage() -{ - AssertReturnVoid (getCurrentListView() == hdsView); - - VBoxNewHDWzd dlg (this); - - if (dlg.exec() == QDialog::Accepted) - { - CHardDisk hd = dlg.hardDisk(); - VBoxMedia::Status status = - hd.GetAccessible() ? VBoxMedia::Ok : - hd.isOk() ? VBoxMedia::Inaccessible : - VBoxMedia::Error; - vboxGlobal().addMedia (VBoxMedia (CUnknown (hd), VBoxDefs::HD, status)); - } -} - - -void VBoxDiskImageManagerDlg::addImage() -{ - Q3ListView *currentList = getCurrentListView(); - DiskImageItem *item = - currentList->currentItem() && - currentList->currentItem()->rtti() == DiskImageItem::TypeId ? - static_cast (currentList->currentItem()) : 0; - - QString dir; - if (item && item->getStatus() == VBoxMedia::Ok) - dir = QFileInfo (item->getPath().stripWhiteSpace()).dirPath (true); - - if (dir.isEmpty()) - if (currentList == hdsView) - dir = vbox.GetSystemProperties().GetDefaultVDIFolder(); - - if (dir.isEmpty() || !QFileInfo (dir).exists()) - dir = vbox.GetHomeFolder(); - - QString title; - QString filter; - VBoxDefs::DiskType type = VBoxDefs::InvalidType; - - if (currentList == hdsView) - { - filter = tr ("All hard disk images (*.vdi; *.vmdk);;" - "Virtual Disk images (*.vdi);;" - "VMDK images (*.vmdk);;" - "All files (*)"); - title = tr ("Select a hard disk image file"); - type = VBoxDefs::HD; - } - else if (currentList == cdsView) - { - filter = tr ("CD/DVD-ROM images (*.iso);;" - "All files (*)"); - title = tr ("Select a CD/DVD-ROM disk image file"); - type = VBoxDefs::CD; - } - else if (currentList == fdsView) - { - filter = tr ("Floppy images (*.img);;" - "All files (*)"); - title = tr ("Select a floppy disk image file"); - type = VBoxDefs::FD; - } - else - { - AssertMsgFailed (("Root list should be equal to hdsView, cdsView or fdsView")); - } - - QString src = VBoxGlobal::getOpenFileName (dir, filter, this, title); - src = QDir::convertSeparators (src); - - addImageToList (src, type); - if (!vbox.isOk()) - vboxProblem().cannotRegisterMedia (this, vbox, type, src); -} - - -void VBoxDiskImageManagerDlg::removeImage() -{ - Q3ListView *currentList = getCurrentListView(); - DiskImageItem *item = - currentList->currentItem() && - currentList->currentItem()->rtti() == DiskImageItem::TypeId ? - static_cast (currentList->currentItem()) : 0; - AssertMsg (item, ("Current item must not be null")); - - QUuid uuid = item->getUuid(); - AssertMsg (!uuid.isNull(), ("Current item must have uuid")); - - QString src = item->getPath().stripWhiteSpace(); - VBoxDefs::DiskType type = VBoxDefs::InvalidType; - - if (currentList == hdsView) - { - type = VBoxDefs::HD; - bool deleteImage = false; - - /// @todo When creation of VMDK is implemented, we should - /// enable image deletion for them as well (use - /// GetStorageType() to define the correct cast). - CHardDisk disk = item->getMedia().disk; - if (disk.GetStorageType() == KHardDiskStorageType_VirtualDiskImage && - disk.GetParent().isNull() && /* must not be differencing (see below) */ - item->getStatus() == VBoxMedia::Ok) - { - int rc = vboxProblem().confirmHardDiskImageDeletion (this, src); - if (rc == QIMessageBox::Cancel) - return; - deleteImage = rc == QIMessageBox::Yes; - } - else - { - /// @todo note that differencing images are always automatically - /// deleted when unregistered, but the following message box - /// doesn't mention it. I keep it as is for now because - /// implementing the portability feature will most likely change - /// this behavior (we'll update the message afterwards). - if (!vboxProblem().confirmHardDiskUnregister (this, src)) - return; - } - - CHardDisk hd = vbox.UnregisterHardDisk (uuid); - if (!vbox.isOk()) - vboxProblem().cannotUnregisterMedia (this, vbox, type, src); - else if (deleteImage) - { - /// @todo When creation of VMDK is implemented, we should - /// enable image deletion for them as well (use - /// GetStorageType() to define the correct cast). - CVirtualDiskImage vdi = CUnknown (hd); - if (vdi.isOk()) - vdi.DeleteImage(); - if (!vdi.isOk()) - vboxProblem().cannotDeleteHardDiskImage (this, vdi); - } - } - else if (currentList == cdsView) - { - type = VBoxDefs::CD; - vbox.UnregisterDVDImage (uuid); - } - else if (currentList == fdsView) - { - type = VBoxDefs::FD; - vbox.UnregisterFloppyImage (uuid); - } - - if (vbox.isOk()) - vboxGlobal().removeMedia (type, uuid); - else - vboxProblem().cannotUnregisterMedia (this, vbox, type, src); -} - - -void VBoxDiskImageManagerDlg::releaseImage() -{ - Q3ListView *currentList = getCurrentListView(); - DiskImageItem *item = - currentList->currentItem() && - currentList->currentItem()->rtti() == DiskImageItem::TypeId ? - static_cast (currentList->currentItem()) : 0; - AssertMsg (item, ("Current item must not be null")); - - QUuid itemId = item->getUuid(); - AssertMsg (!itemId.isNull(), ("Current item must have uuid")); - - /* if it is a hard disk sub-item: */ - if (currentList == hdsView) - { - CHardDisk hd = item->getMedia().disk; - QUuid machineId = hd.GetMachineId(); - if (vboxProblem().confirmReleaseImage (this, - vbox.GetMachine (machineId).GetName())) - { - releaseDisk (machineId, itemId, VBoxDefs::HD); - VBoxMedia media (item->getMedia()); - media.status = hd.GetAccessible() ? VBoxMedia::Ok : - hd.isOk() ? VBoxMedia::Inaccessible : - VBoxMedia::Error; - vboxGlobal().updateMedia (media); - } - } - /* if it is a cd/dvd sub-item: */ - else if (currentList == cdsView) - { - QString usage = item->getTotalUsage(); - if (vboxProblem().confirmReleaseImage (this, usage)) - { - QStringList permMachines = - QStringList::split (' ', vbox.GetDVDImageUsage (itemId, - KResourceUsage_Permanent)); - for (QStringList::Iterator it = permMachines.begin(); - it != permMachines.end(); ++it) - releaseDisk (QUuid (*it), itemId, VBoxDefs::CD); - - CDVDImage cd = vbox.GetDVDImage (itemId); - VBoxMedia media (item->getMedia()); - media.status = cd.GetAccessible() ? VBoxMedia::Ok : - cd.isOk() ? VBoxMedia::Inaccessible : - VBoxMedia::Error; - vboxGlobal().updateMedia (media); - } - } - /* if it is a floppy sub-item: */ - else if (currentList == fdsView) - { - QString usage = item->getTotalUsage(); - if (vboxProblem().confirmReleaseImage (this, usage)) - { - QStringList permMachines = - QStringList::split (' ', vbox.GetFloppyImageUsage (itemId, - KResourceUsage_Permanent)); - for (QStringList::Iterator it = permMachines.begin(); - it != permMachines.end(); ++it) - releaseDisk (QUuid (*it), itemId, VBoxDefs::FD); - - CFloppyImage fd = vbox.GetFloppyImage (itemId); - VBoxMedia media (item->getMedia()); - media.status = fd.GetAccessible() ? VBoxMedia::Ok : - fd.isOk() ? VBoxMedia::Inaccessible : - VBoxMedia::Error; - vboxGlobal().updateMedia (media); - } - } -} - - -void VBoxDiskImageManagerDlg::releaseDisk (QUuid aMachineId, - QUuid aItemId, - VBoxDefs::DiskType aDiskType) -{ - CSession session; - CMachine machine; - /* is this media image mapped to this VM: */ - if (!cmachine.isNull() && cmachine.GetId() == aMachineId) - { - machine = cmachine; - } - /* or some other: */ - else - { - session = vboxGlobal().openSession (aMachineId); - if (session.isNull()) return; - machine = session.GetMachine(); - } - /* perform disk releasing: */ - switch (aDiskType) - { - case VBoxDefs::HD: - { - /* releasing hd: */ - CHardDiskAttachmentEnumerator en = - machine.GetHardDiskAttachments().Enumerate(); - while (en.HasMore()) - { - CHardDiskAttachment hda = en.GetNext(); - if (hda.GetHardDisk().GetId() == aItemId) - { - machine.DetachHardDisk (hda.GetBus(), - hda.GetChannel(), - hda.GetDevice()); - if (!machine.isOk()) - vboxProblem().cannotDetachHardDisk (this, - machine, hda.GetBus(), hda.GetChannel(), hda.GetDevice()); - break; - } - } - break; - } - case VBoxDefs::CD: - { - /* releasing cd: */ - machine.GetDVDDrive().Unmount(); - break; - } - case VBoxDefs::FD: - { - /* releasing fd: */ - machine.GetFloppyDrive().Unmount(); - break; - } - default: - AssertMsgFailed (("Incorrect disk type.")); - } - /* save all setting changes: */ - machine.SaveSettings(); - if (!machine.isOk()) - vboxProblem().cannotSaveMachineSettings (machine); - /* if local session was opened - close this session: */ - if (!session.isNull()) - session.Close(); -} - - -QUuid VBoxDiskImageManagerDlg::getSelectedUuid() -{ - Q3ListView *currentList = getCurrentListView(); - QUuid uuid; - - if (currentList->selectedItem() && - currentList->selectedItem()->rtti() == DiskImageItem::TypeId) - uuid = static_cast ( - currentList->selectedItem())->getUuid(); - - return uuid; -} - - -QString VBoxDiskImageManagerDlg::getSelectedPath() -{ - Q3ListView *currentList = getCurrentListView(); - QString path; - - if (currentList->selectedItem() && - currentList->selectedItem()->rtti() == DiskImageItem::TypeId ) - path = static_cast (currentList->selectedItem()) - ->getPath().stripWhiteSpace(); - - return path; -} - - -void VBoxDiskImageManagerDlg::processDoubleClick (Q3ListViewItem*) -{ - Q3ListView *currentList = getCurrentListView(); - - if (doSelect && currentList->selectedItem() && buttonOk->isEnabled()) - accept(); -}