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.
Concernant les images, seul les format png sont supportés.
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;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.
Sélectionnezprogram 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 :
