Accueil
Club Emploi Blogs   TV   Dév. Web PHP XML Python Autres 2D-3D-Jeux Sécurité Windows Linux PC Mac
Accueil Conception Java DotNET Visual Basic  C  C++ Delphi Eclipse MS-Office SQL & SGBD Oracle  4D  Business Intelligence

Introduction au MIDlet Pascal 2.02

Date de publication : 30 Décembre 2009 , Date de mise à jour : 30 Décembre 2009


VII. Ressources
VII-A. Utilisation des images
VII-B. Exemple de code


VII. Ressources

Les ressources MIDlet Pascal sont des fichiers que nous pouvons importer et utiliser dans un projet. Ces fichiers peuvent être des images, de la musique, ou tout autre type de fichier.

Nous allons donc voir comment importer et utiliser dans images dans un projet. Puis nous examinerons un exemple de code qui simule une horloge analogique.


VII-A. Utilisation des images

Créez un nouveau projet, nommons-le hello3.
Dans le menu « Project », choisissez « Import ressource file ». Choisissez l'image à ajouter puis cliquez sur ouvrir. Vous pouvez voir dans l'onglet «Files » à gauche le fichier image ajouté.
Vous pouvez aussi choisir de dessiner l'image à l'aide de l'éditeur d'image de MIDlet Pascal. Pour cela, dans le menu « Project », choisissez « New image ressource». Indiquez la taille de l'image et son nom puis cliquez sur « Ok ».

Voyons un petit programme utilisant les images.
Téléchargez le fichier image suivant puis ajoutez-le à notre projet hello3.

infoConcernant les images, seul les format png sont supportés.
horloge.png
Nous allons utiliser le type « image » disponible dans MIDlet Pascal pour manipuler les ressources images.
Le code suivant charge l'image contenue dans le fichier image.png précédemment ajouté à notre projet, et l'affiche à l'écran.
Var monImage : Image ;

Begin
 monImage :=loadImage('/horloge.png') ;
drawImage(monIage, 10, 10);
repeat until getKeyPressed<>KE_NONE;
End;
				
warning Le chemin de l'image doit être précédé du slash « / », sinon la compilation se passera bien, mais à l'exécution on aura une erreur et le programme se bloquera.

VII-B. Exemple de code

Nous voilà maintenant bien armés pour faire un petit programme affichant une horloge analogique.

Nous allons utiliser le fichier horloge.png que vous avez précédemment téléchargé pour nous servir de cadran.

Créez un nouveau projet, nommons-le « horloge ». Ajoutez l'image horloge.png à votre projet.
Nous allons diviser notre programme en une unité uHorloge en plus du programme principal.
L'unité uHorloge se contentera de dessiner les aiguilles de notre l'horloge en se basant sur l'heure de notre téléphone.
Voyons le code de l'unité uHorloge :
unit uhorloge;

interface

//(x, y) position du centre de l'horloge

//r le rayon du cadran

procedure init(x, y, r : integer);
procedure dessiner;


implementation
	
 const PI=3.141592653;	
	
 var 
      centre : record // le centre de l'horloge

                x, y : integer;
               end;
               
      rayon : integer; // le rayon de l'horloge.

                        // On considere que l'horloge est un cercle

            
 
procedure init(x, y, r : integer);
 begin
   centre.x:=x;
   centre.y:=y;
   rayon:=r;
 end;
 
 //arrondie un reel positif a l'entier le plus proche

 function Round(a : real):integer;
  var c: integer;
       b : real;
 begin
 c:=trunc(a);
 b:=a-c;
 if(b<0.5) then
  Round:=c
 else
 Round:=c+1; 
 end;

//convertit les radians en degres

function radToDegre(a: real) : integer;
 begin
  radToDegre:=round(180*a/pi);
 end;

//dessine un cercle de centre (x, y) et de rayon r 

 procedure drawCircle(x, y, r : integer);
 begin
  drawEllipse(x-r, y-r, r*2, r*2);
 end;

//dessine les aiguille de l'horloge

procedure dessiner;
 var h, m, s, time : integer;
     hPos, mPos, sPos : record
                          x, y : integer;
                        end;
      a, b, c :real;
      img : Image;
 begin
 //on obtient l'heure actuelle

 time := GetCurrentTime;
  h:=getHour(time);
  m:=getMinute(time);
  s:=getSecond(time);
  
  //on calcule la position des aiguilles

  //les secondes

  a:=s * PI / 30 - PI / 2;
  	sPos.x := round( (cos(s * PI / 30 - PI / 2) * (rayon-5) + Centre.x));
    sPos.y := round(sin(s * PI / 30 - PI / 2) * (rayon-5) + Centre.y);
		//minutes

		b:=m * PI / 30 - PI / 2;
    mPos.x:= round((cos(m * PI / 30 - PI / 2) * (rayon-10) + Centre.x));
    mPos.y:= round( (sin(m * PI / 30 - PI / 2) * (rayon-10) + Centre.y));
		//heures

		c:=(h*30 + m / 2) * PI / 180 - PI / 2;
    hPos.x :=  round((cos((h*30 + m / 2) * PI / 180 - PI / 2) * (rayon-20)+ Centre.x));
    hPos.y :=  round((sin((h*30 + m / 2) * PI / 180 - PI / 2) * (rayon-20)+ Centre.y));
		
   //on dessine la scene

   //seconde  

   setColor(204, 0, 0);
   drawLine(centre.x, centre.y, sPos.x, sPos.y);
   
   //minute  

   setColor(150, 50, 210);
   drawLine(centre.x, centre.y+1, mPos.x, mPos.y);
   drawLine(centre.x, centre.y-1, mPos.x, mPos.y);
   drawLine(centre.x, centre.y, mPos.x, mPos.y);
   
   //heure 

   setColor(0, 0, 0);
   drawLine(centre.x, centre.y,   hPos.x, hPos.y);
   drawLine(centre.x, centre.y+1, hPos.x, hPos.y);
   drawLine(centre.x, centre.y-1, hPos.x, hPos.y);
   drawLine(centre.x, centre.y+2, hPos.x, hPos.y);
   drawLine(centre.x, centre.y-2, hPos.x, hPos.y);   
 end;

initialization
	
end.
	
Dans l'interface, nous plaçons les procédures init(x, y, r), qui indique la position du centre de l'horloge et le rayon de celle-ci, et dessiner(), qui dessine les aiguilles à l'écran.
Le code suivant permet d'obtenir l'heure de notre téléphone :
//time, h, m et s etant des Integer

  time := GetCurrentTime;
  h:=getHour(time);
  m:=getMinute(time);
  s:=getSecond(time);
	
Connaissant la position des aiguilles, nous les dessinons avec la procedure drawLine(). La couleur des aiguilles étant fixée avec la procédure setColor(r : integer, g: integer, b:integer).

Le programme principal est très court, puisqu'il fait appel à l'unité uHorloge qui fait tout le gros travail. Le travail qui est confié est de charger l'image depuis le fichier horloge.png, d'appeler les fonctions définies dans uHorloge qui initialisent la position de l'horloge, et dans une boucle dessine les aiguilles de l'horloge.
Télécharger
program horloge;

uses uHorloge;

 var img : Image;
      taille, cad : record
                x, y : integer;
               end; 
      temps : integer;
 

begin
 //on charge l'image de notre cadran

 img:=LoadImage('/horloge.png');
 taille.x:=getImageWidth(img);
 taille.y:=getImageHeight(img);

 // on cherche a centrer l'horloge sur l'ecran

 cad.x:=(getWidth div 2)-(taille.x div 2);
 cad.y:=(getheight div 2)-(taille.y div 2);

 uHorloge.init(cad.x+taille.x div 2, cad.y+taille.y div 2, taille.x div 2-20);

 repeat
  drawImage(img, cad.x, cad.y);
  uHorloge .dessiner;
  Repaint;
  delay(100);
  setColor(255, 255, 255);
  fillRect(0, 0, getWidth, getheight);
 until getKeyPressed<>KE_NONE;

end.
	
La procédure fillRect dessine un rectangle rempli avec la couleur spécifiée dans setColor(), qui est la couleur blanche. De son côté, la procédure delay() fait dormir l'application suivant le nombre de milisecondes qui lui est passé en paramètre.

L'exécution du programme dans l'émulateur donne :

 

Copyright ©2009  Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.

Vos questions techniques : forum d'entraide Accueil - Publiez vos articles, tutoriels, cours et rejoignez-nous dans l'équipe de rédaction du club d'entraide des développeurs francophones. Nous contacter - Copyright 2000..2005 www.developpez.com