Introduction à MIDlet Pascal

MIDlet Pascal est disponible au téléchargement ; la version 2.02 utilisée pour ce tutoriel est téléchargeable par un lien au bas de la page.

Une fois téléchargé, double-cliquez sur MPInstall202.exe. Ensuite suivez les instructions jusqu'à la fin de l'installation.

L'installation est finie ; à présent, vous pouvez lancer l'outil.

MIDlet Pascal peut s'installer sur toutes les versions de Windows.

L'installation sous Linux se fait en deux temps si vous ne disposez pas de wine (site officiel).

II-B-1. Étape 1 : Installation de wine .▲

II-B-2. Étape 2 : Installation de MIDlet Pascal 2.02▲

Nous présenterons seulement quelques menus de l'interface, les autres étant assez intuitifs.

III-A-1. Outil d'édition et de gestion▲

III-A-2. Gestion de la vue▲

III-A-3. Gestion des éléments de projet▲

unit votre_unite;
 
interface
        { add public declarations here }
 
implementation
        { add unit functions and procedures here }
 
initialization
        { add initialization code here }
end.

III-A-4. Options▲

cmd /A /C %JAD%

Elle ne contient que des raccourcis vers certains éléments des menus ci-dessus.

En compilant votre programme, vous verrez apparaître sur la console ce qu'a produit le compilateur.

Exemple : en compilant le source projet_test.mpsrc(mpsrc = midlet pascal source) :

V-A-1. Théorie sur la compilation▲

MIDlet-1: test, /icon.png, main
MIDlet-Jar-Size: 33610
MIDlet-Jar-URL: test.jar
MIDlet-Name: test
MIDlet-Vendor: darrylsite
MIDlet-Icon: /icon.png
MIDlet-Version: 1.0.0
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0

V-A-2. La compilation en pratique▲

program hello;
 
//fait rotation des caractères d'une phrase
function rotation(tex: string) :string;
var
  c, d: char;
  i :integer;
begin
  c:=getChar(tex,0);
  for i:=length(tex)-1 downto 0 do
    begin
      d:=getChar(tex,i);
      tex:=setChar(tex, c, i);
      c:=d;
    end;
  rotation:=tex;
end;
 
{--------------------------------------}
 
{crée l'effet de texte défilant et l'affiche sur l"ecran}
procedure animation;
const
  texte='Hello world - MidletPascal - developpez.com *** ';
  dim=20;
var
  rot, aux : string;
  a, b : integer;
begin
  rot:=texte;
  //SetFont(FONT_FACE_SYSTEM,FONT_STYLE_BOLD,FONT_SIZE_LARGE);
  //couleur bleue
  setColor(0, 0, 250);
  rot:=texte;
  //on cherche a centrer le texte sur l'ecran
  b:=(getHeight div 2) - (getStringHeight(copy(rot,0, dim)) div 2);
  a:=(getWidth div 2) - (getStringWidth(copy(rot,0, dim)) div 2);
  repeat
    setColor(50, 114, 184);
    aux:=copy(rot,0, dim);
    drawText(aux, a, b);
    rot:=rotation(rot);
    repaint;
    delay(250);
    SetColor(255, 255, 255);
    FillRect(a, b, getStringWidth(aux)+20, getStringHeight(aux));
  until GetKeyClicked <> KE_NONE;
end;
 
BEGIN
  animation;
END.

V-A-3. Fichiers jad et jar générés lors de la compilation▲

Voyons comment exécuter notre projet dans un émulateur, et ensuite comment déployer l'application et l'installer sur les téléphones portables.

V-B-1. Exécution du projet dans un émulateur▲

V-B-2. Déploiement et exécution sur téléphone portable▲

MIDlet-1: test, /icon.png, main
MIDlet-Jar-Size: 33610
MIDlet-Jar-URL: test.jar
MIDlet-Name: test
MIDlet-Vendor: darrylsite
MIDlet-Icon: /icon.png
MIDlet-Version: 1.0.0
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0

MIDlet-Jar-URL: http://darrylsite.developpez.com/midlet/test.jar

Une unité sous MIDlet Pascal comprend trois parties :

• Interface ;
• Implémentation ;
• Initialisation.

Dans l'interface, on définit l'entête des fonctions que d'autres programmes pourront utiliser. C'est dans la partie implémentation que ces fonctions seront déclarées entièrement avec leur code. On peut aussi déclarer dans les entêtes des fonctions qui n'ont pas été définies dans la partie implémentation. La dernière partie - initialisation - est réservée à l'initialisation des variables globales de l'unité.

Avec MIDlet Pascal, on ne peut définir qu'une unité par fichier, et le nom du fichier doit correspondre au nom de l'unité.

Format d'une unité sous MIDlet Pascal : PremierUnite.mpsrc.

unit premierUnite;
 
interface
{ procedure et fonctions publiques }
 
implementation
{ codes des procedures et fonctions}
 
initialization
{ initializations des variables}
end.

Lancez MIDlet Pascal et créez un nouveau projet. Nommons-le « hello2 ». Allez dans le menu Project et choisissez New source file. Dans la boîte de dialogue qui s'affiche, tapez le nom de l'unité « transform».

Nous allons transformer notre programme précédent en un programme principal et une unité. Voyons le code de l'unité :

unit transform;
 
interface
 
procedure animation; //affiche le texte defilant
procedure setTexte(s : String); //definit le texte a faire defiler
 
implementation
 
var
  texte : String; //le texte a faire défiler
  dim : integer; // nombre de caractères à afficher
 
procedure setTexte(s : String);
begin
  texte:=s;
end;
 
//fait rotation des caractere d'une phrase
function rotation(tex: string) :string;
var
  c, d: char;
  i :integer;
begin
  c:=getChar(tex,0);
  for i:=length(tex)-1 downto 0 do
    begin
      d:=getChar(tex,i);
      tex:=setChar(tex, c, i);
      c:=d;
    end;
  rotation:=tex;
end;
 
{cree l'effet de texte defilant et l'affiche}
procedure animation;
var
  rot, aux : string;
  a, b : integer;
begin
  //on affiche le texte defilant
  rot:=texte;
  setColor(0, 0, 250);
  rot:=texte;
  //position du texte à l'ecran
  //on affiche le texte centre sur l'ecran
  b:=(getHeight div 2) - (getStringHeight(copy(rot,0, dim)) div 2);
  a:=(getWidth div 2) - (getStringWidth(copy(rot,0, dim)) div 2);
  repeat
    setColor(50, 114, 184);
    aux:=copy(rot,0, dim);
    drawText(aux, a, b);
    rot:=rotation(rot);
    repaint;
    delay(250);
    SetColor(255, 255, 255);
    FillRect(a, b, getStringWidth(aux)+20, getStringHeight(aux));
  until GetKeyClicked <> KE_NONE;
end;
 
initialization
 
dim:=20;
 
end.

Vous pouvez voir qu'il n'y a pas de modification importante par rapport au code précédent. Nous avons mis les deux fonctions setText() et animation() dans la partie interface. Dans la partie implementation, nous avons défini le code de ces deux fonctions, et aussi d'autres fonctions comme rotation(), qui est utilisée par animation(), mais qui ne pourra être appelée par un autre programme ou unité utilisant l'unité transform puisque son entête ne figure pas dans la partie Interface.

Dans la dernière partie, à savoir initialization, nous initialisons dim à 20, qui est le nombre de caractères à afficher à l'écran.

Pour utiliser l'unité dans un programme, il suffit d'ajouter après le nom du programme la clause uses suivie du nom de l'unité. Si vous voulez utiliser une unité depuis une autre unité, la clause uses doit être placée immédiatement après la clause implementation.

Une fois la déclaration faite, toutes les procédures et variables disponibles dans l'interface de l'unité peuvent être utilisées.

Voyons le code du programme principal de notre programme utilisant l'unité transform :

program hello;
//appel de l'unite
 
uses tranform; 
 
BEGIN
setTexte(' hello world -- darrylsite -- developpez.com --');
animation;
 
END.

Lorsque que plusieurs unités ont les mêmes noms pour des identificateurs, on peut précéder le nom de l'identificateur du nom de l'unité qui le contient, suivi d'un point. Et ceci est indispensable si on veut utiliser des variables, des types ou des constantes déclarées dans la partie interface d'une unité.

program hello;
//appel de l'unite
 
uses tranform; 
 
BEGIN
Transform.setTexte(' hello world -- darrylsite -- developpez.com --');
Transform.animation;
 
END.

Il nous arrive fréquemment de réutiliser des unités provenant d'autres projets. Avec certains compilateurs comme Turbo Pascal ou Free Pascal, par exemple, il suffit de mettre l'unité dans le même dossier puis de lancer la compilation. Avec MIDlet Pascal, il faut créer une nouvelle unité dans le projet en cours, puis copier/coller le code de l'ancienne unité dans celle que vous venez de créer.

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 resource. 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 le format png est supporté.

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.

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;
 
//arrondit un réel positif à 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 procédure 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 lui 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.

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 :