|
|
|
Source : ct|23.04.08
< Tutoriels Informatique, Multimédia, Chinois
OnBoardC est une suite de développement libre permettant de réaliser, en langage C compilé et sans runtime, des programmes destinés à fonctionner sur un OS Palm. Si vous ne savez pas comment télécharger, installer et utiliser OnBoardC, rendez-vous sur le tutorial "Programmer en langage C pour Palm OS" qui explique en détail comment procéder.
Nous supposerons que vous maîtrisez ces éléments, et nous allons maintenant regarder comment afficher, à l'aide d'un programme court et simple, des textes, des nombres, des lignes et des rectangles pleins (donc des points) sur l'écran d'un Palm.
Nous allons commencer par créer un squelette de programme le plus court possible, afin de pouvoir bien isoler l'essentiel du code. Puis nous étudierons les prototypes de quatre fonctions importantes permettant d'afficher du texte, des nombres, des lignes et des rectangles sur l'écran du Palm. Enfin nous compléterons le squelette du programme, en mettant en oeuvre ces fonctions dans un exemple. Dans ce tutorial, nous suivrons donc le plan suivant :
1) Réalisation d'un squelette de programme minimum;
2) Etude des fonctions permettant d'afficher des textes, des nombres et des dessins;
3) Mise en oeuvre des fonctions dans un programme exemple.
Notre squelette de programme minimum, dont le contenu figure ci-après, comprend 4 parties:
A-Une partie contenant la déclaration du fichier
<PalmOS.h>qui sera utilisé par le compilateur;
B-Une partie contenant votre code spécifique;
C-Une partie contenant le code relatif à la procédure de fenêtre du programme. Cette procédure regarde si l'utilisateur clique avec le crayon et, dans l'affirmative elle se termine, si le clic effectué correspond à message de fin de programme;
D-Une partie contenant la procédure principale du programme, qui exécute une fois la procédure debut() puis la procédure de fenêtre boucle() en boucle.
Si vous avez déjà fait de la programmation windows la procédure principale, appelée PilotMain(), correspond à la procédure WinMain().
//--------------------
//A-Définitions
//--------------------
#ifdef __GNUC__
#include <PalmOS.h>
#endif
//---------------------------
//B-Votre code
//---------------------------
static int debut()
{
//Ajouter votre code ici
return 0;
}
//----------------------
//C-Procédure de fenêtre
//----------------------
static void boucle()
{
EventType evt;
do
{
EvtGetEvent(&evt, evtWaitForever);
if (!SysHandleEvent(&evt)) FrmDispatchEvent(&evt);
}
while (evt.eType!=appStopEvent);
}
//--------------------
//D-Procédure principale
//---------------------
UInt32 PilotMain(UInt16 launchCode, void *cmdPBP, UInt16 launchFlags)
{
if (launchCode==sysAppLaunchCmdNormalLaunch)
{if (debut() ==0) boucle();}
return 1;
}
Si vous compilez puis exécutez ce programme source, il affichera simplement une fenêtre vide et sans titre, ce qui est tout à fait normal. Pour le quitter et revenir à l'écran "Applications" du Palm , cliquez la petite maison située en bas à gauche sous la fenêtre du programme.
Nous allons nous servir de quatre fonctions, qui sont déclarées dans le fichier "OnBoardHeaderV40.pdb" fourni avec la suite OnBoardC ( vous pouvez facilement le vérifier en ouvrant ce fichier à l'aide de TL-PDB).
1) La fonction StrPrintF()
Cette fonction permet d'afficher le contenu (qui peut être formaté...) d'une chaine de caractères char *formatStr dans une chaine de caractères char *s. Son prototype est : Int16 StrPrintF(char *s, const char *formatStr, ...)
//Exemples:
int n=3; suivi de StrPrintF(texte,"n = %i",2*n);// place la valeur 2*3= 6 dans la chaine "texte". StrPrintF(texte,"bonjour !"); //place le texte "Bonjour !" dans la chaine "texte"
2) La fonction WinDrawChars()
Cette fonction permet d'afficher, à un emplacement de coordonnées x,y de l'écran, le contenu d'une chaine de caractères *chars ayant une longueur len. Son prototype est : void WinDrawChars(const char *chars, Int16 len, Coord x, Coord y).
//Exemple:
WinDrawChars(texte,StrLen(texte),10,30); //affiche le contenu de la chaine texte à l'emplacement 10,30 de l'écran.
3) La fonction WinDrawLine()
Cette fonction permet de dessiner une ligne à l'écran, entre les points de coordonnées (x1,y1) et (x2,y2). Son prototype est void WinDrawLine(Coord x1, Coord y1, Coord x2, Coord y2).
//Exemple:
WinDrawLine(0, 50, 200, 50); //dessine une ligne à l'écran entre les points (0,50) et (200,50).
4) La fonction WinDrawRectangle()
Cette fonction permet de dessiner un rectangle plein. Les points haut-gauche et bas-droit de ce rectangle doivent être définis dans une variable rp de type RectangleType *. Le prototype de cette fonction est void WinDrawRectangle(const RectangleType *rP, UInt16 cornerDiam). Le type RectangleType est défini par une structure contenant les 2 points haut-gauche et bas-droit. Le paramètre cornerDiam prend la valeur 0..
typedef struct {
PointType topLeft;
PointType extent;
} RectangleType;
typedef RectangleType *RectanglePtr;
//Exemple :
RectangleType r;
r.topLeft.x=100;
r.topLeft.y=100;
r.extent.x=5;
r.extent.y=5;
WinDrawRectangle (&r,0);
Nous allons mettre en oeuvre ces fonctions en insérant les lignes de codes suivantes dans la procédure debut() (partie B) de notre squelette de programme. Les trois autres parties (A, C et D) restant inchangées.
//--------------------
//A: Définitions
//--------------------
#ifdef __GNUC__
#include <PalmOS.h>
#endif
//---------------------------
//B: Votre code
//---------------------------
static int debut()
{
RectangleType r;
r.topLeft.x=80;
r.topLeft.y=20;
r.extent.x=5;
r.extent.y=5;
char* mot="Bonjour !";
char texte[80];
int n;
n = 1234;
StrPrintF(texte,"n = %i",2*n);
WinDrawChars (mot, StrLen(mot),10,10);
WinDrawChars(texte,StrLen(texte),10,30);
WinDrawRectangle (&r,0);
WinDrawLine(0, 50, 200, 50);
return 0;
}
//----------------------
//C: Boucle évènementielle
//----------------------
static void boucle()
{
EventType evt;
do
{
EvtGetEvent(&evt, evtWaitForever);
if (!SysHandleEvent(&evt)) FrmDispatchEvent(&evt);
}
while (evt.eType!=appStopEvent);
}
//--------------------
//D: Procédure principale
//---------------------
UInt32 PilotMain(UInt16 launchCode, void *cmdPBP, UInt16 launchFlags)
{
if (launchCode==sysAppLaunchCmdNormalLaunch)
{if (debut() ==0) boucle();}
return 1;
}
Créez un projet OnBoardC de nom "essai" par exemple, insérez le code précédent dans le fichier source "essai.c" , puis compilez-le.
Une fois la compilation terminée, cliquez l'icône "essai".
A l'exécution, le programme affiche à l'écran:
- "Bonjour !" à l'emplacement (10,10) ;
- 2*1234 soit 2468 à l'emplacement (10,30) ;
- Un rectangle plein de dimension 5x5 pixels à l'emplacement (80,20) ;
- Une ligne entre les points (0,50) et (200,50).
Pour vous permettre de gagner du temps et diminuer le risque d'erreurs de manipulation, vous trouverez ici une copie du programme source au format .txt . Cette copie est enregistrée dans un fichier intitulé "copie_essai.txt". Ouvrez-le dans TL-PDB, puis créez le fichier correspondant "copie_essai.pdb". Transférez ce fichier "copie_essai.pdb" dans l'émulateur Palm (ou dans le Palm lui-même), puis ouvrez-le avec SrcEdit et copiez le texte correspondant dans le presse-papiers de l'émulateur Palm (ou dans celui du Palm).
Ensuite, créez un projet nouveau avec OnBoardC, en veillant à ne pas lui donner le même nom (sinon vous aurez une erreur au moment de la compilation du style "Out of memory ! erreur 14", :-( c'est toujours énervant...).
Dans le cas présent, pour éviter cette erreur, appelez votre nouveau projet "essai" par exemple, ou donnez-lui le nom que vous voulez mais ne l'appelez surtout pas "copie_essai".... Copiez dans le fichier source "essai.c" de votre nouveau projet le texte source que vous avez mis dans le presse-papiers. Compilez et exécutez le programme.
Maintenant il ne vous reste plus qu'à créer de nouveaux programmes contenant des dessins originaux. Par exemple, vous pouvez créer un programme affichant un dessin ou un motif réutilisable. Exécutez ce programme à l'aide de l'émulateur Palm, puis copiez le contenu de l'écran dans le presse-papiers ( à l'aide de la touche "Impr écran" ) et ensuite copiez-le dans Paint. Vous pouvez ainsi sauver votre dessin au format "bmp" ou "png" en vue de le réutiliser ultérieurement dans un autre logiciel.
 |
|
© http://turrier.fr (2007) |