VBoxDiskImageManagerDlg.ui.h revision 677833bc953b6cb418c701facbdcf4aa18d6c44e
/**
*
* VBox frontends: Qt GUI ("VirtualBox"):
* "Virtual Disk Manager" dialog UI include (Qt Designer)
*/
/*
* Copyright (C) 2006 InnoTek Systemberatung GmbH
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License 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.
*
* If you received this file as part of a commercial VirtualBox
* distribution, then only the terms of your commercial VirtualBox
* license agreement apply instead of the previous paragraph.
*/
/****************************************************************************
** 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.
*****************************************************************************/
{
{
return info;
}
int rtti() const { return 1001; }
{
else
}
DiskImageItem* nextSibling() const
{
return (QListViewItem::nextSibling() &&
}
};
{
if (!mModelessDialog)
{
"VBoxDiskImageManagerDlg",
/* 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 */
/* listen also to the machine state change because hard disks of running
* VMs are inaccessible by the current design */
}
mModelessDialog->show();
}
void VBoxDiskImageManagerDlg::init()
{
polished = false;
mToBeRefreshed = false;
mInLoop = false;
img =
/* setup tab widget icons */
"hd_disabled_16px.png"));
"cd_disabled_16px.png"));
"fd_disabled_16px.png"));
/* setup image list views */
hdsView->setShowToolTips (false);
cdsView->setShowToolTips (false);
fdsView->setShowToolTips (false);
/* status-bar currently disabled */
/* context menu composing */
// imEditAction = new QAction (this, "imEditAction");
// connect (imEditAction, SIGNAL (activated()),
// this, SLOT (editImage()));
// imEditAction->setMenuText (tr ("&Edit..."));
// imEditAction->setText (tr ("Edit"));
// imEditAction->setAccel (tr ("Ctrl+E"));
// imEditAction->setStatusTip (tr ("Edit properties of selected media image file"));
imReleaseAction->setStatusTip (tr ("Release selected media image file from being using in some VM"));
// imEditAction->setIconSet (VBoxGlobal::iconSet ("guesttools_16px.png", "guesttools_disabled_16px.png"));
// imEditAction->addTo (itemMenu);
/* toolbar composing */
setUsesTextLabel (true);
toolBar->addSeparator();
// imEditAction->addTo (toolBar);
toolBar->addSeparator();
/* menu bar */
// imEditAction->addTo (toolBar);
/* setup size grip */
/* setup information pane */
QApplication::setGlobalMouseTracking (true);
/* setup information pane layouts */
/* create info-pane for hd list-view */
/* create info-pane for cd list-view */
/* create info-pane for fd list-view */
}
QIRichLabel *VBoxDiskImageManagerDlg::createInfoString (QString name, QWidget *root, int row, int column)
{
/* prevent the name columns from being expanded */
if (column == -1)
{
/* add qt-html tags to prevent wrapping and to have the same initial
* height of nameLabel and infoLabel (plain text gets a height smaller
* than rich text */
}
else
{
/* add some spacing to the left of the name field for all columns but
* the first one, to separate it from the value field (note that adding
* spacing to the right is not necessary since Qt does it anyway for
* rich text for whatever stupid reason). */
if (column == 0)
else
}
return infoLabel;
}
{
QMainWindow::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;
}
{
DiskImageItem *item = 0;
}
{
}
{
mModelessDialog = 0;
}
{
{
{
case Key_Enter:
case Key_Return:
{
if (currentDefault)
break;
}
case Key_Escape:
{
reject();
break;
}
}
}
else
}
{
QPushButton *defButton = 0;
{
++it;
}
return defButton;
}
int VBoxDiskImageManagerDlg::exec()
{
setResult (0);
show();
mInLoop = true;
mInLoop = false;
return result();
}
{
if (mInLoop)
{
hide();
}
else
{
close();
}
}
{
return clv;
}
{
{
/* Dragged object(s) has entered list-view area */
{
if (aObject == currentList)
{
dragEnterEvent->accept();
}
break;
}
/* Dragged object(s) was dropped on list-view area */
{
if (aObject == currentList)
{
{
/* Checking dropped media type */
{
}
{
}
{
}
/* If media type has been determined - attach this device */
if (type)
}
refreshAll();
}
break;
}
{
{
if (defaultButton)
}
break;
}
{
{
if (defaultButton)
}
break;
}
default:
break;
}
}
{
return;
switch (aDiskType)
{
{
{
}
break;
}
{
break;
}
{
break;
}
default:
{
Assert(0);
}
}
}
{
DiskImageItem *item = 0;
if (aList)
else if (aRoot)
else
Assert(0);
return item;
}
{
if (aItem)
}
{
++it)
{
if (usage)
usage += ", ";
}
++it)
{
/* skip IDs that are in the permanent list */
{
if (usage)
usage += ", [";
else
usage += "[";
}
}
return usage;
}
{
++it)
{
if (usage)
usage += ", ";
}
++it)
{
/* skip IDs that are in the permanent list */
{
if (usage)
usage += ", [";
else
usage += "[";
}
}
return usage;
}
{
DiskImageItem *item = 0;
{
}
item = createImageNode (
);
/* compose tool-tip information */
if (!accessible)
{
}
else
{
"<nobr>Disk type: %2</nobr><br>"
"<nobr>Storage type: %3</nobr>")
}
return item;
}
{
DiskImageItem *item = 0;
size);
/* compose tool-tip information */
if (!accessible)
{
/// @todo (r=dmik) correct this when GetLastAccessError() is
// implemented for IFloppyImage/IDVDImage
}
else
{
}
return item;
}
{
DiskImageItem *item = 0;
size);
/* compose tool-tip information */
if (!accessible)
{
/// @todo (r=dmik) correct this when GetLastAccessError() is
// implemented for IFloppyImage/IDVDImage
}
else
{
}
return item;
}
{
while (enumerator.HasMore())
{
}
}
{
/* ignore non-interesting aMedia */
return;
DiskImageItem *item = 0;
{
{
break;
}
{
break;
}
{
break;
}
default:
{
AssertMsgFailed (("Invalid aMedia type\n"));
break;
}
}
}
const QUuid *aTargetVMId,
const VBoxMediaList *mediaList,
{
if (aTargetVMId)
if (doSelect)
else
buttonCancel->setShown (false);
/* listen to "media enumeration" signals */
/* listen to "media enumeration finished" signals */
/* insert already enumerated media */
if (mediaList)
else
insertMedia (*it);
if (!mediaList)
{
/* only start enumerating media if we haven't been supplied with a list
* (it's ok if the enumeration has been already started, nothing will
* happen) */
refreshAll();
}
}
{
/* This function is unnecessary since media devices enumeration
performs on full VBoxMediaList completion */
}
{
if (!mToBeRefreshed) return;
insertMedia (*it);
imRefreshAction->setEnabled (true);
unsetCursor();
mToBeRefreshed = false;
}
{
/// @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 CEnums::PoweredOff:
{
refreshAll();
break;
}
default:
break;
}
}
{
notice->adjustSize();
aListView->setEnabled (false);
}
{
if (notice)
}
{
aListView->setEnabled (true);
}
void VBoxDiskImageManagerDlg::refreshAll()
{
if (mToBeRefreshed) return;
mToBeRefreshed = true;
imRefreshAction->setEnabled (false);
/* start enumerating media */
}
{
if (parentList == hdsView)
{
return false;
}
else if (parentList == cdsView)
{
/* check if there is temporary usage: */
CEnums::TemporaryUsage));
if (!tempMachines.isEmpty())
return false;
/* only permamently mounted .iso could be released */
CEnums::PermanentUsage));
return false;
}
else if (parentList == fdsView)
{
/* check if there is temporary usage: */
CEnums::TemporaryUsage));
if (!tempMachines.isEmpty())
return false;
/* only permamently mounted .iso could be released */
CEnums::PermanentUsage));
return false;
}
else
{
return false;
}
return true;
}
{
if (aItem)
{
}
}
{
currentList->setFocus();
/* tab stop setup */
}
{
checkImage (item) &&
// imEditAction->setEnabled (modifyEnabled);
// itemMenu->setItemVisible (itemMenu->idAt(0), modifyEnabled);
if (doSelect)
{
(!newEnabled ||
}
if (item)
{
if (getCurrentListView() == hdsView)
{
}
else if (getCurrentListView() == cdsView)
{
}
else if (getCurrentListView() == fdsView)
{
}
}
}
{
if (!aItem)
{
}
}
void VBoxDiskImageManagerDlg::newImage()
{
{
/* synchronize modeless dialog if present */
}
}
void VBoxDiskImageManagerDlg::addImage()
{
if (item)
if (!dir)
if (currentList == hdsView)
if (currentList == hdsView) {
} else if (currentList == cdsView) {
} else if (currentList == fdsView) {
} else {
AssertMsgFailed (("Root list should be equal to hdsView, cdsView or fdsView"));
}
this, "AddDiskImageDialog",
title);
DiskImageItem *createdItem = 0;
if (src)
{
if (currentList == hdsView)
{
{
/// @todo (dmik) later, change wrappers so that converting
// to CUnknown is not necessary for cross-assignments
{
/* synchronize modeless dialog if present */
}
}
}
else
if (currentList == cdsView)
{
{
{
/* synchronize modeless dialog if present */
}
}
}
else
if (currentList == fdsView)
{
{
{
/* synchronize modeless dialog if present */
}
}
}
{
}
}
/* set current item */
}
void VBoxDiskImageManagerDlg::removeImage()
{
if (currentList == hdsView)
{
int deleteImage;
{
}
else
{
}
return;
{
/// @todo (dmik) later, change wrappers so that converting
// to CUnknown is not necessary for cross-assignments
vdi.DeleteImage();
}
}
else if (currentList == cdsView)
{
}
else if (currentList == fdsView)
{
}
{
}
else
{
/* synchronize modeless dialog if present */
{
DiskImageItem *itemToRemove = 0;
QListView *modelessView = 0;
if (currentList == hdsView)
else if (currentList == cdsView)
else if (currentList == fdsView)
if (modelessView->currentItem())
}
}
}
void VBoxDiskImageManagerDlg::releaseImage()
{
/* if it is a hard disk sub-item: */
if (currentList == hdsView)
{
{
/* re-request current usage */
}
}
else if (currentList == cdsView)
{
/* only permamently mounted .iso could be released */
{
CEnums::PermanentUsage));
/* re-request current usage */
}
}
/* if it is a floppy sub-item: */
else if (currentList == fdsView)
{
/* only permamently mounted .img could be released */
{
CEnums::PermanentUsage));
/* re-request current usage */
}
}
/* processing modeless dialog */
{
DiskImageItem *itemToRelease = 0;
QListView *modelessView = 0;
if (currentList == hdsView)
else if (currentList == cdsView)
else if (currentList == fdsView)
}
}
{
/* is this media image mapped to this VM: */
{
}
/* or some other: */
else
{
}
/* perform disk releasing: */
switch (aDiskType)
{
{
/* releasing hd: */
{
{
hda.GetDeviceNumber());
break;
}
}
break;
}
{
/* releasing cd: */
break;
}
{
/* releasing fd: */
break;
}
default:
AssertFailed();
}
/* save all setting changes: */
/* if local session was opened - close this session: */
}
{
if ( currentList->selectedItem() &&
->getUuid());
return uuid;
}
{
->getPath().stripWhiteSpace();
return path;
}
{
accept();
}
const QUuid &aMachineId)
{
DiskImageItem *item = 0;
if (currentList->firstChild() &&
do {
{
}
} while (item);
}