[Pratique] Création de jeux 2D en EFL



Historique des mises à jour

  • Le 06/04/2010
    Mise à jour tuto complet



Nous allons étudier une bibliothèque qui a pour nom EFL (Enlightenment Foundation Libraries).
Cette bibliothèque, une fois installée, rajoute de nombreuses possibilités. Vous allez pouvoir en effet ouvrir des fenêtres, faire du plein écran, dessiner, gérer le contrôle du clavier, de la souris ...

Ceci est la version 2 de se tuto. Avril 2010

Les bases - EVAS

Bonjour voila je vous propose, un document présenté , comme un cours permettant d'apprendre et d'appréhender le concept des EFL.
Je me suis instpiré d'un cours sur la sdl, que j'ai adapté pour les efl.

Prerequis


Pour pouvoir comprendre ce cours, il est impérative d'avoir ces prérequis :

  • Savoir coder en C : notion de base.
  • Avoir installer la librairies EFL.


Avoir de l'aide pour vos application développer en EFL :

Rejoignez la communauté fr sur #e.fr (irc.freenode.net) ou sur les listes de diffusions, et n'oubliez pas d'aller consulter le Wiki (en) ou Wiki (fr).

Installation de la librairie EFL

Chapter intro

Pourquoi avoir choisi la librairie EFL ?

Here some text...

Téléchargement de la librairie EFL

Here some text...

Créer un projet EFL

Here some text...
Chapter conclu

Création d'une fenêtre et d'objets EVAS

Charger et arrêter EVAS

Dans cette partie nous allons étudier EVAS, qui est un composant des EFL, dont voici l'utilité :

Citation :
Evas est le moteur de rendu des Efls. Il utilise du code très optimisé pour le traitement des images, ainsi que l'accélération matérielle disponible pour optimiser le rendu. Evas utilise une notion d'objets, le développeur "joue" avec ces objets sans avoir à se soucier de leurs états.


Un grand nombre de bibliothèques écrites en C nécessitent d'être initialisées et fermées par des appels à des fonctions. EVAS n'échappe pas à la règle.

En effet, la bibliothèque doit charger un certain nombre d'informations dans la mémoire pour pouvoir fonctionner correctement. Ces informations sont chargées en mémoire dynamiquement par des malloc (ils sont très utiles ici !). Or, comme vous le savez, qui dit malloc dit... free !
Vous devez libérer la mémoire que vous avez allouée manuellement et dont vous n'avez plus besoin. Si vous ne le faites pas, votre programme va prendre plus de place en mémoire que nécessaire, et dans certains cas ça peut être complètement catastrophique (imaginez que vous fassiez une boucle infinie de malloc sans le faire exprès, en quelques secondes vous saturerez toute votre mémoire !).

Voici donc les 2 premières fonctions d'EVAS à connaître :

  • ecore_evas_init () : charge EVAS en mémoire (des malloc y sont faits).
  • ecore_evas_shutdown (): libère EVAS de la mémoire (des free y sont faits).


ecore_evas_init () : chargement d'EVAS


La fonction ecore_evas_init () est super simple à utiliser vu qu'elle ne prend pas de paramètre :

Code : c
ecore_evas_init ();


ecore_evas_shutdown () : arrêt d'EVAS


La fonction ecore_evas_shutdown () est aussi simple à utiliser que ça compére vu qu'elle aussi ne prend pas de paramètre :

Code : c
  ecore_evas_shutdown ();


Tous les systèmes initialisés seront arrêtés et libérés de la mémoire.
Bref, c'est un moyen de quitter EVAS proprement. A faire à la fin de votre programme.

En résumé...



Code : c
#include <stdlib.h>
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{

  ecore_evas_init (); // Démarrage des EFL

   /*
    Les EFL sont chargées.
    Vous pouvez mettre ici le contenu de votre programme
    */

ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

return 0;

 }


Bien entendu, aucun programme "sérieux" ne tiendra dans le main. Ce que je fais là est schématique. Dans la réalité, votre main contiendra certainement plein d'appels à des fonctions qui feront elles aussi plein d'appels à d'autres fonctions.
Ce qui compte au final, c'est qu'EVAS soit chargée au début et qu'elle soit fermées à la fin quand vous n'en avez plus besoin.

Gérer les erreurs


Voila quoi utiliser :

Code : c
...
    if (!ecore_evas_init()) {
        printf("Ecore_Evas failed. Please check your installation!\n");
        return 1;
    }
...

Ouverture d'une fenêtre

Bon, EVAS est initialisée et fermée correctement maintenant :)
La prochaine étape, si vous le voulez bien (et je suis sûr que vous le voulez bien :D ), c'est l'ouverture d'une fenêtre !

Pour commencer déjà, assurez-vous d'avoir un main qui ressemble à ceci :

Code : c

#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
      if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
    {
        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
        exit(EXIT_FAILURE); // On quitte le programme
    }
 
ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

return EXIT_SUCCESS;

 }


(cela devrait être le cas si vous avez bien suivi le début du chapitre).
Pour le moment pas la peine compiler, rien ne se passe, puisque on ouvre et ferme notre programme en EFL.

Choix du mode vidéo


La première chose à faire après ecore_evas_init () c'est indiquer le mode vidéo que vous voulez utiliser, c'est-à-dire la résolution, le nombre de couleurs et quelques autres options.

On va utiliser pour cela la fonction ecore_evas_new() qui prend 6 paramètres :

  • Des options (des flags, correspondant au driver video utilisé)
  • La position abscise de la fenêtre sur l'écran
  • La position ordonnée de la fenêtre sur l'écran
  • La largeur de la fenêtre désirée (en pixels)
  • La hauteur de la fenêtre désirée (en pixels)
  • "Option extra", par défaut NULL, mais dépends du drivers ( des flags)


Je vais expliquer le premier et la derniére options.

Les options : on doit utiliser des flags pour définir des options correspondant au driver video utilisé. Voici les principaux flags que vous pouvez utiliser :

  • SOFTWARE_X11 : driver utilisé par défaut sous linux
  • SOFTWARE_X11 : driver utilisé si on dévellope sous windows ;)

La derniere options seras toujours à NULL.

Mais avant de faire ça, il faut déclarer un "objet" qui vas contenir notre écran, appellon le ecran :

Code : console
Ecore_Evas  *ecran;


Donc, si je fais :

Code : console
Ecore_Evas  *ecran;
ecran = ecore_evas_new ("software_x11", 0, 0, 640, 480, NULL);

Cela crée une variable evran qui ouvre une fenêtre de taille 640*480 en utilisant le drivers software_x11.

Il faut maintenant afficher notre objet :

Code : console
ecore_evas_show (ecran);

Voici un premier code source très simple que vous pouvez essayer :

Code : console
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

        ecran = ecore_evas_new ("software_x11", 0, 0, 640, 480, NULL); //On paramétre notre écran
        
        ecore_evas_show (ecran);//On affiche notre écran

        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

return EXIT_SUCCESS;

 }


Testez.
Que se passe-t-il ? La fenêtre apparaît et disparaît à la vitesse de la lumière. En effet, la fonction ecore_evas_show ();
est immédiatement suivie de ecore_evas_shutdown, donc tout s'arrête immédiatement.

Mettre en pause le programme


Comment faire pour faire en sorte que la fenêtre se maintienne ?


Il faut faire comme le font tous les programmes, que ce soit des jeux vidéo ou autre : une boucle infinie.
En effet, en faisant une bête boucle infinie on empêche notre programme de s'arrêter, de plus, la fonction ecore_main_loop_begin() ne sert pas a seulement mettre en pause, c'est un "main loop" c'est à dire une boucle infinie, durant laquelle on teste tous les evenements specifiques au systeme graphique (souris, clavier, gestion des fenetres, etc...) et durant laquelle sont geres les timer ( on verras sa plus en détaille, dans les prochains chapitres)

Code : console
ecore_main_loop_begin();


Pour arreter le programme il suffit d'appuyer sur la croix de la fenettre ouverte.

Résumons ou nous en somme :

Code : console
#include <Ecore.h>
#include <Ecore_Evas.h>
int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

        ecran = ecore_evas_new ("software_x11", 0, 0, 640, 480, NULL); //On paramétre notre écran
        
        ecore_evas_show (ecran);//On affiche notre écran

        ecore_main_loop_begin();
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

return EXIT_SUCCESS;

 }

Compilé moi ça et savouré !
Voici à quoi devrait ressembler la fenêtre que vous avez sous les yeux (ici une fenêtre 640x480) :

EFL Fênetre vide

Pfiou ! Nous y sommes enfin arrivés ! :D

Changer le titre de la fenetre


Pour le moment, notre fenêtre n'a pas de titre, que diriez-vous de changer cela ?
C'est extrêmement simple, il suffit d'utiliser la fonction :

Code : console
ecore_evas_title_set()


Cette fonction prend 2 paramètres.
Le premier est le titre de l'object fenêtre que vous voulez nommer et le deuxiéme et le nom que vous voule lui donnez.

Voici donc la ligne à rajouter dans notre code pour renommer la fenetre, cette ligne est à rajouter juste aprés la déclaration de l'object ecran :

Code : console
ecore_evas_title_set(ecran, "Ma super fenêtre Enlightenment !");/code>


Et pour finir voici notre code complet basique :

<code type="console">
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

        ecran = ecore_evas_new ("software_x11", 0, 0, 640, 480, NULL); //On paramétre notre écran
        ecore_evas_title_set(ecran, "Ma super fenêtre Enlightenment !");

        ecore_evas_show (ecran);// On affiche notre écran

        ecore_main_loop_begin();
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

return EXIT_SUCCESS;

 }


La fenêtre a maintenant un titre
EFL Fênetre titre

Manipulation des objets

Pour le moment nous avons une fenêtre avec un fond noir. C'est la fenêtre de base.
Ce qu'on veut faire, c'est la remplir, c'est-à-dire ajouter des "objets" dedans.

EVAS nous propose que des fonctions de base, très simples,que nous allons voir :


Votre conteneur d'objet : l'écran


Dans tout programme EFL, il y a au moins un élément que l'on appelle généralement ecran. C'est un conteneur d'objet C'est lui qui vas contenir tout nos objet créer que l'on vas manipuler.

Dans notre code source, chaque objet sera mémorisée dans une variable de type Ecore_Evas. Oui, c'est un type de variable créé par les EFL (une structure en l'occurence).

Comme la première surface que nous devons créer est l'écran, allons-y :

Code : c
Ecore_Evas  *ecran;


Vous remarquerez que je crée un pointeur. Pourquoi je fais ça ? Parce que c'est la lib EFL qui va allouer de l'espace en mémoire pour notre surface. Une surface n'a en effet pas toujours la même taille, et la lib EFL est obligée de faire une allocation dynamique pour nous (ici ça dépendra de la taille de la fenêtre que vous avez ouverte).

Je ne vous l'ai pas dit tout à l'heure, mais la fonction ecore_evas_new renvoie une valeur ! Elle renvoie un pointeur sur la surface de l'écran qu'elle a créée en mémoire pour nous.
Cool, on va donc pouvoir récupérer ce pointeur dans ecran :

Notre pointeur peut valoir :

  • False : ecran vaut False si la lib EVAS ecore_evas_new n'a pas réussi à charger le mode vidéo demandé. Cela arrive si le driveur video, n'est pas bon
  • Une autre valeur : si la valeur est différente de NULL, c'est que la lib EFL a pu allouer la surface en mémoire, donc que tout est bon !


Il serait bien ici de gérer les erreurs, comme on l'a fait tout à l'heure pour l'initialisation de la ecore_evas_init. Voici donc notre main avec la gestion de l'erreur pour ecore_evas_new :

Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...

        if (!ecore_evas_init()) {
        printf("Ecore_Evas failed. Please check your installation!\n");
        return 1;
    }

        ecran = ecore_evas_new ("software_x11", 0, 0, 640, 480, NULL); //On paramétre notre écran
        
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }

        ecore_evas_title_set(ecran, "Ma super fenêtre Enlightenment !");

        ecore_evas_show (ecran);// On affiche notre écran

        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme

        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;

 }



Les objet


Un peu avoir plusieurs type d'objet, mais dans notre cas, nous allons étudier pour le moment ses 3 la :

  • Objet rectangle
  • Objet ligne



Il existe d'autre type d'objet que nous verrons plus tard.


Nous allons dans un premier temps voir comment créer une ligne et un rectangle avec une couleur unie. Dans le chapitre suivant, nous apprendrons à charger une image.

Objet rectangle


Premiére chose à faire créer notre objet evas conteneur :

Code : c
Evas_Object *object_01; //objet que l'on vas coloriser


On commence par intégrer notre object dans l'evas ( qui je rapelle est en réalité notre fenêtres qui contiendras nos objets) :

Code : c
object_01 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas


la couleur :


On donne la couleur à notre objet en utilisant la fonction evas_object_color_set :

Code : c
evas_object_color_set (object_01,17, 206, 112, 255); // couleur du rectangle


Cette fonction prend en paramétre :

  • Le nom de l'objet_evas sur lequelle on applique notre couleur
  • La quantité de rouge de la couleur
  • La quantité de vert de la couleur
  • La quantité de bleu de la couleur
  • Un paramétre pour la transparence (parametre dit 'alpha') que nous verrons plus en détail dans la prochaine partie


La taille de notre objet :


Code : c
evas_object_resize(object_01, 640, 480); // taille du rectangle


Cette fonction prend en paramétre :

  • Le nom de l'objet_evas sur lequelle on applique notre couleur
  • La hauteur de l'objet
  • La largeur de l'objet


Mise à jour de l'affichage avec notre objet :


Cette fonction prend en paramétre notre Evas_object object_01, afin de l'afficher dans notre écran.

Code : c
   evas_object_show (object_01); // Mise à jour de l'écran


On résume !


Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *object_01; //objet que l'on vas coloriser

        if (  !ecore_evas_init ()) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 640, 480, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Ma super fenêtre Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//NOTRE OBJET QUE L'ON VAS COLORISER 
        surface_01 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas
        evas_object_color_set (object_01,17, 206, 112, 255); // couleur du rectangle
        evas_object_resize(object_01, 640, 480); // taille du rectangle
        evas_object_show (object_01); // Mise à jour de l'écran

//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt d'Evas (libération de la mémoire).

        return EXIT_SUCCESS;

 }


Résultat :

EFL Fênetre coloriser

Dessiner un deuxiéme objet à l'écran


Rien de plus simple on déclare un autre objet "object_02" :
Code : c
 Evas_Object *object_01,*object_02; //Objets que l'on vas coloriser

On lui donne une couleur :
Code : c
evas_object_color_set (object_02,255, 255, 255, 255); // couleur du rectangle

On donne un taille à notre objet (longeur, largeur)
Code : c
evas_object_resize(object_02, 220, 180); // taille du rectangle

On demmande à notre programme d'afficher notre objet :
Code : c
evas_object_show (object_02); // Mise à jour de l'écran


On résume !


Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *object_01,*object_02; ///Objets que l'on vas coloriser

        if (  !ecore_evas_init ()) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 640, 480, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Ma super fenêtre Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran



//NOTRE SURFACE_01 QUE L'ON VAS COLORISER 
        object_01 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas
        evas_object_color_set (object_01,17, 206, 112, 255); // couleur du rectangle
        evas_object_resize(object_01, 640, 480); // taille du rectangle
        evas_object_show (object_01); // Mise à jour de l'écran

//NOTRE SURFACE_02 QUE L'ON VAS COLORISER 
        object_02 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas
        evas_object_color_set (object_02,255, 255, 255, 255); // couleur du rectangle
        evas_object_resize(object_02, 220, 180); // taille du rectangle
        evas_object_show (object_02); // Mise à jour de l'écran

//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }



Résultat :

EFL Fênetre avec 2 object

Centrer l'objet à l'écran


Allez, c'est presque fini courage ^^

il suffit d'utiliser la fonction :

Code : c
evas_object_move (object_02, 25, 50); // position du réctangle dans notre fenetre


Cette fonction attend :

  • L'objet à positionner (ici, ce sera object_02,)
  • la position en x : l'abscisse
  • la position en y : l'ordonnée


Il faut savoir que le point de coordonnées (0, 0) est situé tout en haut à gauche.
En bas à droite, le point a les coordonnées (640, 480) si vous avez ouvert une fenêtre de taille 640x480 comme moi.

Aidez-vous de ce schéma pour vous situer :

EFL Fênetre coordonées

On sait afficher l'objet en haut à gauche.
Il serait aussi facile de la mettre en bas à droite. Les coordonnées seraient (640 - 220, 480 - 180), car il faut retrancher la taille de notre rectangle pour qu'il s'affiche entièrement.

Mais... comment faire pour centrer le rectangle blanc ?
Si vous réfléchissez bien 2 secondes, c'est un simple petit calcul mathématique ;)

Code : c
evas_object_move (object_02, ((640 / 2) - (220 / 2)), (480 / 2) - (180 / 2)); // position de notre objet centré dans notre fenetre 


L'abscisse du rectangle sera la moitié de la largeur de l'écran (640 / 2). Mais, en plus de ça, il faut retrancher la moitié de la largeur du rectangle (220 / 2), car sinon ça ne sera pas parfaitement centré (essayez de ne pas le faire, vous verrez ce que je veux dire smile.png )
C'est la même chose pour l'ordonnée avec la hauteur de l'écran et de ma la surface.


Résumé du code :


Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *object_01,*object_02; //objets que l'on vas coloriser

        if (  !ecore_evas_init ()) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 640, 480, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Ma super fenêtre Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//NOTRE object_01 QUE L'ON VAS COLORISER 
        object_01 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas
        evas_object_color_set (object_01,17, 206, 112, 255); // couleur du rectangle
        evas_object_resize(object_01, 640, 480); // taille du rectangle
        evas_object_show (object_01); // Mise à jour de l'écran

//NOTRE object_02 QUE L'ON VAS COLORISER 
        object_02 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas
        evas_object_color_set (object_02,255, 255, 255, 255); // couleur du rectangle
        evas_object_resize(object_02, 220, 180); // taille du rectangle
        evas_object_move (object_02, ((640 / 2) - (220 / 2)), (480 / 2) - (180 / 2)); // position de notre surface centré dans notre fenetre 
        evas_object_show (object_02); // Mise à jour de l'écran

//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }



Ce qui donnerra :


EFL Fênetre avec 1 surfaces centrée

C'est pas magique, c'est mathématique ! :D

une ligne


Rien de plus simple on vas créér un nouvelle objet :

Code : c
    Evas_Object *object_01,*object_02,*object_03; //objets que l'on vas coloriser


On vas bien sur rajouter notre objet dans notre EVAS "ecran" :

Code : c
object_03 = evas_object_line_add (ecran); // création de l'objet ligne dans l'EVAS ecran


et on créer notre ligne avec la fonction :
Code : c
evas_object_line_xy_set (object_03,0,0,640,480);

Pour définir notre droit il nous faut 2 points donc :
La fonction prendras 5 paramétres :
  • Le nom de l'objet
  • Coordonée du premier point en abscisse
  • Coordonée du premier point en ordonnée
  • Coordonée du deuxiéme point en abscisse
  • Coordonée du deuxiéme point en ordonnée


Il ne rest plus qu'a mettre àjour notre écran :

Code : c
evas_object_show (object_03); // Mise à jour de l'écran


Et voila !

                        



(Exercice) Créer un dégradé

On va finir le chapitre par un petit exercice (corrigé) suivi d'une série d'autres exercices (non corrigés pour vous forcer à bosser :\-°|:whistle: )

L'exercice corrigé n'est vraiment pas difficile : on veut créer un dégradé vertical allant du noir au blanc.
Vous allez devoir créer 255 surfaces de 1 pixel de hauteur. Chacune aura une couleur différente, de plus en plus noire.

Voici ce que vous devez arriver à obtenir au final :

Fenêtre dégradés

C'est mignon tout plein non ? ^^
Et le pire c'est qu'il suffit de quelques petites boucles pour y arriver :p


Pour faire ça, on va devoir créer 256 surfaces (256 lignes) ayant les composantes rouge-vert-bleu suivantes :

Code : c
(0, 0, 0) // Noir

(1, 1, 1) // Gris très très proche du noir

(2, 2, 2) // Gris très proche du noir

...

(128, 128, 128) // Gris moyen (à 50%)

...

(253, 253, 253) // Gris très proche du blanc

(254, 254, 254) // Gris très très proche du blanc

(255, 255, 255) // Blanc



Tout le monde devrait avoir vu venir une boucle pour faire ça (on va pas faire 256 copier/collers, faut pas abuser ! :p )

Allez au boulot, z'avez 5 minutes montre en main ! :pirate:

Correction !


On commence par créer la variable i dont on aura besoin pour nos for.

On change aussi la hauteur de la fenêtre pour qu'elle soit plus adaptée dans notre cas. On lui donne donc 256 pixels de hauteur (pour chacune des 256 lignes à afficher).

Code : c
ecran = ecore_evas_new ("software_x11", 0, 0, 640, 255, NULL); //On paramétre notre écran


On modifie notre surface pour qu'elle fasse 640 de longeur et 1 de largeur :
Code : c
evas_object_resize(surface_01, 640,1); // taille du rectangle


on créer notre boucle et on affecte i au couleur :
Code : c
//NOTRE SURFACE_01 QUE L'ON VAS COLORISER 
        for (i = 0; i <= 255;i++)
        {
                surface_01 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas
                evas_object_color_set (surface_01,i, i, i, 17); // couleur du rectangle
                evas_object_resize(surface_01, 640,1); // taille du rectangle
                evas_object_move (surface_01,  0,i); // position de notre surface centré dans notre fenetre 
                evas_object_show (surface_01); // Mise à jour de l'écran
        }


Résumé du main



Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *surface_01; //Surface que l'on vas coloriser
        int i = 0;

        
        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 640, 255, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Mon dégradé en EFL !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran


//NOTRE SURFACE_01 QUE L'ON VAS COLORISER 
        for (i = 0; i <= 255;i++)
        {
                surface_01 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas
                evas_object_color_set (surface_01,i, i, i, 17); // couleur du rectangle
                evas_object_resize(surface_01, 640,1); // taille du rectangle
                evas_object_move (surface_01,  0,i); // position de notre surface centré dans notre fenetre 
                evas_object_show (surface_01); // Mise à jour de l'écran
        }


//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).


        return EXIT_SUCCESS;

 }




Je veux des exercices pour m'entraîner !


Pas de problème, je suis un véritable générateur d'exercices ambulant :magicien:|:wizard:

  • Créez le dégradé inverse, du blanc au noir. Il vous faudra peut-être réfléchir 10 secondes avant de trouver comment faire :\-°|:whistle:
  • Vous pouvez aussi faire un double dégradé, en allant du noir au blanc comme on a fait ici puis du blanc au noir (la fenêtre fera alors le double de hauteur).
  • Guère plus difficile, vous pouvez aussi vous entraîner à faire un dégradé horizontal au lieu d'un dégradé vertical
  • Faites des dégradés en utilisant d'autres couleurs que le blanc et le noir. Essayez pour commencer du rouge au noir, du vert au noir et du bleu au noir, puis du rouge au blanc etc...
  • Essayez de faire un dégradé pour d'autres couleurs allant du rouge au vert par exemple, ou encore du jaune au vert foncé etc.




Ci-dessous un dégradé couché de soleil de la droite vers la gauche :

EFL Fênetre dégradé couché de soleil

Afficher des images

Introduction
Dans notre premier chapitre de pratique des EFL, nous avons appris à charger les EFL, ouvrir une fenêtre et gérer les surfaces.

Or, pour le moment nous n'avons appris qu'à créer des surfaces unies, c'est-à-dire ayant la même couleur. Les surfaces unies ça va un moment, mais ce serait délicat de faire un jeu avec juste des carrés de couleur :p
Dans ce chapitre, nous allons justement apprendre à charger des images dans des surfaces, les EFL ne gére pas tout les formats d'images,les formats que gére les EFL sont : png, jpeg, xpm, ppm, gif, tiff, svg et eet
dans ce chapitre nous allons utilisé les formats les plus utilisé les jpg et les png.

Charger une image JPG


Nous allons travailler avec plusieurs images dans ce chapitre. Si vous voulez faire les tests en même temps que vous lisez (et vous devriez !), je vous recommande fortement de télécharger ce pack qui contient toutes les images dont on va avoir besoin :




Placez toutes les images dans le dossier de votre projet.
Nous allons commencer par travailler avec le fichier lac_en_montagne.jpg C'est une scène 3D d'exemple livrée avec le logiciel de modélisation Vue d'Esprit (c'était à l'époque où j'espérais me découvrir un talent artistique, mais ça fait belle lurette que j'ai abandonné :p )

Déclarer un objet surface qui vas contenir notre image


Avant toute chose il faut déclarer un objet evas, qui vas contenir toute élements que l'on rajouteras dans notre fenetre.

Code : c
Evas_Object *surface_01;


Charger l'image dans un objet

On rajoute notre objet surface dans notre fenêtre :


Code : c
surface_01 = evas_object_image_add (evas);


Préciser ou ce trouve l'image :


on vas utiliser la fonction evas_object_image_file_set() :

Code : c
evas_object_image_file_set (fond, "lac_en_montagne.jpg", NULL);


Cette fonction prend trois paramétre :
  • L'object à référencer (dans notre cas surface_01 )
  • L'emplacement de l'image
  • Parametre dit clé eet, utilisé quand le fichier est un fichier edje (ou eet)


Nous verrons edje dans un autre chapitre dédié.


Récuperer la taille de l'image :


Pour ça on utilise :

Code : c
evas_object_image_size_get(surface_01, &iw, &ih); 


Cette fonction récupére toute seul la taille de l'image par le principe de déférencement/indirection :
il faut déclarer les entiers iw et ih et aprés la fonction s'ooccupe de tout.

Penser à déclarer les entiers au début de votre code :

Code : c
int iw,ih;


Donner en mémoire la taille de notre images :

Code : c
evas_object_image_size_set(surface_01, iw, ih);
evas_object_image_fill_set(surface_01, 0, 0, iw, ih);
evas_object_resize (surface_01, iw, ih);


Placer l'image sur notre fenêtres


Code : c
evas_object_move (surface_01, 0, 0);


Mise à jour de l'écran

Et bien sur la mise à jour de l'écran pour afficher notre image dans la fenêtre :
Code : c
evas_object_show (surface_01);


Résumé :


Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *surface_01; //Surface que l'on vas coloriser
        int iw,ih;

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 800, 600, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Chargement d'images en Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//Notre surface qui vas contenir l'image        
        surface_01 = evas_object_image_add (evas);
        evas_object_image_file_set (surface_01, "lac_en_montagne.jpg", NULL);
        evas_object_image_size_get(surface_01, &iw, &ih); 
        evas_object_image_size_set(surface_01, iw, ih);
        evas_object_image_fill_set(surface_01, 0, 0, iw, ih);
        evas_object_resize (surface_01, iw, ih);
        evas_object_move (surface_01, 0, 0);
        evas_object_show (surface_01);

//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }


Ce qui donnera ceci :

EFL Fênetre chargement d'images
C'est aussi simple que cela :)

Gestion de la transparence

Nous avons chargé une jolie image jpg tout à l'heure dans notre fenêtre.
Supposons que l'on veuille ajouter une image par-dessus. Ca vous arrivera très fréquemment, car dans un jeu en général le personnage que l'on déplace est un jpg, et il se déplace sur une image de fond.

On va afficher l'image de Zozor sur la scène :

Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *surface_01,*surface_02; //Surface que l'on vas coloriser
        int iw,ih;

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 800, 600, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Chargement d'images en Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//Notre surface qui vas contenir l'image        
        surface_01 = evas_object_image_add (evas);
        evas_object_image_file_set (surface_01, "lac_en_montagne.jpg", NULL);
        evas_object_image_size_get(surface_01, &iw, &ih); 
        evas_object_image_size_set(surface_01, iw, ih);
        evas_object_image_fill_set(surface_01, 0, 0, iw, ih);
        evas_object_resize (surface_01, iw, ih);
        evas_object_move (surface_01, 0, 0);
        evas_object_show (surface_01);

//Notre surface qui vas contenir zozor
        surface_02 = evas_object_image_add (evas);
        evas_object_image_file_set (surface_02, "zozor1.png", NULL);
        evas_object_image_size_get(surface_02, &iw, &ih); 
        evas_object_image_size_set(surface_02, iw, ih);
        evas_object_image_fill_set(surface_02, 0, 0, iw, ih);
        evas_object_resize (surface_02, iw, ih);
        evas_object_move (surface_02, 500, 260);
        evas_object_show (surface_02);

//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }



On a juste rajouté une surface pour y stocker Zozor, que l'on ajoute ensuite à un endroit sur la scène.
Le résultat est le suivant :

EFL Fênetre chargement d'images transparentes

C'est moche hein ? :D

Bah oui, c'est parce que t'as mis un fond bleu tout moche sur l'image de Zozor !


Parce que vous croyez qu'avec un fond noir ou un fond marron derrière Zozor ça aurait été plus joli ? :\-°|:whistle:
Ben non, le problème ici c'est que notre image est forcément rectangulaire, donc si on la colle sur la scène on voit son fond et ça fait moche.

Heureusement, les EFL gère la transparence !

Rendre une image transparente

La on a pas trops le choix, à vous de vous débrouiller avec votre logiciel de dessin (Gimp ...) pour donner un fond transparent à votre image et de la sauvegarder en png, pour garder la transparence!

j'ai fait la manip pour vous ;\) un beau zozor, transparent !

Remplacer dans le code : zozor1.png par zozor_transparent.png

Relencer le programme et vous verrez ceci :

EFL Fênetre chargement d'images transparentes

Ca, c'est LA technique de base que vous réutiliserez tout le temps dans vos futurs programmes. Apprenez à bien manier la transparence car c'est fondamental si on veut avoir un jeu un minimum réaliste ^^

La transparence Alpha


Pour avoir son image transparente dans une application EFL, il faut utilisé la commande :

Code : c

evas_object_color_set (o, 255, 255, 255, 255);


J'ai déja expliquer comment sa s'utilise pour colorer un objet, mais la on vas l'utiliser pour faire de la transparence et pour sa, il faut indiquer les 3 mêmes valeurs afin de recréer cette transparence :

voila un tableau qui montre comment sa marche :
Alpha Code Aperçu
255 entièrement opaque evas_object_color_set (o, 255, 255, 255, 255);
190 evas_object_color_set (o, 190, 190, 190, 190);
128 le juste milieu evas_object_color_set (o, 128, 128, 128, 128);
75 evas_object_color_set (o, 75, 75, 75, 75);
0 entièrement transparente evas_object_color_set (o, 0, 0, 0, 0);



Voila pour les deux types de transparence.



Charger plus de formats d'image

Il n'y a pas pour le moment d'autre moyen, d'afficher les autre formats d'image à par ce sité que je rappel :

evas_object_image_file_set(), permet de lire les fichiers png, jpeg, xpm, ppm, gif, tiff, svg et eet
qui se fait de maniere transparente et depend des loaders qui ont ete compiles quand ont compile evas.

Conclusion


Vous êtes maintenant capables d'afficher certains type d'images dans vos programmes EFL, et, surtout, de rendre ces images transparentes.
Avec ces fonctions pourtant très simples des EFL, vous allez pouvoir réaliser à peu près tous les programmes que vous voulez.

Mais avant ça, il va falloir étudier un chapitre très important des EFL : les évènements. Cela vous permettra de gérer le clavier, la souris, rien de moins que ça ! :\)
Au lieu d'avoir un programme "passif" comme maintenant où vous vous contentez de regarder votre fenêtre, vous allez pouvoir contrôler un personnage au clavier, cliquer dans la fenêtre etc. :D

La gestion des évènements

La gestion des évènements est une des fonctionnalités les plus importantes des EFL.
C'est à partir de là que vous allez vraiment être capables de tout faire.

Concrètement, qu'est-ce que c'est ?

Par exemple, quand l'utilisateur appuie sur une touche du clavier, on dit qu'il s'est produit un évènement. Mais ce n'est pas tout ! Il existe bien d'autres types d'évènements :
Clavier_souris
  • Quand l'utilisateur clique avec la souris
  • Quand il bouge la souris
  • Quand il réduit la fenêtre
  • Quand il demande à fermer la fenêtre etc

Tout ça, ce sont des évènements. Ce sont des "signaux" envoyés à votre programme pour l'informer qu'il s'est passé quelque chose.

Le rôle de ce chapitre sera de vous apprendre à traiter ces évènements. Vous serez capables de dire à l'ordinateur "Si l'utilisateur clique à cet endroit, fais ça, sinon fais cela... S'il bouge la souris, fais ceci. S'il appuie sur la touche Q, arrête le programme..." etc.

Nous ne traiterons ici que les évènements du clavier et de la souris.
D'autres évènements un peu plus complexes, comme ceux générés par le joystick,ne sont malheuresement pas gére pas les EFL, mais il éxiste d'autre technique pour y remedier, on verras ça un peux plus tard.

Le principe des évènements

Pour nous habituer aux évènements, nous allons apprendre à traiter le plus simple d'entre eux : la demande de fermeture du programme.
C'est un évènement qui se produit lorsque l'utilisateur clique sur la croix pour fermer la fenêtre Bouton fermeture Enlighenment

Nous allons écrire une fonction que permettras la fermeture du programme lorsqu'on appuie sur une touche qu'on défini.

La variable d'évènement


Pour traiter des évènements, vous aurez besoin de déclarer une variable (juste une seule rassurez-vous) de type Evas_Event_Key_Down.
Appelez-la comme vous voulez, moi je vais l'appeler "event" (ce qui signifie "évènement" en anglais).

Code : c
Evas_Event_Key_Down *event;


Nous allons nous contenter pour nos tests d'un main très basique qui affiche juste une fenêtre, contenant un objet comme fond d'écran, c'est sur cette objet que nous allons réaliser l'evenement, comme on l'a vu il y a quelques chapitres.
Avant d'utiliser cette variable d'événement préparon notre cod :

Commençant par un main de base qui reprend l'image de toute à l'heure (comme fond), notre départ :

Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *surface_01; //Surface que l'on vas coloriser
        int iw,ih;

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 800, 600, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Chargement d'images en Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//Notre surface qui vas contenir l'image        
        surface_01 = evas_object_image_add (evas);
        evas_object_image_file_set (surface_01, "lac_en_montagne.jpg", NULL);
        evas_object_image_size_get(surface_01, &iw, &ih); 
        evas_object_image_size_set(surface_01, iw, ih);
        evas_object_image_fill_set(surface_01, 0, 0, iw, ih);
        evas_object_resize (surface_01, iw, ih);
        evas_object_move (surface_01, 0, 0);
        evas_object_show (surface_01);


//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }


C'est donc un code très basique, il contient deux choses : un objet "surface_01" qui contient notre fond d'écran et la déclaration de la variable event dont nous allons bientôt nous servir.
Voile le code de base opérationnel !

La boucle des évènements

Lorsqu'on veut attendre un évènement, on fait généralement une boucle. Cette boucle se répètera tant qu'on n'a pas eu l'évènement voulu.

cette boucle c'est cette fonction qui le fait :
Code : c
ecore_main_loop_begin();


j'ai déja parlé de cette boucle, mais je vais me répetter sa fait pas de mal :

Cette fonction empêche notre programme de s'arrêter, de plus, la fonction teste tous les evenements specifiques au systeme graphique (souris, clavier, gestion des fenetres, etc...) et durant laquelle sont geres les timer ( on verras sa plus en détaille, dans les prochains chapitres)

Récupération de l'évènement

Pour récupérer l'événement on vas s'y prend en trois fois étapes , on utilise d'abord cette fonction :

1 / Le Focus


Code : c
evas_object_focus_set(surface_01 , 1);


Cette fonction est trés importante car c'est elle qui vas définir l'objet qui détiens le focus, c'est à dire l'objet qui détient détient toute l'attention de la boucle évenement.

2 / Objet sur l'esquelle on vas appliquer des changements


On utilise cette fonction :
Code : c
evas_object_event_callback_add(surface_01, EVAS_CALLBACK_KEY_DOWN, key_down, NULL);

Cette fonction prend en paramétre :
  • surface_01 : L'objet sur lequelle, l'événement est attendu, et donc dans notre cas une surface qui vas subir un déplacement)
  • EVAS_CALLBACK_KEY_DOWN :
  • key_down : une fonction que l'on vas créer et qui vas nous permettre d'initiliaser un évenement
  • NULL : correspond à des données qu' on passe à la fonction, il s'agira du premier paramètre (void *data)


On noteras quelque chose d'important on ne peux pas avoir le focus sur deux objets en même tps!!


Dans la fonction on utilise donc l'objet surface_01, sur lequelles on vas exécuter la fonction key_down(), dans notre cas.
Et à chaque fois qu'un événement qui est défini dans le fichier Evas.h (on verras ce fichier extrémement important plus en détails), la fonction s'exécuteras.


et derniére étape la fonction key_down :

Code : c
void key_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
    Evas_Event_Key_Down *event;
    event = (Evas_Event_Key_Down *)event_info;// récupération de l'évenement dans un event passé en paramétre (event_info)
}


Analyse de l'évènement


Maintenant, nous possédons une variable event qui contient des informations sur l'évènement qui s'est produit.
Il faut regarder la sous-variable event->keyname et faire un test sur sa valeur.

Mais comment on sait quelle valeur correspond à l'évènement "Quitter" par exemple ?


Il suffit de le créer dans notre fonction key_down()
Code : c

void key_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
    Evas_Event_Key_Down *event;

    event = (Evas_Event_Key_Down *)event_info; 
    if ( /* Test */)  ecore_main_loop_quit();
}



Cette fonction key_down récupére un événements,
qui seras annalyser par notre test conditionel if
On utilise la fonction ecore_main_loop_quit() qui fermeras le programme dans les régles de l'art des EFL.

Résumé du code :

Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

void key_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
        Evas_Event_Key_Down *event;
        event = (Evas_Event_Key_Down *)event_info;// récupération de l'évenement dans un event passé en paramétre (event_info)
        if ( /* Test */ )  ecore_main_loop_quit();// annalyse de l'évenement
        
}


int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *surface_01; //Surface que l'on vas coloriser
        Evas_Event_Key_Down *event;// Cette variable servira à gérer les évènements 
        int iw,ih;

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 800, 600, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Chargement d'images en Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//Notre surface qui vas contenir l'image        
        surface_01 = evas_object_image_add (evas);
        evas_object_image_file_set (surface_01, "lac_en_montagne.jpg", NULL);
        evas_object_image_size_get(surface_01, &iw, &ih); 
        evas_object_image_size_set(surface_01, iw, ih);
        evas_object_image_fill_set(surface_01, 0, 0, iw, ih);
        evas_object_resize (surface_01, iw, ih);
        evas_object_move (surface_01, 0, 0);
        evas_object_show (surface_01);

        evas_object_focus_set(surface_01 , 1);
        evas_object_event_callback_add(surface_01, EVAS_CALLBACK_KEY_DOWN, key_down, NULL);



//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }



Pas la peinde compiler ça ne feras rien, car nous n'avons rien demandé dans notre test conditionnel de la fonction key_down(), il nous faut dabord étudier la partie suivante le clavier.

Le clavier

Nous allons maintenant étudier les évènements produits par le clavier.

Si vous avez compris le début du chapitre, vous n'aurez AUCUN problème pour traiter les autres types d'évènements. C'est tellement facile qu'on en pleurerait presque.

Pourquoi est-ce si simple ? Tout ce que vous allez avoir à faire c'est rajouter d'autres "condition" dans le "if" pour traiter d'autres types d'évènements.

Les évènements du clavier


Il existe 2 évènements différents qui peuvent être générés par le clavier :

  • EVAS_CALLBACK_KEY_DOWN : quand une touche du clavier est enfoncée
  • EVAS_CALLBACK_KEY_UP : quand une touche du clavier est relâchée


Pourquoi y a-t-il ses 2 évènements ?


Parce que quand vous appuyez sur une touche, en fait il se passe 2 choses : vous enfoncez la touche (EVAS_CALLBACK_KEY_DOWN), puis vous la relâchez (EVAS_CALLBACK_KEY_UP). Les EFL vous permet de traiter ces 2 évènements, ce qui sera bien pratique vous verrez.

Pour le moment, nous allons nous contenter de traiter l'évènement EVAS_CALLBACK_KEY_DOWN (appui de la touche) :

Code : c
void key_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
    Evas_Event_Key_Down *event;

    event = (Evas_Event_Key_Down *)event_info;
    if ( event->keyname )  ecore_main_loop_quit();
}


Si on appuie sur une touche, le programme s'arrêtera :)
Testez, vous verrez ;\)

Récupérer la touche


Savoir qu'une touche a été enfoncée c'est bien, mais savoir laquelle, c'est quand même mieux, pour savoir ce qu'il ce passe lors d'appuie sur une touche ou vas tester ce code :

Code : c
 printf("touche préssé: %s\n", event->keyname);


vous voulez peut être le code complet allé :

Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

void key_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
        Evas_Event_Key_Down *event;

        event = (Evas_Event_Key_Down *)event_info;// récupération de l'évenement dans un event passé en paramétre (event_info)
        printf("touche préssé: %s\n", event->keyname);// Affiche la touche préssé
        if ( event->keyname )  ecore_main_loop_quit();// annalyse de l'évenement

}



int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *surface_01; //Surface que l'on vas coloriser
        Evas_Event_Key_Down *event;// Cette variable servira à gérer les évènements 
        int iw,ih;

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 800, 600, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Chargement d'images en Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//Notre surface qui vas contenir l'image        
        surface_01 = evas_object_image_add (evas);
        evas_object_image_file_set (surface_01, "lac_en_montagne.jpg", NULL);
        evas_object_image_size_get(surface_01, &iw, &ih); 
        evas_object_image_size_set(surface_01, iw, ih);
        evas_object_image_fill_set(surface_01, 0, 0, iw, ih);
        evas_object_resize (surface_01, iw, ih);
        evas_object_move (surface_01, 0, 0);
        evas_object_show (surface_01);

        evas_object_focus_set(surface_01 , 1);
        evas_object_event_callback_add(surface_01, EVAS_CALLBACK_KEY_DOWN, key_down, NULL);



//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }


Si vous avez testé ce code, vous aurrez surrement, remarquer que sur la console on vois ce qui est stocker dans event->keyname!!

et vous verrer que chaque touche porte son nom.

donc voila le code pour quitter l'application en appuyant sur la touche echap :

Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

void key_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
        Evas_Event_Key_Down *event;

        event = (Evas_Event_Key_Down *)event_info;// récupération de l'évenement dans un event passé en paramétre (event_info)
        printf("touche préssé: %s\n", event->keyname);// Affiche la touche préssé
        if ( !strcmp(event->keyname, "Escape")  )  ecore_main_loop_quit();// annalyse de l'évenement, si la touche esc est préssé le programme s'arrete
}



int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *surface_01; //Surface que l'on vas coloriser
        Evas_Event_Key_Down *event;// Cette variable servira à gérer les évènements 
        int iw,ih;

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 800, 600, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Chargement d'images en Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//Notre surface qui vas contenir l'image        
        surface_01 = evas_object_image_add (evas);
        evas_object_image_file_set (surface_01, "lac_en_montagne.jpg", NULL);
        evas_object_image_size_get(surface_01, &iw, &ih); 
        evas_object_image_size_set(surface_01, iw, ih);
        evas_object_image_fill_set(surface_01, 0, 0, iw, ih);
        evas_object_resize (surface_01, iw, ih);
        evas_object_move (surface_01, 0, 0);
        evas_object_show (surface_01);

        evas_object_focus_set(surface_01 , 1);
        evas_object_event_callback_add(surface_01, EVAS_CALLBACK_KEY_DOWN, key_down, NULL);



//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }



Récupérer la taille de notre surface


Nous allons déclarer Evas_Coord

Code : c
Evas_Coord dx, dy;

Ce qui vas nous permettre de récupérer l'emplacement de notre surface pour pouvoir la déplacer par la suite, pour récupérer la position en X et Y nous utiliserons cette fonction, qui affecteras à dx et dy les positions actuel de l'objet.


Code : c
evas_object_geometry_get(copie_surface, &dx, &dy, NULL, NULL);// récupération des coordonnées de la surface


Déplacer notre surface

Il suffit d'utiliser cette fonction que nous acons utilisé précedemment et d'ajouter ou soustraire une valeur suivant qu'on veut déplacer notre surface sur X ou Y

Code : c
evas_object_move (copie_surface, dx-10, dy); // déplacement de la surface

(Exercice) Diriger Zozor au clavier

Vous êtes maintenant capables de déplacer une image dans la fenêtre à l'aide du clavier !

De plus, ce que je vais vous apprendre là est le plus interressant, car je pense que c'est la base de tous les jeux fait en EFL, donc ça vaut doublement le coup d'être très attentif

Charger l'image


Pour commencer, nous allons créer notre fond blanc, puis y afficher notre zozor !
On va faire simple : on vas créer 2 surfaces, une pour le fond blanc et l'autre pour le zozor.

Créez donc la surface surface_01 et zozor puis chargez l'image.

Code : c
        Evas_Object *surface_01,*zozor; //Surface que l'on vas coloriser
...


EFL Dirigée  Zozor

On vas positionner Zozor au milieu de l'écran :

Code : c
evas_object_move (surface_02, (800/2)-(iw/2), (600/2)-(ih/2));// Positionne notre Zozor au milieu de l'écran !


Si vous vous êtes bien débrouillés, vous devriez être arrivés à afficher Zozor au centre de l'écran :

EFL Dirigée  Zozor


Traiter l'évènement key_down


Evas_Coord dx, dy;
..
if ( !strcmp(event->keyname, "Left") )
{
evas_object_geometry_get(copie_surface, &dx, &dy, NULL, NULL);// récupération des coordonnées de la surface
evas_object_move (copie_surface, dx-10, dy); // déplacement de la surface
printf("Position Gauche : (%d,%d) \n",dx,dy);
}




Résumé du code :


Ce code permettras de déplacer notre image zozor_transparent.png, sur un fond blanc, dans les sens, haut, bas gauche et droite, par pas de 10.

Code : c

#include <Ecore.h>
#include <Ecore_Evas.h>

void key_down(void *data, Evas *e, Evas_Object *copie_surface, void *event_info)
{
    Evas_Coord dx, dy;
    Evas_Event_Key_Down *event;/* Cette variable servira plus tard à gérer les évènements */

    event = (Evas_Event_Key_Down *)event_info;

        if ( !strcmp(event->keyname, "Escape")  )  
        {
                printf("touche préssé: %s\n", event->keyname);// Affiche la touche préssé
                printf("Au revoir !\n");
                ecore_main_loop_quit();// annalyse de l'évenement, si la touche esc est préssé le programme s'arrete
        }
    else if ( !strcmp(event->keyname, "Left") )
    {
        evas_object_geometry_get(copie_surface, &dx, &dy, NULL, NULL);// récupération des coordonnées de la surface
        evas_object_move (copie_surface, dx-10, dy); // déplacement de la surface
        printf("Position Gauche : (%d,%d) \n",dx,dy);
    }
    else if (!strcmp(event->keyname, "Right"))
    {
        evas_object_geometry_get(copie_surface, &dx, &dy, NULL, NULL);// récupération des coordonnées de la surface
        evas_object_move (copie_surface, dx+10, dy);// déplacement de la surface
        printf("Position Droite : (%d,%d) \n",dx,dy);

    }
    else if (!strcmp(event->keyname, "Up"))
    {
        evas_object_geometry_get(copie_surface, &dx, &dy, NULL, NULL);// récupération des coordonnées de la surface
        evas_object_move (copie_surface, dx, dy-10); // déplacement de la surface
             printf("Position Haut : (%d,%d) \n",dx,dy);
    }
    else if (!strcmp(event->keyname, "Down"))
    {
        evas_object_geometry_get(copie_surface, &dx, &dy, NULL, NULL);// récupération des coordonnées de la surface
        evas_object_move (copie_surface, dx, dy+10); // déplacement de la surface
        printf("Position Bas : (%d,%d) \n",dx,dy);
    }
}


int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *surface_01,*surface_02; //Surface que l'on vas coloriser
        int iw,ih;

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 800, 600, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Gestion des évènements en Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//Notre surface qui vas contenir l'image        
        surface_01 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas
        evas_object_color_set (surface_01,255, 255, 255, 255); // couleur du rectangle
        evas_object_resize(surface_01, 800, 600); // taille du rectangle
        evas_object_show (surface_01); // Mise à jour de l'écran

//Notre surface qui vas contenir zozor
        surface_02 = evas_object_image_add (evas);
        evas_object_image_file_set (surface_02, "zozor_transparent.png", NULL);
        evas_object_image_size_get(surface_02, &iw, &ih); 
        evas_object_image_size_set(surface_02, iw, ih);
        evas_object_image_fill_set(surface_02, 0, 0, iw, ih);
        evas_object_resize (surface_02, iw, ih);
        evas_object_move (surface_02, 500, 260);
        evas_object_show (surface_02);

        evas_object_focus_set(surface_02 , 1);
        evas_object_event_callback_add(surface_02, EVAS_CALLBACK_KEY_DOWN, key_down, NULL);

//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }



On peut donc déplacer Zozor où l'on veut sur l'écran maintenant !

EFL Dirigée  Zozor

La souris

Après le clavier, attaquons maintenant la souris ! :D

Vous vous dites peut-être que gérer la souris est plus compliqué que le clavier ?
Que nenni ! C'est même plus simple, vous allez voir ^^

La souris peut générer plusieurs types d'évènements différents, nous allon svoir les 3 principaux :

  • EVAS_CALLBACK_MOUSE_DOWN : lorsqu'on clique avec la souris. Cela correspond au moment où le bouton de la souris est enfoncé.
  • EVAS_CALLBACK_MOUSE_UP : lorsqu'on relâche le bouton de la souris. Tout cela fonctionne exactement sur le même principe que les touches du clavier, il y a d'abord un appui, puis un relâchement du bouton.
  • EVAS_CALLBACK_MOUSE_MOVE, : lorsqu'on déplace la souris. A chaque fois que la souris bouge dans la fenêtre (ne serait-ce que d'un pixel !)


Pour voir les autres evenements géré on peut allé voir ici --> Data Structures d'EVAS

Nous allons d'abord travailler avec les clics de la souris et plus particulièrement avec EVAS_CALLBACK_MOUSE_UP. On ne travaillera pas avec EVAS_CALLBACK_MOUSE_DOWN ici, mais vous savez de toute manière que c'est exactement pareil sauf que cela se produit plus tôt, au moment de l'enfoncement du bouton de la souris.
Nous verrons un peu plus loin comment traiter l'évènement EVAS_CALLBACK_MOUSE_MOVE

Gérer les clics de la souris


Nous allons donc capturer un évènement de type EVAS_CALLBACK_MOUSE_UP (clic de la souris) puis voir quelles informations on peut récupérer.
Alors allons-y gaiement :

Code : c
void cb_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
        Evas_Event_Mouse_Down *event; // déclaration d'un évenement
        event = (Evas_Event_Mouse_Up *)event_info; //initialisation de la variable sur l'évenemnt produit par la souris
}



et pensé à changer dans notre main l'evénement callback :
Code : c
  evas_object_event_callback_add(surface_01, EVAS_CALLBACK_MOUSE_UP, cb_down, NULL);


Quelles informations peut-on récupérer lors d'un clic de la souris ? Il y en a 2 :

  • Le bouton de la souris avec lequel on a cliqué (clic gauche ? clic droit ? clic bouton du milieu ?)
  • Les coordonnées de la souris au moment du clic (x et y)


Récupérer les coordonnées de la souris


On va d'abord voir avec quel bouton de la souris on a cliqué.
Pour cela, il faut analyser la sous-variable event->button et voir à qu'elle valeur du bouton de la souris il correspond :

  • 1 : clic avec le bouton gauche de la souris.
  • 2 : clic avec le bouton du milieu de la souris (tout le monde n'en a pas forcément un).
  • 3 : clic avec le bouton droit de la souris.


Il peut avoir d'autre valeur, suivant le nbr de bouton que vous avez sur votre souris


On va faire un test simple pour vérifier si on a fait un clic droit avec la souris. Si on a fait un clic droit, on arrête le programme (oui je sais c'est pas très original pour le moment mais ça permet de tester \^\^ ) :


Code : c
void cb_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
        Evas_Event_Mouse_Down *event; // déclaration d'un évenement
        event = (Evas_Event_Mouse_Up *)event_info; //initialisation de la variable sur l'évenemnt produit par la souris
       
        if(event->button == 3) // si on appuye sur le clique droit 
         ecore_main_loop_quit(); // on stop le programme
}


Vous pouvez tester, vous verrez que le programme s'arrête si on fait un clic droit :)

Récupérer les coordonnées de la souris


Voilà une information très intéressante : les coordonnées de la souris au moment du clic !
On les récupère à l'aide de 2 variables (pour l'abscisse et l'ordonnée) : event->output.x et event->output.y

Amusons-nous un petit peu : on va afficher Zozor à l'endroit du clic de la souris.

EFL gestion evenement Zozor

Voici la correction :

Spoiler (cliquez pour afficher)

Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

Evas_Object * zozor (Evas *evas,int move1,int move2)
{

Evas_Object *o;
int iw, ih;
o = evas_object_image_add (evas);
evas_object_image_file_set (o, "zozor_transparent.png", NULL);
evas_object_image_size_get(o, &iw, &ih);
evas_object_image_size_set(o, iw, ih);
evas_object_image_fill_set(o, 0, 0, iw, ih);
evas_object_resize (o, iw, ih);
evas_object_move (o, move1, move2);
evas_object_show (o);
return o;
}

void cb_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
{
        Evas_Event_Mouse_Up *event; // déclaration d'un évenement
        event = (Evas_Event_Mouse_Up *)event_info; //initialisation de la variable sur l'évenemnt produit par la souris
        printf("touche pressée: %d en coordonnée (%d,%d)\n", event->button,event->output.x,event->output.y);// Affiche la touche préssé
        
        if(event->button == 2)// si clique sur le bouton 2 (bouton milieu souris)
         ecore_main_loop_quit(); //on quitte le programme
        else if(event->button == 1)// si on clque sur le bouton 1
         zozor (e, event->output.x, event->output.y);// affiche un nouveau Zozor à l'applacemet du clique
}

int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objet
        Evas_Object *surface_01; //Surface que l'on vas coloriser
       int iw,ih;

        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 800, 600, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Chargement d'images en Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//Notre surface qui vas contenir l'image        
        surface_01 = evas_object_image_add (evas);
        evas_object_image_file_set (surface_01, "lac_en_montagne.jpg", NULL);
        evas_object_image_size_get(surface_01, &iw, &ih); 
        evas_object_image_size_set(surface_01, iw, ih);
        evas_object_image_fill_set(surface_01, 0, 0, iw, ih);
        evas_object_resize (surface_01, iw, ih);
        evas_object_move (surface_01, 0, 0);
        evas_object_show (surface_01);       

        evas_object_focus_set(surface_01 , 1);
        evas_object_event_callback_add(surface_01, EVAS_CALLBACK_MOUSE_UP, cb_down, NULL);

//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }


Conclusion


Il faut un peu de temps avant de se faire à la gestion des évènements. Passez donc le temps qu'il faudra pour être à l'aise, surtout avec la boucle de traitement des évènements.

Quelques exercices

Avant de vous laisser, voici quelques idées d'exercices que je vous recommande de faire pour vous entraîner :

Changement de la couleur de fond


Faites un programme ouvrant une fenêtre initialement noire.
Si on appuie sur la flèche "haut" du clavier, le fond doit se blanchir progressivement : couleur 1, 1, 1, puis couleur 2, 2, 2, jusqu'à la couleur 255, 255, 255 (le blanc).
La flèche "bas" du clavier, elle, doit noircir l'écran.

Attention : faites un test pour vérifier qu'on ne dépasse pas 255 et un autre pour vérifier si on ne va pas en-dessous de 0 ! Pour info, la couleur 300, 300, 300 n'existe pas heureux.png


Traînée de Zozor


Faites un programme dans lequel 3 Zozors suivent la souris. Placez le premier à la position de la souris (comme on l'a fait dans le cours), puis le second 20 pixels en bas à droite, le troisième encore 20 pixels en bas à droite.


Le tampon Zozor


Faites en sorte que lorsqu'on clique avec la souris sur l'écran, ça colle un Zozor à l'endroit indiqué.
Oui je sais, on l'a déjà fait pour étudier l'évènement "clic de la souris", mais cette fois je veux que l'on puisse "coller" à l'écran 10 Zozors maximum à la fois (alors qu'auparavant on ne pouvait en coller qu'un seul à la fois).

La touche "Suppr" doit servir à effacer l'écran (il faudra réinitialiser toutes les coordonnées à (-1, -1) par exemple).

Si vous arrivez à faire tout ça, vous pouvez aller plus loin en faisant un "jeu de tampons" : on sélectionnera un tampon différent en appuyant sur une touche numérique (0 à 9) qu'on pourra ensuite coller à l'écran en cliquant avec la souris. On peut faire un mini-Paint pour les enfants, à condition d'avoir créé des tampons intéressants (vous avez déjà un Zozor, à vous d'imaginer d'autres éléments comme un sapin, un soleil, un nuage )



Allez au boulot les programmeurs en herbe

Que va-t-on faire maintenant ?



Si vous êtes un peu imaginatifs, vous devriez maintenant être capables de réaliser de véritables jeux en EFL ! Vous savez en effet pratiquement tout ce qu'il faut savoir sur le clavier et la souris et vous pouvez donc faire dès à présent un grand nombre de jeux intéressants.
Dans peu de temps nous ferons un TP pour rassembler tout ce qu'on a appris sur les EFL afin de créer un premier jeu (et un jeu sérieux attention)

Bien entendu, il vous reste encore pas mal de choses à découvrir dans les EFL, comme rajouter la gestion du joystick, l'écriture de texte à l'écran, rajouter la gestion du son etc... Tout vient à point à qui sait attendre dit-on


Vu qu'il y a beaucoup de fonctions à retenir, je vous conseille vraiment de ne pas aller trop vite sinon vous ne retiendrez rien. "Ne mettez pas la charrue avant les boeufs" : commencez par faire des choses simples, puis compliquez-les au fur et à mesure. Ne commencez pas par quelque chose de compliqué dès le début, sinon c'est le ramassage de dents assuré !

Maîtrisez le temps !

Chapter intro
Chapter conclu
Part conclu

Edje

Part intro
Part conclu

Annexes

Dans cette Partie je présente des exemples de codes, qui correspondent aux exercice non corrigé du cours !

Exemple : La gestion des évènements

Changement de la couleur de fond



Citation :
Faites un programme ouvrant une fenêtre initialement noire.
Si on appuie sur la flèche "haut" du clavier, le fond doit se blanchir progressivement : couleur 1, 1, 1, puis couleur 2, 2, 2, jusqu'à la couleur 255, 255, 255 (le blanc).
La flèche "bas" du clavier, elle, doit noircir l'écran.


J'ai essayé de commenter au maximum le code afin de comprendre à quoi corresponde, les lignes de code.


Faites un test pour vérifier qu'on ne dépasse pas 255 et un autre pour vérifier si on ne va pas en-dessous de 0 ! Pour info, la couleur 300, 300, 300 n'existe pas


Voila le code que j'ai fais :
Code : c
#include <Ecore.h>
#include <Ecore_Evas.h>

void key_down(void *data, Evas *e, Evas_Object *copie_surface, void *event_info)
{
    int colorRed, colorGreen, colorBleue,alpha;//Variable pour la récperation des valeurs couleurs
    Evas_Event_Key_Down *event;/* Cette variable servira plus tard à gérer les évènements */

    event = (Evas_Event_Key_Down *)event_info; // Récupération de l'évenement clavier : "quand une touche du clavier est enfoncée"

        if ( !strcmp(event->keyname, "Escape")  )  
        {
                printf("touche préssé: %s\n", event->keyname);// Affiche la touche préssé
                printf("Au revoir !\n");
                ecore_main_loop_quit();// annalyse de l'évenement, si la touche esc est préssé le programme s'arrete
        }
        else if ( !strcmp(event->keyname, "Up") )
        {
                evas_object_color_get (copie_surface,&colorRed, &colorGreen, &colorBleue, &alpha); // Récupére les valeur actuel de la surface
                if(colorRed <255)
                {
                        evas_object_color_set (copie_surface,colorRed+1, colorGreen+1, colorBleue+1, alpha); // applique les nouvelles couleurs du rectangle
                        printf("Valeur couleur Up (Rouge, Vert, Bleu, Alpha) : (%d,%d,%d,%d) \n",colorRed, colorGreen, colorBleue,alpha);
                } else printf("Attention  Vous êtes arrivé ! à la limite 255\n"); 
        }
        else if (!strcmp(event->keyname, "Down"))
        {
                evas_object_color_get (copie_surface,&colorRed, &colorGreen, &colorBleue, &alpha); // Récupére les valeur actuel de la surface
                if(colorRed >0)
                {
                        evas_object_color_set (copie_surface,colorRed-1, colorGreen-1, colorBleue-1, alpha);  // applique les nouvelles couleurs du rectangle
                        printf("Valeur couleur Up (Rouge, Vert, Bleu, Alpha) : (%d,%d,%d,%d) \n",colorRed, colorGreen, colorBleue,alpha);
                } else printf("Attention  Vous êtes arrivé ! à la limite 0\n"); 
        }
        
}



int
main (int argc, char *argv[])
{
        Ecore_Evas  *ecran;//Déclaration de variable ecran, qui vas contenir nos images et autres ...
        Evas        *evas; //Conteneur d'objets
        Evas_Object *surface_01; //Surface que l'on vas coloriser


        if (  ecore_evas_init () == -1) // Démarrage des EFL. Si erreur alors...
                {
                        printf( "Erreur d'initialisation des EFL "); // Ecriture de l'erreur
                        exit(EXIT_FAILURE); // On quitte le programme
                }

//NOTRE FENETRE VIDE
        ecran = ecore_evas_new ("software_x11", 0, 0, 800, 600, NULL); //On paramétre notre écran
        if (!ecran) // si probléme sur le driveur pour les EFL
        {
                ecore_evas_shutdown (); // Arrêt des EFL
                return EXIT_FAILURE; // On quitte le programme
        }
        ecore_evas_title_set(ecran, "Gestion des évènements en Enlightenment !");
        ecore_evas_show (ecran);// On affiche notre écran
        evas = ecore_evas_get (ecran);// conteneur qui prend notre écran

//Notre surface qui est une surface noir
        surface_01 = evas_object_rectangle_add (evas); // création de l'objet rectangle dans l'evas
        evas_object_color_set (surface_01,0, 0, 0, 255); // couleur du rectangle
        evas_object_resize(surface_01, 800, 600); // taille du rectangle
        evas_object_show (surface_01); // Mise à jour de l'écran


//Focus et récupération des evenement clavier
        evas_object_focus_set(surface_01 , 1);// on met le focus de l'évenement sur la surface désiré
        evas_object_event_callback_add(surface_01, EVAS_CALLBACK_KEY_DOWN, key_down, NULL);// fonction de l'évenement

//Fin du programme
        ecore_main_loop_begin();//notre boocle qui attend l'appuie sur la croix pour terminer le programme
        ecore_evas_shutdown ();  // Arrêt des EFL (libération de la mémoire).

        return EXIT_SUCCESS;
 }