# [SCRIPT]Frontend lancement Qemu GTK2Perl

## Zazbar

salut,

j'ai développé un frontend en GTK2 en perl pour Qemu.

Bon ca n'est qu'un premiere ebauche, il est pas encore trop beau, ni ne possede toutes les fonctionnaliés désirées mais pour le moment il me permet de faire ce que je veux  :Smile: 

Notez que vous devez avoir le paquet dev-perl/gtk2-perl afin de pouvoir le lancer.

voici le code :

```

#!/usr/bin/perl -w

# Frontend Gtk2Perl pour Qemu

# Développé par Grm

# Version : 0.1 - 08/11/2006

#    - release alpha

#Packages

use strict;

use Gtk2 '-init';

#Constantes

use constant TRUE => 1;

use constant FALSE => 0; 

my $version="0.1";

my $defaultMemory = '256';

my $pwdImages = "/home/grm/qemu/img/";

my $defaultSrcPort = 8080;

my $defaultDstPort = 8080;

my $defaultSize = 4;

# Creation de la fenetre et des éléments dessus

my $fenetre = Gtk2::Window->new('toplevel');

$fenetre->signal_connect('delete_event', \&CloseWindow);

$fenetre->signal_connect('destroy', \&DestroyWindow);

#Format de la fenetre

$fenetre->set_border_width(15);

$fenetre->set_title("Qemu Launcher ".$version);

my $hboxPrinc = Gtk2::HBox->new(FALSE, 2);

my $vboxPrinc = Gtk2::VBox->new(FALSE, 2);

###########################################

#Frame des images

my $frameImage = Gtk2::Frame->new('Option des Images');

my $vboxImage = Gtk2::VBox->new(FALSE,4);

#Nom de l'image

my $hboxNomImage = Gtk2::HBox->new(FALSE,2);

my $labelNomImage = Gtk2::Label->new("Nom de l'image :");

$hboxNomImage->pack_start($labelNomImage, FALSE, FALSE, 0);

my $entryNomImage = Gtk2::Entry->new;

$hboxNomImage->pack_start($entryNomImage, FALSE, FALSE, 0);

$vboxImage->pack_start($hboxNomImage, FALSE, FALSE, 0);

#Mémoire

my $hboxMemoireImage = Gtk2::HBox->new(FALSE,2);

my $labelMemoireImage = Gtk2::Label->new("Mémoire allouée :");

$hboxMemoireImage->pack_start($labelMemoireImage, FALSE, FALSE, 0);

my $entryMemoireImage = Gtk2::Entry->new;

$entryMemoireImage->set_text($defaultMemory);

$hboxMemoireImage->pack_start($entryMemoireImage, FALSE, FALSE, 0);

$vboxImage->pack_start($hboxMemoireImage, FALSE, FALSE, 0);

#Repertoire des images

my $hboxNomRep = Gtk2::HBox->new(FALSE,2);

my $labelNomRep = Gtk2::Label->new("Répertoire des images:");

$hboxNomRep->pack_start($labelNomRep, FALSE, FALSE, 0);

my $entryNomRep = Gtk2::Entry->new();

$entryNomRep->set_text($pwdImages);

$hboxNomRep->pack_start($entryNomRep, FALSE, FALSE, 0);

$vboxImage->pack_start($hboxNomRep, FALSE, FALSE, 0);

#cd ISO

my $hboxNomIso = Gtk2::HBox->new(FALSE,2);

my $labelNomIso = Gtk2::Label->new("CDROM (chemin vers ISO) :");

$hboxNomIso->pack_start($labelNomIso, FALSE, FALSE, 0);

my $entryNomIso = Gtk2::Entry->new;

$hboxNomIso->pack_start($entryNomIso, FALSE, FALSE, 0);

$vboxImage->pack_start($hboxNomIso, FALSE, FALSE, 0);

# Le bouton

my $buttonLancer = Gtk2::Button->new('Lancer !');

$buttonLancer->signal_connect('clicked', \&LancementQemu);

$vboxImage->pack_start($buttonLancer, FALSE, FALSE, 0);

#On met tout dans la frame et on met la frame dans sa boite

$frameImage->add($vboxImage);

$vboxPrinc->pack_start($frameImage, FALSE, FALSE, 0);

#########################################

#Frame de création des Images

my $frameImageCreate = Gtk2::Frame->new("Création d'une image");

my $vboxImageCreate = Gtk2::VBox->new(FALSE,4);

#Nom de l'image

my $hboxNomImageCreate = Gtk2::HBox->new(FALSE,2);

my $labelNomImageCreate = Gtk2::Label->new("Nom de l'image à créer :");

$hboxNomImageCreate->pack_start($labelNomImageCreate, FALSE, FALSE, 0);

my $entryNomImageCreate = Gtk2::Entry->new;

$hboxNomImageCreate->pack_start($entryNomImageCreate, FALSE, FALSE, 0);

$vboxImageCreate->pack_start($hboxNomImageCreate, FALSE, FALSE, 0);

#Format de l'image

my $hboxFormat = Gtk2::HBox->new(FALSE,2);

my $labelFormat = Gtk2::Label->new("Format désiré :");

$hboxFormat->pack_start($labelFormat, FALSE, FALSE, 0);

my $buttonQcow = Gtk2::RadioButton->new(undef,'Qcow');

$hboxFormat->pack_start($buttonQcow, FALSE, FALSE, 0);

my $buttonNormal = Gtk2::RadioButton->new($buttonQcow->get_group,'Normal');

$hboxFormat->pack_start($buttonNormal, FALSE, FALSE, 0);

$vboxImageCreate->pack_start($hboxFormat, FALSE, FALSE, 0);

#Taille de l'image

my $hboxTailleImageCreate = Gtk2::HBox->new(FALSE,2);

my $labelTailleImageCreate = Gtk2::Label->new("Taille (en Go) :");

$hboxTailleImageCreate->pack_start($labelTailleImageCreate, FALSE, FALSE, 0);

my $entryTailleImageCreate = Gtk2::Entry->new;

$entryTailleImageCreate->set_text($defaultSize);

$hboxTailleImageCreate->pack_start($entryTailleImageCreate, FALSE, FALSE, 0);

$vboxImageCreate->pack_start($hboxTailleImageCreate, FALSE, FALSE, 0);

#Le bouton pour lancer tout ca

my $buttonImageCreate = Gtk2::Button->new('Créer !');

$buttonImageCreate->signal_connect('clicked', \&CreationImage);

$vboxImageCreate->pack_start($buttonImageCreate, FALSE, FALSE, 0);

#On met tout dans la frame et on met la frame dans sa boite

$frameImageCreate->add($vboxImageCreate);

$vboxPrinc->pack_start($frameImageCreate, FALSE, FALSE, 0);

###########################################

#Frame des Paramètres

my $frameParam = Gtk2::Frame->new('Paramètre de lancement');

my $vboxParam = Gtk2::VBox->new(FALSE, 6);

#KQEMU

my $buttonKqemu = Gtk2::CheckButton->new('KQemu');

$buttonKqemu->set_active(TRUE);

$vboxParam->pack_start($buttonKqemu, FALSE, FALSE, 0);

#net

my $buttonNet = Gtk2::CheckButton->new('Net');

$buttonNet->set_active(TRUE);

$vboxParam->pack_start($buttonNet, FALSE, FALSE, 0);

#REDIR

my $buttonRedir = Gtk2::CheckButton->new('Redirection de port');

$buttonRedir->set_active(TRUE);

$vboxParam->pack_start($buttonRedir, FALSE, FALSE, 0);

my $hboxRedir = Gtk2::HBox->new(FALSE, 4);

my $labelRedirSrc = Gtk2::Label->new('Source');

$hboxRedir->pack_start($labelRedirSrc, FALSE, FALSE, 0);

my $entryRedirSrc = Gtk2::Entry->new;

$entryRedirSrc->set_text($defaultSrcPort);

$hboxRedir->pack_start($entryRedirSrc, FALSE, FALSE, 0);

my $labelRedirDst = Gtk2::Label->new('Destination');

$hboxRedir->pack_start($labelRedirDst, FALSE, FALSE, 0);

my $entryRedirDst = Gtk2::Entry->new;

$entryRedirDst->set_text($defaultDstPort);

$hboxRedir->pack_start($entryRedirDst, FALSE, FALSE, 0);

$vboxParam->pack_start($hboxRedir, FALSE, FALSE, 0);

#USB

my $buttonUsb = Gtk2::CheckButton->new('USB');

$buttonUsb->set_active(TRUE);

$vboxParam->pack_start($buttonUsb, FALSE, FALSE, 0);

#BOOT CD

my $buttonBootCD = Gtk2::CheckButton->new('Boot à partir du cdrom');

$buttonBootCD->set_active(FALSE);

$buttonBootCD->signal_connect('toggled', \&BootCDToggle);

$vboxParam->pack_start($buttonBootCD, FALSE, FALSE, 0);

#On met tout dans la frame 

$frameParam->add($vboxParam);

#On Constitue le panneau principal

$hboxPrinc->pack_start($vboxPrinc, FALSE, FALSE, 0);

$hboxPrinc->pack_start($frameParam, FALSE, FALSE,0);

#Affichage fenetre et entre dans boucle main

$fenetre->add($hboxPrinc);

$fenetre->show_all;

Gtk2->main;

#Fonction d'évènements

sub erreur {

        my $errorDialog = Gtk2::MessageDialog->new($fenetre, 'destroy_with_parent', 'error', 'ok', $_[0]);

   my $return = $errorDialog->run;

   $errorDialog->destroy;

}

sub CreationImage {

   my $cmd;

   my $rep=$entryNomRep->get_text;

   if (! -e "$rep" ) {

      erreur "Le répertoire de destination des images n'existe pas !";

      return;

   }

   if ( $entryNomImageCreate->get_text ne "") {

      my $type;

      if ($buttonQcow->get_active) {

         $type = "-f qcow";

      }

      $cmd = "qemu-img create ".$type." ".$rep.$entryNomImageCreate->get_text;

   } else {

      erreur "Veuillez spécifier le nom l'image";

      return;

   }

   if ( $entryTailleImageCreate->get_text ne "") {

      $cmd = $cmd." ".$entryTailleImageCreate->get_text."G";

   } else {

      erreur "Impossible de créer une image vide";

      return;

   }

   print $cmd;

}   

sub LancementQemu {

   my $cmd;

   my $img = $entryNomRep->get_text.$entryNomImage->get_text;

   my $iso = $entryNomIso->get_text;

   if ( -f "$img") {

      $cmd = 'qemu '.$img.' -m '.$entryMemoireImage->get_text;

   } else {

      erreur "Le fichier Image \"".$img."\" n'existe pas !";

      return;

   }

   if ($buttonNet->get_active) {

      $cmd = $cmd." -net nic -net user";

   }

   

   if (! $buttonBootCD->get_active) {

      if ($entryNomIso->get_text ne ""){

         if ( -e "$iso") {

            $cmd = $cmd." -cdrom ".$entryNomIso->get_text;

         } else {

            erreur "Le fichier image du CDROM \"".$entryNomIso->get_text."\" n'existe pas";

            return;

         }

      }

      if ($buttonKqemu->get_active) {

         $cmd = $cmd." -kernel-kqemu";

      }

      if ($buttonNet->get_active) {

         $cmd = $cmd." -net nic -net user";

      }

      if ($buttonRedir->get_active) {

         if (( $entryRedirSrc->get_text ne "") && ( $entryRedirDst->get_text ne "")){

            $cmd = $cmd." -redir tcp:".$entryRedirSrc->get_text."::".$entryRedirDst->get_text;

         } else {

            erreur "Veuillez spécifier des ports Sources ou désactiver la redirection";

            return;

         }

      }

      if ($buttonUsb->get_active) {

         $cmd = $cmd." -usb";

      }

   } else {

      if ( -f "$iso") {

         $cmd = $cmd." -boot d -cdrom ".$entryNomIso->get_text;

      } else {

         erreur "Le fichier d'image ISO n'existe pas ! Impossible de booter dessus.";

         return;

      }

   }

   $cmd = $cmd." &";

   print $cmd;

   system $cmd;

}

sub BootCDToggle {

   my $etat = $buttonBootCD->get_active();

   $buttonKqemu->set_active($etat^TRUE);

   $buttonRedir->set_active($etat^TRUE);

   $entryRedirSrc->set_editable($etat^TRUE);

   $entryRedirDst->set_editable($etat^TRUE);

   $buttonUsb->set_active($etat^TRUE);

}

#Fonctions de fermeture de la fenetre

sub CloseWindow {

   return FALSE;

}

sub DestroyWindow {

   Gtk2->main_quit;

   return FALSE;

}

```

Donc si il y aurait des bonnes ames pour le tester, me faire part de leurs remarques/critiques (constructives, cela va de soi  :Smile: , j'en tiendrais compte.

A pluche et merci

----------

## Enlight

j'aimerai mais mon qemu chie dans la colle (depuis gcc-4.1), je peux avoir un ou des screenshots en attendant?

----------

## Zazbar

Bien sur, je vais te préparer un screenshot d'ici demain (l'interface est pas encore très évoluée :p ) ....

et pour ton problème de qemu .... j'ai reussi a le compiler avec gcc4.1 ... mais au maxium la version 0.8.2 par contre kqemu sans problème la derniere version ...

 */etc/portage/package.mask wrote:*   

> 
> 
> >=app-emulation/qemu-0.8.2
> 
> >=app-emulation/qemu-user-0.8.2
> ...

 

source

----------

