L’utilisation de cet API comporte beaucoup de similitude avec le précédent. Encore une fois l’information sera prise sur une page web utilisant SSL et la réponse sera dans le format JSON (JavaScript Object Notation). Par contre, au lieu d’utiliser la méthode GET, ce sera la méthode POST qui sera utilisée par le protocole HTTP.

La première étape est de créer un nouveau projet FireMonkey HD. Dans la Form il faut insérer un TIdHTTP, un TIdSSLIOHandlerSocketOpenSSL, deux contrôles TEdit et un TButton. Vous pouvez donner comme texte à votre bouton le mot « Réduire ». Je vous propose de placer les composants dans la fenêtre de la manière suivante:
La capture d’écran a été faite sous MAC OS X. C’est effectivement l’un des avantages de FireMonkey, l’application pourra fonctionner avec un système d’exploitation Windows ou MAC OS.

Dans votre fichier cpp voici le fichier d’en-tête à ajouter:

#include <Data.DBXJSON.hpp>

Voici le code à ajouter dans votre constructeur:

    IdHTTP1->IOHandler = IdSSLIOHandlerSocketOpenSSL1;

    Edit2->ReadOnly = true; // L'URL réduit ne peut pas être changé

La prochaine étape est d’ajouter le code dans l’événement OnClick du bouton.

    Edit2->Text = ""; // On efface le texte
    Application->ProcessMessages();

    System::Classes::TStringStream* SourceFile =
        new System::Classes::TStringStream("{\"longUrl\": \"" + Edit1->Text + "\"}");

    IdHTTP1->Request->ContentType = "application/json";
    System::UnicodeString Response = IdHTTP1->Post(
        "https://www.googleapis.com/urlshortener/v1/url", SourceFile);

    TJSONObject* Obj = static_cast<TJSONObject*>(TJSONObject::ParseJSONValue(Response));
    if(Obj)
    {
        TJSONPair* Pair = Obj->Get("id");
        if(Pair)
        {
            TJSONString* Answer = static_cast<TJSONString*>(Pair->JsonValue);
            Edit2->Text = AnsiDequotedStr(Answer->ToString(), '\"');
        }
    }

    delete SourceFile;

La première ligne de code efface le texte dans le contrôle de saisie monoligne. Par contre cette action ne sera pas exécutée sur le champ parce que le reste du code est bloquant car une requête HTTP au serveur doit s’effectuer. Cette requête pourrait prendre quelques secondes donc à la deuxième ligne on laisse du temps pour exécuter l’action précédente qui est dans la file d’attente des messages. Le contrôle TEdit sera alors redessiné sans le texte.

La méthode Post sert à appeler l’API et mettre la réponse dans la variable Response, en voici un exemple:

{
 "kind": "urlshortener#url",
 "id": "http://goo.gl/bT3bc",
 "longUrl": "http://imgs.xkcd.com/comics/time_management.png"
}

Voilà, vous savez maintenant utiliser l’API URL Shortener avec C++Builder. Si vous préférez utiliser les services de TinyURL au lieu de Google, alors voici le code dont il faut vous servir dans l’événement OnClick du bouton:

    Edit2->Text = ""; // On efface le texte
    Application->ProcessMessages();

    Edit2->Text = IdHTTP1->Get("http://tinyurl.com/api-create.php?url=" + Edit1->Text);

Avant de débuter, il faut aller sur le site de Google pour activer l’API Page Speed Online dans la section Services. Il vous faudra créer une clef d’API qui sera utilisée à chaque requête. Il est à noter que Google vous donne le droit d’exécuter 2500 requêtes par jour pour cet API.

Page Speed Online API Activé

La première étape est de créer un nouveau projet FireMonkey HD. Dans la Form il faut insérer un TIdHTTP, un TIdSSLIOHandlerSocketOpenSSL, un TChart et un TLayout dans lequel il y aura un TEdit un TButton. On aligne le contrôle TLayout à alBottom et le TChart à alClient. Vous pouvez donner comme texte à votre bouton le mot « Analyser ».

Avant même de voir le code, je vous présente le résultat final. Ceci vous permettra de mieux comprendre vers où nous nous dirigeons.

Dans votre fichier cpp voici la liste de fichier d’en-tête à utiliser ainsi que la macro qui va contenir votre clef d’API. N’essayer pas d’utiliser celle-ci, il s’agit de caractères écrits de façon aléatoire.

#include <Data.DBXJSON.hpp>
#include <FMXTee.Series.hpp>
#define GOOGLEAPIKEY "dskk1j3sW4WBYdkjds8sSDSD" // Clef d'API

Voici le code à ajouter dans votre constructeur:

    IdHTTP1->IOHandler = IdSSLIOHandlerSocketOpenSSL1;

    Chart1->Title->Text->Text = "Statistique de la page"; // Titre du diagramme
    Chart1->Legend->Title->Text->Text = "Ressource en octets"; // Titre de la légende
    Series::TPieSeries *Series = new Series::TPieSeries(this); // Diagramme circulaire
    Series->Marks->Visible = false; // Ce n'est pas nécessaire car on a déjà une légende
    Chart1->AddSeries(Series);

Étant donné que nous accéderons à un site web qui utilise SSL (https), la première ligne de code est critique. Sans elle, une exception dans la classe EIdIOHandlerPropInvalid produira le message « IOHandler value is not valid ». Parce que nous utilisons OpenSSL, les fichiers ssleay32.dll et libeay32.dll devront être distribués avec votre application.

Les lignes 3 à 7 servent à ajouter des informations au graphique.

La prochaine étape est d’ajouter le code dans l’événement OnClick du bouton.

    Chart1->Series[0]->Clear(); // Efface le contenu du diagramme

    String Response = IdHTTP1->Get(
        "https://www.googleapis.com/pagespeedonline/v1/runPagespeed?url=" +
        Edit1->Text + "&key=" GOOGLEAPIKEY);

    TJSONObject* Obj = static_cast<TJSONObject*>(TJSONObject::ParseJSONValue(Response));
    TJSONPair* Pair = Obj->Get("pageStats");
    if(Pair)
    {
        String Value;
        TJSONString* Answer;
        TJSONObject* PageStats = static_cast<TJSONObject*>(Pair->JsonValue);
        if((Pair = PageStats->Get("htmlResponseBytes")) != NULL)
        {
            Answer = static_cast<TJSONString*>(Pair->JsonValue);
            Value = AnsiDequotedStr(Answer->ToString(), '\"');
            Chart1->Series[0]->Add(Value.ToIntDef(0), "HTML", claGreen);
        }
        if((Pair = PageStats->Get("cssResponseBytes")) != NULL)
        {
            Answer = static_cast<TJSONString*>(Pair->JsonValue);
            Value = AnsiDequotedStr(Answer->ToString(), '\"');
            Chart1->Series[0]->Add(Value.ToIntDef(0), "CSS", claOrange);
        }
        if((Pair = PageStats->Get("imageResponseBytes")) != NULL)
        {
            Answer = static_cast<TJSONString*>(Pair->JsonValue);
            Value = AnsiDequotedStr(Answer->ToString(), '\"');
            Chart1->Series[0]->Add(Value.ToIntDef(0), "Image", claYellow);
        }
        if((Pair = PageStats->Get("javascriptResponseBytes")) != NULL)
        {
            Answer = static_cast<TJSONString*>(Pair->JsonValue);
            Value = AnsiDequotedStr(Answer->ToString(), '\"');
            Chart1->Series[0]->Add(Value.ToIntDef(0), "JavaScript", claRed);
        }
        if((Pair = PageStats->Get("otherResponseBytes")) != NULL)
        {
            Answer = static_cast<TJSONString*>(Pair->JsonValue);
            Value = AnsiDequotedStr(Answer->ToString(), '\"');
            Chart1->Series[0]->Add(Value.ToIntDef(0), "Autre", claBlue);
        }
    }

Les lignes 3 à 5 servent à appeler l’API et mettre la réponse dans la variable Response. Cette réponse utilise le format JSON (JavaScript Object Notation). Voici la section qui nous intéresse pour notre projet:

{
 "pageStats": {
  "numberResources": 89,
  "numberHosts": 11,
  "totalRequestBytes": "18788",
  "numberStaticResources": 72,
  "htmlResponseBytes": "511838",
  "cssResponseBytes": "127217",
  "imageResponseBytes": "399484",
  "javascriptResponseBytes": "396089",
  "otherResponseBytes": "4023",
  "numberJsResources": 19,
  "numberCssResources": 4
 }
}

Comme on peut le voir certaines valeurs numériques utilisent des guillemets doubles, c’est pour cette raison que nous utiliserons la fonction AnsiDequotedStr pour les enlever.

En terminant, je voulais juste vous faire une petite mise en garde. Faites attention de protéger votre clef d’API car il est très facile pour n’importe qui de la retrouver en regardant le contenu de votre fichier exécutable. Même pas besoin d’éditeur hexadécimal compliqué, il suffit du Bloc-notes comme démontré ici:

Les fichiers à modifier sont ceux qui se trouvent dans le dossier $(BDS)\bin\subversion. Il s’agit des DLLs qu’utilise RAD Studio pour faire fonctionner son client svn. Dans ledit dossier on y trouve le fichier readme.txt suivant qui explique comment faire la mise à jour:

===============================================================================
Information about bin/subversion.
===============================================================================
This directory contains the Subversion .dll files used by the IDE’s Subversion
integration. These files can be upgraded by going to www.collab.net and
downloading the subversion client and extracting it to this location. Other
subversion installations will not be used be default. The IDE only looks in
this location, this behavior can be changed by setting the registry string
SvnDllDir under the Subversion key to the location of your Subversion
installation. This will not work with all Subversion installation because not
all installation use the same .dll names.

Pour télécharger sur le site Web de CollabNet il faut s’enregistrer, pour cette raison j’ai préféré prendre mes fichiers dans le projet Win32Svn qui se trouve sur SourceForge. Même si votre système est 64 bits il faut prendre une version 32 bits des fichiers car l’IDE est 32 bits.

Une fois l’archive enregistrée sur votre disque dur, il faut extraire tous les fichiers *.dll du dossier bin dans le dossier $(BDS)\bin\subversion. Si vous n’êtes pas certain de ce que vous faites n’hésitez pas à faire une copie de sauvegarde des fichiers utilisés par Embarcadero.

Si C++Builder était ouvert alors il faut le redémarrer. Maintenant vous devriez avoir accès aux options de révision de code et enfin pouvoir cliquer sur le bouton Commit à l’intérieur de votre IDE préféré.

Une des première chose à connaître dans FireMonkey est les formats d’images supportés par la classe TBitmap.

Voici la liste des formats supportés sur toutes les plates-formes :

• JPEG (.jpeg, .jpg)
• TIFF (.tiff, .tif)
• GIF
• PNG
• BMP

Voici la liste des formats supplémentaires avec Direct2D sur Windows :

• JPEG XR (.hdp, .jxr, .wdp)
• ICO

Voici la liste des formats supplémentaires avec GDI+ sur Windows :

• WMF
• ICO

Finalement, la liste des formats supplémentaires sur OS X :

• JPEG 2000 (.jp2)
• PSD
• TGA
• ICNS

Étant donné que TBitmap gère tous ces types d’images, cela simplifie beaucoup le code nécessaire pour charger une image des ressources. Avec ces trois lignes, vous allez pouvoir charger n’importe quelle image mentionnée plus haut.

    TResourceStream *Res = new TResourceStream((unsigned)HInstance, "PNG_LOGO", (System::WideChar *)RT_RCDATA);
    Image1->Bitmap->LoadFromStream(Res);
    delete Res;

Pour utiliser ce code il faut que toutes les images dans les ressources soient de type RCDATA. Faites attention dans l’IDE lorsque vous ajoutez une image Bitmap: le type par défaut est BITMAP, donc il faut le changer.

Bonne chance dans vos projets FireMonkey!

Maintenant, voyons comment utiliser cette classe. Tout d’abord, voici l’entête qu’il faudra ajouter à votre projet.

#include <System.Zip.hpp>

Voici un exemple très simple de code pour effectuer la compression d’un fichier.

    TZipFile *ZipFile = new TZipFile(); // Création de l'objet

    ZipFile->Open("c:\\fichier.zip", zmWrite); // Ouverture du fichier en mode écriture

    ZipFile->Add("c:\\test.xml", "test.xml"); // Ajout d'un fichier dans l'archive

    ZipFile->Close(); // Fermeture du fichier

    delete ZipFile; // Libération de la mémoire

Ce n’est pas plus compliqué que cela!

Lorsqu’un menu contextuel se ferme, l’évènement WM_MENUSELECT est envoyé avec certains paramètres. Le seul problème c’est que ce n’est pas la fenêtre qui reçoit l’évènement. C’est la classe TPopupList qui a cette responsabilité. Dans Menus.hpp on retrouve cette ligne de code:

extern PACKAGE TPopupList* PopupList;

L’objet PopupList est créé à l’initialisation, il va donc falloir capturer les messages qu’il reçoit pour appeler une méthode lors de la fermeture du menu.

Voici la liste des méthodes et attributs à ajouter a votre fichier .h:

private:	// User declarations
    void __fastcall PopupWndProc(Messages::TMessage &Message);

    WNDPROC OldPopupProc;
    TFNWndProc FPopupProcInst;
    TPopupMenu *FLastOpenPopupMenu;
protected:
    void __fastcall DoPopupExit(TPopupMenu *PopupMenu);

La première étape est de rediriger les messages vers la méthode PopupWndProc. Avant de faire cela on va d’abord enregistrer l’ancienne adresse de la procédure de fenêtre dans OldPopupProc. Voici le code à ajouter à votre constructeur:

    FPopupProcInst = MakeObjectInstance(PopupWndProc);
    OldPopupProc = (WNDPROC)SetWindowLongPtr(PopupList->Window, GWL_WNDPROC,
        (LONG_PTR)FPopupProcInst);

Dans le destructeur on va restaurer l’appel vers la méthode WndProc originale et libérer la mémoire allouée par la fonction MakeObjectInstance:

    if(FPopupProcInst != NULL)
    {
        SetWindowLong(PopupList->Window, GWL_WNDPROC, (LONG)OldPopupProc);
        FreeObjectInstance(FPopupProcInst);
    }

À la réception du message WM_MENUSELECT on regarde si MenuFlag est à 0xFFFF et Menu à NULL. Si c’est le cas, alors le menu est fermé et on appelle DoPopupExit. Cette méthode a pour paramètre un pointeur vers le TPopupMenu qui vient de se fermer. La variable FLastOpenPopupMenu contient cette information. On lui affecte une valeur à la réception du message WM_INITMENUPOPUP qui est appelé lorsqu’un TPopupMenu est sur le point d’être actif. À la place de ce message, l’évènement OnPopup aurait pu être utilisé, mais je l’ai fait de cette manière pour rendre le code plus général. Les lignes 25 et 26 servent à appeler la méthode WndProc originale.

void __fastcall TForm1::PopupWndProc(Messages::TMessage &Message)
{
    if(Message.Msg == WM_MENUSELECT)
    {
        TWMMenuSelect *MenuSelect = (TWMMenuSelect *)&Message;
        if(MenuSelect->MenuFlag == 0xFFFF && MenuSelect->Menu == NULL)
        {
            DoPopupExit(FLastOpenPopupMenu);
        }
    }
    else if(Message.Msg == WM_INITMENUPOPUP)
    {
        TWMInitMenuPopup *InitMenuPopup = (TWMInitMenuPopup *)&Message;
        const int ListCount = PopupList->Count;
        for(int i = 0; i < ListCount; ++i)
        {
            TPopupMenu *LPopupMenu = (TPopupMenu *)PopupList->Items[i];
            if(LPopupMenu->Handle == InitMenuPopup->MenuPopup)
            {
                FLastOpenPopupMenu = LPopupMenu;
                break;
            }
        }
    }
    Message.Result = CallWindowProc(OldPopupProc, PopupList->Window,
        Message.Msg, Message.WParam, Message.LParam);
}

La seule chose qui manque est de mettre votre code à l’intérieur de cette méthode.

void __fastcall TForm1::DoPopupExit(TPopupMenu *PopupMenu)
{
}

Avec le code plus haut, il serait très facile de faire un composant que l’on pourrait utiliser dans plusieurs projets qui nécessitent d’être notifiés lors de la fermeture d’un menu contextuel. L’ajout d’une propriété OnPopupExit serait simple à implémenter.

J’espère que cet article vous sera pratique.

Dans votre fichier d’en-tête, ajoutez la déclaration suivante:

    void __fastcall HookResourceString(TResStringRec& ResStringRec, Char* StrID);

Voici la méthode à ajouter à votre code:

void __fastcall TForm1::HookResourceString(TResStringRec& ResStringRec, Char* StrID)
{
    DWORD OldProtect;

    VirtualProtect(&ResStringRec, sizeof(ResStringRec), PAGE_EXECUTE_READWRITE, &OldProtect);
#if __BORLANDC__ >= 0x630
    // Pour C++Builder XE et plus
    ResStringRec.Identifier = Integer(StrID);
#else
    ResStringRec.ident = Integer(StrID);
#endif
    VirtualProtect(&ResStringRec, sizeof(ResStringRec), OldProtect, &OldProtect);
}

Le code est assez simple: on change la protection sur ResStringRec pour que l’on puisse y mettre un pointeur vers la chaîne de caractères StrID. Lorsque la modification est terminée, on remet la protection précédente.

Il est à noter que la structure TResStringRec n’est pas la même sur C++Builder 2010 et C++Builder XE. Étant donné que je n’ai pas d’autre version à ma disposition, je n’ai pas pu les vérifier.

Sur C++Builder 2010:

struct PACKAGE TResStringRec
{
    long *module;
    long ident;
};

Sur C++Builder XE:

struct DECLSPEC_DRECORD TResStringRec
{
public:
    unsigned *Module;
    int Identifier;
};

Voici un exemple d’utilisation avec la fonction MessageDlg:

HookResourceString(_SMsgDlgConfirm, L"Mon titre");
HookResourceString(_SMsgDlgYes, L"Absolument");
HookResourceString(_SMsgDlgNo, L"Pas du tout");
HookResourceString(_SMsgDlgCancel, L"Laisse faire");

MessageDlg("Veux-tu faire quelque chose?", mtConfirmation,
        TMsgDlgButtons() << mbYes << mbNo << mbCancel, 0, mbCancel);

Le premier paramètre de la méthode est le nom de la ressource qui correspond aux noms que l’on retrouve dans le fichier Consts.hpp. Donc, il est important d’inclure ce fichier d’en-tête dans votre code. Si vous êtes intéressés à connaître le texte original, alors je vous conseille de jeter un coup d’œil au fichier Consts.pas.

Je vous laisse avec une capture d’écran du résultat.

Tout d’abord, voici le prototype de la fonction qui sert à dessiner une texture à l’écran:

void GRRLIB_DrawImg (
	const f32  	xpos,			// Position de l'image sur l'axe horizontal
	const f32  	ypos,			// Position de l'image sur l'axe vertical
	const GRRLIB_texImg *  tex,	// La texture à dessiner
	const f32  	degrees,		// La rotation en degré
	const f32  	scaleX,			// Proportion sur l'axe horizontal
	const f32  	scaleY,			// Proportion sur l'axe vertical
	const u32  	color			// La couleur
)

Le dernier paramètre de la fonction, color, sert à changer la couleur d’une texture. Le format de la couleur est le codage RGBA, qui est codé sur 4 octets (32 bits). Le premier octet représente le rouge, le second le vert, le troisième le bleu et finalement le dernier octet est pour l’opacité. 0 veut dire que la couleur n’est pas présente, tandis que 255, FF en hexadécimal, signifie que l’intensité de la couleur est à son maximum. Pour le canal alpha, 0 veut dire que l’image sera complètement transparente, donc dans cet exemple, l’opacité sera fixée à 255.

À partir de l’image PNG suivante on va afficher à l’écran quatre fantômes de différentes couleurs.
Il suffit d’ajouter quelque lignes seulement pour faire un test. Les lignes surlignées sont celles ajoutées au code du template du dossier examples de GRRLIB.

#include <grrlib.h>

#include <stdlib.h>
#include <wiiuse/wpad.h>

#include "ghost.h"

int main(int argc, char **argv) {
    // Initialise the Graphics & Video subsystem
    GRRLIB_Init();

    // Initialise the Wiimotes
    WPAD_Init();

    GRRLIB_SetBackgroundColour(0xFE, 0xCF, 0x07, 0xFF);
    GRRLIB_texImg *Fantome = GRRLIB_LoadTexture(ghost);

    // Loop forever
    while(1) {

        WPAD_ScanPads();  // Scan the Wiimotes

        // If [HOME] was pressed on the first Wiimote, break out of the loop
        if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME)  break;

        // -------------------------------------------------------------------
        // Place your drawing code here
        GRRLIB_DrawImg(50, 50, Fantome, 0, 1, 1, 0xEF1E23FF); // Blinky
        GRRLIB_DrawImg(50, 250, Fantome, 0, 1, 1, 0xEE5395FF); // Pinky
        GRRLIB_DrawImg(250, 50, Fantome, 0, 1, 1, 0x6ECEDEFF); // Inky
        GRRLIB_DrawImg(250, 250, Fantome, 0, 1, 1, 0xF67E1FFF); // Clyde
        // -------------------------------------------------------------------

        GRRLIB_Render();  // Render the frame buffer to the TV
    }

    GRRLIB_FreeTexture(Fantome);
    GRRLIB_Exit(); // Be a good boy, clear the memory allocated by GRRLIB

    exit(0);
}

Le code est assez simple: à l’aide de la fonction GRRLIB_SetBackgroundColour on choisit une couleur d’arrière plan. Une texture est créée à la ligne 16 qui sera utilisée pour dessiner les fantômes aux lignes 28 à 31. Finalement la texture est détruite à la ligne 37.

Voici une capture d’écran du résultat final sous l’émulateur Dolphin révision 6972.

Une autre petite astuce est d’utiliser les paramètres scaleX et scaleY pour faire pivoter respectivement la texture horizontalement et verticalement. Pour effectuer cela il suffit de mettre une valeur négative. J’ai fait un petit bout de code qui déplace un fantôme de gauche à droite. Lorsque le fantôme se dirige vers la gauche, il regarde dans cette direction, même si sur l’image originale il regarde vers la droite.

#include <grrlib.h>

#include <stdlib.h>
#include <wiiuse/wpad.h>

#include "ghost.h"

typedef enum DirectionX {dGauche, dDroite} DirectionX;

int main(int argc, char **argv) {
    // Initialise the Graphics & Video subsystem
    GRRLIB_Init();

    // Initialise the Wiimotes
    WPAD_Init();

    GRRLIB_SetBackgroundColour(0xFE, 0xCF, 0x07, 0xFF);
    GRRLIB_texImg *Fantome = GRRLIB_LoadTexture(ghost);
    GRRLIB_SetMidHandle(Fantome, true);

    f32 Xposition = 0.0f;   // Position de l'image sur l'axe horizontal
    f32 FlipImage = 1.0f;   // Retourne l'image horizontalement
    DirectionX Direction = dDroite; // Direction (gauche ou droite)

    // Loop forever
    while(1) {

        WPAD_ScanPads();  // Scan the Wiimotes

        // If [HOME] was pressed on the first Wiimote, break out of the loop
        if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME)  break;

        // --------------------------------------------------------------------
        if(Xposition < Fantome->w / 2.0f) {
            Xposition = Fantome->w / 2.0f;
            Direction = dDroite; // On change la direction
            FlipImage = 1.0f;    // Le fantôme regarde vers la droite
        }
        else if(Xposition > (rmode->fbWidth - (Fantome->w / 2.0f))) {
            Xposition = rmode->fbWidth - (Fantome->w / 2.0f);
            Direction = dGauche; // On change la direction
            FlipImage = -1.0f;   // Le fantôme regarde vers la gauche
        }
        if(Direction == dGauche)
            Xposition -= 1.5f; // On se déplace un peu plus vers la gauche
        else
            Xposition += 1.5f; // On se déplace un peu plus vers la droite
        GRRLIB_DrawImg(Xposition, 150, Fantome, 0, FlipImage, 1, 0xEF1E23FF);
        // --------------------------------------------------------------------

        GRRLIB_Render();  // Render the frame buffer to the TV
    }

    GRRLIB_FreeTexture(Fantome);
    GRRLIB_Exit(); // Be a good boy, clear the memory allocated by GRRLIB

    exit(0);
}

Lorsque le fantôme atteint la gauche de l’écran du téléviseur, on entre dans la condition à la ligne 34. Quand on arrive à la droite, c’est la condition de la ligne 39 qui est vraie. L’image devrait être dessinée 50 ou 60 fois par seconde dépendant si l’affichage de votre téléviseur est 50 ou 60 Hz. En anglais on parle de FPS (frame per second). La valeur 1.5 aux lignes 45 et 47 correspond à la vitesse de déplacement de l’image, elle est calculée en nombre de pixels par frame.

La fonction GRRLIB_DrawImg est la base de tout jeu 2D conçu avec GRRLIB, donc il est important de bien la comprendre. J’espère que cet article vous a aidé.

C’est un programmeur du nom de godisgovernment qui a finalement fixé le problème à la révision 6177. Cette modification ne fait donc pas partie de la version 2.0, qui est la dernière version officielle à être distribuée. Les dernières versions de Dolphin sous Subversion sont quand même disponibles en téléchargement à partir de ce site Web.

Étant donné que ce n’est pas mon habitude de terminer un article sans code, je vous laisse avec un programme qui vous permettra de faire vous-même le test sous Dolphin. La bibliothèque GRRLIB sera utilisée pour la partie graphique. Comme pour tous les homebrews sur la Wii, c’est wiiuse qui servira pour la communication avec la Wii Remote.

#include <grrlib.h>
#include <stdlib.h>
#include <wiiuse/wpad.h>

#include "player1_point_png.h"

#define HOTSPOTX 48 // Cursor hot spot for x coordinate
#define HOTSPOTY 48 // Cursor hot spot for y coordinate

int main(int argc, char **argv) {
    // Initialise the Graphics & Video subsystem
    GRRLIB_Init();

    GRRLIB_texImg *Cursor0 = GRRLIB_LoadTexture(player1_point_png);
    GRRLIB_SetHandle(Cursor0, HOTSPOTX, HOTSPOTY);// Not needed, by default center is selected

    // Initialise the Wiimotes
    WPAD_Init();
    WPAD_SetDataFormat(WPAD_CHAN_ALL, WPAD_FMT_BTNS_ACC_IR);
    WPAD_SetVRes(WPAD_CHAN_ALL, rmode->fbWidth, rmode->efbHeight);

    // Loop forever
    while(1) {
        WPAD_ScanPads();  // Scan the Wiimotes
        WPADData *WPadData0 = WPAD_Data(WPAD_CHAN_0);

        // If [HOME] was pressed on the first Wiimote, break out of the loop
        if (WPadData0->btns_d & WPAD_BUTTON_HOME)  break;

        // ---------------------------------------------------------------------
        if(WPadData0->ir.valid) {
            GRRLIB_DrawImg(WPadData0->ir.x - HOTSPOTX,
                WPadData0->ir.y - HOTSPOTY, Cursor0,
                WPadData0->ir.angle, 1, 1, 0xFFFFFFFF);
        }
        // ---------------------------------------------------------------------

        GRRLIB_Render();  // Render the frame buffer to the TV
    }

    GRRLIB_Exit(); // Be a good boy, clear the memory allocated by GRRLIB

    GRRLIB_FreeTexture(Cursor0);

    exit(0);
}

À la ligne 14 on charge l’image dans une texture. L’image utilisée pour le pointeur est celle-ci: Il s’agit d’une image qui fait partie d’un ensemble de curseurs pour la Wii conçus par drmr. Toutes les images sont de 96×96 pixels et le point sensible, habituellement le bout du doigt, est situé au centre. L’auteur a renoncé à ses droits sur les images pour les mettre dans le domaine public. Vous pouvez donc les utiliser dans vos applications sans problème de copyright.

À la ligne 19 on spécifie le format des données qui seront prises sur la Wii Remote. BTNS_ACC_IR veut dire boutons + accéléromètre + infrarouge. Par la suite, la fonction WPAD_SetVRes sert à définir la résolution d’écran virtuel pour la localisation de l’infrarouge. Pour ces opérations on utilise le paramètre WPAD_CHAN_ALL pour que tous les contrôleurs soient affectés. Pour que la fonction affecte une télécommande en particulier on doit utiliser WPAD_CHAN_0, WPAD_CHAN_1, WPAD_CHAN_2 ou WPAD_CHAN_3.

À la ligne 25 on va chercher les données de la première Wii Remote avec la fonction WPAD_Data. Les lignes 31 à 35 servent à faire afficher le curseur avec le bon angle à la position vers laquelle la télécommande pointe. Et ce, seulement si les coordonnés sont valides. Donc, si vous mettez votre main devant la Wii Remote, le pointeur disparaîtra de l’écran de votre téléviseur.

J’aurais pu ajouter bien des choses dans le code, mais j’ai décidé de le garder simple.

Bonne programmation…

La première méthode qui sera expliquée sera l’utilisation d’une texture. Bien sûr, lorsqu’on parle de texture, on parle d’une image. Même si GRRLIB supporte les formats JPEG et Bitmap, il serait préférable que celle-ci soit en format PNG, car ce format permet l’utilisation de transparence. Il existe plusieurs logiciels qui permettent de générer de telles images. Celui que j’utilise est WiiBuilder. Voici l’image qui sera utilisée pour cet article:
Vous pouvez vous rendre compte de certaines limites simplement en regardant l’image. Tous les caractères qui seront nécessaires dans l’application devront être générés dans l’image. Dans celle-ci, il n’y a que les caractères 32 à 128, qui sont les caractères visibles du code ASCII. Donc, pas question d’utiliser un E accent aigu ou un A accent grave. Ces caractères auraient pu être générés, mais l’image aurait été plus grande.

Le plus grand inconvénient à utiliser une image est que chaque caractère doit avoir la même largeur. Dans l’exemple ci-dessus, c’est 13 pixels. Cela veut dire que même si on décide d’afficher un i ou un !, ils vont prendre la même place qu’un m ou w, qui sont généralement plus grand. Donc, à l’écran le mot Wii, pourrait avoir l’air de "W i i ". Bien sûr cela dépend toujours de la police utilisée. Dans celle que j’ai choisie, tous les caractères ont sensiblement la même largeur. On dit que c’est une police d’écriture à chasse fixe.

Il faut convertir l’image en fichier d’entête et la transformer en texture à l’aide de la fonction GRRLIB_LoadTexture. Ces manipulations ont déjà été abordées dans un article précédent, donc veuillez vous y référer si vous avez besoin d’aide. Il existe deux différences entre l’affichage de texte et l’affichage d’images. La première est qu’après avoir chargé l’image dans une structure de type GRRLIB_texImg, il faut spécifier les détails de notre image avec la fonction GRRLIB_InitTileSet. Les paramètres de la fonction dans l’ordre sont un pointeur vers la texture, la largeur et la hauteur d’un caractère et le caractère de départ. La seconde différence est l’utilisation de GRRLIB_Printf au lieu de GRRLIB_DrawImg.

Voici donc le code. Les lignes surlignées sont celles ajoutées au code du template du dossier examples de GRRLIB.

#include <grrlib.h>

#include <stdlib.h>
#include <wiiuse/wpad.h>

#include "demofont.h"

int main(int argc, char **argv) {
    // Initialise the Graphics & Video subsystem
    GRRLIB_Init();

    GRRLIB_texImg *demo_font = GRRLIB_LoadTexture(demofont);
    GRRLIB_InitTileSet(demo_font, 13, 23, 32);

    // Initialise the Wiimotes
    WPAD_Init();

    // Loop forever
    while(1) {

        WPAD_ScanPads();  // Scan the Wiimotes

        // If [HOME] was pressed on the first Wiimote, break out of the loop
        if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME)  break;

        // ---------------------------------------------------------------------
        // Place your drawing code here
        GRRLIB_Printf(5, 100, demo_font, 0xFFFFFFFF, 1,
            "Ceci est un test de texture");
        // ---------------------------------------------------------------------

        GRRLIB_Render();  // Render the frame buffer to the TV
    }

    GRRLIB_FreeTexture(demo_font);
    GRRLIB_Exit(); // Be a good boy, clear the memory allocated by GRRLIB

    exit(0);
}

Cela fait le tour de la première méthode. La prochaine dont il va être question est l’utilisation de fichier BMF pour afficher du texte. BMF est l’extension qui désigne un bitmap font. Ce type de fichier peut être téléchargé sur le site Web suivant: http://bmf.wz.cz. La police que j’ai choisie se nomme NOSTK. Elle possède seulement 35 caractères et les lettres minuscules ne sont pas présentes.

Les étapes pour afficher du texte sont assez simples. Encore une fois, on transforme le fichier en entête qui sera inclus dans le main.c. On charge l’image dans une structure. Cette fois-ci, il s’agit d’un GRRLIB_bytemapFont. On dessine le texte avec GRRLIB_PrintBMF et la mémoire est libérée grâce à GRRLIB_FreeBMF.

Voici le code avec les nouvelles lignes surlignées:

#include <grrlib.h>

#include <stdlib.h>
#include <wiiuse/wpad.h>

#include "demofont.h"
#include "nostk.h"

int main(int argc, char **argv) {
    // Initialise the Graphics & Video subsystem
    GRRLIB_Init();

    GRRLIB_texImg *demo_font = GRRLIB_LoadTexture(demofont);
    GRRLIB_InitTileSet(demo_font, 13, 23, 32);
    GRRLIB_bytemapFont *bmf_font = GRRLIB_LoadBMF(nostk);

    // Initialise the Wiimotes
    WPAD_Init();

    // Loop forever
    while(1) {

        WPAD_ScanPads();  // Scan the Wiimotes

        // If [HOME] was pressed on the first Wiimote, break out of the loop
        if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME)  break;

        // ---------------------------------------------------------------------
        // Place your drawing code here
        GRRLIB_Printf(10, 100, demo_font, 0xFFFFFFFF, 1,
            "Ceci est un test de texture");
        GRRLIB_PrintBMF(10, 150, bmf_font,
            "CECI EST UN TEST DE FICHIER BMF");
        // ---------------------------------------------------------------------

        GRRLIB_Render();  // Render the frame buffer to the TV
    }

    GRRLIB_FreeTexture(demo_font);
    GRRLIB_FreeBMF(bmf_font);
    GRRLIB_Exit(); // Be a good boy, clear the memory allocated by GRRLIB

    exit(0);
}

La dernière méthode est l’utilisation de fichier TTF. TTF est l’extension pour désigner une police de caractères de format TrueType. Les polices TrueType sont constituées de vecteurs donc la qualité du texte ne diminue pas contrairement au bitmap lorsque la taille augmente. La police que j’ai choisie se nomme Miama et elle possède 1110 caractères. Par contre, sa taille est de 106 Ko, ce qui reste quand même raisonnable. Elle a été téléchargée sur le site Open Font Library.org.

Les étapes pour afficher du texte sont les mêmes que pour les BMF, sauf que l’on remplace le mot BMF par TTF. On charge l’image dans une structure de type GRRLIB_ttfFont avec la fonction GRRLIB_LoadTTF. On dessine le texte avec GRRLIB_PrintfTTF et la mémoire est libérée grâce à GRRLIB_FreeTTF. Il est possible d’utiliser des chaînes de caractères de type wchar_t avec la fonction GRRLIB_PrintfTTFW.

Voici le code avec les nouvelles lignes surlignées:

#include <grrlib.h>

#include <stdlib.h>
#include <wiiuse/wpad.h>

#include "demofont.h"
#include "nostk.h"
#include "Miama.h"

int main(int argc, char **argv) {
    // Initialise the Graphics & Video subsystem
    GRRLIB_Init();

    GRRLIB_texImg *demo_font = GRRLIB_LoadTexture(demofont);
    GRRLIB_InitTileSet(demo_font, 13, 23, 32);
    GRRLIB_bytemapFont *bmf_font = GRRLIB_LoadBMF(nostk);
    GRRLIB_ttfFont *ttf_font = GRRLIB_LoadTTF(Miama, Miama_size);

    // Initialise the Wiimotes
    WPAD_Init();

    // Loop forever
    while(1) {

        WPAD_ScanPads();  // Scan the Wiimotes

        // If [HOME] was pressed on the first Wiimote, break out of the loop
        if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME)  break;

        // ---------------------------------------------------------------------
        // Place your drawing code here
        GRRLIB_Printf(10, 100, demo_font, 0xFFFFFFFF, 1,
            "Ceci est un test de texture");
        GRRLIB_PrintBMF(10, 150, bmf_font,
            "CECI EST UN TEST DE FICHIER BMF");
        GRRLIB_PrintfTTF(10, 200, ttf_font,
            "Ceci est un test de police TrueType", 60, 0xFFFFFFFF);
        // ---------------------------------------------------------------------

        GRRLIB_Render();  // Render the frame buffer to the TV
    }

    GRRLIB_FreeTexture(demo_font);
    GRRLIB_FreeBMF(bmf_font);
    GRRLIB_FreeTTF(ttf_font);
    GRRLIB_Exit(); // Be a good boy, clear the memory allocated by GRRLIB

    exit(0);
}

L’encodage par défaut des fichiers dans Programmer’s Notepad pourrait vous causer des problèmes avec certains caractères de la langue française. Si c’est la cas, il faut donc aller dans File / Properties… ou sinon utiliser le raccourci Alt + Entrée avec le bon fichier ouvert. Au lieu de Default dans la liste Encoding, vous pouvez sélectionner UTF-8. Si vous désirez ne pas altérer votre fichier qui contient le code, vous pouvez alors créer un fichier d’entête avec l’encodage de votre choix qui contiendra tout le texte dans des directives #define.

Je vous laisse avec une image du résultat final.