VM_Wizard_Window::VM_Wizard_Window( QWidget *parent )
: QDialog(parent)
{
ui.setupUi( this );
ui.Label_Page->setBackgroundRole( QPalette::Base );
New_VM = new Virtual_Machine();
// Loadind All Templates
if( Load_OS_Templates() )
{
// Find default template
for( int ix = 0; ix < ui.CB_OS_Type->count(); ++ix )
{
if( ui.CB_OS_Type->itemText(ix) == Settings.value("Default_VM_Template", "Linux 2.6").toString() )
{
ui.CB_OS_Type->setCurrentIndex( ix );
}
}
}
else
{
AQWarning( "void VM_Wizard_Window::on_Button_Next_clicked()",
"No VM Templates Found!" );
}
}
void Emulator_Options_Window::Set_Emulator( const Emulator &emul )
{
Current_Emulator = emul;
// Name
ui.Edit_Name->setText( Current_Emulator.Get_Name() );
// Path
ui.Edit_Path_to_Dir->setText( Current_Emulator.Get_Path() );
// Version
if( Current_Emulator.Get_Check_Version() ) ui.RB_Check_Version->setChecked( true ); // Check version
else if( Current_Emulator.Get_Check_Available_Options() ) ui.RB_Check_Options->setChecked( true ); // Check available options
else if( Current_Emulator.Get_Force_Version() ) ui.RB_Force_Version->setChecked( true ); // Force version
else ui.RB_Save_Options->setChecked( true ); // Use saved emulator available options
// Force Version
switch( Current_Emulator.Get_Version() )
{
case VM::QEMU_2_0:
ui.CB_Version->setCurrentIndex( 1 );
break;
default:
AQWarning( "void Emulator_Options_Window::Set_Emulator( Emulator emul )",
"Version NOT Valid! Use Default" );
ui.CB_Version->setCurrentIndex( 0 );
break;
}
// Emulator Binary Files
QMap<QString, QString> bin_files = Current_Emulator.Get_Binary_Files();
// Clear
ui.Table_Systems->clearContents();
while( ui.Table_Systems->rowCount() > 0 ) ui.Table_Systems->removeRow( 0 );
// Add new
for( QMap<QString, QString>::const_iterator iter = bin_files.constBegin(); iter != bin_files.constEnd(); iter++ )
{
ui.Table_Systems->insertRow( ui.Table_Systems->rowCount() );
QTableWidgetItem *newItem;
/*if( ui.RB_QEMU->isChecked() )
{
newItem = new QTableWidgetItem( iter.key() );
ui.Table_Systems->setItem( ui.Table_Systems->rowCount()-1, 0, newItem );
}
else
{
newItem = new QTableWidgetItem( iter.key() );
ui.Table_Systems->setItem( ui.Table_Systems->rowCount()-1, 0, newItem );
}*/
newItem = new QTableWidgetItem( iter.value() );
ui.Table_Systems->setItem( ui.Table_Systems->rowCount()-1, 1, newItem );
}
Update_Info = false; // Update emulator info
}
bool Advanced_Settings_Window::Save_Emulators_Info()
{
// FIXME save only if emulators changed
// Check defaults emulators
bool installed_kvm, installed_qemu, default_kvm, default_qemu;
installed_kvm = installed_qemu = default_kvm = default_qemu = false;
for( int ix = 0; ix < Emulators.count(); ++ix )
{
if( Emulators[ix].Get_Type() == VM::QEMU )
{
installed_qemu = true;
if( Emulators[ix].Get_Default() ) default_qemu = true;
}
else if( Emulators[ix].Get_Type() == VM::KVM )
{
installed_kvm = true;
if( Emulators[ix].Get_Default() ) default_kvm = true;
}
}
if( installed_qemu && default_qemu == false )
{
AQGraphic_Warning( tr("Error!"), tr("Default QEMU Emulator isn't selected!") );
return false;
}
if( installed_kvm && default_kvm == false )
{
AQGraphic_Warning( tr("Error!"), tr("Default KVM Emulator isn't selected!") );
return false;
}
// Remove old emulators files
if( ! Remove_All_Emulators_Files() )
{
AQWarning( "bool Advanced_Settings_Window::Save_Emulators_Info()",
"Not all old emulators files removed!" );
}
// Save new files
for( int ix = 0; ix < Emulators.count(); ++ix )
{
if( ! Emulators[ ix ].Save() )
{
AQGraphic_Warning( tr("Error!"),
tr("Cannot save emulator \"%1\"!").arg(Emulators[ix].Get_Name()) );
}
}
return true;
}
Convert_HDD_Image_Window::Convert_HDD_Image_Window( QWidget *parent )
: QDialog( parent )
{
ui.setupUi( this );
resize( width(), minimumSizeHint().height() );
HDD_Info = new HDD_Image_Info();
connect( HDD_Info, SIGNAL(Completed(bool)),
this, SLOT(Update_Info(bool)) );
Valid_Info = false;
Possible_Encrypte = false;
if( ! Get_QEMU_IMG_Info() )
{
AQWarning( "Convert_HDD_Image_Window::Convert_HDD_Image_Window( QWidget *parent )",
"Cannot get qemu-img info!" );
QStringList formats;
formats << "qcow2" << "qcow" << "vmdk" << "cow" << "raw" << "cloop";
ui.CB_Output_Format->addItems( formats );
}
}
void Emulator_Control_Window::Add_USB_To_VM()
{
QAction *usb_item = qobject_cast<QAction*>( sender() );
if( usb_item )
{
QList<QAction*> ac_list = ui.menuDisconnect->actions();
for( int ix = 0; ix < ac_list.count(); ++ix )
{
// Unique value
if( usb_item->data().toString() == ac_list[ix]->data().toString() )
{
AQWarning( "void Emulator_Control_Window::Add_USB_To_VM()",
"This is not unique value: " + usb_item->data().toString() );
return;
}
}
// Create Item for Disconnect Menu
QAction *dis_act = new QAction( usb_item->text(), ui.menuDisconnect );
dis_act->setData( usb_item->data() );
connect( dis_act, SIGNAL(triggered()), this, SLOT(Delete_USB_From_VM()) );
ui.menuDisconnect->addAction( dis_act );
// Add To Running VM
emit Ready_Read_Command( "usb_add host:" + usb_item->data().toString() );
}
else
{
AQError( "void Emulator_Control_Window::Add_USB_To_VM()",
"Cannot convert to QAction!" );
}
}
bool VM_Wizard_Window::Create_New_VM()
{
// Icon
QString icon_path = Find_OS_Icon( ui.Edit_VM_Name->text() );
if( icon_path.isEmpty() )
{
AQWarning( "void VM_Wizard_Window::Create_New_VM()", "Icon for new VM not Found!" );
New_VM->Set_Icon_Path( "other.png" );
}
else
{
New_VM->Set_Icon_Path( icon_path );
}
// Name
New_VM->Set_Machine_Name( ui.Edit_VM_Name->text() );
// Create path valid string
QString VM_File_Name = Get_FS_Compatible_VM_Name( ui.Edit_VM_Name->text() );
// Set Computer Type?
if( ui.RB_Generate_VM->isChecked() )
{
New_VM->Set_Computer_Type( Current_Devices->System.QEMU_Name );
}
// RAM
New_VM->Set_Memory_Size( ui.Memory_Size->value() );
// Wizard Mode
if( ui.RB_Typical->isChecked() )
{
// Hard Disk
VM::Device_Size hd_size;
hd_size.Size = ui.SB_HDD_Size->value();
hd_size.Suffix = VM::Size_Suf_Gb;
QString hd_path = Settings.value( "VM_Directory", "~" ).toString() + VM_File_Name;
Create_New_HDD_Image( hd_path + "_HDA.img", hd_size );
New_VM->Set_HDA( VM_HDD(true, hd_path + "_HDA.img") );
// Other HDD's
if( New_VM->Get_HDB().Get_Enabled() )
{
Create_New_HDD_Image( hd_path + "_HDB.img", New_VM->Get_HDB().Get_Virtual_Size() );
New_VM->Set_HDB( VM_HDD(true, hd_path + "_HDB.img") );
}
if( New_VM->Get_HDC().Get_Enabled() )
{
Create_New_HDD_Image( hd_path + "_HDC.img", New_VM->Get_HDC().Get_Virtual_Size() );
New_VM->Set_HDC( VM_HDD(true, hd_path + "_HDC.img") );
}
if( New_VM->Get_HDD().Get_Enabled() )
{
Create_New_HDD_Image( hd_path + "_HDD.img", New_VM->Get_HDD().Get_Virtual_Size() );
New_VM->Set_HDD( VM_HDD(true, hd_path + "_HDD.img") );
}
}
else
{
bool devices_finded = false;
// CPU Type
if( ui.RB_VM_Template->isChecked() )
{
// Find QEMU System Name in VM
if( ui.RB_Emulator_KVM->isChecked() )
{
Current_Devices = &All_Systems[ "qemu-kvm" ];
if( ! Current_Devices->System.QEMU_Name.isEmpty() ) devices_finded = true;
}
else // QEMU
{
Current_Devices = &All_Systems[ New_VM->Get_Computer_Type() ];
if( ! Current_Devices->System.QEMU_Name.isEmpty() ) devices_finded = true;
}
}
else
{
// Find QEMU System Name in CB_Computer_Type
if( ui.RB_Emulator_KVM->isChecked() )
{
Current_Devices = &All_Systems[ "qemu-kvm" ];
if( ! Current_Devices->System.QEMU_Name.isEmpty() ) devices_finded = true;
}
else // QEMU
{
for( QMap<QString, Available_Devices>::const_iterator it = All_Systems.constBegin(); it != All_Systems.constEnd(); it++ )
{
if( it.value().System.Caption == ui.CB_Computer_Type->currentText() )
{
Current_Devices = &it.value();
devices_finded = true;
break;
}
}
}
}
if( ! devices_finded )
{
AQGraphic_Error( "bool VM_Wizard_Window::Create_New_VM()", tr("Error!"),
tr("Cannot Find QEMU System ID!") );
return false;
}
New_VM->Set_CPU_Type( Current_Devices->CPU_List[ui.CB_CPU_Type->currentIndex()].QEMU_Name );
// Hard Disk
if( ! ui.Edit_HDA_File_Name->text().isEmpty() )
New_VM->Set_HDA( VM_HDD(true, ui.Edit_HDA_File_Name->text()) );
else
New_VM->Set_HDA( VM_HDD(false, "") );
}
// Network
if( ui.RB_User_Mode_Network->isChecked() )
{
if( New_VM->Get_Network_Cards_Count() == 0 )
{
New_VM->Set_Use_Network( true );
VM_Net_Card net_card;
net_card.Set_Net_Mode( VM::Net_Mode_Usermode );
New_VM->Add_Network_Card( net_card );
}
}
else if( ui.RB_No_Network->isChecked() )
{
New_VM->Set_Use_Network( false );
for( int rx = 0; rx < New_VM->Get_Network_Cards_Count(); ++rx )
{
New_VM->Delete_Network_Card( 0 );
}
}
// Set Emulator Name (version) to Default ("")
Emulator tmp_emul = New_VM->Get_Emulator();
tmp_emul.Set_Name( "" );
New_VM->Set_Emulator( tmp_emul );
// Create New VM XML File
New_VM->Create_VM_File( Settings.value("VM_Directory", "~").toString() + VM_File_Name + ".aqemu", false );
return true;
}
